TOC

Syntaxe non valide en Python: raisons courantes pour SyntaxError

Syntaxe non valide en Python: raisons courantes pour SyntaxError

Python est connu pour sa syntaxe simple. Cependant, lorsque vous apprenez Python pour la première fois ou lorsque vous êtes arrivé à Python avec une solide expérience dans un autre langage de programmation, vous pouvez rencontrer certaines choses que Python n’autorise pas. Si vous avez déjà reçu un + SyntaxError + lorsque vous essayez d’exécuter votre code Python, ce guide peut vous aider. Tout au long de ce didacticiel, vous verrez des exemples courants de syntaxe non valide en Python et apprendrez à résoudre le problème.

*À la fin de ce didacticiel, vous serez en mesure de:*
 *Identifier* syntaxe non valide * en Python
 *Comprendre* `+ SyntaxError +` * tracebacks
* *Résoudre* syntaxe invalide ou l'empêcher complètement
*Bonus gratuit:* lien: [5 réflexions sur la maîtrise de Python], un cours gratuit pour les développeurs Python qui vous montre la feuille de route et l'état d'esprit dont vous aurez besoin pour faire passer vos compétences Python au niveau supérieur.

Syntaxe non valide en Python

Lorsque vous exécutez votre code Python, l’interpréteur l’analysera d’abord pour le convertir en code octet Python, qu’il exécutera ensuite. L’interpréteur trouvera toute syntaxe non valide en Python au cours de cette première étape de l’exécution du programme, également appelée étape d’analyse . Si l’interpréteur ne parvient pas à analyser votre code Python avec succès, cela signifie que vous avez utilisé une syntaxe non valide quelque part dans votre code. L’interprète tentera de vous montrer où cette erreur s’est produite.

Lorsque vous apprenez Python pour la première fois, il peut être frustrant d’obtenir un + SyntaxError +. Python tentera de vous aider à déterminer où se trouve la syntaxe non valide dans votre code, mais le traceback qu’il fournit peut être un peu déroutant. Parfois, le code vers lequel il pointe est parfaitement correct.

*Remarque:* Si votre code est *syntaxiquement* correct, alors vous pouvez obtenir d'autres exceptions levées qui ne sont pas un `+ SyntaxError +`. Pour en savoir plus sur les autres exceptions de Python et comment les gérer, consultez https://realpython.com/python-exceptions/[Python Exceptions: An Introduction].

Vous ne pouvez pas gérer la syntaxe non valide en Python comme les autres exceptions. Même si vous avez essayé d’envelopper un code + try + et + except + 'autour de code avec une syntaxe non valide, vous verrez toujours l’interpréteur déclencher un + SyntaxError + `.

+ SyntaxError + Exception et Traceback

Lorsque l’interpréteur rencontre une syntaxe non valide dans le code Python, il déclenche une exception + SyntaxError + et fournit une traceback avec des informations utiles pour vous aider à déboguer l’erreur. Voici du code qui contient une syntaxe non valide en Python:

 1 # theofficefacts.py
 2 ages = {
 3     'pam': 24,
 4     'jim': 24
 5     'michael': 43
 6 }
 7 print(f'Michael is {ages["michael"]} years old.')

Vous pouvez voir la syntaxe non valide dans le littéral du dictionnaire à la ligne 4. La deuxième entrée, + 'jim' +, manque une virgule. Si vous avez essayé d’exécuter ce code tel quel, vous obtiendrez le suivi suivant:

$ python theofficefacts.py
File "theofficefacts.py", line 5
    'michael': 43
            ^
SyntaxError: invalid syntax

Notez que le message de trace localise l’erreur à la ligne 5, pas à la ligne 4. L’interpréteur Python tente de montrer où se trouve la syntaxe non valide. Cependant, il ne peut vraiment indiquer où il a remarqué un problème pour la première fois. Lorsque vous obtenez un traceback + SyntaxError + et que le code vers lequel pointe le traceback semble correct, vous voudrez commencer à reculer dans le code jusqu’à ce que vous puissiez déterminer ce qui ne va pas.

