Ajouter des paires clé-valeur à un dictionnaire dans une boucle en Python
Dictionary est une structure de données étonnante et efficace pour stocker des données sous forme de paires clé-valeur en Python.
Puisqu’il s’agit d’une structure de données, un dictionnaire n’est pas seulement spécifique à Python mais également disponible dans d’autres langages de programmation tels que C++, Java, JavaScript, etc. Il est référencé avec un nom différent tel que map et JSON (JavaScript Object Notation) objet.
Un dictionnaire a une clé, et une clé peut être n’importe quelle valeur ou objet pouvant être haché et immuable. La raison derrière ces deux exigences est que la représentation de hachage d’un objet dépend des valeurs qu’il stocke à l’intérieur.
Si les valeurs peuvent être manipulées dans le temps, l’objet n’aurait pas de représentation de hachage unique et fixe. Une valeur dans un dictionnaire peut être n’importe quoi ; il peut s’agir d’une valeur entière, d’une valeur flottante, d’une valeur double, d’une valeur de chaîne, d’un objet de classe, d’une liste, d’un arbre binaire, d’une liste chaînée, d’une fonction et même d’un dictionnaire.
En ce qui concerne la complexité temporelle, un dictionnaire prend un temps constant, O(1), en moyenne, pour ajouter, supprimer et accéder à un élément.
Cet article explique comment ajouter des paires clé-valeur à un dictionnaire dans une boucle.
Ajouter des paires clé-valeur à un dictionnaire dans une boucle
Pour ajouter des paires clé-valeur à un dictionnaire dans une boucle, nous pouvons créer deux listes qui stockeront les clés et les valeurs de notre dictionnaire. Ensuite, en supposant que la clé ième est destinée à la valeur ième, nous pouvons parcourir les deux listes ensemble et ajouter des valeurs à leurs clés respectives dans le dictionnaire.
Comprenons cela à l’aide d’un code Python, reportez-vous au code suivant :
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def add(*args):
s = 0
for x in args:
s += x
return s
dictionary = {}
keys = [
"Integer",
"String",
"Float",
"List of Strings",
"List of Float Numbers",
"List of Integers",
"Dictionary",
"Class Object",
"Function",
"List of Class Objects",
]
values = [
1,
"Hello",
2.567,
["Computer", "Science"],
[1.235, 5.253, 77.425],
[11, 22, 33, 44, 55],
{"a": 500, "b": 1000, "c": 1500},
Point(1, 6),
add,
[Point(0, 0), Point(0, 7.5), Point(7.5, 7.5), Point(7.5, 0)],
]
for key, value in zip(keys, values):
dictionary[key] = value
print(dictionary)
Production :
{'Integer': 1, 'String': 'Hello', 'Float': 2.567, 'List of Strings': ['Computer', 'Science'], 'List of Float Numbers': [1.235, 5.253, 77.425], 'List of Integers': [11, 22, 33, 44, 55], 'Dictionary': {'a': 500, 'b': 1000, 'c': 1500}, 'Class Object': <__main__.Point object at 0x7f2c74906d90>, 'Function': <function add at 0x7f2c748a3d30>, 'List of Class Objects': [<__main__.Point object at 0x7f2c749608b0>, <__main__.Point object at 0x7f2c748a50a0>, <__main__.Point object at 0x7f2c748a5430>, <__main__.Point object at 0x7f2c748a53d0>]}
La complexité temporelle de la solution ci-dessus est O(n), et la complexité spatiale de la solution ci-dessus est également O(n), où n est la taille des listes keys et values. De plus, le code ci-dessus montre que tous les types de valeurs dont nous avons parlé peuvent être stockés dans un dictionnaire.
Nous pouvons embellir la sortie en réitérant le dictionnaire et en imprimant chaque paire clé-valeur ou en imprimant chaque paire clé-valeur tout en les ajoutant au dictionnaire. Notez que l’on peut également utiliser des packages Python pré-construits tels que le package json et des packages open source externes pour jouer avec la sortie JSON, ajouter un codage couleur, ajouter une indentation, etc.
Pour notre cas d’utilisation, nous allons créer une fonction stub pour imprimer un dictionnaire. Référez-vous au code suivant :
def print_dictionary(dictionary):
for key, value in dictionary.items():
print(f"{key}: {value}")
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def add(*args):
s = 0
for x in args:
s += x
return s
dictionary = {}
keys = [
"Integer",
"String",
"Float",
"List of Strings",
"List of Float Numbers",
"List of Integers",
"Dictionary",
"Class Object",
"Function",
"List of Class Objects",
]
values = [
1,
"Hello",
2.567,
["Computer", "Science"],
[1.235, 5.253, 77.425],
[11, 22, 33, 44, 55],
{"a": 500, "b": 1000, "c": 1500},
Point(1, 6),
add,
[Point(0, 0), Point(0, 7.5), Point(7.5, 7.5), Point(7.5, 0)],
]
for key, value in zip(keys, values):
dictionary[key] = value
print_dictionary(dictionary)
Production :
Integer: 1
String: Hello
Float: 2.567
List of Strings: ['Computer', 'Science']
List of Float Numbers: [1.235, 5.253, 77.425]
List of Integers: [11, 22, 33, 44, 55]
Dictionary: {'a': 500, 'b': 1000, 'c': 1500}
Class Object: <__main__.Point object at 0x7f7d94160d90>
Function: <function add at 0x7f7d940fddc0>
List of Class Objects: [<__main__.Point object at 0x7f7d941ba8b0>, <__main__.Point object at 0x7f7d940ff130>, <__main__.Point object at 0x7f7d940ff310>, <__main__.Point object at 0x7f7d940ff3d0>]
La complexité temporelle et spatiale de la solution ci-dessus est la même que celle de la solution précédente, O(n).
Les deux extraits de code ci-dessus utilisent une boucle for. Nous pouvons effectuer la même tâche en utilisant une boucle while.
L’extrait de code suivant illustre l’ajout de valeurs à un dictionnaire à l’aide d’une boucle while.
def print_dictionary(dictionary):
for key, value in dictionary.items():
print(f"{key}: {value}")
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def add(*args):
s = 0
for x in args:
s += x
return s
dictionary = {}
keys = [
"Integer",
"String",
"Float",
"List of Strings",
"List of Float Numbers",
"List of Integers",
"Dictionary",
"Class Object",
"Function",
"List of Class Objects",
]
values = [
1,
"Hello",
2.567,
["Computer", "Science"],
[1.235, 5.253, 77.425],
[11, 22, 33, 44, 55],
{"a": 500, "b": 1000, "c": 1500},
Point(1, 6),
add,
[Point(0, 0), Point(0, 7.5), Point(7.5, 7.5), Point(7.5, 0)],
]
n = min(len(keys), len(values))
i = 0
while i != n:
dictionary[keys[i]] = values[i]
i += 1
print_dictionary(dictionary)
Production :
Integer: 1
String: Hello
Float: 2.567
List of Strings: ['Computer', 'Science']
List of Float Numbers: [1.235, 5.253, 77.425]
List of Integers: [11, 22, 33, 44, 55]
Dictionary: {'a': 500, 'b': 1000, 'c': 1500}
Class Object: <__main__.Point object at 0x7fdbe16c0d90>
Function: <function add at 0x7fdbe165ddc0>
List of Class Objects: [<__main__.Point object at 0x7fdbe171a8b0>, <__main__.Point object at 0x7fdbe165f130>, <__main__.Point object at 0x7fdbe165f310>, <__main__.Point object at 0x7fdbe165f3d0>]
La complexité temporelle et spatiale de la solution ci-dessus est la même que celle de la solution précédente, O(n).
Vaibhav is an artificial intelligence and cloud computing stan. He likes to build end-to-end full-stack web and mobile applications. Besides computer science and technology, he loves playing cricket and badminton, going on bike rides, and doodling.
Article connexe - Python Dictionary
- Comment vérifier si une clé existe dans un dictionnaire en Python
- Convertir un dictionnaire en liste en Python
- Comment obtenir tous les fichiers d'un répertoire
- Comment trouver la valeur maximale dans le dictionnaire Python
- Comment trier un dictionnaire Python par valeur
- Comment fusionner deux dictionnaires en Python 2 et 3