python 목록에서 고유한 값 가져오기

python 목록에서 고유한 값 가져오기

이 질문에는 이미 답변이 있습니다.

목록에서 중복 제거 (57개 답변)

닫힘4년 전에요.

다음 목록에서 원하는 값을 가져옵니다.

['nowplaying', 'PBS', 'PBS', 'nowplaying', 'job', 'debate', 'thenandnow']

필요한 출력은 다음과 같습니다.

['nowplaying', 'PBS', 'job', 'debate', 'thenandnow']

이 코드는 동작합니다.

output = []
for x in trends:
    if x not in output:
        output.append(x)
print(output)

제가 사용해야 할 더 좋은 해결책이 있을까요?

먼저 목록을 쉼표로 구분하여 올바르게 선언하십시오.목록을 세트로 변환하면 원하는 값을 얻을 수 있습니다.

mylist = ['nowplaying', 'PBS', 'PBS', 'nowplaying', 'job', 'debate', 'thenandnow']
myset = set(mylist)
print(myset)

목록으로 사용할 경우 다음을 수행하여 목록으로 다시 변환해야 합니다.

mynewlist = list(myset)

다른 방법으로는 목록 대신 처음부터 세트를 사용하는 것이 더 빠를 수 있습니다.그 후 코드는 다음과 같습니다.

output = set()
for x in trends:
    output.add(x)
print(output)

지적된 바와 같이, 세트는 원래의 순서를 유지하지 않습니다.필요한 경우는, 순서 있는 세트의 실장을 참조해 주세요(자세한 것에 대하여는, 이 질문을 참조해 주세요).

사용하고 싶은 타입과 일치하기 위해서:

mylist = list(set(mylist))

요소의 순서를 유지할 필요가 있는 경우는, 다음과 같이 해 주세요.

used = set()
mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for x in mylist if x not in used and (used.add(x) or True)]

또 하나의 솔루션은reduce '일시적'이 없는 usedvarvar.var..discloss.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])

업데이트 - 2020년 12월 - 최선의 접근법일 수 있습니다!

python 3.7부터 표준 dict는 삽입 순서를 유지합니다.

버전 3.7에서 변경됨: 사전 순서는 삽입 순서임을 보증합니다.이 동작은 3.6부터의 CPython 구현 상세입니다.

'우리'를 할 수 .dict.from_keys★★★★★★★★★★★★★★★★★★!

메모: 코멘트에서 이 접근방식을 제공해 주신 @rlat에게 크레딧이 돌아옵니다.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = list(dict.fromkeys(mylist))

속도에 관해서는, 새로운 마음에 드는 어프로치가 될 만큼 빠르고 읽기 쉬운 어프로치입니다.

업데이트 - 2019년 3월

그리고 세 번째 해결책은 깔끔하지만 그 이후로는 좀 느리지만.indexO(n)ㄹ 수 있다

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for i, x in enumerate(mylist) if i == mylist.index(x)]

업데이트 - 2016년 10월

다른 해결 과 같습니다.reduce에는 '아까 '아까', '아까', '아까',.append그래서 사람이 더 쉽게 읽을 수 있고 이해하기 쉽죠.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])
#which can also be writed as:
unique = reduce(lambda l, x: l if x in l else l+[x], mylist, [])

메모: 사람이 읽을 수 있는 수준이 높아지면 스크립트의 성능이 저하된다는 점에 유의하십시오.단,dict.from_keyspython 3.7+는 python 3.7+입니다.

import timeit

setup = "mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']"

#10x to Michael for pointing out that we can get faster with set()
timeit.timeit('[x for x in mylist if x not in used and (used.add(x) or True)]', setup='used = set();'+setup)
0.2029558869980974

timeit.timeit('[x for x in mylist if x not in used and (used.append(x) or True)]', setup='used = [];'+setup)
0.28999493700030143

