Comment supprimer les avertissements "variable inutilisée" dans Eclipse/PyDev
Comment supprimer les avertissements "variable inutilisée" dans Eclipse/PyDev
Lorsque je travaille avec des fonctions qui renvoient des n-uplets, souvent, je n'ai besoin que de l'une des valeurs, mais je souhaite tout de même affecter plusieurs variables. J'aimerais pouvoir désactiver temporairement cet avertissement pour pouvoir me concentrer sur des problèmes plus graves. Ensuite, je peux le réactiver lorsque je fais plus d’une vérification finale.
Si vous vous demandez pourquoi je le ferais délibérément, c'est juste pour la lisibilité. Supposons qu'une fonction retourne un tuple de n-uplets, plusieurs parties de mon code pourraient fonctionner avec la troisième valeur, comme ceci:
label, content = myfunc()[2]
Parfois, je ne suis peut-être intéressé que par le contenu, mais je trouve cela ...
tmp, content = myfunc()[2]
... pour être plus parallèle (et donc plus lisible) que ceci:
content = myfunc()[2][1]
S'il existe un meilleur moyen de procéder simplement sans affecter de variable jetable inutilisée, n'hésitez pas à fournir cette réponse.
>>> myfunc()[2]
('lab', 'val')
>>> , v = myfunc()[2]
SyntaxError: invalid syntax
>>> tmp, v = myfunc()[2]
>>>
Si vous n'avez pas besoin de la valeur d'une variable, affectez-la à la variable spéciale _.
En ce qui concerne Python, _ n'a rien de spécial; c'est juste un autre identifiant légal comme un autre.
Cependant, pour la plupart des outils de style "lint" (y compris PyDev si possible) et, plus important encore, pour les lecteurs humains, cela a une signification particulière: "Je n'ai pas besoin de cette variable, je ne fais que mettre quelque chose ici, car l'API/syntaxe/tout ce qui le nécessite ". Ce qui signifie qu'ils ne vous préviendront pas de ne pas l'utiliser.
Alors:
_, content = myfunc()[2]
Et oui, vous avez raison de dire que ceci est souvent plus lisible que myfunc()[2][1]. De plus, cela vous aidera à détecter quelques erreurs supplémentaires. Si myfunc()[2] n'a pas exactement deux membres, l'affectation Tuple sera lancée, mais le [1] ne le sera pas.
Très, très rarement, ce n'est pas une bonne idée car la valeur est quelque chose que vous voulez voir ramasser les ordures dès que possible, et la lier à _ au lieu de ne pas la lier du tout (par exemple, via [2][1]) retarde cela.
Plus sérieusement, cela entre en conflit avec un autre idiome qui utilise également spécialement _: Le code qui utilise gettext pour l'internationalisation a généralement pour effet:
import gettext
_ = gettext.gettext
Ou équivalent:
from gettext import gettext as _
Évidemment, vous ne pouvez pas utiliser _ comme raccourci gettext et identifiant sans signification. (Vous pourriez réellement vous en sortir, car la signification de gettext est liée au niveau global du module, et l'identificateur sans signification ne devrait être utilisé que dans les corps de fonction… mais c'est une très mauvaise idée d'essayer, car à Vous finirez par utiliser la variable gettext_ dans une fonction après avoir attribué une valeur locale qui l’obscurcira.) Rien ne vous oblige à utiliser _ dans les deux cas - mais si vous utilisez autre chose, vous risquez de confondre les lecteurs ( et peut-être le même outil anti-peluches que vous cherchez à pacifier en premier lieu). Vous devez donc décider lequel est le plus important pour vous dans un projet donné. (Et généralement, si vous utilisez gettext, ce sera le plus important.)
Si vous appelez à plusieurs reprises myfunc et supprimez certaines de ces valeurs, vous pouvez envisager d'écrire une fonction wrapper:
def mywrapperfunc():
_, content = myfunc()[2]
return content
Ensuite, votre code peut simplement faire:
content = mywrapperfunc()
Cela présente de nombreux avantages:
- C'est évidemment plus facile à lire que tout ce qui vous oblige à vous rappeler que vous voulez la deuxième moitié d'un tuple qui se trouve dans l'index 2 de la séquence renvoyée par
myfunc. - Cela vous donne un endroit pour mettre un joli nom (espérons-le plus beau que
mywrapperfunc) et/ou des commentaires/docstrings, au cas où ce ne serait pas anodin. - Cela signifie que si vous modifiez ultérieurement
myfuncde sorte que la valeur souhaitée se trouve maintenant dans l'index 3 au lieu de 2, et que le deuxième membre d'un tuple à 3 éléments au lieu d'un tuple à 2 éléments, il vous suffit de modifiermywrapperfuncau lieu de 20 lignes de code. - Cela signifie également que si vous souhaitez utiliser ultérieurement un idiome
_en conflit (par exemple, pour modifier votre code avecgettext), vous ne devez le modifier qu’à un seul endroit.
Remarque un côté: Dans l’interpréteur interactif, _ a a une signification particulière: il est lié au résultat de la dernière commande interactive. Mais cela ne signifie pas que vous ne pouvez pas utiliser _ dans l'interpréteur interactif. (En fait, c'est encore mieux, car tout ce que vous cachez est immédiatement écrasé, de sorte que le très rare problème de GC ne se pose pas.)
Ajoutez le commentaire #@UnusedVariable à la fin de la ligne.
Tous les avertissements dans PyDev ont un commentaire de désactivation similaire. Utilisez la solution rapide pour les découvrir (placez le curseur dans l’avertissement et appuyez sur Ctrl + 1) ou faites référence à ces lignes à partir du code source - PyDev :
public static final String MSG_TO_IGNORE_TYPE_UNUSED_IMPORT = "@UnusedImport";
public static final String MSG_TO_IGNORE_TYPE_UNUSED_WILD_IMPORT = "@UnusedWildImport";
public static final String MSG_TO_IGNORE_TYPE_UNUSED_VARIABLE = "@UnusedVariable";
public static final String MSG_TO_IGNORE_TYPE_UNDEFINED_VARIABLE = "@UndefinedVariable";
public static final String MSG_TO_IGNORE_TYPE_DUPLICATED_SIGNATURE = "@DuplicatedSignature";
public static final String MSG_TO_IGNORE_TYPE_REIMPORT = "@Reimport";
public static final String MSG_TO_IGNORE_TYPE_UNRESOLVED_IMPORT = "@UnresolvedImport";
public static final String MSG_TO_IGNORE_TYPE_NO_SELF = "@NoSelf";
public static final String MSG_TO_IGNORE_TYPE_UNDEFINED_IMPORT_VARIABLE = "@UndefinedVariable";
public static final String MSG_TO_IGNORE_TYPE_UNUSED_PARAMETER = "@UnusedVariable";
public static final String MSG_TO_IGNORE_TYPE_NO_EFFECT_STMT = "@NoEffect";
public static final String MSG_TO_IGNORE_TYPE_INDENTATION_PROBLEM = "@IndentOk";
public static final String MSG_TO_IGNORE_TYPE_ASSIGNMENT_TO_BUILT_IN_SYMBOL = "@ReservedAssignment";
public static final String MSG_TO_IGNORE_TYPE_PEP8 = "@IgnorePep8";
public static final String MSG_TO_IGNORE_TYPE_ARGUMENTS_MISATCH = "@ArgumentMismatch";
Préférences -> PyDev -> Editeur -> Analyse de code, onglet "Non utilisé"
Trouver le réglage pour
Ne rapporte pas de variable non utilisée si le nom commence par: (séparés par une virgule)
puis utilisez l’un des préfixes de cette liste ou ajoutez-en un autre.
Par exemple, si vous avez une variable à jeter "tmp" dans le code suivant:
tmp, content = myfunc()[2]
et vous avez '_' sur votre liste de préfixes à ignorer, puis convertissez "tmp" en "_tmp" comme ceci:
_tmp, content = myfunc()[2]
Votre erreur disparaîtra. Je pense que c'est une solution plus lisible que d'utiliser simplement '_', comme suggéré par @abarnert, et cela évite également les complications du conflit avec la traduction.
Je rencontre ce problème parfois lorsque j'utilise une fonctionnalité similaire à celle que vous décrivez quand un tuple est renvoyé. Vous pouvez définir globalement des niveaux d'avertissement pour l'analyse du code de PyDev dans la section Préférences -> PyDev -> Editeur -> Analyse du code. Dans Analyse de code de l'onglet Non utilisé, il existe une option permettant de définir le niveau d'avertissement pour "Variable non utilisée" ainsi que pour d'autres occurrences.
Vous pouvez également supprimer un avertissement donné dans Eclipse dans any language (y compris Python) à l’aide d’un plugin supplémentaire. http://suppresswarnings.drupalgardens.com
Également disponible sur le marché: