Liste Verständnis, ohne [ ... ] in Python

Beitritt eine Liste:

>>> ''.join([ str(_) for _ in xrange(10) ])
'0123456789'

join müssen ein durchsuchbar.

Offenbar join's argument ist [ str(_) for _ in xrange(10) ], und es ist ein list comprehension.

Schau mal hier:

>>>''.join( str(_) for _ in xrange(10) )
'0123456789'

Nun join's argument ist nur str(_) for _ in xrange(10) keine [], aber das Ergebnis ist das gleiche.

Warum? Tut str(_) for _ in xrange(10) produzieren auch eine Liste oder ein durchsuchbar?

Ich könnte mir vorstellen, dass join ist wahrscheinlich in C geschrieben und läuft somit wesentlich schneller als eine list comprehension... Test-Zeit!
Offenbar, lese ich deine Frage völlig falsch. Es scheint wieder ein generator für mich...
Nur eine Anmerkung: _ hat keine Besondere Bedeutung, es ist eine normale Variablen-Namen. Es wird oft als Wegwerf-Namen, aber das ist nicht der Fall (die variable). Ich würde vermeiden Sie es in einen code (auf diese Weise zumindest).

InformationsquelleAutor Alcott | 2012-01-30

list-comprehension python

57
```
>>>''.join( str(_) for _ in xrange(10) )
```
Dies wird als eine generator-Ausdruck, und erklärt in PEP 289.

Der Hauptunterschied zwischen generator-Ausdrücke und-Liste Verstehens ist, dass die ehemaligen nicht-erstellen der Liste im Speicher.

