ほとんどの場合、リストに重複があるかどうかを確認するプログラムを作成する必要があり、リストに重複がある場合はそれらを削除し、重複/削除されなかったアイテムを含む新しいリストを返します。これは私が持っているものですが、正直に言うと何をすべきかわかりません。

def remove_duplicates():
    t = ['a', 'b', 'c', 'd']
    t2 = ['a', 'c', 'd']
    for t in t2:
        t.append(t.remove())
    return t

アイテムの一意のコレクションを取得する一般的なアプローチは、を使用することsetです。セットは、個別のオブジェクトの順序付けられていないコレクションです。イテラブルからセットを作成するには、単純にそれを組み込み関数に渡すことができます。後で実際のリストが再び必要になった場合は、同様にセットを関数に渡すことができます。set()list()

次の例は、実行しようとしていることをすべてカバーする必要があります。

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> list(set(t))
[1, 2, 3, 5, 6, 7, 8]
>>> s = [1, 2, 3]
>>> list(set(t) - set(s))
[8, 5, 6, 7]

例の結果からわかるように、元の順序は維持されていません。上記のように、セット自体は順序付けられていないコレクションであるため、順序は失われます。セットをリストに変換すると、任意の順序が作成されます。

秩序の維持

順序が重要な場合は、別のメカニズムを使用する必要があります。これに対する非常に一般的な解決策は、OrderedDict挿入時にキーの順序を維持することに依存することです。

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]

Python 3.7以降、組み込み辞書は挿入順序も維持することが保証されているため、Python 3.7以降（またはCPython 3.6）を使用している場合は、それを直接使用することもできます。

>>> list(dict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]

これは、最初に辞書を作成し、それからリストを作成するというオーバーヘッドがあることに注意してください。実際に順序を維持する必要がない場合は、セットを使用する方がよい場合があります。これにより、操作する操作が多くなります。重複を削除するときに順序を維持するための詳細と代替方法については、この質問を確認してください。

最後にset、OrderedDict/ dictソリューションだけでなく、アイテムもハッシュ可能である必要があることに注意してください。これは通常、それらが不変でなければならないことを意味します。ハッシュ可能ではないアイテム（リストオブジェクトなど）を処理する必要がある場合は、基本的にすべてのアイテムをネストされたループ内の他のすべてのアイテムと比較する必要がある遅いアプローチを使用する必要があります。

Python 2.7では、元の順序を維持しながら反復可能オブジェクトから重複を削除する新しい方法は次のとおりです。

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

Python 3.5では、OrderedDictにC実装があります。私のタイミングは、これがPython 3.5のさまざまなアプローチの中で最速かつ最短であることを示しています。

Python 3.6では、通常の辞書が秩序あるコンパクトなものになりました。（この機能はCPythonとPyPyに適用されますが、他の実装には存在しない場合があります）。これにより、順序を維持しながら重複排除を行う新しい最速の方法が得られます。

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

Python 3.7では、通常のdictはすべての実装で順序付けされることが保証されています。 したがって、最短かつ最速のソリューションは次のとおりです。

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

それはワンライナーです：list(set(source_list))トリックを行います。

A setは重複する可能性がないものです。

更新：順序を維持するアプローチは2行です。

from collections import OrderedDict
OrderedDict((x, True) for x in source_list).keys()

ここではOrderedDict、キーの挿入順序を記憶し、特定のキーの値が更新されても変更しないという事実を使用します。True値として挿入しますが、何でも挿入できます。値は使用されません。（setのようにたくさんの作品dictも、無視された値を持ちます。）

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

注文を気にしない場合は、次のようにします。

def remove_duplicates(l):
    return list(set(l))

A setは重複しないことが保証されています。

重複の最初の要素の順序を保持する新しいリストを作成するには L

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

たとえばif L=[1, 2, 2, 3, 4, 2, 4, 3, 5]それnewlistから[1,2,3,4,5]

これにより、新しい要素を追加する前に、以前にリストに表示されていない各要素がチェックされます。また、インポートは必要ありません。

