มี built-in ที่ลบรายการที่ซ้ำกันออกจาก Python ในขณะที่รักษาลำดับหรือไม่ ฉันรู้ว่าฉันสามารถใช้ชุดเพื่อลบรายการที่ซ้ำกัน แต่นั่นเป็นการทำลายคำสั่งเดิม ฉันก็รู้ว่าฉันสามารถม้วนตัวเองเช่นนี้:

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

(ขอขอบคุณที่ผ่อนคลายสำหรับตัวอย่างโค้ดนั้น)

แต่ฉันต้องการใช้ประโยชน์จากตัวเองหรือสำนวน Pythonic เพิ่มเติมถ้าเป็นไปได้

คำถามที่เกี่ยวข้องในหลามสิ่งที่เป็นขั้นตอนวิธีที่เร็วที่สุดสำหรับการลบซ้ำกันจากรายการเพื่อให้ทุกองค์ประกอบที่ไม่ซ้ำกันในขณะที่รักษาเพื่อ ?

ที่นี่คุณมีทางเลือก: http://www.peterbe.com/plog/uniqifiers-benchmark

เร็วที่สุด:

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

ทำไมกำหนดseen.addเพื่อseen_addแทนเพียงโทรseen.add? Python เป็นภาษาแบบไดนามิกและการแก้ปัญหาการseen.addวนซ้ำแต่ละครั้งนั้นมีค่าใช้จ่ายสูงกว่าการแก้ไขตัวแปรท้องถิ่น seen.addอาจมีการเปลี่ยนแปลงระหว่างการทำซ้ำและรันไทม์ไม่ฉลาดพอที่จะออกกฎ ในการเล่นที่ปลอดภัยจะต้องตรวจสอบวัตถุทุกครั้ง

หากคุณวางแผนที่จะใช้ฟังก์ชั่นนี้จำนวนมากบนชุดข้อมูลเดียวกันบางทีคุณอาจจะดีกว่าด้วยชุดที่สั่ง: http://code.activestate.com/recipes/528878/

O (1) การแทรกการลบและการตรวจสอบสมาชิกต่อการดำเนินการ

(หมายเหตุเพิ่มเติมเล็กน้อย: seen.add()ส่งคืนเสมอNoneดังนั้นorข้างต้นมีเพียงวิธีที่จะพยายามอัปเดตชุดและไม่ได้เป็นส่วนสำคัญของการทดสอบเชิงตรรกะ)

แก้ไข 2016

ดังที่เรย์มอนด์ชี้ให้เห็นใน python 3.5+ ซึ่งOrderedDictมีการใช้งานใน C แนวทางการเข้าใจรายการจะช้ากว่าOrderedDict(เว้นแต่ว่าคุณต้องการรายการจริง ๆ ในตอนท้าย - และถึงตอนนั้นถ้าอินพุตนั้นสั้นมาก) ดังนั้นทางออกที่ดีที่สุดสำหรับ 3.5+ OrderedDictคือ

การแก้ไขที่สำคัญปี 2558

ในฐานะที่เป็น@abarnert notes more_itertoolsไลบรารี ( pip install more_itertools) จะมีunique_everseenฟังก์ชันที่สร้างขึ้นเพื่อแก้ไขปัญหานี้โดยไม่มีการกลายพันธุ์ที่ไม่สามารถอ่านได้ ( not seen.add) ในรายการความเข้าใจ นี่เป็นวิธีที่เร็วที่สุดเช่นกัน:

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

การนำเข้าไลบรารีอย่างง่ายเพียงครั้งเดียวและไม่มีแฮ็ก นี้มาจากการใช้สูตร itertools unique_everseenซึ่งมีลักษณะ:

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

ในหลามสำนวนได้รับการยอมรับ (ซึ่งทำงานได้ แต่ไม่เหมาะสำหรับความเร็วตอนนี้ผมจะใช้) สำหรับการใช้งานนี้:2.7+unique_everseencollections.OrderedDict

ไทม์: O (N)

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

มันดูดีกว่า:

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

และไม่ใช้แฮ็คที่น่าเกลียด :

not seen.add(x)

ซึ่งอาศัยอยู่กับความจริงที่ว่าset.addเป็นวิธีการในสถานที่ที่มักจะส่งกลับNoneเพื่อประเมินnot NoneTrue

