La comprensione dell'elenco riassocia i nomi anche dopo l'ambito della comprensione. È giusto?

Le comprensioni stanno avendo alcune interazioni impreviste con l'ambito. È questo il comportamento previsto?

Ho un metodo:

def leave_room(self, uid):
  u = self.user_by_id(uid)
  r = self.rooms[u.rid]

  other_uids = [ouid for ouid in r.users_by_id.keys() if ouid != u.uid]
  other_us = [self.user_by_id(uid) for uid in other_uids]

  r.remove_user(uid) # OOPS! uid has been re-bound by the list comprehension above

  # Interestingly, it's rebound to the last uid in the list, so the error only shows
  # up when len > 1

A rischio di piagnucolare, questa è una brutale fonte di errori. Mentre scrivo nuovo codice, solo occasionalmente trovo errori molto strani dovuti al rebinding, anche ora che so che è un problema. Devo fare una regola come "anteponi sempre le variabili temporanee nelle comprensioni di elenchi con un trattino basso", ma anche questo non è infallibile.

Il fatto che ci sia questa bomba a orologeria casuale in attesa in qualche modo nega tutta la piacevole "facilità d'uso" della comprensione delle liste.

Le comprensioni dell'elenco fanno trapelare la variabile di controllo del ciclo in Python 2 ma non in Python 3. Ecco Guido van Rossum (creatore di Python) che spiega la storia dietro questo:

Abbiamo anche apportato un'altra modifica in Python 3, per migliorare l'equivalenza tra le comprensioni delle liste e le espressioni del generatore. In Python 2, la comprensione della lista "trapela" la variabile di controllo del ciclo nello scope circostante:

x = 'before'
a = [x for x in 1, 2, 3]
print x # this prints '3', not 'before'

Questo era un artefatto dell'implementazione originale della comprensione delle liste; è stato per anni uno dei "piccoli sporchi segreti" di Python. È iniziato come un compromesso intenzionale per rendere le comprensioni delle liste incredibilmente veloci e, sebbene non fosse una trappola comune per i principianti, occasionalmente pungeva sicuramente le persone. Per le espressioni del generatore non abbiamo potuto farlo. Le espressioni del generatore vengono implementate utilizzando generatori, la cui esecuzione richiede un frame di esecuzione separato. Pertanto, le espressioni del generatore (specialmente se ripetono su una breve sequenza) erano meno efficienti delle comprensioni di lista.

Tuttavia, in Python 3, abbiamo deciso di correggere il "piccolo sporco segreto" della comprensione delle liste utilizzando la stessa strategia di implementazione delle espressioni del generatore. Quindi, in Python 3, l'esempio sopra (dopo la modifica per usare print (x) :-) stamperà 'prima', dimostrando che la 'x' nella comprensione dell'elenco si ombreggia temporaneamente ma non sovrascrive la 'x' circostante scopo.

Sì, le comprensioni delle liste "perdono" la loro variabile in Python 2.x, proprio come i cicli for.

In retrospettiva, questo è stato riconosciuto come un errore ed è stato evitato con espressioni generatrici. EDIT: Come osserva Matt B. è stato anche evitato quando le sintassi di comprensione di set e dizionari venivano backported da Python 3.

Il comportamento delle liste di comprensione doveva essere lasciato com'è in Python 2, ma è stato completamente risolto in Python 3.

Ciò significa che in tutto:

list(x for x in a if x>32)
set(x//4 for x in a if x>32)         # just another generator exp.
dict((x, x//16) for x in a if x>32)  # yet another generator exp.
{x//4 for x in a if x>32}            # 2.7+ syntax
{x: x//16 for x in a if x>32}        # 2.7+ syntax

l' xè sempre locale per l'espressione mentre questi:

[x for x in a if x>32]
set([x//4 for x in a if x>32])         # just another list comp.
dict([(x, x//16) for x in a if x>32])  # yet another list comp.

in Python 2.x tutte le xvariabili perdono nello scope circostante.

AGGIORNAMENTO per Python 3.8 (?) : PEP 572 introdurrà un :=operatore di assegnazione che fuoriesce deliberatamente dalle comprensioni e dalle espressioni del generatore! È motivato essenzialmente da 2 casi d'uso: acquisire un "testimone" da funzioni di terminazione anticipata come any()e all():

if any((comment := line).startswith('#') for line in lines):
    print("First comment:", comment)
else:
    print("There are no comments")

e aggiornamento dello stato mutevole:

total = 0
partial_sums = [total := total + v for v in values]

Vedere l' Appendice B per l'esatto ambito. La variabile è assegnata nell'ambiente più vicino defo lambda, a meno che la funzione non la dichiari nonlocalo global.

Sì, l'assegnazione avviene lì, proprio come accadrebbe in un forciclo. Non viene creato alcun nuovo ambito.

Questo è sicuramente il comportamento previsto: ad ogni ciclo, il valore è vincolato al nome specificato. Per esempio,

>>> x=0
>>> a=[1,54,4,2,32,234,5234,]
>>> [x for x in a if x>32]
[54, 234, 5234]
>>> x
5234

Una volta riconosciuto, sembra abbastanza facile da evitare: non utilizzare nomi esistenti per le variabili all'interno delle comprensioni.

È interessante notare che questo non influisce sul dizionario o sulla comprensione dell'insieme.

>>> [x for x in range(1, 10)]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x
9
>>> {x for x in range(1, 5)}
set([1, 2, 3, 4])
>>> x
9
>>> {x:x for x in range(1, 100)}
{1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, 96: 96, 97: 97, 98: 98, 99: 99}
>>> x
9

Tuttavia è stato risolto in 3 come indicato sopra.

qualche soluzione alternativa, per python 2.6, quando questo comportamento non è desiderabile

# python
Python 2.6.6 (r266:84292, Aug  9 2016, 06:11:56)
Type "help", "copyright", "credits" or "license" for more information.
>>> x=0
>>> a=list(x for x in xrange(9))
>>> x
0
>>> a=[x for x in xrange(9)]
>>> x
8

In python3, mentre si trova nella comprensione delle liste, la variabile non viene modificata una volta terminato l'ambito, ma quando si usa il semplice ciclo for la variabile viene riassegnata fuori dall'ambito.

i = 1 print (i) print ([i nell'intervallo (5)]) print (i) Il valore di i rimarrà solo 1.

Ora usa semplicemente for loop il valore di i verrà riassegnato.