blocks|key|526462|text|这只是一句话：list(set(source_list))会做到这一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|526463|set是不可能有重复项的东西。|526464|更新:一种保持顺序的方法是两行：|526465|from+collections+import+OrderedDict
OrderedDict((x,+True)+for+x+in+source_list).keys()|code-block|syntax|javascript|526466|在这里，我们使用的事实是，OrderedDict记住键的插入顺序，并且在更新特定键处的值时不会更改它。我们插入True作为值，但是我们可以插入任何东西，值就是不用。(set的工作方式也非常类似于忽略了值的dict。)|526467|entityMap^0|7|M|0|0|3|0|0|0|D|B|1J|4|2B|3|2U|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|R|$]]

It's a one-liner: <code>list(set(source_list))</code> will do the trick.

A <code>set</code> is something that can't possibly have duplicates.

Update: an order-preserving approach is two lines:

<pre><code>from collections import OrderedDict
OrderedDict((x, True) for x in source_list).keys()
</code></pre>

Here we use the fact that <code>OrderedDict</code> remembers the insertion order of keys, and does not change it when a value at a particular key is updated. We insert <code>True</code> as values, but we could insert anything, values are just not used. (<code>set</code> works a lot like a <code>dict</code> with ignored values, too.)

blocks|key|743011|text|>>>+t+=+[1,+2,+3,+1,+2,+5,+6,+7,+8]
>>>+t
[1,+2,+3,+1,+2,+5,+6,+7,+8]
>>>+s+=+[]
>>>+for+i+in+t:
+++++++if+i+not+in+s:
++++++++++s.append(i)
>>>+s
[1,+2,+3,+5,+6,+7,+8]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|743012|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>&gt;&gt;&gt; t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
&gt;&gt;&gt; t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
&gt;&gt;&gt; s = []
&gt;&gt;&gt; for i in t:
 if i not in s:
 s.append(i)
&gt;&gt;&gt; s
[1, 2, 3, 5, 6, 7, 8]
</code></pre>

blocks|key|742882|text|如果您不关心顺序，只需执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|742883|def+remove_duplicates(l):
++++return+list(set(l))|code-block|syntax|javascript|742884|保证set不会有重复项。|offset|length|style|CODE|742885|entityMap^0|0|0|2|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you don't care about the order, just do this:

<pre><code>def remove_duplicates(l):
 return list(set(l))
</code></pre>

A <code>set</code> is guaranteed to not have duplicates.

blocks|key|526727|text|创建一个新列表，保留L中重复项的第一个元素的顺序|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|526728|newlist=[ii+for+n,ii+in+enumerate(L)+if+ii+not+in+L[:n]]|526729|例如if+L=[1,+2,+2,+3,+4,+2,+4,+3,+5]，则newlist将为[1,2,3,4,5]|526730|这将检查每个新元素在添加之前没有出现在列表中。此外，它不需要导入。|526731|entityMap^0|A|1|0|0|1K|0|2|W|10|7|19|B|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|10|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|M|$]]

To make a new list retaining the order of first elements of duplicates in <code>L</code>

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

for example <code>if L=[1, 2, 2, 3, 4, 2, 4, 3, 5]</code> then <code>newlist</code> will be <code>[1,2,3,4,5]</code>

This checks each new element has not appeared previously in the list before adding it. 
Also it does not need imports.

blocks|key|743054|text|另一种方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|743055|>>>+seq+=+[1,2,3,'a',+'a',+1,2]
>>+dict.fromkeys(seq).keys()
['a',+1,+2,+3]|code-block|syntax|javascript|743056|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|$]]

Another way of doing:

<pre><code>&gt;&gt;&gt; seq = [1,2,3,'a', 'a', 1,2]
&gt;&gt; dict.fromkeys(seq).keys()
['a', 1, 2, 3]
</code></pre>

blocks|key|743286|text|简单易用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|743287|myList+=+[1,+2,+3,+1,+2,+5,+6,+7,+8]
cleanlist+=+[]
[cleanlist.append(x)+for+x+in+myList+if+x+not+in+cleanlist]|code-block|syntax|javascript|743288|输出：|743289|>>>+cleanlist+
[1,+2,+3,+5,+6,+7,+8]|743290|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|$]]

Simple and easy:

<pre><code>myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanlist = []
[cleanlist.append(x) for x in myList if x not in cleanlist]
</code></pre>

Output:

<pre><code>&gt;&gt;&gt; cleanlist 
[1, 2, 3, 5, 6, 7, 8]
</code></pre>