Dans l’exemple ci-dessus, il n’y a pas de problème à omettre une virgule, selon ce qui vient après. Par exemple, il n’y a aucun problème avec une virgule manquante après "" michael "" à la ligne 5. Mais une fois que l’interprète rencontre quelque chose qui n’a pas de sens, il ne peut que vous indiquer la première chose qu’il a trouvée qu’il ne pouvait pas comprendre.

*Remarque:* Ce didacticiel suppose que vous connaissez les bases des *tracesbacks* de Python. Pour en savoir plus sur la traceback Python et comment les lire, consultez https://realpython.com/python-traceback/[Understanding the Python Traceback].

Il existe quelques éléments d’une traceback + SyntaxError + qui peuvent vous aider à déterminer où se trouve la syntaxe non valide dans votre code:

  • Le nom du fichier où la syntaxe non valide a été rencontrée

  • Le numéro de ligne et la ligne de code reproduite où le problème a été rencontré

  • Un signe d’insertion (+ ^ +) sur la ligne en dessous du code reproduit, qui vous montre le point du code qui a un problème

  • Le message d’erreur qui vient après le type d’exception + SyntaxError +, qui peut fournir des informations pour vous aider à déterminer le problème

Dans l’exemple ci-dessus, le nom de fichier donné était + theofficefacts.py +, le numéro de ligne était 5 et le curseur pointait vers la citation de fermeture de la clé de dictionnaire + michael +. Le + SyntaxError + traceback peut ne pas pointer vers le vrai problème, mais il pointera vers le premier endroit où l’interpréteur ne pourrait pas donner un sens à la syntaxe.

Il existe deux autres exceptions que vous pourriez voir augmenter Python. Ils sont équivalents à + ​​SyntaxError + mais ont des noms différents:

  1. + IndentationError +

  2. + TabError +

Ces exceptions héritent toutes deux de la classe + SyntaxError +, mais ce sont des cas particuliers où l’indentation est concernée. Une erreur + + IndentationError + est déclenchée lorsque les niveaux d’indentation de votre code ne correspondent pas. Un + TabError + est levé lorsque votre code utilise à la fois des tabulations et des espaces dans le même fichier. Vous examinerez ces exceptions de plus près dans une section ultérieure.

Problèmes de syntaxe courants

Lorsque vous rencontrez une + SyntaxError + pour la première fois, il est utile de savoir pourquoi il y a eu un problème et ce que vous pouvez faire pour corriger la syntaxe non valide dans votre code Python. Dans les sections ci-dessous, vous verrez certaines des raisons les plus courantes pour lesquelles une + SyntaxError + peut être déclenchée et comment vous pouvez les corriger.

Utilisation abusive de l’opérateur d’affectation (+ = +)

Il existe plusieurs cas en Python où vous ne pouvez pas affecter des objets. Certains exemples affectent des littéraux et des appels de fonction. Dans le bloc de code ci-dessous, vous pouvez voir quelques exemples qui tentent de le faire et les traces de retour + SyntaxError + résultantes:

>>>

>>> len('hello') = 5
  File "<stdin>", line 1
SyntaxError: can't assign to function call

>>> 'foo' = 1
  File "<stdin>", line 1
SyntaxError: can't assign to literal

>>> 1 = 'foo'
  File "<stdin>", line 1
SyntaxError: can't assign to literal

Le premier exemple essaie d’affecter la valeur + 5 + à l’appel + len () +. Le message + SyntaxError + est très utile dans ce cas. Il vous indique que vous ne pouvez pas attribuer de valeur à un appel de fonction.

Les deuxième et troisième exemples tentent d’affecter une chaîne et un entier aux littéraux. La même règle est vraie pour les autres valeurs littérales. Une fois de plus, les messages de trace indiquent que le problème se produit lorsque vous essayez d’affecter une valeur à un littéral.

