Wie funktioniert die str(Liste) arbeiten?

Warum str(list) gibt, wie wir sehen Liste auf der Konsole? Wie funktioniert str(list) Arbeit? (jede Bezugnahme auf den CPython-code für str(list))?

>>> x = ['abc', 'def', 'ghi']
>>> str(x)
"['abc', 'def', 'ghi']"

Um die ursprüngliche Liste wieder von der str(list) ich:

>>> from ast import literal_eval
>>> x = ['abc', 'def', 'ghi']
>>> str(x)
"['abc', 'def', 'ghi']"
>>> list(str(x))
['[', "'", 'a', 'b', 'c', "'", ',', ' ', "'", 'd', 'e', 'f', "'", ',', ' ', "'", 'g', 'h', 'i', "'", ']']
>>> literal_eval(str(x))
['abc', 'def', 'ghi']

Warum nicht list(str(list)) stellt sich die str(list) zurück zu der ursprünglichen Liste?

Oder die ich verwenden könnte:

>>> eval(str(x))
['abc', 'def', 'ghi']

Ist literal_eval das gleiche wie eval? Ist eval sicher zu verwenden?

Wie oft kann ich Folgendes tun? Macht den code brechen, wenn es tut immer str(list(str(list))))? E. g.

>>> x = 'abc'
>>> list(x)
['a', 'b', 'c']
>>> str(list(x))
"['a', 'b', 'c']"
>>> list(str(list(x)))
['[', "'", 'a', "'", ',', ' ', "'", 'b', "'", ',', ' ', "'", 'c', "'", ']']
>>> str(list(str(list(x))))
'[\'[\', "\'", \'a\', "\'", \',\', \' \', "\'", \'b\', "\'", \',\', \' \', "\'", \'c\', "\'", \']\']'
>>> list(str(list(str(list(x)))))
['[', "'", '[', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", 'a', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", 'b', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", 'c', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ']', "'", ']']
>>> str(list(str(list(str(list(x))))))
'[\'[\', "\'", \'[\', "\'", \',\', \' \', \'"\', "\'", \'"\', \',\', \' \', "\'", \'a\', "\'", \',\', \' \', \'"\', "\'", \'"\', \',\', \' \', "\'", \',\', "\'", \',\', \' \', "\'", \' \', "\'", \',\', \' \', \'"\', "\'", \'"\', \',\', \' \', "\'", \'b\', "\'", \',\', \' \', \'"\', "\'", \'"\', \',\', \' \', "\'", \',\', "\'", \',\', \' \', "\'", \' \', "\'", \',\', \' \', \'"\', "\'", \'"\', \',\', \' \', "\'", \'c\', "\'", \',\', \' \', \'"\', "\'", \'"\', \',\', \' \', "\'", \']\', "\'", \']\']'
>>> list(str(list(str(list(str(list(x)))))))
['[', "'", '[', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", '[', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', "'", '"', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", '"', "'", ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", 'a', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', "'", '"', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", '"', "'", ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', "'", '"', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", '"', "'", ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", 'b', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', "'", '"', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", '"', "'", ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', "'", '"', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", '"', "'", ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", 'c', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', "'", '"', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", '"', "'", ',', ' ', "'", ',', "'", ',', ' ', "'", ' ', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ']', "'", ',', ' ', '"', "'", '"', ',', ' ', "'", ']', "'", ']']

Anscheinend haben Sie die Erwartung, dass die Schaffung eines string aus einer Liste rund um trippable. Es ist nicht vorgesehen; die Listen sind nicht end-user-vorzeigbar Objekte, und Sie erhalten die gleiche Ausgabe wie repr(listobject); debug-Informationen für Entwickler Verbrauch nur.
Listen nicht __str__ Methode überhaupt, seine tp_str slot ist tatsächlich leer. Also, statt seine tp_repr - slot wird verwendet, um die repr Darstellung der Liste und Ihre Elemente(einschließlich cylic Objekten): hg.python.org/cpython/file/e8783c581928/Objects/...

InformationsquelleAutor alvas | 2015-05-07

59

Gut, Sie haben insgesamt 4 Fragen, lassen Sie uns gehen Sie eins nach dem anderen.

1. Warum str(list) gibt, wie wir sehen list auf der Konsole? Wie funktioniert str(list) Arbeit?

Was ist str() und __str__()?

Den str() aufrufbar ist die Rückgabe einer druckbare form des Objekts nur! Aus der docs

str(object) nicht immer versuchen, einen string zurückgeben, der ist
akzeptabel eval(); Ihr Ziel ist die Rückgabe einer druckbaren string.

Den __str__() Funktion in einer Klasse wird aufgerufen, Wann immer Sie nennen str() auf ein Objekt. Wieder aus der Dokumentation

object.__str__(self)

Genannt, die von der str() built-in-Funktion und die print - Anweisung zur Berechnung des "informellen" string-Darstellung eines Objekts.

Was ist der list aufrufbar?