blocks|key|744410|text|回答得很晚。如果您不关心列表顺序，您可以使用带set唯一性的*arg扩展来去除重复，即：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|744411|l+=+[*{*l}]|code-block|syntax|javascript|744412|Demo|744413|entityMap|0|LINK|mutability|MUTABLE|url|https://trinket.io/python3/6115229780^0|N|3|U|4|0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

Very late answer. If you don't care about the list order, you can use <code>*arg</code> expansion with <code>set</code> uniqueness to remove dupes, i.e.:
<pre><code>l = [*{*l}]
</code></pre>
<a href="https://trinket.io/python3/6115229780" rel="nofollow noreferrer">Demo</a>

blocks|key|527665|text|如果您想保留顺序，并且不使用任何外部模块，这里有一个简单的方法来实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527666|>>>+t+=+[1,+9,+2,+3,+4,+5,+3,+6,+7,+5,+8,+9]
>>>+list(dict.fromkeys(t))
[1,+9,+2,+3,+4,+5,+6,+7,+8]|code-block|syntax|javascript|527667|注意:此方法保留了出现的顺序，因此，如上所述，9将在1之后出现，因为它是第一次出现。然而，这与您通过执行以下操作得到的结果相同|527668|from+collections+import+OrderedDict
ulist=list(OrderedDict.fromkeys(l))|527669|但它更短，运行速度也更快。|527670|这之所以有效，是因为每次fromkeys函数尝试创建一个新键时，如果该值已经存在，它将直接覆盖它。但是，这根本不会影响字典，因为fromkeys创建了一个字典，其中所有键的值都是None，因此它可以有效地以这种方式消除所有重复项。|offset|length|style|CODE|527671|entityMap^0|0|0|0|0|0|C|8|1S|8|2H|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]|$O|12|P|13|Q|R]|$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

If you want to preserve the order, and not use any external modules here is an easy way to do this:

<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; t = [1, 9, 2, 3, 4, 5, 3, 6, 7, 5, 8, 9]
&gt;&gt;&gt; list(dict.fromkeys(t))
[1, 9, 2, 3, 4, 5, 6, 7, 8]
</code></pre>

Note: This method preserves the order of appearance, so, as seen above, nine will come after one because it was the first time it appeared. This however, is the same result as you would get with doing

<pre class="lang-py prettyprint-override"><code>from collections import OrderedDict
ulist=list(OrderedDict.fromkeys(l))
</code></pre>

but it is much shorter, and runs faster.

This works because each time the <code>fromkeys</code> function tries to create a new key, if the value already exists it will simply overwrite it. This wont affect the dictionary at all however, as <code>fromkeys</code> creates a dictionary where all keys have the value <code>None</code>, so effectively it eliminates all duplicates this way.

blocks|key|527383|text|您可以使用set删除重复项：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|527384|mylist+=+list(set(mylist))|code-block|syntax|javascript|527385|但请注意，结果将是无序的。如果这是一个问题：|527386|mylist.sort()|527387|entityMap^0|5|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

You can use <code>set</code> to remove duplicates:

<pre><code>mylist = list(set(mylist))
</code></pre>

But note the results will be unordered. If that's an issue:

<pre><code>mylist.sort()
</code></pre>

blocks|key|526532|text|尝试使用集合：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|526533|import+sets
t+=+sets.Set(['a',+'b',+'c',+'d'])
t1+=+sets.Set(['a',+'b',+'c'])

print+t+%7C+t1
print+t+-+t1|code-block|syntax|javascript|526534|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|$]]

Try using sets:

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

print t | t1
print t - t1
</code></pre>

blocks|key|526842|text|带有排序保留的Reduce变量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|526843|假设我们有list：|526844|l+=+[5,+6,+6,+1,+1,+2,+2,+3,+4]|code-block|syntax|javascript|526845|Reduce变量(低效)：|526846|>>>+reduce(lambda+r,+v:+v+in+r+and+r+or+r+%2B+[v],+l,+[])
[5,+6,+1,+2,+3,+4]|526847|速度提高5倍，但更复杂|526848|>>>+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]|526849|解释：|526850|default+=+(list(),+set())
#+user+list+to+keep+order
#+use+set+to+make+lookup+faster

def+reducer(result,+item):
++++if+item+not+in+result[1]:
++++++++result[0].append(item)
++++++++result[1].add(item)
++++return+result

reduce(reducer,+l,+default)[0]|526851|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|$]]

Reduce variant with ordering preserve:

Assume that we have list:

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

Reduce variant (unefficient):

