Enumerate

[LisaF]

Hey Leute,

wenn ich diesen Code eingebe

Code: Alles auswählen

my_list = ['apple', 'banana', 'grapes', 'pear']
for counter, value in enumerate(my_list):
    print (counter, value)

kommt ja bekanntlich folgendes raus: # 0 apple
# 1 banana
# 2 grapes
# 3 pear

Wenn ich jedoch enumerate weglasse,

Code: Alles auswählen

 my_list = ['apple', 'banana', 'grapes', 'pear']
for counter in my_list:
    print (counter) 

bekomm ich ja bekanntlich apple banana grapes pear raus. Meine Frage ist nun warum steht counter im 1. code für die Indexzahlen und im 2. Code ohne enumerate für den Inhalt? Dachte der Schlüsselbegriff den man für enumerate wählt steht immer für die Indexzahlen?

[__blackjack__]

@LisaF: Die Frage ist ein bisschen komisch. `enumerate()` erzeugt ja die Zahlen und wenn im zweiten Beispiel kein `enumerate()` verwendet wird, woher sollte denn da die Zahlen kommen? Da kommen dann nur die Elemente von der Liste. Die Frage ist da also eher warum die die Variable `counter` nennst und nicht `value` oder `fruit_name`.

Oder dachtest Du wenn Du den Namen `counter` wählst muss sich Python bemühen was passendes dafür zu generieren? Da würdest Du etwas viel vom Rechner verlangen. Es ist umgekehrt, dem Rechner/Python sind Namen inhaltlich total egal. Die musst Du passend zu den Werten wählen. Und zwar nicht für den Rechner sondern für Dich selbst und andere menschliche Leser.

[sparrow]

@LisaF: Ich verstehe deine Frage nicht, versuche sie aber zu interpretieren.

Wie du eine Variable nennst, ist egal. Ob die nun counter, value, mumpitz oder keksdose heißt. Das hat nichts mit einem Schlüsselwort zu tun.
In deinem zweiten Beispiel iterierst du über die Elemente einer Liste (my_list). Also hat counter je Durchlauf den Wert eines der Elemente.

enumerate ist eine Funktion, der man ein iterierbares Objekt übergibt. Sie gibt ein iterierbares Objekt zurück, das je Durchlauf einen Tupel mit zwei Werten zurück gibt. Den Index und den Wert des übergebenen Objektes.

[LisaF]

Vielen Dank schon mal, ja dass man die Variablennamen frei wählen kann ist mir bekannt, hab das Beispiel aus dem Internet um zu verstehen, wie die Durchläufe bei enumerate sind.
Was ist jetzt genau der Unterschied zwischen

Code: Alles auswählen

my_list = ['apple', 'banana', 'grapes', 'pear']
for counter, value in enumerate(my_list):
    print (counter, value)

und

Code: Alles auswählen

my_list = ['apple', 'banana', 'grapes', 'pear']
for value in enumerate(my_list):
    print (value)

Bei der Ausgabe fehlen beim 1. Code die Klammern, was genau macht das "Counter" im 1. Code, wenn man doch alleine mit enumerate sich eine sortierte Liste ausgeben lassen kann? Wie ist der Durchlauf beim 1. Code?

[sparrow]

In Python gibt es etwas, das nennt man "tuple unpacking". Wenn du einen Tuple mit x Elementen hast, dann kannst du x Namen angeben, an die die einzelnen Werte des Tuples gebunden werden. Das ist, was im ersten Beispiel erfolgt. Du bekomms je Durchlauf einen Tuple aus zwei Werten und bindest die beiden Werte an die Namen "coutner" und "value".
Im zweiten Beispiel bindest du den Tuple an den Namen "value".

[LisaF]

Daaanke das hat mir echt geholfen
noch eine letzte Frage, warum bekomm ich bei diesem Code

Code: Alles auswählen

liste = [3, 6, 123, 54, 127]
for inhalt in enumerate (liste):
    liste [inhalt[0]] = inhalt [1] * 2
print (inhalt)

nur den letzten Tupel ausgegeben (4, 127) ?

[__blackjack__]

@LisaF: Weil das da im Code so steht das nach der Schleife der Wert von `inhalt` ausgegeben werden soll. Was hättest Du da anderes erwartet und warum?

Würde Dich das hier auch wundern?

Code: Alles auswählen

inhalt = (0, 3)
inhalt = (1, 6)
inhalt = (2, 123)
inhalt = (3, 54)
inhalt = (4, 127)
print(inhalt)

Edit: Das ist übrigens ganz fürchterlicher Code, den so niemand schreiben würde. Das wäre:

Code: Alles auswählen

liste = [3, 6, 123, 54, 127]
liste = [wert * 2 for wert i liste]

[Sirius3]

Das ist eine sehr schlechte for-Schleife, weil man einen Index benutzt, um den Inhalt einer Tabelle zu ändern. Statt Listen zu ändern, erzeugt man eine neue Liste:

Code: Alles auswählen

liste = [3, 6, 123, 54, 127]
neue_liste = [zahl*2 for zahl in liste]

Es wird nur der letzte Tuple ausgegeben, weil das `print` nach der Schleife kommt, und dort der letzte Schritt an `inhalt` gebunden bleibt.

[LisaF]