同僚は、本日のコードレビューのために、承認された回答をコードの一部として私に送信しました。問題の答えの優雅さには確かに感心しますが、そのパフォーマンスには満足していません。私はこの解決策を試しました（ルックアップ時間を短縮するためにセットを使用しています）

def ordered_set(in_list):
    out_list = []
    added = set()
    for val in in_list:
        if not val in added:
            out_list.append(val)
            added.add(val)
    return out_list

効率を比較するために、100の整数のランダムなサンプルを使用しました-62は一意でした

from random import randint
x = [randint(0,100) for _ in xrange(100)]

In [131]: len(set(x))
Out[131]: 62

ここに測定の結果があります

In [129]: %timeit list(OrderedDict.fromkeys(x))
10000 loops, best of 3: 86.4 us per loop

In [130]: %timeit ordered_set(x)
100000 loops, best of 3: 15.1 us per loop

さて、セットがソリューションから削除されるとどうなりますか？

def ordered_set(inlist):
    out_list = []
    for val in inlist:
        if not val in out_list:
            out_list.append(val)
    return out_list

結果はOrderedDictほど悪くありませんが、元のソリューションの3倍以上です

In [136]: %timeit ordered_set(x)
10000 loops, best of 3: 52.6 us per loop

PandasとNumpyを使用したソリューションもあります。どちらもnumpy配列を返すため.tolist()、リストが必要な場合は関数を使用する必要があります。

t=['a','a','b','b','b','c','c','c']
t2= ['c','c','b','b','b','a','a','a']

パンダのソリューション

パンダ機能の使用unique()：

import pandas as pd
pd.unique(t).tolist()
>>>['a','b','c']
pd.unique(t2).tolist()
>>>['c','b','a']

Numpyソリューション

numpy関数を使用しますunique()。

import numpy as np
np.unique(t).tolist()
>>>['a','b','c']
np.unique(t2).tolist()
>>>['a','b','c']

numpy.unique（）も値をソートすることに注意してください。したがって、リストt2はソートされて返されます。この回答のように順序を保存して使用したい場合：

_, idx = np.unique(t2, return_index=True)
t2[np.sort(idx)].tolist()
>>>['c','b','a']

ソリューションは他のソリューションに比べてそれほどエレガントではありませんが、pandas.unique（）と比較すると、numpy.unique（）を使用すると、選択した1つの軸に沿ってネストされた配列が一意かどうかを確認することもできます。

別の方法：

>>> seq = [1,2,3,'a', 'a', 1,2]
>> dict.fromkeys(seq).keys()
['a', 1, 2, 3]

シンプルで簡単：

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

出力：

>>> cleanlist 
[1, 2, 3, 5, 6, 7, 8]

この回答では、2つのセクションがあります。2つのユニークなソリューションと、特定のソリューションの速度のグラフです。

重複するアイテムの削除

これらの回答のほとんどは、ハッシュ可能な重複アイテムのみを削除しますが、この質問は、ハッシュ可能なアイテムだけが必要というわけではないことを意味しません。つまり、ハッシュ可能なアイテムを必要としないソリューションをいくつか提供します。

collections.Counterは標準ライブラリの強力なツールで、これに最適です。Counterが含まれているソリューションは他に1つしかありません。ただし、そのソリューションはハッシュ可能なキーにも限定されます。

Counterでハッシュできないキーを許可するために、オブジェクトのデフォルトのハッシュ関数を取得しようとするContainerクラスを作成しましたが、失敗した場合は、アイデンティティ関数を試行します。また、eqおよびハッシュ方式も定義します。これは、ソリューションでハッシュ化できないアイテムを許可するのに十分なはずです。ハッシュ不可のオブジェクトは、ハッシュ可能であるかのように扱われます。ただし、このハッシュ関数はハッシュ化できないオブジェクトにIDを使用します。つまり、両方ともハッシュ化できない2つの等しいオブジェクトは機能しません。これをオーバーライドして、同等の変更可能な型のハッシュを使用するように変更することをお勧めします（hash(tuple(my_list))if my_listis a list を使用するなど）。

私も2つの解決策を作りました。「OrderedCounter」というOrderedDictとCounterの両方のサブクラスを使用して、アイテムの順序を保持する別のソリューション。さて、ここに関数があります：

