neue Liste ohne Tupel aus Liste mit Tupeln erstellen

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
yssob88
User
Beiträge: 6
Registriert: Sonntag 20. Januar 2019, 10:43

Moin,

gibt es eine geschickte Möglichkeit durch einfaches Referenzieren mit Indices aus einer Liste mit Tupeln (x,y-Koordinaten) eine neue Liste (z.B. nur x-Koordinaten, ohne Tupel) zu erstellen, ohne dafür eine Schleife anzuwerfen?

Grüße

Peter
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

mir Ist nicht klar, was dich an der Schleife nun genau stört. Wie sie hinzuschreiben ist? Oder was sie für die Laufzeit bedeutet?
yssob88
User
Beiträge: 6
Registriert: Sonntag 20. Januar 2019, 10:43

Ich finde Schleifen nicht so elegant. Ok, ist natürlich subjektiv. Aber ich würde tatsächlich erwarten, dass es von der Laufzeit schneller wäre keine Schleife zu benutzen. Bei kleinen Listen spielt es natürlich keine Rolle.
nezzcarth
User
Beiträge: 1632
Registriert: Samstag 16. April 2011, 12:47

Für so etwas nimmt man in Python entweder eine List Comprehension (was ja auch eine Schleife ist), oder, wenn etwas mehr Logik benötigt wird, eine reguläre Schleife.

Zum Beispiel:

Code: Alles auswählen

In [1]: l = [(1,2), (3,4), (5,6)]                                                                                                                             

In [2]: m = [x for x,_ in l]                                                                                                                                  

In [3]: m                                                                                                                                                     
Out[3]: [1, 3, 5]

__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

yssob88 hat geschrieben: Sonntag 20. Januar 2019, 14:18 Ich finde Schleifen nicht so elegant. Ok, ist natürlich subjektiv. Aber ich würde tatsächlich erwarten, dass es von der Laufzeit schneller wäre keine Schleife zu benutzen. Bei kleinen Listen spielt es natürlich keine Rolle.
Wenn du etwas n-mal machen willst, dann muss n-mal Code laufen. So ist das halt. Mit wenigen Ausnahmen. Wuerdest du zB numpy benutzen, koenntest du diese Projektion einer Koordinate durch slicing erreichen - dann sieht dann ganze etwas anders aus, weil fuer diesen speziellen Fall einfach intern Schrittweiten beim Zugriff veraendert werden etc. Aber wirklich sparen kannst du dir die notwendigen Rechenschritte normalerweise halt nicht.
yssob88
User
Beiträge: 6
Registriert: Sonntag 20. Januar 2019, 10:43

__deets__ hat geschrieben: Sonntag 20. Januar 2019, 14:41
yssob88 hat geschrieben: Sonntag 20. Januar 2019, 14:18 Ich finde Schleifen nicht so elegant. Ok, ist natürlich subjektiv. Aber ich würde tatsächlich erwarten, dass es von der Laufzeit schneller wäre keine Schleife zu benutzen. Bei kleinen Listen spielt es natürlich keine Rolle.
Wenn du etwas n-mal machen willst, dann muss n-mal Code laufen. So ist das halt. Mit wenigen Ausnahmen. Wuerdest du zB numpy benutzen, koenntest du diese Projektion einer Koordinate durch slicing erreichen - dann sieht dann ganze etwas anders aus, weil fuer diesen speziellen Fall einfach intern Schrittweiten beim Zugriff veraendert werden etc. Aber wirklich sparen kannst du dir die notwendigen Rechenschritte normalerweise halt nicht.
Naja, der Vergleich hinkt etwas. Ich wollte ja genau nicht etwas n-mal machen, sondern geschickt auf bestehende Daten referenzieren.
Aber wenn es dafür keine Möglichkeit gibt, ist es halt so.
Vielen Dank für Eure Antworten. Es geht auch mit Schleife.
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Was willst Du denn machen? Ist es nötig eine neue Liste zu erzeugen? Oder hast Du nur eine Funktion, die sowohl mit x als auch y arbeiten soll und das per Parameter einstellbar? Dann reicht ja ein Index. Oder Du machst einen Generator, oder, oder, oder...
yssob88
User
Beiträge: 6
Registriert: Sonntag 20. Januar 2019, 10:43

