DESCRIPTION.

Créer un objet séquence, ou collection, qui contient un ensemble de couples clé:valeur, oû les valeurs peuvent être de toutes natures d'objets valides. 

SYNTAXE.

DCT_Donnees = { "clea" : valeura , ... ,"clen" : valeurn }

DCT_Donnees = ⇨ Nom de la variable [ optionnel ]

{ } ⇨ création d'une instance de dict ( ) [ OBLIGATOIRE ]

"cle" : valeur ⇨ couple clé:valeur [ optionnel ]

DCT_Donnees = dict ( iterable )

DCT_Donnees = ⇨ Nom de la variable [ optionnel ]

dict ( ) ⇨ appel du constructeur de classe [ OBLIGATOIRE ]

iterable ⇨ objet itérable contenant les clés:valeurs [ optionnel ]

NOTES.

Python gère de nombreux types d'objets_variables. Certains sont des collections de valeurs regroupées au sein d'un même objet_variable. Les dictionnaires, dict ( ),  sont des objets_variables composites, comme les listes, où l'on peut enregistrer des couples clé-valeur dans un ordre quelconque, où les clés, en pratique,  sont unique, c'est à dire présente une seule fois par dict ( ), puisqu'une valeur est identifiée grâce à sa clé.

Depuis Python 3.7, l'ordre d'insertion des couples clé-valeur est préservé dans le dictionnaire. Avant l'ordre était arbitraire. La modification d'une valeur, d'un couple clé-valeur existante, ne modifie pas l'ordre des entrées dans le dictionnaire.

Les instances de dict ( ) sont des objets itérables et mutables.

Dans un couple clé:valeur, valeur peut être une référence à n'importe quel objet valide dans Python, int ( ), float ( ), str ( ), list ( ), ..., par contre clé doit être, obligatoirement, un objet immuable, str ( ), int ( ), tuple ( ), ..., mais on privilégiera, autant que possible, le type str ( ).

Dans la forme DCT_Donnees = dict ( iterable ), iterable peut prendre de nombreuses formes, faisant parfois intervenir des méthodes built-in pour sa constitution. Toutefois, après l'interprétation de l'expression de sa création si nécessaire, les items de l'objet iterable doivent être eux-mêmes des objets itérables de deux items, où le premier sera la clé, et devra répondre aux exigences du nommage des clés, et le deuxième la valeur. 

Bien qu'étant un raccourcit, la forme de création DCT_Donnees = { "clea" : valeura , ... ,"clen" : valeurn } est à privilégier.

Les variables globales de type dict ( ) sont identifiées dans le site par : DCT_. 

Voir les conventions sur les variables utilisées dans ce site ...

CRÉER UN NOUVEAU DICTIONNAIRE.

DCT_Joueur = {  "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

Créer un dictionnaire nommée DCT_Joueur qui contient 4 valeurs initialisées lors de la création. Les clés sont Nom, Prenom, Force et Match (il est souhaitable d’éviter de mettre des lettres accentuées et autres symboles dans les noms de clés). Les valeurs sont PAUL (type str), Pierre (type str) , 1499 (type int) , G G P N (type liste).

ou

DCT_Joueur = {  } créé un dictionnaire vide.

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] } ajoute (ou créé et ajoute) les couples clé:valeur dans DCT_Joueur.

ou

DCT_Joueur = dict ( [ ( "Nom" , "PAUL" ) , ( "Prenom" , "Pierre" ) , ( "Force" , 1499 ) , ( "Match" , [ "G" , "G" , "P" , "N" ]  ) ] )

ou

