Wie konvertiere ich die Zeichenfolgendarstellung einer Liste in eine Liste?

Ich habe mich gefragt, was der einfachste Weg ist, eine stringListe wie die folgende in eine zu konvertieren list:

x = u'[ "A","B","C" , " D"]'

Auch für den Fall, dass der Benutzer Leerzeichen zwischen die Kommas und Leerzeichen innerhalb der Anführungszeichen setzt. Ich muss auch damit umgehen, um:

x = ["A", "B", "C", "D"] 

in Python.

Ich weiß, dass ich mit strip()und split()mit dem Split-Operator Leerzeichen entfernen und nach Nicht-Alphabeten suchen kann. Aber der Code wurde sehr klobig. Gibt es eine schnelle Funktion, die mir nicht bekannt ist?

>>> import ast
>>> x = u'[ "A","B","C" , " D"]'
>>> x = ast.literal_eval(x)
>>> x
['A', 'B', 'C', ' D']
>>> x = [n.strip() for n in x]
>>> x
['A', 'B', 'C', 'D']

ast.literal_eval :

Mit ast.literal_eval können Sie einen Ausdrucksknoten oder eine Zeichenfolge, die einen Python-Ausdruck enthält, sicher auswerten. Die bereitgestellte Zeichenfolge oder der bereitgestellte Knoten besteht möglicherweise nur aus den folgenden Python-Literalstrukturen: Zeichenfolgen, Zahlen, Tupel, Listen, Diktate, Boolesche Werte und Keine.

Das jsonModul ist eine bessere Lösung , wenn es eine ist Zeichenfolge Liste der Wörterbücher. Die json.loads(your_data)Funktion kann verwendet werden, um es in eine Liste zu konvertieren.

>>> import json
>>> x = u'[ "A","B","C" , " D"]'
>>> json.loads(x)
[u'A', u'B', u'C', u' D']

Ähnlich

>>> x = u'[ "A","B","C" , {"D":"E"}]'
>>> json.loads(x)
[u'A', u'B', u'C', {u'D': u'E'}]

Das evalist gefährlich - Sie sollten keine Benutzereingaben ausführen.

Wenn Sie 2.6 oder neuer haben, verwenden Sie ast anstelle von eval:

>>> import ast
>>> ast.literal_eval('["A","B" ,"C" ," D"]')
["A", "B", "C", " D"]

Sobald Sie das haben, stripdie Saiten.

Wenn Sie eine ältere Version von Python verwenden, können Sie mit einem einfachen regulären Ausdruck dem, was Sie wollen, sehr nahe kommen:

>>> x='[  "A",  " B", "C","D "]'
>>> re.findall(r'"\s*([^"]*?)\s*"', x)
['A', 'B', 'C', 'D']

Dies ist nicht so gut wie die ast-Lösung. Beispielsweise werden maskierte Anführungszeichen in Zeichenfolgen nicht korrekt verarbeitet. Aber es ist einfach, beinhaltet keine gefährliche Bewertung und ist möglicherweise gut genug für Ihren Zweck, wenn Sie auf einem älteren Python ohne Ast arbeiten.

import ast
l = ast.literal_eval('[ "A","B","C" , " D"]')
l = [i.strip() for i in l]

Es gibt eine schnelle Lösung:

x = eval('[ "A","B","C" , " D"]')

Unerwünschte Leerzeichen in den Listenelementen können auf folgende Weise entfernt werden:

x = [x.strip() for x in eval('[ "A","B","C" , " D"]')]

Inspiriert von einigen der obigen Antworten, die mit Basis-Python-Paketen funktionieren, habe ich die Leistung einiger weniger verglichen (mit Python 3.7.3):

Methode 1: ast

import ast
list(map(str.strip, ast.literal_eval(u'[ "A","B","C" , " D"]')))
# ['A', 'B', 'C', 'D']

import timeit
timeit.timeit(stmt="list(map(str.strip, ast.literal_eval(u'[ \"A\",\"B\",\"C\" , \" D\"]')))", setup='import ast', number=100000)
# 1.292875313000195

