Comment puis-je contourner la déclaration d'une variable inutilisée dans une boucle for?

Question

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

 ['' for x in myList]
 

Pour créer efficacement une nouvelle liste contenant une chaîne vide pour chaque élément de la liste, je n’utilise jamais les x . Existe-t-il une manière plus simple d’écrire cela afin que je n’aie pas à déclarer la variable inutilisée x ?

Answer 1

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

 ['' for _ in myList]

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

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

 [''] * len(myList)
 

Answer 2

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 des boucles n'utilisant pas les éléments de la chose itérée et la règle étant qu'il y a une "cible" à décompresser.

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

Answer 3

Si vous devez nommer vos arguments (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
 

et ensuite l'utiliser comme ça

 def SomeMethod(name_should_remain):
  UnusedArgument(name_should_remain)
 

Answer 4

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.

Answer 5

Commentaire de comment puis-je obtenir autour de déclarer une nouvelle variable dans une boucle for (a manqué de commenter la taille)

Python gère la même référence de 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, se référer au même objet en mémoire.Ce qui se passe, quand on change la valeur d'une immuable variable.

In [5]: j = j+1

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

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

vous pouvez le voir j maintenant commence à pointer un nouvel emplacement (où 2 est stocké), et j'ai encore des points à l'emplacement où 1 est stockée. Pendant l'évaluation,

j = j+1

La valeur est choisi à partir de 142671248, calculée(si pas déjà dans le cache), et de les mettre à un nouvel emplacement 142671236. j est fait à point pour le nouvel emplacement. En termes plus simples, une nouvelle copie faite à chaque fois immuable variable est modifiée.

La mutabilité

Mutable objets de la loi sur les peu différent à 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

A et b pointent vers le même emplacement mémoire.

In [20]: a.append(5)

Emplacement mémoire pointé 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

À la fois a et b, pointent toujours vers le même emplacement mémoire. En d'autres mots, mutable variables la loi de la même zone mémoire pointée par la variable, au lieu de faire une copie de la valeur pointée par la variable, comme dans immuable variable de cas.