web-dev-qa-db-fra.com

Supprimer les doublons dans les listes

J'ai besoin d'écrire un programme pour vérifier si une liste contient des doublons et si elle le fait, elle les supprime et renvoie une nouvelle liste avec les éléments non dupliqués/supprimés. C'est ce que j'ai, mais pour être honnête, je ne sais pas quoi faire.

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

L'approche courante pour obtenir une collection unique d'éléments consiste à utiliser un set . Les ensembles sont des collections unordered d'objets distincts. Pour créer un ensemble à partir de n'importe quelle valeur, vous pouvez simplement le transmettre à la fonction set() intégrée. Si vous avez besoin ultérieurement d’une liste réelle, vous pouvez également transmettre l’ensemble à la fonction list() .

L'exemple suivant devrait couvrir tout ce que vous essayez de faire:

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

Comme vous pouvez le voir dans l'exemple de résultat, la commande d'origine n'est pas conservée. Comme mentionné ci-dessus, les ensembles eux-mêmes sont des collections non ordonnées, ainsi l'ordre est perdu. Lors de la conversion d'un ensemble en liste, un ordre arbitraire est créé.

Si l'ordre est important pour vous, vous devrez alors utiliser un mécanisme différent. Une solution très courante consiste à s’appuyer sur OrderedDict pour conserver l’ordre des clés lors de l’insertion:

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

Notez que cela a pour corollaire la surcharge de créer un dictionnaire, puis de créer une liste à partir de celui-ci. Donc, si vous n'avez pas réellement besoin de préserver l'ordre, vous feriez mieux d'utiliser un jeu. Consultez cette question pour plus de détails et d’autres moyens de préserver l’ordre lors de la suppression des doublons.


Enfin, notez que la solution set ainsi que la solution OrderedDict nécessitent que vos éléments soient hashable. Cela signifie généralement qu'ils doivent être immuables. Si vous devez traiter des éléments qui ne peuvent pas être traités (par exemple, des objets de liste), vous devrez alors adopter une approche lente dans laquelle vous devrez essentiellement comparer chaque élément avec tous les autres éléments d'une boucle imbriquée.

1277
poke

Dans Python 2.7 , le nouveau moyen de supprimer les doublons d'un itérable tout en les maintenant dans l'ordre d'origine est le suivant:

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

En Python 3.5 , OrderedDict a une implémentation en C. Mon timing montre que c’est maintenant à la fois la plus rapide et la plus courte des différentes approches de Python 3.5.

Dans Python 3.6 , le dict normal est devenu à la fois ordonné et compact. (Cette fonctionnalité est valable pour CPython et PyPy mais peut ne pas être présente dans d'autres implémentations). Cela nous donne un nouveau moyen plus rapide de déduplication tout en maintenant l’ordre:

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

Dans Python 3.7 , le dict normal est garanti pour les deux à travers toutes les implémentations. Donc, la solution la plus courte et la plus rapide est:

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

C'est un one-liner: list(set(source_list)) fera l'affaire.

Un set est quelque chose qui ne peut pas avoir de doublons.

Mise à jour: une approche préservant les commandes comporte deux lignes:

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

Nous utilisons ici le fait que OrderedDict mémorise l'ordre d'insertion des clés et ne le modifie pas lorsqu'une valeur d'une clé particulière est mise à jour. Nous insérons True en tant que valeurs, mais nous pouvons tout insérer, les valeurs ne sont tout simplement pas utilisées. (set fonctionne beaucoup comme un dict avec des valeurs ignorées, aussi.)

170
9000
>>> 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]
79
Neeraj

Si vous ne vous souciez pas de la commande, procédez comme suit:

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

Un set est garanti pour ne pas avoir de doublons.

68
Brendan Long

Une autre façon de faire:

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

Un collègue m'a envoyé la réponse acceptée dans le cadre de son code pour une analyse de code aujourd'hui . Bien que j'admire certainement l'élégance de la réponse en question, je ne suis pas satisfait du résultat . J'ai essayé cette solution (J'utilise set pour réduire le temps de recherche)

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

Pour comparer l'efficacité, j'ai utilisé un échantillon aléatoire de 100 nombres entiers - 62 étaient uniques

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

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

Voici les résultats des mesures

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

Eh bien, que se passe-t-il si set est supprimé de la solution?

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

Le résultat n'est pas aussi mauvais qu'avec OrderedDict , mais plus de 3 fois plus que la solution d'origine

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

Il existe également des solutions utilisant Pandas et Numpy. Ils renvoient tous deux numpy tableau, vous devez donc utiliser la fonction .tolist() si vous voulez une liste.

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