<pre><code>&gt;&gt;&gt; reduce(lambda r, v: v in r and r or r + [v], l, [])
[5, 6, 1, 2, 3, 4]
</code></pre>

5 x faster but more sophisticated

<pre><code>&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())
# user list to keep order
# use set to make lookup faster

def reducer(result, item):
 if item not in result[1]:
 result[0].append(item)
 result[1].add(item)
 return result

reduce(reducer, l, default)[0]
</code></pre>

blocks|key|527455|text|一种更好的方法可能是，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527456|import+pandas+as+pd

myList+=+[1,+2,+3,+1,+2,+5,+6,+7,+8]
cleanList+=+pd.Series(myList).drop_duplicates().tolist()
print(cleanList)

#>+[1,+2,+3,+5,+6,+7,+8]|code-block|syntax|javascript|527457|这个顺序仍然保持不变。|527458|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|$]]

One more better approach could be,

<pre><code>import pandas as pd

myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanList = pd.Series(myList).drop_duplicates().tolist()
print(cleanList)

#&gt; [1, 2, 3, 5, 6, 7, 8]
</code></pre>

and the order remains preserved.

blocks|key|527185|text|不使用set|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527186|data=[1,+2,+3,+1,+2,+5,+6,+7,+8]
uni_data=[]
for+dat+in+data:
++++if+dat+not+in+uni_data:
++++++++uni_data.append(dat)

print(uni_data)+|code-block|syntax|javascript|527187|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|$]]

Without using set 

<pre><code>data=[1, 2, 3, 1, 2, 5, 6, 7, 8]
uni_data=[]
for dat in data:
 if dat not in uni_data:
 uni_data.append(dat)

print(uni_data) 
</code></pre>

blocks|key|743252|text|这个人关心的是顺序，没有太多的麻烦(OrderdDict和其他)。可能不是最Pythonic式的方法，也不是最短的方法，但它做到了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|743253|def+remove_duplicates(item_list):
++++'''+Removes+duplicate+items+from+a+list+'''
++++singles_list+=+[]
++++for+element+in+item_list:
++++++++if+element+not+in+singles_list:
++++++++++++singles_list.append(element)
++++return+singles_list|code-block|syntax|javascript|743254|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 one cares about the order without too much hassle (OrderdDict &amp; others). Probably not the most Pythonic way, nor shortest way, but does the trick:
<pre><code>def remove_duplicates(item_list):
 ''' Removes duplicate items from a list '''
 singles_list = []
 for element in item_list:
 if element not in singles_list:
 singles_list.append(element)
 return singles_list
</code></pre>

blocks|key|526872|text|下面的代码是用于删除列表中重复项的简单代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|526873|def+remove_duplicates(x):
++++a+=+[]
++++for+i+in+x:
++++++++if+i+not+in+a:
++++++++++++a.append(i)
++++return+a

print+remove_duplicates([1,2,2,3,3,4])|code-block|syntax|javascript|526874|它返回1,2,3,4|526875|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|$]]

below code is simple for removing duplicate in list

<pre><code>def remove_duplicates(x):
 a = []
 for i in x:
 if i not in a:
 a.append(i)
 return a

print remove_duplicates([1,2,2,3,3,4])
</code></pre>

it returns [1,2,3,4]

blocks|key|527006|text|以下是回复中列出的最快的蟒蛇解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527007|使用短路评估的实现细节允许使用列表理解，这是足够快的。visited.add(item)始终返回None作为结果，其计算结果为False，因此or的右侧将始终是此类表达式的结果。|offset|length|style|CODE|527008|自己计时|527009|def+deduplicate(sequence):
++++visited+=+set()
++++adder+=+visited.add++#+get+rid+of+qualification+overhead
++++out+=+[adder(item)+or+item+for+item+in+sequence+if+item+not+in+visited]
++++return+out|code-block|syntax|javascript|527010|entityMap^0|0|R|H|1C|4|1R|5|1Z|2|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|P|$]]

Here's the fastest pythonic solution comaring to others listed in replies.

Using implementation details of short-circuit evaluation allows to use list comprehension, which is fast enough. <code>visited.add(item)</code> always returns <code>None</code> as a result, which is evaluated as <code>False</code>, so the right-side of <code>or</code> would always be the result of such an expression.

Time it yourself

<pre><code>def deduplicate(sequence):
 visited = set()
 adder = visited.add # get rid of qualification overhead
 out = [adder(item) or item for item in sequence if item not in visited]
 return out
</code></pre>