from collections import OrderedDict, Counter

class Container:
    def __init__(self, obj):
        self.obj = obj
    def __eq__(self, obj):
        return self.obj == obj
    def __hash__(self):
        try:
            return hash(self.obj)
        except:
            return id(self.obj)

class OrderedCounter(Counter, OrderedDict):
     'Counter that remembers the order elements are first encountered'

     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))

     def __reduce__(self):
         return self.__class__, (OrderedDict(self),)

def remd(sequence):
    cnt = Counter()
    for x in sequence:
        cnt[Container(x)] += 1
    return [item.obj for item in cnt]

def oremd(sequence):
    cnt = OrderedCounter()
    for x in sequence:
        cnt[Container(x)] += 1
    return [item.obj for item in cnt]

remdは順序付けされていないソートであり、oremdは順序付けされたソートです。どちらが速いかははっきりとわかりますが、とにかく説明します。非順序付けされたソートはわずかに高速です。順序を必要としないため、保持するデータが少なくなります。

次に、各回答の速度比較も表示したいと思います。だから、今からやります。

どの関数が最速ですか？

重複を取り除くために、いくつかの回答から10個の関数を収集しました。各関数の速度を計算し、matplotlib.pyplotを使用してグラフに入れました。

これを3回のグラフに分けました。ハッシュ可能とは、ハッシュできるオブジェクトのことであり、ハッシュ不可能とは、ハッシュできないオブジェクトのことです。順序付けられたシーケンスは順序を保持するシーケンスであり、順序付けられていないシーケンスは順序を保持しません。さて、ここにいくつかの用語があります：

Unordered Hashableは、重複を削除するすべてのメソッド用で、必ずしも順序を維持する必要はありませんでした。アンハッシュ可能にするために機能する必要はありませんでしたが、機能しました。

Ordered Hashableは、リスト内のアイテムの順序を維持する任意のメソッド用でしたが、unhashableで機能する必要はありませんでしたが、機能しました。

Ordered Unhashableは、リスト内のアイテムの順序を保持し、ハッシュ化できないものに対して機能する方法です。

y軸は、かかった秒数です。

x軸は、関数が適用された番号です。

順序付けされていないハッシャブルと順序付けされたハッシャブルのシーケンスを次の理解度で生成しました。 [list(range(x)) + list(range(x)) for x in range(0, 1000, 10)]

順序付けられたハッシュ化不可の場合： [[list(range(y)) + list(range(y)) for y in range(x)] for x in range(0, 1000, 10)]

範囲内に「ステップ」があることに注意してください。これがないと、10倍の時間がかかります。また、個人的な見解では、少し読みやすくなったのではないかと思いました。

また、凡例のキーは、関数の最も重要な部分として私が推測しようとしたものであることに注意してください。どんな機能が最悪または最高ですか？グラフはそれ自体を物語っています。

これで解決すると、ここにグラフがあります。

順序付けされていないハッシュ可能

（拡大）

注文したハッシュ可能

（拡大）

順序付けられたハッシュ不可

（拡大）

リストに口述があったので、上記のアプローチは使用できませんでした。エラーが発生しました：

TypeError: unhashable type:

したがって、注文を気にする場合や、一部のアイテムはハッシュ化できません。次に、これが便利な場合があります。

def make_unique(original_list):
    unique_list = []
    [unique_list.append(obj) for obj in original_list if obj not in unique_list]
    return unique_list

一部の人は、副作用を伴うリスト内包表記を適切な解決策ではないと見なす場合があります。ここに代替があります：

def make_unique(original_list):
    unique_list = []
    map(lambda x: unique_list.append(x) if (x not in unique_list) else False, original_list)
    return unique_list

これまでに見てきたすべての順序を維持するアプローチは、単純な比較（せいぜいO（n ^ 2）の時間の複雑さ）を使用するか、ハッシュ可能な入力に制限される重いOrderedDicts/ set+のlist組み合わせを使用します。以下は、ハッシュに依存しないO（nlogn）ソリューションです。

更新により、key引数、ドキュメント、Python 3の互換性が追加されました。

# from functools import reduce <-- add this import on Python 3

