blocks|key|1220394|text|如果你喜欢函数式编程风格，这里有一个有用的函数，它是使用doctest进行自我记录和测试的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1220395|def+decompose(a_list):
++++"""Turns+a+list+into+a+set+of+all+elements+and+a+set+of+duplicated+elements.

++++Returns+a+pair+of+sets.+The+first+one+contains+elements
++++that+are+found+at+least+once+in+the+list.+The+second+one
++++contains+elements+that+appear+more+than+once.

++++>>>+decompose([1,2,3,5,3,2,6])
++++(set([1,+2,+3,+5,+6]),+set([2,+3]))
++++"""
++++return+reduce(
++++++++lambda+(u,+d),+o+:+(u.union([o]),+d.union(u.intersection([o]))),
++++++++a_list,
++++++++(set(),+set()))

if+__name__+==+"__main__":
++++import+doctest
++++doctest.testmod()|code-block|syntax|javascript|1220396|在那里，您可以通过检查返回对的第二个元素是否为空来测试单一性：|1220397|def+is_set(l):
++++"""Test+if+there+is+no+duplicate+element+in+l.

++++>>>+is_set([1,2,3])
++++True
++++>>>+is_set([1,2,1])
++++False
++++>>>+is_set([])
++++True
++++"""
++++return+not+decompose(l)[1]|1220398|请注意，这并不是很有效，因为您是显式地构造分解。但在使用reduce的过程中，你可以得出一些等价的(但效率稍低)的答案5：|1220399|def+is_set(l):
++++try:
++++++++def+func(s,+o):
++++++++++++if+o+in+s:
++++++++++++++++raise+Exception
++++++++++++return+s.union([o])
++++++++reduce(func,+l,+set())
++++++++return+True
++++except:
++++++++return+False|1220400|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/doctest.html^0|S|7|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

If you are fond of functional programming style, here is a useful function, self-documented and tested code using <a href="http://docs.python.org/library/doctest.html" rel="noreferrer">doctest</a>.

<pre><code>def decompose(a_list):
 """Turns a list into a set of all elements and a set of duplicated elements.

 Returns a pair of sets. The first one contains elements
 that are found at least once in the list. The second one
 contains elements that appear more than once.

 &gt;&gt;&gt; decompose([1,2,3,5,3,2,6])
 (set([1, 2, 3, 5, 6]), set([2, 3]))
 """
 return reduce(
 lambda (u, d), o : (u.union([o]), d.union(u.intersection([o]))),
 a_list,
 (set(), set()))

if __name__ == "__main__":
 import doctest
 doctest.testmod()
</code></pre>

From there you can test unicity by checking whether the second element of the returned pair is empty:

<pre><code>def is_set(l):
 """Test if there is no duplicate element in l.

 &gt;&gt;&gt; is_set([1,2,3])
 True
 &gt;&gt;&gt; is_set([1,2,1])
 False
 &gt;&gt;&gt; is_set([])
 True
 """
 return not decompose(l)[1]
</code></pre>

Note that this is not efficient since you are explicitly constructing the decomposition. But along the line of using reduce, you can come up to something equivalent (but slightly less efficient) to answer 5:

<pre><code>def is_set(l):
 try:
 def func(s, o):
 if o in s:
 raise Exception
 return s.union([o])
 reduce(func, l, set())
 return True
 except:
 return False
</code></pre>

blocks|key|1435456|text|这是旧的，但这里的答案让我得到了一个略有不同的解决方案。如果你准备滥用理解，你可以通过这种方式获得短路。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1435457|xs+=+[1,+2,+1]
s+=+set()
any(x+in+s+or+s.add(x)+for+x+in+xs)
#+You+can+use+a+similar+approach+to+actually+retrieve+the+duplicates.
s+=+set()
duplicates+=+set(x+for+x+in+xs+if+x+in+s+or+s.add(x))|code-block|syntax|javascript|1435458|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 is old, but the answers here led me to a slightly different solution. If you are up for abusing comprehensions, you can get short-circuiting this way.

<pre><code>xs = [1, 2, 1]
s = set()
any(x in s or s.add(x) for x in xs)
# You can use a similar approach to actually retrieve the duplicates.
s = set()
duplicates = set(x for x in xs if x in s or s.add(x))
</code></pre>

blocks|key|1220512|text|最近，我使用生成器在列表中回答了一个与establish+all+the+duplicates相关的问题。它的优点是，如果只是用来确定“如果有重复的话”，那么你只需要获得第一个项目，其余的可以忽略，这是最终的捷径。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1220513|这是我直接从moooeeeep改编的一种有趣的基于集合的方法|1220514|def+getDupes(l):
++++seen+=+set()
++++seen_add+=+seen.add
++++for+x+in+l:
++++++++if+x+in+seen+or+seen_add(x):
++++++++++++yield+x|code-block|syntax|javascript|1220515|因此，完整的受骗列表将是list(getDupes(etc))。为了简单地测试“是否”有一个副本，它应该被包装如下：|style|CODE|1220516|def+hasDupes(l):
++++try:
++++++++if+getDupes(l).next():+return+True++++#+Found+a+dupe
++++except+StopIteration:
++++++++pass
++++return+False|1220517|这可以很好地扩展，并在列表中的任何位置提供一致的操作时间--我使用多达1m个条目的列表进行了测试。如果您对数据有所了解，特别是知道可能会在上半年出现的复制，或者其他让您扭曲需求的东西，比如需要获取实际的复制，那么有几个真正的替代复制定位器可能会表现更好。我推荐的两个是..。|1220518|简单的基于字典的方法，非常易读：|1220519|def+getDupes(c):
++++d+=+{}
++++for+i+in+c:
++++++++if+i+in+d:
++++++++++++if+d[i]:
++++++++++++++++yield+i
++++++++++++++++d[i]+=+False
++++++++else:
++++++++++++d[i]+=+True|1220520|在排序列表中利用itertools+(本质上是一个ifilter/izip/tee)，如果你得到了所有的副本，那么效率会非常高，尽管没有那么快就得到第一个：|1220521|def+getDupes(c):
++++a,+b+=+itertools.tee(sorted(c))
++++next(b,+None)
++++r+=+None
++++for+k,+g+in+itertools.ifilter(lambda+x:+x[0]==x[1],+itertools.izip(a,+b)):
++++++++if+k+!=+r:
++++++++++++yield+k
++++++++++++r+=+k|1220522|这些是我为full+dupe+list尝试的方法中表现最好的，第一个复制出现在从开始到中间的1m元素列表中的任何位置。令人惊讶的是，排序步骤增加的开销是如此之少。您的里程数可能会有所不同，但以下是我的特定计时结果：|1220523|Finding+FIRST+duplicate,+single+dupe+places+"n"+elements+in+to+1m+element+array