Den list() aufrufbar ist das erstellen einer Liste aus einer iterierbar als argument übergeben. Wieder aus der docs

Rückkehr eine list deren Elemente sind die gleichen und in der gleichen Reihenfolge wie
wiederholenden items

So str(list) gibt Ihnen eine druckbare form und list(str(list)) iteriert über die Schnur. Das ist list(str(list)) wird Ihnen eine Liste der einzelnen Zeichen der die druckbare form des Arguments übergeben.

Einem kleinen Spaziergang-durch zwischen der verschachtelten Aufrufe,

Gegebenen Liste l = ['a','b'] _{(Entschuldigung für die kleineren als Beispiel, dass in deiner Frage)}.

Beim Aufruf str(l) gibt es eine druckbare form der Liste l, das ist "['a','b']".

Nun kann man deutlich sehen, dass "['a','b']" ist ein string und ist in der Tat ein iterierbar. Wenn Sie jetzt anrufen list auf dieser also list("['a','b']") Sie bekommen eine komische Liste wie ['[', "'", 'a', "'", ',', "'", 'b', "'", ']']. Warum geschieht dies? Dies geschieht, weil der string iteriert über seine Charaktere, Sie können dies testen, indem mithilfe einer dummy-string,
```
>>> 'dummy'
'dummy'
>>> list('dummy')
['d', 'u', 'm', 'm', 'y']
```
So, wenn Sie rufen Sie die list auf einen string bekommen Sie eine Liste der Zeichen. Beachten Sie, dass die hier wieder auf, wenn Sie anrufen str() auf list('dummy') Sie nicht wieder Ihre ursprüngliche string 'dummy' so wieder werden kann, müssen Sie join! So erinnert die gleiche Funktion wird NICHT bekommen Sie wieder Ihre ursprüngliche Objekt!

Also, Aufruf str() über eine Liste nennt die builtin __str__() - Methode der Liste?

Die Antwort ist NEIN!

Was passiert intern, wenn Sie anrufen str() auf eine Liste?

Wann immer Sie nennen str() auf ein list-Objekt, mit den Schritten gefolgt sind
1. Rufen Sie die repr() jedes element in der Liste.
2. Fügen Sie ein schickes [ an der front und ein weiterer ] am Ende der Liste.
3. Kommen alle von Ihnen mit einem Komma.
~~Wie Sie sehen können aus dem source-code von der Liste Objekt in cpython auf github.~~ Gehen, durch, den Quellcode in cpython hg.python, das ist klar, können Sie die folgenden drei Kommentare. _{(Dank Ashwini für den link auf, dass insbesondere code)}
```
/* Do repr() on each element.  Note that this may mutate the list,
   so must refetch the list size on each iteration. */ line (382)

/* Add "[]" decorations to the first and last items. */ line (398)

/* Paste them all together with ", " between. */ line (418)
```
Diese entsprechen den Punkten, die ich oben erwähnt.

Nun, was ist repr()?

repr() druckt das string-Darstellung von Objekten. Wieder aus der Dokumentation

Return einen string, der die druckbare Darstellung eines Objekts.

und beachten Sie auch diesen Satz!

Für viele Arten, diese Funktion macht einen Versuch, einen string zurückgeben
das ergäbe ein Objekt mit dem gleichen Wert zu übergeben eval(),
ansonsten ist die Darstellung einer Zeichenfolge in Spitzen Klammern
enthält der name und der Typ der das Objekt zusammen mit
zusätzliche Informationen, die oft auch den Namen und die Adresse des
Objekt.

- Und nun Ihre zweite Frage hier,

2. Warum nicht list(str(list)) stellt sich die str(list) zurück zu der ursprünglichen Liste?

Intern str(list) tatsächlich schafft die repr() Darstellung des list-Objekts. Also, um wieder die Liste nach dem Aufruf str auf der Liste, die Sie wirklich brauchen, zu tun eval auf es und nicht eine list nennen.

Workarounds

Aber wir alle wissen, dass eval das böse, also was ist/sind der workaround(s)?

1. Mit literal_eval

Den ersten work-around wäre, die Nutzung ast.literal_eval. Das bringt uns zu deiner 3. Frage,

3. Ist literal_eval() das gleiche wie eval()? Ist eval() sicher zu verwenden?

ast.literal_eval() ist sicher im Gegensatz zu die eval() Funktion. Die docs sich erwähnen, dass es sicher ist -

Sicher einen Ausdruck auszuwerten Knoten oder einem string, der einen Python-literal oder container-Darstellung

2. Verwendung von string-Funktionen und gelieferten

