목록에 중복 제거

목록에 중복 제거

어떻게 중복되지 않고 새로운 목록을 가져오니?

[1, 2, 3, 1]  →  [1, 2, 3]

어떻게 저는 그것이 중복되는 항목은 완전히 제거됩니다 새로운 목록을 가져오니?

[1, 2, 3, 1]  →  [2, 3]

그 흔한 방법 항목의 독특한 컬렉션 세트를 사용하는 것이다.뚜렷한 개체의 세트다 순서가 없는 소장품들이다.어떤iterable에서 집합을 만드려면 단순히 내장된 set()함수에 전달할 수 있다.나중에 다시 진정한 명단이 필요한데 비슷한 그 list()기능을 중심으로 통과할 수 있다.

다음 예제에서는 당신 노력하고 있:을 포함해야 한다.

>>> t = [1, 2, 3, 1, 2, 3, 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]

파이선 3.7에 출발하는 것, 내장된 사전으로 삽입하는 것이 질서를 유지하는 파이썬 3.7거나 나중에(또는 CPython 3.6)에 있어서도 직접적으로 그 사용할 수 있습니다. 보장된다.

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

이 먼저 그것에서 목록을 만든 사전을 만드는 약간의 오버 헤드가 있을 수도 있습니다.만일 여러분이 질서를 유지시키기 위해서 필요하지 않으면 자주 더 많아 진 집합을 사용하여기 때문에 특히 이것이 여러분이 많은 이상의 수술과 함께 일할 수 있습니다.중복 항목을 제거할 때 순서를 보존하는 다른 방법 및 자세한 내용은 이 질문을 참조하십시오.

---

으로, 「」와「」의 모두,set뿐만 아니라OrderedDict/dict솔루션에서는 항목이 해시 가능해야 합니다.이것은 보통 그들이 불변해야 한다는 것을 의미합니다.해시할 수 없는 항목(예를 들어 목록 개체)을 처리해야 하는 경우 기본적으로 모든 항목을 중첩된 루프에 있는 다른 모든 항목과 비교해야 하는 느린 방법을 사용해야 합니다.

Python 2.7 에서는, 원래의 순서를 유지하면서, 반복 가능으로부터 중복을 삭제하는 새로운 방법은, 다음과 같습니다.

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

한 줄입니다.list(set(source_list))효과가 있을 거야

A set을 사용하다

업데이트: 주문 유지 접근 방식에는 다음 두 가지가 있습니다.

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