Methode 2: json

import json
list(map(str.strip, json.loads(u'[ "A","B","C" , " D"]')))
# ['A', 'B', 'C', 'D']

import timeit
timeit.timeit(stmt="list(map(str.strip, json.loads(u'[ \"A\",\"B\",\"C\" , \" D\"]')))", setup='import json', number=100000)
# 0.27833264000014424

Methode 3: kein Import

list(map(str.strip, u'[ "A","B","C" , " D"]'.strip('][').replace('"', '').split(',')))
# ['A', 'B', 'C', 'D']

import timeit
timeit.timeit(stmt="list(map(str.strip, u'[ \"A\",\"B\",\"C\" , \" D\"]'.strip('][').replace('\"', '').split(',')))", number=100000)
# 0.12935059100027502

Ich war enttäuscht zu sehen, dass die Methode mit der schlechtesten Lesbarkeit die Methode mit der besten Leistung war. Bei der am besten lesbaren Option sind Kompromisse zu berücksichtigen. Für die Art der Workloads, für die ich normalerweise Python verwende Wert Lesbarkeit über eine etwas leistungsfähigere Option, aber wie üblich hängt es davon ab.

Wenn es sich nur um eine eindimensionale Liste handelt, können Sie dies tun, ohne etwas zu importieren:

>>> x = u'[ "A","B","C" , " D"]'
>>> ls = x.strip('[]').replace('"', '').replace(' ', '').split(',')
>>> ls
['A', 'B', 'C', 'D']

Angenommen, alle Ihre Eingaben sind Listen und die doppelten Anführungszeichen in der Eingabe spielen keine Rolle, kann dies durch einfaches Ersetzen von regulären Ausdrücken erfolgen. Es ist ein bisschen perl-y, funktioniert aber wie ein Zauber. Beachten Sie auch, dass die Ausgabe jetzt eine Liste von Unicode-Zeichenfolgen ist. Sie haben nicht angegeben, dass Sie dies benötigen, aber es scheint angesichts der Unicode-Eingabe sinnvoll zu sein.

import re
x = u'[ "A","B","C" , " D"]'
junkers = re.compile('[[" \]]')
result = junkers.sub('', x).split(',')
print result
--->  [u'A', u'B', u'C', u'D']

Die Junkers-Variable enthält einen kompilierten regulären Ausdruck (für die Geschwindigkeit) aller Zeichen, die wir nicht wollen, wobei] als Zeichen einige Backslash-Tricks erfordert. Das re.sub ersetzt alle diese Zeichen durch nichts, und wir teilen die resultierende Zeichenfolge durch Kommas auf.

Beachten Sie, dass dadurch auch Leerzeichen aus den Einträgen u '["oh nein"]' ---> [u'ohno '] entfernt werden. Wenn dies nicht das ist, was Sie wollten, muss der reguläre Ausdruck etwas aufgemotzt werden.

Wenn Sie wissen, dass Ihre Listen nur Zeichenfolgen in Anführungszeichen enthalten, erhalten Sie in diesem Pyparsing-Beispiel eine Liste der entfernten Zeichenfolgen (wobei sogar die ursprüngliche Unicode-Ness erhalten bleibt).

>>> from pyparsing import *
>>> x =u'[ "A","B","C" , " D"]'
>>> LBR,RBR = map(Suppress,"[]")
>>> qs = quotedString.setParseAction(removeQuotes, lambda t: t[0].strip())
>>> qsList = LBR + delimitedList(qs) + RBR
>>> print qsList.parseString(x).asList()
[u'A', u'B', u'C', u'D']

Wenn Ihre Listen mehr Datentypen haben können oder sogar Listen in Listen enthalten, benötigen Sie eine vollständigere Grammatik - wie diese im Pyparsing-Wiki, die Tupel, Listen, Ints, Floats und Zeichenfolgen in Anführungszeichen verarbeitet. Funktioniert mit Python-Versionen bis 2.4.

