Comment vérifier si une chaîne est un python valide d'identification? y compris le mot-clé case?

Python 3

Python 3 a maintenant 'foo'.isidentifier(), de sorte que semble être la meilleure solution pour les dernières versions de Python (merci camarade runciter@freenode pour la suggestion). Toutefois, un peu de manière contre-intuitive, il ne vérifie pas à l'encontre de la liste de mots-clés, de sorte que la combinaison des deux doit être utilisé:

import keyword
def isidentifier(ident: str) -> bool:
"""Determines if string is valid Python identifier."""
if not isinstance(ident, str):
raise TypeError("expected str, but got {!r}".format(type(ident)))
if not ident.isidentifier():
return False
if keyword.iskeyword(ident):
return False
return True

Python 2

Pour Python 2, plus facilement possible de vérifier si une chaîne donnée est valide Python identificateur est de laisser Python analyser lui-même.

Il y a deux approches possibles. La plus rapide est d'utiliser ast, et de vérifier si l'AST de la même expression est de la forme désirée:

import ast
def isidentifier(ident):
"""Determines, if string is valid Python identifier."""
# Smoke test — if it's not string, then it's not identifier, but we don't
# want to just silence exception. It's better to fail fast.
if not isinstance(ident, str):
raise TypeError("expected str, but got {!r}".format(type(ident)))
# Resulting AST of simple identifier is <Module [<Expr <Name "foo">>]>
try:
root = ast.parse(ident)
except SyntaxError:
return False
if not isinstance(root, ast.Module):
return False
if len(root.body) != 1:
return False
if not isinstance(root.body[0], ast.Expr):
return False
if not isinstance(root.body[0].value, ast.Name):
return False
if root.body[0].value.id != ident:
return False
return True

Une autre est de laisser tokenize module scission de l'identifiant dans le flux de jetons, et vérifier qu'il ne contient que notre nom:

import keyword
import tokenize
def isidentifier(ident):
"""Determines if string is valid Python identifier."""
# Smoke test - if it's not string, then it's not identifier, but we don't
# want to just silence exception. It's better to fail fast.
if not isinstance(ident, str):
raise TypeError("expected str, but got {!r}".format(type(ident)))
# Quick test - if string is in keyword list, it's definitely not an ident.
if keyword.iskeyword(ident):
return False
readline = lambda g=(lambda: (yield ident))(): next(g)
tokens = list(tokenize.generate_tokens(readline))
# You should get exactly 2 tokens
if len(tokens) != 2:
return False
# First is NAME, identifier.
if tokens[0][0] != tokenize.NAME:
return False
# Name should span all the string, so there would be no whitespace.
if ident != tokens[0][1]:
return False
# Second is ENDMARKER, ending stream
if tokens[1][0] != tokenize.ENDMARKER:
return False
return True

La même fonction, mais compatible avec Python 3, ressemble à ceci:

import keyword
import tokenize
def isidentifier_py3(ident):
"""Determines if string is valid Python identifier."""
# Smoke test — if it's not string, then it's not identifier, but we don't
# want to just silence exception. It's better to fail fast.
if not isinstance(ident, str):
raise TypeError("expected str, but got {!r}".format(type(ident)))
# Quick test — if string is in keyword list, it's definitely not an ident.
if keyword.iskeyword(ident):
return False
readline = lambda g=(lambda: (yield ident.encode('utf-8-sig')))(): next(g)
tokens = list(tokenize.tokenize(readline))
# You should get exactly 3 tokens
if len(tokens) != 3:
return False
# If using Python 3, first one is ENCODING, it's always utf-8 because 
# we explicitly passed in UTF-8 BOM with ident.
if tokens[0].type != tokenize.ENCODING:
return False
# Second is NAME, identifier.
if tokens[1].type != tokenize.NAME:
return False
# Name should span all the string, so there would be no whitespace.
if ident != tokens[1].string:
return False
# Third is ENDMARKER, ending stream
if tokens[2].type != tokenize.ENDMARKER:
return False
return True

Cependant, être conscient de bugs en Python 3 tokenize de mise en œuvre qui rejettent certains complètement identificateurs valides comme ℘᧚, ﮯ et 贈ᩭ. ast fonctionne très bien cependant. Généralement, je déconseillerais à l'aide de tokenizebase de mise en œuvre effective des contrôles.

Aussi, certains peuvent considérer que la machinerie lourde comme AST analyseur à être un peu exagéré. Cette simple mise en œuvre est autonome et garanti pour fonctionner sur n'importe quel Python 2:

import keyword
import string
def isidentifier(ident):
"""Determines if string is valid Python identifier."""
if not isinstance(ident, str):
raise TypeError("expected str, but got {!r}".format(type(ident)))
if not ident:
return False
if keyword.iskeyword(ident):
return False
first = '_' + string.lowercase + string.uppercase
if ident[0] not in first:
return False
other = first + string.digits
for ch in ident[1:]:
if ch not in other:
return False
return True

Voici quelques tests pour vérifier tous ces travaux:

assert(isidentifier('foo'))
assert(isidentifier('foo1_23'))
assert(not isidentifier('pass'))    # syntactically correct keyword
assert(not isidentifier('foo '))    # trailing whitespace
assert(not isidentifier(' foo'))    # leading whitespace
assert(not isidentifier('1234'))    # number
assert(not isidentifier('1234abc')) # number and letters
assert(not isidentifier(''))      # Unicode not from allowed range
assert(not isidentifier(''))        # empty string
assert(not isidentifier('   '))     # whitespace only
assert(not isidentifier('foo bar')) # several tokens
assert(not isidentifier('no-dashed-names-for-you')) # no such thing in Python
# Unicode identifiers are only allowed in Python 3:
assert(isidentifier('℘᧚')) # Unicode $Other_ID_Start and $Other_ID_Continue

Performance

Toutes les mesures ont été réalisées sur ma machine (MBPr la Mi-2014) sur le même test générés aléatoirement un ensemble de 1 500 000 éléments, 1000 000 valide et 500 000 invalides. YMMV

== Python 3:
method | calls/sec | faster
---------------------------
token  |    48 286 |  1.00x
ast    |   175 530 |  3.64x
native | 1 924 680 | 39.86x
== Python 2:
method | calls/sec | faster
---------------------------
token  |    83 994 |  1.00x
ast    |   208 206 |  2.48x
simple | 1 066 461 | 12.70x

La liste de python mots-clés est à court de sorte que vous pouvez vérifier la syntaxe d'une simple regex et l'adhésion à une relativement petite liste de mots-clés

import keyword #thanks asmeurer
import re
my_var = "$testBadVar"
print re.match("[_A-Za-z][_a-zA-Z0-9]*",my_var) and not keyword.iskeyword(my_var)

une plus courte, mais plus dangereux alternative serait

my_bad_var="%#ASD"
try:exec("{0}=1".format(my_bad_var))
except SyntaxError: #this maynot be right error
print "Invalid variable name!"

et enfin un peu plus sûr variante

my_bad_var="%#ASD"
try:
cc = compile("{0}=1".format(my_bad_var),"asd","single")
eval(cc)
print "VALID"
except SyntaxError: #maybe different error
print "INVALID!"