, , 고, 고, 고, 고, 고, 용, 용, 용, 용, here, here, here, here, here, here, here, here that,OrderedDict는 키의 삽입 순서를 기억하고, 특정 키의 값이 갱신되어도 키 삽입 순서를 변경하지 않습니다.삽입하다True아무 것도 삽입할 수 있지만 값은 사용되지 않습니다.(set합니다.dict★★★★★★★★★★★★★★★★★★★★★」

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

순서를 신경 쓰지 않는 경우는, 다음의 순서에 따라 주세요.

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

A set이치노

의 첫 번째 한 새 L:

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

if ": if: ifL = [1, 2, 2, 3, 4, 2, 4, 3, 5] , , , 「 」newlist 되다[1, 2, 3, 4, 5]

새 요소를 추가하기 전에 각 요소가 목록에 나타나지 않았는지 확인합니다.또한 수입도 필요 없습니다.

Panda와 Numpy를 이용한 해결책도 있다.둘 다 numpy 배열을 반환하므로 목록을 원하는 경우 함수를 사용해야 합니다.

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

판다 용액

팬더 기능 사용:

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

Numpy 용액

numpy 함수를 사용합니다.

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

다만, 다른 솔루션과 비교하면 그다지 우아하지 않습니다.단, numpy.unique()는 선택된 축을 따라 중첩된 배열이 고유한지 여부를 확인할 수도 있습니다.

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

중복 항목 제거

이러한 답변의 대부분은 해시 가능한 중복 항목만 삭제하지만, 이 질문은 해시 가능한 항목만 필요하지 않다는 의미는 아닙니다. 즉, 해시 가능한 항목이 필요하지 않은 솔루션을 제안합니다.

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

Counter에서 캐시할 수 없는 키를 허용하기 위해 컨테이너 클래스를 만들었습니다. 컨테이너 클래스는 객체의 기본 해시 함수를 가져오려고 시도하지만 실패하면 ID 함수를 시도합니다.또한 eq 및 해시 메서드를 정의합니다.이 정도면 당사의 솔루션에서 캐시 불능 아이템을 사용할 수 있습니다.캐시할 수 없는 개체는 해시할 수 있는 개체로 취급됩니다.그러나 이 해시 함수는 캐시할 수 없는 개체의 ID를 사용합니다. 즉, 캐시할 수 없는 두 개의 동일한 개체는 작동하지 않습니다.이것을 무효로 하고, 동등한 가변 타입의 해시를 사용하도록 변경하는 것을 추천합니다(예를 들면,hash(tuple(my_list))my_list리스트입니다).

나도 두 가지 해결책을 만들었어.OrderedDict와 Counter의 하위 클래스를 모두 사용하여 항목의 순서를 유지하는 또 다른 솔루션 'OrderedCounter'입니다.다음은 기능을 제시하겠습니다.

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을 클릭합니다.

이걸 세 번에 걸쳐서 그래프로 나눠봤어요.해시 가능은 해시할 수 있는 모든 개체이며, 캐시 불가능은 해시할 수 없는 모든 개체입니다.순서 있는 시퀀스는 순서를 유지하는 시퀀스이며, 순서가 없는 시퀀스는 순서를 유지하지 않습니다.이제 몇 가지 용어가 더 있습니다.

Unordered Hashable은 순서를 유지할 필요가 없는 중복을 제거하는 모든 메서드에 대한 것입니다.캐시 불능에 효과가 있을 필요는 없었지만 가능했다.

주문된 해시블은 목록 내 항목의 순서를 유지하는 모든 메서드에 해당하지만 캐시 해제 시 동작할 필요는 없지만 가능합니다.

Ordered Uncashable은 목록 내 항목의 순서를 유지하며 캐시 해제된 항목에 대해 작동하는 메서드입니다.

Y축에는 소요된 초수가 표시됩니다.

x축에는 해당 기능이 적용된 번호가 표시됩니다.

가 매겨지지 않은 하여 다음과 을 주문했습니다.[list(range(x)) + list(range(x)) for x in range(0, 1000, 10)]

캐시 해제 의 경우: " " " " "[[list(range(y)) + list(range(y)) for y in range(x)] for x in range(0, 1000, 10)]

에는 다음과 같은 이 있습니다.step 제가는 조금 더 .그리고 제 개인적인 생각으로는 좀 더 읽기 쉬웠을 것 같아서요.

또한 범례의 키는 기능 구현의 가장 중요한 부분이라고 추측하려고 했습니다.어떤 기능이 가장 나쁘거나 가장 좋은가요?그래프로 알 수 있다.

이것으로 해결했습니다.그래프는 다음과 같습니다.

정렬되지 않은 해시 테이블

(확대)

주문한 해시 테이블

(확대)

주문된 캐시 불능

(확대)

동료가 오늘 코드 리뷰를 위해 자신의 코드의 일부로 승인된 답변을 제게 보냈습니다.나는 확실히 문제의 답변의 우아함에 감탄하지만, 나는 그 퍼포먼스에 만족하지 않는다.이 솔루션을 사용해 보았습니다(조회 시간을 단축하기 위해 세트를 사용합니다).

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

솔루션에서 세트가 제거되면 어떻게 됩니까?

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

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

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

답이너너 늦늦늦늦늦
순서를 않는 는, 「 」를 사용할 수 .*arg를 사용하여 확장합니다.set" " " 복거를를거를를 。

l = [*{*l}]

Python3 데모

또 다른 방법:

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

심플하고 간단:

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]

목록에 딕트가 있어서 위의 방법을 사용할 수 없었습니다.에러가 발생했습니다.

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

본 )) 중 를 사용합니다.OrderedDicts/set+list해시 가능한 입력으로 제한된 조합입니다.해시에 의존하지 않는 O(nlogn) 솔루션을 다음에 나타냅니다.

갱신에 의해,key파이썬 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]]))] 

주문을 유지하고 외부 모듈을 사용하지 않는 것이 가장 쉬운 방법입니다.

>>> 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가 첫 번째 표시이므로 1 뒤에 나옵니다.하지만 이것은 당신이 할 때 얻을 수 있는 것과 동일한 결과입니다.

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

하지만 그것은 훨씬 짧고 더 빨리 달린다.

마다 '이렇게 하다'가 나오기 할 수 있어요.왜하 、 ,, 매,fromkeys함수는 새 키를 생성하려고 합니다. 값이 이미 존재하는 경우 해당 키를 덮어씁니다.이것은 에는 전혀 .fromkeys는 모든 이 ""인 .None이렇게 하면 중복되는 모든 것을 효과적으로 제거할 수 있습니다.

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

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

