Python Variablen Zuweisung in eine for-Schleife

a=[1,2,3]
b=a
a.append(4)
print(b)       #[1,2,3,4]
print(a)       #[1,2,3,4]

Sind Sie hier ändern der Liste. Inhalt der Liste ändert, aber die Liste Identität bleibt.

a=1
b=a
a+=1

Dies ist jedoch eine Umwidmung. Weisen Sie ein anderes Objekt zu a.

Beachten Sie, dass, wenn Sie Tat a += [4] im 1. Beispiel, hättest du gesehen das gleiche Ergebnis. Dies kommt von der Tatsache, dass a += something ist das gleiche wie a = a.__iadd__(something), mit einem fallback auf a = a.__add__(something) wenn __iadd__() existiert nicht.

Der Unterschied ist, dass __iadd__() versucht, seine Arbeit zu tun, "inplace", durch das verändern des Objekts, es funktioniert auf und es wieder. So a bezieht sich auf die gleiche wie vorher. Dies funktioniert nur mit veränderliche Objekte wie Listen.

Auf unveränderliche Objekte wie Ganzzahlen __add__() genannt wird. Es gibt ein anderes Objekt, das führt zu a zeigt auf ein anderes Objekt als zuvor. Es gibt keine andere Wahl, als int-Werte sind unveränderlich.

a,b,c=1,2,3
li=[a,b,c]
for x in li:
    x+=1
print(li)        #[1,2,3]

Hier x += 1 bedeutet das gleiche wie x = x + 1. Es ändert wo x bezieht, aber nicht die Inhalte der Liste.

Vielleicht ist meine Frage sollte sein, wie eine Schleife über eine Liste von Ganzzahlen und wechseln Sie Sie, ohne >anzeigen (), wie muss ich eine if-Anweisung drin.

for i, x in enumerate(li):
    li[i] = x + 1

tritt jede Liste position den alten Wert + 1.

Das wichtigste hier sind die Variablen Namen. Sie sind wirklich nur Schlüssel zu einem Wörterbuch. Sie sind entschlossen, zur Laufzeit, abhängig vom aktuellen Bereich.

Lassen Sie uns einen Blick, welche Namen Sie den Zugang in Ihrem code. Die die einheimischen - Funktion hilft uns dabei: Er zeigt die Namen im lokalen Bereich (und Ihren Wert). Hier ist Ihr code, mit einigen debugging-Ausgabe:

a = [1, 2, 3]       # a is bound
print(locals())
for x in a:         # a is read, and for each iteration x is bound
    x = x + 3       # x is read, the value increased and then bound to x again
    print(locals())
print(locals())
print(x)

(Hinweis: ich ausgebaut x += 3 zu x = x + 3 um die Sichtbarkeit zu erhöhen für den Namen zugreift, Lesen und schreiben.)

Zunächst binden Sie die Liste [1, 2, 3]auf den Namen a. Dann, Sie die Liste Durchlaufen. Während jeder iteration den Wert gebunden ist, den Namen x im aktuellen Bereich. Ihre Aufgabe weist dann einen anderen Wert, um x.

Hier ist die Ausgabe

{'a': [1, 2, 3]}
{'a': [1, 2, 3], 'x': 4}
{'a': [1, 2, 3], 'x': 5}
{'a': [1, 2, 3], 'x': 6}
{'a': [1, 2, 3], 'x': 6}
6

Ohne Punkt sind Sie den Zugriff auf a die Liste, und damit wird sich nie ändern.

Um Ihr problem zu beheben, würde ich verwenden Sie die enumerate-Funktion, um den index zusammen mit dem Wert und klicken Sie dann auf die Liste mit den Namen a zu ändern.

for idx, x in enumerate(a):
    a[idx] = x + 3
print(a)

Ausgabe:

[4, 5, 6]

Hinweis: möchten Sie möglicherweise wickeln Sie diese Beispiele in eine Funktion, um zu vermeiden das überladen globalen namespace.

Mehr über Bereiche, Lesen Sie die Kapitel in der Python-tutorial. Um weiter zu untersuchen, verwenden Sie den globals Funktion zu sehen, die Namen der globalen namespace. (Nicht zu verwechseln mit der global Schlüsselwort, beachten Sie den fehlenden 's'.)

Spaß haben!

Ihre Frage hat mehrere Teile, es wird also schwer sein für eine Antwort auf alle von Ihnen. glglgl hat einen großartigen job gemacht, auf den meisten davon, aber deine Letzte Frage ist noch unerklärt:

Vielleicht ist meine Frage sollte sein, wie eine Schleife über eine Liste von Ganzzahlen und wechseln Sie Sie ohne Karte (), wie muss ich eine if-Anweisung, in der es

"Ich brauche eine if-Anweisung drin" bedeutet nicht, dass Sie nicht verwenden können map.

Zuerst, wenn Sie möchten, dass die if wählen Sie die Werte, die Sie behalten möchten, map hat einen guten Freund namens - filter, was genau das macht. Zum Beispiel, um nur die ungeraden zahlen, aber hinzufügen, um jeden von Ihnen, Sie könnten dies tun:

>>> a = [1, 2, 3, 4, 5]
>>> b = []
>>> for x in a:
...     if x%2:
...         b.append(x+1)

Oder nur dieses:

>>> b = map(lambda x: x+1, filter(lambda x: x%2, a))

Wenn auf der anderen Seite wollen Sie die if zur Steuerung der Ausdruck selbst—z.B., zu ergänzen, 1 die ungeraden zahlen aber lassen Sie auch diejenigen, die allein, Sie können ein if Ausdruck der gleichen Weise, die Sie möchten, verwenden Sie eine if-Anweisung:

>>> for x in a:
...     if x%2:
...         b.append(x+1)
...     else:
...         b.append(x)

>>> b = map(lambda x: x+1 if x%2 else x, a)

Zweite, Verstehens sind im Grunde gleichwertig zum map und filter, aber mit Ausdrücke statt Funktionen. Wenn Ihr Ausdruck nur "diese Funktion aufrufen", dann verwenden Sie map oder filter. Wenn die Funktion wäre einfach ein lambda-Ausdruck auswerten dieses Ausdrucks", dann verwenden Sie ein Verständnis. Die beiden oben genannten Beispiele bekommen mehr lesbar, so:

>>> b = [x+1 for x in a if x%2]
>>> b = [x+1 if x%2 else x for x in a]