blocks|key|527255|text|Python+3中非常简单的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527256|>>>+n+=+[1,+2,+3,+4,+1,+1]
>>>+n
[1,+2,+3,+4,+1,+1]
>>>+m+=+sorted(list(set(n)))
>>>+m
[1,+2,+3,+4]|code-block|syntax|javascript|527257|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|$]]

Very simple way in Python 3:

<pre><code>&gt;&gt;&gt; n = [1, 2, 3, 4, 1, 1]
&gt;&gt;&gt; n
[1, 2, 3, 4, 1, 1]
&gt;&gt;&gt; m = sorted(list(set(n)))
&gt;&gt;&gt; m
[1, 2, 3, 4]
</code></pre>

blocks|key|527307|text|不幸的是。这里的大多数答案要么不保留顺序，要么太长。这是一个简单的，保持顺序的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527308|s+=+[1,2,3,4,5,2,5,6,7,1,3,9,3,5]
x=[]

[x.append(i)+for+i+in+s+if+i+not+in+x]
print(x)|code-block|syntax|javascript|527309|这将为您提供x，删除了重复项，但保留了顺序。|527310|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|$]]

Unfortunately. Most answers here either do not preserve the order or are too long. Here is a simple, order preserving answer.

<pre><code>s = [1,2,3,4,5,2,5,6,7,1,3,9,3,5]
x=[]

[x.append(i) for i in s if i not in x]
print(x)
</code></pre>

This will give you x with duplicates removed but preserving the order.

blocks|key|744438|text|我用纯python函数实现了这一点。当您的items值为JSON时，这是有效的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|744439|[i+for+n,+i+in+enumerate(items)+if+i+not+in+items[n+%2B+1+:]]|code-block|syntax|javascript|744440|entityMap^0|L|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I did this with pure python function. This works when your <code>items</code> value is JSON.

<pre><code>[i for n, i in enumerate(items) if i not in items[n + 1 :]]
</code></pre>

blocks|key|526648|text|下面是一个示例，返回没有重复且保持顺序的列表。不需要任何外部导入。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|526649|def+GetListWithoutRepetitions(loInput):
++++#+return+list,+consisting+of+elements+of+list/tuple+loInput,+without+repetitions.
++++#+Example:+GetListWithoutRepetitions([None,None,1,1,2,2,3,3,3])
++++#+Returns:+[None,+1,+2,+3]

++++if+loInput==[]:
++++++++return+[]

++++loOutput+=+[]

++++if+loInput[0]+is+None:
++++++++oGroupElement=1
++++else:+#+loInput[0]<>None
++++++++oGroupElement=None

++++for+oElement+in+loInput:
++++++++if+oElement<>oGroupElement:
++++++++++++loOutput.append(oElement)
++++++++++++oGroupElement+=+oElement
++++return+loOutput|code-block|syntax|javascript|526650|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|$]]

Here is an example, returning list without repetiotions preserving order. Does not need any external imports.

<pre><code>def GetListWithoutRepetitions(loInput):
 # return list, consisting of elements of list/tuple loInput, without repetitions.
 # Example: GetListWithoutRepetitions([None,None,1,1,2,2,3,3,3])
 # Returns: [None, 1, 2, 3]

 if loInput==[]:
 return []

 loOutput = []

 if loInput[0] is None:
 oGroupElement=1
 else: # loInput[0]&lt;&gt;None
 oGroupElement=None

 for oElement in loInput:
 if oElement&lt;&gt;oGroupElement:
 loOutput.append(oElement)
 oGroupElement = oElement
 return loOutput
</code></pre>

blocks|key|743423|text|如果不想使用内置的set、dict.keys、uniqify、counter来移除重复项(就地编辑而不是返回新列表)，请选中此选项|type|unstyled|depth|inlineStyleRanges|entityRanges|data|743424|>>>+t+=+[1,+2,+3,+1,+2,+5,+6,+7,+8]
>>>+for+i+in+t:
...+++++if+i+in+t[t.index(i)%2B1:]:
...+++++++++t.remove(i)
...+
>>>+t
[3,+1,+2,+5,+6,+7,+8]|code-block|syntax|javascript|743425|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|$]]

Check this if you want to remove duplicates (in-place edit rather than returning new list) without using inbuilt set, dict.keys, uniqify, counter

<pre><code>&gt;&gt;&gt; t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
&gt;&gt;&gt; for i in t:
... if i in t[t.index(i)+1:]:
... t.remove(i)
... 
&gt;&gt;&gt; t
[3, 1, 2, 5, 6, 7, 8]
</code></pre>

