如何将列表的字符串表示形式转换为列表

Question

我想知道，最简单的方法是将以下列表的字符串表示形式转换为list：

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

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

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

我知道我可以用strip（）和split（）剥离空格，并检查非字母字符。但是代码变得非常笨拙。我不知道有一个快速功能吗？

Answer 1

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

评估仅包含python文字或容器显示的表达节点或字符串。所提供的字符串或节点只能由以下python文字结构组成：字符串，字节，数字，元组，列表，列表，dict，sets，booleans，none and eLLIPSIS 。<<。 /p>

这可用于评估包含python值的字符串，而无需自行解析值。它无法评估任意复杂的表达式，例如涉及操作员或索引。

Answer 2

JSON 当有一个更好的解决方案时A 弦乐字典列表。 json.loads（your_data）函数可用于将其转换为列表。

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

相似地

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

Answer 3

eval是危险的 - 您不应执行用户输入。

如果您有2.6或更新，请使用AST而不是eval：

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

一旦拥有，strip字符串。

如果您使用的是较旧版本的Python，则可以通过简单的正则表达式非常接近您想要的内容：

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

它不如AST解决方案，例如，它无法正确处理字符串中的逃脱引号。但这很简单，不涉及危险的评估，如果您在没有AST的较旧的python上，则可能足以满足您的目的。

Answer 4

有一个快速的解决方案：

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

列表元素中有害的白空间可以以这种方式删除：

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

Answer 5

从上面的一些答案中启发了与基本Python软件包一起使用的答案，我比较了少数的性能（使用Python 3.7.3）：

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

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

方法3：没有进口

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

我很失望地看到我认为最糟糕的可读性的方法是具有最佳性能的方法...在使用最可读的选项时，有权衡需要考虑...对于工作负载的类型，我通常使用Python，因为我通常将可读性评估为性能稍高的选项，但是像往常一样，它取决于。

Answer 6

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

Answer 7

如果仅是一个维度列表，则可以在不导入任何内容的情况下完成：

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

Answer 8

无需导入任何东西或评估。您可以在大多数基本用例中以一行进行此操作，包括原始问题中给出的用例。

一个衬里

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

说明

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(',')

输出：

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

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

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

嵌套列表，

如果您的列表列表，它确实会变得更加烦人。不使用正则施法（可以简化替换），并假设您想返回一个扁平的列表（以及 Zen说平面比嵌套）：

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

如果您需要保留嵌套列表，则会变得有些丑陋，但是只能使用正则表达式并列表理解：最后一个解决方案将会完成：

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

这个最后的解决方案将会在存储为字符串的任何列表上工作，无论是否嵌套。

Answer 9

你可以做这个

**

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

**
最好的一个是公认的答案，

尽管这不是一种安全的方法，但最好的答案是被公认的答案。
回答时，不知道评估危险。

Answer 10

假设您的所有输入都是列表，并且输入中的双引号实际上无关紧要，则可以通过简单的RegexP替换来完成。有点 perl-y-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']

Junkers变量包含一个我们不想要的所有字符的编译的REGEXP（用于速度），用作字符需要一些后斜切的欺骗。
re.sub 一无所有地替换所有这些字符，我们在逗号上拆分了结果字符串。

请注意，这还从内部条目中删除了空间， [u'ohno']。如果这不是您想要的，那么Regexp就必须加一点汤。

Answer 11

如果您知道您的列表仅包含引用的字符串，则此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']

如果您的列表可以具有更多的数据类型，甚至可以包含列表中的列表，那么您将需要更完整的语法 - 例如这个在pyparsing示例中，该目录将处理元组，列表，ints，floats和rowing struged strings。

Answer 12

您可能会遇到此类问题，同时处理存储为Pandas DataFrame的刮擦数据。

如果值列表以文本为单位，则该解决方案就像魅力一样。

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

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

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

无需外部库。

Answer 13

形式时，通常会发生这种情况

通常会在将字符串存储到CSV 的列表中以op问：

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

这是如何将其加载回列表的

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

listItems = rows[0]

： ListItems 现在列表

Answer 14

要进一步完成使用JSON，一个非常方便的转换Unicode的功能在此答案。

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

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

Answer 15

JSON.LOADS（）和JSON.DUMPS（）来自JSON软件包是JavaScript JSON.PARSE（） and code>和的等效方式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"]'

Answer 16

我想通过Regex提供更直观的图案解决方案。
以下函数将输入作为包含任意字符串的弦乐列表。

逐步说明：
您可以删除所有围墙，括号和value_separator（前提是它们不是要提取的值的一部分，否则使得正则更复杂）。然后，您将清洁的字符串拆分在单引号或双引号上，并以非空值（或偏好，无论是奇数索引值）。

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

Answer 17

因此，遵循所有答案，我决定为最常见的方法计时：

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

最终胜利！

Answer 18

您可以通过切片列表的字符串表示形式中的第一个和最后一个字符来保存.strip（）函数（请参见下面的第三行）：

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

Answer 19

并使用纯python-没有导入任何库：

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

Answer 20

如果您不想导入任何库：

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)

输出：

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

解决方案是不起作用

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

此方法的警告是，如果您的字符串内有逗号，则该

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

的你想要。

Answer 21

这是一个函数的实现，将字符串转换为并不是很短的列表，但它非常简单明了，可以按照手动执行此操作，可以做您期望的事情以及您将要做的事情：

def string_to_list(value):
    assert(isinstance(value, (str, list)))
    if isinstance(value, list):
        return value
    assert(value.startswith("[") and value.endswith("]"))
    value = value.strip().removeprefix("[").removesuffix("]").split(",")
    for i, item in enumerate(value):
        item = item.strip()
        if item.startswith("'") and item.endswith("'"):
            item = item.removeprefix("'").removesuffix("'")
        elif item.startswith('"') and item.endswith('"'):
            item = item.removeprefix('"').removesuffix('"')
        value[i] = item
    return value

Answer 22

该解决方案比我在以前的答案中阅读的某些内容要简单，但是它需要匹配列表的所有功能。

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

输出：

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