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
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.
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']
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.)
>>> 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]
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.
Une autre façon de faire:
>>> seq = [1,2,3,'a', 'a', 1,2]
>> dict.fromkeys(seq).keys()
['a', 1, 2, 3]
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
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é.
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]
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
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]]))]
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
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.
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é.
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)
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']
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]
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]
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]
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']
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
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
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
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]
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()
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]
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
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
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]
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.
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'}
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!!
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
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/
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.
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)
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-.
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.
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
list_with_unique_items = list(set(list_with_duplicates))
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
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
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']