blocks|key|527055|text|我认为转换为set是删除重复项的最简单方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527056|list1+=+[1,2,1]
list1+=+list(set(list1))
print+list1|code-block|syntax|javascript|527057|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 think converting to set is the easiest way to remove duplicate:

<pre><code>list1 = [1,2,1]
list1 = list(set(list1))
print list1
</code></pre>

blocks|key|527996|text|我没有看到不可哈希值的答案，一个线性，n+log+n，仅标准库，所以这是我的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527997|list(map(operator.itemgetter(0),+itertools.groupby(sorted(items))))|code-block|syntax|javascript|527998|或者作为生成器函数：|527999|def+unique(items:+Iterable[T])+->+Iterable[T]:
++++"""For+unhashable+items+(can't+use+set+to+unique)+with+a+partial+order"""
++++yield+from+map(operator.itemgetter(0),+itertools.groupby(sorted(items)))|528000|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|$]]

I didn't see answers for non-hashable values, one liner, n log n, standard-library only, so here's my answer:
<pre><code>list(map(operator.itemgetter(0), itertools.groupby(sorted(items))))
</code></pre>
Or as a generator function:
<pre><code>def unique(items: Iterable[T]) -&gt; Iterable[T]:
 &quot;&quot;&quot;For unhashable items (can't use set to unique) with a partial order&quot;&quot;&quot;
 yield from map(operator.itemgetter(0), itertools.groupby(sorted(items)))
</code></pre>

blocks|key|743377|text|要删除重复项，请将其设置为一组，然后再次将其设置为列表并打印/使用它。一个集合保证有唯一的元素。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|743378|a+=+[1,2,3,4,5,9,11,15]
b+=+[4,5,6,7,8]
c=a%2Bb
print+c
print+list(set(c))+#one+line+for+getting+unique+elements+of+c|code-block|syntax|javascript|743379|输出将如下所示(在python+2.7中检查)|743380|[1,+2,+3,+4,+5,+9,+11,+15,+4,+5,+6,+7,+8]++#simple+list+addition+with+duplicates
[1,+2,+3,+4,+5,+6,+7,+8,+9,+11,+15]+#duplicates+removed!!|743381|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|$]]

To remove the duplicates, make it a SET and then again make it a LIST and print/use it.
A set is guaranteed to have unique elements. For example : 

<pre><code>a = [1,2,3,4,5,9,11,15]
b = [4,5,6,7,8]
c=a+b
print c
print list(set(c)) #one line for getting unique elements of c
</code></pre>

The output will be as follows (checked in python 2.7)

<pre><code>[1, 2, 3, 4, 5, 9, 11, 15, 4, 5, 6, 7, 8] #simple list addition with duplicates
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 15] #duplicates removed!!
</code></pre>

blocks|key|743623|text|def+remove_duplicates(A):
+++[A.pop(count)+for+count,elem+in+enumerate(A)+if+A.count(elem)!=1]
+++return+A|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|743624|用于删除重复项的列表压缩|unstyled|743625|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>def remove_duplicates(A):
 [A.pop(count) for count,elem in enumerate(A) if A.count(elem)!=1]
 return A
</code></pre>

A list comprehesion to remove duplicates

blocks|key|743671|text|如果你不关心顺序，想要一些不同于上面建议的pythonic方式的东西(也就是，它可以在面试中使用)，那么：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|743672|def+remove_dup(arr):
++++size+=+len(arr)
++++j+=+0++++#+To+store+index+of+next+unique+element
++++for+i+in+range(0,+size-1):
++++++++#+If+current+element+is+not+equal
++++++++#+to+next+element+then+store+that
++++++++#+current+element
++++++++if(arr[i]+!=+arr[i%2B1]):
++++++++++++arr[j]+=+arr[i]
++++++++++++j%2B=1

++++arr[j]+=+arr[size-1]+#+Store+the+last+element+as+whether+it+is+unique+or+repeated,+it+hasn't+stored+previously

++++return+arr[0:j%2B1]

if+__name__+==+'__main__':
++++arr+=+[10,+10,+1,+1,+1,+3,+3,+4,+5,+6,+7,+8,+8,+9]
++++print(remove_dup(sorted(arr)))|code-block|syntax|javascript|743673|时间复杂度:+O(n)|743674|辅助空间:+O(n)|743675|参考：http://www.geeksforgeeks.org/remove-duplicates-sorted-array/|offset|length|743676|entityMap|0|LINK|mutability|MUTABLE|url|http://www.geeksforgeeks.org/remove-duplicates-sorted-array/^0|0|0|0|0|3|1O|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

