I was wondering what the simplest way is to convert a string representation of a list like the following to a list:

我想知道将如下所示的列表的字符串表示形式转换为列表的最简单方法是什么：

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

Even in cases where the user puts spaces in between the commas, and spaces inside of the quotes, I need to handle that as well and convert it to:

即使在用户将空格放在逗号之间和引号内的情况下，我也需要处理它并将其转换为：

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

I know I can strip spaces with strip() and split() and check for non-letter characters. But the code was getting very kludgy. Is there a quick function that I'm not aware of?

我知道我可以使用strip()和plit()来删除空格，并检查非字母字符。但代码变得非常笨拙。有没有我不知道的快速功能？

优秀答案推荐

>>> import ast
>>> x = '[ "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:

Ast.wen al_eval：

Evaluate an expression node or a string containing only a Python literal or container display. The string or node provided may only consist of the following Python literal structures: strings, bytes, numbers, tuples, lists, dicts, sets, booleans, None and Ellipsis.

This can be used for evaluating strings containing Python values without the need to parse the values oneself. It is not capable of evaluating arbitrarily complex expressions, for example involving operators or indexing.

The json module is a better solution whenever there is a stringified list of dictionaries. The json.loads(your_data) function can be used to convert it to a list.

只要有一个字符串化的词典列表，json模块就是一个更好的解决方案。可以使用json.Loads(YOUR_DATA)函数将其转换为列表。

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

Similarly

类似

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

The eval is dangerous - you shouldn't execute user input.

评估是危险的--您不应该执行用户输入。

If you have 2.6 or newer, use ast instead of eval:

如果您的版本是2.6或更高版本，请使用ast而不是eval：

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

Once you have that, strip the strings.

一旦你有了它，就把绳子脱掉。

If you're on an older version of Python, you can get very close to what you want with a simple regular expression:

如果您使用的是较旧版本的Python，则使用一个简单的正则表达式就可以非常接近您想要的结果：

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

This isn't as good as the ast solution, for example it doesn't correctly handle escaped quotes in strings. But it's simple, doesn't involve a dangerous eval, and might be good enough for your purpose if you're on an older Python without ast.

这不如上一个解决方案好，例如，它不能正确处理字符串中的转义引号。但它很简单，不涉及危险的求值，如果您使用的是没有AST的较旧的Python，那么它可能就足够好了。

Inspired from some of the answers above that work with base Python packages I compared the performance of a few (using Python 3.7.3):

受上面一些适用于基本Python包的答案的启发，我比较了几个包(使用Python3.7.3)的性能：

Method 1: ast

方法一：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

Method 2: json

方法二：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

Method 3: no 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

I was disappointed to see what I considered the method with the worst readability was the method with the best performance... there are trade-offs to consider when going with the most readable option... for the type of workloads I use Python for I usually value readability over a slightly more performant option, but as usual it depends.

我很失望地发现，我认为可读性最差的方法是性能最好的方法……在选择最具可读性的选项时，需要考虑一些权衡因素。对于我使用Python的工作负载类型，我通常更看重可读性，而不是性能稍高的选项，但像往常一样，这取决于。

There is a quick solution:

有一个快速的解决方案：

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

Unwanted whitespaces in the list elements may be removed in this way:

可以通过以下方式删除列表元素中不需要的空格：

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

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

If it's only a one dimensional list, this can be done without importing anything:

如果它只是一个一维列表，则无需导入任何内容即可完成：

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

There isn't any need to import anything or to evaluate. You can do this in one line for most basic use cases, including the one given in the original question.

不需要进口任何东西，也不需要评估。对于大多数基本用例，包括原始问题中给出的用例，您可以在一行中完成此操作。

One liner

l_x = [i.strip() for i in x[1:-1].replace('"',"").split(',')]

Explanation

x = '[ "A","B","C" , " D"]'
# String indexing to eliminate the brackets.
# Replace, as split will otherwise retain the quotes in the returned list
# Split to convert to a list
l_x = x[1:-1].replace('"',"").split(',')

Outputs:

产出：

for i in range(0, len(l_x)):
    print(l_x[i])
# vvvv output vvvvv
'''
 A
B
C
  D
'''
print(type(l_x)) # out: class 'list'
print(len(l_x)) # out: 4