Test+set+len+change+:++++++++50+-++.+.+.+.+.++--+0.002
Test+in+dict++++++++:++++++++50+-++.+.+.+.+.++--+0.002
Test+in+set+++++++++:++++++++50+-++.+.+.+.+.++--+0.002
Test+sort/adjacent++:++++++++50+-++.+.+.+.+.++--+0.023
Test+sort/groupby+++:++++++++50+-++.+.+.+.+.++--+0.026
Test+sort/zip+++++++:++++++++50+-++.+.+.+.+.++--+1.102
Test+sort/izip++++++:++++++++50+-++.+.+.+.+.++--+0.035
Test+sort/tee/izip++:++++++++50+-++.+.+.+.+.++--+0.024
Test+moooeeeep++++++:++++++++50+-++.+.+.+.+.++--+0.001+*
Test+iter*/sorted+++:++++++++50+-++.+.+.+.+.++--+0.027

Test+set+len+change+:++++++5000+-++.+.+.+.+.++--+0.017
Test+in+dict++++++++:++++++5000+-++.+.+.+.+.++--+0.003+*
Test+in+set+++++++++:++++++5000+-++.+.+.+.+.++--+0.004
Test+sort/adjacent++:++++++5000+-++.+.+.+.+.++--+0.031
Test+sort/groupby+++:++++++5000+-++.+.+.+.+.++--+0.035
Test+sort/zip+++++++:++++++5000+-++.+.+.+.+.++--+1.080
Test+sort/izip++++++:++++++5000+-++.+.+.+.+.++--+0.043
Test+sort/tee/izip++:++++++5000+-++.+.+.+.+.++--+0.031
Test+moooeeeep++++++:++++++5000+-++.+.+.+.+.++--+0.003+*
Test+iter*/sorted+++:++++++5000+-++.+.+.+.+.++--+0.031

Test+set+len+change+:+++++50000+-++.+.+.+.+.++--+0.035
Test+in+dict++++++++:+++++50000+-++.+.+.+.+.++--+0.023
Test+in+set+++++++++:+++++50000+-++.+.+.+.+.++--+0.023
Test+sort/adjacent++:+++++50000+-++.+.+.+.+.++--+0.036
Test+sort/groupby+++:+++++50000+-++.+.+.+.+.++--+0.134
Test+sort/zip+++++++:+++++50000+-++.+.+.+.+.++--+1.121
Test+sort/izip++++++:+++++50000+-++.+.+.+.+.++--+0.054
Test+sort/tee/izip++:+++++50000+-++.+.+.+.+.++--+0.045
Test+moooeeeep++++++:+++++50000+-++.+.+.+.+.++--+0.019+*
Test+iter*/sorted+++:+++++50000+-++.+.+.+.+.++--+0.055

Test+set+len+change+:++++500000+-++.+.+.+.+.++--+0.249
Test+in+dict++++++++:++++500000+-++.+.+.+.+.++--+0.145
Test+in+set+++++++++:++++500000+-++.+.+.+.+.++--+0.165
Test+sort/adjacent++:++++500000+-++.+.+.+.+.++--+0.139
Test+sort/groupby+++:++++500000+-++.+.+.+.+.++--+1.138
Test+sort/zip+++++++:++++500000+-++.+.+.+.+.++--+1.159
Test+sort/izip++++++:++++500000+-++.+.+.+.+.++--+0.126
Test+sort/tee/izip++:++++500000+-++.+.+.+.+.++--+0.120+*
Test+moooeeeep++++++:++++500000+-++.+.+.+.+.++--+0.131
Test+iter*/sorted+++:++++500000+-++.+.+.+.+.++--+0.157|1220524|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/9835762/find-and-list-duplicates-in-python-list/31439372#31439372|1|https://stackoverflow.com/users/1025391/moooeeeep|2^0|J|S|0|0|6|9|1|0|0|C|J|0|0|0|0|0|0|0|5|E|2|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]]|C|$]]|$1|D|3|E|5|6|7|1J|8|@]|9|@$A|1K|B|1L|1|1M]]|C|$]]|$1|F|3|G|5|H|7|1N|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1O|8|@$A|1P|B|1Q|M|N]]|9|@]|C|$]]|$1|O|3|P|5|H|7|1R|8|@]|9|@]|C|$I|J]]|$1|Q|3|R|5|6|7|1S|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1T|8|@]|9|@]|C|$]]|$1|U|3|V|5|H|7|1U|8|@]|9|@]|C|$I|J]]|$1|W|3|X|5|6|7|1V|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|H|7|1W|8|@]|9|@]|C|$I|J]]|$1|10|3|11|5|6|7|1X|8|@]|9|@$A|1Y|B|1Z|1|20]]|C|$]]|$1|12|3|13|5|H|7|21|8|@]|9|@]|C|$I|J]]|$1|14|3|-4|5|6|7|22|8|@]|9|@]|C|$]]]|15|$16|$5|17|18|19|C|$1A|1B]]|1C|$5|17|18|19|C|$1A|1D]]|1E|$5|17|18|19|C|$1A|1B]]]]

