blocks|key|475051|text|这里有一些替代方案：http://www.peterbe.com/plog/uniqifiers-benchmark|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|475052|最快的一个：|475053|def+f7(seq):
++++seen+=+set()
++++seen_add+=+seen.add
++++return+[x+for+x+in+seq+if+not+(x+in+seen+or+seen_add(x))]|code-block|syntax|javascript|475054|为什么将seen.add分配给seen_add而不是只调用seen.add？Python是一种动态语言，每次迭代解析seen.add比解析局部变量花费更大。seen.add可能在迭代之间发生了变化，而且运行时不够聪明，无法排除这一点。为了安全起见，每次都要检查对象。|style|CODE|475055|如果您计划在相同的数据集中大量使用此函数，那么使用一个有序集：http://code.activestate.com/recipes/528878/可能会更好。|475056|O(1)每次操作的插入、删除和成员检查。|475057|(补充一点：seen.add()总是返回None，所以上面的or只是作为尝试一个集合更新的一种方式，而不是作为逻辑测试的一个组成部分)。|475058|entityMap|0|LINK|mutability|MUTABLE|url|http://www.peterbe.com/plog/uniqifiers-benchmark|1|http://code.activestate.com/recipes/528878/^0|A|1C|0|0|0|0|4|8|F|8|T|8|1M|8|26|8|0|V|17|1|0|0|6|A|K|4|U|2|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1A|8|@$A|1B|B|1C|M|N]|$A|1D|B|1E|M|N]|$A|1F|B|1G|M|N]|$A|1H|B|1I|M|N]|$A|1J|B|1K|M|N]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1L|8|@]|9|@$A|1M|B|1N|1|1O]]|C|$]]|$1|Q|3|R|5|6|7|1P|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1Q|8|@$A|1R|B|1S|M|N]|$A|1T|B|1U|M|N]|$A|1V|B|1W|M|N]]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1X|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|13]]]]

Here you have some alternatives: <a href="http://www.peterbe.com/plog/uniqifiers-benchmark" rel="noreferrer">http://www.peterbe.com/plog/uniqifiers-benchmark</a>

Fastest one:

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

Why assign <code>seen.add</code> to <code>seen_add</code> instead of just calling <code>seen.add</code>? Python is a dynamic language, and resolving <code>seen.add</code> each iteration is more costly than resolving a local variable. <code>seen.add</code> could have changed between iterations, and the runtime isn't smart enough to rule that out. To play it safe, it has to check the object each time.

If you plan on using this function a lot on the same dataset, perhaps you would be better off with an ordered set: <a href="http://code.activestate.com/recipes/528878/" rel="noreferrer">http://code.activestate.com/recipes/528878/</a>

O(1) insertion, deletion and member-check per operation.

(Small additional note: <code>seen.add()</code> always returns <code>None</code>, so the <code>or</code> above is there only as a way to attempt a set update, and not as an integral part of the logical test.)

blocks|key|770431|text|from+itertools+import+groupby
[+key+for+key,_+in+groupby(sortedList)]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|770432|这个列表甚至不需要排序，充分的条件是等值被分组在一起。|unstyled|770433|编辑:我假设“保持顺序”意味着列表实际上是有序的。如果不是这样，那么MizardX的解决方案就是正确的。|offset|length|style|BOLD|770434|社区编辑:然而，这是“将重复的连续元素压缩为单个元素”的最优雅的方法。|770435|entityMap^0|0|0|0|1G|0|0|Z|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|F|7|V|8|@$I|W|J|X|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>from itertools import groupby
[ key for key,_ in groupby(sortedList)]
</code></pre>

The list doesn't even have to be sorted, the sufficient condition is that equal values are grouped together.

Edit: I assumed that "preserving order" implies that the list is actually ordered. If this is not the case, then the solution from MizardX is the right one.

Community edit: This is however the most elegant way to "compress duplicate consecutive elements into a single element".

blocks|key|475126|text|如果你需要一个衬垫，也许这会有帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475127|reduce(lambda+x,+y:+x+%2B+y+if+y[0]+not+in+x+else+x,+map(lambda+x:+[x],lst))|code-block|syntax|javascript|475128|..。应该有用，但如果我错了，请纠正我|475129|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you need one liner then maybe this would help:

<pre><code>reduce(lambda x, y: x + y if y[0] not in x else x, map(lambda x: [x],lst))
</code></pre>

... should work but correct me if i'm wrong

blocks|key|771429|text|对于无法使用的类型(例如列表)，根据MizardX的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|771430|def+f7_noHash(seq)
++++seen+=+set()
++++return+[+x+for+x+in+seq+if+str(+x+)+not+in+seen+and+not+seen.add(+str(+x+)+)]|code-block|syntax|javascript|771431|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For no hashable types (e.g. list of lists), based on MizardX's:

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

blocks|key|475204|text|MizardX的回答很好地收集了多种方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475205|这就是我在大声思考的时候想到的：|475206|mylist+=+[x+for+i,x+in+enumerate(mylist)+if+x+not+in+mylist[i%2B1:]]|code-block|syntax|javascript|475207|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

MizardX's answer gives a good collection of multiple approaches.

This is what I came up with while thinking aloud:

<pre><code>mylist = [x for i,x in enumerate(mylist) if x not in mylist[i+1:]]
</code></pre>

