목록에서 중복 제거

질문자 :Neemaximo

목록에 중복 항목이 있는지 확인하는 프로그램을 작성해야 하고 중복 항목이 있으면 제거하고 중복/제거되지 않은 항목이 있는 새 목록을 반환합니다. 이것은 내가 가진 것이지만 솔직히 나는 무엇을해야할지 모르겠습니다.

 def remove_duplicates(): t = ['a', 'b', 'c', 'd'] t2 = ['a', 'c', 'd'] for t in t2: t.append(t.remove()) return t

고유한 항목 컬렉션을 가져오는 일반적인 방법은 set 을 사용하는 것입니다. 집합은 고유한 개체 의 정렬되지 않은 컬렉션입니다. iterable에서 집합을 생성하려면 내장 set() 함수에 전달하면 됩니다. 나중에 실제 목록이 다시 필요하면 유사하게 집합을 list() 함수에 전달할 수 있습니다.

다음 예에서는 수행하려는 모든 작업을 다루어야 합니다.

 >>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8] >>> t [1, 2, 3, 1, 2, 5, 6, 7, 8] >>> list(set(t)) [1, 2, 3, 5, 6, 7, 8] >>> s = [1, 2, 3] >>> list(set(t) - set(s)) [8, 5, 6, 7]

예제 결과에서 알 수 있듯이 원래 순서가 유지되지 않습니다 . 위에서 언급했듯이 집합 자체는 순서가 지정되지 않은 컬렉션이므로 순서가 손실됩니다. 집합을 목록으로 다시 변환할 때 임의의 순서가 생성됩니다.

질서 유지

순서가 중요하다면 다른 메커니즘을 사용해야 합니다. 이에 대한 매우 일반적인 솔루션은 삽입하는 동안 키 순서를 유지하기 위해 OrderedDict

 >>> from collections import OrderedDict >>> list(OrderedDict.fromkeys(t)) [1, 2, 3, 5, 6, 7, 8]

Python 3.7부터 내장 사전은 삽입 순서도 유지하도록 보장되므로 Python 3.7 이상(또는 CPython 3.6)을 사용하는 경우에도 직접 사용할 수 있습니다.

 >>> list(dict.fromkeys(t)) [1, 2, 3, 5, 6, 7, 8]

이것은 먼저 사전을 생성한 다음 사전에서 목록을 생성하는 약간의 오버헤드가 있을 수 있습니다. 실제로 순서를 유지할 필요가 없다면 세트를 사용하는 것이 더 나은 경우가 많습니다. 특히 작업할 작업이 훨씬 더 많기 때문입니다. 중복을 제거할 때 순서를 보존하는 자세한 방법과 대체 방법은 이 질문 을 확인하십시오.

---

마지막으로 set 와 OrderedDict / dict 솔루션 모두 항목이 해시 가능 해야 한다는 점에 유의하십시오. 이것은 일반적으로 변경 불가능해야 함을 의미합니다. 해시할 수 없는 항목(예: 목록 개체)을 처리해야 하는 경우 기본적으로 모든 항목을 중첩 루프의 다른 모든 항목과 비교해야 하는 느린 접근 방식을 사용해야 합니다.

poke

Python 2.7 에서 iterable에서 중복을 제거하면서 원래 순서대로 유지하는 새로운 방법은 다음과 같습니다.

 >>> from collections import OrderedDict >>> list(OrderedDict.fromkeys('abracadabra')) ['a', 'b', 'r', 'c', 'd']

Python 3.5 에서 OrderedDict에는 C 구현이 있습니다. 내 타이밍은 이것이 이제 Python 3.5에 대한 다양한 접근 방식 중 가장 빠르고 가장 짧다는 것을 보여줍니다.

Python 3.6 에서 일반 dict는 순서가 지정되고 압축되었습니다. (이 기능은 CPython 및 PyPy에 적용되지만 다른 구현에는 없을 수 있습니다.) 이는 순서를 유지하면서 중복을 제거하는 가장 빠른 새로운 방법을 제공합니다.

 >>> list(dict.fromkeys('abracadabra')) ['a', 'b', 'r', 'c', 'd']

Python 3.7 에서 일반 dict는 모든 구현에서 모두 순서가 지정되도록 보장됩니다. 따라서 가장 짧고 빠른 솔루션은 다음과 같습니다.

 >>> list(dict.fromkeys('abracadabra')) ['a', 'b', 'r', 'c', 'd']