Si les clés sont toutes des chaines de caractères ordinaires, on peut appeler le constructeur de classe, en lui passant les couples clé:valeur comme des arguments nommés. A noter que les clés ne doivent pas être présentées entre guillemets (").

DCT_Joueur = dict ( [ Nom = "PAUL" , Prenom = "Pierre" , Force = 1499 , Match = [ "G" , "G" , "P" , "N" ]  ] )

D'autres possibilités existent aussi grâce à l'utilisation du constructeur de classe, comme :

DCT_Equivalence = dict ( zip ( "abcdef" , range ( 20 , 0 , -3 ) ) )

print ( DCT_Equivalence ) retourne {'a': 20, 'b': 17, 'c': 14, 'd': 11, 'e': 8, 'f': 5}

On peut aussi utiliser la technique dite "compréhension des listes" pour initialiser un dict ( ) avec certaines spécificités.

DCT_Cubes = { x : x ** 3 for x in [ 3 , 4 , 8 , 14 ] }

print ( DCT_Cubes ) retourne {3: 27, 4: 64, 8: 512, 14: 2744}

DCT_Carres = { x : x ** 2 for x in range ( 5 ) }

print ( DCT_Carres ) retourne {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

DCT_Majuscules = { f"chr ( { valeur } )" : chr ( valeur ) for valeur in range ( 65 , 91 ) }

print ( DCT_Majuscules ) retourne {'chr (65)': 'A', 'chr (66)': 'B', 'chr (67)': 'C', 'chr (68)': 'D', 'chr (69)': 'E', 'chr (70)': 'F', 'chr (71)': 'G', 'chr (72)': 'H', 'chr (73)': 'I', 'chr (74)': 'J', 'chr (75)': 'K', 'chr (76)': 'L', 'chr (77)': 'M', 'chr (78)': 'N', 'chr (79)': 'O', 'chr (80)': 'P', 'chr (81)': 'Q', 'chr (82)': 'R', 'chr (83)': 'S', 'chr (84)': 'T', 'chr (85)': 'U', 'chr (86)': 'V', 'chr (87)': 'W', 'chr (88)': 'X', 'chr (89)': 'Y', 'chr (90)': 'Z'}

On peut créer aussi des dictionnaires "vierges" avec des clés connues et une valeur commune, par défauts, pour toutes les clés, en utilisant la méthode de classe dict.fromkeys ( ).

LST_Prix = [ "Unitaire" , "Marge" , "Commission" , "Taxe" ]

DCT_Produit = dict.fromkeys ( LST_Prix , 0 )

print ( DCT_Produit ) retourne {'Unitaire': 0, 'Marge': 0, 'Commission': 0, 'Taxe': 0}

Une méthode pratique avec des suite de lettres ou de nombres.

DCT_Taux = dict.fromkeys ( "abcde" , 5 )

print ( DCT_Taux ) retourne {'a': 5, 'b': 5, 'c': 5, 'd': 5, 'e': 5}

DCT_Place = dict.fromkeys ( range ( 1 , 11 )  , "n.c." )

print ( DCT_Place ) retourne {1: 'n.c.', 2: 'n.c.', 3: 'n.c.', 4: 'n.c.', 5: 'n.c.', 6: 'n.c.', 7: 'n.c.', 8: 'n.c.', 9: 'n.c.', 10: 'n.c.'}

Le premier argument est obligatoire un objet intérable. Le second est optionnel et doit être une valeur valide, par défaut (absence de l'argument) la valeur sera l'objet None.

LST_Ronde = [ "Ronde 1" , "Ronde 2" , "Ronde 3" , "Ronde 4" , "Ronde 5" , "Ronde 6"  ]

DCT_Adversaires = dict.fromkeys ( LST_Ronde )

print ( DCT_Adversaires ) retourne {'Ronde 1': None, 'Ronde 2': None, 'Ronde 3': None, 'Ronde 4': None, 'Ronde 5': None, 'Ronde 6': None}

L'objet itérable fournis comme premier argument, peut-être exprimé sous la forme d'une compréhension de liste.

DCT_Exercices = dict.fromkeys ( [ i**2 for i in range ( 10 ) ] , "√x ?" )

print ( DCT_Exercices ) retourne {0: '√x ?', 1: '√x ?', 4: '√x ?', 9: '√x ?', 16: '√x ?', 25: '√x ?', 36: '√x ?', 49: '√x ?', 64: '√x ?', 81: '√x ?'}

LECTURE D'UN DICTIONNAIRE.

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

print ( DCT_Joueur ) retourne {'Nom': 'PAUL', 'Prenom': 'Pierre', 'Force': 1499, 'Match': ['G', 'G', 'P', 'N']}.

print ( DCT_Joueur [ "Force" ] ) retourne 1499

c'est à dire la valeur affectée à la clé 'Force'.

Attention si vous appelez une clé qui n'existe pas dans le dictionnaire, une exception sera levée.

print ( DCT_Joueur [ "Categorie" ] ) retourne KeyError: 'Categorie' .

Pour savoir si une clé est présente dans un dictionnaire on utilise la l'opérateur in.

DCT_Joueur = { 'Nom' : 'PAUL' , 'Prenom' : 'Pierre' , 'Force' : 1499 , 'Match' : [ 'G' , 'G' , 'P' , 'N' , ] }

print ( "Match" in DCT_Joueur ) retourne True

car la clé "Match" est présente du dictionnaire DCT_Joueur.

print ( "Categorie" in DCT_Joueur ) retourne False

car la clé "Categorie" est absente du dictionnaire DCT_Joueur.

print ( "Force" not in DCT_Joueur ) retourne False

car not in teste l'absence de la clé "Force" dans le dictionnaire  DCT_Joueur.

print ( "Categorie" not in DCT_Joueur ) retourne True

car not in teste l'absence de la clé "Categorie" dans le dictionnaire  DCT_Joueur. 

Pour connaitre si une valeur est associée à une clé, dont la présence est incertaine, on utilise la méthode .get ( ).

print ( DCT_Joueur.get ( "Categorie" ) ) retourne None

car il n'y a aucune clé de ce nom dans le dictionnaire.

La méthode .get ( ) accepte un second paramètre optionnel qui sera retourné si la clé n'est pas trouvée dans le dictionnaire.

print ( DCT_Joueur.get ( "Nom" , "Clé non trouvée" ) ) retourne PAUL

car la clé "Nom" est une clé du dictionnaire DCT_Joueur.

print ( DCT_Joueur.get ( "Categorie" , "Clé non trouvée" ) ) retourne Clé non trouvée

car la clé "Categorie" n'est pas une clé du dictionnaire DCT_Joueur.

Lecture de tous les couples clé-valeur d'un dictionnaire (nouvelle vue du dictionnaire).

DCT_Joueur = { 'Nom' : 'PAUL' , 'Prenom' : 'Pierre' , 'Force' : 1499 , 'Match' : [ 'G' , 'G' , 'P' , 'N' , ] }

print ( DCT_Joueur.items ( ) ) retourne dict_items([('Nom', 'PAUL'), ('Prenom', 'Pierre'), ('Force', 1499), ('Match', ['G', 'G', 'P', 'N'])])

Notez que le type de l'objet retourné, dict_items, apparaît en entête, et la présence de crochets [ ] (c'est une list ( ) ) qui entourent tous les couples clé-valeur, présentés entre parenthèses (se dont des tuples ( ) ).  

print ( type ( DCT_Joueur.items ( ) ) ) retourne <class 'dict_items'>.

Lecture de tous les couples clé-valeur d'un dictionnaire avec une boucle.

for kcle , kvaleur in DCT_Joueur.items ( ) :

print ( kcle , kvaleur )

retourne

Nom PAUL

Prenom Pierre

Force 1499

Match ['G', 'G', 'P', 'N']

Lecture de toutes les clés, sans leur valeur associée, d'un dictionnaire.

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

print ( DCT_Joueur.keys ( ) ) retourne dict_keys(['Nom', 'Prenom', 'Force', 'Match'])

Notez que le type de l'objet retourné, dict_keys, apparaît en entête, et la présence de crochets [ ] (c'edt une list ( ) ) qui entourent tous les noms des clés.  

print ( type ( DCT_Joueur.keys ( ) ) ) retourne <class 'dict_keys'>.

Lecture de toutes les clés d'un dictionnaire avec une boucle.

for kcle in DCT_Joueur.keys ( ) :

print ( kcle )

retourne

Nom

Prenom

Force

Match

Lecture de toutes les valeurs, sans leur clé associée, d'un dictionnaire.

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

print ( DCT_Joueur.values ( ) ) retourne dict_values(['PAUL', 'Pierre', 1499, ['G', 'G', 'P', 'N']])

Notez que le type de l'objet retourné, dict_values, apparaît en entête, et la présence de crochets [ ] (c'est une list ( ) ) qui entourent les valeurs.