If you don't care about order and want something different than the pythonic ways suggested above (that is, it can be used in interviews) then : 

<pre><code>def remove_dup(arr):
 size = len(arr)
 j = 0 # To store index of next unique element
 for i in range(0, size-1):
 # If current element is not equal
 # to next element then store that
 # current element
 if(arr[i] != arr[i+1]):
 arr[j] = arr[i]
 j+=1

 arr[j] = arr[size-1] # Store the last element as whether it is unique or repeated, it hasn't stored previously

 return arr[0:j+1]

if __name__ == '__main__':
 arr = [10, 10, 1, 1, 1, 3, 3, 4, 5, 6, 7, 8, 8, 9]
 print(remove_dup(sorted(arr)))
</code></pre>

Time Complexity : O(n)

Auxiliary Space : O(n)

Reference: <a href="http://www.geeksforgeeks.org/remove-duplicates-sorted-array/" rel="nofollow noreferrer">http://www.geeksforgeeks.org/remove-duplicates-sorted-array/</a>

blocks|key|743761|text|另一种解决方案可能如下所示。在列表之外创建一个字典，以item为key，index为value，然后打印字典键。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|743762|>>>+lst+=+[1,+3,+4,+2,+1,+21,+1,+32,+21,+1,+6,+5,+7,+8,+2]
>>>
>>>+dict_enum+=+{item:index+for+index,+item+in+enumerate(lst)}
>>>+print+dict_enum.keys()
[32,+1,+2,+3,+4,+5,+6,+7,+8,+21]|code-block|syntax|javascript|743763|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|$]]

Another solution might be the following. Create a dictionary out of the list with item as key and index as value, and then print the dictionary keys.

<pre><code>&gt;&gt;&gt; lst = [1, 3, 4, 2, 1, 21, 1, 32, 21, 1, 6, 5, 7, 8, 2]
&gt;&gt;&gt;
&gt;&gt;&gt; dict_enum = {item:index for index, item in enumerate(lst)}
&gt;&gt;&gt; print dict_enum.keys()
[32, 1, 2, 3, 4, 5, 6, 7, 8, 21]
</code></pre>

blocks|key|743462|text|为了完整性，并且由于这是一个非常流行的问题，toolz库提供了一个unique函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|743463|>>>+tuple(unique((1,+2,+3)))
(1,+2,+3)
>>>+tuple(unique((1,+2,+1,+3)))
(1,+2,+3)|code-block|syntax|javascript|743464|entityMap|0|LINK|mutability|MUTABLE|url|http://toolz.readthedocs.io/en/latest/|1|http://toolz.readthedocs.io/en/latest/api.html#toolz.itertoolz.unique^0|X|6|M|5|0|X|6|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

For completeness, and since this is a very popular question, the <a href="http://toolz.readthedocs.io/en/latest/" rel="nofollow noreferrer">toolz</a> library offers a <a href="http://toolz.readthedocs.io/en/latest/api.html#toolz.itertoolz.unique" rel="nofollow noreferrer"><code>unique</code></a> function:

<pre><code>&gt;&gt;&gt; tuple(unique((1, 2, 3)))
(1, 2, 3)
&gt;&gt;&gt; tuple(unique((1, 2, 1, 3)))
(1, 2, 3)
</code></pre>

blocks|key|527243|text|def+remove_duplicates(input_list):
++if+input_list+==+[]:
++++return+[]
++#sort+list+from+smallest+to+largest
++input_list=sorted(input_list)
++#initialize+ouput+list+with+first+element+of+the+++++++sorted+input+list
++output_list+=+[input_list[0]]
++for+item+in+input_list:
++++if+item+>output_list[-1]:
++++++output_list.append(item)
++return+output_list+++|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|527244|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 remove_duplicates(input_list):
 if input_list == []:
 return []
 #sort list from smallest to largest
 input_list=sorted(input_list)
 #initialize ouput list with first element of the sorted input list
 output_list = [input_list[0]]
 for item in input_list:
 if item &gt;output_list[-1]:
 output_list.append(item)
 return output_list 
</code></pre>

blocks|key|743892|text|这只是一个可读的函数，很容易理解，而且我使用了dict数据结构，我使用了一些内置函数和O(n)的更好的复杂度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|743893|def+undup(dup_list):
++++b={}
++++for+i+in+dup_list:
++++++++b.update({i:1})
++++return+b.keys()
a=["a",'b','a']
print+undup(a)|code-block|syntax|javascript|743894|释放:你可能会得到一个缩进错误(如果复制和粘贴)，在粘贴之前使用上面的代码和适当的缩进|743895|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|$]]

