¿Cómo convertir la representación de cadena de la lista en una lista?

Me preguntaba cuál es la forma más sencilla de convertir una stringlista como la siguiente a list:

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

Incluso en caso de que el usuario ponga espacios entre las comas y espacios dentro de las comillas. Necesito manejar eso también para:

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

en Python

Sé que puedo eliminar espacios con strip()y split()usando el operador dividido y verificar si no hay alfabetos. Pero el código se estaba volviendo muy torpe. ¿Hay alguna función rápida que no conozca?

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

Con ast.literal_eval, puede evaluar de forma segura un nodo de expresión o una cadena que contiene una expresión de Python. La cadena o nodo proporcionado solo puede consistir en las siguientes estructuras literales de Python: cadenas, números, tuplas, listas, dictos, booleanos y Ninguno.

El jsonmódulo es una mejor solución siempre que haya una lista de diccionarios en cadena . La json.loads(your_data)función se puede usar para convertirla en una lista.

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

similar

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

El evales peligroso: no debe ejecutar la entrada del usuario.

Si tiene 2.6 o más reciente, use ast en lugar de eval:

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

Una vez que tienes eso, striplas cuerdas.

Si estás en una versión anterior de Python, puedes acercarte mucho a lo que quieres con una simple expresión regular:

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

Esto no es tan bueno como la solución ast, por ejemplo, no maneja correctamente las comillas escapadas en cadenas. Pero es simple, no implica una evaluación peligrosa, y podría ser lo suficientemente bueno para su propósito si está en una Python más antigua sin ast.

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

Hay una solución rápida:

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

Los espacios en blanco no deseados en los elementos de la lista se pueden eliminar de esta manera:

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

Inspirado en algunas de las respuestas anteriores que funcionan con paquetes básicos de Python, comparé el rendimiento de algunos (usando Python 3.7.3):

Método 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

Método 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

Método 3: no importar

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

Me decepcionó ver lo que consideraba que el método con la peor legibilidad era el método con el mejor rendimiento ... hay compensaciones a tener en cuenta al elegir la opción más legible ... para el tipo de cargas de trabajo para las que uso Python. valor de lectura sobre una opción ligeramente más eficiente, pero como siempre depende.

Si es solo una lista unidimensional, esto se puede hacer sin importar nada:

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

Asumiendo que todas sus entradas son listas y que las comillas dobles en la entrada en realidad no importan, esto se puede hacer con un simple regexp replace. Es un poco perl-y pero funciona como un encanto. Tenga en cuenta también que el resultado ahora es una lista de cadenas unicode, no especificó que lo necesitaba, pero parece tener sentido dada la entrada 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']

La variable junkers contiene una expresión regular compilada (para la velocidad) de todos los caracteres que no queremos, usando] como carácter requirió algunos trucos de barra invertida. El re.sub reemplaza todos estos caracteres con nada, y dividimos la cadena resultante en las comas.

Tenga en cuenta que esto también elimina espacios de las entradas internas u '["oh no"]' ---> [u'ohno ']. Si esto no es lo que querías, la expresión regular debe mejorarse un poco.

Si sabe que sus listas solo contienen cadenas entre comillas, este ejemplo de pyparsing le dará su lista de cadenas despojadas (incluso conservando la Unicode-ness original).

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

Si sus listas pueden tener más tipos de datos, o incluso contener listas dentro de las listas, necesitará una gramática más completa, como esta en el wiki de pyparsing, que manejará tuplas, listas, ints, flotantes y cadenas entre comillas. Funcionará con versiones de Python de nuevo a 2.4

Para completar aún más la respuesta de @Ryan usando json, una función muy conveniente para convertir Unicode es la publicada aquí: https://stackoverflow.com/a/13105359/7599285

ex con comillas dobles o simples:

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

Me gustaría proporcionar una solución de patrones más intuitiva con regex. La siguiente función toma como entrada una lista en cadena que contiene cadenas arbitrarias.

Explicación por pasos: elimina todos los espacios en blanco, los corchetes y los separadores de valores (siempre que no sean parte de los valores que desea extraer, de lo contrario, hacen que la expresión regular sea más compleja). Luego divide la cadena limpia entre comillas simples o dobles y toma los valores no vacíos (o valores indexados impares, sea cual sea la preferencia).

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

muestra de prueba : "['21'," foo "'6', '0'," A "]"

y con Python puro: no importar ninguna biblioteca

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

Puede encontrarse con este problema al tratar con datos raspados almacenados como Pandas DataFrame.

Esta solución funciona como un encanto si la lista de valores está presente como texto .

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

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

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

No se requiere biblioteca externa.

Entonces, siguiendo todas las respuestas, decidí cronometrar los métodos más comunes:

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

¡Así que al final regex gana!

puede guardarse el .strip () fcn simplemente cortando el primer y el último carácter de la representación de cadena de la lista (consulte la tercera línea a continuación)

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