print ( type ( DCT_Joueur.values ( ) ) ) retourne <class 'dict_values'>.

Lecture de toutes les valeurs d'un dictionnaire avec une boucle.

for kvaleur in DCT_Joueur.values ( ) :

print ( kvaleur )

retourne

PAUL

Pierre

1499

['G', 'G', 'P', 'N']

Convertir l'ensemble des clés d'un dict ( ) en list ( ).

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

list ( DCT_Joueur ) retourne ['Nom', 'Prenom', 'Force' ,'Match']

Trier les clés d'un dict ( ).

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

sorted ( DCT_Joueur ) retourne ['Force', 'Match', 'Nom', 'Prenom']

A noter que la méthode sorted ( ) retourne un objet list ( ) contenant uniquement les clés du dictionnaire.

MODIFIER UNE VALEUR GRACE A SA CLÉ.

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

DCT_Joueur [ 'Force' ] = 1250

print ( DCT_Joueur ) retourne {'Nom': 'PAUL', 'Prenom': 'Pierre', 'Force': 1250, 'Match': ['G', 'G', 'P', 'N']}

print ( DCT_Joueur [ 'Force' ] ) retourne 1250

c'est à dire la nouvelle valeur affectée à la clé 'Force'.

SUPPRIMER UN COUPLE CLÉ-VALEUR D'UN DICTIONNAIRE.

