Hinzufügen von Schlüssel-Wert-Paaren zu einem Dictionary innerhalb einer Schleife in Python
Dictionary ist eine erstaunliche und effiziente Datenstruktur zum Speichern von Daten in Form von Schlüssel-Wert-Paaren in Python.
Da es sich um eine Datenstruktur handelt, ist ein Dictionary nicht nur spezifisch für Python, sondern auch in anderen Programmiersprachen wie C++, Java, JavaScript usw. verfügbar. Es wird mit einem anderen Namen wie Map und JSON-Objekt (JavaScript Object Notation).
Ein Dictionary hat einen Schlüssel, und ein Schlüssel kann ein beliebiger Wert oder ein beliebiges Objekt sein, das hashbar und unveränderlich ist. Der Grund für diese beiden Anforderungen ist, dass die Hash-Darstellung eines Objekts von den darin gespeicherten Werten abhängt.
Wenn die Werte im Laufe der Zeit manipuliert werden können, hätte das Objekt keine eindeutige und feste Hash-Darstellung. Ein Wert in einem Dictionary kann alles sein; es kann ein Integer-Wert, ein Float-Wert, ein Double-Wert, ein String-Wert, ein Klassenobjekt, eine Liste, ein Binärbaum, eine verknüpfte Liste, eine Funktion und sogar ein Dictionary sein.
Wenn es um Zeitkomplexität geht, braucht ein Dictionary konstante Zeit, im Durchschnitt O(1), um ein Element hinzuzufügen, zu löschen und darauf zuzugreifen.
In diesem Artikel wird beschrieben, wie Sie einem Dictionary innerhalb einer Schleife Schlüssel-Wert-Paare hinzufügen.
Schlüssel-Wert-Paare zu einem Dictionary innerhalb einer Schleife hinzufügen
Um innerhalb einer Schleife Schlüssel-Wert-Paare zu einem Dictionary hinzuzufügen, können wir zwei Listen erstellen, die die Schlüssel und Werte unseres Dictionaries speichern. Unter der Annahme, dass der ith-Schlüssel für den ith-Wert gedacht ist, können wir als nächstes die beiden Listen gemeinsam durchlaufen und Werte zu ihren jeweiligen Schlüsseln im Dictionary hinzufügen.
Lassen Sie uns dies mit Hilfe von Python-Code verstehen, siehe folgenden Code:
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)
Ausgabe:
{'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>]}
Die Zeitkomplexität der obigen Lösung ist O(n), und die Raumkomplexität der obigen Lösung ist ebenfalls O(n), wobei n die Grösse der Listen Schlüssel und Werte ist. Darüber hinaus zeigt der obige Code, dass alle Arten von Werten, über die wir gesprochen haben, in einem Dictionary gespeichert werden können.
Wir können die Ausgabe verschönern, indem wir das Dictionary erneut iterieren und jedes Schlüssel-Wert-Paar drucken oder jedes Schlüssel-Wert-Paar drucken, während wir sie dem Dictionary hinzufügen. Beachten Sie, dass Sie auch vorgefertigte Python-Pakete wie das json-Paket und externe Open-Source-Pakete verwenden können, um mit der JSON-Ausgabe herumzuspielen, Farbcodierung hinzuzufügen, Einrückungen hinzuzufügen usw.
Für unseren Anwendungsfall erstellen wir eine Stub-Funktion zum Drucken eines Dictionaries. Siehe folgenden Code:
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)
Ausgabe:
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>]
Die Zeit- und Raumkomplexität der obigen Lösung ist dieselbe wie die der vorherigen Lösung, O(n).
Die beiden obigen Code-Schnipsel verwenden eine for-Schleife. Wir können die gleiche Aufgabe mit einer while-Schleife ausführen.
Der folgende Codeausschnitt zeigt das Hinzufügen von Werten zu einem Dictionary mithilfe einer while-Schleife.
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)
Ausgabe:
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>]
Die Zeit- und Raumkomplexität der obigen Lösung ist dieselbe wie die der vorherigen Lösung, 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.
Verwandter Artikel - Python Dictionary
- Wie man prüft, ob ein Schlüssel in einem Dictionary in Python vorhanden ist
- Konvertieren eines Dictionaries in eine Liste in Python
- So erhalten Sie alle Dateien eines Verzeichnisses
- Wie finde ich den Maximalwert im Python-Dictionary
- Wie man ein Python-Dictionary nach Wert sortiert
- Wie man zwei Wörterbücher in Python 2 und 3 zusammenführen kann