Jusqu'à présent, nous avons vu les façons de créer un dictionnaire de plusieurs manières et différentes opérations sur la clé et les valeurs dans Python. dictionnaire . Voyons maintenant différentes manières de créer un dictionnaire de listes. Notez que la restriction avec les clés dans le Python Le dictionnaire est que seuls les types de données immuables peuvent être utilisés comme clés, ce qui signifie que nous ne pouvons pas utiliser un dictionnaire de listes comme clé.
Exemple :
Input: myDict = {} myDict['key1'] = [1, 2] # Adding list as value myDict['key2'] = ['Geeks', 'For', 'Geeks'] Output: {'key2': ['Geeks', 'For', 'Geeks'], 'key1': [1, 2]} Explanation: In the output, we have a dictionary of lists.> Énoncé du problème
Nous obtenons généralement l'erreur typrerror si nous essayons de l'implémenter de la manière normale.
Python3
# Creating a dictionary> myDict>=> {[>1>,>2>]:>'Geeks'>}> print>(myDict)> |
remplacer tout Java
>
>
Sortir:
TypeError: unhashable type: 'list'>
Mais la même chose peut être faite très judicieusement avec les valeurs d’un dictionnaire. Voyons toutes les différentes façons dont nous pouvons créer un dictionnaire de listes.
Façons de créer un dictionnaire de listes
Voici les sujets que nous aborderons dans cet article :
- En utilisant indice
- En utilisant le méthode append()
- En utilisant le Méthode setdefault()
- En utilisant compréhension de liste
- En utilisant dict par défaut
- En utilisant Json.dumb() méthode
- En utilisant module itertools
Créer un dictionnaire de listes en utilisant l'indice
Ce code initialise un vide dictionnaire myDict>. Il ajoute ensuite deux paires clé-valeur au dictionnaire :'key1'>avec la valeur[1, 2]>, et'key2'>avec la valeur['Geeks', 'For', 'Geeks']>. Enfin, le code imprime le contenu du dictionnaire.
Python3
# Creating an empty dictionary> myDict>=> {}> # Adding list as value> myDict[>'key1'>]>=> [>1>,>2>]> myDict[>'key2'>]>=> [>'Geeks'>,>'For'>,>'Geeks'>]> print>(myDict)> |
>
>
Sortir:
{'key2': ['Geeks', 'For', 'Geeks'], 'key1': [1, 2]}> Complexité temporelle : O(1) pour chaque insertion de dictionnaire et impression du dictionnaire.
Espace auxiliaire : O(n), où n est le nombre total d'éléments dans le dictionnaire.
Créez un dictionnaire de listes en utilisant la méthode append()
Ajout d'une liste imbriquée en tant que valeur à l'aide de l'option méthode append(). Créez une nouvelle liste et nous pouvons simplement ajouter cette liste à la valeur.
Python3
# Creating an empty dictionary> myDict>=> {}> # Adding list as value> myDict[>'key1'>]>=> [>1>,>2>]> # creating a list> lst>=> [>'Geeks'>,>'For'>,>'Geeks'>]> # Adding this list as sublist in myDict> myDict[>'key1'>].append(lst)> print>(myDict)> |
>
Java trier une liste
>
Sortir:
{'key1': [1, 2, ['Geeks', 'For', 'Geeks']]}> Complexité temporelle : O(1).
Complexité de l'espace auxiliaire : Sur).
Créez un dictionnaire de listes à l'aide de la méthode setdefault()
Parcourez la liste et continuez à ajouter les éléments jusqu'à la plage donnée en utilisant le méthode setdefault().
Python3
fonction de flèche dactylographiée
# Creating an empty dict> myDict>=> dict>()> # Creating a list> valList>=> [>'1'>,>'2'>,>'3'>]> # Iterating the elements in list> for> val>in> valList:> >for> ele>in> range>(>int>(val),>int>(val)>+> 2>):> >myDict.setdefault(ele, []).append(val)> print>(myDict)> |
>
>
Sortir:
{1: ['1'], 2: ['1', '2'], 3: ['2', '3'], 4: ['3']}> Complexité temporelle : O(n^2)
Complexité spatiale : Sur)
Création d'un dictionnaire de listes à l'aide de la compréhension de liste
Dans compréhension de liste nous parcourons les valeurs'1'>,'2'>, et'3'>, et pour chaque valeur, il crée une paire clé-valeur dans le dictionnaire. La clé est la valeur actuelle et la valeur est une plage d'entiers commençant par la valeur convertie en entier et se terminant par la valeur plus 1.
Python
# Creating a dictionary of lists using list comprehension> d>=> dict>((val,>range>(>int>(val),>int>(val)>+> 2>))> >for> val>in> [>'1'>,>'2'>,>'3'>])> print>(d)> |
>
>
Sortir:
{'1': [1, 2], '3': [3, 4], '2': [2, 3]}> Complexité temporelle : O(1).
Complexité de l'espace auxiliaire : Sur).
Création d'un dictionnaire de listes à l'aide de defaultdict
Importer le dict par défaut classe du module collections. Définissez une liste de tuples lst avec chaque tuple contenant une paire clé-valeur. Créez un objet defaultdict appelé orDict qui aura les valeurs par défaut d'une liste vide. Parcourez la liste des tuples lst à l'aide d'une boucle for et décompressez chaque tuple dans les variables key et val. Ajoutez la valeur val à la liste associée à la clé dans le dictionnaire orDict.
Imprimez le dictionnaire résultant ou Dict.
Note : La même chose peut également être faite avec un simple dictionnaire mais l'utilisation de defaultdict est plus efficace dans de tels cas.
Python3
from> collections>import> defaultdict> lst>=> [(>'Geeks'>,>1>), (>'For'>,>2>), (>'Geeks'>,>3>)]> orDict>=> defaultdict(>list>)> # iterating over list of tuples> for> key, val>in> lst:> >orDict[key].append(val)> print>(orDict)> |
>
>
Sortir:
defaultdict(, {'For': [2], 'Geeks': [1, 3]})> Complexité temporelle : O(n).
Espace auxiliaire : O(n).
Notez qu'il n'y a que deux paires clé : valeur dans le dictionnaire de sortie mais la liste d'entrée contient trois tuples. Le premier élément (c'est-à-dire la clé) est le même pour le premier et le troisième tuples et deux clés ne peuvent jamais être identiques.
Création d'un dictionnaire de listes à l'aide de Json
En important lejson>module. Il initialise une listelst>contenant des tuples. Ensuite, un dictionnaire videdict>est initialisé. Le code convertit la listelst>dans une chaîne au format JSON en utilisantjson.dumps()> , et attribue cette chaîne comme clé dans le dictionnairedict>avec la valeur convertie. Enfin, le dictionnaire est imprimé.
Python3
0,04 en fraction
#importing json> import> json> #Initialisation of list> lst>=> [(>'Geeks'>,>1>), (>'For'>,>2>), (>'Geeks'>,>3>)]> #Initialisation of dictionary> dict> => {}> #using json.dump()> hash> => json.dumps(lst)> #creating a hash> dict>[>hash>]>=> 'converted'> #Printing dictionary> print>(>dict>)> |
>
>
Sortir:
{'[['Geeks', 1], ['For', 2], ['Geeks', 3]]': 'converted'}> Complexité temporelle : O(n), où n est la longueur de la liste lst.
Espace auxiliaire : O(n), où n est la longueur de la liste lst.
jquery en cliquant
Création d'un dictionnaire de listes à l'aide de itertools
Une approche consiste à utiliser la fonction zip_longest du module itertools. Cette fonction vous permet de parcourir deux ou plusieurs itérables de manière parallèle, en remplissant tous les éléments manquants avec une valeur de remplissage spécifiée.
Python3
from> itertools>import> zip_longest> # Initialize the lists> list1>=> [>1>,>2>,>3>]> list2>=> [>10>,>20>,>30>,>40>]> list3>=> [>'a'>,>'b'>,>'c'>,>'d'>,>'e'>]> # Use zip_longest to iterate over the lists in parallel> d>=> {}> for> elem1, elem2, elem3>in> zip_longest(list1, list2, list3, fillvalue>=>0>):> >d.setdefault(elem1, []).append(elem2)> >d.setdefault(elem1, []).append(elem3)> print>(d)> # Output: {1: [10, 'a'], 2: [20, 'b'], 3: [30, 'c'], 0: [40, 'd']}> |
>
>Sortir
{1: [10, 'a'], 2: [20, 'b'], 3: [30, 'c'], 0: [40, 'd', 0, 'e']}> Complexité temporelle : O(n), où n est la longueur de la liste la plus longue.
Espace auxiliaire : Sur)