Das istein Beispielcode der zeigen sollte, wie umständlich es ist Werte in einer for Schleife zu ändern, ist aus dem Buch "Python 3, Michael Bonacina". Den Code habe ich leicht abgeändert, hab statt der Liste einfach mal den Inhalt ausgegeben, um zu verstehen wie das Programm da durch läuft. Also macht der Part

Code: Alles auswählen

liste [inhalt[0]] = inhalt [1] * 2

praktisch gar nichts, wenn man sich den Inhalt ausgeben lässt? Was ist hier genau der Unterschied zwischen Liste und Inhalt, warum verändert sich der Wert der Liste, aber nicht der Inhalt?

[__blackjack__]

@LisaF: Der Wert der Liste verändert sich weil da Code steht der den Wert der Liste verändert in dem Elementen in der Liste ein neuer Wert zugewiesen wird. Da steht aber kein Code der `inhalt` verändert. Welcher sollte das denn sein? Zumal `inhalt` ja an Tupel gebunden wird, und eine Eigenschaft von Tupeln gegenüber Listen ist ja gerade, dass man den Wert von einem Tupel gar nicht ändern *kann*.

Und Du gibst den Wert von `inhalt` *einmal* *nach* der Schleife aus. Was hättest Du da denn anderes erwartet, wenn Dich anscheinend überrascht, dass es der eine Wert ist den `inhalt` im letzten Schleifendurchlauf zugewiesen bekommen hat? Also noch einmal die Frage ob Dich die Ausgabe von (4,127) bei diesem Code auch wundert:

Code: Alles auswählen

inhalt = (0, 3)
inhalt = (1, 6)
inhalt = (2, 123)
inhalt = (3, 54)
inhalt = (4, 127)
print(inhalt)

Denn dieser Code ist bezogen auf den Namen `inhalt` das gleiche wie der Effekt den die ``for``-Schleife hat.

[LisaF]

Und Du gibst den Wert von `inhalt` *einmal* *nach* der Schleife aus. Was hättest Du da denn anderes erwartet, wenn Dich anscheinend überrascht, dass es der eine Wert ist den `inhalt` im letzten Schleifendurchlauf zugewiesen bekommen hat? Also noch einmal die Frage ob Dich die Ausgabe von (4,127) bei diesem Code auch wundert:

Code: Alles auswählen

inhalt = (0, 3)
inhalt = (1, 6)
inhalt = (2, 123)
inhalt = (3, 54)
inhalt = (4, 127)
print(inhalt)

Denn dieser Code ist bezogen auf den Namen `inhalt` das gleiche wie der Effekt den die ``for``-Schleife hat.

Okay diesen Teil hab ich verstanden, dass ich den Wert danach nur einmal aufrufe. Aber warum gibt er die 127 aus, wenn ich vorher den Wert in der Liste verdoppelt habe? Sorry dass ich mich jetzt so anstelle, aber ich will wissen was hier genau der Unterschied ist zwischen den Elementen in der Liste und "inhalt"? Inhalt ist an Tupel gebunden, inhalt [0] ist der Index und inhalt [1] ist der Wert, also verdoppel ich den Wert jeder Zahl, also warum bekomm ich dann beim Aufrufen dieser Werte wieder 127 raus?

[sparrow]

@LisaF: Du meinst in deinem letzten Beispielcode? Dem hier?

Code: Alles auswählen

liste = [3, 6, 123, 54, 127]
for inhalt in enumerate (liste):
    liste [inhalt[0]] = inhalt [1] * 2
print (inhalt)

Das hat __blackjack__ bereits erklärt.
Schrei doch mal hinter jede Zeile, was du denkst, was sie tut.
Du verdoppelst da zwar etwas, aber das wird nicht an den Namen 'inhalt' gebunden.

[__deets__]

Oder um das noch mal anders zu illustrieren:

Code: Alles auswählen

ein_ding = 1000
eine_liste = [ein_ding]
ein_ding = 2000
print(ein_ding)
print(eine_liste)

Namen in Python zeigen einfach nur auf ein Objekt, das irgendwo im Speicher ist. Wenn man

Code: Alles auswählen

ein_ding = anderes_objekt

schreibt, dann zeigt ein_ding jetzt auf etwas anderes, nicht mehr auf das Objekt 2000.

Eine Liste zeigt auf eine Reihe von Objekten. Ob die Objekte darin auch von anderen Stellen aus bennannt oder allgemeiner referenziert werden, ist dabei irrelevant. Wenn du jetzt also

Code: Alles auswählen

eine_liste[0] = 12345678

schreibst, dann wird der Wert von ein_ding dadurch nicht beeinflusst.

[LisaF]

Vielen Dank, Ihr seid klasse mit dieser Illustration wird es mir nun klarer.
Könntet Ihr mir vll. nur noch den Durchlauf erklären bei

Code: Alles auswählen

liste [inhalt[0]] = inhalt [1] * 2

nimmt er hier die komplette Liste und multipliziert sie auf einmal mit dem Befehl inhalt[0] oder nimmt er erst die 3*2, 6*2, 123*2 etc. ?
Oder anders gefragt, warum könnte man hier nicht einfach

Code: Alles auswählen

liste = inhalt [1] * 2

schreiben? Denn ich dachte, der Wert der in [1] steht sind die Werte in der Liste und [0] nur die Indexzahlen?

[__deets__]

Aber doch nur EIN Index, und EIN Wert. Wenn du nicht die ganzen anderen Werte verlieren willst, dann geht das so nicht.