Raymond Hettinger

한 줄짜리입니다. list(set(source_list)) 이 트릭을 수행합니다.

set 은 중복이 있을 수 없는 것입니다.

업데이트: 주문 보존 접근 방식은 두 줄입니다.

 from collections import OrderedDict OrderedDict((x, True) for x in source_list).keys()

OrderedDict 가 키의 삽입 순서를 기억하고 특정 키의 값이 업데이트될 때 이를 변경하지 않는다는 사실을 사용합니다. True 를 값으로 삽입하지만 아무 것도 삽입할 수 있으며 값은 사용되지 않습니다. ( set 은 무시된 값을 가진 dict 과 매우 유사하게 작동합니다.)

9000

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8] >>> t [1, 2, 3, 1, 2, 5, 6, 7, 8] >>> s = [] >>> for i in t: if i not in s: s.append(i) >>> s [1, 2, 3, 5, 6, 7, 8]

Neeraj

순서가 중요하지 않다면 다음과 같이 하십시오.

 def remove_duplicates(l): return list(set(l))

set 에는 중복이 없음이 보장됩니다.

Brendan Long

L 에서 중복 항목의 첫 번째 요소 순서를 유지하는 새 목록을 만들려면

newlist=[ii for n,ii in enumerate(L) if ii not in L[:n]]

예를 들어 if L=[1, 2, 2, 3, 4, 2, 4, 3, 5] 이면 newlist 은 [1,2,3,4,5]

이것은 추가하기 전에 각각의 새로운 요소가 이전에 목록에 나타나지 않았는지 확인합니다. 또한 수입품이 필요하지 않습니다.

Richard Fredlund

Pandas와 Numpy를 사용하는 솔루션도 있습니다. 둘 다 numpy 배열을 반환하므로 목록을 원하면 .tolist()

 t=['a','a','b','b','b','c','c','c'] t2= ['c','c','b','b','b','a','a','a']

판다 솔루션

팬더 함수 unique() :

 import pandas as pd pd.unique(t).tolist() >>>['a','b','c'] pd.unique(t2).tolist() >>>['c','b','a']

넘피 솔루션

numpy 함수 사용하기 unique() .

 import numpy as np np.unique(t).tolist() >>>['a','b','c'] np.unique(t2).tolist() >>>['a','b','c']

numpy.unique() 도 값을 정렬합니다 . 따라서 목록 t2 가 정렬되어 반환됩니다. 이 답변에서와 같이 주문을 보존하려면 다음을 수행하십시오 .

 _, idx = np.unique(t2, return_index=True) t2[np.sort(idx)].tolist() >>>['c','b','a']

이 솔루션은 다른 솔루션에 비해 그렇게 우아하지는 않지만 pandas.unique()와 비교할 때 numpy.unique()를 사용하면 선택한 하나의 축을 따라 중첩 배열이 고유한지 확인할 수도 있습니다.

G M

동료가 오늘 코드 검토를 위해 코드의 일부로 수락된 답변을 보냈습니다. 질문에 대한 답변의 우아함에는 확실히 감탄하지만 성능에는 만족하지 않습니다. 나는이 솔루션을 시도했습니다 (나는 조회 시간을 줄이기 위해 set을 사용합니다)

 def ordered_set(in_list): out_list = [] added = set() for val in in_list: if not val in added: out_list.append(val) added.add(val) return out_list

효율성을 비교하기 위해 100개 정수의 무작위 샘플을 사용했습니다. 62개는 고유했습니다.

 from random import randint x = [randint(0,100) for _ in xrange(100)] In [131]: len(set(x)) Out[131]: 62

다음은 측정 결과입니다

 In [129]: %timeit list(OrderedDict.fromkeys(x)) 10000 loops, best of 3: 86.4 us per loop In [130]: %timeit ordered_set(x) 100000 loops, best of 3: 15.1 us per loop

솔루션에서 set이 제거되면 어떻게 될까요?

 def ordered_set(inlist): out_list = [] for val in inlist: if not val in out_list: out_list.append(val) return out_list

결과는 OrderedDict 만큼 나쁘지는 않지만 여전히 원래 솔루션의 3배 이상입니다.

 In [136]: %timeit ordered_set(x) 10000 loops, best of 3: 52.6 us per loop

volcano

이 답변에는 두 개의 섹션이 있습니다. 두 개의 고유한 솔루션과 특정 솔루션의 속도 그래프입니다.

