Có tích hợp nào loại bỏ các bản sao khỏi danh sách trong Python, trong khi giữ trật tự không? Tôi biết rằng tôi có thể sử dụng một bộ để loại bỏ trùng lặp, nhưng điều đó phá hủy trật tự ban đầu. Tôi cũng biết rằng tôi có thể tự lăn như thế này:

def uniq(input):
  output = []
  for x in input:
    if x not in output:
      output.append(x)
  return output

(Nhờ thư giãn cho mẫu mã đó .)

Nhưng tôi muốn tận dụng một thành ngữ Pythonic tích hợp hoặc nhiều hơn nếu có thể.

Câu hỏi liên quan: Trong Python, thuật toán nhanh nhất để loại bỏ các bản sao khỏi danh sách là gì để tất cả các phần tử là duy nhất trong khi duy trì trật tự ?

Ở đây bạn có một số lựa chọn thay thế: http://www.peterbe.com/plog/uniqifier-benchmark

Nhanh nhất

def f7(seq):
    seen = set()
    seen_add = seen.add
    return [x for x in seq if not (x in seen or seen_add(x))]

Tại sao assign seen.addđể seen_addthay vì chỉ gọi seen.add? Python là một ngôn ngữ động và việc giải quyết seen.addmỗi lần lặp lại tốn kém hơn so với việc giải quyết một biến cục bộ.seen.addcó thể đã thay đổi giữa các lần lặp và thời gian chạy không đủ thông minh để loại trừ điều đó. Để chơi nó an toàn, nó phải kiểm tra đối tượng mỗi lần.

Nếu bạn dự định sử dụng chức năng này rất nhiều trên cùng một tập dữ liệu, có lẽ bạn sẽ tốt hơn với một bộ được đặt hàng: http://code.activestate.com/recipes/528878/

Ôi (1) chèn, xóa và kiểm tra thành viên trên mỗi thao tác.

(Lưu ý bổ sung nhỏ: seen.add()luôn trả về None, vì vậy, orở trên chỉ có một cách để thử cập nhật đã đặt và không phải là một phần không thể thiếu của kiểm tra logic.)

Chỉnh sửa năm 2016

Như Raymond đã chỉ ra , trong python 3.5+ OrderedDictđược triển khai trong C, cách tiếp cận hiểu danh sách sẽ chậm hơn OrderedDict(trừ khi bạn thực sự cần danh sách ở cuối - và thậm chí sau đó, chỉ khi đầu vào rất ngắn). Vì vậy, giải pháp tốt nhất cho 3,5+ là OrderedDict.

Chỉnh sửa quan trọng 2015

Như @abarnert lưu ý, more_itertoolsthư viện ( pip install more_itertools) chứa một unique_everseenhàm được xây dựng để giải quyết vấn đề này mà không có bất kỳ đột biến ( ) nào không thể đọc được trong việc hiểu danh sách. Đây cũng là giải pháp nhanh nhất:not seen.add

>>> from  more_itertools import unique_everseen
>>> items = [1, 2, 0, 1, 3, 2]
>>> list(unique_everseen(items))
[1, 2, 0, 3]