*Remarque:* Les exemples ci-dessus ne contiennent pas la ligne de code répétée et le signe d'insertion (`+ ^ +`) pointant vers le problème dans le traçage. L'exception et le retraçage que vous voyez seront différents lorsque vous êtes dans le REPL vs en essayant d'exécuter ce code à partir d'un fichier. Si ce code était dans un fichier, vous obtiendrez la ligne de code répétée et le signe d'insertion pointant vers le problème, comme vous l'avez vu dans d'autres cas tout au long de ce didacticiel.

Il est probable que votre intention n’est pas d’attribuer une valeur à un appel littéral ou à un appel de fonction. Par exemple, cela peut se produire si vous omettez accidentellement le signe égal supplémentaire (+ = +), ce qui transformerait l’affectation en comparaison. Une comparaison, comme vous pouvez le voir ci-dessous, serait valide:

>>>

>>> len('hello') == 5
True

La plupart du temps, lorsque Python vous dit que vous effectuez une affectation à quelque chose qui ne peut pas être affecté, vous pouvez d’abord vérifier pour vous assurer que l’instruction ne doit pas être une expression booléenne à la place. Vous pouvez également rencontrer ce problème lorsque vous essayez d’attribuer une valeur à un mot clé Python, que vous aborderez dans la section suivante.

Mots-clés Python mal orthographiés, manquants ou mal utilisés

Les mots clés Python sont un ensemble de mots protégés qui ont une signification particulière en Python. Ce sont des mots que vous ne pouvez pas utiliser comme identificateurs, variables ou noms de fonction dans votre code. Ils font partie du langage et ne peuvent être utilisés que dans le contexte autorisé par Python.

Il existe trois façons courantes d’utiliser par erreur des mots clés:

  1. Faute d’orthographe un mot clé

  2. Manquant un mot-clé

  3. Utilisation abusive d’un mot clé

Si vous mal orthographiez un mot-clé dans votre code Python, vous obtiendrez un + SyntaxError +. Par exemple, voici ce qui se passe si vous épelez incorrectement le mot clé + pour +:

>>>

>>> fro i in range(10):
  File "<stdin>", line 1
    fro i in range(10):
        ^
SyntaxError: invalid syntax

Le message indique + SyntaxError: syntaxe non valide +, mais ce n’est pas très utile. Le traceback pointe vers le premier endroit où Python pouvait détecter que quelque chose n’allait pas. Pour corriger ce type d’erreur, assurez-vous que tous vos mots clés Python sont correctement orthographiés.

Un autre problème courant avec les mots clés est lorsque vous les manquez complètement:

>>>

>>> for i range(10):
  File "<stdin>", line 1
    for i range(10):
              ^
SyntaxError: invalid syntax

Encore une fois, le message d’exception n’est pas très utile, mais le traçage tente de vous orienter dans la bonne direction. Si vous reculez du curseur, vous pouvez voir que le mot-clé + in + est absent de la syntaxe de boucle + for +.

Vous pouvez également abuser d’un mot-clé Python protégé. N’oubliez pas que les mots clés ne peuvent être utilisés que dans des situations spécifiques. Si vous ne les utilisez pas correctement, vous aurez alors une syntaxe non valide dans votre code Python. Un exemple courant de ceci est l’utilisation de https://realpython.com/python-for-loop/#the-break-and-continue-statements [+ continue + ou + break +] en dehors d’une boucle. Cela peut facilement se produire pendant le développement lorsque vous implémentez des choses et que vous déplacez la logique en dehors d’une boucle:

>>>

>>> names = ['pam', 'jim', 'michael']
>>> if 'jim' in names:
...     print('jim found')
...     break
...
  File "<stdin>", line 3
SyntaxError: 'break' outside loop

>>> if 'jim' in names:
...     print('jim found')
...     continue
...
  File "<stdin>", line 3
SyntaxError: 'continue' not properly in loop

