¿Cómo puedo evitar declarar una variable no utilizada en un bucle for?

Si tengo una lista de comprensión (por ejemplo) como esta:

['' for x in myList]

Efectivamente, al hacer una nueva lista que tiene una cadena vacía para cada elemento de una lista, nunca uso el x. ¿Existe una forma más limpia de escribir esto para no tener que declarar la xvariable no utilizada ?

_ es un nombre de marcador de posición estándar para miembros ignorados en una asignación de bucle for y tupla, por ejemplo

['' for _ in myList]

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

Por cierto, su lista podría escribirse sin comprensión de la lista (asumiendo que desea hacer una lista de miembros inmutables como cadenas, números enteros, etc.)

[''] * len(myList)

No. Como dice el Zen: los casos especiales no son lo suficientemente especiales como para romper las reglas. El caso especial es que los bucles no usan los elementos de la cosa que se está iterando y la regla es que hay un "objetivo" para desempaquetar.

Sin embargo, puede utilizarlo _como nombre de variable, que normalmente se entiende como "no utilizado intencionadamente" (incluso PyLint, etc. lo sabe y respeta).

Resulta que usar dummy*(la palabra inicial es ficticia) como nombre de variable hace el mismo truco que _. _es un estándar conocido y sería mejor utilizar nombres de variables significativos. Así que usted puede utilizar dummy, dummy1, dummy_anything. Al usar estos nombres de variables PyLint, no se quejará.

Agregue el siguiente comentario después del bucle for en la misma línea:

#pylint: disable = variable-unused

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

Si necesita nombrar sus argumentos (en caso, por ejemplo, al escribir simulacros que no usan ciertos argumentos a los que se hace referencia por nombre), puede agregar este método de atajo:

def UnusedArgument(_):
  pass

y luego úsalo así

def SomeMethod(name_should_remain):
  UnusedArgument(name_should_remain)

Los objetos del generador en realidad no usan las variables. Entonces algo como

list(('' for x in myList))

debería hacer el truco. Tenga en cuenta que x no se define como una variable fuera de la comprensión del generador.

También puede anteponer un nombre de variable con _si prefiere darle a la variable un nombre legible por humanos. Por ejemplo, puede utilizar _foo, _foo1, _anythingy pylint no se quejará. En un bucle for, sería como:

for _something in range(10):
    do_something_else()

editar: Agregar ejemplo

Una forma detallada es:

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

Evita declarar una variable usada de esta manera.

También puede agregar objetos mutables e inmutables (como diccionarios) en newList.

Otra cosa para los novatos de Python como yo, '_', 'tonto' son un poco desconcertantes.

Pruébelo, es simple:

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

Comentar ¿Cómo puedo evitar declarar una variable no utilizada en un bucle for? (Se acabó el tamaño del comentario)

Python mantiene la misma referencia para el objeto creado. (independientemente de la mutabilidad), por ejemplo,

In [1]: i = 1

In [2]: j = 1

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

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

Puede ver que tanto i como j se refieren al mismo objeto en la memoria. Qué sucede cuando cambiamos el valor de una variable inmutable.

In [5]: j = j+1

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

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

puede ver que j ahora comienza a señalar una nueva ubicación (donde se almacena 2), y todavía apunta a la ubicación donde se almacena 1. Mientras evalúa,

j = j+1

El valor se toma de 142671248, se calcula (si aún no se ha almacenado en caché) y se coloca en una nueva ubicación 142671236. Se hace que j apunte a la nueva ubicación. En términos más simples, se realiza una nueva copia cada vez que se modifica una variable inmutable.

Mutabilidad

Los objetos mutables actúan de forma poco diferente a este respecto. Cuando el valor señalado por

In [16]: a = []

In [17]: b = a

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

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

Tanto a como b apuntan a la misma ubicación de memoria.

In [20]: a.append(5)

Se modifica la ubicación de la memoria señalada por a.

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

Tanto a como b, aún apuntan a la misma ubicación de memoria. En otras palabras, las variables mutables actúan en la misma ubicación de memoria apuntada por la variable, en lugar de hacer una copia del valor apuntado por la variable, como en el caso de variable inmutable.