Come posso aggirare la dichiarazione di una variabile inutilizzata in un ciclo for?


88

Se ho una lista di comprensione (ad esempio) come questa:

['' for x in myList]

Effettivamente creando un nuovo elenco che ha una stringa vuota per ogni elemento in un elenco, non uso mai il x. C'è un modo più pulito per scrivere questo in modo da non dover dichiarare la xvariabile inutilizzata ?


Ispirato da questa domanda, ho creato un tutorial di YouTube che copre le variabili inutilizzate nelle comprensioni degli elenchi youtube.com/watch?v=cZb5aFcpsAs
Brendan Metcalfe

Risposte:


132

_ è un nome segnaposto standard per i membri ignorati in un ciclo for e nell'assegnazione di tupla, ad es

['' for _ in myList]

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

BTW la tua lista potrebbe essere scritta senza la comprensione della lista (supponendo che tu voglia creare una lista di membri immutabili come stringhe, numeri interi ecc.).

[''] * len(myList)

10
Quest'ultimo deve essere accompagnato da un enorme avvertimento che non fa la cosa prevista per gli oggetti mutabili.

5
@Mohit:a=[[]]*4;a[0].append(5);print(a)
kennytm

@Ramy: Mohit ha pubblicato una spiegazione ma è stata eliminata: S Comunque, controlla Note 2 in docs.python.org/py3k/library/… .
kennytm

2
@Ramy, Python mantiene lo stesso riferimento per lo stesso oggetto in memoria.
Mohit Ranka

Ha importanza se eseguo forloop annidati , ad esempio? O se dentro for _ in range(...)voglio dire _, var = f(x)? Si confonderà tra le due _variabili?
Eric Auld

19

No. Come dice lo Zen: i casi speciali non sono abbastanza speciali da infrangere le regole. Il caso speciale è che i cicli non utilizzano gli elementi della cosa che viene iterata e la regola è che c'è un "obiettivo" in cui decomprimere.

È comunque possibile utilizzare _come nome variabile, che di solito è inteso come "intenzionalmente inutilizzato" (anche PyLint ecc. Lo sa e lo rispetta).


Pylint tuttavia lamenta che C: 10,24: Invalid variable name "_" (invalid-name)a meno che non lo si aggiunge good-namesnel vostro .pylintrc.
giorgiosironi

13

Si scopre che usare dummy*(la parola iniziale è fittizia) come nome della variabile fa lo stesso trucco di _. _è uno standard noto e sarebbe meglio usare nomi di variabili significativi. Così si può utilizzare dummy, dummy1, dummy_anything. Utilizzando questi nomi di variabili PyLintnon si lamenterà.


In effetti preferisco questo approccio. rimane significativo.
RvdK

2

Aggiungi il seguente commento dopo il ciclo for sulla stessa riga:

#pylint: disable = unused-variable

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

1

Se è necessario assegnare un nome ai propri argomenti (nel caso, ad esempio, durante la scrittura di mock che non utilizzano determinati argomenti a cui si fa riferimento per nome), è possibile aggiungere questo metodo di scelta rapida:

def UnusedArgument(_):
  pass

e poi usalo in questo modo

def SomeMethod(name_should_remain):
  UnusedArgument(name_should_remain)

0

Gli oggetti del generatore non utilizzano effettivamente le variabili. Quindi qualcosa di simile

list(('' for x in myList))

dovrebbe fare il trucco. Nota che x non è definita come una variabile al di fuori della comprensione del generatore.


0

Puoi anche anteporre un nome di variabile con _se preferisci dare alla variabile un nome leggibile dagli umani. Ad esempio è possibile utilizzare _foo, _foo1, _anythinge pylint non si lamenterà. In un ciclo for, sarebbe come:

for _something in range(10):
    do_something_else()

modifica: aggiungi esempio


0

Un modo dettagliato è:

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

Eviti di dichiarare una variabile usata in questo modo.

Inoltre puoi aggiungere oggetti mutabili e immutabili (come dizionari) in newList.

Un'altra cosa per i neofiti di Python come me, '_', 'dummy' sono un po 'sconcertanti.


0

Provalo, è semplice:

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

-1

Commento a Come posso aggirare la dichiarazione di una variabile inutilizzata in un ciclo for? (Ran out of comment size)

Python mantiene lo stesso riferimento per l'oggetto creato. (indipendentemente dalla mutabilità), ad esempio,

In [1]: i = 1

In [2]: j = 1

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

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

Puoi vedere sia i che j, fare riferimento allo stesso oggetto in memoria. Cosa succede, quando cambiamo il valore di una variabile immutabile.

In [5]: j = j+1

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

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

puoi vedere che j ora inizia a indicare una nuova posizione, (dove è memorizzato 2), e i punta ancora alla posizione in cui è memorizzato 1. Durante la valutazione,

j = j+1

Il valore viene scelto da 142671248, calcolato (se non è già memorizzato nella cache) e inserito in una nuova posizione 142671236. j viene fatto puntare alla nuova posizione. In termini più semplici, viene creata una nuova copia ogni volta che viene modificata una variabile immutabile.

Mutabilità

Gli oggetti mobili agiscono in modo leggermente diverso a questo riguardo. Quando il valore indicato da

In [16]: a = []

In [17]: b = a

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

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

Sia a che b puntano alla stessa posizione di memoria.

In [20]: a.append(5)

La posizione di memoria indicata da a viene modificata.

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

Sia a che b, puntano ancora alla stessa posizione di memoria. In altre parole, le variabili mutabili agiscono della stessa locazione di memoria puntata dalla variabile, invece di fare una copia del valore puntato dalla variabile, come nel caso della variabile immutabile.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.