this is just a readable funtion ,easily understandable ,and i have used the dict data structure,i have used some builtin funtions and a better complexity of O(n)

<pre><code>def undup(dup_list):
 b={}
 for i in dup_list:
 b.update({i:1})
 return b.keys()
a=["a",'b','a']
print undup(a)
</code></pre>

disclamer: u may get an indentation error(if copy and paste) ,use the above code with proper indentation before pasting

blocks|key|744039|text|Python内置了许多函数，您可以使用set()来删除列表中的重复项。根据您的示例，下面有两个列表t和t2|type|unstyled|depth|inlineStyleRanges|entityRanges|data|744040|t+=+['a',+'b',+'c',+'d']
t2+=+['a',+'c',+'d']
result+=+list(set(t)+-+set(t2))
result|code-block|syntax|javascript|744041|答案：'b‘|744042|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|$]]

Python has built-in many functions You can use set() to remove the duplicate inside the list.
As per your example there are below two lists t and t2

<pre><code>t = ['a', 'b', 'c', 'd']
t2 = ['a', 'c', 'd']
result = list(set(t) - set(t2))
result
</code></pre>

Answer: ['b']

blocks|key|527576|text|有时，您需要就地删除重复的项目，而不创建新列表。例如，列表很大，或者将其保留为卷影副本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527577|from+collections+import+Counter
cntDict+=+Counter(t)
for+item,cnt+in+cntDict.items():
++++for+_+in+range(cnt-1):
++++++++t.remove(item)|code-block|syntax|javascript|527578|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|$]]

Sometimes you need to remove the duplicate items in-place, without creating new list. For example, the list is big, or keep it as a shadow copy

<pre><code>from collections import Counter
cntDict = Counter(t)
for item,cnt in cntDict.items():
 for _ in range(cnt-1):
 t.remove(item)
</code></pre>

blocks|key|527778|text|如果您的列表是有序的，则可以使用以下方法对其进行迭代，跳过重复的值。这在处理大列表时特别有用，因为它占用的内存很少，从而避免了构建dict或set的成本|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|527779|def+uniq(iterator):
++++prev+=+None
++++for+item+in+iterator:
++++++++if+item+!=+prev:
++++++++++++prev+=+item
++++++++++++yield+item|code-block|syntax|javascript|527780|然后：|527781|for+item+in+uniq([1,+1,+3,+5,+5,+6]):
++++print(item,+end='+')|527782|输出将是：1+3+5+6|527783|要返回列表对象，您可以执行以下操作：|527784|>>>+print(list(uniq([1,+1,+3,+5,+5,+6])))
[1,+3,+5,+6]|527785|entityMap^0|1T|4|1Y|3|0|0|0|0|5|7|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|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|17|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|U|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|V|$]]

If your list is ordered, you can use the following approach to iterate over it skipping the repeated values. This is especially useful to handle big lists with low memory consumption evading the cost of building a <code>dict</code> or a <code>set</code>:

<pre><code>def uniq(iterator):
 prev = None
 for item in iterator:
 if item != prev:
 prev = item
 yield item
</code></pre>

Then:

<pre><code>for item in uniq([1, 1, 3, 5, 5, 6]):
 print(item, end=' ')
</code></pre>

The output is going to be: <code>1 3 5 6</code>

To return a list object, you could do:

<pre><code>&gt;&gt;&gt; print(list(uniq([1, 1, 3, 5, 5, 6])))
[1, 3, 5, 6]
</code></pre>

blocks|key|744626|text|使用set，但保留顺序|type|unstyled|depth|inlineStyleRanges|entityRanges|data|744627|unique+=+set()
[unique.add(n)+or+n+for+n+in+l+if+n+not+in+unique]|code-block|syntax|javascript|744628|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|$]]

Using set, but preserving order
<pre><code>unique = set()
[unique.add(n) or n for n in l if n not in unique]
</code></pre>

blocks|key|744670|text|您可以比较集合和列表的长度，并将集合项目保存到列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|744671|if+len(t)+!=+len(set(t)):
++++t+=+[x+for+x+in+set(t)]|code-block|syntax|javascript|744672|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 can compare the length of the set and the list and save the set items to list.
<pre><code>if len(t) != len(set(t)):
 t = [x for x in set(t)]
 
</code></pre>

blocks|key|527261|text|list_with_unique_items+=+list(set(list_with_duplicates))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|527262|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>list_with_unique_items = list(set(list_with_duplicates))
</code></pre>