Anderen workaround gemacht werden kann str.split()
```
>>> x = ['abc', 'def', 'ghi']
>>> a = str(x)
>>> a[2:-2].split("', '")
['abc', 'def', 'ghi']
```
Dies ist nur eine einfache Art und Weise zu tun, die für eine Liste von strings. Für eine Liste von Integer-zahlen müssen Sie map.
```
>>> x = [1,2,3]
>>> a =str(x)
>>> list(map(int,a[1:-1].split(', '))) # No need for list call in Py2
[1, 2, 3]
```
Somit im Gegensatz zu literal_eval diese sind einfach hacks gegeben, dass Sie wissen, dass die Elemente der Liste. Wenn Sie sind heterogen in der Natur wie [1, "a", True] dann haben Sie, um eine Schleife durch die Liste split und entdecken Sie das element und geben Sie dann konvertieren Sie Sie und fügen Sie die konvertierte element, um eine endgültige Liste.

Einem anderen Ort, wo dies nicht gelingt, ist, wenn der string selbst enthält Anführungszeichen. Wie bereits erwähnt, durch nneonneo in einem Kommentar

Den str.split Lösung ist sehr zerbrechlich und bricht, wenn die Eingabe enthält z.B. strings, die ", " oder Tupel, oder andere Listen, ... Es ist viel besser zu bedienen ast.literal_eval da, der sich mit allen Feinheiten der syntax.

Und für Ihre Letzte Frage,

4. Macht den code brechen, wenn Sie tun str(list(str(list)))) wieder und wieder?

Nicht wirklich. Die Ausgabe wird wachsen länger und länger, als jedes mal, wenn Sie erstellen ein list einer str und dann wieder immer die druckbare version. Die Beschränkung ist Ihre physikalische Maschine Einschränkung nur. (die werden bald erreicht, da jeder Schritt die Länge des Strings ist, multipliziert mit 5.)
- Über das Was passiert intern, wenn Sie anrufen str auf eine list? Teil, warum nicht tun, 3 vor 2 wie ', '.join(i.__repr__() for i in l).join('[]')?
- 1. Leistungsfähigkeit 2. Einfachheit. Es ist einfacher, um die Klammern um die ersten und letzten Elemente auf einmal. Sobald Sie Hinzugefügt werden, die einzelnen Elemente können direkt an _PyString_Join und das Ergebnis zurückgeben. Wie Sie sehen können in deinem Beispiel sind Sie joining zweimal. Durchschnittlich diese Methode funktioniert besser.
- Die str.split Lösung ist sehr zerbrechlich und bricht, wenn die Eingabe enthält z.B. strings, die ", " oder Tupel, oder andere Listen, ... Es ist viel besser zu bedienen ast.literal_eval da, der sich mit allen Feinheiten der syntax.
InformationsquelleAutor Bhargav Rao
6

Anscheinend haben Sie die Erwartung, dass die Schaffung eines string aus einer Liste rund um trippable. Es ist nicht vorgesehen; die Listen sind nicht end-user-vorzeigbar Objekte, und Sie erhalten die gleiche Ausgabe wie repr(listobject); debug-Informationen für Entwickler Verbrauch nur.

Den list() callable erstellt ein neues list-Objekt aus jedem beliebigen wiederholenden Objekt; Python-strings sind iterierbar Herstellung von einzelnen Zeichen, wenn Sie so tun, list(stringobject) erzeugt immer eine Liste mit den einzelnen Zeichen.

Als solche list() wird nie versuchen, zu interpretieren, ein string-argument als Python-syntax; und dies würde auch nicht funktionieren, wenn die ursprüngliche Liste enthaltenen Objekte ohne eine Python-literal-Schreibweise. Nehmen Sie zum Beispiel:
```
>>> def foo(): return 'bar'
... 
>>> alist = [foo]
>>> alist
[<function foo at 0x106c748c0>]
```
Können Sie nicht nehmen, die debug-string-Ausgang und drehen Sie diese zurück in die ursprüngliche Liste, vor allem, wenn Sie diese in einem Python-interpreter dort, wo es nicht auch eine solche Funktion definiert.

InformationsquelleAutor Martijn Pieters
3

Den str() Funktion in python wird verwendet, um einen Wert in eine Zeichenfolge. Die einfache Antwort auf das, was die str() ist eine list ist, dass es erstellt eine string-Darstellung der Liste (die eckigen Klammern und allem).

Als für die list(str(list)) alles, was Sie tun, ist zu erzählen python zu konvertieren, die auf der ursprünglichen Liste in einen string, dann sind Sie aufspaltet, string und legt es in eine Liste, so dass jeder index hat einen Charakter. So könnte man nest list und str Anrufe, so oft wie Sie wollen (vorausgesetzt, Ihr computer über genügend Speicher verfügt).

InformationsquelleAutor NendoTaka

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Was ist `str()` und `str()`?

Was ist der `list` aufrufbar?

Was passiert intern, wenn Sie anrufen `str()` auf eine Liste?

Nun, was ist `repr()`?

Workarounds

1. Mit `literal_eval`

2. Verwendung von string-Funktionen und gelieferten

Was ist str() und __str__()?

Was ist der list aufrufbar?

Was passiert intern, wenn Sie anrufen str() auf eine Liste?

Nun, was ist repr()?