중복 항목 제거

이러한 답변의 대부분은 단지 해쉬있는 중복 항목을 제거 할 수 있지만 그것을 의미하지 않습니다이 질문은 그냥 해쉬 항목을 필요로하지 않는 몇 가지 솔루션을 제공 할 것입니다 의미 해쉬 항목이 필요하지 않습니다.

collections.Counter 는 이것을 위해 완벽할 수 있는 표준 라이브러리의 강력한 도구입니다. 카운터가 있는 다른 솔루션은 단 하나뿐입니다. 그러나 해당 솔루션은 해시 가능한 키로 제한됩니다.

Counter에서 해싱할 수 없는 키를 허용하기 위해 Container 클래스를 만들었습니다. 이 클래스는 개체의 기본 해시 함수를 가져오려고 하지만 실패하면 ID 기능을 시도합니다. 또한 eq 및 해시 메서드를 정의합니다. 이것은 우리 솔루션에서 해시 할 수 없는 항목을 허용하기에 충분해야 합니다. 해시할 수 없는 개체는 해시 가능한 것처럼 처리됩니다. 그러나 이 해시 함수는 해시할 수 없는 객체에 대해 ID를 사용합니다. 즉, 해시할 수 없는 두 개의 동일한 객체는 작동하지 않습니다. 이것을 재정의하고 동등한 가변 유형의 해시를 사용하도록 변경하는 것이 좋습니다(예: my_list 가 목록인 경우 hash(tuple(my_list))

또한 두 가지 솔루션을 만들었습니다. 'OrderedCounter'라는 OrderedDict 및 Counter의 하위 클래스를 사용하여 항목의 순서를 유지하는 또 다른 솔루션입니다. 이제 기능은 다음과 같습니다.

 from collections import OrderedDict, Counter class Container: def __init__(self, obj): self.obj = obj def __eq__(self, obj): return self.obj == obj def __hash__(self): try: return hash(self.obj) except: return id(self.obj) class OrderedCounter(Counter, OrderedDict): 'Counter that remembers the order elements are first encountered' def __repr__(self): return '%s(%r)' % (self.__class__.__name__, OrderedDict(self)) def __reduce__(self): return self.__class__, (OrderedDict(self),) def remd(sequence): cnt = Counter() for x in sequence: cnt[Container(x)] += 1 return [item.obj for item in cnt] def oremd(sequence): cnt = OrderedCounter() for x in sequence: cnt[Container(x)] += 1 return [item.obj for item in cnt]

remd 는 비순차 정렬이고 oremd 는 정렬 정렬입니다. 어느 것이 더 빠른지 명확하게 알 수 있지만 어쨌든 설명하겠습니다. 정렬되지 않은 정렬은 항목의 순서를 저장하지 않기 때문에 약간 더 빠릅니다.

이제 각 답변의 속도 비교도 보여주고 싶었습니다. 이제 그렇게 하겠습니다.

어떤 기능이 가장 빠릅니까?

중복을 제거하기 위해 몇 가지 답변에서 10 가지 기능을 수집했습니다. 각 함수의 속도를 계산하고 matplotlib.pyplot을 사용하여 그래프에 넣었습니다.

나는 이것을 3 라운드의 그래프로 나눴다. 해시 가능 객체는 해시될 수 있는 모든 객체이고, 해시 불가능 객체는 해시될 수 없는 객체입니다. 순서가 있는 순서는 순서를 유지하는 순서이고 순서가 없는 순서는 순서를 유지하지 않습니다. 이제 몇 가지 용어가 더 있습니다.

Unordered Hashable 은 중복을 제거하는 모든 방법을 위한 것으로 반드시 순서를 유지할 필요는 없습니다. unhashable을 위해 작동할 필요는 없었지만 가능했습니다.

Ordered Hashable 은 목록에 있는 항목의 순서를 유지하는 모든 방법을 위한 것이지만, unhashable에 대해서는 작동할 필요가 없었지만 가능했습니다.

Ordered Unhashable 은 목록에 있는 항목의 순서를 유지하고 unhashable에 대해 작동하는 모든 방법이었습니다.

y축은 소요된 시간(초)입니다.

x축은 함수가 적용된 번호입니다.

다음 이해력을 사용하여 순서가 지정되지 않은 해시 가능 항목 및 순서화된 해시 가능 항목에 대한 시퀀스를 생성했습니다. [list(range(x)) + list(range(x)) for x in range(0, 1000, 10)]

순서가 지정된 unhashable의 경우: [[list(range(y)) + list(range(y)) for y in range(x)] for x in range(0, 1000, 10)]

step 가 있다는 점에 유의하십시오. 그렇지 않으면 10배의 시간이 걸리기 때문입니다. 그리고 제 개인적인 생각으로는 조금 더 읽기 쉬웠을 것 같다는 생각이 들었기 때문입니다.

또한 범례의 키는 함수 구현의 가장 중요한 부분으로 추측하려고 시도한 것입니다. 최악 또는 최선의 기능은 무엇입니까? 그래프는 그 자체로 말합니다.

그것이 해결되면 다음은 그래프입니다.

정렬되지 않은 해시 가능

(확대)

주문된 해시 가능

(확대)

주문된 Unhashables

(확대)

Corman

다른 방법:

 >>> seq = [1,2,3,'a', 'a', 1,2] >> dict.fromkeys(seq).keys() ['a', 1, 2, 3]

James

간단하고 쉬운:

 myList = [1, 2, 3, 1, 2, 5, 6, 7, 8] cleanlist = [] [cleanlist.append(x) for x in myList if x not in cleanlist]

산출:

 >>> cleanlist [1, 2, 3, 5, 6, 7, 8]

Nima Soroush

내 목록에 사전이 있으므로 위의 접근 방식을 사용할 수 없습니다. 오류가 발생했습니다.

 TypeError: unhashable type:

따라서 주문 및/또는 일부 항목에 대해 관심이 있는 경우 해시할 수 없습니다 . 그러면 다음이 유용할 수 있습니다.

 def make_unique(original_list): unique_list = [] [unique_list.append(obj) for obj in original_list if obj not in unique_list] return unique_list

어떤 사람들은 부작용이 있는 목록 이해를 좋은 해결책이 아니라고 생각할 수 있습니다. 대안은 다음과 같습니다.

 def make_unique(original_list): unique_list = [] map(lambda x: unique_list.append(x) if (x not in unique_list) else False, original_list) return unique_list

cchristelis

답변이 많이 늦었습니다. 목록 순서가 set *arg 확장을 사용하여 속임수를 제거할 수 있습니다. 예:

 l = [*{*l}]

데모

Pedro Lobito

순서를 유지하고 외부 모듈을 사용하지 않으려면 다음을 수행하는 쉬운 방법입니다.

 >>> t = [1, 9, 2, 3, 4, 5, 3, 6, 7, 5, 8, 9] >>> list(dict.fromkeys(t)) [1, 9, 2, 3, 4, 5, 6, 7, 8]

참고: 이 방법은 출현 순서를 유지하므로 위에서 보았듯이 9가 처음 등장했기 때문에 9가 차례로 나옵니다. 그러나 이것은 수행할 때와 동일한 결과입니다.

 from collections import OrderedDict ulist=list(OrderedDict.fromkeys(l))

그러나 훨씬 더 짧고 더 빠르게 실행됩니다.

fromkeys 함수가 새 키를 생성하려고 할 때마다 값이 이미 존재하는 경우 단순히 덮어쓰기 때문에 작동합니다. fromkeys 는 모든 키에 값이 None 인 사전을 생성하므로 사전에 전혀 영향을 미치지 않으므로 이러한 방식으로 모든 중복을 효과적으로 제거합니다.

HEEL_caT666

지금까지 내가 본 모든 순서 보존 접근 방식은 순진한 비교(기껏해야 O(n^2) 시간 복잡도 사용) 또는 해시 가능한 입력으로 제한된 OrderedDicts / set + list 다음은 해시 독립적인 O(nlogn) 솔루션입니다.

업데이트 는 key 인수, 문서 및 Python 3 호환성을 추가했습니다.

 # from functools import reduce <-- add this import on Python 3 def uniq(iterable, key=lambda x: x): """ Remove duplicates from an iterable. Preserves order. :type iterable: Iterable[Ord => A] :param iterable: an iterable of objects of any orderable type :type key: Callable[A] -> (Ord => B) :param key: optional argument; by default an item (A) is discarded if another item (B), such that A == B, has already been encountered and taken. If you provide a key, this condition changes to key(A) == key(B); the callable must return orderable objects. """ # Enumerate the list to restore order lately; reduce the sorted list; restore order def append_unique(acc, item): return acc if key(acc[-1][1]) == key(item[1]) else acc.append(item) or acc srt_enum = sorted(enumerate(iterable), key=lambda item: key(item[1])) return [item[1] for item in sorted(reduce(append_unique, srt_enum, [srt_enum[0]]))]

Eli Korvigo

다음과 같이 할 수도 있습니다.

 >>> t = [1, 2, 3, 3, 2, 4, 5, 6] >>> s = [x for i, x in enumerate(t) if i == t.index(x)] >>> s [1, 2, 3, 4, 5, 6]

위의 방법이 작동하는 이유는 index 메서드가 요소의 첫 번째 인덱스만 반환하기 때문입니다. 중복 요소는 더 높은 인덱스를 갖습니다. 여기를 참조하십시오:

list.index(x[, 시작[, 끝]])
값이 x인 첫 번째 항목의 목록에서 0부터 시작하는 인덱스를 반환합니다. 그러한 항목이 없으면 ValueError 를 발생시킵니다.

Atonal

목록에서 중복을 제거하는 가장 좋은 방법은 Python에서 사용할 수 있는 set() 함수를 사용하여 해당 집합을 다시 목록으로 변환하는 것입니다.

 In [2]: some_list = ['a','a','v','v','v','c','c','d'] In [3]: list(set(some_list)) Out[3]: ['a', 'c', 'd', 'v']

Anurag Misra

set 을 사용하여 중복을 제거할 수 있습니다.

 mylist = list(set(mylist))

그러나 결과는 순서가 지정되지 않습니다. 그것이 문제라면:

 mylist.sort()

Flavio Wuensche

세트를 사용해보십시오:

 import sets t = sets.Set(['a', 'b', 'c', 'd']) t1 = sets.Set(['a', 'b', 'c']) print t | t1 print t - t1

Charlie Martin

주문 보존으로 변형 줄이기:

목록이 있다고 가정합니다.

 l = [5, 6, 6, 1, 1, 2, 2, 3, 4]

변형 줄이기(비효율적):

 >>> reduce(lambda r, v: v in r and r or r + [v], l, []) [5, 6, 1, 2, 3, 4]

5배 더 빠르지만 더 정교함

 >>> reduce(lambda r, v: v in r[1] and r or (r[0].append(v) or r[1].add(v)) or r, l, ([], set()))[0] [5, 6, 1, 2, 3, 4]

설명:

 default = (list(), set()) # user list to keep order # use set to make lookup faster def reducer(result, item): if item not in result[1]: result[0].append(item) result[1].add(item) return result reduce(reducer, l, default)[0]

Bershadsky

한 가지 더 나은 접근 방식은

 import pandas as pd myList = [1, 2, 3, 1, 2, 5, 6, 7, 8] cleanList = pd.Series(myList).drop_duplicates().tolist() print(cleanList) #> [1, 2, 3, 5, 6, 7, 8]

그리고 순서는 유지됩니다.

Akarsh Jain

다음 기능을 사용할 수 있습니다.

 def rem_dupes(dup_list): yooneeks = [] for elem in dup_list: if elem not in yooneeks: yooneeks.append(elem) return yooneeks

예 :

 my_list = ['this','is','a','list','with','dupicates','in', 'the', 'list']

용법:

 rem_dupes(my_list)

['이것', '이', '아', '목록', '~와', '복제', '인', '더']

Cybernetic

이 작업을 수행하는 다른 방법을 제안하는 다른 답변이 많이 있지만 모두 일괄 작업이며 일부는 원래 순서를 버립니다. 필요한 항목에 따라 괜찮을 수 있지만 각 값의 첫 번째 인스턴스 순서대로 값을 반복하고 중복 항목을 즉석에서 모두 제거하려는 경우 다음을 사용할 수 있습니다. 이 발전기:

 def uniqify(iterable): seen = set() for item in iterable: if item not in seen: seen.add(item) yield item

이것은 생성기/반복기를 반환하므로 반복기를 사용할 수 있는 모든 곳에서 사용할 수 있습니다.

 for unique_item in uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]): print(unique_item, end=' ') print()