blocks|key|744541|text|Test+=+[1,8,2,7,3,4,5,1,2,3,6]
Test.sort()
i=1
while+i<+len(Test):
++if+Test[i]+==+Test[i-1]:
++++Test.remove(Test[i])
++i=+i%2B1
print(Test)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|744542|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>Test = [1,8,2,7,3,4,5,1,2,3,6]
Test.sort()
i=1
while i&lt; len(Test):
 if Test[i] == Test[i-1]:
 Test.remove(Test[i])
 i= i+1
print(Test)
</code></pre>

blocks|key|744579|text|检查字符串'a‘和'b’|type|unstyled|depth|inlineStyleRanges|entityRanges|data|744580|clean_list+=+[]
++++for+ele+in+raw_list:
++++++++if+'b'+in+ele+or+'a'+in+ele:
++++++++++++pass
++++++++else:
++++++++++++clean_list.append(ele)|code-block|syntax|javascript|744581|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|$]]

<h1>Check for the string 'a' and 'b'</h1>
<pre><code>clean_list = []
 for ele in raw_list:
 if 'b' in ele or 'a' in ele:
 pass
 else:
 clean_list.append(ele)
</code></pre>

blocks|key|744609|text|Write+a+Python+program+to+create+a+list+of+numbers+by+taking+input+from+the+user+and+then+remove++the+duplicates+from+the+list.+You+can+take+input+of+non-zero+numbers,+with+an+appropriate++prompt,+from+the+user+until+the+user+enters+a+zero+to+create+the+list+assuming+that+the+numbers++are+non-zero.++
Sample+Input:+[10,+34,+18,+10,+12,+34,+18,+20,+25,+20]++
Output:+[10,+34,+18,+12,+20,+25]+

+lst+=+[]
print("ENTER+ZERO+NUMBER+FOR+EXIT+!!!!!!!!!!!!")
print("ENTER+LIST+ELEMENTS++::+")
while+True:
++++n+=+int(input())
++++if+n+==+0+:
+++++++print("!!!!!!!!!!!+EXIT+!!!!!!!!!!!!")
+++++++break
++++else+:
++++++++lst.append(n)
print("LIST+ELEMENR+ARE+::+",lst)
#dup+=+set()
uniq+=+[]
for+x+in+lst:
++++if+x+not+in+uniq:
++++++++uniq.append(x)
+++++++#+dup.add(x)
print("UNIQUE+ELEMENTS+IN+LIST+ARE+::+",uniq)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|744610|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>Write a Python program to create a list of numbers by taking input from the user and then remove the duplicates from the list. You can take input of non-zero numbers, with an appropriate prompt, from the user until the user enters a zero to create the list assuming that the numbers are non-zero. 
Sample Input: [10, 34, 18, 10, 12, 34, 18, 20, 25, 20] 
Output: [10, 34, 18, 12, 20, 25] 

 lst = []
print(&quot;ENTER ZERO NUMBER FOR EXIT !!!!!!!!!!!!&quot;)
print(&quot;ENTER LIST ELEMENTS :: &quot;)
while True:
 n = int(input())
 if n == 0 :
 print(&quot;!!!!!!!!!!! EXIT !!!!!!!!!!!!&quot;)
 break
 else :
 lst.append(n)
print(&quot;LIST ELEMENR ARE :: &quot;,lst)
#dup = set()
uniq = []
for x in lst:
 if x not in uniq:
 uniq.append(x)
 # dup.add(x)
print(&quot;UNIQUE ELEMENTS IN LIST ARE :: &quot;,uniq)
</code></pre>

Pretty much I need to write a program to check if a list has any duplicates and if it does it removes them and returns a new list with the items that weren't duplicated/removed. This is what I have but to be honest I do not know what to do.
<pre><code>def remove_duplicates():
 t = ['a', 'b', 'c', 'd']
 t2 = ['a', 'c', 'd']
 for t in t2:
 t.append(t.remove())
 return t
</code></pre>

Removing duplicates in lists

数据结构

Python

JSON

我几乎需要编写一个程序来检查列表是否有重复项，如果有，它会删除它们，并返回一个新的列表，其中包含未被复制/删除的项。这就是我所拥有的，但老实说，我不知道该怎么办。def remove_duplicates():    t = ['a', 'b', 'c', 'd']    t2 = ['a', 'c', 'd']    for t in t2:        t.append(t.remove()

问删除列表中的重复项
EN

回答 39

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问删除列表中的重复项EN

回答 39

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问删除列表中的重复项
EN