Ici, Python fait un excellent travail pour vous dire exactement ce qui ne va pas. Les messages " 'rompre' la boucle extérieure " et " 'continuer' ne fonctionnent pas correctement dans la boucle " vous aident à déterminer exactement quoi faire. Si ce code était dans un fichier, Python aurait également le signe d’insertion pointant directement vers le mot-clé mal utilisé.

Un autre exemple est si vous essayez d’affecter un mot clé Python à une variable ou utilisez un mot clé pour définir une fonction:

>>>

>>> pass = True
  File "<stdin>", line 1
    pass = True
         ^
SyntaxError: invalid syntax

>>> def pass():
  File "<stdin>", line 1
    def pass():
           ^
SyntaxError: invalid syntax

Lorsque vous essayez d’attribuer une valeur à + pass +, ou lorsque vous essayez de définir une nouvelle fonction appelée + pass +, vous obtiendrez un ` + SyntaxError + et voir à nouveau le message + "syntaxe invalide" + `.

Il pourrait être un peu plus difficile de résoudre ce type de syntaxe non valide dans le code Python car le code semble bien de l’extérieur. Si votre code semble bon, mais que vous obtenez toujours un + SyntaxError +, alors vous pourriez envisager de vérifier le nom de variable ou le nom de fonction que vous souhaitez utiliser par rapport à la liste de mots clés pour la version de Python que vous utilisez.

La liste des mots clés protégés a changé avec chaque nouvelle version de Python. Par exemple, dans Python 3.6, vous pouvez utiliser + wait + comme nom de variable ou nom de fonction, mais à partir de Python 3.7, ce mot a été ajouté à la liste des mots clés. Maintenant, si vous essayez d’utiliser + wait + comme nom de variable ou de fonction, cela provoquera un + SyntaxError + si votre code est pour Python 3.7 ou version ultérieure.

Un autre exemple de ceci est + print +, qui diffère entre Python 2 et Python 3:

Version print Type Takes A Value

Python 2

keyword

no

Python 3

built-in function

yes

+ print + est un mot-clé dans Python 2, vous ne pouvez donc pas lui attribuer de valeur. En Python 3, cependant, c’est une fonction intégrée à laquelle on peut attribuer des valeurs.

Vous pouvez exécuter le code suivant pour afficher la liste des mots clés dans la version de Python que vous utilisez:

import keyword
print(keyword.kwlist)

+ mot clé + fournit également l’utile + mot clé.iskeyword () +. Si vous avez juste besoin d’un moyen rapide pour vérifier la variable + pass +, alors vous pouvez utiliser le one-liner suivant:

>>>

>>> import keyword; keyword.iskeyword('pass')
True

Ce code vous indiquera rapidement si l’identifiant que vous essayez d’utiliser est un mot clé ou non.

Parenthèses, parenthèses et citations manquantes

Souvent, la cause de la syntaxe non valide dans le code Python est une parenthèse fermante manquée ou non appariée, un crochet ou une citation. Celles-ci peuvent être difficiles à repérer dans de très longues lignes de parenthèses imbriquées ou dans des blocs multi-lignes plus longs. Vous pouvez repérer les guillemets incompatibles ou manquants à l’aide des retraits de Python:

>>>

>>> message = 'don't'
  File "<stdin>", line 1
    message = 'don't'
                   ^
SyntaxError: invalid syntax