blocks|key|771456|text|您可以引用列表理解，因为它是由符号'_1‘构建的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|771457|例如，下面的函数是唯一的--通过引用元素列表理解来表示元素列表，而不更改元素的顺序。|771458|def+unique(my_list):+
++++return+[x+for+x+in+my_list+if+x+not+in+locals()['_[1]']]|code-block|syntax|javascript|771459|演示：|771460|l1+=+[1,+2,+3,+4,+1,+2,+3,+4,+5]
l2+=+[x+for+x+in+l1+if+x+not+in+locals()['_[1]']]
print+l2|771461|输出：|771462|[1,+2,+3,+4,+5]|771463|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You can reference a list comprehension as it is being built by the symbol '_[1]'. For example, the following function unique-ifies a list of elements without changing their order by referencing its list comprehension.

<pre><code>def unique(my_list): 
 return [x for x in my_list if x not in locals()['_[1]']]
</code></pre>

Demo:

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

Output:

<pre><code>[1, 2, 3, 4, 5]
</code></pre>

blocks|key|475244|text|sequence+=+['1',+'2',+'3',+'3',+'6',+'4',+'5',+'6']
unique+=+[]
[unique.append(item)+for+item+in+sequence+if+item+not+in+unique]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|475245|唯一的['1',+'2',+'3',+'6',+'4',+'5']→|unstyled|offset|length|style|CODE|475246|entityMap^0|0|3|U|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

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

unique → <code>['1', '2', '3', '6', '4', '5']</code>