I recently answered a related question to <a href="https://stackoverflow.com/questions/9835762/find-and-list-duplicates-in-python-list/31439372#31439372">establish all the duplicates</a> in a list, using a generator. It has the advantage that if used just to establish 'if there is a duplicate' then you just need to get the first item and the rest can be ignored, which is the ultimate shortcut.

This is an interesting set based approach I adapted straight from <a href="https://stackoverflow.com/users/1025391/moooeeeep">moooeeeep</a>:

<pre><code>def getDupes(l):
 seen = set()
 seen_add = seen.add
 for x in l:
 if x in seen or seen_add(x):
 yield x
</code></pre>

Accordingly, a full list of dupes would be <code>list(getDupes(etc))</code>. To simply test "if" there is a dupe, it should be wrapped as follows:

<pre><code>def hasDupes(l):
 try:
 if getDupes(l).next(): return True # Found a dupe
 except StopIteration:
 pass
 return False
</code></pre>

This scales well and provides consistent operating times wherever the dupe is in the list -- I tested with lists of up to 1m entries. If you know something about the data, specifically, that dupes are likely to show up in the first half, or other things that let you skew your requirements, like needing to get the actual dupes, then there are a couple of really alternative dupe locators that might outperform. The two I recommend are...

Simple dict based approach, very readable:

<pre><code>def getDupes(c):
 d = {}
 for i in c:
 if i in d:
 if d[i]:
 yield i
 d[i] = False
 else:
 d[i] = True
</code></pre>

Leverage itertools (essentially an ifilter/izip/tee) on the sorted list, very efficient if you are getting all the dupes though not as quick to get just the first:

<pre><code>def getDupes(c):
 a, b = itertools.tee(sorted(c))
 next(b, None)
 r = None
 for k, g in itertools.ifilter(lambda x: x[0]==x[1], itertools.izip(a, b)):
 if k != r:
 yield k
 r = k
</code></pre>

These were the top performers from the approaches I tried for the <a href="https://stackoverflow.com/questions/9835762/find-and-list-duplicates-in-python-list/31439372#31439372">full dupe list</a>, with the first dupe occurring anywhere in a 1m element list from the start to the middle. It was surprising how little overhead the sort step added. Your mileage may vary, but here are my specific timed results:

<pre><code>Finding FIRST duplicate, single dupe places "n" elements in to 1m element array

Test set len change : 50 - . . . . . -- 0.002
Test in dict : 50 - . . . . . -- 0.002
Test in set : 50 - . . . . . -- 0.002
Test sort/adjacent : 50 - . . . . . -- 0.023
Test sort/groupby : 50 - . . . . . -- 0.026
Test sort/zip : 50 - . . . . . -- 1.102
Test sort/izip : 50 - . . . . . -- 0.035
Test sort/tee/izip : 50 - . . . . . -- 0.024
Test moooeeeep : 50 - . . . . . -- 0.001 *
Test iter*/sorted : 50 - . . . . . -- 0.027

Test set len change : 5000 - . . . . . -- 0.017
Test in dict : 5000 - . . . . . -- 0.003 *
Test in set : 5000 - . . . . . -- 0.004
Test sort/adjacent : 5000 - . . . . . -- 0.031
Test sort/groupby : 5000 - . . . . . -- 0.035
Test sort/zip : 5000 - . . . . . -- 1.080
Test sort/izip : 5000 - . . . . . -- 0.043
Test sort/tee/izip : 5000 - . . . . . -- 0.031
Test moooeeeep : 5000 - . . . . . -- 0.003 *
Test iter*/sorted : 5000 - . . . . . -- 0.031

Test set len change : 50000 - . . . . . -- 0.035
Test in dict : 50000 - . . . . . -- 0.023
Test in set : 50000 - . . . . . -- 0.023
Test sort/adjacent : 50000 - . . . . . -- 0.036
Test sort/groupby : 50000 - . . . . . -- 0.134
Test sort/zip : 50000 - . . . . . -- 1.121
Test sort/izip : 50000 - . . . . . -- 0.054
Test sort/tee/izip : 50000 - . . . . . -- 0.045
Test moooeeeep : 50000 - . . . . . -- 0.019 *
Test iter*/sorted : 50000 - . . . . . -- 0.055

Test set len change : 500000 - . . . . . -- 0.249
Test in dict : 500000 - . . . . . -- 0.145
Test in set : 500000 - . . . . . -- 0.165
Test sort/adjacent : 500000 - . . . . . -- 0.139
Test sort/groupby : 500000 - . . . . . -- 1.138
Test sort/zip : 500000 - . . . . . -- 1.159
Test sort/izip : 500000 - . . . . . -- 0.126
Test sort/tee/izip : 500000 - . . . . . -- 0.120 *
Test moooeeeep : 500000 - . . . . . -- 0.131
Test iter*/sorted : 500000 - . . . . . -- 0.157
</code></pre>