def uniq(iterable, key=lambda x: x):
    """
    Remove duplicates from an iterable. Preserves order. 
    :type iterable: Iterable[Ord => A]
    :param iterable: an iterable of objects of any orderable type
    :type key: Callable[A] -> (Ord => B)
    :param key: optional argument; by default an item (A) is discarded 
    if another item (B), such that A == B, has already been encountered and taken. 
    If you provide a key, this condition changes to key(A) == key(B); the callable 
    must return orderable objects.
    """
    # Enumerate the list to restore order lately; reduce the sorted list; restore order
    def append_unique(acc, item):
        return acc if key(acc[-1][1]) == key(item[1]) else acc.append(item) or acc 
    srt_enum = sorted(enumerate(iterable), key=lambda item: key(item[1]))
    return [item[1] for item in sorted(reduce(append_unique, srt_enum, [srt_enum[0]]))] 

順序を維持し、外部モジュールを使用しない場合は、これを行う簡単な方法を次に示します。

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

注：このメソッドは表示の順序を保持するため、上記のように、最初に表示されたため、1つ後に9つが続きます。しかし、これはあなたがすることで得られるのと同じ結果です

from collections import OrderedDict
ulist=list(OrderedDict.fromkeys(l))

しかし、それははるかに短く、より速く実行されます。

これは、fromkeys関数が新しいキーを作成しようとするたびに、値がすでに存在する場合は単に上書きするため機能します。ただし、これはディクショナリにはまったく影響しませんfromkeys。すべてのキーが値を持つディクショナリを作成するNoneため、この方法ですべての重複を効果的に排除します。

これを行うこともできます：

>>> t = [1, 2, 3, 3, 2, 4, 5, 6]
>>> s = [x for i, x in enumerate(t) if i == t.index(x)]
>>> s
[1, 2, 3, 4, 5, 6]

上記が機能する理由は、indexメソッドが要素の最初のインデックスのみを返すためです。重複する要素には、より高いインデックスがあります。ここを参照してください：

list.index（x [、start [、end]]）
値がxである最初のアイテムのリストでゼロから始まるインデックスを返します。そのようなアイテムがない場合、ValueErrorを発生させます。

セットを使用してみてください：

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

print t | t1
print t - t1

順序を保持してバリアントを削減：

リストがあると仮定します：

l = [5, 6, 6, 1, 1, 2, 2, 3, 4]

バリアントを削減（非効率的）：

>>> reduce(lambda r, v: v in r and r or r + [v], l, [])
[5, 6, 1, 2, 3, 4]

5倍高速ですが、より洗練されています

>>> reduce(lambda r, v: v in r[1] and r or (r[0].append(v) or r[1].add(v)) or r, l, ([], set()))[0]
[5, 6, 1, 2, 3, 4]

説明：

default = (list(), set())
# 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]

リストから重複を削除する最善の方法は、Pythonで使用可能なset（）関数を使用して、そのセットをリストに再度変換することです。

In [2]: some_list = ['a','a','v','v','v','c','c','d']
In [3]: list(set(some_list))
Out[3]: ['a', 'c', 'd', 'v']

次の関数を使用できます。

def rem_dupes(dup_list): 
    yooneeks = [] 
    for elem in dup_list: 
        if elem not in yooneeks: 
            yooneeks.append(elem) 
    return yooneeks

例：

my_list = ['this','is','a','list','with','dupicates','in', 'the', 'list']

使用法：

rem_dupes(my_list)

['this'、 'is'、 'a'、 'list'、 'with'、 'dupicates'、 'in'、 'the']

これを行うさまざまな方法を提案する他の多くの答えがありますが、それらはすべてバッチ操作であり、それらのいくつかは元の順序を捨てます。それは必要なものによっては大丈夫かもしれませんが、各値の最初のインスタンスの順序で値を反復処理したい場合、およびその場ですべての複製を一度に削除する場合は、このジェネレータ：

def uniqify(iterable):
    seen = set()
    for item in iterable:
        if item not in seen:
            seen.add(item)
            yield item

これはジェネレータ/イテレータを返すので、イテレータを使用できる場所ならどこでも使用できます。

for unique_item in uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]):
    print(unique_item, end=' ')

