Cet article décrit comment vérifier s’il y a des éléments en double (= si tous les éléments sont uniques) dans une liste en Python pour les cas suivants :
- La liste ne contient pas d’objets non hachables
- La liste contient des objets non hachables
Consultez l’article suivant pour supprimer ou extraire les éléments en double de la liste.
Vérifiez si la liste contient des éléments en double (il n’y a pas d’objet non hachable)
Utilisez set() si la liste ne contient pas d’objets non hachables tels que list. En passant une liste à set(), il renvoie set, qui ignore les valeurs en double et ne conserve que les valeurs uniques comme éléments.
Obtenez le nombre d’éléments de cet ensemble et la liste d’origine avec la fonction intégrée len() et comparez.
Si le nombre d’éléments est le même, cela signifie qu’il n’y a pas d’éléments en double dans la liste d’origine, et si le nombre d’éléments est différent, cela signifie que la liste d’origine contient des éléments en double.
La fonction qui renvoie False lorsqu’il n’y a pas d’éléments en double et True lorsqu’il y a des éléments en double est la suivante :
def has_duplicates(seq):
return len(seq) != len(set(seq))
l = [0, 1, 2]
print(has_duplicates(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates(l))
# True
L’exemple de code ci-dessus utilise list, mais la même fonction peut être utilisée avec tuple.
Étant donné que set n’est pas autorisé à contenir des objets non hachables tels que list, une erreur TypeError se produira pour une liste contenant une liste (liste à deux dimensions, liste de listes).
l_2d = [[0, 1], [1, 1], [0, 1], [1, 0]]
# print(has_duplicates(l_2d))
# TypeError: unhashable type: 'list'
Vérifiez si la liste contient des éléments en double (il y a un objet non hachable)
Dans le cas d’une liste incluant une liste, on peut vérifier s’il y a des éléments en double par la fonction suivante :
def has_duplicates2(seq):
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) != len(unique_list)
l_2d = [[0, 0], [0, 1], [1, 1], [1, 0]]
print(has_duplicates2(l_2d))
# False
l_2d = [[0, 0], [0, 1], [1, 1], [1, 1]]
print(has_duplicates2(l_2d))
# True
Génère une liste contenant uniquement des valeurs uniques en utilisant la compréhension de liste au lieu de set() et compare le nombre d’éléments. Voir l’article suivant pour plus de détails.
Cette fonction fonctionne également pour les listes qui ne contiennent pas d’objets non hachables comme les listes.
l = [0, 1, 2]
print(has_duplicates2(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates2(l))
# True
L’exemple ci-dessus vérifie si la liste contient la même liste. Vous pouvez vérifier si les éléments de chaque liste sont dupliqués en aplatissant la liste d’origine à une dimension, puis vérifier s’ils sont dupliqués.
l_2d = [[0, 1], [2, 3]]
print(sum(l_2d, []))
# [0, 1, 2, 3]
print(has_duplicates(sum(l_2d, [])))
# False
l_2d = [[0, 1], [2, 0]]
print(has_duplicates(sum(l_2d, [])))
# True
Dans cet exemple, sum() est utilisé pour aplatir la liste, mais vous pouvez également utiliser itertools.chain.from_iterable(). Si vous souhaitez aplatir une liste à plus de trois dimensions, vous devez définir une nouvelle fonction. Voir l’article suivant.