blocks|key|1220576|text|另一种简洁的方法是使用Counter。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1220577|要确定原始列表中是否有重复项，请执行以下操作：|1220578|from+collections+import+Counter

def+has_dupes(l):
++++#+second+element+of+the+tuple+has+number+of+repetitions
++++return+Counter(l).most_common()[0][1]+>+1|code-block|syntax|javascript|1220579|或获取具有重复项的项目列表：|1220580|def+get_dupes(l):
++++return+[k+for+k,+v+in+Counter(l).items()+if+v+>+1]|1220581|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3.6/library/collections.html#collections.Counter^0|B|7|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Another way of doing this succinctly is with <a href="https://docs.python.org/3.6/library/collections.html#collections.Counter" rel="nofollow noreferrer">Counter</a>.

To just determine if there are any duplicates in the original list:

<pre><code>from collections import Counter

def has_dupes(l):
 # second element of the tuple has number of repetitions
 return Counter(l).most_common()[0][1] &gt; 1
</code></pre>

Or to get a list of items that have duplicates:

<pre><code>def get_dupes(l):
 return [k for k, v in Counter(l).items() if v &gt; 1]
</code></pre>

blocks|key|1435657|text|我发现这样做的性能最好，因为它在第一次发现重复时缩短了操作，然后这个算法的时间和空间复杂度为O(n)，其中n是列表的长度：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1435658|def+has_duplicated_elements(iterable):
++++"""+Given+an+`iterable`,+return+True+if+there+are+duplicated+entries.+"""
++++clean_elements_set+=+set()
++++clean_elements_set_add+=+clean_elements_set.add

++++for+possible_duplicate_element+in+iterable:

++++++++if+possible_duplicate_element+in+clean_elements_set:
++++++++++++return+True

++++++++else:
++++++++++++clean_elements_set_add(+possible_duplicate_element+)

++++return+False|code-block|syntax|javascript|1435659|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|$]]

I found this to do the best performance because it short-circuit the operation when the first duplicated it found, then this algorithm has time and space complexity O(n) where n is the list's length:

<pre><code>def has_duplicated_elements(iterable):
 """ Given an `iterable`, return True if there are duplicated entries. """
 clean_elements_set = set()
 clean_elements_set_add = clean_elements_set.add

 for possible_duplicate_element in iterable:

 if possible_duplicate_element in clean_elements_set:
 return True

 else:
 clean_elements_set_add( possible_duplicate_element )

 return False
</code></pre>

blocks|key|1435701|text|我真的不知道set在幕后做了什么，所以我只想让它保持简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1435702|def+dupes(num_list):
++++unique+=+[]
++++dupes+=+[]
++++for+i+in+num_list:
++++++++if+i+not+in+unique:
++++++++++++unique.append(i)
++++++++else:
++++++++++++dupes.append(i)
++++if+len(dupes)+!=+0:
++++++++return+False
++++else:
++++++++return+True|code-block|syntax|javascript|1435703|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|$]]

I dont really know what set does behind the scenes, so I just like to keep it simple.

<pre><code>def dupes(num_list):
 unique = []
 dupes = []
 for i in num_list:
 if i not in unique:
 unique.append(i)
 else:
 dupes.append(i)
 if len(dupes) != 0:
 return False
 else:
 return True
</code></pre>

blocks|key|1435763|text|更简单的解决方案如下所示。只需用pandas+.duplicated()方法检查True/False，然后求和。另请参阅pandas.Series.duplicated+—+pandas+0.24.1+documentation|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1435764|import+pandas+as+pd

def+has_duplicated(l):
++++return+pd.Series(l).duplicated().sum()+>+0

print(has_duplicated(['one',+'two',+'one']))
#+True
print(has_duplicated(['one',+'two',+'three']))
#+False|code-block|syntax|javascript|1435765|entityMap|0|LINK|mutability|MUTABLE|url|https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.duplicated.html#pandas.Series.duplicated^0|N|D|1O|1I|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

A more simple solution is as follows. Just check True/False with pandas <code>.duplicated()</code> method and then take sum. Please also see <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.duplicated.html#pandas.Series.duplicated" rel="nofollow noreferrer">pandas.Series.duplicated — pandas 0.24.1 documentation</a> 

<pre class="lang-python prettyprint-override"><code>import pandas as pd

def has_duplicated(l):
 return pd.Series(l).duplicated().sum() &gt; 0

print(has_duplicated(['one', 'two', 'one']))
# True
print(has_duplicated(['one', 'two', 'three']))
# False
</code></pre>

blocks|key|1435815|text|如果列表包含不可散列的项，则可以使用Alex+Martelli's+solution，但使用列表而不是集合，但对于较大的输入会更慢:+O(N%5E2)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1435816|def+has_duplicates(iterable):
++++seen+=+[]
++++for+x+in+iterable:
++++++++if+x+in+seen:
++++++++++++return+True
++++++++seen.append(x)
++++return+False|code-block|syntax|javascript|1435817|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/1541820/4518341^0|I|O|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

If the list contains unhashable items, you can use <a href="https://stackoverflow.com/a/1541820/4518341">Alex Martelli's solution</a> but with a list instead of a set, though it's slower for larger inputs: O(N^2).

<pre><code>def has_duplicates(iterable):
 seen = []
 for x in iterable:
 if x in seen:
 return True
 seen.append(x)
 return False
</code></pre>