Solution de pandas

Utiliser la fonction Pandas unique() :

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

Solution Numpy

Utilisation de la fonction numpy unique() .

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

Notez que numpy.unique () trie également les valeurs. Donc, la liste t2 est retournée triée. Si vous voulez que l'ordre soit préservé, utilisez-le comme dans cette réponse :

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

La solution n'est pas si élégante par rapport aux autres, cependant, comparée à pandas.unique (), numpy.unique () permet également de vérifier si les tableaux imbriqués sont uniques le long d'un axe sélectionné.

16
G M

Simple et facile:

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

Sortie:

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

J'avais un dict dans ma liste, je ne pouvais donc pas utiliser l'approche ci-dessus. J'ai eu l'erreur:

TypeError: unhashable type:

Donc, si vous vous souciez de order et/ou que certains articles sont inshashable . Ensuite, vous trouverez peut-être cela utile:

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

Certains peuvent considérer que la compréhension de la liste avec un effet secondaire n'est pas une bonne solution. Voici une alternative:

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
10
cchristelis

Toutes les approches préservant les ordres que j'ai observées jusqu'ici utilisent soit une comparaison naïve (avec au mieux une complexité temporelle de O (n ^ 2)), soit un poids lourd OrderedDicts/set + list combinaisons qui sont limitées aux entrées hachables. Voici une solution O(nlogn) indépendante du hachage:

Update a ajouté l'argument key, la documentation et la compatibilité avec 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]]))] 
7
Eli Korvigo

Essayez d'utiliser des ensembles:

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

print t | t1
print t - t1
6
Charlie Martin

Vous pouvez aussi faire ceci:

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

La raison pour laquelle fonctionne ci-dessus est que la méthode index ne renvoie que le premier index d'un élément. Les éléments en double ont des indices plus élevés. Reportez-vous à ici :

list.index (x [ début [ fin]])
Retourne l'index de base zéro dans la liste de le premier élément dont la valeur est x. Déclenche une ValueError s'il n'y a pas de tel article.

6
Atonal

Une autre meilleure approche pourrait être,

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]

et l'ordre reste préservé.

5
Akarsh Jain

Sans utiliser set 

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) 
5
Suresh Gupta

La meilleure approche pour supprimer les doublons d’une liste est d’utiliser set () function, disponible en python, convertissant à nouveau ce set en liste

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

Il existe de nombreuses autres réponses suggérant différentes façons de procéder, mais il s’agit d’opérations en mode batch, dont certaines jettent la commande initiale. Cela peut convenir en fonction de vos besoins, mais si vous souhaitez effectuer une itération sur les valeurs dans l'ordre de la première instance de chaque valeur et que vous souhaitez supprimer les doublons à la volée par rapport à l'ensemble, vous pouvez utiliser ce générateur:

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

Cela renvoie un générateur/itérateur, de sorte que vous pouvez l'utiliser partout où vous pouvez utiliser un itérateur.

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

print()

Sortie:

1 2 3 4 5 6 7 8

Si vous voulez une list, vous pouvez faire ceci:

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

print(unique_list)

Sortie:

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

le code ci-dessous est simple pour supprimer les doublons dans la liste

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

il retourne [1,2,3,4]

4
vinay hegde

Réduire variante avec commande conservée:

Supposons que nous avons la liste:

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

Réduire variante (non efficace):

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

5 fois plus rapide mais plus sophistiqué

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

Explication:

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]
4
Sergey M Nikitin

Vous pouvez utiliser la fonction suivante: 

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

Exemple

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

Utilisation:

rem_dupes(my_list)

['this', 'est', 'a', 'list', 'with', 'dupicates', 'in', 'the']

4
Cybernetic

Celui-ci se soucie de la commande sans trop de soucis (OrderdDict & autres). Ce n'est probablement pas le moyen le plus pythonique, ni le plus court, mais le truc:

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
4
cgf

Voici la solution Pythonic la plus rapide parmi les solutions répertoriées dans les réponses.

L’utilisation des détails d’implémentation de l’évaluation des courts-circuits permet d’utiliser la compréhension de liste, qui est assez rapide. visited.add(item) renvoie toujours None comme résultat, qui est évalué en tant que False; le côté droit de or serait toujours le résultat d'une telle expression.

Chronométrez vous-même

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
3
thodnev

Utiliserset:

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

Utiliserunique:

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

Manière très simple en 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]
3
Wariored

Vous pouvez utiliser set pour supprimer les doublons:

mylist = list(set(mylist))

Mais notez que les résultats ne seront pas ordonnés. Si c'est un problème:

mylist.sort()
2
Flavio Wuensche

Cochez cette option si vous souhaitez supprimer les doublons (modification sur place plutôt que de renvoyer une nouvelle liste) sans utiliser le jeu incorporé, dict.keys, uniqify, counter

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> for i in t:
...     if i in t[t.index(i)+1:]:
...         t.remove(i)
... 
>>> t
[3, 1, 2, 5, 6, 7, 8]
2
user2404093

Voici un exemple, liste retournée sans répétitions préservant l’ordre. Ne nécessite aucune importation externe.

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
2
Apogentus

Je pense que convertir en set est le moyen le plus simple de supprimer les doublons:

list1 = [1,2,1]
list1 = list(set(list1))
print list1
2
user8383782

Une autre solution pourrait être la suivante. Créez un dictionnaire dans la liste avec l'élément en tant que clé et index en tant que valeur, puis imprimez les clés du dictionnaire.

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

Il y a beaucoup de réponses ici qui utilisent une set(..) (qui est rapide étant donné les éléments sont hashable), ou une liste (qui a l'inconvénient qu'il en résulte un O (n2) algorithme.

La fonction que je propose est hybride: nous utilisons une set(..) pour les éléments qui sont hashable, et une list(..) pour ceux qui ne le sont pas. De plus, il est implémenté en tant que generator, ce qui permet par exemple de limiter le nombre d'éléments ou d'effectuer un filtrage supplémentaire.

Enfin, nous pouvons également utiliser un argument key pour spécifier en quoi les éléments doivent être uniques. Par exemple, nous pouvons utiliser ceci si nous voulons filtrer une liste de chaînes de sorte que chaque chaîne de la sortie ait une longueur différente.

def uniq(iterable, key=lambda x: x):
    seens = set()
    seenl = []
    for item in iterable:
        k = key(item)
        try:
            seen = k in seens
        except TypeError:
            seen = k in seenl
        if not seen:
            yield item
            try:
                seens.add(k)
            except TypeError:
                seenl.append(k)

Nous pouvons maintenant par exemple utiliser ceci comme:

>>> list(uniq(["Apple", "pear", "banana", "lemon"], len))
['Apple', 'pear', 'banana']
>>> list(uniq(["Apple", "pear", "lemon", "banana"], len))
['Apple', 'pear', 'banana']
>>> list(uniq(["Apple", "pear", {}, "lemon", [], "banana"], len))
['Apple', 'pear', {}, 'banana']
>>> list(uniq(["Apple", "pear", {}, "lemon", [], "banana"]))
['Apple', 'pear', {}, 'lemon', [], 'banana']
>>> list(uniq(["Apple", "pear", {}, "lemon", {}, "banana"]))
['Apple', 'pear', {}, 'lemon', 'banana']

Il s’agit donc d’un filtre uniqeness qui peut fonctionner sur tous les itératifs et filtrer les uniques, qu’ils soient ou non lavables.

Cela suppose une hypothèse: si un objet est hashable, et qu'un autre ne l'est pas, les deux objets ne sont jamais égaux. Cela peut se produire à proprement parler, bien que ce soit très rare.

1
Willem Van Onsem

Vous pouvez le faire simplement en utilisant des ensembles.

Step1: Get Différents éléments de listes 
Step2 Get Eléments communs des listes 
Step3 Combinez-les

In [1]: a = ["apples", "bananas", "cucumbers"]

In [2]: b = ["pears", "apples", "watermelons"]

In [3]: set(a).symmetric_difference(b).union(set(a).intersection(b))
Out[3]: {'apples', 'bananas', 'cucumbers', 'pears', 'watermelons'}
1
Anurag Misra

Pour supprimer les doublons, faites-en un SET, puis faites-en une liste et imprimez/utilisez-le . Par exemple : 

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

Le résultat sera comme suit (vérifié en python 2.7)

[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!!
1
krozaine
def remove_duplicates(A):
   [A.pop(count) for count,elem in enumerate(A) if A.count(elem)!=1]
   return A

Une liste de compréhension pour supprimer les doublons

1
whackamadoodle3000

Si vous ne vous souciez pas de l'ordre et que vous voulez quelque chose de différent des méthodes Pythonic suggérées ci-dessus (c'est-à-dire qu'il peut être utilisé dans des interviews), 

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 __== '__main__':
    arr = [10, 10, 1, 1, 1, 3, 3, 4, 5, 6, 7, 8, 8, 9]
    print(remove_dup(sorted(arr)))

Complexité temporelle: O (n)

Espace auxiliaire: O (n)

Référence: http://www.geeksforgeeks.org/remove-duplicates-sorted-array/

1
Santosh Pillai

Malheureusement. La plupart des réponses ici ne conservent pas l'ordre ou sont trop longues. Voici une réponse simple et préservant l'ordre.

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)

Cela vous donnera x avec les doublons supprimés mais en préservant l'ordre. 

0
ste_kwr

Par souci d’exhaustivité, et comme il s’agit d’une question très populaire, la bibliothèque toolz propose une fonction unique :

>>> Tuple(unique((1, 2, 3)))
(1, 2, 3)
>>> Tuple(unique((1, 2, 1, 3)))
(1, 2, 3)
0
Björn Pollex

Parfois, vous devez supprimer les éléments en double sur place, sans créer de nouvelle liste. Par exemple, la liste est longue ou conservez-la en tant que cliché instantané.

from collections import Counter
cntDict = Counter(t)
for item,cnt in cntDict.items():
    for _ in range(cnt-1):
        t.remove(item)
0
where23

Il nécessite l’installation d’un module tiers, mais le package iteration_utilities contient un unique_everseen1 fonction pouvant supprimer tous les doublons tout en préservant l'ordre:

>>> from iteration_utilities import unique_everseen

>>> list(unique_everseen(['a', 'b', 'c', 'd'] + ['a', 'c', 'd']))
['a', 'b', 'c', 'd']

Si vous souhaitez éviter la surcharge de l'opération d'ajout de liste, vous pouvez utiliser itertools.chain à la place:

>>> from itertools import chain
>>> list(unique_everseen(chain(['a', 'b', 'c', 'd'], ['a', 'c', 'd'])))
['a', 'b', 'c', 'd']

Le unique_everseen fonctionne également si vous avez des éléments inutiles (par exemple des listes) dans les listes:

>>> from iteration_utilities import unique_everseen
>>> list(unique_everseen([['a'], ['b'], 'c', 'd'] + ['a', 'c', 'd']))
[['a'], ['b'], 'c', 'd', 'a']

Cependant, cela sera (beaucoup) plus lent que si les articles sont lavables.


1 Divulgation: Je suis l'auteur de la bibliothèque iteration_utilities-.

0
MSeifert

Si vous souhaitez conserver l'ordre et ne pas utiliser de modules externes, voici un moyen simple de procéder:

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

Remarque: Cette méthode conserve l'ordre d'apparition. Par conséquent, comme indiqué ci-dessus, neuf suivront après un, car il s'agissait de la première fois. Ceci est cependant le même résultat que vous obtiendriez avec

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

mais il est beaucoup plus court et court plus vite.

Cela fonctionne parce que chaque fois que la fonction fromkeys essaie de créer une nouvelle clé, si la valeur existe déjà, elle sera simplement écrasée. Ceci n’affectera toutefois pas le dictionnaire, puisque fromkeys crée un dictionnaire dans lequel toutes les clés ont la valeur None, ce qui élimine ainsi tous les doublons.

0
HEEL_caT666
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   
0
Dennis Peterson
list_with_unique_items = list(set(list_with_duplicates))
0
Gajendra D Ambi

c’est juste une fonction lisible, facilement compréhensible, et j’ai utilisé la structure de données dict, j’ai utilisé quelques fonctions intégrées et une meilleure complexité de O (n)

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

disclamer: u peut avoir une erreur d’indentation (si copier-coller), utilisez le code ci-dessus avec l’indentation appropriée avant de coller

0
yunus

Si votre liste est ordonnée, vous pouvez utiliser l'approche suivante pour la parcourir en ignorant les valeurs répétées. Ceci est particulièrement utile pour gérer de grandes listes avec une faible consommation de mémoire en évitant le coût de construction d'une dict ou d'une set:

def uniq(iterator):
    prev = None
    for item in iterator:
        if item != prev:
            prev = item
            yield item

Ensuite:

for item in [1, 1, 3, 5, 5, 6]:
    print(item, end=' ')

La sortie sera: 1 3 5 6

0
Israel Teixeira

Python a de nombreuses fonctions intégrées Vous pouvez utiliser set () pour supprimer le doublon dans la liste . Selon votre exemple, il y a ci-dessous deux listes t et t2

t = ['a', 'b', 'c', 'd']
t2 = ['a', 'c', 'd']
result = list(set(t) - set(t2))
result

Réponse: ['b']

0
Anoop Kumar