La méthode .pop ( ) permet de supprimer un couple clé-valeur d'un dictionnaire et de retourner uniquement la valeur associée au couple clé-valeur supprimé.

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

print ( DCT_Joueur ) retourne {'Nom': 'PAUL', 'Prenom': 'Pierre', 'Force': 1499, 'Match': ['G', 'G', 'P', 'N']}

Force = DCT_Joueur.pop ( "Force" )

print ( Force ) retourne 1499

print ( DCT_Joueur ) retourne {'Nom': 'PAUL', 'Prenom': 'Pierre', 'Match': ['G', 'G', 'P', 'N']}

le couple 'Force': 1499 n'apparait plus, il a été effacé, détruit, du dict ( ) DCT_Joueur.

Si la clé, á supprimer, est absente du dictionnaire, on peut "programmer" une valeur par défaut, en second paramètre, qui sera retournée.

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

Categorie = DCT_Joueur.pop ( "Categorie" , "Absent ou déjà détruit ..." ) 

print ( Categorie ) retourne Absent ou déjà détruit ...

Si le second argument (retour par défaut) est absent et que la clé n'existe pas dans le dictionnaire, une exception est levée.

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

Categorie = DCT_Joueur.pop ( "Categorie" ) retourne KeyError: 'Categorie'

La méthode .popitem ( ) permet de supprimer le dernier couple clé-valeur entré dans le dictionnaire et de retourner le couple-valeur associée à la clé supprimée. (avant Python 3.7, le couple détruit est arbitraire).

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

print ( DCT_Joueur ) retourne {'Nom': 'PAUL', 'Prenom': 'Pierre', 'Force': 1499, 'Match': ['G', 'G', 'P', 'N']}

Destruction = DCT_Joueur.popitem ( )

print ( DCT_Joueur ) retourne {'Nom': 'PAUL', 'Prenom': 'Pierre', 'Force': 1499}

print ( Destruction ) retourne ('Match', ['G', 'G', 'P', 'N'])

print ( DCT_Joueur.popitem ( ) ) retourne ('Force', 1499)

print ( DCT_Joueur ) retourne {'Nom': 'PAUL', 'Prenom': 'Pierre'}

print ( DCT_Joueur.popitem ( ) ) retourne ('Prenom', 'Pierre')