อย่างไรก็ตามโปรดทราบว่าโซลูชันแฮ็คจะเร็วขึ้นในความเร็วที่เป็นดิบแม้ว่ามันจะมีความซับซ้อนรันไทม์ O (N) เหมือนกัน

ใน 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คำสั่งปกติกลายเป็นคำสั่งและกะทัดรัด (คุณลักษณะนี้มีไว้สำหรับ CPython และ PyPy แต่อาจไม่ปรากฏในการใช้งานอื่น ๆ ) วิธีนี้ทำให้เราสามารถขจัดข้อมูลซ้ำซ้อนได้เร็วที่สุดในขณะที่ยังคงคำสั่งซื้อ:

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

ใน Python 3.7 dict ปกตินั้นรับประกันว่าจะได้รับคำสั่งทั้งการใช้งานทั้งหมด ดังนั้นทางออกที่สั้นและเร็วที่สุดคือ:

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

การตอบสนองต่อ @max: เมื่อคุณย้ายไปที่ 3.6 หรือ 3.7 และใช้ dict ปกติแทนOrderedDictคุณจะไม่สามารถเอาชนะประสิทธิภาพได้ในทางอื่น พจนานุกรมมีความหนาแน่นสูงและสามารถแปลงเป็นรายการได้โดยแทบไม่มีค่าใช้จ่าย รายการเป้าหมายมีขนาดล่วงหน้าเป็น len (d) ซึ่งจะบันทึกการปรับขนาดทั้งหมดที่เกิดขึ้นในรายการความเข้าใจ นอกจากนี้เนื่องจากรายการคีย์ภายในมีความหนาแน่นการคัดลอกพอยน์เตอร์จึงเกือบจะเร็วเหมือนการคัดลอกรายการ

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

ที่ไม่ซ้ำกัน→ ['1', '2', '3', '6', '4', '5']

ที่จะไม่เตะม้าที่ตายแล้ว (คำถามนี้เก่ามากและมีคำตอบที่ดีอยู่แล้ว) แต่นี่เป็นวิธีแก้ปัญหาโดยใช้แพนด้าที่ค่อนข้างเร็วในหลาย ๆ สถานการณ์และตายง่ายต่อการใช้งาน

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

รายการไม่จำเป็นต้องเรียงลำดับเงื่อนไขที่เพียงพอคือค่าที่เท่ากันถูกจัดกลุ่มเข้าด้วยกัน

แก้ไข: ฉันสันนิษฐานว่า "รักษาลำดับ" หมายความว่ารายการมีการสั่งซื้อจริง หากไม่เป็นเช่นนั้นโซลูชันจาก MizardX นั้นเหมาะสม

การแก้ไขโดยชุมชน: นี่เป็นวิธีที่ยอดเยี่ยมที่สุดในการ "บีบอัดองค์ประกอบที่ต่อเนื่องกันเป็นองค์ประกอบเดียว"

ฉันคิดว่าถ้าคุณต้องการรักษาระเบียบ

คุณสามารถลองสิ่งนี้:

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

หรือในทำนองเดียวกันคุณสามารถทำสิ่งนี้:

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

คุณยังสามารถทำสิ่งนี้:

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

มันสามารถเขียนได้เช่นนี้

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

ในPython 3.7และสูงกว่าพจนานุกรมรับประกันว่าจะจำคำสั่งแทรกของพวกเขา คำตอบสำหรับคำถามนี้สรุปสถานการณ์ปัจจุบันของกิจการ

การOrderedDictแก้ปัญหาจึงล้าสมัยและไม่มีคำชี้แจงการนำเข้าเราสามารถออก:

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

สำหรับคำตอบที่ช้ามากสำหรับคำถามอื่นที่เก่ามาก:

itertoolsสูตรมีฟังก์ชั่นที่ไม่นี้โดยใช้เป็นseenเทคนิคชุด แต่:

• จัดการkeyฟังก์ชั่นมาตรฐาน
• ไม่ใช้แฮ็คที่ไม่สมควร
• ปรับการวนซ้ำให้เหมาะสมโดยการผูกไว้ล่วงหน้าseen.addแทนที่จะค้นหา N ครั้ง ( f7ทำสิ่งนี้ด้วยเช่นกัน แต่บางรุ่นก็ทำไม่ได้)
• ปรับการวนซ้ำให้เหมาะสมโดยใช้ifilterfalseดังนั้นคุณจะต้องวนซ้ำองค์ประกอบที่ไม่ซ้ำกันใน Python แทนองค์ประกอบทั้งหมด (คุณยังคงวนซ้ำพวกเขาทั้งหมดภายในifilterfalseแน่นอน แต่มันอยู่ใน C และเร็วกว่ามาก)