산출:

 1 2 3 4 5 6 7 8

---

list 원하면 다음을 수행할 수 있습니다.

 unique_list = list(uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8])) print(unique_list)

산출:

 [1, 2, 3, 4, 5, 6, 7, 8]

Cyphase

세트를 사용하지 않고

 data=[1, 2, 3, 1, 2, 5, 6, 7, 8] uni_data=[] for dat in data: if dat not in uni_data: uni_data.append(dat) print(uni_data)

Suresh Gupta

아래 코드는 목록에서 중복을 제거하는 간단합니다.

 def remove_duplicates(x): a = [] for i in x: if i not in a: a.append(i) return a print remove_duplicates([1,2,2,3,3,4])

[1,2,3,4]를 반환합니다.

vinay hegde

답변에 나열된 다른 솔루션과 비교하여 가장 빠른 파이썬 솔루션은 다음과 같습니다.

단락 평가의 구현 세부 정보를 사용하면 충분히 빠른 목록 이해를 사용할 수 있습니다. visited.add(item) False 로 평가되는 결과로 항상 None or 의 오른쪽은 항상 이러한 표현식의 결과가 됩니다.

스스로 시간을 잰다

 def deduplicate(sequence): visited = set() adder = visited.add # get rid of qualification overhead out = [adder(item) or item for item in sequence if item not in visited] return out

