Dieser Leitfaden erläutert häufige Python-Syntaxfehler, welche proaktiven Strategien Sie einsetzen können, um sie zu vermeiden, und welche reaktiven Methoden Sie verwenden können, um sie effizient zu beheben:
Der Python Interpreter führt Python-Code aus und übersetzt ihn in Maschinensprache. Wenn Syntaxregeln verletzt werden, stoppt die Ausführung, und eine Fehlermeldung mit einem Traceback wird angezeigt.
Syntaxfehler entstehen durch strukturelle Fehler, ähnlich wie grammatikalische Fehler in einer Sprache. Zum Beispiel erfordert Python korrekte Einrückung für Blöcke wie if-Anweisungen und Schleifen.
Im Gegensatz zu runtime errors, die während der Programmausführung auftreten, verhindern Syntaxfehler die Ausführung vollständig.
Python folgt vielen syntax rules, weshalb Syntaxfehler häufig sind. In diesem Abschnitt werden mehrere häufige Fehler und ihre Lösungen erläutert.
Python verwendet Satzzeichen, um Code zu strukturieren. Stellen Sie sicher, dass diese korrekt platziert und richtig paarweise verwendet werden, um Syntaxfehler zu vermeiden.
Zum Beispiel müssen runde Klammern (), eckige Klammern [] und geschweifte Klammern {} immer paarweise verwendet werden. Wenn Sie eine öffnen, müssen Sie sie schließen.
Im folgenden Beispiel bleibt eine geschweifte Klammer ungeschlossen:
# Incorrect
proxies = {
'http': proxy_url,
'https': proxy_urlWenn Sie dies auszuführen versuchen, wirft der Interpreter einen SyntaxError:
File "python-syntax-errors.py", line 2
proxies = {
^
SyntaxError: '{' was never closedDer Python Interpreter liefert eine detaillierte Fehlermeldung, einschließlich Dateiname, Zeilennummer und einem Pfeil, der anzeigt, wo der Fehler aufgetreten ist. Hier wird angegeben, dass '{' was never closed.
Mit dieser Information können Sie das Problem leicht identifizieren und beheben, indem Sie die geschweifte Klammer schließen.
# Correct
proxies = {
'http': proxy_url,
'https': proxy_url
} # Closed a curly bracketAnführungszeichen (' oder ") verursachen in Python häufig Probleme. Wie viele Programmiersprachen verwendet Python Anführungszeichen, um Strings zu definieren. Stellen Sie immer sicher, dass derselbe Typ von Anführungszeichen zum Öffnen und Schließen eines Strings verwendet wird.
# Incorrect
host = "brd.superproxy.io'Das Mischen von einfachen und doppelten Anführungszeichen führt zu einem Syntaxfehler:
File "python-syntax-errors.py", line 2
host = "brd.superproxy.io'
^
SyntaxError: unterminated string literal (detected at line 2)Hier teilt Ihnen der Interpreter mit, dass Sie den String literal in der zweiten Zeile nicht beendet haben:
# Correct
host = "brd.superproxy.io"Wenn ein String sowohl einfache als auch doppelte Anführungszeichen enthält, verwenden Sie dreifache Anführungszeichen (''' oder """), um den String einzuschließen, wie hier:
quote = """He said, "It's the best proxy service you can find!", and showed me this provider."""Kommas trennen Elemente in Listen, Tupeln und Funktionsargumenten. Ein fehlendes Komma kann unerwartete Fehler verursachen.
# Incorrect
proxies= [
{"http": "http://123.456.789.1:8080", "https": "https://123.456.789.1:8080"}
{"http": "http://98.765.432.1:3128", "https": "https://98.765.432.1:3128"}
{"http": "http://192.168.1.1:8080", "https": "https://192.168.1.1:8080"}
]Beim Ausführen dieses Codes entsteht die folgende Fehlermeldung:
File "python-syntax-errors.py", line 3
{"http": "http://123.456.789.1:8080", "https": "https://123.456.789.1:8080"}
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?Fehlermeldungen sind hilfreich, aber sie erkennen nicht alle Probleme. Wenn ein fehlendes Komma erkannt wird, prüfen Sie den umgebenden Code auf weitere fehlende Kommas, um eine korrekte Syntax sicherzustellen.
# Correct
proxies = [
{"http": "http://123.456.789.1:8080", "https": "https://123.456.789.1:8080"},
{"http": "http://98.765.432.1:3128", "https": "https://98.765.432.1:3128"},
{"http": "http://192.168.1.1:8080", "https": "https://192.168.1.1:8080"}
]Im Gegensatz zu Kommas werden Doppelpunkte verwendet, um einen neuen Codeblock zu beginnen (wie in einer if-Anweisung oder for-Schleife):
import requests
from bs4 import BeautifulSoup
# Incorrect
response = requests.get('https://example.com')
if response.status_code == 200
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.text
print(title)
)Das Vergessen eines Doppelpunkts führt zu folgendem Syntaxfehler:
if response.status_code == 200
^
SyntaxError: expected ':' Aus dieser Fehlermeldung lässt sich leicht erkennen, dass ein Doppelpunkt fehlt, und Sie können ihn an der vorgeschlagenen Stelle hinzufügen, um das Problem zu beheben:
import requests
from bs4 import BeautifulSoup
# Correct
response = requests.get('https://example.com')
if response.status_code == 200:
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.text
print(title)Python keywords sind reservierte Wörter mit spezifischer Bedeutung und können nicht als Variablennamen verwendet werden. Ein Keyword falsch zu schreiben, falsch zu platzieren oder wegzulassen, verursacht einen Fehler.
Zum Beispiel kann die falsche Schreibweise des Keywords import beim Importieren der Module requests und pprint zu Problemen führen.
# Incorrect
improt requests
import pprintDiese falsche Schreibweise führt dazu, dass der Interpreter den folgenden invalid syntax-Fehler ausgibt:
File "python-syntax-errors.py", line 2
improt requests
^^^^^^^^
SyntaxError: invalid syntaxEinige Fehlermeldungen können vage sein und erfordern zusätzliche Aufmerksamkeit. In diesem Fall zeigt der Pfeil auf requests und damit auf die Stelle, an der der Syntaxfehler erkannt wurde. Da ein falsch geschriebener Modulname keinen Syntaxfehler verursacht, liegt das Problem wahrscheinlich an einem falsch geschriebenen import-Keyword.
Das Korrigieren von import behebt den Fehler.
# Correct
import requests
import pprintEs ist auch möglich, die from ... import …-Anweisung wie folgt falsch zu verwenden:
import BeautifulSoup from bs4Obwohl es in Ordnung wirkt, führt das Ausführen des vorherigen Codes zu einem Fehler, weil das Keyword from vor import stehen muss:
File "python-syntax-errors.py", line 2
import BeautifulSoup from bs4
^^^^
SyntaxError: invalid syntaxDas Vertauschen von from und import behebt das Problem:
from bs4 import BeautifulSoupDas Vergessen eines Keywords kann in Python verschiedene Fehler verursachen. Dieses Problem ist subtil, da je nach fehlendem Keyword unterschiedliche Fehler erscheinen können.
Zum Beispiel kann das Weglassen des Keywords return in einer Funktion, die einen Wert zurückgeben soll, zu unerwartetem Verhalten führen.
def fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
# Missing a return statement here
data = fetch_data()Dies löst keinen Syntaxfehler aus, aber die Funktion gibt None statt des erwarteten Ergebnisses zurück. Das Hinzufügen des Keywords return behebt den vorherigen Code:
def fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
data = fetch_data()Wenn Sie beim Definieren einer Funktion das Keyword def vergessen, erhalten Sie einen Syntaxfehler:
# Missing the `def` keyword
fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
data = fetch_data()Der vorherige Code löst einen Syntaxfehler aus, weil der Interpreter ein Keyword vor dem Funktionsnamen erwartet:
File "python-syntax-errors.py", line 1
fetch_data():
^
SyntaxError: invalid syntaxDas Hinzufügen des Keywords def behebt den Fehler:
def fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
data = fetch_data()Wenn Sie in einer bedingten Anweisung das Keyword if vergessen, entsteht ein Fehler, da der Interpreter ein Keyword vor der Bedingung erwartet.
import requests
from bs4 import BeautifulSoup
response = requests.get('https://example.com')
# Missing the if keyword
response.status_code == 200:
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.text
print(title)File "python-syntax-errors.py", line 6
response.status_code == 200:
^
SyntaxError: invalid syntaxSie müssen lediglich das Keyword if hinzufügen, um dieses Problem zu beheben:
import requests
from bs4 import BeautifulSoup
response = requests.get('https://example.com')
if response.status_code == 200:
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.text
print(title)Note: Fehlende Keywords können auch andere Arten von Fehlern auslösen, seien Sie daher besonders vorsichtig.
In Python steht = für assignment, während == für comparison verwendet wird. Wenn Sie beides verwechseln, kann dies zu einem Syntaxfehler führen.
import requests
from bs4 import BeautifulSoup
# Incorrect
response = requests.get('https://example.com', proxies=proxies)
if response = requests.get('https://example.com/data', proxies=proxies):
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
for item in data:
print(item.text)
else:
print("Failed to retrieve data")Im vorherigen Code erkennt der Interpreter korrekt, was das Problem verursacht hat:
File "python-syntax-errors.py", line 5
if response = requests.get('https://example.com/data', proxies=proxies)
^^^^^^Hier prüfen Sie, ob die Antwort dem Ergebnis von request.get() entspricht. Um den Fehler zu beheben, ersetzen Sie im if-Statement den Zuweisungsoperator (=) durch den Vergleichsoperator (==).
import requests
from bs4 import BeautifulSoup
# Correct
response = requests.get('https://example.com', proxies=proxies)
# Change in the following line
if response == requests.get('https://example.com/data', proxies=proxies):
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
for item in data:
print(item.text)
else:
print("Failed to retrieve data")Python nutzt Einrückung, um Codeblöcke zu definieren. Eine falsche Einrückung verhindert, dass der Interpreter die Blockstruktur erkennt, was zu einem IndentationError führt.
# Incorrect
async with async_playwright() as playwright:
await run(playwright)Im vorherigen Beispiel fehlt nach der Blockdefinition (nach einem Doppelpunkt) die Einrückung. Beim Ausführen des Codes entsteht ein Fehler.
File "python-syntax-errors.py", line 2
await run(playwright)
^
IndentationError: expected an indented block after the with statement on line 1Um dieses Problem zu beheben, folgen Sie den Syntaxregeln von Python und rücken Sie den Codeblock korrekt ein:
# Correct
async with async_playwright() as playwright:
await run(playwright)Variablennamen müssen mit einem Buchstaben oder einem Unterstrich beginnen und dürfen nur Buchstaben, Zahlen und Unterstriche enthalten. Python unterscheidet Groß- und Kleinschreibung, daher sind myvariable, myVariable und MYVARIABLE unterschiedlich.
Ein Variablenname darf nicht mit einer Zahl beginnen. Das folgende Beispiel verletzt diese Regel, indem es mit 1 beginnt.
# Incorrect
1st_port = 22225Wenn Sie den vorherigen Code ausführen, wirft der Interpreter einen SyntaxError:
File "python-syntax-errors.py", line 2
1st_port = 1
^
SyntaxError: invalid decimal literalUm dies zu beheben, müssen Sie den Variablennamen mit einem Buchstaben oder einem Unterstrich beginnen. Jede der folgenden Optionen kann funktionieren:
# Correct
first_port = 22225
port_no_1 = 22225Um eine Funktion zu definieren, verwenden Sie das Keyword def, gefolgt vom Funktionsnamen, Klammern und einem Doppelpunkt. Beim Aufruf einer Funktion verwenden Sie ihren Namen, gefolgt von Klammern. Wenn eines dieser Elemente fehlt, entsteht ein Syntaxfehler.
import requests
from bs4 import BeautifulSoup
# Incorrect
def fetch_data
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
# Incorrect
data = fetch_dataIn diesem Beispiel verursachen fehlende Elemente mehrere Syntaxfehler. Um sie zu beheben, fügen Sie nach fetch_data in der Funktionsdefinition Klammern und einen Doppelpunkt hinzu sowie nach dem Funktionsaufruf in der letzten Zeile Klammern.
import requests
from bs4 import BeautifulSoup
# Corrected
def fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
# Corrected
data = fetch_data()Fehlende Klammern oder Doppelpunkte in einer Funktionsdefinition verursachen immer einen Syntaxfehler. Wenn Sie jedoch beim Aufruf einer Funktion (fetch_data()) die Klammern vergessen, wird möglicherweise keine Exception ausgelöst, was zu unerwartetem Verhalten führen kann.
Fehlerfreien Code zu schreiben ist eine Fähigkeit, die mit Übung kommt. Das Verständnis und die Umsetzung der folgenden Best Practices kann Ihnen helfen, häufige Syntaxfehler zu vermeiden.
Der beste Umgang mit Syntaxfehlern besteht darin, sie zu verhindern. Machen Sie sich vor Beginn eines Projekts mit den häufigsten Syntaxregeln der Sprache vertraut.
Ein guter Code-Editor hilft, Syntaxfehler zu vermeiden, mit Funktionen wie Syntax-Highlighting und Einrückungsprüfung. Diese Tools können Probleme erkennen, bevor Sie Ihren Code ausführen.
Zum Beispiel kann eine rote Markierung im Editor auf einen fehlenden Doppelpunkt in if response.status_code == 200 hinweisen.
Konsistenz ist entscheidend, um sauberen, fehlerfreien Code zu schreiben. Ein konsistenter Stil verbessert die Lesbarkeit und macht Fehler leichter erkennbar.
In Python ist der PEP 8 Style Guide der Standard und bietet Richtlinien zur Variablennamensgebung, Einrückung und Verwendung von Whitespace.
Das Aufteilen von Code in kleine, klar definierte Funktionen verbessert die Wartbarkeit und das Debugging. Jede Funktion sollte einem einzigen, klaren Zweck dienen. Funktionen, die zu viel tun, werden schwieriger zu verstehen und zu debuggen.
Betrachten Sie zum Beispiel die Funktion scrape_and_analyze():
import requests
from bs4 import BeautifulSoup
from textblob import TextBlob
def scrape_and_analyze():
url = "https://example.com/articles"
response = requests.get(url)
soup = BeautifulSoup(response.content, "html.parser")
titles = soup.find_all("h2", class_="article-title")
sentiments = []
for title in titles:
title_text = title.get_text()
blob = TextBlob(title_text)
sentiment = blob.sentiment.polarity
sentiments.append(sentiment)
return sentiments
print(scrape_and_analyze())In diesem Beispiel wäre es besser lesbar, diese Funktion in mehrere kleinere aufzuteilen, von denen jede einen kleineren, besser handhabbaren Teil des Codes ausführt:
import requests
from bs4 import BeautifulSoup
from textblob import TextBlob
def scrape_titles(url):
"""Scrape article titles from a given URL."""
response = requests.get(url)
soup = BeautifulSoup(response.content, "html.parser")
titles = soup.find_all("h2", class_="article-title")
return [title.get_text() for title in titles]
def analyze_sentiment(text):
"""Analyze sentiment of a given text."""
blob = TextBlob(text)
return blob.sentiment.polarity
def analyze_titles_sentiment(titles):
"""Analyze sentiment of a list of titles."""
return [analyze_sentiment(title) for title in titles]
def scrape_and_analyze(url):
"""Scrape titles from a website and analyze their sentiment."""
titles = scrape_titles(url)
sentiments = analyze_titles_sentiment(titles)
return sentiments
url = "https://example.com/articles"
print(scrape_and_analyze(url))Trotz bester Bemühungen können Fehler weiterhin auftreten. Python liefert Fehlermeldungen, die das Problem und seinen Ort beschreiben.
Python-Fehlermeldungen liefern Details zum Problem und zu seinem Ort. Eine sorgfältige Analyse kann helfen, das Problem zu identifizieren und eine Lösung zu finden.
Die Verwendung von print()-Statements ist eine schnelle Möglichkeit, den Ausführungsfluss nachzuverfolgen und Variablenwerte in kleinen Projekten zu prüfen. Dies ist nützlich für schnelles Debugging, sollte jedoch aufgrund von Sicherheits- und Performance-Risiken nicht in Production verwendet werden.
Bei komplexen Problemen oder größeren Codebases ist ein Debugger effektiver. Debugger ermöglichen das Setzen von Breakpoints, das schrittweise Durchlaufen von Code und das Untersuchen von Variablen über mehrere Funktionsaufrufe hinweg und bieten damit einen kontrollierteren Debugging-Prozess.
Wenn Sie bei einem schwierigen Fehler nicht weiterkommen, zögern Sie nicht, Hilfe zu suchen. Online-Ressourcen wie die Python Docs und Real Python bieten wertvolle Anleitungen. Communities wie r/Python, r/LearnPython, Stack Overflow und das Python Forum sind großartige Orte, um Antworten und Lösungen zu finden.
Ob Sie zuverlässige Proxy-Services, automatisierte Datenerfassung, einsatzbereite Datensätze oder Automatisierung von Web-Scraping-Aufgaben benötigen: Bright Data bietet Lösungen, die Ihre Web-Scraping-Projekte effizienter und produktiver machen können. Interessieren Sie sich dafür, Web-Scraping mit Python zu lernen? Lesen Sie unseren detaillierten Schritt-für-Schritt Python Scraping Guide.
Registrieren Sie sich jetzt, um das passende Produkt für Ihre Anforderungen zu finden, und starten Sie noch heute eine kostenlose Testversion!