Ici, la trace pointe vers le code non valide où il y a un + t '+ après un guillemet simple de fermeture. Pour résoudre ce problème, vous pouvez effectuer l’une des deux modifications:

  1. Échapper la citation unique avec une barre oblique inverse (`+ 'don \' t '+')

  2. Entourez la chaîne entière entre guillemets (" Don't ")

Une autre erreur courante consiste à oublier de fermer la chaîne. Avec les chaînes entre guillemets doubles et entre guillemets simples, la situation et le retraçage sont les mêmes:

>>>

>>> message = "This is an unclosed string
  File "<stdin>", line 1
    message = "This is an unclosed string
                                        ^
SyntaxError: EOL while scanning string literal

Cette fois, le signe d’insertion dans le traceback pointe directement vers le code du problème. Le message + SyntaxError +, " EOL lors de l'analyse du littéral de chaîne ", est un peu plus spécifique et utile pour déterminer le problème. Cela signifie que l’interpréteur Python est arrivé à la fin d’une ligne (EOL) avant qu’une chaîne ouverte ne soit fermée. Pour résoudre ce problème, fermez la chaîne avec une citation qui correspond à celle que vous avez utilisée pour la démarrer. Dans ce cas, ce serait une double citation (`+" + `).

Les citations manquantes dans les instructions à l’intérieur d’un f-string peuvent également conduire à une syntaxe non valide en Python:

 1 # theofficefacts.py
 2 ages = {
 3     'pam': 24,
 4     'jim': 24,
 5     'michael': 43
 6 }
 7 print(f'Michael is {ages["michael]} years old.')

Ici, la référence au dictionnaire + ages + à l’intérieur de la chaîne f imprimée ne contient pas le guillemet de fermeture de la référence de clé. Le traçage résultant est le suivant:

$ python theofficefacts.py
  File "theofficefacts.py", line 7
    print(f'Michael is {ages["michael]} years old.')
         ^
SyntaxError: f-string: unterminated string

Python identifie le problème et vous indique qu’il existe à l’intérieur de la chaîne f. Le message " chaîne non terminée " indique également quel est le problème. Dans ce cas, le signe d’insertion pointe uniquement vers le début de la chaîne f.

Cela peut ne pas être aussi utile que lorsque le curseur pointe vers la zone à problème de la chaîne f, mais il se rétrécit là où vous devez regarder. Il y a une chaîne non terminée quelque part à l’intérieur de cette f-chaîne. Il suffit de savoir où. Pour résoudre ce problème, assurez-vous que toutes les citations et les crochets de chaîne f internes sont présents.

La situation est généralement la même pour les parenthèses et crochets manquants. Par exemple, si vous omettez le crochet de fermeture d’une liste, Python le remarquera et le signalera. Il existe cependant quelques variantes. La première consiste à laisser le crochet de fermeture hors de la liste:

# missing.py
def foo():
    return [1, 2, 3

print(foo())

Lorsque vous exécutez ce code, vous serez averti qu’il y a un problème avec l’appel à + ​​print () +:

$ python missing.py
  File "missing.py", line 5
    print(foo())
        ^
SyntaxError: invalid syntax

Ce qui se passe ici, c’est que Python pense que la liste contient trois éléments: + 1 +, + 2 + et +3 print (foo ()) +. Python utilise whitespace pour grouper les choses logiquement, et parce qu’il n’y a pas de virgule ou de parenthèse séparant + 3 + de `+ print (foo ()) + `, Python les regroupe comme troisième élément de la liste.

Une autre variante consiste à ajouter une virgule de fin après le dernier élément de la liste tout en laissant le crochet de fermeture:

# missing.py
def foo():
    return [1, 2, 3,

print(foo())

Maintenant, vous obtenez une traceback différente:

$ python missing.py
  File "missing.py", line 6

                ^
SyntaxError: unexpected EOF while parsing

Dans l’exemple précédent, + 3 + et + print (foo ()) + ont été regroupés en un seul élément, mais ici vous voyez une virgule séparant les deux. Maintenant, l’appel à + ​​print (foo ()) + est ajouté en tant que quatrième élément de la liste, et Python atteint la fin du fichier sans le crochet de fermeture. Le retraçage vous indique que Python est arrivé à la fin du fichier (EOF), mais qu’il s’attendait à autre chose.

Dans cet exemple, Python s’attendait à un crochet fermant (+] +), mais la ligne et le signe d’insertion répétés ne sont pas très utiles. Les parenthèses et crochets manquants sont difficiles à identifier pour Python. Parfois, la seule chose que vous pouvez faire est de commencer à partir du curseur et de reculer jusqu’à ce que vous puissiez identifier ce qui manque ou ce qui ne va pas.

Syntaxe erronée du dictionnaire

Vous avez vu le lien: # syntaxerror-exception-and-traceback [plus tôt] que vous pourriez obtenir un + SyntaxError + si vous laissez la virgule hors d’un élément de dictionnaire. Une autre forme de syntaxe invalide avec les dictionnaires Python est l’utilisation du signe égal (+ = +) pour séparer les clés et les valeurs, au lieu des deux points:

>>>

>>> ages = {'pam'=24}
  File "<stdin>", line 1
    ages = {'pam'=24}
                 ^
SyntaxError: invalid syntax

Encore une fois, ce message d’erreur n’est pas très utile. La ligne répétée et le curseur sont cependant très utiles! Ils pointent à droite vers le caractère problématique.

Ce type de problème est courant si vous confondez la syntaxe Python avec celle d’autres langages de programmation. Vous verrez également cela si vous confondez l’acte de définir un dictionnaire avec un appel + dict () +. Pour résoudre ce problème, vous pouvez remplacer le signe égal par deux points. Vous pouvez également passer à l’utilisation de + dict () +:

>>>

>>> ages = dict(pam=24)
>>> ages
{'pam': 24}

Vous pouvez utiliser + dict () + pour définir le dictionnaire si cette syntaxe est plus utile.

Utilisation de la mauvaise indentation

Il existe deux sous-classes de + SyntaxError + qui traitent spécifiquement des problèmes d’indentation:

  1. + IndentationError +

  2. + TabError +

Alors que d’autres langages de programmation utilisent des accolades pour désigner des blocs de code, Python utilise whitespace. Cela signifie que Python s’attend à ce que les espaces blancs de votre code se comportent de manière prévisible. Cela soulèvera un + IndentationError + s’il y a une ligne dans un bloc de code qui a le mauvais nombre d’espaces:

 1 # indentation.py
 2 def foo():
 3     for i in range(10):
 4         print(i)
 5   print('done')
 6
 7 foo()

Cela peut être difficile à voir, mais la ligne 5 ne comporte que 2 espaces en retrait. Il doit être en ligne avec l’instruction de boucle + for +, qui est de 4 espaces. Heureusement, Python peut repérer cela facilement et vous dira rapidement quel est le problème.

Il y a aussi un peu d’ambiguïté ici, cependant. La ligne + print ('done') + est-elle destinée à être après la boucle + for + ou inside le bloc de boucle + for +? Lorsque vous exécutez le code ci-dessus, vous verrez l’erreur suivante:

$ python indentation.py
  File "indentation.py", line 5
    print('done')
                ^
IndentationError: unindent does not match any outer indentation level

Même si la traceback ressemble beaucoup à la trace + SyntaxError +, c’est en fait une + IndentationError +. Le message d’erreur est également très utile. Il vous indique que le niveau d’indentation de la ligne ne correspond à aucun autre niveau d’indentation. En d’autres termes, + print ('done') + est en retrait de 2 espaces, mais Python ne peut trouver aucune autre ligne de code correspondant à ce niveau d’indentation. Vous pouvez résoudre ce problème rapidement en vous assurant que le code correspond au niveau d’indentation attendu.

L’autre type de + SyntaxError + est le + TabError + , que vous verrez chaque fois qu’une ligne contient des tabulations ou des espaces pour son retrait, tandis que le reste du fichier contient l’autre. Cela pourrait rester caché jusqu’à ce que Python vous le signale!

Si la taille de votre tabulation a la même largeur que le nombre d’espaces dans chaque niveau d’indentation, il peut sembler que toutes les lignes sont au même niveau. Cependant, si une ligne est indentée à l’aide d’espaces et l’autre est indentée avec des tabulations, alors Python signalera cela comme un problème:

 1 # indentation.py
 2 def foo():
 3     for i in range(10):
 4         print(i)
 5     print('done')
 6
 7 foo()

Ici, la ligne 5 est en retrait avec une tabulation au lieu de 4 espaces. Ce bloc de code peut vous sembler parfaitement bien, ou il peut sembler complètement faux, selon les paramètres de votre système.

Python, cependant, remarquera immédiatement le problème. Mais avant d’exécuter le code pour voir ce que Python vous dira, il peut être utile de voir un exemple de ce à quoi ressemble le code sous différents paramètres de largeur d’onglet:

$ tabs 4 # Sets the shell tab width to 4 spaces
$ cat -n indentation.py
     1   # indentation.py
     2   def foo():
     3       for i in range(10)
     4           print(i)
     5       print('done')
     6
     7   foo()

$ tabs 8 # Sets the shell tab width to 8 spaces (standard)
$ cat -n indentation.py
     1   # indentation.py
     2   def foo():
     3       for i in range(10)
     4           print(i)
     5           print('done')
     6
     7   foo()

$ tabs 3 # Sets the shell tab width to 3 spaces
$ cat -n indentation.py
     1   # indentation.py
     2   def foo():
     3       for i in range(10)
     4           print(i)
     5      print('done')
     6
     7   foo()

Notez la différence d’affichage entre les trois exemples ci-dessus. La plupart du code utilise 4 espaces pour chaque niveau d’indentation, mais la ligne 5 utilise un seul onglet dans les trois exemples. La largeur de l’onglet change en fonction du paramètre largeur de l’onglet :

  • Si la largeur de tabulation est de 4 , alors l’instruction + print + ressemblera à l’extérieur de la boucle + for +. La console affichera `` + 'done' + 'à la fin de la boucle.

  • Si la largeur de tabulation est de 8 , ce qui est standard pour de nombreux systèmes, alors l’instruction + print + ressemblera à l’intérieur de la boucle + for +. La console affichera `` + 'done' + `après chaque numéro.

  • Si la largeur de tabulation est de 3 , alors l’instruction + print + semble hors de propos. Dans ce cas, la ligne 5 ne correspond à aucun niveau d’indentation.

Lorsque vous exécutez le code, vous obtiendrez l’erreur et le retraçage suivants:

$ python indentation.py
  File "indentation.py", line 5
    print('done')
                ^
TabError: inconsistent use of tabs and spaces in indentation

Remarquez le + TabError + au lieu de l’habituel + SyntaxError +. Python signale la ligne de problème et vous donne un message d’erreur utile. Il vous indique clairement qu’il existe un mélange d’onglets et d’espaces utilisés pour l’indentation dans le même fichier.

La solution consiste à faire en sorte que toutes les lignes du même fichier de code Python utilisent des tabulations ou des espaces, mais pas les deux. Pour les blocs de code ci-dessus, le correctif serait de supprimer l’onglet et de le remplacer par 4 espaces, qui afficheront ` + 'done' + 'une fois la boucle `+ pour + terminée.

Définition et appel de fonctions

Vous pouvez rencontrer une syntaxe non valide dans Python lorsque vous définissez ou appelez des fonctions. Par exemple, vous verrez un + SyntaxError + si vous utilisez un point-virgule au lieu d’un deux-points à la fin d’une définition de fonction:

>>>

>>> def fun();
  File "<stdin>", line 1
    def fun();
             ^
SyntaxError: invalid syntax

Le retraçage ici est très utile, le curseur pointant vers la droite du caractère problématique. Vous pouvez effacer cette syntaxe non valide en Python en remplaçant le point-virgule par deux points.

De plus, les arguments de mots clés dans les définitions de fonction et les appels de fonction doivent être dans le bon ordre. Les arguments de mot-clé viennent toujours après les arguments de position. Le non-respect de cette commande entraînera un + SyntaxError +:

>>>

>>> def fun(a, b):
...     print(a, b)
...
>>> fun(a=1, 2)
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

Ici, encore une fois, le message d’erreur est très utile pour vous dire exactement ce qui ne va pas avec la ligne.

Modification des versions de Python

Parfois, du code qui fonctionne parfaitement dans une version de Python se casse dans une version plus récente. Cela est dû à des changements officiels dans la syntaxe de la langue. L’exemple le plus connu est l’instruction + print +, qui est passée d’un mot clé en Python 2 à une fonction intégrée en Python 3:

>>>

>>> # Valid Python 2 syntax that fails in Python 3
>>> print 'hello'
  File "<stdin>", line 1
    print 'hello'
                ^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print('hello')?

C’est l’un des exemples où le message d’erreur fourni avec le + SyntaxError + brille! Non seulement il vous indique que vous manquez des parenthèses dans l’appel + print +, mais il fournit également le code correct pour vous aider à corriger l’instruction.

Un autre problème que vous pourriez rencontrer est lorsque vous lisez ou découvrez la syntaxe qui est une syntaxe valide dans une version plus récente de Python, mais qui n’est pas valide dans la version dans laquelle vous écrivez. Un exemple de ceci est la syntaxe f-string, qui n’existait pas dans les versions Python antérieures à 3.6:

>>>

>>> # Any version of python before 3.6 including 2.7
>>> w ='world'
>>> print(f'hello, {w}')
  File "<stdin>", line 1
    print(f'hello, {w}')
                      ^
SyntaxError: invalid syntax

Dans les versions de Python antérieures à 3.6, l’interpréteur ne sait rien de la syntaxe de la chaîne f et fournira simplement un message générique "" syntaxe invalide "`. Le problème, dans ce cas, est que le code _semble parfaitement bien, mais il a été exécuté avec une ancienne version de Python. En cas de doute, vérifiez la version de Python que vous utilisez!

La syntaxe Python continue d’évoluer et de nouvelles fonctionnalités intéressantes ont été introduites dans Python 3.8:

Si vous souhaitez essayer certaines de ces nouvelles fonctionnalités, vous devez vous assurer que vous travaillez dans un environnement Python 3.8. Sinon, vous obtiendrez un + SyntaxError +.

Python 3.8 fournit également le nouveau* + SyntaxWarning + *. Vous verrez cet avertissement dans les situations où la syntaxe est valide mais semble toujours suspecte. Un exemple de ceci serait si vous manquiez une virgule entre deux tuples dans une liste. Ce serait une syntaxe valide dans les versions Python antérieures à 3.8, mais le code déclencherait un + TypeError + car un tuple n’est pas appelable:

>>>

>>> [(1,2)(2,3)]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object is not callable

Ce + TypeError + signifie que vous ne pouvez pas appeler un tuple comme une fonction, ce que l’interprète Python pense que vous faites.

Dans Python 3.8, ce code soulève toujours le + TypeError +, mais maintenant vous verrez également un + SyntaxWarning + qui indique comment vous pouvez résoudre le problème:

>>>

>>> [(1,2)(2,3)]
<stdin>:1: SyntaxWarning: 'tuple' object is not callable; perhaps you missed a comma?
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object is not callable

Le message utile accompagnant le nouveau + SyntaxWarning + fournit même un indice (" peut-être avez-vous manqué une virgule? ") Pour vous orienter dans la bonne direction!

Conclusion

Dans ce didacticiel, vous avez vu les informations que le traçage + SyntaxError + vous donne. Vous avez également vu de nombreux exemples courants de syntaxe non valide en Python et quelles sont les solutions à ces problèmes. Non seulement cela accélérera votre flux de travail, mais cela fera également de vous un réviseur de code plus utile!

Lorsque vous écrivez du code, essayez d’utiliser un IDE qui comprend la syntaxe Python et fournit des commentaires. Si vous placez de nombreux exemples de code Python non valides de ce tutoriel dans un bon IDE, ils devraient mettre en évidence les lignes de problème avant même de pouvoir exécuter votre code.

Obtenir un + SyntaxError + pendant que vous apprenez Python peut être frustrant, mais maintenant vous savez comment comprendre les messages de traceback et quelles formes de syntaxe non valide en Python vous pourriez rencontrer. La prochaine fois que vous obtenez un + SyntaxError +, vous serez mieux équipé pour résoudre le problème rapidement!

Related