# 10x to rlat for suggesting this approach!   
timeit.timeit('list(dict.fromkeys(mylist))', setup=setup)
0.31227896199925453

timeit.timeit('reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])', setup='from functools import reduce;'+setup)
0.7149233570016804

timeit.timeit('reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])', setup='from functools import reduce;'+setup)
0.7379565160008497

timeit.timeit('reduce(lambda l, x: l if x in l else l+[x], mylist, [])', setup='from functools import reduce;'+setup)
0.7400134069976048

timeit.timeit('[x for i, x in enumerate(mylist) if i == mylist.index(x)]', setup=setup)
0.9154880290006986

코멘트에 대한 답변

왜냐하면 @monica가 "어떻게 되는 거야?"라는 좋은 질문을 했기 때문입니다.그걸 이해하는 데 문제가 있는 모든 사람들을 위해서요.이 동작의 원리와 여기서 일어나는 마법에 대해 좀 더 자세히 설명하겠습니다.

그래서 그녀는 먼저 물었다.

그런지 요.unique = [used.append(x) for x in mylist if x not in used]동작하지 않습니다.

음, 실제로 효과가 있다.

>>> used = []
>>> mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
>>> unique = [used.append(x) for x in mylist if x not in used]
>>> print used
[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']
>>> print unique
[None, None, None, None, None]

는 우리가 그 안에서 입니다.unique단, '(', '') .used왜냐하면 이해 .append는 을 합니다.used 및 return variableNone.

그 를 래래 the the 위해서unique variable과 합니다..append(x) if x not in used..appendx측에있있 있있있다다

하지만 우리가 너무 순진해서 그대로 한다면:

>>> unique = [x for x in mylist if x not in used and used.append(x)]
>>> print unique
[]

우리는 그 대가로 아무것도 얻지 못할 것이다.

은요..append는 " "를 반환합니다.None

x not in used and None

이는 기본적으로 항상 다음과 같습니다.

1. False 때x에 used ,
2. None 때x 없다used.