You can parse and clean up this list as needed using list comprehension.

您可以根据需要使用列表理解来解析和清理此列表。

l_x = [i.strip() for i in l_x] # list comprehension to clean up
for i in range(0, len(l_x)):
    print(l_x[i])
# vvvvv output vvvvv
'''
A
B
C
D
'''

Nested lists

If you have nested lists, it does get a bit more annoying. Without using regex (which would simplify the replace), and assuming you want to return a flattened list (and the zen of python says flat is better than nested):

如果你有嵌套列表，它确实会变得有点烦人。不使用正则表达式（这会简化替换），假设你想返回一个扁平的列表（Python的禅宗说扁平比嵌套好）：

x = '[ "A","B","C" , " D", ["E","F","G"]]'
l_x = x[1:-1].split(',')
l_x = [i
    .replace(']', '')
    .replace('[', '')
    .replace('"', '')
    .strip() for i in l_x
]
# returns ['A', 'B', 'C', 'D', 'E', 'F', 'G']

If you need to retain the nested list it gets a bit uglier, but it can still be done just with regular expressions and list comprehension:

如果你需要保留嵌套列表，它会变得有点丑陋，但它仍然可以通过正则表达式和列表解析来完成：

import re

x = '[ "A","B","C" , " D", "["E","F","G"]","Z", "Y", "["H","I","J"]", "K", "L"]'
# Clean it up so the regular expression is simpler
x = x.replace('"', '').replace(' ', '')
# Look ahead for the bracketed text that signifies nested list
l_x = re.split(r',(?=\[[A-Za-z0-9\',]+\])|(?<=\]),', x[1:-1])
print(l_x)
# Flatten and split the non nested list items
l_x0 = [item for items in l_x for item in items.split(',') if not '[' in items]
# Convert the nested lists to lists
l_x1 = [
    i[1:-1].split(',') for i in l_x if '[' in i
]
# Add the two lists
l_x = l_x0 + l_x1

This last solution will work on any list stored as a string, nested or not.

最后一个解决方案适用于以字符串形式存储的任何列表，无论是否嵌套。

You can do this

你可以做到的

**

**

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

**
best one is the accepted answer

**最好的答案是公认的答案

Though this is not a safe way, the best answer is the accepted one.
wasn't aware of the eval danger when answer was posted.

尽管这不是一种安全的方法，但最好的答案是公认的。当答案被发布时，我并没有意识到年龄的危险。

Assuming that all your inputs are lists and that the double quotes in the input actually don't matter, this can be done with a simple regexp replace. It is a bit perl-y, but it works like a charm. Note also that the output is now a list of Unicode strings, you didn't specify that you needed that, but it seems to make sense given Unicode input.

假设您的所有输入都是列表，并且输入中的双引号实际上并不重要，这可以通过一个简单的regexp替换来完成。它有点像Perl-y，但它的作用就像一个护身符。另请注意，输出现在是一个Unicode字符串列表，您没有指定需要它，但在给定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']

The junkers variable contains a compiled regexp (for speed) of all characters we don't want, using ] as a character required some backslash trickery.
The re.sub replaces all these characters with nothing, and we split the resulting string at the commas.

JUNKS变量包含我们不需要的所有字符的已编译regexp(表示速度)，使用]作为字符需要一些反斜杠技巧。Re.sub键将所有这些字符替换为空，并在逗号处拆分生成的字符串。

Note that this also removes spaces from inside entries u'["oh no"]' ---> [u'ohno']. If this is not what you wanted, the regexp needs to be souped up a bit.

注意，这也删除了条目u‘[“oh no”]’->[u‘ohno’]中的空格。如果这不是您想要的，那么regexp需要稍微改进一下。

If you know that your lists only contain quoted strings, this pyparsing example will give you your list of stripped strings (even preserving the original Unicode-ness).

