Jak przekonwertować reprezentację łańcuchową listy na listę?

The json moduł jest lepszym rozwiązaniem, gdy istnieje stringified lista słowników. Funkcja json.loads(your_data) może być użyta do przekonwertowania jej na listę.

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

Podobnie

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

The eval jest niebezpieczne - nie powinieneś wykonywać danych wejściowych użytkownika.

Jeśli masz 2.6 lub nowszy, użyj ast zamiast eval:

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

Kiedy już to masz, strip struny.

Jeśli korzystasz ze starszej wersji Pythona, możesz bardzo zbliżyć się do tego, co chcesz, używając prostego wyrażenia regularnego:

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

To nie jest tak dobre, jak rozwiązanie ast, na przykład nie obsługuje poprawnie cudzysłowów w łańcuchach. Ale to proste, nie wiąże się z niebezpieczną oceną i może bądź wystarczająco dobry dla swojego celu, jeśli jesteś na starszym Pythonie bez ast.

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

Jest szybkie rozwiązanie:

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

Niechciane spacje w elementach listy mogą zostać usunięte w ten sposób:

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

Zainspirowany niektórymi z powyższych odpowiedzi, które działają z bazowymi pakietami Pythona, porównałem wydajność kilku (używając Pythona 3.7.3):

Metoda 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

Metoda 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

Metoda 3: Brak importu

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

Byłem rozczarowany, widząc, że uznałem metodę o najgorszej czytelności za metodę o najlepszej wydajności... przy wyborze najbardziej czytelnej opcji należy wziąć pod uwagę kompromisy... na Typ obciążeń używam Pythona, ponieważ zwykle cenię czytelność nad nieco bardziej wydajną opcją, ale jak zwykle zależy.

Jeśli jest to tylko lista jednowymiarowa, można to zrobić bez importowania czegokolwiek:

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

Zakładając, że wszystkie dane wejściowe są listami i że podwójne cudzysłowy w danych wejściowych nie mają znaczenia, można to zrobić za pomocą prostego zastępowania wyrażeń regularnych. Jest trochę perl-y, ale działa jak urok. Zauważ również, że wyjście jest teraz listą ciągów unicode, nie określiłeś, że tego potrzebujesz, ale wydaje się to mieć sens, biorąc pod uwagę wejście unicode.

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']

Zmienna junkers zawiera skompilowane Wyrażenie regularne (dla szybkości) wszystkich znaków, których nie chcemy, używając] jako znaku wymaganego sztuczka odwrotnego ukośnika. Re.sub zastępuje wszystkie te znaki niczym, a wynikowy ciąg dzielimy na przecinki.

Zauważ, że usuwa to również spacje z wpisów u ' ["oh no"] '- - - >[u'Ohno']. Jeśli to nie jest to, czego chciałeś, Wyrażenie regularne musi być nieco podrasowane.

Jeśli wiesz, że Twoje listy zawierają tylko cytowane ciągi znaków, ten przykład pyparsingu da ci listę usuniętych ciągów (nawet zachowując oryginalny Unicode-ness).

>>> 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']

Jeśli Twoje listy mogą mieć więcej typów danych, a nawet zawierać listy wewnątrz list, będziesz potrzebował pełniejszej gramatyki tej {[5] } na pyparsing wiki, która będzie obsługiwać krotki, listy, ints, pływaki i cytowane ciągi. Będzie współpracować z wersjami Pythona do wersji 2.4.

Aby uzupełnić odpowiedź @ Ryan za pomocą json, jedną z bardzo wygodnych funkcji do konwersji unicode jest ta zamieszczona tutaj: https://stackoverflow.com/a/13105359/7599285

Ex z podwójnymi lub pojedynczymi cudzysłowami:

>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']

Możesz napotkać taki problem podczas radzenia sobie ze zeskrobanymi danymi przechowywanymi jako ramka danych Pandas.

To rozwiązanie działa jak charm, Jeśli Lista wartości jest obecna jako tekst .

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

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

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

Nie jest wymagana zewnętrzna biblioteka.

Chciałbym zapewnić bardziej intuicyjne rozwiązanie do tworzenia wzorów z regex. Poniższa funkcja przyjmuje jako wejście listę stringified zawierającą dowolne ciągi znaków.

Objaśnienie stopniowe: Usuwasz wszystkie odstępy,bracketing i separatory wartości (pod warunkiem, że nie są one częścią wartości, które chcesz wyodrębnić, w przeciwnym razie regex jest bardziej złożony). Następnie dzielisz oczyszczony ciąg znaków na pojedyncze lub podwójne cudzysłowy i przyjmujesz niepuste wartości (lub nieparzyste wartości indeksowane, niezależnie od preferencje).

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

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

I z czystym Pythonem - nie importowanie żadnych bibliotek

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

Tak więc, podążając za wszystkimi odpowiedziami postanowiłem zmierzyć się z najczęstszymi metodami:

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

Więc w końcu regex wygrywa!

/ Align = "left" / strip() fcn po prostu odcinając pierwszy i ostatni znak z reprezentacji łańcuchowej listy (patrz trzecia linia poniżej)

>>> 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'>