For in Pythonic Way

[gulper]

Moin,

Ja ich bin Anfänger, aber vor Allem Umsteiger und Wiedereinsteiger.
Und ich komme mit meinen Tutorials bei dieser Frage nicht weiter.
Mit Python und seinen Spezifika bin ich noch nicht wirklich vertraut.
Der folgende Codeteil funktioniert zwar, scheint mir aber keinesfalls Pythonic, wie ihr das so gerne ausdrückt.

Code: Alles auswählen

def convlist(arr):
    for i in range(0,len(arr)):
        arr[i][1]=min2h(arr[i][1])
    return arr

Eigentlich soll in einer Liste von Listen nur jedes 2 te. Listenelement in eine Funktion hineingegeben werden und ersetzt werden.
Das muss doch eigentlich viel eleganter gehen.
Die folgende Idee scheitert schon daran den Wert zurückzugeben und zu überschreiben

Code: Alles auswählen

for l in arr:  
    l[1]=min2h(l[1])

Womit kann ich das vereinfachen, und wie muss ich weitersuchen?
Evtl. hat ja auch einer einen Ein- oder Zweizeiler, an dem weiterlernen kann?

Gruß

[__deets__]

Also erst mal ist es unpythonisch, Datenstrukturen zu veraendern, statt neue Datenstrukturen mit veraenderten Werten zu produzieren. Das reduziert dann naemlich deutlich die Menge der Fehler, weil eine Funktion das, was sie gemacht, zurueckgibt, statt ein uebergebenes Argument still und heimlich zu veraendern. Und was man, *wenn* man schon so arbeiten, *niemals* macht, ist dieses veraenderte Argument dann auch noch zurueck zu geben, weil das die Erwartung weckt, dass es sich um eine neue Datenstruktur handelt. ZB der Grund, warum list.sort *None* zurueckgibt, und man stattdessen

Code: Alles auswählen

neu = sorted(alt)

benutzt.

Und prinzipiell sehe ich da keinen Grund, warum dein zweites Snippet da nicht hilft, denn fuer mich geht das problemlos. Einmal schlecht zur illustration, und einmal besser:

Code: Alles auswählen

import pprint

def new_value(v):
    return v * 2


def transform_bad(l):
    for item in l:
        item[1] = new_value(item[1])


def make_new(item):
    return [item[0], new_value(item[1])]

def transform_good(l):
    return [make_new(item) for item in l]

def main():
    l = [
        [0, 1],
        [1, 1],
        [2, 1],
    ]
    transform_bad(l)
    pprint.pprint(l)
    new_l = transform_good(l)
    pprint.pprint(l) # unmodified
    pprint.pprint(new_l)

# main guard
if __name__ == '__main__':
    main()

Man kann make_new jetzt auch zB durch ein lambda ersetzen, um es zu inlinen, aber lesbarer ist in meinen Augen besser.

Zu guter Letzt ist eine Liste von Listen dieser Art eher ungewoehnlich, es klingt eher nach einer Liste von Tupeln (die man dann auch passenderweise nicht veraendern kann), oder gar gleich eine Liste von Objekten, wobei man ja mit namedtuple oder attrs sich sowas leichtgewichtig bauen kann.

[gulper]

Danke, das hat mir schon einiges Weitergeholfen.
1) eher neue Struktur erzeugen
2) Auf dem Weg zu Listen von Objekten bin ich noch nicht angekommen. Da steuere ich aber schon drauf zu.
3) So langsam wird mir endlich auch der praktische Unterschied Liste / Tupel klar . Da bin ich nicht so richtig mit klargekommen. Es zu lesen und dann zu sehen ist einfach Zweierlei.

Absolut riesiges Danke.

[pillmuncher]

Es gibt in Python das sog. Iterable Unpacking:

Code: Alles auswählen

a, b, c = [1, 2, 3]

Das kann man sich auch in List Comprehensions zunutze machen:

Code: Alles auswählen

def minh2h(value):
    ...

def main():
    old_pairs = [...]
    new_pairs = [[first, minh2h(second)] for first, second in old_pairs]
    ...

if __name__ == '__main__':
    main()

[__blackjack__]

@gulper: Ein bisschen sinnlose Korinthenkackerei zu 2): Da in Python jeder Wert ein Objekt ist, hattest Du schon Listen mit Objekten. Nur noch keine mit Objekten von einem Typ den Du selbst geschrieben hast.