blocks|key|475269|text|我想如果你想维持秩序，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475270|你可以试试这个：|475271|list1+=+['b','c','d','b','c','a','a']++++
list2+=+list(set(list1))++++
list2.sort(key=list1.index)++++
print+list2|code-block|syntax|javascript|475272|同样，您也可以这样做：|475273|list1+=+['b','c','d','b','c','a','a']++
list2+=+sorted(set(list1),key=list1.index)++
print+list2+|475274|您也可以这样做：|475275|list1+=+['b','c','d','b','c','a','a']++++
list2+=+[]++++
for+i+in+list1:++++
++++if+not+i+in+list2:++
++++++++list2.append(i)`++++
print+list2|475276|它也可以写成如下：|475277|list1+=+['b','c','d','b','c','a','a']++++
list2+=+[]++++
[list2.append(i)+for+i+in+list1+if+not+i+in+list2]++++
print+list2+|475278|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

I think if you wanna maintain the order,

<h2>you can try this:</h2>

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

<h2>OR similarly you can do this:</h2>

<pre><code>list1 = ['b','c','d','b','c','a','a'] 
list2 = sorted(set(list1),key=list1.index) 
print list2 
</code></pre>

<h2>You can also do this:</h2>

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

<h2>It can also be written as this:</h2>

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

blocks|key|475310|text|最佳解决方案因Python版本和环境约束而不同：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475311|Python3.6(以及大多数支持3.6的解释器，作为实现细节)：|475312|最初是在PyPy+2.5.0中介绍的，并在CPython+3.6中作为实现细节而采用，然后才成为Python3.7中的语言保证，普通dict是按插入顺序排列的，甚至比(也是在CPython+3.5中实现的C语言)+collections.OrderedDict更有效。因此，到目前为止，最快的解决方案也是最简单的：|offset|length|style|CODE|475313|>>>+items+=+[1,+2,+0,+1,+3,+2]
>>>+list(dict.fromkeys(items))++#+Or+[*dict.fromkeys(items)]+if+you+prefer
[1,+2,+0,+3]|code-block|syntax|javascript|475314|与list(set(items))一样，这会将所有工作推到C层(在CPython上)，但是由于dict是按插入顺序排列的，所以dict.fromkeys不会失去排序。它比list(set(items))慢(通常需要50%25-100%25的时间)，但比其他任何保持顺序的解决方案都要快得多(大约需要in‘在列表中的一半时间)。|475315|重要注意事项：来自more_itertools的unique_everseen解决方案(见下文)在延迟和支持不可访问的输入项方面有一些独特的优势；如果您需要这些特性，这是唯一可行的解决方案。|BOLD|475316|Python3.5(如果性能不重要，所有旧版本)|475317|正如雷蒙德指出所言，在CPython+3.5中，OrderedDict是用C实现的，丑陋的列表理解黑客比OrderedDict.fromkeys慢(除非您在最后真正需要列表--即使这样，也只有在输入非常短的情况下才会这么做)。因此，在性能和可读性方面，CPython+3.5的最佳解决方案是OrderedDict等效于3.6%2B使用普通dict|475318|>>>+from+collections+import+OrderedDict
>>>+items+=+[1,+2,+0,+1,+3,+2]
>>>+list(OrderedDict.fromkeys(items))
[1,+2,+0,+3]|475319|在CPython+3.4和更早版本上，这将比其他一些解决方案慢，所以如果分析显示您需要更好的解决方案，请继续阅读。|475320|Python+3.4及更早版本，如果性能非常关键且第三方模块是可以接受的|475321|正如@abarnert所指出的，more_itertools库(pip+install+more_itertools)包含一个unique_everseen函数，它是为解决这个问题而构建的，在列表理解中没有任何不可读的+(not+seen.add)+突变。这也是最快的解决方案：|475322|>>>+from+more_itertools+import+unique_everseen
>>>+items+=+[1,+2,+0,+1,+3,+2]
>>>+list(unique_everseen(items))
[1,+2,+0,+3]|475323|只是一个简单的库导入和没有黑客。|475324|该模块正在调整迭代工具配方unique_everseen，如下所示：|475325|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|475326|但与itertools配方不同的是，它支持不可访问的项(这需要付出性能代价；如果iterable中的所有元素都是不可哈斯的，则算法将变成O(n²)，而如果它们都是可选的，则为O(n)+)。|475327|重要注意事项：与这里的所有其他解决方案不同，unique_everseen可以懒洋洋地使用；峰值内存使用量将相同(最终，底层set将增长到相同的大小)，但如果不对结果进行list处理，只需迭代它，就可以在找到唯一项时处理它们，而不是等到整个输入在处理第一个唯一项之前被删除。|475328|Python3.4及更早版本，如果性能非常关键且第三方模块不可用|475329|你有两个选择：|475330|复制并粘贴食谱到您的代码，并根据上面的more_itertools示例使用它|ordered-list-item|475331|使用丑陋的黑客可以让单一的listcomp同时检查和更新set，以跟踪所看到的内容：
seq+=+set()+x表示seq中的x，如果x不在set中，而不是seen.add(x)
以依赖丑陋的黑客为代价：
不是seen.add(x)
它依赖于这样一个事实，即set.add是一个始终返回None的就地方法，因此not+None的计算结果为True。|475332|请注意，上面所有的解决方案都是O(n)+(保存对不可访问项的unique_everseen调用，即O(n²)，而其他解决方案将立即在TypeError中失败)，所以当它们不是最热门的代码路径时，所有解决方案都具有足够的性能。使用哪个版本取决于您可以依赖哪个版本的语言规范/解释器/第三方模块，性能是否关键(不要假设它是关键的；它通常不是)，最重要的是可读性(因为如果维护这段代码的人后来心情不好，那么您聪明的微观优化可能就不值得了)。|475333|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/480227/364696|1|https://stackoverflow.com/a/39835527/336527|2|https://stackoverflow.com/a/19279812/1219006|3|https://pythonhosted.org/more-itertools/api.html|4|https://pythonhosted.org/more-itertools/api.html#more_itertools.unique_everseen|5|https://docs.python.org/3/library/itertools.html#itertools-recipes|6^0|0|0|1U|4|2Z|N|0|0|1|G|1B|4|1R|D|2D|G|41|7|0|0|0|6|9|E|O|F|0|0|O|B|1G|K|41|B|4N|4|5|2|1|0|0|0|0|G|E|W|Q|1R|F|33|C|2X|4|3H|2|2|9|2|G|E|3|1R|F|4|0|0|0|D|F|D|F|5|0|0|2|9|14|8|1W|5|2F|4|0|0|6|M|F|1Q|3|2D|4|0|0|0|J|E|5|2|6|0|S|3|3L|7|3Z|4|4B|8|4P|4|2L|5|0|F|4|U|F|1D|5|1U|9|0^^$0|@$1|2|3|4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2C|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|2D|8|@$F|2E|G|2F|H|I]|$F|2G|G|2H|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|2I|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|2J|8|@$F|2K|G|2L|H|I]|$F|2M|G|2N|H|I]|$F|2O|G|2P|H|I]|$F|2Q|G|2R|H|I]]|9|@$F|2S|G|2T|1|2U]]|A|$]]|$1|Q|3|R|5|6|7|2V|8|@$F|2W|G|2X|H|S]|$F|2Y|G|2Z|H|I]|$F|30|G|31|H|I]]|9|@]|A|$]]|$1|T|3|U|5|6|7|32|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|33|8|@$F|34|G|35|H|I]|$F|36|G|37|H|I]|$F|38|G|39|H|I]|$F|3A|G|3B|H|I]]|9|@$F|3C|G|3D|1|3E]]|A|$]]|$1|X|3|Y|5|L|7|3F|8|@]|9|@]|A|$M|N]]|$1|Z|3|10|5|6|7|3G|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|3H|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|3I|8|@$F|3J|G|3K|H|I]|$F|3L|G|3M|H|I]|$F|3N|G|3O|H|I]|$F|3P|G|3Q|H|I]|$F|3R|G|3S|H|S]|$F|3T|G|3U|H|S]]|9|@$F|3V|G|3W|1|3X]|$F|3Y|G|3Z|1|40]|$F|41|G|42|1|43]]|A|$]]|$1|15|3|16|5|L|7|44|8|@]|9|@]|A|$M|N]]|$1|17|3|18|5|6|7|45|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|46|8|@$F|47|G|48|H|I]]|9|@$F|49|G|4A|1|4B]]|A|$]]|$1|1B|3|1C|5|L|7|4C|8|@]|9|@]|A|$M|N]]|$1|1D|3|1E|5|6|7|4D|8|@$F|4E|G|4F|H|I]|$F|4G|G|4H|H|I]|$F|4I|G|4J|H|I]|$F|4K|G|4L|H|I]]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|4M|8|@$F|4N|G|4O|H|S]|$F|4P|G|4Q|H|I]|$F|4R|G|4S|H|I]|$F|4T|G|4U|H|I]]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|4V|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|4W|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|1N|7|4X|8|@$F|4Y|G|4Z|H|I]]|9|@$F|50|G|51|1|52]]|A|$]]|$1|1O|3|1P|5|1N|7|53|8|@$F|54|G|55|H|I]|$F|56|G|57|H|I]|$F|58|G|59|H|I]|$F|5A|G|5B|H|I]|$F|5C|G|5D|H|I]|$F|5E|G|5F|H|S]]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|5G|8|@$F|5H|G|5I|H|I]|$F|5J|G|5K|H|I]|$F|5L|G|5M|H|I]|$F|5N|G|5O|H|I]]|9|@]|A|$]]|$1|1S|3|-4|5|6|7|5P|8|@]|9|@]|A|$]]]|1T|$1U|$5|1V|1W|1X|A|$1Y|1Z]]|20|$5|1V|1W|1X|A|$1Y|21]]|22|$5|1V|1W|1X|A|$1Y|23]]|24|$5|1V|1W|1X|A|$1Y|25]]|26|$5|1V|1W|1X|A|$1Y|27]]|28|$5|1V|1W|1X|A|$1Y|29]]|2A|$5|1V|1W|1X|A|$1Y|29]]]]

The best solution varies by Python version and environment constraints:
<h4>Python 3.7+ (and most interpreters supporting 3.6, as an implementation detail):</h4>
First introduced in PyPy 2.5.0, and adopted in CPython 3.6 as an implementation detail, before being made a language guarantee in Python 3.7, plain <code>dict</code> is insertion-ordered, and even more efficient than the (also C implemented as of CPython 3.5) <code>collections.OrderedDict</code>. So the fastest solution, by far, is also the simplest:
<pre><code>&gt;&gt;&gt; items = [1, 2, 0, 1, 3, 2]
&gt;&gt;&gt; list(dict.fromkeys(items)) # Or [*dict.fromkeys(items)] if you prefer
[1, 2, 0, 3]
</code></pre>
Like <code>list(set(items))</code> this pushes all the work to the C layer (on CPython), but since <code>dict</code>s are insertion ordered, <code>dict.fromkeys</code> doesn't lose ordering. It's slower than <code>list(set(items))</code> (takes 50-100% longer typically), but much faster than any other order-preserving solution (takes about half the time of <a href="https://stackoverflow.com/a/480227/364696">hacks involving use of <code>set</code>s in a listcomp</a>).
Important note: The <code>unique_everseen</code> solution from <code>more_itertools</code> (see below) has some unique advantages in terms of laziness and support for non-hashable input items; if you need these features, it's the only solution that will work.
<h4>Python 3.5 (and all older versions if performance isn't critical)</h4>
As Raymond <a href="https://stackoverflow.com/a/39835527/336527">pointed out</a>, in CPython 3.5 where <code>OrderedDict</code> is implemented in C, ugly list comprehension hacks are slower than <code>OrderedDict.fromkeys</code> (unless you actually need the list at the end - and even then, only if the input is very short). So on both performance and readability the best solution for CPython 3.5 is the <code>OrderedDict</code> equivalent of the 3.6+ use of plain <code>dict</code>:
<pre><code>&gt;&gt;&gt; from collections import OrderedDict
&gt;&gt;&gt; items = [1, 2, 0, 1, 3, 2]
&gt;&gt;&gt; list(OrderedDict.fromkeys(items))
[1, 2, 0, 3]
</code></pre>
On CPython 3.4 and earlier, this will be slower than some other solutions, so if profiling shows you need a better solution, keep reading.
<h4>Python 3.4 and earlier, if performance is critical and third-party modules are acceptable</h4>
As <a href="https://stackoverflow.com/a/19279812/1219006">@abarnert</a> notes, the <a href="https://pythonhosted.org/more-itertools/api.html" rel="noreferrer"><code>more_itertools</code></a> library (<code>pip install more_itertools</code>) contains a <a href="https://pythonhosted.org/more-itertools/api.html#more_itertools.unique_everseen" rel="noreferrer"><code>unique_everseen</code></a> function that is built to solve this problem without any unreadable (<code>not seen.add</code>) mutations in list comprehensions. This is the fastest solution too:
<pre><code>&gt;&gt;&gt; from more_itertools import unique_everseen
&gt;&gt;&gt; items = [1, 2, 0, 1, 3, 2]
&gt;&gt;&gt; list(unique_everseen(items))
[1, 2, 0, 3]
</code></pre>
Just one simple library import and no hacks.
The module is adapting the itertools recipe <a href="https://docs.python.org/3/library/itertools.html#itertools-recipes" rel="noreferrer"><code>unique_everseen</code></a> which looks like:
<pre><code>def unique_everseen(iterable, key=None):
 &quot;List unique elements, preserving order. Remember all elements ever seen.&quot;
 # unique_everseen('AAAABBBCCDAABBB') --&gt; A B C D
 # unique_everseen('ABBCcAD', str.lower) --&gt; 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
</code></pre>
but unlike the <code>itertools</code> recipe, it supports non-hashable items (at a performance cost; if all elements in <code>iterable</code> are non-hashable, the algorithm becomes <code>O(n²)</code>, vs. <code>O(n)</code> if they're all hashable).
Important note: Unlike all the other solutions here, <code>unique_everseen</code> can be used lazily; the peak memory usage will be the same (eventually, the underlying <code>set</code> grows to the same size), but if you don't <code>list</code>ify the result, you just iterate it, you'll be able to process unique items as they're found, rather than waiting until the entire input has been deduplicated before processing the first unique item.
<h4>Python 3.4 and earlier, if performance is critical and third party modules are unavailable</h4>
You have two options:
<ol>
<li>Copy and paste in <a href="https://docs.python.org/3/library/itertools.html#itertools-recipes" rel="noreferrer">the <code>unique_everseen</code> recipe</a> to your code and use it per the <code>more_itertools</code> example above
</li>
<li>Use ugly hacks to allow a single listcomp to both check and update a <code>set</code> to track what's been seen:
<pre><code>seen = set()
[x for x in seq if x not in seen and not seen.add(x)]
</code></pre>
at the expense of relying on the ugly hack:
<pre><code> not seen.add(x)
</code></pre>
which relies on the fact that <code>set.add</code> is an in-place method that always returns <code>None</code> so <code>not None</code> evaluates to <code>True</code>.
</li>
</ol>
Note that all of the solutions above are <code>O(n)</code> (save calling <code>unique_everseen</code> on an iterable of non-hashable items, which is <code>O(n²)</code>, while the others would fail immediately with a <code>TypeError</code>), so all solutions are performant enough when they're not the hottest code path. Which one to use depends on which versions of the language spec/interpreter/third-party modules you can rely on, whether or not performance is critical (don't assume it is; it usually isn't), and most importantly, readability (because if the person who maintains this code later ends up in a murderous mood, your clever micro-optimization probably wasn't worth it).

blocks|key|770507|text|借鉴为列表定义Haskell的nub函数时使用的递归思想，这将是一种递归方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|770508|def+unique(lst):
++++return+[]+if+lst==[]+else+[lst[0]]+%2B+unique(filter(lambda+x:+x!=+lst[0],+lst[1:]))|code-block|syntax|javascript|770509|例如：|770510|In+[118]:+unique([1,5,1,1,4,3,4])
Out[118]:+[1,+5,+4,+3]|770511|我尝试了不断增长的数据大小，并看到了次线性时间复杂性(并不确定，但建议这应该是正常的数据)。|770512|In+[122]:+%25timeit+unique(np.random.randint(5,+size=(1)))
10000+loops,+best+of+3:+25.3+us+per+loop

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

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

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

In+[126]:+%25timeit+unique(np.random.randint(5,+size=(10000)))
100+loops,+best+of+3:+11+ms+per+loop|770513|我还认为有趣的是，这可以很容易地被其他操作推广到唯一性。如下所示：|770514|import+operator
def+unique(lst,+cmp_op=operator.ne):
++++return+[]+if+lst==[]+else+[lst[0]]+%2B+unique(filter(lambda+x:+cmp_op(x,+lst[0]),+lst[1:]),+cmp_op)|770515|例如，您可以传入一个函数，该函数使用舍入到相同整数的概念，就像为了唯一性目的它是“相等”一样，如下所示：|770516|def+test_round(x,y):
++++return+round(x)+!=+round(y)|770517|然后，unique(some_list，test_round)将提供列表中唯一的元素，其中唯一性不再意味着传统的等式(这是通过使用基于集合或基于切分键的方法来解决这个问题的)，而是意味着对于元素可能舍入的每一个可能的整数K，只需要取第一个循环到K的元素，例如：|770518|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]|770519|entityMap^0|F|3|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1C|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1E|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1G|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|1I|8|@]|D|@]|E|$]]|$1|12|3|13|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|14|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|15|$]]

Borrowing the recursive idea used in definining Haskell's <code>nub</code> function for lists, this would be a recursive approach:

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

e.g.:

<pre><code>In [118]: unique([1,5,1,1,4,3,4])
Out[118]: [1, 5, 4, 3]
</code></pre>

I tried it for growing data sizes and saw sub-linear time-complexity (not definitive, but suggests this should be fine for normal data).

<pre><code>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
</code></pre>

I also think it's interesting that this could be readily generalized to uniqueness by other operations. Like this:

<pre><code>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)
</code></pre>

For example, you could pass in a function that uses the notion of rounding to the same integer as if it was "equality" for uniqueness purposes, like this:

<pre><code>def test_round(x,y):
 return round(x) != round(y)
</code></pre>

then unique(some_list, test_round) would provide the unique elements of the list where uniqueness no longer meant traditional equality (which is implied by using any sort of set-based or dict-key-based approach to this problem) but instead meant to take only the first element that rounds to K for each possible integer K that the elements might round to, e.g.:

<pre><code>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]
</code></pre>

blocks|key|770551|text|相对有效的方法是使用_sorted_+a+numpy数组：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|770552|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]]])|code-block|syntax|javascript|770553|产出：|770554|array([+1,++3,++8,+12])|770555|entityMap^0|A|8|L|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

Relatively effective approach with <code>_sorted_</code> a <code>numpy</code> arrays:

<pre><code>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]]])
</code></pre>

Outputs:

<pre><code>array([ 1, 3, 8, 12])
</code></pre>

blocks|key|2008839|text|对于另一个很老的问题的另一个很晚的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2008840|菜谱有一个使用seen集技术执行此操作的函数，但是：|offset|length|style|CODE|2008841|处理标准的key函数。|unordered-list-item|2008842|不会使用不体面的黑客。|2008843|通过预绑定seen.add优化循环，而不是查找N次。(f7也会这样做，但有些版本不会这样做。)|2008844|通过使用ifilterfalse优化循环，所以您只需要遍历Python中的唯一元素，而不是所有元素。(当然，您仍然在ifilterfalse中遍历所有这些代码，但这是用C语言编写的，而且要快得多。)|2008845|它真的比f7快吗？这取决于您的数据，因此您将不得不测试和查看。如果您最后想要一个列表，f7使用listcomp，在这里没有办法做到这一点。(您可以直接append而不是yielding，也可以将生成器提供给list函数，但是两者都不能像listcomp中的LIST_APPEND那样快。)无论如何，通常来说，挤出几微秒并不像拥有一个容易理解的、可重用的、已经写好的功能一样重要，当你想要装饰的时候，它不需要DSU。|2008846|和所有的菜谱一样，它也可以在more-iterools中使用。|2008847|如果您只想使用no-key的情况，可以将其简化为：|2008848|def+unique(iterable):
++++seen+=+set()
++++seen_add+=+seen.add
++++for+element+in+itertools.ifilterfalse(seen.__contains__,+iterable):
++++++++seen_add(element)
++++++++yield+element|code-block|syntax|javascript|2008849|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/3/library/itertools.html#itertools-recipes|1|https://pypi.python.org/pypi/more-itertools^0|0|7|4|0|2|0|0|5|3|0|0|5|8|R|2|0|4|C|1M|C|0|4|2|17|2|23|6|2C|5|2V|4|0|E|D|E|D|1|0|A|3|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@$D|1D|E|1E|F|G]]|9|@$D|1F|E|1G|1|1H]]|A|$]]|$1|H|3|I|5|J|7|1I|8|@$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|K|3|L|5|J|7|1L|8|@]|9|@]|A|$]]|$1|M|3|N|5|J|7|1M|8|@$D|1N|E|1O|F|G]|$D|1P|E|1Q|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|1R|8|@$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1W|8|@$D|1X|E|1Y|F|G]|$D|1Z|E|20|F|G]|$D|21|E|22|F|G]|$D|23|E|24|F|G]|$D|25|E|26|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|27|8|@$D|28|E|29|F|G]]|9|@$D|2A|E|2B|1|2C]]|A|$]]|$1|U|3|V|5|6|7|2D|8|@$D|2E|E|2F|F|G]]|9|@]|A|$]]|$1|W|3|X|5|Y|7|2G|8|@]|9|@]|A|$Z|10]]|$1|11|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]]|12|$13|$5|14|15|16|A|$17|18]]|19|$5|14|15|16|A|$17|1A]]]]

For another very late answer to another very old question:

The <a href="http://docs.python.org/3/library/itertools.html#itertools-recipes"><code>itertools</code> recipes</a> have a function that does this, using the <code>seen</code> set technique, but:

<ul>
<li>Handles a standard <code>key</code> function.</li>
<li>Uses no unseemly hacks.</li>
<li>Optimizes the loop by pre-binding <code>seen.add</code> instead of looking it up N times. (<code>f7</code> also does this, but some versions don't.)</li>
<li>Optimizes the loop by using <code>ifilterfalse</code>, so you only have to loop over the unique elements in Python, instead of all of them. (You still iterate over all of them inside <code>ifilterfalse</code>, of course, but that's in C, and much faster.)</li>
</ul>

Is it actually faster than <code>f7</code>? It depends on your data, so you'll have to test it and see. If you want a list in the end, <code>f7</code> uses a listcomp, and there's no way to do that here. (You can directly <code>append</code> instead of <code>yield</code>ing, or you can feed the generator into the <code>list</code> function, but neither one can be as fast as the LIST_APPEND inside a listcomp.) At any rate, usually, squeezing out a few microseconds is not going to be as important as having an easily-understandable, reusable, already-written function that doesn't require DSU when you want to decorate.

As with all of the recipes, it's also available in <a href="https://pypi.python.org/pypi/more-itertools"><code>more-iterools</code></a>.

If you just want the no-<code>key</code> case, you can simplify it as:

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

blocks|key|772035|text|你可以做一个丑陋的名单理解黑客。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|772036|[l[i]+for+i+in+range(len(l))+if+l.index(l[i])+==+i]|code-block|syntax|javascript|772037|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You could do a sort of ugly list comprehension hack.

<pre><code>[l[i] for i in range(len(l)) if l.index(l[i]) == i]
</code></pre>

blocks|key|2008876|text|l+=+[1,2,2,3,3,...]
n+=+[]
n.extend(ele+for+ele+in+l+if+ele+not+in+set(n))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2008877|一个生成器表达式，它使用集合的O(1)查找来确定是否在新列表中包含一个元素。|unstyled|2008878|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>l = [1,2,2,3,3,...]
n = []
n.extend(ele for ele in l if ele not in set(n))
</code></pre>

A generator expression that uses the O(1) look up of a set to determine whether or not to include an element in the new list.

blocks|key|772047|text|5倍更快的减少变体，但更复杂|type|unstyled|depth|inlineStyleRanges|entityRanges|data|772048|>>>+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]|code-block|syntax|javascript|772049|解释：|772050|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]|772051|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

5 x faster reduce variant but more sophisticated

<pre><code>&gt;&gt;&gt; l = [5, 6, 6, 1, 1, 2, 2, 3, 4]
&gt;&gt;&gt; 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]
</code></pre>

Explanation:

<pre><code>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

&gt;&gt;&gt; reduce(reducer, l, default)[0]
[5, 6, 1, 2, 3, 4]
</code></pre>

blocks|key|2008904|text|一个简单的递归解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2008905|def+uniquefy_list(a):
++++return+uniquefy_list(a[1:])+if+a[0]+in+a[1:]+else+[a[0]]%2Buniquefy_list(a[1:])+if+len(a)>1+else+[a[0]]|code-block|syntax|javascript|2008906|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A simple recursive solution:

<pre><code>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)&gt;1 else [a[0]]
</code></pre>

blocks|key|475527|text|如果您经常使用pandas，并且美学优于性能，那么请考虑内置函数pandas.Series.drop_duplicates。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|475528|++++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|code-block|syntax|javascript|475529|时间安排：|475530|++++In+[104]:+%25timeit+f7(alist)
++++1000+loops,+best+of+3:+1.3+ms+per+loop
++++In+[110]:+%25timeit+uniquifier(alist)
++++100+loops,+best+of+3:+4.39+ms+per+loop|475531|entityMap|0|LINK|mutability|MUTABLE|url|http://pandas.pydata.org/^0|7|6|W|T|7|6|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

If you routinely use <a href="http://pandas.pydata.org/" rel="nofollow"><code>pandas</code></a>, and aesthetics is preferred over performance, then consider the built-in function <code>pandas.Series.drop_duplicates</code>:

<pre><code> 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
</code></pre>

Timing: 

<pre><code> 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
</code></pre>

blocks|key|772088|text|这将保持秩序，并在O(n)时间内运行。基本上，这个想法是在任何有重复发现的地方创建一个洞，然后把它沉到底部。使用读和写指针。每当发现重复时，只有读指针前进，而写指针停留在重复条目上以覆盖它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|772089|def+deduplicate(l):
++++count+=+{}
++++(read,write)+=+(0,0)
++++while+read+<+len(l):
++++++++if+l[read]+in+count:
++++++++++++read+%2B=+1
++++++++++++continue
++++++++count[l[read]]+=+True
++++++++l[write]+=+l[read]
++++++++read+%2B=+1
++++++++write+%2B=+1
++++return+l[0:write]|code-block|syntax|javascript|772090|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

this will preserve order and run in O(n) time. basically the idea is to create a hole wherever there is a duplicate found and sink it down to the bottom. makes use of a read and write pointer. whenever a duplicate is found only the read pointer advances and write pointer stays on the duplicate entry to overwrite it.

<pre><code>def deduplicate(l):
 count = {}
 (read,write) = (0,0)
 while read &lt; 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]
</code></pre>

blocks|key|475565|text|不使用导入模块或集合的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475566|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)|code-block|syntax|javascript|475567|给出输出：|475568|['ask',+'not',+'what',+'your',+'country',+'can',+'do',+'for',+'you']|475569|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

A solution without using imported modules or sets:

<pre><code>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)
</code></pre>

Gives output:

<pre><code>['ask', 'not', 'what', 'your', 'country', 'can', 'do', 'for', 'you']
</code></pre>

blocks|key|770629|text|In+CPython+3.6%2B+(以及从Python+3.7%2B开始的所有其他Python实现)，字典被命令，因此，在保持重复的同时保持原来的顺序，从迭代中删除重复项的方法如下：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|770630|>>>+list(dict.fromkeys('abracadabra'))
['a',+'b',+'r',+'c',+'d']|code-block|syntax|javascript|770631|在Python3.5及更低版本(包括Python2.7)中使用OrderedDict。我的时间显示，在Python3.5的各种方法中，这既是最快的，也是最短的(当它获得C实现时；在3.5之前，它仍然是最清晰的解决方案，虽然不是最快的)。|CODE|770632|>>>+from+collections+import+OrderedDict
>>>+list(OrderedDict.fromkeys('abracadabra'))
['a',+'b',+'r',+'c',+'d']|770633|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/whatsnew/3.7.html#summary-release-highlights|1|https://docs.python.org/3/library/collections.html#collections.OrderedDict^0|0|F|K|B|1E|3|0|0|0|0|A|I|9|V|B|V|B|1|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@$9|14|A|15|1|16]]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|M]]|D|@$9|1F|A|1G|1|1H]]|E|$]]|$1|N|3|O|5|H|7|1I|8|@]|D|@]|E|$I|J]]|$1|P|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|Q|$R|$5|S|T|U|E|$V|W]]|X|$5|S|T|U|E|$V|Y]]]]

In CPython 3.6+ (and all other Python implementations starting with Python 3.7+), dictionaries <a href="https://docs.python.org/3/whatsnew/3.7.html#summary-release-highlights" rel="noreferrer">are ordered</a>, so the way to remove duplicates from an iterable while keeping it in the original order is:
<pre><code>&gt;&gt;&gt; list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
</code></pre>
In Python 3.5 and below (including Python 2.7), use the <a href="https://docs.python.org/3/library/collections.html#collections.OrderedDict" rel="noreferrer"><code>OrderedDict</code></a>. My timings show that this is now both the fastest and shortest of the various approaches for Python 3.5 (when it gained a C implementation; prior to 3.5 it's still the clearest solution, though not the fastest).
<pre><code>&gt;&gt;&gt; from collections import OrderedDict
&gt;&gt;&gt; list(OrderedDict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
</code></pre>

blocks|key|475711|text|不要踢死马(这个问题很古老，已经有了很多好的答案)，但是这里有一个使用熊猫的解决方案，在很多情况下是相当快的，而且使用起来非常简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475712|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]|code-block|syntax|javascript|475713|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Not to kick a dead horse (this question is very old and already has lots of good answers), but here is a solution using pandas that is quite fast in many circumstances and is dead simple to use. 

<pre><code>import pandas as pd

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

&gt;&gt;&gt; pd.Series(my_list).drop_duplicates().tolist()
# Output:
# [0, 1, 2, 3, 4, 5]
</code></pre>

blocks|key|475751|text|在Python3.7和更高版本中，字典是用来记住它们的键插入顺序的有保证。这问题的答案总结了当前的状况。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|475752|因此，OrderedDict解决方案就过时了，没有任何导入语句，我们只需发出：|CODE|475753|>>>+lst+=+[1,+2,+1,+3,+3,+2,+4]
>>>+list(dict.fromkeys(lst))
[1,+2,+3,+4]|code-block|syntax|javascript|475754|entityMap|0|LINK|mutability|MUTABLE|url|https://mail.python.org/pipermail/python-dev/2017-December/151283.html|1|https://stackoverflow.com/questions/39980323/are-dictionaries-ordered-in-python-3-6^0|1|9|X|3|0|11|1|1|0|3|B|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]|$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|H]]|D|@]|E|$]]|$1|I|3|J|5|K|7|19|8|@]|D|@]|E|$L|M]]|$1|N|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]|V|$5|Q|R|S|E|$T|W]]]]

In Python 3.7 and above, dictionaries are <a href="https://mail.python.org/pipermail/python-dev/2017-December/151283.html" rel="noreferrer">guaranteed</a> to remember their key insertion order. The answer to <a href="https://stackoverflow.com/questions/39980323/are-dictionaries-ordered-in-python-3-6">this</a> question summarizes the current state of affairs.

The <code>OrderedDict</code> solution thus becomes obsolete and without any import statements we can simply issue:

<pre><code>&gt;&gt;&gt; lst = [1, 2, 1, 3, 3, 2, 4]
&gt;&gt;&gt; list(dict.fromkeys(lst))
[1, 2, 3, 4]
</code></pre>

blocks|key|475782|text|就地法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475783|这个方法是二次型的，因为我们对列表中的每个元素都有一个线性查找(由于del+s，我们必须增加重新排列列表的成本)。|offset|length|style|CODE|475784|尽管如此，如果我们从列表的末尾开始，然后继续到原点，删除在子列表左边的每个术语，就可以在适当的位置操作。|475785|代码中的这个想法很简单|475786|for+i+in+range(len(l)-1,0,-1):+
++++if+l[i]+in+l[:i]:+del+l[i]+|code-block|syntax|javascript|475787|实现的简单测试|475788|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]:+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|475789|entityMap^0|0|Y|3|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|12|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|14|8|@]|9|@]|A|$O|P]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

<h3>An in-place method</h3>

This method is quadratic, because we have a linear lookup into the list for every element of the list (to that we have to add the cost of rearranging the list because of the <code>del</code> s).

That said, it is possible to operate in place if we start from the end of the list and proceed toward the origin removing each term that is present in the sub-list at its left

This idea in code is simply

<pre><code>for i in range(len(l)-1,0,-1): 
 if l[i] in l[:i]: del l[i] 
</code></pre>

<hr>

A simple test of the implementation

<pre><code>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]: 
</code></pre>

blocks|key|2009113|text|删除序列中的重复值，但保留其余项的顺序。通用发生器功能的使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2009114|#+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}]|code-block|syntax|javascript|2009115|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Eliminating the duplicate values in a sequence, but preserve the order of the remaining items. Use of general purpose generator function.

<pre><code># 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}]
</code></pre>

blocks|key|772155|text|下面是一个简单的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|772156|list1+=+["hello",+"+",+"w",+"o",+"r",+"l",+"d"]
sorted(set(list1+),+key=list1.index)|code-block|syntax|javascript|772157|这给出了输出：|772158|["hello",+"+",+"w",+"o",+"r",+"l",+"d"]|772159|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

here is a simple way to do it:
<pre><code>list1 = [&quot;hello&quot;, &quot; &quot;, &quot;w&quot;, &quot;o&quot;, &quot;r&quot;, &quot;l&quot;, &quot;d&quot;]
sorted(set(list1 ), key=list1.index)
</code></pre>
that gives the output:
<pre><code>[&quot;hello&quot;, &quot; &quot;, &quot;w&quot;, &quot;o&quot;, &quot;r&quot;, &quot;l&quot;, &quot;d&quot;]
</code></pre>

blocks|key|770729|text|熊猫用户应该查看pandas.unique。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|770730|>>>+import+pandas+as+pd
>>>+lst+=+[1,+2,+1,+3,+3,+2,+4]
>>>+pd.unique(lst)
array([1,+2,+3,+4])|code-block|syntax|javascript|770731|函数返回一个NumPy数组。如果需要，可以使用tolist方法将其转换为列表。|770732|entityMap|0|LINK|mutability|MUTABLE|url|https://pandas.pydata.org/docs/reference/api/pandas.unique.html|1|https://numpy.org/doc/1.18/reference/generated/numpy.ndarray.tolist.html^0|8|D|8|D|0|0|0|N|6|N|6|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

pandas users should check out <a href="https://pandas.pydata.org/docs/reference/api/pandas.unique.html" rel="noreferrer"><code>pandas.unique</code></a>.

<pre><code>&gt;&gt;&gt; import pandas as pd
&gt;&gt;&gt; lst = [1, 2, 1, 3, 3, 2, 4]
&gt;&gt;&gt; pd.unique(lst)
array([1, 2, 3, 4])
</code></pre>

The function returns a NumPy array. If needed, you can convert it to a list with the <a href="https://numpy.org/doc/1.18/reference/generated/numpy.ndarray.tolist.html" rel="noreferrer"><code>tolist</code></a> method.

blocks|key|475828|text|一个线性列表理解：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|475829|values_non_duplicated+=+[value+for+index,+value+in+enumerate(values)+if+value+not+in+values[+:+index]]|code-block|syntax|javascript|475830|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

One liner list comprehension:
<pre><code>values_non_duplicated = [value for index, value in enumerate(values) if value not in values[ : index]]
</code></pre>

blocks|key|475834|text|x+=+[1,+2,+1,+3,+1,+4]

#+brute+force+method
arr+=+[]
for+i+in+x:
++if+not+i+in+arr:
++++arr.insert(x[i],i)

#+recursive+method
tmp+=+[]
def+remove_duplicates(j=0):
++++if+j+<+len(x):
++++++if+not+x[j]+in+tmp:
++++++++tmp.append(x[j])
++++++i+=+j%2B1++
++++++remove_duplicates(i)

++++++

remove_duplicates()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|475835|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>x = [1, 2, 1, 3, 1, 4]

# brute force method
arr = []
for i in x:
 if not i in arr:
 arr.insert(x[i],i)

# recursive method
tmp = []
def remove_duplicates(j=0):
 if j &lt; len(x):
 if not x[j] in tmp:
 tmp.append(x[j])
 i = j+1 
 remove_duplicates(i)

 

remove_duplicates()
</code></pre>

How do I remove duplicates from a list, while preserving order? Using a set to remove duplicates destroys the original order.
Is there a built-in or a Pythonic idiom?

How do I remove duplicates from a list, while preserving order?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如何在保留顺序的同时从列表中删除重复项？使用集合移除重复项会破坏原始订单。有没有内置的或者是Pythonic的成语？

问如何在保留顺序的同时从列表中删除重复项？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在保留顺序的同时从列表中删除重复项？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在保留顺序的同时从列表中删除重复项？
EN