Python : comment comparer ou fusionner des listes ?
Table des matières
1.1. Concaténation de la liste avec L’opérateur +
1.2. Concaténation de la liste avec append ()
1.3. Concaténation de la liste avec entend ()
1.4. Concaténation de la liste avec l'opérateur Asterisk *
1.5. Concaténation de listes avec itertools.chain()
1.6. Concaténation des listes avec compréhension des listes
2.2. La comparaison simple avec boucle for
2.3. La comparaison avec zip() + boucle for
2.4. La comparaison avec zip() + len()+ sum()
2.5. La comparaison avec map()+ len() + reduce()
2.6. La comparaison avec map() + all()
3. Exercices
Introduction
Les listes en Python sont des structures de données très flexibles et puissantes. Elles peuvent être utilisées pour représenter le comportement de nombreuses structures de données classiques et pour former la base d'autres structures sous la forme de listes personnalisées. Elles sont dynamiques et, comme les tuples, peuvent contenir n'importe quel type d'objet, mais, contrairement aux tuples, elles sont mutables, ce qui permet de modifier leur contenu. Vous pouvez également utiliser le principe du déballage de tuples pour affecter des éléments de listes à des variables discrètes. Une liste est littéralement exprimée comme une séquence d'objets séparés par des virgules et placés entre crochets. Vous pouvez créer une liste vide soit en spécifiant une paire de crochets vides, soit en utilisant la valeur par défaut de la fonction de type list (). Les listes sont fournies avec plusieurs méthodes pour ajouter et supprimer des membres, et elles supportent également certaines opérations de type arithmétique pour concaténer et copier des listes de manière similaire à des chaînes de caractères.
1. Comment concaténer les listes en python ?
En effet, on appelle concaténation des listes une action qui consiste à additionner les différents éléments de la liste à la fin d'une autre liste. À titre d'exemple, si nous disposons d'une liste contenant des éléments [1,0,1] et d'une autre liste contenant des éléments [1,2,1], lorsque nous concaténons à la fois les deux listes, nous obtenons [1,0,1,1,2,1] ou [1,2,1,1,0,1] selon la séquence de concaténation.
Il y a différentes méthodes pour enchaîner les listes en Python. Voici les différentes manières possibles, une par une.
- Opérateur de concaténation (+)
- Boucles/append () Méthode intégrée.
- Compréhension de la liste.
- Opérateur.
- Entend () Méthode intégrée.
- itertools.chain().
1.1. Concaténation de la liste avec L’opérateur + :
Cette méthode permet de combiner deux listes en Python. La majorité des utilisateurs utilisent l'opérateur + afin de concaténer les listes. Voici des exemples pour bien comprendre.
Exemple 1 :
Syntaxe :
# l'initialisation des listes
list_1 = [4,1,2,3,7,5]
list_2 = [1,0,8,5,3,9]
# additionner deux listes en utilisant l'opérateur +.
List = list_1 + list_2
print(List)
Résultat d’exécution :
Exemple 2 :
Syntaxe :
# l'initialisation des listes
list_1 = [8, 2, 7]
list_2 = [9, 2, 5]
list_3 = [1, 0, 1]
# additionner des listes en utilisant l'opérateur +.
list_1 = list_1 + list_3 + list_2
print(list_1)
Résultat d’exécution :
La difficulté de l'opérateur + utilisé lors de la concaténation des listes vient du fait de la création d'une autre liste à chaque concaténation de liste. Ceci peut être très désagréable si on utilise l'opérateur + plus d'une fois dans une boucle.
1.2. Concaténation de la liste avec append () :
La méthode suivante pour enchaîner les listes consiste à utiliser la boucle for. On va itérer sur une des listes et on va ajouter ses éléments à la fin d'une autre liste. À ce moment, l'une des listes contient tous les éléments. Passons maintenant à une boucle qui permet de concaténer deux listes.
Exemple 3 :
Syntaxe :
# l'initialisation des listes
list_1 = [4,1,2,3,7,5]
list_2 = [1,0,8,5,3,9]
for element in list_2:
list_1.append(element)
print(list_1)
Résultat d’exécution :
Exemple 4 :
Syntaxe :
# l'initialisation des listes
list_1 = [4,1,2,3,7,5]
list_2 = [1,0,8,5,3,9]
List = []
for element in list_1:
List.append(element)
for element in list_2:
List.append(element)
print(List)
Résultat d’exécution :
Il est possible de concaténer plusieurs listes à la fois en utilisant la boucle for si on veut.
Exemple 5 :
Syntaxe :
# initializing lists
list_1 = [8, 2, 7]
list_2 = [9, 2, 5]
list_3 = [1, 0, 1]
List = []
for element in list_1:
List.append(element)
for element in list_2:
List.append(element)
for element in list_3:
List.append(element)
print(List)
Résultat d’exécution :
1.3. Concaténation de la liste avec entend () :
Dans la partie précédente, on a étudié la méthode append (). Le problème important est que si vous voulez
enchaîner deux listes, vous devez exécuter une itération sur chaque élément de la liste et les inclure un
par un. Ceci est compliqué et il doit y avoir un moyen plus efficace.
La méthode list.extend(list) permet d'ajouter les éléments de la liste à la fin de la deuxième liste.
La comparaison entre append() et extend() est que la méthode append() ajoute un seul élément alors que
la méthode extend() additionne une série d'éléments à la liste.
Exemple 6:
Syntaxe :
# initializing lists
list_1 = [4,1,2,3,7,5]
list_2 = [1,0,8,5,3,9]
list_1.extend(list_2)
print(list_1)
Résultat d’exécution :
Exemple 7 :
Syntaxe :
# l'initialisation des listes
list_1 = [8, 2, 7]
list_2 = [9, 2, 5]
list_3 = [1, 0, 1]
list_1.extend(list_1)
list_1.extend(list_3)
print(list_1)
Résultat d’exécution :
1.4. Concaténation de la liste avec l'opérateur Asterisk * :
Il y a plusieurs utilisations de l'opérateur astérisque. Cependant, une bonne astuce est de s'en servir comme un opérateur de décompression qui "décompose" le contenu d'une structure de données de type liste ou un dictionnaire dans une nouvelle structure.
Si vous êtes spécialiste du décompactage des éléments à partir des itérateurs en utilisant l'opérateur, cette méthode de concaténation est peut-être familière. Une des principales utilisations consiste à décomposer le contenu d'un itérateur. Le désassemblage consiste à examiner Chaque élément d'un itérateur.
Exemple 8 :
Syntaxe :
# l'initialisation des listes
list_1 = [4,1,2,3,7,5]
list_2 = [1,0,8,5,3,9]
List = [*list_2, *list_1]
print(List)
Résultat d’exécution :
Exemple 9:
Syntaxe :
# l'initialisation des listes
list_1 = [8, 2, 7]
list_2 = [9, 2, 5]
list_3 = [1, 0, 1]
List = [*list_3, *list_2, *list_1]
print(List)
Résultat d’exécution :
1.5. Concaténation de listes avec itertools.chain() :
Le module itertools du langage Python offre plusieurs outils pour la manipulation des itératifs tels que les listes. Il est également important de noter que ces outils permettent de combiner deux listes d'itérables. Après la conversion de l’itérable résultante en une liste, il est aussi possible d'obtenir le même résultat que précédemment.
Exemple 10 :
Syntaxe :
import itertools
# l'initialisation des listes
list_1 = [4,1,2,3,7,5]
list_2 = [1,0,8,5,3,9]
print(list(itertools.chain(list_2, list_1)))
Résultat d’exécution :
Exemple 11:
Syntaxe:
import itertools
# l'initialisation des listes
list_1 = [8, 2, 7]
list_2 = [9, 2, 5]
list_3 = [1, 0, 1]
print(list(itertools.chain(list_3, list_1, list_2)))
Résultat d’exécution :
1.6. Concaténation des listes avec compréhension des listes:
La compréhension des listes est un moyen efficace pour créer des listes. La forme simple est [expression + contexte].
Expression : Que faire de chaque membre de la liste ?
Contexte : Que sélectionner comme éléments de liste ? Il s'agit d'un nombre quelconque des expressions for et if.
Exemple 12 :
Syntaxe :
# l'initialisation des listes
list_1 = [4,1,2,3,7,5]
list_2 = [1,0,8,5,3,9]
List = [element for i in [list_1, list_2] for element in i]
print(List)
Résultat d’exécution :
Exemple 13 :
Syntaxe :
# l'initialisation des listes
list_1 = [8, 2, 7]
list_2 = [9, 2, 5]
list_3 = [1, 0, 1]
List = [element for i in [list_1, list_2, list_3] for element in i]
print(List)
Résultat d’exécution :
Exemple 14:
Syntaxe :
# l'initialisation des listes
list_1 = [4,1,2,3,7,5]
list_2 = [1,0,8,5,3,9]
# 1. Liste concatenation operator +
List_1 = list_1 + list_2
print(List_1)
# 2. Liste append() methode
List_2 = []
for e in list_1:
List_2.append(e)
for e in list_2:
List_2.append(e)
print(List_2)
# 3. List extend() methode
List_3 = []
List_3.extend(list_1)
List_3.extend(list_2)
print(List_3)
# 4. Asterisk operator *
List_4 = [*list_1, *list_2]
print(List_4)
# 5. Itertools.chain()
import itertools
List_5 = list(itertools.chain(list_1, list_2))
print(List_5)
# 6. List comprehension
List_6 = [e for i in (list_1, list_2) for e in i]
print(List_6)
Résultat d’exécution :
2. Comment comparer deux listes en python ?
2.1. La comparaison simple
Exemple 15 :
Syntaxe :
def méthode_1(list_1, list_2):
return list_1 == list_2
list_1 = [1, 0, 1, 0, 1]
list_2 = [1, 0, 1]
print(méthode_1(list_1, list_2))
Résultat d’exécution :
2.2. La comparaison simple avec boucle for
Exemple 16 :
Syntaxe :
# 2. boucle for
def méthode_1(list_1, list_2):
for i in range(min(len(list_2), len(list_1))):
if list_2[i] != list_1[i]:
return False
return len(list_1) == len(list_2)
list_1 = [1, 0, 1, 0, 1]
list_2 = [1, 0, 1]
print(méthode_1(list_1, list_2))
print(méthode_1(list_1, list_1))
Résultat d’exécution :
En effet, dans le code, on itére sur tous les indices de 0 jusqu'à la dernière position de la liste la plus petite comme indiqué par la partie min(len(liste_1), len(liste_2)). Vous examinez ensuite si les deux éléments à placer à la même position ne sont pas identiques. Si les deux éléments sont différents, donc liste_1[i] != liste_2[i], vous pouvez directement retourner False parce que les listes sont elles aussi différentes.
Dans le cas où vous avez parcouru la totalité de la boucle sans renvoyer False, alors les éléments de la liste sont semblables. Toutefois, une liste peut être plus grande encore ! Ainsi, en retournant len(liste_1) == len(liste_2), il est garanti que vous ne retournerez True que si 1) tous les éléments sont identiques et 2) les listes ont la même taille.
2.3. La comparaison avec zip() + boucle for
Exemple 17:
Syntaxe:
def méthode_1(list_1, list_2):
for i, j in zip(list_1, list_2):
if i != j:
return False
return len(list_2) == len(list_1)
list_1 = [1, 0, 1, 0, 1]
list_2 = [1, 0, 1]
print(méthode_1(list_1, list_2))
print(méthode_1(list_1, list_1))
Résultat d’exécution :
Au lieu d'itérer sur des indices, vous itérez maintenant sur des paires d'éléments . Si la taille des listes est différente, les autres éléments de la liste la plus étendue seront sautées. De cette manière, la comparaison par élément devient simplifiée et aucun modèle d'indexation compliqué n'est nécessaire. En évitant les index au niveau de la fonction zip(), on obtient une approche plus pythonique, évidemment !
2.4. La comparaison avec zip() + len()+ sum()
Exemple 18:
Syntaxe:
# 4. Sum() + Zip() + Len()
def méthode_1(list_1, list_2):
s = sum(i == j for i, j in zip(list_1, list_2))
return s == len(list_1) == len(list_2)
list_1 = [1, 0, 1, 0, 1]
list_2 = [1, 0, 1]
print(méthode_1(list_1, list_2))
print(méthode_1(list_1, list_1))
# False
# True
print(méthode_1([1, 0], [0, 1]))
# False
Résultat d’exécution :
Cependant, les vrais codeurs Python préfèrent souvent éviter une boucle for et utilisent des expressions génératrices.
On crée d'abord une expression itérative de valeurs booléennes en utilisant l'expression génératrice i == j pour i, j dans zip(liste_1, liste_2).
Ensuite, vous faites la somme des valeurs booléennes pour trouver le nombre d'éléments identiques et vous le mémorisez dans la variable s.
Finalement, on compare avec la taille des deux listes. Si les trois valeurs sont similaires, les deux listes contiennent les mêmes éléments et ont la même longueur. Elles sont identiques !
2.5. La comparaison avec map()+ len() + reduce()
Exemple 19
Syntaxe:
# 5. map() + reduce() + len()
from functools import reduce
def méthode_1(list_1, list_2):
S = map(lambda i, j: i == j, list_1, list_2)
res = reduce(lambda i, j: i and j, S)
return res and len(list_1) == len(list_2)
list_1 = [1, 0, 1, 0, 1]
list_2 = [1, 0, 1]
print(méthode_1(list_1, list_2))
print(méthode_1(list_1, list_1))
print(méthode_1([1, 0, 1], [1, 0, 1]))
Résultat d’exécution :
La fonction map() associe toutes les paires des éléments à des valeurs de type booléen . La fonction reduce() regroupe toutes les valeurs de type booléen en effectuant une opération and(et).
2.6. La comparaison avec map() + all()
Exemple 20:
Syntaxe:
# l'initialisation des listes
# 6. map() + all()
def méthode_1(list_1, list_2):
res = all(map(lambda i, j: i == j, list_1, list_1))
return res and len(list_1) == len(list_2)
list_1 = [1, 0, 1, 0, 1]
list_2 = [1, 0, 1]
print(méthode_1(list_1, list_2))
# False
print(méthode_1([1, 2, 1], [1, 2, 1]))
# True
Résultat d’exécution :
Cette opération est identique à la méthode précédemment utilisée, mais en utilisant la fonction all() au lieu de reduce() pour associer toutes les valeurs de type booléen dans une opération and(et) globale.
1. Exercices
Exercice 1 :
Écrivez un programme Python pour créer une liste en concaténant une liste donnée qui va de 1 à n.
Exercice 2 :
Écrivez un programme Python pour obtenir la différence entre les deux listes.
Exercice 3 :
Écrivez un programme Python pour ajouter une liste à la deuxième liste.
2. Correction des exercices
Exercice 1:
Syntaxe:
List = ['a', 'b','c']
n = 3
res = ['{}{}'.format(i, j) for j in range(1, n+1) for i in List]
print(res)
Résultat d’exécution :
Exercice 2:
Syntaxe:
def méthode_1(list_1, list_2):
dif_list_1_list_2 = list(set(list_1) - set(list_2))
dif_list_2_list_1 = list(set(list_2) - set(list_1))
return dif_list_1_list_2 + dif_list_2_list_1
list_1 = [1, 2, 1, 5, 1]
list_2 = [4, 2, 5, 6]
print(méthode_1(list_1, list_2))
list_1 = [1, 2, 1, 3, 1]
list_2 = [1, 0, 1]
print(méthode_1(list_1, list_2))
Résultat d’exécution :
Exercice 3:
Syntaxe:
list_1 = [1, 2, 3, 4]
list_2 = ['cour-gratuit', 'yahoo', 'yandex']
List_res = list_1 + list_2
#extend method
list_1.extend(list_2)
#affichage
print(list_1)
print(List_res)
Résultat d’exécution :
3. Conclusion
Les moyens les plus efficaces permettant de concaténer les listes sont en général les opérateurs + et *. Il est possible d'utiliser toutes les méthodes mentionnées précédemment pour effectuer la concaténation des listes. En pratique, vous apprendrez quand et quelle méthode utiliser en fonction des nécessités du programme.
Le résultat de la combinaison serait basé sur la séquence dans laquelle vous placerez les listes à associer. J'espère que vous comprendriez les différentes méthodes de chaînage des listes.
Article publié le 17 Novembre 2020par Babachekhe Mohamed