มันเร็วกว่าจริงf7หรือ ขึ้นอยู่กับข้อมูลของคุณดังนั้นคุณจะต้องทดสอบและดู หากคุณต้องการรายการในที่สุดf7ใช้ listcomp และไม่มีวิธีการทำที่นี่ (คุณสามารถappendแทนyieldไอเอ็นจีได้โดยตรงหรือคุณสามารถป้อนเครื่องกำเนิดไฟฟ้าเข้าไปในlistฟังก์ชั่น แต่ไม่มีใครสามารถเร็วเท่ากับ LIST_APPEND ภายใน listcomp) ในอัตราใดก็ตามโดยทั่วไปการบีบไมโครวินาทีออกไปจะไม่เท่ากับ สิ่งสำคัญคือการมีฟังก์ชั่นที่เข้าใจง่ายนำมาใช้ใหม่เขียนได้แล้วซึ่งไม่ต้องการ DSU เมื่อคุณต้องการตกแต่ง

more-iteroolsเช่นเดียวกับทุกสูตรก็ยังมีอยู่ใน

หากคุณต้องการเพียงแค่keyกรณีคุณสามารถทำให้มันง่ายขึ้นเป็น:

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

เพียงเพื่อเพิ่มอีก (performant มาก) การดำเนินงานของการทำงานดังกล่าวจากโมดูลภายนอก¹ : 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]

การกำหนดเวลา

ฉันไม่ได้กำหนดเวลาที่บางคน (Python 3.6) และการแสดงเหล่านี้ว่ามันเป็นเร็วกว่าทางเลือกอื่น ๆ ทั้งหมดที่ฉันทดสอบรวมทั้งOrderedDict.fromkeys, f7และ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()

และเพื่อให้แน่ใจว่าฉันได้ทำการทดสอบที่ซ้ำซ้อนมากขึ้นเพื่อตรวจสอบว่ามันสร้างความแตกต่างหรือไม่:

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

และอีกอันมีค่าเดียวเท่านั้น:

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

ในทุกกรณีiteration_utilities.unique_everseenฟังก์ชันนี้เร็วที่สุด (บนคอมพิวเตอร์ของฉัน)

นี้iteration_utilities.unique_everseenฟังก์ชั่นนี้ยังสามารถจัดการกับค่า unhashable ในการป้อนข้อมูล (อย่างไรกับO(n*n)ผลการปฏิบัติงานแทนของO(n)ประสิทธิภาพการทำงานเมื่อค่าที่มี hashable)

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

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

¹ข้อสงวนสิทธิ์: ฉันเป็นผู้เขียนแพ็คเกจนี้

สำหรับประเภทที่ไม่มีการแฮช (เช่นรายการของรายการ) โดยยึดตาม 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 ) )]

การยืมแนวคิดแบบเรียกซ้ำที่ใช้ในการกำหนดnubฟังก์ชันของ Haskell สำหรับรายการนี่จะเป็นวิธีแบบเรียกซ้ำ:

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

เช่น:

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

ฉันลองใช้เพื่อเพิ่มขนาดข้อมูลและเห็นความซับซ้อนเชิงเวลาย่อย (ไม่ชัดเจน แต่แนะนำว่าควรจะดีสำหรับข้อมูลปกติ)

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

ฉันยังคิดว่ามันน่าสนใจที่จะสามารถทำให้เป็นลักษณะทั่วไปได้อย่างง่ายดายโดยการดำเนินการอื่น ๆ แบบนี้:

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)

ตัวอย่างเช่นคุณสามารถส่งผ่านฟังก์ชั่นที่ใช้แนวคิดของการปัดเศษเป็นจำนวนเต็มเดียวกันราวกับว่ามันเป็น "ความเท่าเทียมกัน" เพื่อจุดประสงค์ที่เป็นเอกลักษณ์เช่นนี้:

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