는 「이러한 것은, 「,indexmethod는 요소의 첫 번째 인덱스만 반환합니다.중복 요소는 인덱스가 높습니다.여기를 참조해 주세요.

])list.index(x[, start[, end])
값이 x인 첫 번째 항목 목록에서 0 기반 인덱스를 반환합니다. ValueError를 사용합니다.

목록에서 중복을 제거하는 가장 좋은 방법은 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']

하시면 됩니다.set복을제 제거: :

mylist = list(set(mylist))

하지만 결과는 뒤죽박죽입니다.문제가 되는 경우:

mylist.sort()

여러 가지 제안을 Perfplot과 비교했습니다.입력 배열에 중복 요소가 없는 경우 입력 데이터가 Python 목록인지 NumPy 배열인지에 관계없이 모든 메서드가 거의 동일하게 빠른 것으로 나타났습니다.

되어 있는 , " " "는 " " " " 입니다.set,dict ★★★★★★★★★★★★★★★★★」np.unique입력 데이터가 목록일 경우 메서드는 costant-time이 됩니다.NumPy 배열이면np.unique열 살이다

그것들도 상시 운영이 아니라는 것이 다소 놀랍습니다.

---

그림을 재현하는 코드:

import perfplot
import numpy as np
import matplotlib.pyplot as plt


def setup_list(n):
    # return list(np.random.permutation(np.arange(n)))
    return [0] * n


def setup_np_array(n):
    # return np.random.permutation(np.arange(n))
    return np.zeros(n, dtype=int)


def list_set(data):
    return list(set(data))


def numpy_unique(data):
    return np.unique(data)


def list_dict(data):
    return list(dict.fromkeys(data))


b = perfplot.bench(
    setup=[
        setup_list,
        setup_list,
        setup_list,
        setup_np_array,
        setup_np_array,
        setup_np_array,
    ],
    kernels=[list_set, numpy_unique, list_dict, list_set, numpy_unique, list_dict],
    labels=[
        "list(set(lst))",
        "np.unique(lst)",
        "list(dict(lst))",
        "list(set(arr))",
        "np.unique(arr)",
        "list(dict(arr))",
    ],
    n_range=[2 ** k for k in range(23)],
    xlabel="len(array)",
    equality_check=None,
)
# plt.title("input array = [0, 1, 2,..., n]")
plt.title("input array = [0, 0,..., 0]")
b.save("out.png")
b.show()

세트 사용:

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

print t | t1
print t - t1

한 가지 더 좋은 방법이 있을 수 있습니다.

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]

질서는 유지되고 있습니다.

이 제품은 주문에 큰 번거로움 없이 대응하고 있습니다(OrderdDict 등).아마도 가장 피톤적인 길도 아니고 가장 짧은 길도 아닐 것입니다. 하지만 비결은 다음과 같습니다.

def remove_duplicates(item_list):
    ''' Removes duplicate items from a list '''
    singles_list = []
    for element in item_list:
        if element not in singles_list:
            singles_list.append(element)
    return singles_list

오더 유지 기능을 사용하여 변종 감소:

리스트가 있다고 가정합니다.

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]

그 밖에도 여러 가지 방법을 제안하는 답변이 있지만 모두 일괄 처리 작업이며 일부 답변은 원래 주문을 폐기합니다.필요한 항목에 따라 다르지만 각 값의 첫 번째 인스턴스 순서로 값을 반복하고 중복된 값을 즉시 삭제할 경우 다음 제너레이터를 사용할 수 있습니다.

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]

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

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)

['this', 'is', 'a', 'list', 'with', 'certificates', 'in', 'the']

세트 사용:

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

세트 사용 안 함

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) 

Python의 매직 빌트인 타입

Python에서는 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'

캐시 불능의 특수한 케이스(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']
]

왜냐하면 태플은 해시 가능하며 리스트와 태플 사이에서 데이터를 쉽게 변환할 수 있기 때문이다.

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

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]를 반환한다.

여기 다른 사람들에게 가장 빨리 다가가는 버마적인 해결책이 있습니다.

단락 평가의 구현 세부사항을 사용하면 목록 파악을 사용할 수 있습니다. 이는 충분히 빠른 속도입니다. visited.add(item) 반환하다None결과적으로, 그것은 로 평가된다.False 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

언급URL : https://stackoverflow.com/questions/7961363/removing-duplicates-in-lists