print()

出力：

1 2 3 4 5 6 7 8

あなたがしたい場合はlist、これを行うことができます：

unique_list = list(uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]))

print(unique_list)

出力：

[1, 2, 3, 4, 5, 6, 7, 8]

セットなし

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) 

を使用setして重複を削除できます。

mylist = list(set(mylist))

ただし、結果は順序付けされないことに注意してください。それが問題である場合：

mylist.sort()

もう1つのより良いアプローチは、

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]

順序は維持されます。

これはあまり面倒なことなく注文を気にします（OrderdDictなど）。おそらく最もPython的な方法でも、最も短い方法でもありませんが、トリックを行います：

def remove_duplicates(list):
    ''' Removes duplicate items from a list '''
    singles_list = []
    for element in list:
        if element not in singles_list:
            singles_list.append(element)
    return singles_list

以下のコードは、リスト内の重複を削除するためのシンプルなものです

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

[1,2,3,4]を返します

これが、返信にリストされている他の人と並ぶ最速のpythonicソリューションです。

短絡評価の実装の詳細を使用すると、十分に高速なリスト内包表記を使用できます。visited.add(item)常にNone結果として返され、として評価されるFalseため、の右側はorは常にそのような式の結果になります。

自分で時間を計る

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

セットを使用：

a = [0,1,2,3,4,3,3,4]
a = list(set(a))
print a

ユニークな使用：

import numpy as np
a = [0,1,2,3,4,3,3,4]
a = np.unique(a).tolist()
print a

残念ながら。ここでのほとんどの回答は、順序を維持しないか、長すぎます。これは、単純な順序保持の答えです。

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)

これにより、重複が削除されたxが得られますが、順序は保持されます。

Python 3の非常に簡単な方法：

>>> n = [1, 2, 3, 4, 1, 1]
>>> n
[1, 2, 3, 4, 1, 1]
>>> m = sorted(list(set(n)))
>>> m
[1, 2, 3, 4]

Pythonの魔法組み込み型

Pythonでは、このような複雑なケースを処理するのは非常に簡単で、Pythonの組み込みタイプによってのみ可能です。

やり方をお見せしましょう！

方法1：一般的なケース

リスト内の重複した要素を削除してもソート順を維持する方法（1行のコード）

line = [1, 2, 3, 1, 2, 5, 6, 7, 8]
new_line = sorted(set(line), key=line.index) # remove duplicated element
print(new_line)

あなたは結果を得るでしょう

[1, 2, 3, 5, 6, 7, 8]

方法2：特殊なケース

TypeError: unhashable type: 'list'

ハッシュ化できない特別なケース（3行のコード）

line=[['16.4966155686595', '-27.59776154691', '52.3786295521147']
,['16.4966155686595', '-27.59776154691', '52.3786295521147']
,['17.6508629295574', '-27.143305738671', '47.534955022564']
,['17.6508629295574', '-27.143305738671', '47.534955022564']
,['18.8051102904552', '-26.688849930432', '42.6912804930134']
,['18.8051102904552', '-26.688849930432', '42.6912804930134']
,['19.5504702331098', '-26.205884452727', '37.7709192714727']
,['19.5504702331098', '-26.205884452727', '37.7709192714727']
,['20.2929416861422', '-25.722717575124', '32.8500163147157']
,['20.2929416861422', '-25.722717575124', '32.8500163147157']]

tuple_line = [tuple(pt) for pt in line] # convert list of list into list of tuple
tuple_new_line = sorted(set(tuple_line),key=tuple_line.index) # remove duplicated element
new_line = [list(t) for t in tuple_new_line] # convert list of tuple into list of list

print (new_line)

結果が得られます：

[
  ['16.4966155686595', '-27.59776154691', '52.3786295521147'], 
  ['17.6508629295574', '-27.143305738671', '47.534955022564'], 
  ['18.8051102904552', '-26.688849930432', '42.6912804930134'], 
  ['19.5504702331098', '-26.205884452727', '37.7709192714727'], 
  ['20.2929416861422', '-25.722717575124', '32.8500163147157']
]

タプルはハッシュ可能であり、リストとタプルの間でデータを簡単に変換できるため