blocks|key|1220880|text|我认为比较这里给出的不同解决方案的时间会很有用。为此，我使用了自己的库simple_benchmark|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1220881|​|1220882|📷|atomic|1220883|1220884|因此，对于这种情况，Denis+Otkidach的解决方案确实是最快的。|1220885|其中一些方法也表现出更陡峭的曲线，这些方法随着元素的数量进行二次缩放(Alex+Martellis+solution，wjandrea和这两个Xavier+Decorets解决方案)。同样值得一提的是，来自Keiku的熊猫解决方案有一个非常大的恒定因素。但对于更大的列表，它几乎赶上了其他解决方案。|1220886|并且在复制品位于第一位置的情况下。这有助于查看哪些解决方案是短路的：|1220887|1220888|1220889|1220890|这里有几种方法没有短路:+Kaiku，Frank，Xavier_Decoret+(第一种解决方案)，Turn，Alex+Martelli+(第一种解决方案)和Denis+Otkidach提出的方法(在无重复的情况下最快)。|1220891|我在这里包含了我自己的库中的一个函数：iteration_utilities.all_distinct，它可以在无重复的情况下与最快的解决方案竞争，并且在开始复制的情况下以恒定的时间执行(尽管没有那么快)。|1220892|基准测试的代码如下：|1220893|from+collections+import+Counter
from+functools+import+reduce

import+pandas+as+pd
from+simple_benchmark+import+BenchmarkBuilder
from+iteration_utilities+import+all_distinct

b+=+BenchmarkBuilder()

@b.add_function()
def+Keiku(l):
++++return+pd.Series(l).duplicated().sum()+>+0

@b.add_function()
def+Frank(num_list):
++++unique+=+[]
++++dupes+=+[]
++++for+i+in+num_list:
++++++++if+i+not+in+unique:
++++++++++++unique.append(i)
++++++++else:
++++++++++++dupes.append(i)
++++if+len(dupes)+!=+0:
++++++++return+False
++++else:
++++++++return+True

@b.add_function()
def+wjandrea(iterable):
++++seen+=+[]
++++for+x+in+iterable:
++++++++if+x+in+seen:
++++++++++++return+True
++++++++seen.append(x)
++++return+False

@b.add_function()
def+user(iterable):
++++clean_elements_set+=+set()
++++clean_elements_set_add+=+clean_elements_set.add

++++for+possible_duplicate_element+in+iterable:

++++++++if+possible_duplicate_element+in+clean_elements_set:
++++++++++++return+True

++++++++else:
++++++++++++clean_elements_set_add(+possible_duplicate_element+)

++++return+False

@b.add_function()
def+Turn(l):
++++return+Counter(l).most_common()[0][1]+>+1

def+getDupes(l):
++++seen+=+set()
++++seen_add+=+seen.add
++++for+x+in+l:
++++++++if+x+in+seen+or+seen_add(x):
++++++++++++yield+x

@b.add_function()++++++++++
def+F1Rumors(l):
++++try:
++++++++if+next(getDupes(l)):+return+True++++#+Found+a+dupe
++++except+StopIteration:
++++++++pass
++++return+False

def+decompose(a_list):
++++return+reduce(
++++++++lambda+u,+o+:+(u[0].union([o]),+u[1].union(u[0].intersection([o]))),
++++++++a_list,
++++++++(set(),+set()))

@b.add_function()
def+Xavier_Decoret_1(l):
++++return+not+decompose(l)[1]

@b.add_function()
def+Xavier_Decoret_2(l):
++++try:
++++++++def+func(s,+o):
++++++++++++if+o+in+s:
++++++++++++++++raise+Exception
++++++++++++return+s.union([o])
++++++++reduce(func,+l,+set())
++++++++return+True
++++except:
++++++++return+False

@b.add_function()
def+pyrospade(xs):
++++s+=+set()
++++return+any(x+in+s+or+s.add(x)+for+x+in+xs)

@b.add_function()
def+Alex_Martelli_1(thelist):
++++return+any(thelist.count(x)+>+1+for+x+in+thelist)

@b.add_function()
def+Alex_Martelli_2(thelist):
++++seen+=+set()
++++for+x+in+thelist:
++++++++if+x+in+seen:+return+True
++++++++seen.add(x)
++++return+False

@b.add_function()
def+Denis_Otkidach(your_list):
++++return+len(your_list)+!=+len(set(your_list))

@b.add_function()
def+MSeifert04(l):
++++return+not+all_distinct(l)|code-block|syntax|javascript|1220894|对于论据：|1220895|#+No+duplicate+run
@b.add_arguments('list+size')
def+arguments():
++++for+exp+in+range(2,+14):
++++++++size+=+2**exp
++++++++yield+size,+list(range(size))