如果您知道您的列表只包含带引号的字符串，则此pyparsing示例将为您提供已删除字符串的列表(甚至保留原始的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']

If your lists can have more datatypes, or even contain lists within lists, then you will need a more complete grammar - like this one in the pyparsing examples directory, which will handle tuples, lists, ints, floats, and quoted strings.

如果您的列表可以有更多的数据类型，甚至在列表中包含列表，那么您将需要一个更完整的语法--就像pyparsing Examples目录中的语法一样，它将处理元组、列表、整数、浮点数和带引号的字符串。

You may run into such problem while dealing with scraped data stored as Pandas DataFrame.

在处理存储为Pandas DataFrame的抓取数据时，您可能会遇到这样的问题。

This solution works like charm if the list of values is present as text.

如果值列表以文本形式显示，则此解决方案的工作方式类似于咒语。

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

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

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

No external library required.

This usually happens when you load list stored as string to CSV

当您将存储为字符串的列表加载到CSV时，通常会发生这种情况

If you have your list stored in CSV in form like OP asked:

如果您的列表以CSV格式存储，如OP询问：

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

Here is how you can load it back to list:

以下是如何将其重新加载到列表中：

import csv
with open('YourCSVFile.csv') as csv_file:
    reader = csv.reader(csv_file, delimiter=',')
    rows = list(reader)

listItems = rows[0]

listItems is now list

ListItems现在是List

To further complete Ryan's answer using JSON, one very convenient function to convert Unicode is in this answer.

为了使用JSON进一步完善Ryan的答案，这个答案中有一个非常方便的转换Unicode的函数。

Example with double or single quotes:

带双引号或单引号的示例：

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

json.loads() and json.dumps() from json package is the equivalent way of javascript JSON.parse() and JSON.stringify() so use json solution to keep life simpler

Json包中的json.ads()和json.ump ps()与JSON.parse()和JSON.stringify()是相同的方式，所以使用json解决方案使工作更简单

import json
a = '[ "A","B","C" , " D"]'
print(json.loads(a)) #['A', 'B', 'C', ' D']
b = ['A', 'B', 'C', ' D']
print(json.dumps(b)) # '["A", "B", "C", " D"]'

I would like to provide a more intuitive patterning solution with regex.
The below function takes as input a stringified list containing arbitrary strings.

我想提供一个更直观的模式解决方案与正则表达式。Below函数将包含任意字符串的字符串化列表作为输入。

Stepwise explanation:
You remove all whitespacing,bracketing and value_separators (provided they are not part of the values you want to extract, else make the regex more complex). Then you split the cleaned string on single or double quotes and take the non-empty values (or odd indexed values, whatever the preference).

分步说明：删除所有空格、括号和VALUE_SESPAING(假设它们不是您想要提取的值的一部分，否则会使正则表达式更加复杂)。然后，将清理后的字符串用单引号或双引号分开，并获取非空值(或奇数索引值，无论您的喜好如何)。

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

测试样本：“'21 '，“foo”' 6'，'0'，“A”]”

So, following all the answers I decided to time the most common methods:

因此，在所有答案之后，我决定对最常见的方法进行计时：

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

So in the end regex wins!

所以，最终正则表达式赢了！

You can save yourself the .strip() function by just slicing off the first and last characters from the string representation of the list (see the third line below):

只需从列表的字符串表示形式中删除第一个和最后一个字符(请参见下面的第三行)，就可以省去.strie()函数：

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

And with pure Python - not importing any libraries:

并且使用纯Python-不导入任何库：

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

This is another solution if you don't want to import any library:

如果您不想导入任何库，这是另一个解决方案：

x = '[ "A","B","C" , " D"]'
def toList(stringList):
  stringList = stringList.split('[')[1]# removes "["
  stringList = stringList.split(']')[0]# removes "]"
  stringList = stringList.split(',')#gets objects in the list
  return [text.strip()[1:-1] for text in stringList] #eliminate additional " or ' in the string.
toList(x)

Output:

产出：

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

The caveat to this method is that it doesn't work if you have comma inside your string for example if your input is

此方法需要注意的是，如果字符串中包含逗号，则此方法不起作用，例如，如果输入为

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

your output will be

您的输出将是

['A', '', '', 'C', ' D']

which is not what you want.

这不是你想要的。

This solution is simpler than some I read in the previous answers, but it requires to match all features of the list.

这个解决方案比我在前面的答案中读到的一些解决方案更简单，但它需要匹配列表的所有功能。

x = '[ "A","B","C" , " D"]'
[i.strip() for i in x.split('"') if len(i.strip().strip(',').strip(']').strip('['))>0]

Output:

产出：

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