thodnev

세트 사용:

 a = [0,1,2,3,4,3,3,4] a = list(set(a)) print a

고유 사용:

 import numpy as np a = [0,1,2,3,4,3,3,4] a = np.unique(a).tolist() print a

Nurul Akter Towhid

Python 3에서 매우 간단한 방법:

 >>> n = [1, 2, 3, 4, 1, 1] >>> n [1, 2, 3, 4, 1, 1] >>> m = sorted(list(set(n))) >>> m [1, 2, 3, 4]

Wariored

안타깝게도. 여기에 있는 대부분의 답변은 순서를 유지하지 않거나 너무 깁니다. 다음은 간단한 주문 보존 답변입니다.

 s = [1,2,3,4,5,2,5,6,7,1,3,9,3,5] x=[] [x.append(i) for i in s if i not in x] print(x)

이렇게 하면 중복이 제거되지만 순서는 유지되는 x가 제공됩니다.

ste_kwr

Python의 마법 내장형

파이썬에서는 이와 같이 복잡한 경우를 파이썬의 내장형으로만 처리하는 것이 매우 쉽습니다.

내가 하는 방법을 보여 드리겠습니다!

방법 1: 일반적인 경우

목록에서 중복 요소를 제거하고 여전히 정렬 순서를 유지하는 방법( 1줄 코드)

 line = [1, 2, 3, 1, 2, 5, 6, 7, 8] new_line = sorted(set(line), key=line.index) # remove duplicated element print(new_line)

