목록의 문자열 표현을 목록으로 변환하는 방법은 무엇입니까?

string다음과 같은 목록을 다음으로 변환하는 가장 간단한 방법이 궁금 합니다 list.

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

사용자가 쉼표 사이에 공백을 넣고 따옴표 안에 공백을 넣는 경우에도 마찬가지입니다. 나는 그것을 처리해야합니다.

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

파이썬에서.

split 연산자를 사용하고 공백을 제거 strip()하고 split()알파벳이 아닌 것을 확인할 수 있다는 것을 알고 있습니다 . 그러나 코드는 매우 어려워졌습니다. 내가 모르는 빠른 기능이 있습니까?

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

ast.literal_eval을 사용하면 표현식 노드 또는 Python 표현식이 포함 된 문자열을 안전하게 평가할 수 있습니다. 제공된 문자열 또는 노드는 문자열, 숫자, 튜플, 목록, dicts, 부울 및 없음과 같은 Python 리터럴 구조로만 구성 될 수 있습니다.

json있을 때마다 모듈은 더 나은 솔루션입니다 캐릭터 라인 사전의 목록. 이 json.loads(your_data)기능을 사용하여 목록으로 변환 할 수 있습니다.

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

비슷하게

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

은 eval위험하다 - 당신이 사용자 입력을 실행하지 않아야합니다.

2.6 이상인 경우 eval 대신 ast를 사용하십시오.

>>> 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을 사용하는 경우 목적에 충분할 수 있습니다.

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

빠른 해결책이 있습니다.

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

목록 요소에서 원하지 않는 공백은 다음과 같이 제거 할 수 있습니다.

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

기본 파이썬 패키지에서 작동하는 위의 답변 중 일부에서 영감을 얻었습니다 (파이썬 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

가독성이 가장 나쁜 방법을 고려한 결과가 최고의 성능을 가진 방법이라는 점에 실망했습니다. 가장 읽기 쉬운 옵션으로 갈 때 고려해야 할 장단점이 있습니다. 약간 더 성능이 좋은 옵션에 대한 가치 가독성이지만 평소와 같이 다릅니다.

1 차원 목록 인 경우 아무 것도 가져 오지 않고 수행 할 수 있습니다.

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

모든 입력이 목록이고 입력의 큰 따옴표가 실제로 중요하지 않다고 가정하면 간단한 정규 표현식 대체로 수행 할 수 있습니다. 약간 perl-y이지만 매력처럼 작동합니다. 또한 출력은 이제 유니 코드 문자열 목록이므로 필요하다고 지정하지 않았지만 유니 코드 입력이 주어진 것으로 이해됩니다.

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 변수에는 백 슬래시 트릭이 필요한 문자로]를 사용하여 원하지 않는 모든 문자의 컴파일 된 정규 표현식 (속도)이 포함되어 있습니다. re.sub는 이러한 모든 문자를 아무것도 대체하지 않으며 결과 문자열을 쉼표로 분할합니다.

또한 내부 항목 u '[ "oh no"]'---> [u'ohno ']에서 공백을 제거합니다. 이것이 원하는 것이 아니라면 정규 표현식을 약간 채워야합니다.

목록에 인용 된 문자열 만 포함되어 있다는 것을 알고 있다면이 pyparsing 예제는 스트립 된 문자열 목록을 제공합니다 (원래 유니 코드를 유지하더라도).

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

귀하의 목록에 더 많은 데이터 유형을 가지고, 또는 목록에서 목록을 포함 할 수있는 경우에, 당신은보다 완벽한 문법을해야합니다 - 같은 이 하나의 튜플,리스트,의 int, 수레, 그리고 인용 문자열을 처리 할 대한 파싱 위키. 파이썬 버전 2.4에서 작동합니다.

json을 사용하여 @Ryan의 답변을 더 완성하려면 유니 코드를 변환하는 매우 편리한 함수 중 하나가 여기에 게시 된 것입니다 : https://stackoverflow.com/a/13105359/7599285

큰 따옴표 또는 작은 따옴표가있는 ex :

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

정규식으로보다 직관적 인 패터닝 솔루션을 제공하고 싶습니다. 아래 함수는 임의의 문자열을 포함하는 문자열 목록을 입력으로 사용합니다.

단계별 설명 : 모든 공백, 대괄호 및 value_separators를 제거하십시오 (추출하려는 값의 일부가 아닌 경우 정규식을 더 복잡하게 만듭니다). 그런 다음 정리 된 문자열을 작은 따옴표 또는 큰 따옴표로 나누고 비어 있지 않은 값 (또는 환경 설정에 관계없이 홀수 색인 값)을 사용하십시오.

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

순수 파이썬으로-라이브러리를 가져 오지 않음

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

Pandas DataFrame으로 저장된 스크랩 된 데이터를 처리하는 동안 이러한 문제가 발생할 수 있습니다.

이 솔루션 은 값 목록이 text로 표시되는 경우 매력처럼 작동 합니다 .

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

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

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

외부 라이브러리가 필요하지 않습니다.

따라서 모든 대답을 따르면 가장 일반적인 방법을 시간으로 결정했습니다.

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

결국 정규 표현식이 승리합니다!

목록의 문자열 표현에서 첫 번째 문자와 마지막 문자를 잘라서 .strip () fcn을 저장할 수 있습니다 (아래 세 번째 줄 참조).

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