Chaque langage possède un ensemble de règles définissant comment former correctement des constructions valides. C’est ce qu’on appelle la « syntaxe ». Lorsque l’on apprend à coder, nous faisons tous des erreurs de syntaxe. Les débutants ont souvent du mal à comprendre les règles syntaxiques : ils font fréquemment des erreurs de syntaxe et ne placent pas les symboles au bon endroit.
Les erreurs de syntaxe font partie intégrante du parcours de codage de chacun, mais plus vite vous comprendrez pourquoi elles se produisent, plus vite vous pourrez les corriger.
Dans cet article, vous allez découvrir les différentes erreurs de syntaxe en Python et comment les éviter.
Erreurs de syntaxe en Python
Dans tout langage de programmation, le non-respect des règles syntaxiques entraînera une erreur de syntaxe et l’exécution de votre code sera bloquée.
L’interpréteur Python lit et exécute votre code, agissant comme un traducteur entre le langage Python de haut niveau et le langage machine de bas niveau que votre ordinateur comprend. Si votre code ne respecte pas les règles syntaxiques de Python, l’interpréteur ne saura pas le traiter.
Lorsque l’interpréteur Python rencontre une erreur de syntaxe, il s’arrête et affiche un message d’erreur. Ce message comprend un retour à la ligne de code qui a causé l’erreur, ainsi qu’un indicateur indiquant le premier point de la ligne où l’erreur a été détectée.
L’interpréteur essaie de vous fournir le maximum d’informations pertinentes pour vous aider à diagnostiquer et à résoudre le problème, alors lisez attentivement tous les messages d’erreur.
Les erreurs de syntaxe en Python sont liées à la structure : elles se produisent lorsqu’une commande enfreint les règles syntaxiques du langage. Par exemple, en anglais, une phrase doit toujours commencer par une majuscule et se terminer par un signe de ponctuation. De même, en Python, une déclaration doit toujours se terminer par un retour à la ligne et les blocs de code (comme ceux des instructions « if » ou des boucles) doivent être indentés correctement.
Si vous connaissez les erreurs d’exécution, vous vous demandez peut-être en quoi elles diffèrent des erreurs de syntaxe. Les erreurs de syntaxe empêchent l’exécution d’un programme. Les erreurs d’exécution se produisent après le début de l’exécution du programme.
Exploration des différents types d’erreurs de syntaxe
Comme Python comporte de nombreuses règles syntaxiques, de nombreuses erreurs de syntaxe peuvent également se produire. Dans cette section, vous allez découvrir plusieurs erreurs courantes et leur solution.
Signe de ponctuation mal placé, absent ou mal assorti
Python utilise différents signes de ponctuation pour comprendre la structure de votre code. Vous devez vous assurer que chacun de ces signes de ponctuation est placé correctement et associé à la ponctuation correspondante afin d’éviter les erreurs de syntaxe.
Par exemple, vous devez toujours utiliser les parenthèses (), les crochets [] et les accolades {} par paires correspondantes. Cela signifie que si vous en ouvrez une, vous devez la fermer.
Dans l’exemple suivant, une accolade est utilisée pour définir un objet, mais elle n’est pas fermée :
# Incorrect
proxies = {
'http': proxy_url,
'https': proxy_url
Si vous essayez d’exécuter cet exemple, l’interpréteur retournera une erreur de syntaxe (SyntaxError) :
File "python-syntax-errors.py", line 2
proxies = {
^
SyntaxError: '{' was never closed
Comme indiqué précédemment, l’interpréteur Python fournit généralement une description du message d’erreur. Ici, il vous donne le nom du fichier où l’erreur s’est produite, le numéro de la ligne où elle s’est produite et une flèche indiquant l’endroit dans le code où l’erreur a été détectée. Il vous indique également que { n’a jamais été fermée.
Avec toutes ces informations, vous pouvez facilement comprendre qu’il faut fermer l’accolade pour résoudre le problème :
# Correct
proxies = {
'http': proxy_url,
'https': proxy_url
} # Closed a curly bracket
Les guillemets (simple : ‘ ou double : “) sont un autre signe de ponctuation qui pose souvent problème. Python, comme beaucoup d’autres langages de programmation, utilise des guillemets pour définir les chaînes de caractères. Vous devez utiliser le même type de guillemets pour ouvrir et fermer une chaîne :
# Incorrect
host = "brd.superproxy.io'
Si vous mélangez les guillemets simples et les guillemets doubles, vous commettez une erreur de syntaxe :
File "python-syntax-errors.py", line 2
host = "brd.superproxy.io'
^
SyntaxError: unterminated string literal (detected at line 2)
Ici, l’interpréteur vous indique que vous n’avez pas refermé la chaîne de caractères sur la deuxième ligne :
# Correct
host = "brd.superproxy.io"
Vous pouvez utiliser une paire de guillemets simples pour obtenir le même résultat.
Dans certains cas, il peut être nécessaire d’utiliser des guillemets simples et doubles dans une chaîne de caractères. Dans ce cas, vous pouvez utiliser des guillemets triples comme ceci :
quote = """He said, "It's the best proxy service you can find!", and showed me this provider."""
En Python, on utilise les virgules pour séparer les éléments d’une liste, d’un tuple ou d’un argument de fonction. L’absence de virgule peut entraîner des résultats inattendus :
# 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"}
]
L’exécution de ce code entraîne le message d’erreur suivant :
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?
Bien que les messages d’erreur soient souvent très utiles, ils ne vous donnent pas toujours la solution. Dans cet extrait, il manque quatre virgules, mais le message d’erreur n’a vu que la première. Pour y remédier, vous devez examiner le code autour du message d’erreur et trouver d’autres endroits où vous avez peut-être oublié de placer une virgule :
# 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"}
]
Contrairement aux virgules, les deux points sont utilisés pour commencer un nouveau bloc de code (comme dans une instruction « if » ou une boucle « for ») :
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)
)
L’oubli d’un deux-points entraîne l’erreur de syntaxe suivante :
if response.status_code == 200
^
SyntaxError: expected ':'
Avec ce message d’erreur, il est facile de déterminer qu’il manque un deux-points, et vous pouvez l’ajouter à l’endroit suggéré pour résoudre le problème :
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)
Mots-clés Python mal orthographiés, mal placés ou manquants
Les mots-clés Python sont des mots spéciaux réservés à des significations et des utilisations spécifiques, et vous ne pouvez pas les utiliser comme noms de variables. Si vous vous trompez dans l’orthographe, l’emplacement ou l’utilisation d’un mot-clé, l’interpréteur relève une erreur.
Par exemple, si vous essayez d’importer les modules « requests » et « pprint » dans votre projet de web scraping, vous pouvez accidentellement mal orthographier le mot-clé « import » :
# Incorrect
improt requests
import pprint
Cette faute de frappe entraîne l’apparition de l’erreur de syntaxe suivante dans l’interpréteur :
File "python-syntax-errors.py", line 2
improt requests
^^^^^^^^
SyntaxError: invalid syntax
Malheureusement, ce message d’erreur est vague, et vous devez donc chercher un peu pour comprendre ce qui n’a pas fonctionné. Vous pouvez voir que les flèches du message d’erreur pointent vers les requêtes. C’est là que l’interpréteur a détecté une erreur de syntaxe pour la première fois. Étant donné que l’orthographe du nom d’un module n’entraîne pas d’erreur de syntaxe, la seule autre possibilité est que vous ayez mal orthographié le mot-clé « import ».
Une simple correction du mot « import » permet de corriger l’erreur :
# Correct
import requests
import pprint
Il est également possible de se tromper dans l’instruction « from... import... » comme ceci :
import BeautifulSoup from bs4
Bien que cela semble correct, l’exécution du code précédent déclenche une erreur car le mot-clé « from » devrait précéder « import » :
File "python-syntax-errors.py", line 2
import BeautifulSoup from bs4
^^^^
SyntaxError: invalid syntax
Le fait d’intervertir « from » et « import » résout le problème :
from bs4 import BeautifulSoup
L’oubli d’un mot-clé est un autre problème auquel vous serez probablement confronté lorsque vous coderez en Python. Ce type d’erreur est un peu plus subtil que les autres erreurs mentionnées, car l’omission d’un mot-clé en Python peut entraîner différentes erreurs.
Si vous oubliez d’inclure le mot-clé « return » dans une fonction qui est censée renvoyer une valeur, la fonction ne se comporte pas comme prévu :
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()
Il ne s’agit pas d’une erreur de syntaxe, mais la fonction renvoie « None » plutôt que le résultat attendu. L’ajout du mot-clé « return » corrige le code précédent :
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()
Si vous oubliez le mot-clé « def » lors de la définition d’une fonction, vous rencontrez une erreur de syntaxe :
# 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()
Le code précédent déclenche une erreur de syntaxe, car l’interpréteur attend un mot-clé avant le nom de la fonction :
File "python-syntax-errors.py", line 1
fetch_data():
^
SyntaxError: invalid syntax
L’ajout du mot-clé « def » résout l’erreur :
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()
Si vous oubliez le mot-clé « if » dans une instruction conditionnelle, l’interpréteur déclenche une erreur, car il s’attend à ce qu’un mot-clé précède la condition :
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 syntax
Il suffit d’inclure le mot-clé « if » pour résoudre ce problème :
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)
Notez qu’il ne s’agit là que de quelques exemples de mots-clés manquants en Python. Les mots-clés manquants peuvent également provoquer d’autres types d’erreurs, il convient donc d’être particulièrement vigilant.
Utilisation incorrecte de l’opérateur d’affectation
En Python, le symbole « = » est utilisé pour les affectations, et « == » pour les comparaisons. Si vous confondez ces deux symboles, une erreur de syntaxe pourra être déclenchée :
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")
Dans le code précédent, l’interpréteur détecte correctement la cause du problème :
File "python-syntax-errors.py", line 5
if response = requests.get('https://example.com/data', proxies=proxies)
^^^^^^
Dans ce cas, vous essayez de vérifier que votre réponse est la même que la réponse à la méthode request.get(). Cela signifie que vous devez remplacer l’opérateur d’affectation dans l’instruction « if » par l’opérateur de comparaison :
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")
Erreurs d’indentation
Python utilise l’indentation pour définir les blocs de code. Si votre code n’est pas indenté correctement, l’interpréteur ne peut pas distinguer le contenu du bloc de code et déclenche une IndentationError :
# Incorrect
async with async_playwright() as playwright:
await run(playwright)
Comme vous pouvez le voir dans le code précédent, il n’y a pas d’indentation après la définition d’un bloc (deux points), de sorte que lorsque vous exécutez ce code, vous obtenez le message d’erreur suivant :
File "python-syntax-errors.py", line 2
await run(playwright)
^
IndentationError: expected an indented block after the with statement on line 1
Pour résoudre ce problème, suivez les règles syntaxiques de Python et indentez correctement le bloc de code :
# Correct
async with async_playwright() as playwright:
await run(playwright)
Problèmes liés aux déclarations de variables
Les noms de variables en Python doivent commencer par une lettre ou un trait de soulignement, et ils ne peuvent contenir que des lettres, des chiffres et des traits de soulignement. En outre, Python est sensible à la casse, de sorte que « mavariable », « maVariable » et « MAVARIABLE » sont toutes des variables différentes.
Les noms de vos variables ne peuvent jamais commencer par autre chose qu’une lettre ou un trait de soulignement. Le nom de variable suivant commence par 1, ce qui n’est pas conforme aux règles syntaxiques de Python :
# Incorrect
1st_port = 22225
Lorsque vous exécutez le code précédent, l’interpréteur déclenche une SyntaxError :
File "python-syntax-errors.py", line 2
1st_port = 1
^
SyntaxError: invalid decimal literal
Pour résoudre ce problème, le nom de la variable doit commencer par une lettre ou un trait de soulignement. Toutes les options suivantes peuvent fonctionner :
# Correct
first_port = 22225
port_no_1 = 22225
Erreurs de définition et d’appel de fonction
Pour définir une fonction, vous devez utiliser le mot-clé « def », suivi du nom de la fonction, de parenthèses et de deux points. Lorsque vous appelez une fonction, vous devez utiliser son nom suivi de parenthèses. L’oubli d’un de ces éléments entraîne une erreur de syntaxe :
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_data
Ici, trois éléments sont manquants et chacun d’entre eux provoque une erreur de syntaxe distincte. Pour corriger ces erreurs, vous devez ajouter des parenthèses et des deux points après le nom de la fonction « fetch_data ». Vous devez également ajouter des parenthèses après l’appel de la fonction sur la dernière ligne du bloc de code, comme ceci :
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()
Notez que l’absence de parenthèses et de deux-points dans la définition de la fonction entraîne toujours une erreur de syntaxe. Toutefois, l’interpréteur ne détecte pas l’oubli des parenthèses lors de l’appel d’une fonction (fetch_data()). Dans ce cas, il ne déclenche pas nécessairement une exception, ce qui peut entraîner un comportement inattendu.
Meilleures pratiques pour éviter les erreurs de syntaxe
Écrire du code sans erreur est une compétence qui s’acquiert avec la pratique. La compréhension et la mise en œuvre des meilleures pratiques suivantes peuvent vous aider à éviter les erreurs de syntaxe courantes.
Stratégies proactives
La meilleure façon de traiter les erreurs de syntaxe est d’essayer de les éviter dès le départ.
Avant de commencer à travailler sur un projet, vous devez vous familiariser avec les règles syntaxiques les plus courantes du langage dans lequel vous codez.
Utilisez un éditeur de code avec mise en évidence de la syntaxe et vérification de l’indentation
Un bon éditeur de code est un partenaire idéal pour éviter les erreurs de syntaxe. La plupart des éditeurs de code modernes proposent des fonctionnalités telles que la coloration syntaxique et la vérification de l’indentation, qui peuvent vous aider à repérer les erreurs avant d’exécuter votre code.
Par exemple, dans l’illustration suivante, une marque rouge à la fin de la ligne « if response.status_code == 200 » suggère qu’il y a une erreur puisqu’il n’y a pas de deux points :
Suivez des règles cohérentes en matière de style de codage
La plupart du temps, la cohérence est essentielle lorsqu’il s’agit d’écrire du code propre et sans erreur. Essayez de suivre un style de codage cohérent. Votre code sera ainsi plus facile à lire et à comprendre, ce qui facilitera la détection et la correction des erreurs.
En Python, le guide de style PEP 8 est largement accepté comme la norme en matière de style de codage. Il fournit des directives pour des éléments tels que le nom des variables, l’indentation et l’utilisation de l’espace blanc.
Scindez votre code en petites fonctions bien définies
La décomposition de votre code en petites fonctions bien définies peut en faciliter la gestion et le débogage.
Chaque fonction doit avoir un objectif unique et clair. Si une fonction réalise trop de choses, elle peut devenir difficile à comprendre et à déboguer. Prenons l’exemple de la fonction « 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())
Dans cet exemple, il serait plus lisible de décomposer cette fonction en plusieurs fonctions plus petites, chacune exécutant une portion de code plus petite et plus facile à gérer :
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))
Stratégies réactives
Quels que soient les efforts déployés pour éviter les erreurs, il y en a toujours quelques-unes qui finissent pas apparaître. Les stratégies suivantes sont axées sur le traitement de ces erreurs.
Lisez attentivement les messages d’erreur
Comme indiqué précédemment, Python affiche généralement un message d’erreur qui contient des informations sur la nature de l’erreur et sa localisation.
Une lecture attentive de ces messages d’erreur peut vous donner des indications précieuses sur ce qui n’a pas fonctionné et sur la manière d’y remédier.
Utilisez les instructions « print() » de manière stratégique
L’utilisation des instructions « print() » est un moyen rapide et efficace de débuguer de petits projets ou des problèmes simples pour lesquels vous devez retracer le flux d’exécution ou inspecter les valeurs des variables à des points spécifiques. Cette méthode est particulièrement utile dans le cadre d’un développement rapide et lorsque vous avez une bonne idée de l’origine du problème.
Le débogage par impression peut être moins intrusif et plus rapide à mettre en œuvre, ce qui en fait une méthode de choix pour les corrections rapides et les bugs simples. Cependant, il faut toujours garder à l’esprit qu’il s’agit d’une méthode temporaire, et veiller à ne pas l’utiliser dans le code de production, car l’impression des données présentées aux utilisateurs finaux peut entraîner des fuites de données catastrophiques et des problèmes de performance.
L’utilisation d’un débogueur est plus appropriée lorsque les problèmes sont plus complexes, que les bases de code sont plus importantes ou qu’il est nécessaire d’inspecter l’état du programme plus en profondeur (par exemple, l’état des variables à travers plusieurs appels de fonction ou itérations). Les débogueurs vous permettent de définir des points d’arrêt, de parcourir le code ligne par ligne et d’inspecter l’état de l’application à tout moment, offrant ainsi un environnement de débogage plus contrôlé et plus complet.
Exploitez les ressources et les communautés en ligne
Si vous êtes bloqué sur une erreur particulièrement délicate, n’hésitez pas à demander de l’aide. Il existe de nombreuses ressources en ligne (Python Docs et Real Python) et communautés (r/Python et r/LearnPython subreddits, Stack Overflow et Python Forum) qui fournissent des réponses et des solutions à de nombreux problèmes déjà rencontrés.
Conclusion
Dans cet article, nous avons exploré l’univers des erreurs de syntaxe Python. Vous avez découvert quelques types d’erreurs de syntaxe, y compris où elles peuvent se produire et comment les identifier et les corriger.
Vous avez également découvert plusieurs stratégies proactives et réactives pour vous aider à prévenir les erreurs de syntaxe ou à les corriger lorsqu’elles se produisent.
Bright Data est l’un des principaux fournisseurs d’outils de web scraping. Que vous ayez besoin de proxies fiables, d’automatiser la collecte de données, d’ensembles de données prêts à l’emploi ou d’une automatisation des tâches de web scraping, Bright Data propose des solutions qui peuvent améliorer l’efficacité et la productivité de vos projets.
IInscrivez-vous maintenant pour trouver le produit qui correspond à vos besoins et essayer gratuitement dès aujourd’hui !
Aucune carte de crédit requise