เฉพาะแล้ว (some_list, test_round) จะให้องค์ประกอบที่เป็นเอกลักษณ์ของรายการที่ไม่ซ้ำกันไม่ได้หมายถึงความเท่าเทียมแบบดั้งเดิมอีกต่อไป (ซึ่งมีนัยโดยการใช้วิธีการตั้งค่าใด ๆ หรือ dict-key-based) แต่แทนที่จะใช้ เฉพาะองค์ประกอบแรกที่ปัดเศษเป็น K สำหรับแต่ละเลขจำนวนเต็มที่เป็นไปได้ K ที่องค์ประกอบอาจปัดไปเช่น:

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 เท่าลดตัวแปร แต่ซับซ้อนยิ่งขึ้น

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

คำอธิบาย:

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]

คุณสามารถอ้างอิงรายการความเข้าใจได้เนื่องจากมันถูกสร้างขึ้นโดยสัญลักษณ์ '_ [1]'
ตัวอย่างเช่นฟังก์ชั่นต่อไปนี้เป็นเอกลักษณ์ของรายการองค์ประกอบโดยไม่เปลี่ยนลำดับโดยอ้างอิงความเข้าใจในรายการ

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

การสาธิต:

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

เอาท์พุท:

[1, 2, 3, 4, 5]

คำตอบของ MizardX ให้การรวบรวมหลายวิธีที่ดี

นี่คือสิ่งที่ฉันคิดขึ้นมาในขณะที่คิดดัง ๆ :

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

นี่เป็นวิธีง่ายๆในการทำ:

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

ที่ให้ผลลัพธ์:

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

คุณสามารถแฮ็ครายการความเข้าใจที่น่าเกลียด

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

แนวทางที่มีประสิทธิภาพค่อนข้างมีอาร์เรย์:_sorted_numpy

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

ขาออก:

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

นิพจน์ตัวสร้างที่ใช้ O (1) ค้นหาชุดเพื่อพิจารณาว่าจะรวมองค์ประกอบในรายการใหม่หรือไม่

โซลูชันแบบเรียกซ้ำง่ายๆ:

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

กำจัดค่าที่ซ้ำกันในลำดับ แต่รักษาลำดับของรายการที่เหลือ การใช้ฟังก์ชั่นเครื่องกำเนิดไฟฟ้าเอนกประสงค์

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

pandas.uniqueผู้ใช้หมีแพนด้าควรตรวจสอบ

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

ฟังก์ชันส่งคืนอาร์เรย์ NumPy หากจำเป็นคุณสามารถแปลงเป็นรายการด้วยtolistวิธีการ

หากคุณต้องการหนึ่งซับแล้วอาจจะช่วย:

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

... ควรจะทำงาน แต่แก้ไขให้ถูกต้องหากฉันทำผิด

หากคุณใช้เป็นประจำpandasและความสวยงามเป็นที่ต้องการมากกว่าประสิทธิภาพให้พิจารณาฟังก์ชั่นในตัว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

เวลา:

    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

สิ่งนี้จะรักษาลำดับและเรียกใช้ในเวลา O (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]

โซลูชันโดยไม่ใช้โมดูลหรือชุดที่อิมพอร์ต:

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)

ให้ผลลัพธ์:

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

วิธีการในสถานที่

วิธีนี้เป็นกำลังสองเนื่องจากเรามีการค้นหาเชิงเส้นในรายการสำหรับทุกองค์ประกอบของรายการ (เพื่อที่เราจะต้องเพิ่มค่าใช้จ่ายของการจัดเรียงรายการเนื่องจากdels)

ที่กล่าวว่าเป็นไปได้ที่จะทำงานในสถานที่ถ้าเราเริ่มต้นจากจุดสิ้นสุดของรายการและดำเนินการต่อไปยังจุดเริ่มต้นลบแต่ละคำที่มีอยู่ในรายการย่อยทางด้านซ้าย

ความคิดในรหัสนี้เป็นเพียงแค่

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

การทดสอบอย่างง่ายของการนำไปใช้

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

วิธีการของ zmk นั้นใช้ list comprehension ซึ่งเร็วมาก แต่ยังคงความเป็นระเบียบอยู่เสมอ สำหรับการปรับใช้กับสตริงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ กรณีนี้ยังคงรักษากรณีเดิม

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

ฟังก์ชั่นที่เกี่ยวข้องอย่างใกล้ชิดคือ:

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

รายการทำความเข้าใจหนึ่งรายการ:

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

เพียงเพิ่มเงื่อนไขเพื่อตรวจสอบว่าค่าไม่ได้อยู่ในตำแหน่งก่อนหน้า