두 모두 (「 」 「 」 「 」 「 。False/None로됩니다.falsy그 결과 빈 목록이 나타납니다.

왜 '나'가 되는 거야?None 때x 없다used★★★★★★★★★★★★★★★★★★★★★★★★★★★

Python의 단락 연산자는 이렇게 작동하기 때문입니다.

.x and y거짓으로 하다그렇지 않을 경우 y가 평가되고 결과 값이 반환됩니다.

★★★★★★★★★★★★★★★★★★.x는 사용되지 않습니다(즉, 이 경우). 다음 부품 또는 식은 평가()used.append(x)되고 값()None이 반환됩니다.

를 얻기 것은 입니다..append우리가 처음 만났을 때만 새 리스트에 올렸지

꼭 싶어요.used.append(x)★★★★★★★★★★★★★★★★★★만x 없다used 수 있는 것 같습니다None을 매기다truthy린괜괜 찮,, ?? ???

두은요, 두 번째 은요.short-circuit오퍼레이터가 놀러 옵니다.

.x or y먼저 x를 평가합니다.x가 참이면 값이 반환됩니다.그렇지 않으면 y가 평가되어 결과 값이 반환됩니다.

을 알고 있습니다..append(x)까지나 계속되다falsy1을 1만 or그 옆에는 항상 다음 파트가 있어요.을 사용하다

x not in used and (used.append(x) or True)

그래서 우리가 평가할 수 있는 used.append(x)True그 결과, 표현의 첫 부분이True.

을 볼 수 .reduce★★★★★★ 。

(l.append(x) or l) if x not in l else l
#similar as the above, but maybe more readable
#we return l unchanged when x is in l
#we append x to l and return l when x is not in l
l if x in l else (l.append(x) or l)

여기서 우리는:

1. ★★x로로 합니다.l 그 ''을 반환한다.l 때x 없다lor 「」.append되어 「」가 됩니다.l그 후에 반환됩니다.
2. l도 대지 않고x에 l

Python 목록:

>>> a = ['a', 'b', 'c', 'd', 'b']

원하는 항목을 가져오려면 해당 항목을 세트로 변환합니다(필요에 따라 다시 목록으로 변환할 수 있습니다).

>>> b = set(a)
>>> print(b)
{'b', 'c', 'd', 'a'}

출력 변수 유형은 무엇입니까?

Python 세트가 당신에게 필요한 것입니다.다음과 같이 출력을 선언합니다.

output = set()  # initialize an empty set

이제 ''라는 글자를 붙일 가 되어 output.add(elem)별함특

경고: 목록의 원래 순서를 유지하지 않도록 설정합니다.

중복을 제거하는 옵션에는 다음과 같은 일반 데이터 구조가 포함될 수 있습니다.

• 세트: 정렬되지 않은 고유 요소
• 순서부 세트: 순서부여된 고유 요소

다음은 Python에서 하나를 빠르게 얻을 수 있는 방법에 대한 요약입니다.

정해진

from collections import OrderedDict


seq = [u"nowplaying", u"PBS", u"PBS", u"nowplaying", u"job", u"debate", u"thenandnow"]

코드

옵션 1 - Aset 없음 (순서 없음):

list(set(seq))
# ['thenandnow', 'PBS', 'debate', 'job', 'nowplaying']
    

Python은 순서가 정해진 세트를 가지고 있지 않지만, 여기에 그것을 모방하는 몇 가지 방법이 있다.

옵션 2 -OrderedDict 완료 (오더 완료):

list(OrderedDict.fromkeys(seq))
# ['nowplaying', 'PBS', 'job', 'debate', 'thenandnow']

옵션 3 - adict(삽입 순서), Python 3.6+에서는 기본값입니다.자세한 내용은 이 게시물을 참조하십시오.

list(dict.fromkeys(seq))
# ['nowplaying', 'PBS', 'job', 'debate', 'thenandnow']

참고: 나열된 요소는 해시 가능해야 합니다.후자의 예에 대한 자세한 내용은 이 블로그 투고를 참조하십시오.R을 참조해 주세요.동일한 기술에 대한 Hettinger의 게시물; 명령 보존은 그의 초기 구현 중 하나에서 연장되었습니다.토탈 오더에 대해서는, 「」도 참조해 주세요.

순서 유지:

# oneliners
# slow -> . --- 14.417 seconds ---
[x for i, x in enumerate(array) if x not in array[0:i]]

# fast -> . --- 0.0378 seconds ---
[x for i, x in enumerate(array) if array.index(x) == i]

# multiple lines
# fastest -> --- 0.012 seconds ---
uniq = []
[uniq.append(x) for x in array if x not in uniq]
uniq

순서는 중요하지 않습니다.

# fastest-est -> --- 0.0035 seconds ---
list(set(array))

목록에서 고유 요소 가져오기

mylist = [1,2,3,4,5,6,6,7,7,8,8,9,9,10]

집합에서 단순 논리 사용 - 집합은 고유한 항목 목록입니다.

mylist=list(set(mylist))

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

심플 로직 사용

newList=[]
for i in mylist:
    if i not in newList:
        newList.append(i)

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

pop 메서드 -> pop을 사용하면 마지막 항목 또는 인덱스된 항목이 삭제되어 사용자에게 표시됩니다.비디오

k=0
while k < len(mylist):
    if mylist[k] in mylist[k+1:]:
        mylist.pop(mylist[k])
    else:
        k=k+1

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Numpy 사용

import numpy as np
np.unique(mylist)

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

언급

코드에 numpy를 사용하고 있는 경우(대용량 데이터에 적합한 선택일 수 있음), numpy.unique를 확인합니다.

>>> import numpy as np
>>> wordsList = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
>>> np.unique(wordsList)
array([u'PBS', u'debate', u'job', u'nowplaying', u'thenandnow'], 
      dtype='<U10')

(http://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html)

보시다시피 numpy는 숫자 데이터뿐만 아니라 문자열 배열도 지원합니다.물론 결과는 numpy 배열이지만 여전히 시퀀스처럼 동작하기 때문에 크게 문제가 되지 않습니다.

>>> for word in np.unique(wordsList):
...     print word
... 
PBS
debate
job
nowplaying
thenandnow

vanilla python 목록을 되돌리고 싶다면 언제든지 list()를 호출할 수 있습니다.

그러나 위의 코드 조각에서 알 수 있듯이 결과는 자동으로 정렬됩니다.목록 순서를 유지해야 하는 경우 정렬하지 않고 고유한 numpy를 확인하십시오.

set - 고유한 요소의 정렬되지 않은 집합입니다.요소 목록을 집합의 생성자에게 전달할 수 있습니다.따라서 중복된 요소가 포함된 통과 목록을 고유한 요소로 설정하고 다시 목록으로 변환한 다음 고유한 요소가 포함된 목록을 가져옵니다.퍼포먼스나 메모리의 오버헤드에 대해서는 말할 수 없지만, 작은 리스트에서는 그다지 중요하지 않았으면 합니다.

list(set(my_not_unique_list))

간단명료하게.

목록 압축만 사용하는 동일한 순서 고유 목록입니다.

> my_list = [1, 2, 1, 3, 2, 4, 3, 5, 4, 3, 2, 3, 1]
> unique_list = [
>    e
>    for i, e in enumerate(my_list)
>    if my_list.index(e) == i
> ]
> unique_list
[1, 2, 3, 4, 5]

enumerates를 i 요소 " " "e로 tuple.

my_list.index합니다.e첫 인덱스가 첫 isn isn isn isn 가 아닌 i 지금 반복하고 있는 은 '이렇게'입니다.e은 e록에있있 있있있다다

편집

이것은 퍼포먼스 면에서 좋은 방법이 아닙니다.이것은 목록 압축만을 사용하여 이를 실현하는 방법입니다.

보너스로는 고유한 값과 각 값의 카운트를 모두 얻을 수 있는 간단한 방법입니다.

from collections import Counter
l = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
c = Counter(l)

Python Dictionary의 기본 속성 사용:

inp=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
d={i for i in inp}
print d

출력은 다음과 같습니다.

set([u'nowplaying', u'job', u'debate', u'PBS', u'thenandnow'])

먼저, 당신이 제시한 예는 유효한 목록이 아닙니다.

example_list = [u'nowplaying',u'PBS', u'PBS', u'nowplaying', u'job', u'debate',u'thenandnow']

위가 예제 목록이라고 가정합니다.그런 다음 다음 다음 레시피를 사용하여 고유한 값을 반환하고 필요에 따라 순서를 유지할 수 있는 예제 문서를 반복 도구에 제공할 수 있습니다.여기서 반복 가능한 것은 example_list 입니다.

from itertools import ifilterfalse

def unique_everseen(iterable, key=None):
    "List unique elements, preserving order. Remember all elements ever seen."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in ifilterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

def get_distinct(original_list):
    distinct_list = []
    for each in original_list:
        if each not in distinct_list:
            distinct_list.append(each)
    return distinct_list

set는 중복되는 요소를 목록에서 필터링하는 데 도움이 됩니다. 될 str,int ★★★★★★★★★★★★★★★★★」tuple에 「」가 포함되어 있는 「」를 참조해 주세요.dict other (기타) (기타)list에 '원소 '원소', '원소', '원소', '원소', '원소', '원소', '원소', '원소', '원소', '원소', '원소', '원소', '원소'가 나옵니다.TypeError외입니니다다

다음은 일부(전부는 아님) 해시 불가능한 유형을 처리하는 일반적인 주문 보존 솔루션입니다.

def unique_elements(iterable):
    seen = set()
    result = []
    for element in iterable:
        hashed = element
        if isinstance(element, dict):
            hashed = tuple(sorted(element.iteritems()))
        elif isinstance(element, list):
            hashed = tuple(element)
        if hashed not in seen:
            result.append(element)
            seen.add(hashed)
    return result

def setlist(lst=[]):
   return list(set(lst))

목록에서 원하는 값을 가져오려면 아래 코드를 사용하십시오.

trends = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
output = set(trends)
output = list(output)

중요: 목록 또는 dict와 같이 목록 내의 항목이 해시 가능하지 않은 경우 위의 접근 방식은 작동하지 않습니다.

trends = [{'super':u'nowplaying'}, u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
output = set(trends)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: unhashable type: 'dict'

말은, 그 말이 맞다라는 해야 한다는 입니다.trends목록에는 항상 해시 가능한 항목만 포함됩니다.그렇지 않으면 보다 복잡한 코드를 사용해야 합니다.

from copy import deepcopy

try:
    trends = [{'super':u'nowplaying'}, [u'PBS',], [u'PBS',], u'nowplaying', u'job', u'debate', u'thenandnow', {'super':u'nowplaying'}]
    output = set(trends)
    output = list(output)
except TypeError:
    trends_copy = deepcopy(trends)
    while trends_copy:
        trend = trends_copy.pop()
        if trends_copy.count(trend) == 0:
            output.append(trend)
print output

목록에서 고유한 요소를 가져와 원래 순서를 유지하려면 Python의 표준 라이브러리에서 데이터 구조를 사용할 수 있습니다.

from collections import OrderedDict

def keep_unique(elements):
    return list(OrderedDict.fromkeys(elements).keys())

elements = [2, 1, 4, 2, 1, 1, 5, 3, 1, 1]
required_output = [2, 1, 4, 5, 3]

assert keep_unique(elements) == required_output

Python ≥ 을 하고 있는 는, 플레인 Python © 3.6 을 할 수 .dict경우 : 우 for :

def keep_unique(elements):
    return list(dict.fromkeys(elements).keys())

이것은 딕트의 "콤팩트" 표현이 도입된 이후 가능해졌다.여기 보세요.그러나 이는 "실장 세부사항을 고려했기 때문에 신뢰해서는 안 된다."

지금까지 아무도 주문 유지에 대한 직접적인 답변을 하지 않은 것에 놀랐습니다.

def unique(sequence):
    """Generate unique items from sequence in the order of first occurrence."""
    seen = set()
    for value in sequence:
        if value in seen:
            continue

        seen.add(value)

        yield value

목록뿐만 다른할 수 있도록 unique(range(10))만 하면 됩니다.list(unique(sequence)) 이렇게요.

>>> list(unique([u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']))
[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']

각 아이템은 해시 가능하며 비교가능할 뿐만 아니라 Python의 대부분의 아이템은 O(n)이며 O(n^2)가 아니기 때문에 긴 리스트에서 정상적으로 동작합니다.

이전 답변(목록을 설정으로 변환할 수 있음) 외에 이 방법으로도 가능합니다.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenadnow']
mylist = [i for i in set(mylist)]

출력은 다음과 같습니다.

[u'nowplaying', u'job', u'debate', u'PBS', u'thenadnow']

질서는 유지되지 않습니다.

또 다른 간단한 대답은 (세트를 사용하지 않고)입니다.

>>> t = [v for i,v in enumerate(mylist) if mylist.index(v) == i]
[u'nowplaying', u'PBS', u'job', u'debate', u'thenadnow']

1. 있다고 합니다.output=[]
2. 이 할 수 .trends=list(set(trends))

세트를 사용할 수 있습니다.확실히 하기 위해 리스트와 세트의 차이점을 설명하고 있습니다.sets는 고유한 요소의 순서가 매겨져 있지 않은 집합입니다.목록은 요소의 순서 집합입니다.그렇게,

    unicode_list=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job',u'debate', u'thenandnow']
    list_unique=list(set(unicode_list))
    print list_unique
[u'nowplaying', u'job', u'debate', u'PBS', u'thenandnow']

단, 변수 이름을 지정할 때 list/set을 사용하지 마십시오.위의 목록에서 unicode_list 대신 use list로 오류가 발생합니다.

list=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job',u'debate', u'thenandnow']
        list_unique=list(set(list))
        print list_unique
    list_unique=list(set(list))
TypeError: 'list' object is not callable

목록 삭제에 사용, 목록으로 반환

def get_unique_list(lst):
        if isinstance(lst,list):
            return list(set(lst))

Set은 순서가 매겨지지 않은 고유한 요소의 모음입니다.따라서 다음과 같이 set을 사용하여 원하는 목록을 얻을 수 있습니다.

unique_list = list(set([u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']))

콘텐츠의 고유성을 확인하면서도 원래의 순서를 유지하는 솔루션:

def getUnique(self):
    notunique = self.readLines()
    unique = []
    for line in notunique: # Loop over content
        append = True # Will be set to false if line matches existing line
        for existing in unique:
            if line == existing: # Line exists ? do not append and go to the next line
                append = False
                break # Already know file is unique, break loop
        if append: unique.append(line) # Line not found? add to list
    return unique

편집: 각 행에 대해 파일 전체를 루프하는 대신 사전 키를 사용하여 존재 여부를 확인하는 것이 더 효율적일 수 있습니다.큰 세트에는 솔루션을 사용하지 않습니다.

오래된 질문인 것은 알지만, 저만의 해결책이 있습니다.클래스 상속!:

class UniqueList(list):
    def appendunique(self,item):
        if item not in self:
            self.append(item)
            return True
        return False

그런 다음 목록에 항목을 고유하게 추가할 경우 Unique List에서 appendunique를 호출하면 됩니다.리스트에서 상속되기 때문에 기본적으로 리스트와 같이 동작하기 때문에 index() 등의 함수를 사용할 수 있습니다.또한 true 또는 false를 반환하므로 추가가 성공했는지(일치 항목) 실패했는지(이미 목록에 있음) 확인할 수 있습니다.

목록에서 원하는 항목 목록을 가져오려면 for loop adpending 항목을 UniqueList에 추가합니다(그 후 목록에 복사).

사용 코드 예:

unique = UniqueList()

for each in [1,2,2,3,3,4]:
    if unique.appendunique(each):
        print 'Uniquely appended ' + str(each)
    else:
        print 'Already contains ' + str(each)

인쇄:

Uniquely appended 1
Uniquely appended 2
Already contains 2
Uniquely appended 3
Already contains 3
Uniquely appended 4

목록에 복사:

unique = UniqueList()

for each in [1,2,2,3,3,4]:
    unique.appendunique(each)

newlist = unique[:]
print newlist

인쇄:

[1, 2, 3, 4]

장기 어레이용

s = np.empty(len(var))

s[:] = np.nan

for  x in  set(var):

    x_positions = np.where(var==x)

    s[x_positions[0][0]]=x


sorted_var=s[~np.isnan(s)]

이 기능을 사용해 보세요. 코드와 비슷하지만 다이내믹 레인지입니다.

def unique(a):

    k=0
    while k < len(a):
        if a[k] in a[k+1:]:
            a.pop(k)
        else:
            k=k+1



    return a

다음 기능을 사용합니다.

def uniquefy_list(input_list):
"""
This function  takes a list as input and return a list containing only unique elements from the input list

"""
output_list=[]
for elm123 in input_list:
    in_both_lists=0
    for elm234 in output_list:
        if elm123 == elm234:
            in_both_lists=1
            break
    if in_both_lists == 0:
        output_list.append(elm123)

return output_list

언급URL : https://stackoverflow.com/questions/12897374/get-unique-values-from-a-list-in-python