Condenser deux listes de longueur inégale dans un dictionnaire Python

Présentation

En Python, les listes et les dictionnaires sont l'une des méthodes de collecte et de traitement de données les plus couramment utilisées. Il existe de nombreuses opérations liées aux listes et aux dictionnaires qui sont couramment utilisées pour obtenir des données sous la forme souhaitée. Parfois, nous pouvons également avoir besoin de compresser deux listes différentes et d'obtenir la liste compressée sous forme de dictionnaire.

Dans cet article, nous discuterons de l'opération de compression de deux listes de longueur inégale et afficherons le résultat sous forme de dictionnaire. Cet article aidera les lecteurs à comprendre l'opération de compression d'une liste et à générer un dictionnaire à partir de celle-ci.

Commençons donc par discuter de ce que signifie compresser deux listes inégales.

Compressez deux listes de longueurs inégales

En Python, la compression est l'une des opérations les plus courantes lors de la collecte et du traitement des données, et elle implique l'ajout de deux listes sous forme de paires clé-valeur. En termes simples, il s'agit d'une opération dans laquelle les valeurs ou les éléments d'une liste sont ordonnés ou représentés de manière à les faire ressembler à des paires clé-valeur dans le résultat de sortie.

Cette opération est l'une des plus courantes, car nous pouvons parfois avoir besoin d'une liste ou d'un dictionnaire qui est une combinaison de deux listes différentes. Nous pouvons avoir deux listes de tailles ou de longueurs différentes, puis les fusionner et les afficher sous forme de dictionnaire pour un traitement plus facile et plus efficace des données.

Il existe de nombreuses façons d’obtenir le même effet. Discutons de certaines de ces méthodes.

Méthode 1 : Utiliser Itertools + Cycle

Nous pouvons utiliser la bibliothèque itertools et importer le cycle afin de compresser les deux listes et obtenir le dictionnaire en sortie

.

# Itertools + Cycle Method 


# Import the cycle from itertools
from itertools import cycle

# define two lists
list1 = ['a', 'b', 'c', 'd', 'e']
list2 = [1, 2, 3, 4]

# zip the lists and pass them into the dictionary form
res = dict(zip(list1, cycle(list2)))

# print the final results
print("Final Output Dictionary : ", str(res))

Comme nous pouvons le voir dans le code ci-dessus, nous avons d'abord importé le cycle depuis itertools et défini deux listes de tailles différentes.

Utilisez ensuite la fonction de boucle dans itertools pour compresser les deux listes de longueurs inégales, puis représentez la sortie sous forme de dictionnaire.

Sortie

La sortie du code suivant sera :

Final Output Dictionary: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 1}

Méthode 2 : Utiliser deque

Semblable aux boucles dans itertools, nous pouvons utiliser des deques dans les collections. En important deque, on peut compresser les deux listes et obtenir un dictionnaire.

# using deque for zipping lists

from collections import deque

# define two list that are to be zipped 
ini_lis1 = ['a', 'b', 'c', 'd', 'e']
ini_lis2 = deque([1, 2, 3, 4])

# zip teh lists using deque
result = {}
for letter in ini_lis1:
  number = ini_lis2.popleft()
  result[letter] = number
  ini_lis2.append(number)


# print the final results
print("Output Dict : ", str(result))

Comme on peut le voir dans le code ci-dessus, après avoir importé deque depuis des collections, deux listes de tailles différentes sont définies.

Ensuite, utilisez la fonction for loop et append pour compresser les deux listes. Le résultat final sera imprimé sous forme de dictionnaire.

Sortie

La sortie de ce code sera :

Output Dict : {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 1}

Méthode 3 : Utiliser la classe par défaut

La classe par défaut peut également être utilisée pour compresser deux listes de tailles différentes et donner un dictionnaire en sortie.

# using default class method

# import default dict from collections
from collections import defaultdict

# define two lists
ini_lis1 = ['a', 'b', 'c', 'd', 'e']
ini_lis2 = [1, 2, 3, 4]

# use default dict
result = defaultdict(int)

# add values to the keys respectively
for i in range(len(ini_lis1)):
	result[ini_lis1[i]] += ini_lis2[i % len(ini_lis2)]

# print the final results
print("Output Dict: ", str(dict(result)))

Comme on peut le voir dans le code ci-dessus, deux listes sont définies après avoir importé la classe par défaut et utilisé une boucle for pour ajouter les valeurs aux clés correspondantes.

Veuillez noter que si la clé n'est pas présente dans les données, elle renverra une valeur par défaut. Ici, nous utilisons la valeur par défaut de 0.

Sortie

La sortie du code suivant sera :

Output Dict: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 1}

Méthode 4 : utilisez Zip() + Dict()

C'est le moyen le plus simple de compresser deux listes différentes et de les afficher sous forme de dictionnaire.

# using zip + dict method
# define two lists that are to be zipped
ini_lis1 = ['a', 'b', 'c', 'd', 'e']
ini_lis2 = [1, 2, 3, 4]

# use zip()
result = dict(zip(ini_lis1, ini_lis2 *
        ((len(ini_lis1) + len(ini_lis2) - 1) // len(ini_lis2))))

# print the final results
print("Output Dict: ", str(result))

Dans le code ci-dessus, nous définissons d'abord deux listes différentes puis, lors de la définition du résultat, passons la syntaxe ou le code à dict() qui renverra la sortie au format de données de dictionnaire. Ici, deux listes sont compressées ensemble à l'aide du mot-clé zip, qui ajoute les valeurs de deux listes différentes ensemble.

Sortie

La sortie du code suivant sera :

Output Dict: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 1}

Méthode 5 : utilisez Itertools() + enumerate()

Dans cette méthode, nous utiliserons la bibliothèque Itertools et utiliserons enumerate dans le processus de compression de deux listes.

# using itertools + enumerate
# Import itertools
from itertools import cycle

# define two lists
ini_lis1 = ['a', 'b', 'c', 'd', 'e']
ini_lis2 = [1, 2, 3, 4]

# zip the two lists using for loop and enumerate
result = {v: ini_lis2[i % len(ini_lis2)]
    for i, v in enumerate(ini_lis1)}

# print the final results
print("Output Dict : ", str(result))

Comme nous pouvons le voir dans le code ci-dessus, nous importons d'abord le cycle depuis itertools puis définissons deux listes de tailles différentes. Ensuite à l'aide d'une boucle for et d'une fonction enumerate, on ajoute (compresse) les valeurs ou éléments de deux listes différentes puis les valeurs sont représentées sous la forme d'un dictionnaire.

Sortie

La sortie du code suivant sera :

Output Dict : {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 1}

Conclusion

Dans cet article, nous discutons de l'utilisation de six méthodes différentes pour compresser deux listes de tailles différentes en Python et fournissons des exemples de code et des instructions. Cet article aidera les lecteurs à effectuer des opérations similaires si nécessaire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!