당신은 결과를 얻을 것이다

 [1, 2, 3, 5, 6, 7, 8]

방법 2: 특수한 경우

 TypeError: unhashable type: 'list'

unhashable을 처리하는 특별한 경우( 3줄 코드 )

 line=[['16.4966155686595', '-27.59776154691', '52.3786295521147'] ,['16.4966155686595', '-27.59776154691', '52.3786295521147'] ,['17.6508629295574', '-27.143305738671', '47.534955022564'] ,['17.6508629295574', '-27.143305738671', '47.534955022564'] ,['18.8051102904552', '-26.688849930432', '42.6912804930134'] ,['18.8051102904552', '-26.688849930432', '42.6912804930134'] ,['19.5504702331098', '-26.205884452727', '37.7709192714727'] ,['19.5504702331098', '-26.205884452727', '37.7709192714727'] ,['20.2929416861422', '-25.722717575124', '32.8500163147157'] ,['20.2929416861422', '-25.722717575124', '32.8500163147157']] tuple_line = [tuple(pt) for pt in line] # convert list of list into list of tuple tuple_new_line = sorted(set(tuple_line),key=tuple_line.index) # remove duplicated element new_line = [list(t) for t in tuple_new_line] # convert list of tuple into list of list print (new_line)

당신은 결과를 얻을 것입니다 :

 [ ['16.4966155686595', '-27.59776154691', '52.3786295521147'], ['17.6508629295574', '-27.143305738671', '47.534955022564'], ['18.8051102904552', '-26.688849930432', '42.6912804930134'], ['19.5504702331098', '-26.205884452727', '37.7709192714727'], ['20.2929416861422', '-25.722717575124', '32.8500163147157'] ]

튜플은 해시 가능하고 목록과 튜플 간에 데이터를 쉽게 변환할 수 있기 때문에

Milo Chen

출처 : http:www.stackoverflow.com/questions/7961363/removing-duplicates-in-lists