Comment puis-je éviter de déclarer une variable inutilisée dans une boucle for?

Si j'ai une liste de compréhension (par exemple) comme celle-ci:

['' for x in myList]

En créant effectivement une nouvelle liste qui a une chaîne vide pour chaque élément d'une liste, je n'utilise jamais le x. Existe-t-il une manière plus propre d'écrire ceci pour ne pas avoir à déclarer la xvariable inutilisée ?

_ est un nom d'espace réservé standard pour les membres ignorés dans une affectation de boucle for et de tuple, par exemple

['' for _ in myList]

[a+d for a, _, _, d, _ in fiveTuples]

BTW votre liste pourrait être écrite sans compréhension de liste (en supposant que vous vouliez faire une liste de membres immuables comme des chaînes, des entiers, etc.).

[''] * len(myList)

Non. Comme le dit le Zen: les cas spéciaux ne sont pas assez spéciaux pour enfreindre les règles. Le cas particulier étant les boucles n'utilisant pas les éléments de l'objet en cours d'itération et la règle étant qu'il y a une "cible" à décompresser.

Vous pouvez, cependant, utiliser _comme nom de variable, qui est généralement compris comme "intentionnellement inutilisé" (même PyLint etc. le sait et le respecte).

Il s'avère que l'utilisation de dummy*(le mot de départ est factice) comme nom de variable fait la même chose que _. _est une norme connue et il serait préférable d'utiliser des noms de variables significatifs. Vous pouvez donc utiliser dummy, dummy1, dummy_anything. En utilisant ces noms de variables, PyLintne vous plaindrez pas.

Ajoutez le commentaire suivant après la boucle for sur la même ligne:

#pylint: disable = variable-inutilisée

for i in range(100): #pylint: disable=unused-variable

Si vous avez besoin de nommer vos arguments (au cas, par exemple, lors de l'écriture de simulations qui n'utilisent pas certains arguments référencés par leur nom), vous pouvez ajouter cette méthode de raccourci:

def UnusedArgument(_):
  pass

puis utilisez-le comme ça

def SomeMethod(name_should_remain):
  UnusedArgument(name_should_remain)

Les objets générateurs n'utilisent pas réellement les variables. Donc quelque chose comme

list(('' for x in myList))

devrait faire l'affaire. Notez que x n'est pas défini comme une variable en dehors de la compréhension du générateur.

Vous pouvez également ajouter un nom de variable au préfixe _si vous préférez donner à la variable un nom lisible par l'homme. Par exemple , vous pouvez utiliser _foo, _foo1, _anythinget pylint ne vous plaindrez pas. Dans une boucle for, ce serait comme:

for _something in range(10):
    do_something_else()

modifier: Ajouter un exemple

Une manière verbeuse est:

newList = []
while len(newList) < len(mylist):
    newList.append('')

Vous évitez de déclarer une variable utilisée de cette façon.

Vous pouvez également ajouter des objets mutables et immuables (comme des dictionnaires) dans newList.

Une autre chose pour les débutants en python comme moi, «_», «factice» sont un peu déconcertants.

Essayez-le, c'est simple:

# Use '_' instead of the variable
for _ in range(any_number):
    do_somthing()

Commentaire sur Comment puis-je me déplacer en déclarant une variable inutilisée dans une boucle for?(Ran hors de la taille du commentaire)

Python conserve la même référence pour l'objet créé. (indépendamment de la mutabilité), par exemple,

In [1]: i = 1

In [2]: j = 1

In [3]: id(i)
Out[3]: 142671248

In [4]: id(j)
Out[4]: 142671248

Vous pouvez voir à la fois i et j, faire référence au même objet en mémoire. Que se passe-t-il lorsque nous modifions la valeur d'une variable immuable?

In [5]: j = j+1

In [6]: id(i)
Out[6]: 142671248

In [7]: id(j)
Out[7]: 142671236

vous pouvez voir que j commence maintenant à pointer vers un nouvel emplacement (où 2 est stocké), et i pointe toujours vers l'emplacement où 1 est stocké. Lors de l'évaluation,

j = j+1

La valeur est choisie à partir de 142671248, calculée (si elle n'est pas déjà mise en cache) et placée à un nouvel emplacement 142671236. j est fait pour pointer vers le nouvel emplacement. En termes plus simples, une nouvelle copie est effectuée à chaque fois qu'une variable immuable est modifiée.

Mutabilité

Les objets mutables agissent peu différemment à cet égard. Lorsque la valeur pointée par

In [16]: a = []

In [17]: b = a

In [18]: id(a)
Out[18]: 3071546412L

In [19]: id(b)
Out[19]: 3071546412L

Les deux points a et b pointent vers le même emplacement mémoire.

In [20]: a.append(5)

L'emplacement mémoire indiqué par a est modifié.

In [21]: a
Out[21]: [5]

In [22]: b
Out[22]: [5]

In [23]: id(a)
Out[23]: 3071546412L

In [24]: id(b)
Out[24]: 3071546412L

Les deux a et b, pointent toujours vers le même emplacement mémoire. En d'autres termes, les variables mutables agissent du même emplacement mémoire pointé par la variable, au lieu de faire une copie de la valeur pointée par la variable, comme dans le cas des variables immuables.