print ( DCT_Joueur ) retourne {'Nom': 'PAUL'}

print ( DCT_Joueur.popitem ( ) ) retourne ('Nom', 'PAUL')

print ( DCT_Joueur ) retourne  {}

print ( DCT_Joueur.popitem ( ) ) retourne KeyError: 'popitem(): dictionary is empty'

Notez qu'il n'y a pas de second argument, ni la possibilité de choisir le couple qui sera détruit, contrairement à la méthode .pop ( ).

On peut aussi supprimer un couple clé-valeur avec la instruction del.

DCT_Joueur = { "Nom" : "PAUL" , "Prenom" : "Pierre" , "Force" : 1499 , "Match" : [ "G" , "G" , "P" , "N" ] }

print ( DCT_Joueur ) retourne {'Nom': 'PAUL', 'Prenom': 'Pierre', 'Force': 1499, 'Match': ['G', 'G', 'P', 'N']}

del DCT_Joueur [ 'Force' ]

print ( DCT_Joueur ) retourne {'Nom': 'PAUL', 'Prenom': 'Pierre', 'Match': ['G', 'G', 'P', 'N']}

print ( DCT_Joueur [ 'Force' ] ) retourne KeyError: 'Force'

Evidemment, la suppression d'une clé, avec l'instruction del, supprime automatique la valeur qui lui est affectée du dictionnaire.

AJOUTER UN COUPLE CLÉ-VALEUR A UN DICTIONNAIRE.

Pour ajouter simplement un couple clé-valeur, il suffit de nommer la clé entre crochet et de lui affecter une valeur

DCT_Joueur = {  'Nom' : 'MARTIN' , 'Prenom' : 'José' , 'Force' : 1499 }

print ( DCT_Joueur ) retourne {'Nom': 'MARTIN', 'Prenom': 'José', 'Force': 1499}

DCT_Joueur [ "Match" ] = [ 'P', 'N', 'G', 'G', 'G', 'N' ] 

print ( DCT_Joueur ) retourne {'Nom': 'MARTIN', 'Prenom': 'José', 'Force': 1499, 'Match': ['P', 'N', 'G', 'G', 'G', 'N']}

Pour ajouter un ou plusieurs couples clé-valeur en une seule opération on utilise la méthode .update ( ), en séparant les couples par une virgule, comme lors de la création.

DCT_Joueur = {  'Nom' : 'MARTIN' , 'Prenom' : 'José' , 'Force' : 1499 }

print ( DCT_Joueur ) retourne {'Nom': 'MARTIN', 'Prenom': 'José', 'Force': 1499}

DCT_Joueur.update ( { 'Match' : [ 'P', 'N', 'G', 'G', 'G', 'N' ] } )

print ( DCT_Joueur ) retourne {'Nom': 'MARTIN', 'Prenom': 'José', 'Force': 1499, 'Match': ['P', 'N', 'G', 'G', 'G', 'N']}

équivaut à DCT_Joueur [ "Match" ] = [ 'P', 'N', 'G', 'G', 'G', 'N' ] ci-dessus.

DCT_Carres = { "Deux" : 4 , "Trois" : 9 , "Quatre" : 12 }

print ( DCT_Carres ) retourne {'Deux': 4, 'Trois': 9, 'Quatre': 12}

DCT_Carres .update ( { "Cinq" : 25 , "Six" : 36 , "Sept" : 49 , "Huit" : 64 } )

print ( DCT_Carres ) retourne {'Deux': 4, 'Trois': 9, 'Quatre': 12, 'Cinq': 25, 'Six': 36, 'Sept': 49, 'Huit': 64}

On peut aussi ajouter tous les couples clé-valeur d'un dict ( ) dans un autre.

DCT_Carres = { "Deux" : 4 , "Trois" : 9 , "Quatre" : 12 , "Cinq" : 25 , "Six" : 36 }

