Voici une description de la manière de déterminer si une liste (tableau) comporte des éléments en double (tous les éléments sont uniques) en Python, pour chacun des cas suivants.
- Pour une liste dont l'élément n'est pas une liste
- Pour les listes avec des listes d'éléments (tableaux à deux dimensions, listes de listes, etc.)
Consultez l'article suivant pour savoir comment supprimer ou extraire les éléments en double d'une liste.
Notez que les listes peuvent stocker différents types de données et sont strictement différentes des tableaux. Si vous souhaitez manipuler des tableaux dans des processus qui requièrent une taille de mémoire et des adresses mémoire ou le traitement numérique de données volumineuses, utilisez array (bibliothèque standard) ou NumPy.
Déterminer s'il y a des éléments en double dans la liste (si l'élément n'a pas de liste)
Si l'élément n'a pas d'objet actualisable tel qu'une liste, utilisez le constructeur set() du type set.
Le type set est un type de données qui ne comporte pas d'éléments en double. Lorsqu'une liste est passée au constructeur set(), les valeurs dupliquées sont ignorées et un objet de type set avec uniquement des valeurs uniques comme éléments est retourné.
Le nombre d'éléments dans cet objet de type ensemble et la liste originale sont obtenus et comparés à l'aide de la fonction intégrée len().
- Si le nombre d'éléments est égal, il n'y a pas d'éléments en double dans la liste originale.
- Les éléments en double sont inclus dans la liste originale si le nombre d'éléments est différent.
Les fonctions qui renvoient false s'il n'y a pas d'éléments en double et true s'il y a des éléments en double sont les suivantes
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 est une liste, mais la même fonction peut être utilisée avec des tuples.
Les objets mutables (pouvant être mis à jour) tels que les listes ne peuvent pas être des éléments du type set. Par conséquent, les listes ayant des listes comme éléments (tableaux à deux dimensions, listes de listes, etc.) produiront une TypeError. La contre-mesure est présentée ci-dessous.
l_2d = [[0, 1], [1, 1], [0, 1], [1, 0]]
# print(has_duplicates(l_2d))
# TypeError: unhashable type: 'list'
Déterminer s'il y a des éléments en double dans la liste (si l'élément a une liste)
Dans le cas d'une liste comportant une liste d'éléments (comme une liste de listes), les fonctions suivantes peuvent être utilisées pour déterminer s'il existe des éléments en double.
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
Au lieu de set(), la notation de compréhension de liste génère une liste dont les éléments sont uniquement des valeurs uniques, et le nombre d'éléments est comparé. Voir l'article suivant pour plus de détails.
Cette fonction est également valable pour les listes qui n'ont pas de liste d'éléments.
l = [0, 1, 2]
print(has_duplicates2(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates2(l))
# True
L'exemple donné jusqu'à présent consiste à déterminer si la liste d'éléments est dupliquée (contient la même liste).
On peut déterminer si les éléments de chaque liste se chevauchent après avoir aplati la liste originale à une seule dimension.
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
Ici, sum() est utilisé pour aplatir la liste, mais itertools.chain.from_iterable() peut également être utilisé. En outre, lors de l'aplatissement d'une liste de trois dimensions ou plus, il est nécessaire de définir une nouvelle fonction.
