Dictionaries - Cours

1 Fonctions de base des dictionnaires

Un dictionnaire est une collection de paires clé-valeur. Chaque clé est unique et est utilisée pour accéder ou modifier la valeur associée à cette clé.

1.1 Syntaxe et Complexité en temps

# default_start
# Créer un dictionnaire vide
dictName = {} # O(1)

# Créer un dictionnaire en spécifiant ses paires clé-valeur
dictName = {key1:Value1, key2:Value2, key3:Value3, ... } # O(n)

# Récupérer la liste des clés du dictionnaire
keys = dictName.keys() # O(n)

# Lire une valeur du dictionnaire
value = dictName[key] # O(1)

# Ajouter ou modifier une valeur du dictionnaire
dictName[key] = newValue # O(1)

# Supprimer une paire clé-valeur du dictionnaire
del dictName[key] # O(1)
# default_end

1.2 Exemple

# default_start
# Déclaration d'un dictionnaire représentant un point 2D
point = {"x": 0, "y": 0}
print("point:", point)

# Récupérer la liste des clés du dictionnaire
keys = point.keys()
print("keys:", keys)

# Lire une valeur du dictionnaire
x = point["x"]
print("x:", x)

# Modifier une valeur du dictionnaire
point["y"] = 1
print("point", point)

# Ajouter une paire clé-valeur au dictionnaire
point["z"] = 2
print("point:", point)

# Supprimer une paire clé-valeur du dictionnaire
del point["x"]
print("point:", point)
# default_end

1.3 Premier pas

  1. Créer un dictionnaire nommé \(person\) avec les pairs clé-valeur suivantes : \(\q{name}:\q{Alice}\), \(\q{age}:\q{30}\), \(\q{city}:\q{London}\)
  2. Afficher la chaine de caractère \(\q{person:}\) suivie du dictionnaire \(person\)
  3. Afficher la chaine de caractère \(\q{keys:}\) suivie de toutes les clés du dictionnaire
  4. Afficher la chaine de caractère \(\q{city:}\) suivie de la valeur associée à la clé \(\q{city}\) dans le dictionnaire
  5. Remplacer la valeur de la clé \(\q{city}\) par \(\q{Paris}\) dans le dictionnaire
  6. Afficher à nouveau la chaine de caractère \(\q{city:}\) suivie de la valeur associée à la clé \(\q{city}\) dans le dictionnaire
  7. Ajouter une nouvelle paire clé-valeur \(\q{job}:\q{engineer}\) au dictionnaire
  8. Afficher la chaine de caractère \(\q{job:}\) suivie de la valeur associée à la clé \(\q{job}\) dans le dictionnaire
  9. Supprimer la paire clé-valeur associée à la clé \(\q{age}\) du dictionnaire
  10. Afficher la chaine de caractère \(\q{person:}\) suivie du dictionnaire \(\q{person}\)
# exercice: check 
# default_start
print("Hello, World!")

# default_end
# solution_start
person = {"name": "Alice", "age": 30, "city": "London"}
print("person:", person)
keys = person.keys()
print("keys:", keys)
city = person["city"]
print("city:", city)
person["city"] = "Paris"
print("city:", person["city"])
person["job"] = "engineer"
print("job:", person["job"])
del person["age"]
print("person:", person)
# solution_end

1.4 Exercice

Comprendre

Quelle est la sortie de ce programme ?

# default_start
def mystere(dict1):
    result = {}
    keys = dict1.keys() 
    for key in keys:
        value = dict1[key]
        result[value] = key
    return result
# default_end
# test_start
print(mystere({"a": 1, "b": 2, "c": 3}))
print("C683AKRMaR")
print(mystere({"a": 1, "b": 2, "c": 3, "d": 1}))
print("C683AKRMaR")
print(mystere({3.14: "pi", 2.71: "e", 1.61: "phi"}))
# test_end
# default_start
def mystere(dict1):             # dict1 = {"a": 1, "b": 2, "c": 3}
    result = {}                 # result = {}
    keys = dict1.keys()         # keys = ["a", "b", "c"]
    for key in keys:            # key = "a"       key = "b"       key = "c"
        value = dict1[key]      # value = 1       value = 2       value = 3
        result[value] = key     # result[1] = "a" result[2] = "b" result[3] = "c"
    return result               # return {1: "a", 2: "b", 3: "c"}
print(mystere({"a": 1, "b": 2, "c": 3}))
# default_end

Analyser

Quelle est la complexité en temps de la fonction mystere ci-dessus ?

# default_start
def mystere(dict1):
    result = {}             # O(1) créer un dictionnaire vide
    keys = dict1.keys()     # O(n) récupérer la liste des clés du dictionnaire
    # len(dict1) => len(keys) itérations
    for key in keys:        
        value = dict1[key]    # 1 affectation + 1 accès
        result[value] = key   # 1 accès + 1 affectation
    return result           # 1 retour
# n = len(dict1)
# T(n) = 1 + n  + n * (2 + 2) + 1
#      = 5n + 2
#      = O(n)
# default_end

Concevoir

Écrire une fonction \(exceptDicts(dict1, dict2)\) qui prend en entrée deux dictionnaires \(dict1\) et \(dict2\), et qui retourne un nouveau dictionnaire contenant les paires clé-valeur qui ne sont pas présentes dans les deux dictionnaires.

# exercice: show
# forbidden_keywords:
# forbidden_functions: input, sum, max, min, sorted, range, enumerate, zip, abs, all, any, dir, eval, reversed, map, filter
# forbidden_structures: set, tuple, frozenset, bytearray, bytes
# forbidden_list_methods: 
# forbidden_dict_methods: reversed, or, ior, ror, contains
# default_start
def exceptDicts(dict1, dict2):
    return None
# default_end
# test_start
print(exceptDicts({"a": 1, "b": 2, "c": 3}, {"b": 2, "c": 4, "d": 5}))
print("C683AKRMaR")
print(exceptDicts({"a": 1, "b": 2, "c": 3}, {"a": 1, "b": 2, "c": 3}))
print("C683AKRMaR")
print(exceptDicts({"a": 1, "b": 2, "c": 3}, {"d": 4, "e": 5, "f": 6}))
# test_end
# solution_start
def exceptDicts(dict1, dict2):
    result = {}
    keys1 = dict1.keys() 
    keys2 = dict2.keys() 
    for key in keys1:
        value = dict1[key]
        if key not in dict2:
            result[key] = value
    for key in keys2:
        value = dict2[key]
        if key not in dict1:
            result[key] = value
    return result
# solution_end