Comment trouver les doublons dans une liste et créer une autre liste avec eux ?

Question

Comment puis-je trouver les doublons dans une liste Python et créer une autre liste des doublons ? La liste ne contient que des entiers.

Answer 1

Un peu tard, mais peut-être utile pour certains. Pour une liste plus importante, j'ai trouvé que ceci fonctionnait pour moi.

l=[1,2,3,5,4,1,3,1]
s=set(l)
d=[]
for x in l:
    if x in s:
        s.remove(x)
    else:
        d.append(x)
d
[1,3,1]

Affiche tous les doublons et préserve l'ordre.

Answer 2

Un moyen très simple et rapide de trouver les doublons en une seule itération en Python :

testList = ['red', 'blue', 'red', 'green', 'blue', 'blue']

testListDict = {}

for item in testList:
  try:
    testListDict[item] += 1
  except:
    testListDict[item] = 1

print testListDict

Le résultat sera le suivant :

>>> print testListDict
{'blue': 3, 'green': 1, 'red': 2}

Ceci et plus encore dans mon blog http://www.howtoprogramwithpython.com

Answer 3

J'entre avec beaucoup de retard dans cette discussion. Même si j'aimerais traiter ce problème avec des phrases toutes faites. Parce que c'est le charme de Python. Si nous voulons simplement récupérer les doublons dans une liste séparée (ou toute autre collection), je suggère de faire comme suit : disons que nous avons une liste de doublons que nous pouvons appeler 'cible'.

    target=[1,2,3,4,4,4,3,5,6,8,4,3]

Maintenant, si nous voulons obtenir les doublons, nous pouvons utiliser la méthode ci-dessous :

    duplicates=dict(set((x,target.count(x)) for x in filter(lambda rec : target.count(rec)>1,target)))

Ce code va mettre les enregistrements dupliqués comme clé et le nombre comme valeur dans le dictionnaire 'duplicates'. Le dictionnaire 'duplicate' ressemblera à ce qui suit :

    {3: 3, 4: 4} #it saying 3 is repeated 3 times and 4 is 4 times

Si vous voulez simplement que tous les enregistrements avec des doublons seuls dans une liste, c'est encore un code beaucoup plus court :

    duplicates=filter(lambda rec : target.count(rec)>1,target)

La sortie sera :

    [3, 4, 4, 4, 3, 4, 3]

Cela fonctionne parfaitement dans les versions 2.7.x + de python

Answer 4

Cela semble assez compétitif malgré sa complexité O(n log n), voir les benchmarks ci-dessous.

a = sorted(a)
dupes = list(set(a[::2]) & set(a[1::2]))

Le tri rapproche les doublons les uns des autres, de sorte qu'ils se trouvent à la fois à un indice pair et à un indice impair. Les valeurs uniques sont seulement à un indice pair ou à un indice impair, pas les deux. Ainsi, l'intersection des valeurs d'indice pair et des valeurs d'indice impair constitue les doublons.

Résultats de l'évaluation comparative :

Cela utilise Le repère de MSeifert mais seulement avec les solutions de la réponse acceptée (les géorgiques), les solutions les plus lentes, la solution la plus rapide (à l'exception de it_duplicates car il n'unifie pas les doublons), et le mien. Sinon, il y aurait trop de monde et les couleurs seraient trop similaires.

La première ligne pourrait être a.sort() si nous sommes autorisés à modifier la liste donnée, ce serait un peu plus rapide. Mais le benchmark réutilise la même liste plusieurs fois, donc la modifier perturberait le benchmark.

Et apparemment set(a[::2]).intersection(a[1::2]) ne créerait pas un deuxième ensemble et serait un peu plus rapide, mais meh, c'est aussi un peu plus long.

Answer 5

Méthode 1 :

list(set([val for idx, val in enumerate(input_list) if val in input_list[idx+1:]]))

Explication : [val for idx, val in enumerate(input_list) if val in input_list[idx+1 :]] est une compréhension de liste, qui retourne un élément, si le même élément est présent à partir de sa position actuelle, dans la liste, l'index.

Exemple : input_list = [42,31,42,31,3,31,31,5,6,6,6,6,6,7,42]

en commençant par le premier élément de la liste, 42, avec l'index 0, il vérifie si l'élément 42, est présent dans input_list[1 :] (c'est-à-dire, de l'index 1 jusqu'à la fin de la liste) Parce que 42 est présent dans input_list[1 :], il retournera 42.

Ensuite, il passe à l'élément suivant 31, avec l'indice 1, et vérifie si l'élément 31 est présent dans la input_list[2 :] (c'est-à-dire de l'indice 2 jusqu'à la fin de la liste), Parce que 31 est présent dans input_list[2 :], il retournera 31.

De la même manière, il passe en revue tous les éléments de la liste, et ne renvoie que les éléments répétés/dupliqués dans une liste.

Puis, comme nous avons des doublons, dans une liste, nous devons choisir un de chaque doublon, c'est-à-dire supprimer le doublon parmi les doublons, et pour ce faire, nous appelons un intégré python nommé set(), et il supprime les doublons,

Nous nous retrouvons alors avec un ensemble, mais pas une liste, et donc pour convertir un ensemble en liste, nous utilisons, par typage, list(), et cela convertit l'ensemble des éléments en une liste.

Méthode 2 :

def dupes(ilist):
    temp_list = [] # initially, empty temporary list
    dupe_list = [] # initially, empty duplicate list
    for each in ilist:
        if each in temp_list: # Found a Duplicate element
            if not each in dupe_list: # Avoid duplicate elements in dupe_list
                dupe_list.append(each) # Add duplicate element to dupe_list
        else: 
            temp_list.append(each) # Add a new (non-duplicate) to temp_list

    return dupe_list

Explication : Nous créons ici deux listes vides, pour commencer. Puis on continue à parcourir tous les éléments de la liste, pour voir s'il existe dans temp_list (initialement vide). S'il n'est pas présent dans la liste temp_list, alors nous l'ajoutons à la liste temp_list, en utilisant la méthode suivante ajouter méthode.

S'il existe déjà dans temp_list, cela signifie que l'élément actuel de la liste est un doublon, et donc nous devons l'ajouter à dupe_list en utilisant ajouter méthode.