En Python, un dictionnaire est un ensemble non ordonné de valeurs de données cela pourrait être utilisé pour stocker les valeurs des données de la même manière qu'une carte. Contrairement aux autres types de données, qui ne peuvent inclure qu'une seule valeur par élément, les dictionnaires peuvent également contenir un valeur clé paire. Faire le dictionnaire plus efficace , La valeur-clé est proposée.
En ce qui concerne l'accès aux attributs, le point '.' (un péché x.any_attribute ) est tout ce que la majorité des utilisateurs connaissent. Dit simplement, l'accès aux attributs est le processus d'obtention d'un objet connecté à celui que vous possédez déjà . Cela peut paraître très simple à quelqu'un qui utilise Python sans entrer trop dans les détails. Cependant, beaucoup de choses se passent en coulisses pour ce processus relativement simple.
Qu'est-ce que _dict_ ?
Chaque module possède une propriété unique appelée __dict__. Ce dictionnaire contient la table des symboles du module . Les caractéristiques (inscriptibles) d'un élément sont stockées dans un dictionnaire ou dans l'autre objet de mappage.
Pour faire simple, chaque objet en Python a un propriété indiquée par le symbole __dict__ . De plus, cet objet possède toutes les propriétés qui lui ont été spécifiées. Un autre nom pour __dict__ est proxy de mappage objet. Nous pouvons utiliser le dictionnaire via appliquer la propriété __dict__ à un objet de classe.
Syntaxe :
object.__dict__
Exemple :
class AnimalClass: def __init__(self,identity,age): self.identity = identity self.age = age def feature(self): if self.age == '10': return True else: return False ac = AnimalClass('Lion','10') print(ac.__dict__)
Sortir:
{'identity': 'Lion', 'age': '10'} Exemple 2 :
Cet exemple démontrera qu'au moyen du Attribut __dict__ , on pourrait créer un dictionnaire à partir de n'importe quel objet :
# class Flowers is defined class Flowers: # constructor def __init__(self): # keys are being initialized with # their corresponding values self.Rose = 'red' self.Lily = 'white' self.Lotus = 'pink' def displayit(self): print('The Dictionary from object fields belongs to the class Flowers :') # object animal of class Animals flower = Flowers() # calling displayit function flower.displayit() # calling the attribute __dict__ on flower # object and making it print it print(flower.__dict__)
Sortir:
The Dictionary from object fields belongs to the class Flowers : {'Rose': 'red', 'Lily': 'white', 'Lotus': 'pink'} Exemple 3 :
def funct(): pass funct.practice = 1 print(funct.__dict__) class PracticeClass: x = 1 def practice_function(self): pass print(PracticeClass.__dict__)
Sortir:
{'practice': 1} {'__module__': '__main__', 'x': 1, 'practice_function': , '__dict__': , '__weakref__': , '__doc__': None} Utiliser Dictionary sans utiliser __dict__ en Python :
Création d'un dictionnaire :
En Python, un dictionnaire peut être créé en joignant un liste des entrées entre accolades et en les séparant par une virgule . Le dictionnaire stocke des paires de valeurs, où un élément de paire est la clé et un autre est sa Valeur clé . Contrairement à clés, lequel ne peut pas être répété et doit être immuable, les valeurs dans les dictionnaires peut être de tout type de données et peut être dupliqué .
Les éléments sont séparé par des virgules , chaque clé se distingue de sa valeur par deux points (:), et toute la structure est contenue dans accolades . Un dictionnaire totalement dépourvu de tous mots s’écrit comme suit : {} .
Les clés du dictionnaire doivent être immuable , tel que entiers, tuples ou chaînes , bien que les valeurs puissent être de n'importe quel type. Dans les dictionnaires Python, le même nom de clé orthographié différemment est considéré comme une clé distincte. Veuillez noter que les clés du dictionnaire sont sensibles à la casse ; les clés portant un nom similaire mais une casse distincte seront traitées différemment.
Exemple :
comment vérifier la taille de l'écran
# Creating a Dictionary # using Integer Keys only Dict = {1: 'JAVA', 2: 'T', 3: 'POINT'} print('
Creating a Dictionary by using Integer Keys : ') print(Dict) # Creating a Dictionary # using various Mixed keys Dict = {'Company': 'JavaTpoint', 7: [22, 35, 46, 97]} print('
Creating a Dictionary by using Mixed Keys : ') print(Dict) Sortir:
Creating a Dictionary by using Integer Keys : {1: 'JAVA', 2: 'T', 3: 'POINT'} Creating a Dictionary by using Mixed Keys : {'Company': 'JavaTpoint', 7: [22, 35, 46, 97]} Le méthode intégrée dict() permet également le création de dictionnaires . En termes simples deux accolades {} ensemble aboutira à un dictionnaire vide .
Exemple :
# Creating an empty Dictionary myDict = {} print('This is an Empty Dictionary: ') print(myDict) # Creating a Dictionary # using the dict() method myDict = dict({1: 'JAVA', 2: 'T', 3: 'POINT'}) print('
Creating a Dictionary by using the dict() method : ') print(myDict) # Creating a Dictionary # using each item as a different Pair myDict = dict([(1, 'JavaTpoint'), (2, 'Great')]) print('
Creating a Dictionary by using each item as a different pair : ') print(myDict) Sortir:
This is an Empty Dictionary: {} Creating a Dictionary by using the dict() method : {1: 'JAVA', 2: 'T', 3: 'POINT'} Creating a Dictionary by using each item as a different pair : {1: 'JavaTpoint', 2: 'Great'} Complexités pour créer un dictionnaire :
- Complexité temporelle : O (longueur (dict))
- Complexité spatiale : Sur)
Dictionnaires imbriqués :
C'est une forme de dictionnaire où un ou plusieurs les clés sont associées à un dictionnaire en tant que valeur de la clé.
Exemple :
# Creating a Nested Dictionary # as mentioned above using a dictionary as a value to a key in # a dictionary myDict = dict({1: 'JAVA', 2: 'T', 3: 'POINT', 4: {1: 'JavaTpoint', 2: 'Great'}}) print('
Creating a Nested Dictionary : ') print(myDict) Sortir:
Creating a Nested Dictionary : {1: 'JAVA', 2: 'T', 3: 'POINT', 4: {1: 'JavaTpoint', 2: 'Great'}} Ajout d'éléments à un dictionnaire :
Il y a plusieurs méthodes pour ajouter des éléments à un dictionnaire Python. En spécifiant la valeur et la clé ensemble, par exemple, Dict[Clé] = 'Valeur', une valeur peut être ajoutée à un dictionnaire à la fois. En utilisant le fonction update() intégrée , on peut modifier une valeur existante dans un Dictionnaire. Un dictionnaire existant peut également être étendu avec valeurs de clé imbriquées .
Remarque : Lors de l'ajout d'une valeur, la valeur est mise à jour si la combinaison clé-valeur existe déjà. Sinon, une nouvelle clé et une nouvelle valeur sont ajoutées au dictionnaire.
Exemple :
# Creating Empty Dictionary myDict = {} print('Empty Dictionary: ') print(myDict) # Adding elements only one at a time myDict[0] = 'Java' myDict[3] = 'T' myDict[6] = 41 print('
Dictionary after the addition of 3 elements: ') print(myDict) # Adding a set of values # to a particular Key myDict['settingValues'] = 7, 8, 9 print('
Dictionary after the adding a set of values to a key : ') print(myDict) # Updating the existing Key's Value myDict[3] = 'tPoint' print('
Dictionary after Updated key value: ') print(myDict) # Adding Nested Key value to Dictionary myDict[8] = {'Nested' :{'A' : 'boy', 'B' : 'Girl'}} print('
Dictionary after Addition of a Nested Key: ') print(myDict) Sortir:
Empty Dictionary: {} Dictionary after the addition of 3 elements: {0: 'Java', 3: 'T', 6: 41} Dictionary after the adding a set of values to a key : {0: 'Java', 3: 'T', 6: 41, 'settingValues': (7, 8, 9)} Dictionary after Updated key value: {0: 'Java', 3: 'tPoint', 6: 41, 'settingValues': (7, 8, 9)} Dictionary after Addition of a Nested Key: {0: 'Java', 3: 'tPoint', 6: 41, 'settingValues': (7, 8, 9), 8: {'Nested': {'A': 'boy', 'B': 'Girl'}}} Complexités pour ajouter des éléments à un dictionnaire :
- Complexité temporelle : O(1)/O(n)
- Complexité spatiale : O(1)
Accéder aux éléments du dictionnaire :
Un dictionnaire emploie clés , alors que d'autres types de données nécessitent une indexation pour récupérer les valeurs. Les clés peuvent être utilisées avec le fonction obtenir() ou entre crochets [].
en quelle année l'ordinateur a-t-il été inventé
Dans le cas où un la clé est introuvable dans le dictionnaire, KeyError est produit si nous utilisons crochets []. En revanche, si la clé ne peut pas être localisée, le La fonction get() renvoie Aucun.
Exemple :
# Python program to demonstrate the # accessing of an element, from a Dictionary # Creating a Dictionary myDict = {1: 'Java', 'name': 'T', 2: 'Point', 4: 'Website'} # accessing an element using key print('Accessing an element using the key:') print(myDict['name']) print('Accessing another element using the key:') print(myDict[4]) # accessing an element using the get() method print('Accessing an using the get() method:') print(myDict.get(2)) print('Accessing another using the get() method:') print(myDict.get(1)) Sortir:
Accessing an element using the key: T Accessing another element using the key: Website Accessing an using the get() method: Point Accessing another using the get() method: Java
Complexités pour accéder aux éléments d'un dictionnaire :
- Complexité temporelle : O(1)
- Complexité spatiale : O(1)
Accéder à un élément d'un dictionnaire imbriqué :
Nous pouvons prendre l'aide du technique d'indexation [] pour obtenir la valeur d'une clé existante dans le dictionnaire imbriqué .
Exemple :
# Creating a Dictionary myDict = {'myDict1': {3: 'JavatPoint'}, 'myDict2': {'Info.': 'Website'}} # Accessing the elements using the key print(myDict['myDict1']) print(myDict['myDict1'][3]) print(myDict['myDict2']['Info.']) Sortir:
{3: 'JavatPoint'} JavatPoint Website Méthodes de dictionnaire intégrées :
clair() :
La fonction dict.clear() élimine chaque paire clé-valeur du dictionnaire.
rebase git
copie() :
UN copie moins profonde du dictionnaire est renvoyé par la méthode dict.copy().
fromkeys() :
Utilisation de l'itérable fourni (chaîne, liste, ensemble ou tuple) comme clés et la valeur spécifiée, la fonction dict.fromkeys() crée un nouveau dictionnaire .
obtenir() :
Ce donne la valeur associée avec la clé donnée.
articles() :
UN objet d'affichage du dictionnaire , qui offre une présentation dynamique des éléments du dictionnaire sous forme de liste de paires clé-valeur est retourné par la fonction dict.items(). Lorsque le dictionnaire est mis à jour, ceci l'objet de vue est également mis à jour .
dict.keys() :
La fonction dict.keys() renvoie un objet d'affichage de dictionnaire avec le dictionnaire liste de clés.
populaire() :
Ce renvoie la valeur de la clé après l'avoir supprimée . Si une clé manque dans le dictionnaire, il renvoie soit une Erreur de clé ou renvoie le valeur par défaut s'il y en avait un.
boire() :
Ce supprime un élément du dictionnaire et renvoie un tuple de paires (clé, valeur). Le Dernier entré, premier sorti (LIFO) la séquence est utilisée pour renvoyer des paires.
définir par defaut() :
Ce renvoie la valeur du dictionnaire pour la clé donnée . Si la clé ne peut pas être découverte, la clé avec le valeur par défaut est ajouté. Il fixe Aucun comme le valeur par défaut s'il n'est pas fourni.
valeurs() :
Le objet d'affichage de dictionnaire qui offre une vue dynamique de chaque valeur qui est présent dans le dictionnaire, est renvoyé par la fonction dict.values(). Lorsque le dictionnaire est mis à jour, ceci l'objet de vue est également mis à jour .
mise à jour() :
python génère un uuid
UN dictionnaire ou tout itérable avec des paires clé-valeur , comme un tuple, peut être mis à jour en utilisant la fonction dict.update().
Exemple :
# Example to demonstrate all dictionary methods #Creating a Dictionary mydict1={1:'HTML',2:'CSS',3:'Javascript',4:'Python'} #copy method mydict2=mydict1.copy() print(mydict2) #clear method mydict1.clear() print(mydict1) #get method print(mydict2.get(1)) #items method print(mydict2.items()) #keys method print(mydict2.keys()) #pop method mydict2.pop(4) print(mydict2) #popitem method mydict2.popitem() print(mydict2) #update method mydict2.update({2:'C++'}) print(mydict2) #values method print(mydict2.values()) Sortir:
{1: 'HTML', 2: 'CSS', 3: 'Javascript', 4: 'Python'} {} HTML dict_items([(1, 'HTML'), (2, 'CSS'), (3, 'Javascript'), (4, 'Python')]) dict_keys([1, 2, 3, 4]) {1: 'HTML', 2: 'CSS', 3: 'Javascript'} {1: 'HTML', 2: 'CSS'} {1: 'HTML', 2: 'C++'} dict_values(['HTML', 'C++']) Différence entre un dictionnaire et une liste :
Des structures de données telles qu'un une liste et un dictionnaire sont fondamentalement différents. Un série d'articles commandée peut être stocké dans un liste afin que nous puissions l'indexer ou le parcourir. Les listes peuvent également être modifiées même après avoir déjà été générées car elles sont de type modifiable. Le Dictionnaire Python est un stockage clé-valeur et la mise en œuvre d'un table de hachage . Il ne suit aucune séquence particulière et nécessite des clés hachables. De plus, il est rapide pour les recherches de clés.
UN listes les éléments contiennent les fonctionnalités suivantes :
- Sauf réordonnancement spécifique, ils conserver leur commande actuelle (par exemple, en triant la liste).
- Ils peuvent être de n'importe quel type, ou même un combinaison de sortes .
Les caractéristiques de dictionnaire les éléments sont les suivants :
- Chaque entrée a un valeur et une clé .
- Les commandes sont pas garanti .
Utilisation :
Nous utilisons un dictionnaire si nous avons un ensemble de clés distinctes qui correspondent à des valeurs , mais un liste quand nous avons un groupe ordonné de choses .
Conclusion :
- Dans un langage informatique, les dictionnaires sont une sorte de structure de données utilisée pour contenir des informations c'est en quelque sorte lié.
- Chaque module possède une propriété unique appelée __dict__.
- __dict__ contient la table des symboles du module .
- Les propriétés d'un élément sont stockées dans un objet de mappage.
- Chaque objet en Python a un propriété indiquée par le symbole __dict__ .
- Un autre nom pour __dict__ est également connu sous le nom de objet mappingproxy.
- Les deux composants d'un dictionnaire Python sont appelés Clés et valeurs .
- Toi pourrait ne pas recevoir vos données dans le même ordre que celui dans lequel vous les avez saisies, car les dictionnaires ne conservent pas leurs données dans un ordre spécifique.
- Les clés seront composées uniquement de une chose.
- Les valeurs peuvent être entiers, listes, listes à l'intérieur de listes , etc.
- Il ne peut y avoir plus que une entrée par clé (aucune clé en double n'est autorisée)
- Les clés du dictionnaire doivent être immuable , tel que entiers, tuples ou chaînes , bien que les valeurs puissent être de n'importe quel type.
- Dictionnaire les clés sont sensibles à la casse ; dans les dictionnaires Python, le même nom de clé orthographié différemment est considéré comme un clé distincte .