Ok. Ich habe das mit dieser speziellen Schleife nachgelesen. Heißt wohl Listen-Abstraktion und ist in Python gebräuchlich.
Habe die Syntax nur noch nicht ganz durchschaut, weil sich die Definition von einer "normalen Schleife" unterscheidet.
yssob88
User
Beiträge: 6
Registriert: Sonntag 20. Januar 2019, 10:43

Wie käme ich denn jetzt an die y -Koordinaten in dem Beispiel von nezzcarth? Ich vermisse den Index im Zugriff auf die Tupel...
yssob88
User
Beiträge: 6
Registriert: Sonntag 20. Januar 2019, 10:43

Hab´s rausgefunden! :-)

Code: Alles auswählen

In [6]: n = [y for _,y in l]                                                                                                   

In [7]: n                                                                                                                      
Out[7]: [2, 4, 6]
Ich würde das gerne aber besser verstehen. Ist in diesem Fall x,_ und _,y auf den Zugriff in Tupeln gedacht, bzw. geht das auch mit anderen Datentypen?

Und wenn ich die x- und y-Daten nach der Manipulation wieder wie im Reißverschluss in die ursprüngliche Form von Tupeln in einer Liste wieder zusammenfügen muss, gibt es dafür auch eine analoge Syntax?

Danke nochmals.
Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@yssob88: Das ist einfach ”tuple unpacking” wie man das auch von Zuweisungen ausserhalb von Schleifen oder „list comprehensions“/Generatorausdrücken her kennt und was eigentlich ”iterable unpacking” heissen müsste, weil es nicht nur mit Tupeln funktioniert, sondern mit jedem iterierbaren Objekt.

Code: Alles auswählen

In [3]: position = (42, 23)

In [4]: x, y = position

In [5]: x
Out[5]: 42

In [6]: y
Out[6]: 23
`_` ist in dem Code von Dir auch ein ganz normaler Name und nicht irgendwie etwas syntaktisch besonderes. Der wird per Konvention benutzt wenn einen der Wert nicht interessiert. Damit sich der Leser nicht wundert warum da ein Name an einen Wert gebunden wird und dann aber nirgends verwendet wird. Das macht deutlich, dass das Absicht ist und nicht ein Fehler im Programm, oder dass das Programm an der Stelle noch nicht ganz fertig ist. Man hätte also auch ``n = [y for x, y in l]`` schreiben können.

Das geht in Python nur mit iterierbaren Objekten und man kann da noch ein bisschen mehr Magie auf der linken Seite der Zuweisung mit Sternchen machen. Beispiel für Magie mit Sternchen:

Code: Alles auswählen

In [7]: r = range(10)

In [8]: r
Out[8]: range(0, 10)

In [9]: x, y, *xs = r

In [10]: x
Out[10]: 0

In [11]: y
Out[11]: 1

In [12]: xs
Out[12]: [2, 3, 4, 5, 6, 7, 8, 9]

In [13]: x, *xs, y = r

In [14]: x
Out[14]: 0

In [15]: y
Out[15]: 9

In [16]: xs
Out[16]: [1, 2, 3, 4, 5, 6, 7, 8]

In [17]: *xs, x, y = r

In [18]: x
Out[18]: 8

In [19]: y
Out[19]: 9

In [20]: xs
Out[20]: [0, 1, 2, 3, 4, 5, 6, 7]
Andere Programmiersprachen können das auch noch mit anderen Datentypen machen, und da Sprachen dazu tendieren immer komplexer zu werden, würde ich mich nicht wundern wenn die bei Python als nächstes etwas für Wörterbücher einbauen. Ähnlich wie CoffeeScript und dann ja auch JavaScript das vormachen.

Edit: Zum wieder zusammenfügen gibt es die `zip()`-Funktion. Eventuell in Verbindung mit `list()` wenn ein Iterator nicht reicht, oder dann gleich in einer „list comprehension“ wenn man mit den zusammengefügten Tupeln noch irgend etwas machen möchte bevor es in einer Liste landet.
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
Antworten