Beachten Sie, dass es einen Dritten Weg, der Ausdruck geschrieben:
```
''.join(map(str, xrange(10)))
```
- Ich weiß, es lässt sich auch ein generator erzeugen, der durch eine Tupel-ähnlichen Ausdruck, wie ( str(_) for _ in xrange(10) ). Aber ich war verwirrt, warum die () können sein weggelassen, in join, das heißt, der code sollte wie`.join( (str(_) for _ in xrange(10)) ), richtig?
- Ich lese die PEP289, und jetzt weiß ich über generator, danke .
InformationsquelleAutor NPE
123

Den anderen Befragten richtig beantworten, die Sie entdeckt hatte, eine generator-Ausdruck (die eine notation ähnlich der Liste Verstehens, aber ohne die umgebenden eckigen Klammern).

Im Allgemeinen, genexps (wie Sie liebevoll genannt wird) sind mehr Speicher effizient und schneller als Liste Verstehens.

JEDOCH der Fall ''.join() eine Liste Verständnis ist sowohl schneller und mehr Speicher effizient. Der Grund dafür ist, dass join muss zwei Durchgänge über die Daten, so muss man eigentlich eine echte Liste. Wenn Sie es geben, kann es direkt mit Ihrer Arbeit beginnen. Wenn man es genexp statt, es kann nicht anfangen zu arbeiten, bis er baut eine neue Liste im Speicher durch ausführen der genexp bis zur Erschöpfung:
```
~ $ python -m timeit '"".join(str(n) for n in xrange(1000))'
1000 loops, best of 3: 335 usec per loop
~ $ python -m timeit '"".join([str(n) for n in xrange(1000)])'
1000 loops, best of 3: 288 usec per loop
```
Das gleiche Ergebnis gilt, wenn der Vergleich itertools.imap versus Karte:
```
~ $ python -m timeit -s'from itertools import imap' '"".join(imap(str, xrange(1000)))'
1000 loops, best of 3: 220 usec per loop
~ $ python -m timeit '"".join(map(str, xrange(1000)))'
1000 loops, best of 3: 212 usec per loop
```
- Seltsam, ich bekomme das entgegengesetzte Ergebnis für "".join(l). Ich benutze timeit einrichten, um l entweder [str(n) for n in xrange(1000)] oder (x for x in [str(n) for n in xrange(1000)]). Ergebnisse: 21.7 usec und 1,55 usec, beziehungsweise. iter([str(n) for n in xrange(1000)]) ist noch schneller: 0.87 usec.
- Ihre zweite timing ist dabei zu viel Arbeit. Don ' T wickeln ein genexp um eine listcomp -- verwenden Sie einfach ein genexp direkt. Kein Wunder, du hast seltsame timings.
- In eine Anstrengung, um die Zeit nur join, ich habe alles außer "".join(l) im setup-Anweisung. Und darin liegt das problem -- die genexp war erschöpft, auf die erste Schleife, so dass die nächste 999999 mal trat er eine leere genexp. Kein Wunder, es war schnell.
- Können Sie erklären, warum ''.join() braucht 2 Pässe über den iterator erstellen Sie eine Zeichenfolge?
- Ich denke, der erste Durchlauf ist die Summe der Längen der strings, so wie zuordnen zu können die richtige Menge an Speicher für das verkettete Zeichenfolge, während das zweite Durchlauf ist, kopieren Sie die einzelnen Saiten in den zugewiesenen Raum.
- Denke mal, dass ist richtig. Das ist genau das, was str.mitmachen tut 🙂
- Python 3.3 erscheint deutlich langsamer an diese (wie 40-50% langsamer)
- Unicode-überall kommt nicht ohne Kosten.
- Manchmal vermisse ich wirklich die Fähigkeit, "Favorit" eine spezifische Antwort auf ALSO.
- Was meinst du mit list comprehension wird mehr Speicher effizient hier? Die genexp hat nur O(1) Speicherplatz-overhead, nicht wahr? Scheint kaum der Rede Wert. Oder bin ich mit Blick auf etwas anderes?
- FWIW, die Speicher-Unterschiede sind nicht das gleiche in Python 3, da eine Python-3-Liste comp schafft einen neuen Bereich, während in Python 2 eine Liste comp läuft in den umgebenden Bereich.
InformationsquelleAutor Raymond Hettinger
5

Dein zweites Beispiel verwendet ein generator-Ausdruck anstatt einer Liste erfassen. Der Unterschied ist, dass mit der list-comprehension, die Liste ist vollständig errichtet und übergeben .join(). Mit der generator-Ausdruck, Objekte werden erzeugt und verbraucht .join(). Letztere benötigt weniger Speicher und ist grundsätzlich schneller.

Wie es passiert, die Liste Konstruktor wird gerne verbrauchen jede durchsuchbar, darunter ein generator-Ausdruck. Also:
```
[str(n) for n in xrange(10)]
```
ist nur "syntaktischer Zucker" für:
```
list(str(n) for n in xrange(10))
```
In anderen Worten, eine Liste Verständnis ist nur ein generator-Ausdruck, verwandelte sich in eine Liste.
- Sind Sie sicher, Sie sind äquivalent unter der Haube? Timeit sagt: [str(x) for x in xrange(1000)]: 262 usec, list(str(x) for x in xrange(1000)): 304 usec.
- Du hast Recht. Liste der Verständigung schneller. Und dies ist der Grund, warum die Liste Verstehens Leck in Python 2.x. Dies ist, was GVR schrieb: ""Das war ein Artefakt der ursprünglichen Implementierung der Liste Verstehens; es war eine Python' s "dirty little secrets" für die Jahre. Es begann als eine vorsätzliche Kompromisse zu machen Liste Verstehens sagenhaft schnell, und während es war nicht ein häufiges Problem für Anfänger wird es auf jeden Fall gestochen Menschen gelegentlich." python-history.blogspot.com/2010/06/...
- Der Grund, warum die listcomp schneller ist, weil join hat, um eine Liste zu erstellen, bevor Sie mit der Arbeit beginnen. Das "Leck" auf den Sie sich beziehen, ist nicht ein speed-Problem-es bedeutet nur, dass der loop induction variable ausgesetzt ist, außerhalb der listcomp.
- Dann, was diese Wort bedeuten: "Es begann als ein vorsätzliche Kompromisse zu machen Liste Verstehens sagenhaft schnelle"? Wie ich verstanden habe gibt es eine Verbindung der Leckage mit der Geschwindigkeit Probleme. GVR schrieb auch: "Für generator-Ausdrücke könnten wir dies nicht tun. Generator-Ausdrücke implementiert sind, mithilfe von Generatoren, deren Ausführung erfordert eine separate Ausführung frame. So generator-Ausdrücke (vor allem, wenn Sie Durchlaufen eine kurze Sequenz) waren weniger effizient als Liste Verstehens."
- Dennoch ist es wichtig, diese Worte von GVR: "Und bevor Sie anfangen sich Gedanken über die Liste Verstehens immer langsam in Python 3: Dank der enormen implementierungsaufwand, die ging in Python 3 um die Dinge zu beschleunigen, im Allgemeinen, beide Liste Verstehens-und generator-Ausdrücke in Python 3 sind tatsächlich schneller als in Python 2! (Und es ist nicht mehr ein Geschwindigkeit Unterschied zwischen den beiden.)"
- Sie haben eine fehlerhafte Sprung vom listcomp detail, warum str.join ausführt, wie es funktioniert. Eine der ersten Zeilen in der str.join code ist seq = PySequence_Fast(orig, ""); - und das ist der einzige Grund, Iteratoren laufen langsamer als die von Listen oder Tupeln, die beim aufrufen str.join(). Sie sind willkommen zum start einer chat-wenn Sie möchten, dass Ihr weiter diskutieren (ich bin der Autor von PEP 289, der Schöpfer der LIST_APPEND opcode, und derjenige, optimiert die list () - Konstruktor, also habe ich einige Vertrautheit mit dem Thema).
- BTW, ich meine nicht zu unterstellen, dass Sie äquivalent sind, unter der Haube -- sicherlich, dass wäre eine Implementierung-spezifische detail-nur so, dass der list-comprehension ist im Grunde ein Sonderfall einer generator expression mit einem kleinen süßen geworfen.
- Ich habe meine zweite Bemerkung in Bezug auf die Erwähnung in der Antwort, die list comprehension ist einfach nur eine "syntaktischen Zucker" für list(*generator expression*). Und alle, die ich kannte, war es auch der Artikel, den ich erwähnt in den Kommentaren. So mein wissen über das Thema ist eher oberflächlich und aus fast der Maxime, die Liste Verstehens in Python 2.x schneller als generator-Ausdrücke. Und Tat nichts, ich weiß, dass ''.join() erfordert die Länge des Objekts, bevor es möglicherweise konstruieren die Zeichenfolge ist und dass in diesem besonderen Fall ist es der Hauptgrund der Verlangsamung.
- Und hier Schreibe ich Kommentare, die mehr aus Neugier. Ich hoffe, es ist interessant, nicht nur für mich! Zumindest ist es nicht offensichtlich, dass ''.join() besser aus mit der Liste Verstehens als generator Ausdruck.
- Noch eine Frage, wenn Sie nichts dagegen haben. So wie ich das verstehe, PySequence_Fast(...) ist fast das gleiche wie tuple(...) oder list(...) (je nach Objekt geliefert als parameter). Wenn wir also rufen ''.join(*generator expression*), die gen.Ausdruck umgewandelt werden, um Tupel. Es ist also fast das gleiche wie ''.join(tuple(*generator expression*)). Aber ''.join(*list comprehension*) ist fast das gleiche wie ''.join(list(*generator expression*)). Der einzige Unterschied zwischen den letzten 2 ist die ehemalige implementiert ist ein bisschen anders, so arbeitet Sie schneller und mit Auslaufen.
- So ''.join(*generator expression*) sich herausstellt, führen fast die gleichen Vorgänge, die von ''.join(*list comprehension*) nur mit dem Unterschied, dass *list comprehension* erstellt eine Liste, bevor es gesendet, die als parameter join, und *generator expression* wird verwendet, um ein Tupel erst nachdem es empfangen join fordert PySequence_Fast auf Sie. Bin ich richtig in meinem denken?
- entspricht ungefähr x if isinstance(x, (list, tuple)) else list(x). In anderen Worten, wenn das argument bereits eine Liste oder Tupel, braucht er nicht zu tun, Arbeit überhaupt. Dies unterscheidet sich von list(x) denen macht immer eine neue Liste.
InformationsquelleAutor kindall
5

Wie erwähnt, ist es ein generator-Ausdruck.

Aus der Dokumentation:

Klammern können weggelassen werden, Anrufe mit nur einem argument. Siehe Abschnitt Aufrufe für das detail.

InformationsquelleAutor monkut
4

Wenn es in Klammern, aber nicht Klammern, es ist technisch einen generator-Ausdruck. Generator-Ausdrücke, die eingeführt wurden in Python 2.4.

http://wiki.python.org/moin/Generators

Den Teil nach der Verknüpfung ( str(_) for _ in xrange(10) ) ist, durch sich selbst, einen generator-Ausdruck. Sie könnten etwas tun wie:
```
mylist = (str(_) for _ in xrange(10))
''.join(mylist)
```
und es bedeutet genau das gleiche, was, die Sie schrieb in der zweiten oben genannten Fall.

Generatoren haben einige sehr interessante Eigenschaften, nicht zuletzt von denen ist, dass Sie am Ende nicht die Zuweisung einer ganzen Liste, wenn Sie es nicht benötigen. Stattdessen eine Funktion wie join "Pumpen" die Elemente aus der generator-Ausdruck ein zu einer Zeit, zu tun, Ihre Arbeit auf der kleinen zwischenteilen.

In Ihrer speziellen Beispiele, die Liste und den generator wahrscheinlich nicht durchführen, furchtbar anders, aber im Allgemeinen bin ich lieber mit generator Ausdrücke (und auch die generator-Funktionen) Wann immer ich kann, vor allem, weil es ist äußerst selten für einen generator werden langsamer als eine vollständige Liste Materialisierung.

InformationsquelleAutor sblom
0

Das ist ein generator, sondern als eine Liste Verständnis. Generatoren sind auch iterables, aber anstatt die gesamte Liste zuerst, dann übergeben Sie es zu verbinden, es geht jeder Wert in der xrange eins nach dem anderen, die können sehr viel effizienter.

InformationsquelleAutor Daniel Roseman
0

Dem argument zu Ihrem zweiten join nennen, ist ein generator-Ausdruck. Es produziert ein durchsuchbar.

InformationsquelleAutor Michael J. Barber

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.