Pourquoi pylint s'oppose-t-il aux noms de variables à caractère unique?

Je suis toujours en train de m'habituer aux conventions python et à les utiliser pylintpour rendre mon code plus pythonique, mais je suis déconcerté par le fait que pylint n'aime pas les noms de variables à caractère unique. J'ai quelques boucles comme celle-ci:

for x in x_values:
   my_list.append(x)

et quand je cours pylint, j'obtiens Invalid name "x" for type variable (should match [a-z_][a-z0-9_]{2,30}- cela suggère qu'un nom de variable valide doit contenir entre 3 et 31 caractères, mais j'ai regardé à travers les conventions de dénomination PEP8 et je ne vois rien d'explicite concernant les lettres minuscules simples , et je vois beaucoup d'exemples qui les utilisent.

Y a-t-il quelque chose qui me manque dans PEP8 ou s'agit-il d'une norme propre à pylint?

PyLint vérifie non seulement les recommandations PEP8. Il a également ses propres recommandations, dont l'une est qu'un nom de variable doit être descriptif et pas trop court.

Vous pouvez utiliser ceci pour éviter de tels noms courts:

my_list.extend(x_values)

Ou modifiez la configuration de PyLint pour indiquer à PyLint quel nom de variable est bon.

Un peu plus de détails sur ce que gurney alex a noté: vous pouvez dire à PyLint de faire des exceptions pour les noms de variables qui (vous le jurez) sont parfaitement clairs même s'ils comportent moins de trois caractères. Recherchez ou ajoutez à votre fichier pylintrc , sous l'en- [FORMAT]tête:

# Good variable names which should always be accepted, separated by a comma
good-names=i,j,k,ex,Run,_,pk,x,y

Ici, pk (pour la clé primaire), x et y sont des noms de variables que j'ai ajoutés.

Dans les langages fortement typés, les variables de nom à 1 lettre peuvent être ok-ish, car vous obtenez généralement le type à côté du nom dans la déclaration de la variable ou dans le prototype de fonction / méthode:

bool check_modality(string a, Mode b, OptionList c) {
    ModalityChecker v = build_checker(a, b);
    return v.check_option(c);
}

En Python, vous n'obtenez pas ces informations, donc si vous écrivez:

def check_modality(a, b, c):
    v = build_checker(a, b)
    return v.check_option(c)

vous ne laissez absolument aucun indice à l'équipe de maintenance sur ce que la fonction pourrait faire, comment elle est appelée et ce qu'elle renvoie. Donc, en Python, vous avez tendance à utiliser des noms descriptifs:

def check_modality(name, mode, option_list):
    checker = build_checker(name, mode)
    return checker.check_option(option_list)

et vous ajoutez même une docstring expliquant ce que fait le truc et quels types sont attendus.

De nos jours, il existe également une option pour remplacer l'expression rationnelle. Par exemple, si vous souhaitez autoriser des caractères uniques en tant que variables:

pylint --variable-rgx="[a-z0-9_]{1,30}$" <filename>

Donc, pylintcorrespondra à PEP8 et n'apportera pas de violations supplémentaires. Vous pouvez également l'ajouter à .pylintrc.

La raison plus profonde est que vous souvenez peut - être ce que vous vouliez a, b, c, x, yet zà dire quand vous avez écrit votre code, mais quand d' autres le lisent, ou même quand vous revenez à votre code, le code devient beaucoup plus lisible lorsque vous donnez c'est un nom sémantique. Nous n'écrivons pas des trucs une fois sur un tableau pour ensuite les effacer. Nous écrivons du code qui pourrait rester une dizaine d'années ou plus, et être lu de nombreuses fois.

Utilisez des noms sémantiques. Les noms sémantiques que j'ai utilisés ont été comme ratio, denominator, obj_generator, path, etc. Il peut prendre une seconde ou deux pour les taper, mais le temps que vous gagnez à essayer de comprendre ce que vous avez écrit même une demi - heure à partir de là est bien la peine .