#+Duplicate+at+beginning+run
@b.add_arguments('list+size')
def+arguments():
++++for+exp+in+range(2,+14):
++++++++size+=+2**exp
++++++++yield+size,+[0,+*list(range(size)]

#+Running+and+plotting
r+=+b.run()
r.plot()|1220896|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/MSeifert04/simple_benchmark|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/a4046514c958a57639e0794addfe47f8.png|imageAlt|2|https://stackoverflow.com/a/1541827/5393381|3|https://ask.qcloudimg.com/http-save/yehe-900000/66bf9e371a9b7e9604a4828f2692239b.png|4|https://iteration-utilities.readthedocs.io/en/latest/generated/all_distinct.html^0|Z|G|Z|G|0|0|0|0|1|1|0|0|A|E|2|0|0|0|0|0|1|3|0|0|0|J|W|J|W|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1T|8|@$9|1U|A|1V|B|C]]|D|@$9|1W|A|1X|1|1Y]]|E|$]]|$1|F|3|G|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|20|8|@]|D|@$9|21|A|22|1|23]]|E|$]]|$1|K|3|G|5|6|7|24|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|25|8|@]|D|@$9|26|A|27|1|28]]|E|$]]|$1|N|3|O|5|6|7|29|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|2A|8|@]|D|@]|E|$]]|$1|R|3|G|5|6|7|2B|8|@]|D|@]|E|$]]|$1|S|3|I|5|J|7|2C|8|@]|D|@$9|2D|A|2E|1|2F]]|E|$]]|$1|T|3|G|5|6|7|2G|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|2H|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|2I|8|@$9|2J|A|2K|B|C]]|D|@$9|2L|A|2M|1|2N]]|E|$]]|$1|Y|3|Z|5|6|7|2O|8|@]|D|@]|E|$]]|$1|10|3|11|5|12|7|2P|8|@]|D|@]|E|$13|14]]|$1|15|3|16|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|17|3|18|5|12|7|2R|8|@]|D|@]|E|$13|14]]|$1|19|3|-4|5|6|7|2S|8|@]|D|@]|E|$]]]|1A|$1B|$5|1C|1D|1E|E|$1F|1G]]|1H|$5|1I|1D|1J|E|$1K|1L|1M|-4]]|1N|$5|1C|1D|1E|E|$1F|1O]]|1P|$5|1I|1D|1J|E|$1K|1Q|1M|-4]]|1R|$5|1C|1D|1E|E|$1F|1S]]]]

I thought it would be useful to compare the timings of the different solutions presented here. For this I used my own library <a href="https://github.com/MSeifert04/simple_benchmark" rel="noreferrer"><code>simple_benchmark</code></a>:

<a href="https://i.stack.imgur.com/9LKQA.png" rel="noreferrer"><img src="https://i.stack.imgur.com/9LKQA.png" alt="enter image description here"></a>

So indeed for this case the solution from <a href="https://stackoverflow.com/a/1541827/5393381">Denis Otkidach</a> is fastest.

Some of the approaches also exhibit a much steeper curve, these are the approaches that scale quadratic with the number of elements (Alex Martellis first solution, wjandrea and both of Xavier Decorets solutions). Also important to mention is that the pandas solution from Keiku has a very big constant factor. But for larger lists it almost catches up with the other solutions.

And in case the duplicate is at the first position. This is useful to see which solutions are short-circuiting:

<a href="https://i.stack.imgur.com/RmQ5D.png" rel="noreferrer"><img src="https://i.stack.imgur.com/RmQ5D.png" alt="enter image description here"></a>

Here several approaches don't short-circuit: Kaiku, Frank, Xavier_Decoret (first solution), Turn, Alex Martelli (first solution) and the approach presented by Denis Otkidach (which was fastest in the no-duplicate case).

I included a function from my own library here: <a href="https://iteration-utilities.readthedocs.io/en/latest/generated/all_distinct.html" rel="noreferrer"><code>iteration_utilities.all_distinct</code></a> which can compete with the fastest solution in the no-duplicates case and performs in constant-time for the duplicate-at-begin case (although not as fastest).

The code for the benchmark:

<pre class="lang-py prettyprint-override"><code>from collections import Counter
from functools import reduce

import pandas as pd
from simple_benchmark import BenchmarkBuilder
from iteration_utilities import all_distinct

b = BenchmarkBuilder()

@b.add_function()
def Keiku(l):
 return pd.Series(l).duplicated().sum() &gt; 0

@b.add_function()
def Frank(num_list):
 unique = []
 dupes = []
 for i in num_list:
 if i not in unique:
 unique.append(i)
 else:
 dupes.append(i)
 if len(dupes) != 0:
 return False
 else:
 return True

@b.add_function()
def wjandrea(iterable):
 seen = []
 for x in iterable:
 if x in seen:
 return True
 seen.append(x)
 return False

@b.add_function()
def user(iterable):
 clean_elements_set = set()
 clean_elements_set_add = clean_elements_set.add

 for possible_duplicate_element in iterable:

 if possible_duplicate_element in clean_elements_set:
 return True

 else:
 clean_elements_set_add( possible_duplicate_element )

 return False

@b.add_function()
def Turn(l):
 return Counter(l).most_common()[0][1] &gt; 1

def getDupes(l):
 seen = set()
 seen_add = seen.add
 for x in l:
 if x in seen or seen_add(x):
 yield x

@b.add_function() 
def F1Rumors(l):
 try:
 if next(getDupes(l)): return True # Found a dupe
 except StopIteration:
 pass
 return False

def decompose(a_list):
 return reduce(
 lambda u, o : (u[0].union([o]), u[1].union(u[0].intersection([o]))),
 a_list,
 (set(), set()))

@b.add_function()
def Xavier_Decoret_1(l):
 return not decompose(l)[1]

@b.add_function()
def Xavier_Decoret_2(l):
 try:
 def func(s, o):
 if o in s:
 raise Exception
 return s.union([o])
 reduce(func, l, set())
 return True
 except:
 return False

@b.add_function()
def pyrospade(xs):
 s = set()
 return any(x in s or s.add(x) for x in xs)

@b.add_function()
def Alex_Martelli_1(thelist):
 return any(thelist.count(x) &gt; 1 for x in thelist)

@b.add_function()
def Alex_Martelli_2(thelist):
 seen = set()
 for x in thelist:
 if x in seen: return True
 seen.add(x)
 return False

@b.add_function()
def Denis_Otkidach(your_list):
 return len(your_list) != len(set(your_list))

@b.add_function()
def MSeifert04(l):
 return not all_distinct(l)
</code></pre>

And for the arguments:

<pre class="lang-py prettyprint-override"><code>
# No duplicate run
@b.add_arguments('list size')
def arguments():
 for exp in range(2, 14):
 size = 2**exp
 yield size, list(range(size))

# Duplicate at beginning run
@b.add_arguments('list size')
def arguments():
 for exp in range(2, 14):
 size = 2**exp
 yield size, [0, *list(range(size)]

# Running and plotting
r = b.run()
r.plot()
</code></pre>

blocks|key|1220959|text|为了简单起见，我使用了pyrospade的方法，并对从不区分大小写的Windows注册表生成的简短列表进行了略微修改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1220960|如果将原始路径值字符串拆分为多个单独的路径，则可以使用以下命令删除所有'null‘路径(空或仅含空格的字符串)：|1220961|PATH_nonulls+=+[s+for+s+in+PATH+if+s.strip()]

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

def+DelDupes(aseq)+:
++++seen+=+set()
++++return+[x+for+x+in+aseq+if+(x.lower()+not+in+seen)+and+(not+seen.add(x.lower()))]|code-block|syntax|javascript|1220962|出于测试目的，原始路径既有'null‘条目，也有重复条目：|1220963|[list]++Root+paths+in+HKLM\SYSTEM\CurrentControlSet\Control\Session+Manager\Environment:PATH[list]++Root+paths+in+HKLM\SYSTEM\CurrentControlSet\Control\Session+Manager\Environment
++1++C:\Python37\
++2
++3
++4++C:\Python37\Scripts\
++5++c:\python37\
++6++C:\Program+Files\ImageMagick-7.0.8-Q8
++7++C:\Program+Files+(x86)\poppler\bin
++8++D:\DATA\Sounds
++9++C:\Program+Files+(x86)\GnuWin32\bin
+10++C:\Program+Files+(x86)\Intel\iCLS+Client\
+11++C:\Program+Files\Intel\iCLS+Client\
+12++D:\DATA\CCMD\FF
+13++D:\DATA\CCMD
+14++D:\DATA\UTIL
+15++C:\
+16++D:\DATA\UHELP
+17++%25SystemRoot%25\system32
+18
+19
+20++D:\DATA\CCMD\FF%25SystemRoot%25
+21++D:\DATA\Sounds
+22++%25SystemRoot%25\System32\Wbem
+23++D:\DATA\CCMD\FF
+24
+25
+26++c:\
+27++%25SYSTEMROOT%25\System32\WindowsPowerShell\v1.0\
+28|1220964|已删除空路径，但仍有重复路径，例如(1，3)和(13，20)：|1220965|++++[list]++Null+paths+removed+from+HKLM\SYSTEM\CurrentControlSet\Control\Session+Manager\Environment:PATH
++1++C:\Python37\
++2++C:\Python37\Scripts\
++3++c:\python37\
++4++C:\Program+Files\ImageMagick-7.0.8-Q8
++5++C:\Program+Files+(x86)\poppler\bin
++6++D:\DATA\Sounds
++7++C:\Program+Files+(x86)\GnuWin32\bin
++8++C:\Program+Files+(x86)\Intel\iCLS+Client\
++9++C:\Program+Files\Intel\iCLS+Client\
+10++D:\DATA\CCMD\FF
+11++D:\DATA\CCMD
+12++D:\DATA\UTIL
+13++C:\
+14++D:\DATA\UHELP
+15++%25SystemRoot%25\system32
+16++D:\DATA\CCMD\FF%25SystemRoot%25
+17++D:\DATA\Sounds
+18++%25SystemRoot%25\System32\Wbem
+19++D:\DATA\CCMD\FF
+20++c:\
+21++%25SYSTEMROOT%25\System32\WindowsPowerShell\v1.0\|1220966|最后，被复制的部分被移除了：|1220967|[list]++Massaged+path+list+from+in+HKLM\SYSTEM\CurrentControlSet\Control\Session+Manager\Environment:PATH
++1++C:\Python37\
++2++C:\Python37\Scripts\
++3++C:\Program+Files\ImageMagick-7.0.8-Q8
++4++C:\Program+Files+(x86)\poppler\bin
++5++D:\DATA\Sounds
++6++C:\Program+Files+(x86)\GnuWin32\bin
++7++C:\Program+Files+(x86)\Intel\iCLS+Client\
++8++C:\Program+Files\Intel\iCLS+Client\
++9++D:\DATA\CCMD\FF
+10++D:\DATA\CCMD
+11++D:\DATA\UTIL
+12++C:\
+13++D:\DATA\UHELP
+14++%25SystemRoot%25\system32
+15++D:\DATA\CCMD\FF%25SystemRoot%25
+16++%25SystemRoot%25\System32\Wbem
+17++%25SYSTEMROOT%25\System32\WindowsPowerShell\v1.0\|1220968|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 used pyrospade's approach, for its simplicity, and modified that slightly on a short list made from the case-insensitive Windows registry. 

If the raw PATH value string is split into individual paths all 'null' paths (empty or whitespace-only strings) can be removed by using:

<pre><code>PATH_nonulls = [s for s in PATH if s.strip()]

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

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

The original PATH has both 'null' entries and duplicates for testing purposes:

<pre><code>[list] Root paths in HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment:PATH[list] Root paths in HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment
 1 C:\Python37\
 2
 3
 4 C:\Python37\Scripts\
 5 c:\python37\
 6 C:\Program Files\ImageMagick-7.0.8-Q8
 7 C:\Program Files (x86)\poppler\bin
 8 D:\DATA\Sounds
 9 C:\Program Files (x86)\GnuWin32\bin
 10 C:\Program Files (x86)\Intel\iCLS Client\
 11 C:\Program Files\Intel\iCLS Client\
 12 D:\DATA\CCMD\FF
 13 D:\DATA\CCMD
 14 D:\DATA\UTIL
 15 C:\
 16 D:\DATA\UHELP
 17 %SystemRoot%\system32
 18
 19
 20 D:\DATA\CCMD\FF%SystemRoot%
 21 D:\DATA\Sounds
 22 %SystemRoot%\System32\Wbem
 23 D:\DATA\CCMD\FF
 24
 25
 26 c:\
 27 %SYSTEMROOT%\System32\WindowsPowerShell\v1.0\
 28
</code></pre>

Null paths have been removed, but still has duplicates, e.g., (1, 3) and (13, 20):

<pre><code> [list] Null paths removed from HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment:PATH
 1 C:\Python37\
 2 C:\Python37\Scripts\
 3 c:\python37\
 4 C:\Program Files\ImageMagick-7.0.8-Q8
 5 C:\Program Files (x86)\poppler\bin
 6 D:\DATA\Sounds
 7 C:\Program Files (x86)\GnuWin32\bin
 8 C:\Program Files (x86)\Intel\iCLS Client\
 9 C:\Program Files\Intel\iCLS Client\
 10 D:\DATA\CCMD\FF
 11 D:\DATA\CCMD
 12 D:\DATA\UTIL
 13 C:\
 14 D:\DATA\UHELP
 15 %SystemRoot%\system32
 16 D:\DATA\CCMD\FF%SystemRoot%
 17 D:\DATA\Sounds
 18 %SystemRoot%\System32\Wbem
 19 D:\DATA\CCMD\FF
 20 c:\
 21 %SYSTEMROOT%\System32\WindowsPowerShell\v1.0\
</code></pre>

And finally, the dupes have been removed:

<pre><code>[list] Massaged path list from in HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment:PATH
 1 C:\Python37\
 2 C:\Python37\Scripts\
 3 C:\Program Files\ImageMagick-7.0.8-Q8
 4 C:\Program Files (x86)\poppler\bin
 5 D:\DATA\Sounds
 6 C:\Program Files (x86)\GnuWin32\bin
 7 C:\Program Files (x86)\Intel\iCLS Client\
 8 C:\Program Files\Intel\iCLS Client\
 9 D:\DATA\CCMD\FF
 10 D:\DATA\CCMD
 11 D:\DATA\UTIL
 12 C:\
 13 D:\DATA\UHELP
 14 %SystemRoot%\system32
 15 D:\DATA\CCMD\FF%SystemRoot%
 16 %SystemRoot%\System32\Wbem
 17 %SYSTEMROOT%\System32\WindowsPowerShell\v1.0\
</code></pre>

blocks|key|1220989|text|my_list+=+['one',+'two',+'one']

duplicates+=+[]

for+value+in+my_list:
++if+my_list.count(value)+>+1:
++++if+value+not+in+duplicates:
++++++duplicates.append(value)

print(duplicates)+//["one"]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1220990|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>my_list = ['one', 'two', 'one']

duplicates = []

for value in my_list:
 if my_list.count(value) &gt; 1:
 if value not in duplicates:
 duplicates.append(value)

print(duplicates) //["one"]
</code></pre>

blocks|key|1220999|text|def+check_duplicates(my_list):
++++seen+=+{}
++++for+item+in+my_list:
++++++++if+seen.get(item):
++++++++++++return+True
++++++++seen[item]+=+True
++++return+False|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1221000|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>def check_duplicates(my_list):
 seen = {}
 for item in my_list:
 if seen.get(item):
 return True
 seen[item] = True
 return False
</code></pre>

blocks|key|1221044|text|另一种解决方案是使用slicing，它也可以处理字符串和其他可枚举的内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1221045|def+has_duplicates(x):
++++for+idx,+item+in+enumerate(x):
++++++++if+item+in+x[(idx+%2B+1):]:
++++++++++++return+True
++++return+False


>>>+has_duplicates(["a",+"b",+"c"])
False
>>>+has_duplicates(["a",+"b",+"b",+"c"])
True
>>>+has_duplicates("abc")
False
>>>+has_duplicates("abbc")
True|code-block|syntax|javascript|1221046|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/reference/expressions.html#slicings^0|A|7|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Another solution is to use <a href="https://docs.python.org/3/reference/expressions.html#slicings" rel="nofollow noreferrer">slicing</a>, which will also work with strings and other enumerable things.
<pre><code>def has_duplicates(x):
 for idx, item in enumerate(x):
 if item in x[(idx + 1):]:
 return True
 return False


&gt;&gt;&gt; has_duplicates([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;])
False
&gt;&gt;&gt; has_duplicates([&quot;a&quot;, &quot;b&quot;, &quot;b&quot;, &quot;c&quot;])
True
&gt;&gt;&gt; has_duplicates(&quot;abc&quot;)
False
&gt;&gt;&gt; has_duplicates(&quot;abbc&quot;)
True
</code></pre>

For example, given the list <code>['one', 'two', 'one']</code>, the algorithm should return <code>True</code>, whereas given <code>['one', 'two', 'three']</code> it should return <code>False</code>.

How do I check if there are duplicates in a flat list?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

例如，给定列表['one', 'two', 'one']，算法应返回True，而给定['one', 'two', 'three']，算法应返回False。

问如何检查平面列表中是否有重复项？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何检查平面列表中是否有重复项？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何检查平面列表中是否有重复项？
EN