DCT_Fin = { Sept" : 49 , "Huit" : 64" , Neuf" : 81 , "Dix" : 100 }

DCT_Carres .update ( DCT_Fin )

print ( DCT_Carres ) retourne {'Deux': 4, 'Trois': 9, 'Quatre': 12, 'Cinq': 25, 'Six': 36, 'Sept': 49, 'Huit': 64, 'Neuf': 81, 'Dix': 100}

Depuis Python 3.9, on peut utiliser la notation DCT_Tous = DCT_A | DCT_B pour fusionner deux dictionnaires (un nouveau dictionnaire est créé). Si une clé est présente dans les deux dictionnaires, la valeur associée sera celle du dictionnaire à droite de | (DCT_B). 

DCT_Debut = { "Deux" : 4 , "Trois" : 9 , "Quatre" : 12 , "Cinq" : 25 , "Six" : 36 }

DCT_Fin = { Sept" : 49 , "Huit" : 64" , Neuf" : 81 , "Dix" : 100 }

DCT_Carres = DCT_Debut |  DCT_Fin

print ( DCT_Carres ) retourne {'Deux': 4, 'Trois': 9, 'Quatre': 12, 'Cinq': 25, 'Six': 36, 'Sept': 49, 'Huit': 64, 'Neuf': 81, 'Dix': 100}

Depuis Python 3.9, on peut utiliser la notation DCT_A |= DCT_B pour mettre a jour les couple clé:valeur d'un dictionnaire à partir d'un autre dictionnaire, qui peut avoir une forme de mappage ou d'itérable. Si une clé est présente dans les deux dictionnaires, la valeur associée sera celle du dictionnaire à droite de |= (DCT_B). 

DCT_Carres = { "Deux" : 4 , "Trois" : 9 , "Quatre" : 12 , "Cinq" : 25 , "Six" : 36 }

DCT_Fin = { Sept" : 49 , "Huit" : 64" , Neuf" : 81 , "Dix" : 100 }

DCT_Carres  |=  DCT_Fin

print ( DCT_Carres ) retourne {'Deux': 4, 'Trois': 9, 'Quatre': 12, 'Cinq': 25, 'Six': 36, 'Sept': 49, 'Huit': 64, 'Neuf': 81, 'Dix': 100}

Ajouter des clé-valeur grâce à la fonction zip ( ).

DCT_Equivalence = { "f" : 0 }

DCT_Equivalence.update ( zip ( "abcde" , range ( 20 , 0 , -4 ) ) )

print ( DCT_Equivalence ) retourne {'f': 0, 'a': 20, 'b': 16, 'c': 12, 'd': 8, 'e': 4}

Si un couple clé-valeur de même nom est présent dans le dictionnaire, la valeur est modifiée, mais la position du couple clé:valeur dans le dictionnaire est conservée.

DCT_Equivalence = { "f" : 0 }

DCT_Equivalence.update ( zip ( "abcdef" , range ( 20 , -1 , -4 ) ) )

print ( DCT_Equivalence ) retourne {'f': 0, 'a': 20, 'b': 16, 'c': 12, 'd': 8, 'e': 4}

La méthode .update ( ) permet aussi de modifier les valeurs associées aux clés existantes.

DCT_Itineraire = { "Depart" : "Amsterdam" , "Etape1" : "Bruxelles" , "Etape2" : "Lyon" , "Etape3" : "Berlin" , "Arrivee" : "Bern" }

DCT_Itineraire.update ( Etape2 = "Strasbourg" , Arrivee  = "Losanne" )

print ( DCT_Itineraire ) retourne {'Depart': 'Amsterdam', 'Etape1': 'Bruxelles', 'Etape2': 'Strasbourg', 'Etape3': 'Berlin', 'Arrivee': 'Losanne'}

DCT_Itineraire.update ( Etape4 = "Lyon" , Etape5 = "Losanne" , Arrivee = "bern" )

print ( DCT_Itineraire ) retourne {'Depart': 'Amsterdam', 'Etape1': 'Bruxelles', 'Etape2': 'Strasbourg', 'Etape3': 'Berlin', 'Arrivee': 'bern', 'Etape4': 'Lyon', 'Etape5': 'Losanne'}

Si le couple clé-valeur est absent du dictionnaire, il est ajouté.

La méthode .setdefaut ( ) peut ajouter une clé, si elle n'est pas déjà présente, avec une certaine valeur dans un dictionnaire. Si cette clé est présente dans le dictionnaire, la valeur associée n'est pas modifiée, sinon un couple clé:valeur est ajoutée à la fin du dictionnaire, avec la valeur donnée en second argument, ou None si elle est omise. Si une valeur par défaut est précisée, elle est toujours retournée, sinon Python retourne None si la clé était absente du dictionnaire ou la valeur associée à une clé existante avant l'appel de la méthode.

DCT_Teintes = { "Murs" : "rouge" , "Portes" : "blanche" , "Fenetres" : "mauve" , "Plancher" : "brun" }

print ( DCT_Teintes.setdefault ( "Porte" , "bleu" ) ) retourne bleu

print ( DCT_Teintes.setdefault ( "Murs" ) ) retourne rouge

print ( DCT_Teintes.setdefault ( "Rideaux" , "crème" ) ) retourne crème

print ( DCT_Teintes.setdefault ( "Tapis" ) ) retourne None

print ( DCT_Teintes ) retourne {'Murs': 'rouge', 'Portes': 'blanche', 'Fenetres': 'mauve', 'Plancher': 'brun', 'Porte': 'bleu', 'Rideaux': 'crème', 'Tapis': None}

Notez que les valeurs associées aux clés Murs et Portes n'ont pas été modifiée, le couple Rideaux-crème a été créé et ajouté, et un couple clé "Tapis" : None a été créé et ajouté.

REMARQUES.

Il est possible de supprimer toutes les clés d'un dictionnaire sans supprimer le dictionnaire lui-même.

DCT_Demies = { x : x / 2 for x in range ( 20 , 31 , 2 ) }

print ( DCT_Demies )  retourne {20: 10.0, 22: 11.0, 24: 12.0, 26: 13.0, 28: 14.0, 30: 15.0}

DCT_Demies.clear ( )

print ( DCT_Demies ) retourne {}

Comme souvent dans Python, il n'est pas possible de copier un nouveau dictionnaire, indépendant, en faisant  DCT_A = DCT_B. Cette méthode créée seulement une deuxième façon de d'appeler DCT_A. Toutes modifications portée à DCT_A seront appliquées à DCT_B et réciproquement. En fait, il n'y a qu'un seul et même dictionnaire mais avec deux noms différents.

Pour créer un dictionnaire indépendant mais initialisé avec les clés et valeurs d'un autre, il faut utiliser la fonction .copy ( ). Par exemple : DCT_B = DCT_A.copy ( ). DCT_B sera créé avec toutes les paires clé/valeur de DCT_A. Mais toutes modifications apportées à l'un des dictionnaires (affectation de valeur, suppression ou création de clé) ne sera pas portées sur le second.

Deux objets dict ( ) sont considérés comme égaux (opérateur ==) s'ils ont le même nombre de couples clé:valeur, et que ces couples sont strictement identiques, mais l'ordre des couples clé:valeur peut être différent, sinon ils seront différents (opérateur !=) . Les autres comparaisons d'ordre (opérateur (opérateurs <, <=, >= et >) ne sont pas autorisés avec les dictionnaires, leurs emplois lèveront une exception.

MÉTHODES SPÉCIFIQUES AUX OBJETS DICT ( ). 

clear ( ) : supprime tous les éléments du dictionnaire. 

copy ( ) : crée une copie superficielle.

fromkeys ( ) : crée un dictionnaire avec une valeur commune.

get ( ) : retourne la valeur associée à une clé.

items ( ) : retourne tous les couples clé-valeur.

keys ( ) : retourne toutes les clés d'un dictionnaire.

pop ( ) : supprime un couple clé-valeur en retournant valeur.

popitem ( ) : supprime le dernier couple clé-valeur en retournant valeur.

setdefault ( ) : retourne la valeur d'une clé ou par défaut.

update ( ) : ajoute ou modifie des couples clé:valeur.

values ( ) : retourne toutes les valeurs d'un dictionnaire.