Chỉ cần một thư viện nhập đơn giản và không có hack. Điều này xuất phát từ việc thực hiện công thức itertools unique_everseentrông giống như:

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 filterfalse(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

Trong Python 2.7+, thành ngữ chung được chấp nhận (hoạt động nhưng không được tối ưu hóa cho tốc độ, bây giờ tôi sẽ sử dụng unique_everseen) cho việc sử dụng nàycollections.OrderedDict :

Thời gian chạy: O (N)

>>> from collections import OrderedDict
>>> items = [1, 2, 0, 1, 3, 2]
>>> list(OrderedDict.fromkeys(items))
[1, 2, 0, 3]

Điều này trông đẹp hơn nhiều so với:

seen = set()
[x for x in seq if x not in seen and not seen.add(x)]

và không sử dụng hack xấu xí :

not seen.add(x)

dựa trên thực tế set.addlà một phương thức tại chỗ luôn trả về Noneđể not Noneđánh giá True.

Tuy nhiên, lưu ý rằng giải pháp hack nhanh hơn ở tốc độ thô mặc dù nó có cùng độ phức tạp thời gian chạy O (N).

Trong Python 2.7 , cách mới để loại bỏ các bản sao khỏi một lần lặp trong khi giữ nó theo thứ tự ban đầu là:

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

Trong Python 3.5 , OrderedDict có triển khai C. Thời gian của tôi cho thấy rằng đây là cách nhanh nhất và ngắn nhất trong các cách tiếp cận khác nhau cho Python 3.5.

Trong Python 3.6 , dict thông thường trở nên vừa có trật tự. (Tính năng này được giữ cho CPython và PyPy nhưng có thể không có trong các triển khai khác). Điều đó cho chúng ta một cách khấu trừ nhanh nhất mới trong khi vẫn giữ trật tự:

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

Trong Python 3.7 , lệnh chính quy được đảm bảo cho cả hai thứ tự trên tất cả các cài đặt. Vì vậy, giải pháp ngắn nhất và nhanh nhất là:

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

Trả lời @max: Khi bạn chuyển sang 3.6 hoặc 3.7 và sử dụng lệnh chính quy thay vì OrderedDict , bạn không thể thực sự đánh bại hiệu suất theo bất kỳ cách nào khác. Từ điển dày đặc và dễ dàng chuyển đổi thành một danh sách mà hầu như không có chi phí. Danh sách mục tiêu được định cỡ trước thành len (d) để lưu tất cả các thay đổi kích thước xảy ra trong phần hiểu danh sách. Ngoài ra, vì danh sách khóa nội bộ dày đặc, sao chép các con trỏ gần như nhanh chóng như một bản sao danh sách.

sequence = ['1', '2', '3', '3', '6', '4', '5', '6']
unique = []
[unique.append(item) for item in sequence if item not in unique]

độc đáo → ['1', '2', '3', '6', '4', '5']

Không đá con ngựa chết (câu hỏi này đã rất cũ và đã có rất nhiều câu trả lời hay), nhưng đây là một giải pháp sử dụng gấu trúc khá nhanh trong nhiều trường hợp và rất dễ sử dụng.

import pandas as pd

my_list = [0, 1, 2, 3, 4, 1, 2, 3, 5]

>>> pd.Series(my_list).drop_duplicates().tolist()
# Output:
# [0, 1, 2, 3, 4, 5]

from itertools import groupby
[ key for key,_ in groupby(sortedList)]

Danh sách thậm chí không phải sắp xếp , điều kiện đủ là các giá trị bằng nhau được nhóm lại với nhau.

Chỉnh sửa: Tôi giả định rằng "giữ trật tự" ngụ ý rằng danh sách thực sự được sắp xếp. Nếu đây không phải là trường hợp, thì giải pháp từ MizardX là đúng.

Chỉnh sửa cộng đồng: Tuy nhiên, đây là cách thanh lịch nhất để "nén các phần tử liên tiếp trùng lặp thành một phần tử".

Tôi nghĩ rằng nếu bạn muốn duy trì trật tự,

bạn có thể thử điều này:

list1 = ['b','c','d','b','c','a','a']    
list2 = list(set(list1))    
list2.sort(key=list1.index)    
print list2

HOẶC tương tự bạn có thể làm điều này:

list1 = ['b','c','d','b','c','a','a']  
list2 = sorted(set(list1),key=list1.index)  
print list2 

Bạn cũng có thể làm điều này:

list1 = ['b','c','d','b','c','a','a']    
list2 = []    
for i in list1:    
    if not i in list2:  
        list2.append(i)`    
print list2

Nó cũng có thể được viết như sau:

list1 = ['b','c','d','b','c','a','a']    
list2 = []    
[list2.append(i) for i in list1 if not i in list2]    
print list2 

Trong Python 3.7 trở lên, từ điển được đảm bảo ghi nhớ thứ tự chèn khóa của chúng. Câu trả lời cho điều này câu hỏi tóm tắt tình trạng hiện tại.

Các OrderedDictgiải pháp như vậy, trở nên lỗi thời và không có bất kỳ báo cáo nhập khẩu, chúng tôi chỉ đơn giản là có thể phát hành:

>>> lst = [1, 2, 1, 3, 3, 2, 4]
>>> list(dict.fromkeys(lst))
[1, 2, 3, 4]

Đối với một câu trả lời rất muộn cho một câu hỏi rất cũ khác:

Các itertoolscông thức nấu ăn có một chức năng thực hiện điều này, bằng cách sử dụng seenkỹ thuật thiết lập, nhưng:

• Xử lý một tiêu chuẩn key chức năng .
• Sử dụng không có hack đột xuất.
• Tối ưu hóa vòng lặp bằng cách liên kết trước seen.addthay vì tìm kiếm N lần. (f7 cũng làm điều này, nhưng một số phiên bản thì không.)
• Tối ưu hóa vòng lặp bằng cách sử dụng ifilterfalse, do đó bạn chỉ phải lặp qua các phần tử duy nhất trong Python, thay vì tất cả chúng. (Tất nhiên, bạn vẫn lặp đi lặp lại tất cả chúng bên trong ifilterfalse, nhưng đó là bằng C, và nhanh hơn nhiều.)

Có thực sự nhanh hơn f7? Nó phụ thuộc vào dữ liệu của bạn, vì vậy bạn sẽ phải kiểm tra và xem. Nếu bạn muốn có một danh sách cuối cùng, hãy f7sử dụng một listcomp và không có cách nào để làm điều đó ở đây. (Bạn có thể trực tiếp appendthay vì yielding hoặc bạn có thể đưa máy phát điện vàolist hàm, nhưng không ai có thể nhanh như LIST_APPEND trong danh sách.) Ở mọi mức độ, thông thường, việc vắt ra vài micrô giây sẽ không như quan trọng là có một chức năng đã được viết dễ hiểu, có thể sử dụng lại, không cần DSU khi bạn muốn trang trí.

Như với tất cả các công thức nấu ăn, nó cũng có sẵn trong more-iterools .

Nếu bạn chỉ muốn keytrường hợp không , bạn có thể đơn giản hóa nó như sau:

def unique(iterable):
    seen = set()
    seen_add = seen.add
    for element in itertools.ifilterfalse(seen.__contains__, iterable):
        seen_add(element)
        yield element

Chỉ cần thêm một (rất performant) thực hiện chức năng một ví dụ từ một mô-đun bên ngoài ¹ : iteration_utilities.unique_everseen:

>>> from iteration_utilities import unique_everseen
>>> lst = [1,1,1,2,3,2,2,2,1,3,4]

>>> list(unique_everseen(lst))
[1, 2, 3, 4]

Thời gian

Tôi đã làm một số timings (Python 3.6) và những chương trình mà nó là nhanh hơn so với tất cả các lựa chọn thay thế khác mà tôi thử nghiệm, bao gồm OrderedDict.fromkeys, f7và more_itertools.unique_everseen:

%matplotlib notebook

from iteration_utilities import unique_everseen
from collections import OrderedDict
from more_itertools import unique_everseen as mi_unique_everseen

def f7(seq):
    seen = set()
    seen_add = seen.add
    return [x for x in seq if not (x in seen or seen_add(x))]

def iteration_utilities_unique_everseen(seq):
    return list(unique_everseen(seq))

def more_itertools_unique_everseen(seq):
    return list(mi_unique_everseen(seq))

def odict(seq):
    return list(OrderedDict.fromkeys(seq))

from simple_benchmark import benchmark

b = benchmark([f7, iteration_utilities_unique_everseen, more_itertools_unique_everseen, odict],
              {2**i: list(range(2**i)) for i in range(1, 20)},
              'list size (no duplicates)')
b.plot()

Và để chắc chắn rằng tôi cũng đã thực hiện một thử nghiệm với nhiều bản sao hơn chỉ để kiểm tra xem nó có tạo ra sự khác biệt không:

import random

b = benchmark([f7, iteration_utilities_unique_everseen, more_itertools_unique_everseen, odict],
              {2**i: [random.randint(0, 2**(i-1)) for _ in range(2**i)] for i in range(1, 20)},
              'list size (lots of duplicates)')
b.plot()

Và một chỉ chứa một giá trị:

b = benchmark([f7, iteration_utilities_unique_everseen, more_itertools_unique_everseen, odict],
              {2**i: [1]*(2**i) for i in range(1, 20)},
              'list size (only duplicates)')
b.plot()

Trong tất cả các trường hợp này, iteration_utilities.unique_everseenchức năng là nhanh nhất (trên máy tính của tôi).

iteration_utilities.unique_everseenHàm này cũng có thể xử lý các giá trị không thể xóa trong đầu vào (tuy nhiên với O(n*n)hiệu suất thay vì O(n)hiệu suất khi các giá trị có thể băm).

>>> lst = [{1}, {1}, {2}, {1}, {3}]

>>> list(unique_everseen(lst))
[{1}, {2}, {3}]

¹ Tuyên bố miễn trừ trách nhiệm: Tôi là tác giả của gói đó.

Đối với không có loại có thể băm (ví dụ: danh sách danh sách), dựa trên MizardX:

def f7_noHash(seq)
    seen = set()
    return [ x for x in seq if str( x ) not in seen and not seen.add( str( x ) )]

Mượn ý tưởng đệ quy được sử dụng để xác định nubchức năng của Haskell cho các danh sách, đây sẽ là một cách tiếp cận đệ quy:

def unique(lst):
    return [] if lst==[] else [lst[0]] + unique(filter(lambda x: x!= lst[0], lst[1:]))

ví dụ:

In [118]: unique([1,5,1,1,4,3,4])
Out[118]: [1, 5, 4, 3]

Tôi đã thử nó để tăng kích thước dữ liệu và thấy độ phức tạp thời gian tuyến tính (không dứt khoát, nhưng gợi ý rằng điều này sẽ tốt cho dữ liệu bình thường).

In [122]: %timeit unique(np.random.randint(5, size=(1)))
10000 loops, best of 3: 25.3 us per loop

In [123]: %timeit unique(np.random.randint(5, size=(10)))
10000 loops, best of 3: 42.9 us per loop

In [124]: %timeit unique(np.random.randint(5, size=(100)))
10000 loops, best of 3: 132 us per loop

In [125]: %timeit unique(np.random.randint(5, size=(1000)))
1000 loops, best of 3: 1.05 ms per loop

In [126]: %timeit unique(np.random.randint(5, size=(10000)))
100 loops, best of 3: 11 ms per loop

Tôi cũng nghĩ thật thú vị khi điều này có thể dễ dàng được khái quát hóa thành tính duy nhất bởi các hoạt động khác. Như thế này:

import operator
def unique(lst, cmp_op=operator.ne):
    return [] if lst==[] else [lst[0]] + unique(filter(lambda x: cmp_op(x, lst[0]), lst[1:]), cmp_op)

Ví dụ: bạn có thể chuyển vào một hàm sử dụng khái niệm làm tròn cho cùng một số nguyên như thể đó là "đẳng thức" cho các mục đích duy nhất, như sau:

def test_round(x,y):
    return round(x) != round(y)

sau đó là duy nhất (some_list, test_round) sẽ cung cấp các yếu tố duy nhất của danh sách trong đó tính duy nhất không còn có nghĩa là bình đẳng truyền thống (được ngụ ý bằng cách sử dụng bất kỳ cách tiếp cận dựa trên tập hợp hoặc khóa chính tả nào cho vấn đề này) mà thay vào đó chỉ phần tử đầu tiên làm tròn thành K cho mỗi số nguyên K có thể mà các phần tử có thể làm tròn thành, ví dụ:

In [6]: unique([1.2, 5, 1.9, 1.1, 4.2, 3, 4.8], test_round)
Out[6]: [1.2, 5, 1.9, 4.2, 3]

5 x biến thể giảm nhanh hơn nhưng tinh vi hơn

>>> l = [5, 6, 6, 1, 1, 2, 2, 3, 4]
>>> 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]

Giải trình:

default = (list(), set())
# use 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]
[5, 6, 1, 2, 3, 4]

Bạn có thể tham khảo một sự hiểu biết danh sách vì nó đang được xây dựng bởi biểu tượng '_ [1]'.
Ví dụ, hàm sau duy nhất-ifies một danh sách các phần tử mà không thay đổi thứ tự của chúng bằng cách tham chiếu mức độ hiểu danh sách của nó.

def unique(my_list): 
    return [x for x in my_list if x not in locals()['_[1]']]

Bản giới thiệu:

l1 = [1, 2, 3, 4, 1, 2, 3, 4, 5]
l2 = [x for x in l1 if x not in locals()['_[1]']]
print l2

Đầu ra:

[1, 2, 3, 4, 5]

Câu trả lời của MizardX cung cấp một bộ sưu tập tốt các phương pháp tiếp cận.

Đây là những gì tôi nghĩ ra trong khi suy nghĩ lớn:

mylist = [x for i,x in enumerate(mylist) if x not in mylist[i+1:]]

Đây là một cách đơn giản để làm điều đó:

list1 = ["hello", " ", "w", "o", "r", "l", "d"]
sorted(set(list1 ), key=lambda x:list1.index(x))

cung cấp đầu ra:

["hello", " ", "w", "o", "r", "l", "d"]

Bạn có thể làm một loại hack hiểu danh sách xấu xí.

[l[i] for i in range(len(l)) if l.index(l[i]) == i]

Cách tiếp cận tương đối hiệu quả với _sorted_một numpymảng:

b = np.array([1,3,3, 8, 12, 12,12])    
numpy.hstack([b[0], [x[0] for x in zip(b[1:], b[:-1]) if x[0]!=x[1]]])

Đầu ra:

array([ 1,  3,  8, 12])

l = [1,2,2,3,3,...]
n = []
n.extend(ele for ele in l if ele not in set(n))

Biểu thức trình tạo sử dụng tra cứu O (1) của tập hợp để xác định xem có bao gồm một phần tử trong danh sách mới hay không.

Một giải pháp đệ quy đơn giản:

def uniquefy_list(a):
    return uniquefy_list(a[1:]) if a[0] in a[1:] else [a[0]]+uniquefy_list(a[1:]) if len(a)>1 else [a[0]]

Loại bỏ các giá trị trùng lặp trong một chuỗi, nhưng giữ nguyên thứ tự của các mục còn lại. Sử dụng chức năng tạo mục đích chung.

# for hashable sequence
def remove_duplicates(items):
    seen = set()
    for item in items:
        if item not in seen:
            yield item
            seen.add(item)

a = [1, 5, 2, 1, 9, 1, 5, 10]
list(remove_duplicates(a))
# [1, 5, 2, 9, 10]



# for unhashable sequence
def remove_duplicates(items, key=None):
    seen = set()
    for item in items:
        val = item if key is None else key(item)
        if val not in seen:
            yield item
            seen.add(val)

a = [ {'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 1, 'y': 2}, {'x': 2, 'y': 4}]
list(remove_duplicates(a, key=lambda d: (d['x'],d['y'])))
# [{'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 2, 'y': 4}]

người dùng gấu trúc nên kiểm tra pandas.unique.

>>> import pandas as pd
>>> lst = [1, 2, 1, 3, 3, 2, 4]
>>> pd.unique(lst)
array([1, 2, 3, 4])

Hàm trả về một mảng NumPy. Nếu cần, bạn có thể chuyển đổi nó thành một danh sách với tolistphương thức.

Nếu bạn cần một lớp lót thì có lẽ điều này sẽ giúp:

reduce(lambda x, y: x + y if y[0] not in x else x, map(lambda x: [x],lst))

... nên làm việc nhưng sửa tôi nếu tôi sai

Nếu bạn thường xuyên sử dụng pandasvà tính thẩm mỹ được ưu tiên hơn hiệu suất, thì hãy xem xét chức năng tích hợp pandas.Series.drop_duplicates:

    import pandas as pd
    import numpy as np

    uniquifier = lambda alist: pd.Series(alist).drop_duplicates().tolist()

    # from the chosen answer 
    def f7(seq):
        seen = set()
        seen_add = seen.add
        return [ x for x in seq if not (x in seen or seen_add(x))]

    alist = np.random.randint(low=0, high=1000, size=10000).tolist()

    print uniquifier(alist) == f7(alist)  # True

Thời gian:

    In [104]: %timeit f7(alist)
    1000 loops, best of 3: 1.3 ms per loop
    In [110]: %timeit uniquifier(alist)
    100 loops, best of 3: 4.39 ms per loop

điều này sẽ giữ trật tự và chạy trong thời gian O (n). về cơ bản, ý tưởng là tạo ra một cái lỗ ở bất cứ nơi nào có một bản sao được tìm thấy và nhấn chìm nó xuống đáy. sử dụng một con trỏ đọc và ghi. Bất cứ khi nào một bản sao được tìm thấy chỉ con trỏ đọc tiến lên và con trỏ ghi vẫn ở trên mục trùng lặp để ghi đè lên nó.

def deduplicate(l):
    count = {}
    (read,write) = (0,0)
    while read < len(l):
        if l[read] in count:
            read += 1
            continue
        count[l[read]] = True
        l[write] = l[read]
        read += 1
        write += 1
    return l[0:write]

Một giải pháp mà không sử dụng các mô-đun hoặc bộ nhập khẩu:

text = "ask not what your country can do for you ask what you can do for your country"
sentence = text.split(" ")
noduplicates = [(sentence[i]) for i in range (0,len(sentence)) if sentence[i] not in sentence[:i]]
print(noduplicates)

Cung cấp đầu ra:

['ask', 'not', 'what', 'your', 'country', 'can', 'do', 'for', 'you']

Một phương pháp tại chỗ

Phương pháp này là bậc hai, bởi vì chúng tôi có một tra cứu tuyến tính vào danh sách cho mọi phần tử của danh sách (để chúng tôi phải thêm chi phí sắp xếp lại danh sách vì dels).

Điều đó nói rằng, có thể hoạt động tại chỗ nếu chúng ta bắt đầu từ cuối danh sách và tiến tới nguồn gốc loại bỏ từng thuật ngữ có trong danh sách phụ ở bên trái

Ý tưởng này trong mã chỉ đơn giản là

for i in range(len(l)-1,0,-1): 
    if l[i] in l[:i]: del l[i] 

Một thử nghiệm đơn giản về việc thực hiện

In [91]: from random import randint, seed                                                                                            
In [92]: seed('20080808') ; l = [randint(1,6) for _ in range(12)] # Beijing Olympics                                                                 
In [93]: for i in range(len(l)-1,0,-1): 
    ...:     print(l) 
    ...:     print(i, l[i], l[:i], end='') 
    ...:     if l[i] in l[:i]: 
    ...:          print( ': remove', l[i]) 
    ...:          del l[i] 
    ...:     else: 
    ...:          print() 
    ...: print(l)
[6, 5, 1, 4, 6, 1, 6, 2, 2, 4, 5, 2]
11 2 [6, 5, 1, 4, 6, 1, 6, 2, 2, 4, 5]: remove 2
[6, 5, 1, 4, 6, 1, 6, 2, 2, 4, 5]
10 5 [6, 5, 1, 4, 6, 1, 6, 2, 2, 4]: remove 5
[6, 5, 1, 4, 6, 1, 6, 2, 2, 4]
9 4 [6, 5, 1, 4, 6, 1, 6, 2, 2]: remove 4
[6, 5, 1, 4, 6, 1, 6, 2, 2]
8 2 [6, 5, 1, 4, 6, 1, 6, 2]: remove 2
[6, 5, 1, 4, 6, 1, 6, 2]
7 2 [6, 5, 1, 4, 6, 1, 6]
[6, 5, 1, 4, 6, 1, 6, 2]
6 6 [6, 5, 1, 4, 6, 1]: remove 6
[6, 5, 1, 4, 6, 1, 2]
5 1 [6, 5, 1, 4, 6]: remove 1
[6, 5, 1, 4, 6, 2]
4 6 [6, 5, 1, 4]: remove 6
[6, 5, 1, 4, 2]
3 4 [6, 5, 1]
[6, 5, 1, 4, 2]
2 1 [6, 5]
[6, 5, 1, 4, 2]
1 5 [6]
[6, 5, 1, 4, 2]

In [94]:                                                                                                                             

Cách tiếp cận của zmk sử dụng khả năng hiểu danh sách rất nhanh, nhưng vẫn giữ trật tự một cách tự nhiên. Để áp dụng cho các chuỗi nhạy cảm trường hợp, nó có thể dễ dàng sửa đổi. Điều này cũng bảo tồn trường hợp ban đầu.

def DelDupes(aseq) :
    seen = set()
    return [x for x in aseq if (x.lower() not in seen) and (not seen.add(x.lower()))]

Các chức năng liên quan chặt chẽ là:

def HasDupes(aseq) :
    s = set()
    return any(((x.lower() in s) or s.add(x.lower())) for x in aseq)

def GetDupes(aseq) :
    s = set()
    return set(x for x in aseq if ((x.lower() in s) or s.add(x.lower())))

Hiểu một danh sách lót:

values_non_duplicated = [value for index, value in enumerate(values) if value not in values[ : index]]

Chỉ cần thêm một điều kiện để kiểm tra giá trị đó không nằm ở vị trí trước đó