Um die Antwort von @Ryan mit json weiter zu vervollständigen, ist eine sehr praktische Funktion zum Konvertieren von Unicode die hier veröffentlichte: https://stackoverflow.com/a/13105359/7599285

Ex mit doppelten oder einfachen Anführungszeichen:

>print byteify(json.loads(u'[ "A","B","C" , " D"]')
>print byteify(json.loads(u"[ 'A','B','C' , ' D']".replace('\'','"')))
['A', 'B', 'C', ' D']
['A', 'B', 'C', ' D']

Ich möchte eine intuitivere Musterlösung mit Regex anbieten. Die folgende Funktion verwendet als Eingabe eine String-Liste, die beliebige Strings enthält.

Schrittweise Erklärung: Sie entfernen alle Leerzeichen, Klammern und Werttrennzeichen (vorausgesetzt, sie sind nicht Teil der Werte, die Sie extrahieren möchten, andernfalls wird der reguläre Ausdruck komplexer). Dann teilen Sie die bereinigte Zeichenfolge in einfache oder doppelte Anführungszeichen und nehmen die nicht leeren Werte (oder ungerade indizierte Werte, unabhängig von der Präferenz).

def parse_strlist(sl):
import re
clean = re.sub("[\[\],\s]","",sl)
splitted = re.split("[\'\"]",clean)
values_only = [s for s in splitted if s != '']
return values_only

Testbeispiel : "['21'," foo "'6', '0'," A "]"

und mit reinem Python - keine Bibliotheken importieren

[x for x in  x.split('[')[1].split(']')[0].split('"')[1:-1] if x not in[',',' , ',', ']]

Möglicherweise treten solche Probleme auf, wenn Sie mit als Pandas DataFrame gespeicherten Daten arbeiten.

Diese Lösung funktioniert wie ein Zauber, wenn die Werteliste als Text vorliegt .

def textToList(hashtags):
    return hashtags.strip('[]').replace('\'', '').replace(' ', '').split(',')

hashtags = "[ 'A','B','C' , ' D']"
hashtags = textToList(hashtags)

Output: ['A', 'B', 'C', 'D']

Keine externe Bibliothek erforderlich.

Nach all den Antworten entschied ich mich, die gängigsten Methoden zu bestimmen:

from time import time
import re
import json


my_str = str(list(range(19)))
print(my_str)

reps = 100000

start = time()
for i in range(0, reps):
    re.findall("\w+", my_str)
print("Regex method:\t", (time() - start) / reps)

start = time()
for i in range(0, reps):
    json.loads(my_str)
print("json method:\t", (time() - start) / reps)

start = time()
for i in range(0, reps):
    ast.literal_eval(my_str)
print("ast method:\t\t", (time() - start) / reps)

start = time()
for i in range(0, reps):
    [n.strip() for n in my_str]
print("strip method:\t", (time() - start) / reps)



    regex method:    6.391477584838867e-07
    json method:     2.535374164581299e-06
    ast method:      2.4425282478332518e-05
    strip method:    4.983267784118653e-06

Am Ende gewinnt also Regex!

Sie können sich den .strip () fcn sparen, indem Sie einfach das erste und das letzte Zeichen aus der Zeichenfolgendarstellung der Liste entfernen (siehe dritte Zeile unten).

>>> mylist=[1,2,3,4,5,'baloney','alfalfa']
>>> strlist=str(mylist)
['1', ' 2', ' 3', ' 4', ' 5', " 'baloney'", " 'alfalfa'"]
>>> mylistfromstring=(strlist[1:-1].split(', '))
>>> mylistfromstring[3]
'4'
>>> for entry in mylistfromstring:
...     print(entry)
...     type(entry)
... 
1
<class 'str'>
2
<class 'str'>
3
<class 'str'>
4
<class 'str'>
5
<class 'str'>
'baloney'
<class 'str'>
'alfalfa'
<class 'str'>