Prérequis

Avant de vous plonger dans ce chapitre, vous devez être familiarisé avec :

• Le travail avec les listes et les variables Python fondamentales

Objectifs pédagogiques

À la fin de cette leçon, vous serez capable de :

• Stocker et accéder aux éléments dans un dictionnaire
• Modifier un dictionnaire
• Parcourir un dictionnaire efficacement
• Maîtriser la différence entre une liste et un dictionnaire

Lorsqu'il s'agit de stocker des données tabulaires, vous pourriez initialement penser à utiliser une liste. Considérez l'ensemble de données suivant :

En Python, ces informations pourraient être représentées en utilisant une liste comme montré ci-dessous :

namecounts = [
    'Oliver', 200, 'Emma', 180, 'Liam', 150
]

Cependant, cette approche présente plusieurs limitations.

1. Manque de clarté : il n'est pas immédiatement évident de distinguer quelles valeurs sont des noms et lesquelles sont des fréquences.
2. Confusion : il est facile de se tromper en accédant aux mauvais éléments de la liste, car les indices (les positions des éléments dans la liste) sont utilisés pour y accéder.
3. Efficience : accéder à la fréquence d'un nom spécifique nécessite de parcourir la liste, ce qui peut prendre du temps.

Une façon plus efficace et plus claire de représenter ces informations est d'utiliser un dictionnaire, une collection de paires clé-valeur. Ce sont des structures de données très polyvalentes et efficaces pour la recherche d'informations en général.

Pour créer un dictionnaire vide en Python, vous pouvez utiliser des accolades vides ({}) ou la fonction dict() :

employ = {}
# or
employ = dict()

Pour créer un dictionnaire directement avec des données, vous pouvez utiliser des accolades {} avec des paires clé-valeur séparées par des virgules :

employ = {
    'name': 'John Doe',
    'role': 'Business Analyst',
    'experience': 5,  # years
    'department': 'Finance'
}

Dans ce dictionnaire, 'name', 'role', 'experience' et 'department' sont les clés, tandis que 'John Doe', 'Business Analyst', 5 et 'Finance' sont leurs valeurs correspondantes.

De plus, vous pouvez créer un dictionnaire imbriqué, c'est-à-dire un dictionnaire qui contient un autre dictionnaire comme valeur :

company = {
    'employee1': {
        'name': 'John Doe',
        'role': 'Business Analyst',
        'experience': 5,
        'department': 'Finance'
    },
    'employee2': {
        'name': 'Jane Smith',
        'role': 'Software Engineer',
        'experience': 3,
        'department': 'IT'
    }
}

Dans ce dictionnaire imbriqué, employee1 et employee2 sont des clés, et leurs valeurs sont des dictionnaires contenant les détails de chaque employé.

Vous pouvez voir le dictionnaire imbriqué ci-dessus comme l'équivalent Python du tableau suivant :

Exercice

Pour vous exercer avec les dictionnaires, lancez l'application Jupyter Notebook depuis Anaconda Navigator et créez un nouveau notebook Jupyter dans le dossier exercises du dossier Dictionaries. Nommez-le Favourite_Movies_Dictionary.ipynb. Suivez ces étapes :

1. Créer un dictionnaire : Créez un dictionnaire nommé favourite_movie qui contient des informations sur votre film préféré. Incluez des clés comme 'title', 'director', 'release_year', et 'genre'.
2. Afficher le dictionnaire : Affichez le contenu du dictionnaire favourite_movie.
3. Créer un dictionnaire imbriqué : Créez un dictionnaire imbriqué nommé favourite_movies. Chaque clé devrait être le titre d'un film, et la valeur correspondante devrait être un autre dictionnaire. Ce dictionnaire imbriqué devrait avoir les clés 'director', 'release_year', et 'genre', chacune fournissant des détails sur le film. Assurez-vous que votre dictionnaire imbriqué inclut au moins cinq films distincts.
4. Afficher le dictionnaire imbriqué : Affichez le contenu du dictionnaire favourite_movies.

Voici un exemple de code pour commencer. Vous pouvez le copier dans une cellule de code vide du notebook Jupyter. Les ... dans l'exemple de code sont des espaces réservés. Remplacez-les par votre code.

# Step 1: Create a Dictionary
favourite_movie = ...

# Step 2: Print the Dictionary
print(...)

# Step 3: Create a Nested Dictionary
# Replace 'movie1', 'movie2', etc., with the actual titles of your favourite movies
favourite_movies = {
    'movie1': {
        ...
    },
    'movie2': {
        ...
    },
    'movie3': {
        ...
    },
    'movie4': {
        ...
    },
    'movie5': {
        ...
    }
}

# Step 4: Print the Nested Dictionary
print(...)

Solution

# Step 1: Create a Dictionary
favourite_movie = {
    'title': 'The Shawshank Redemption',
    'director': 'Frank Darabont',
    'release_year': 1994,
    'genre': 'Drama'
}

# Step 2: Print the Dictionary
print(favourite_movie)

# Step 3: Create a Nested Dictionary
favourite_movies = {
    'The Shawshank Redemption': {
        'director': 'Frank Darabont',
        'release_year': 1994,
        'genre': 'Drama'
    },
    'Inception': {
        'director': 'Christopher Nolan',
        'release_year': 2010,
        'genre': 'Sci-Fi'
    },
    'Pulp Fiction': {
        'director': 'Quentin Tarantino',
        'release_year': 1994,
        'genre': 'Crime'
    },
    'The Godfather': {
        'director': 'Francis Ford Coppola',
        'release_year': 1972,
        'genre': 'Crime'
    },
    'Forrest Gump': {
        'director': 'Robert Zemeckis',
        'release_year': 1994,
        'genre': 'Drama'
    }
}

# Step 4: Print the Nested Dictionary
print(favourite_movies)

Accéder aux valeurs par clés

En utilisant des crochets et une clé, vous pouvez récupérer les valeurs d'un dictionnaire. Vous ne pouvez récupérer qu'une seule paire clé-valeur à la fois, et seulement si la clé existe :

print(employ['name'])  # Output: John Doe
print(employ['experience'])  # Output: 5

Si vous essayez d'accéder à une clé qui n'existe pas, Python lèvera une erreur KeyError. Pour éviter cela, vous pouvez utiliser la méthode get, qui renvoie None si la clé n'est pas trouvée :

print(employ.get('country'))  # Output: None

Pour accéder aux valeurs dans un dictionnaire imbriqué, vous pouvez utiliser plusieurs clés :

print(company['employee1']['name'])  # Output: John Doe
print(company['employee2']['role'])  # Output: Software Engineer

Vous pouvez également utiliser la méthode get pour accéder aux valeurs dans un dictionnaire imbriqué :

print(company.get('employee1').get('department'))  # Output: Finance
print(company.get('employee2').get('country', 'Not specified'))  # Output: Not specified

Exercice

Dans le notebook Jupyter Favourite_Movies_Dictionary.ipynb, poursuivez votre pratique avec les dictionnaires en suivant ces étapes :

1. Accédez et affichez le titre de votre troisième film préféré depuis le dictionnaire favourite_movies.
2. Accédez et affichez le réalisateur et l'année de sortie de votre troisième film préféré depuis le dictionnaire favourite_movies.

Solution

# Get and print the title of the third favourite movie
third_movie_title = favourite_movies["Pulp Fiction"]["title"]
print(f"The title of my third favourite movie is: {third_movie_title}")

# Get and print the director and release year of the third movie
third_movie_director = favourite_movies[third_movie_title]['director']
third_movie_year = favourite_movies[third_movie_title]['release_year']
print(f"The director of {third_movie_title} is {third_movie_director}")
print(f"The release year of {third_movie_title} is {third_movie_year}")

Accéder à toutes les valeurs avec la méthode values

Pour récupérer toutes les valeurs d'un dictionnaire, vous pouvez utiliser la méthode values. Cette méthode renvoie un objet vue qui affiche une liste de toutes les valeurs du dictionnaire :

print(employ.values())  # Output: dict_values(['John Doe', 'Business Analyst', 5, 'Finance'])

# Pour convertir en une véritable liste
employ_values_list = list(employ.values())
print(employ_values_list)  # Output: ['John Doe', 'Business Analyst', 5, 'Finance']

Accéder à toutes les clés avec la méthode keys

Pour récupérer toutes les clés d'un dictionnaire, vous pouvez utiliser la méthode keys. Cette méthode renvoie un objet spécial appelé vue (view object) qui affiche une liste de toutes les clés du dictionnaire :

print(employ.keys())  # Output: dict_keys(['name', 'role', 'experience', 'department'])

# Pour convertir en une véritable liste
employ_keys_list = list(employ.keys())
print(employ_keys_list)  # Output: ['name', 'role', 'experience', 'department']

Exercice

Structure de l'entreprise

Créez un nouveau notebook Jupyter dans le dossier exercises du dossier Dictionaries. Nommez-le Company_Structure.ipynb. Après avoir terminé les exercices, n'oubliez pas de sauvegarder le notebook.

Structure des départements de l'entreprise

Imaginez que vous êtes le responsable RH d'une entreprise technologique en croissance. Enregistrez le nombre d'employés dans différents départements à travers différents sites dans un dictionnaire nommé company_departments. Assurez-vous que le dictionnaire représente précisément les différents sites. Par exemple, le décompte pourrait être :

Analyse du département IT

Accédez au nombre d'employés IT du bureau de Londres et affichez-le. Voyons combien de professionnels de l'IT travaillent dans notre succursale londonienne !

Solution

company_departments = {
    'New York': {'Sales': 25, 'Marketing': 15, 'IT': 30, 'HR': 10, 'Finance': 20},
    'London': {'Sales': 20, 'Marketing': 12, 'IT': 25, 'HR': 8, 'Finance': 15},
    'Tokyo': {'Sales': 18, 'Marketing': 10, 'IT': 22, 'HR': 7, 'Finance': 13},
    'Sydney': {'Sales': 15, 'Marketing': 8, 'IT': 20, 'HR': 6, 'Finance': 10},
    'Berlin': {'Sales': 12, 'Marketing': 6, 'IT': 18, 'HR': 5, 'Finance': 8}
}

print(company_departments)

it_employees_in_london = company_departments['London']['IT']
print(f"Number of IT employees in the London office: {it_employees_in_london}")

Tout comme les listes, les dictionnaires sont mutables, ce qui signifie que nous pouvons modifier, ajouter ou supprimer des éléments après la création du dictionnaire. De plus, un dictionnaire ne peut pas avoir deux éléments avec la même clé. La figure ci-dessous montre certaines des méthodes (actions) que vous pouvez utiliser pour modifier le contenu d'un dictionnaire. Pour une liste exhaustive des méthodes pour les dictionnaires, vous pouvez consulter W3Schools.

Par exemple, vous pourriez créer un dictionnaire pour stocker les détails d'un produit :

product_details = {
    "Name": "Smart Office Chair",
    "Category": "Office Furniture",
    "Price": 299.99,
    "In Stock": 50
}

Pour mettre à jour la valeur de "Price" à 279.99, vous pouvez faire comme suit :

product_details["Price"] = 279.99

Pour ajouter un nouvel élément au dictionnaire, vous pouvez simplement assigner une nouvelle paire clé-valeur comme ceci :

product_details["Supplier"] = "ErgoComfort Inc."

La mise à jour et l'ajout d'éléments à un dictionnaire utilisent la même syntaxe. Vous assignez simplement une valeur à une clé. Si la clé existe déjà, sa valeur sera mise à jour. Si la clé n'existe pas, une nouvelle paire clé-valeur sera ajoutée.

Une autre façon d'ajouter un élément à un dictionnaire est d'utiliser la méthode update() :

product_details.update({"ID": "1234-5678-9101-1121"})

Dictionnaire à 2 dimensions (dictionnaire imbriqué)

Si vous travaillez avec un dictionnaire à 2 dimensions (un dictionnaire imbriqué), vous pouvez ajouter ou mettre à jour des valeurs à l’intérieur des sous-dictionnaires de la même manière.

Par exemple, imaginons que vous ayez un dictionnaire qui contient plusieurs produits, et chaque produit a ses propres détails sous forme de sous-dictionnaires :

products = {
    "Product1": {
        "Name": "ErgoChair",
        "Price": 250,
        "Stock": 150
    },
    "Product2": {
        "Name": "SmartDesk",
        "Price": 400,
        "Stock": 80
    }
}

Pour ajouter un nouvel élément au produit "Product1", comme un code produit, vous pouvez procéder ainsi :

products["Product1"]["Code"] = "ERGO-2024"

Cela ajoutera la clé "Code" avec la valeur "ERGO-2024" au sous-dictionnaire de "Product1". Si "Product1" n’existait pas, Python aurait créé cette entrée automatiquement.

Si vous souhaitez mettre à jour une valeur existante dans un sous-dictionnaire, comme modifier le prix du produit "Product2", vous pouvez faire cela :

products["Product2"]["Price"] = 375

Cela modifiera la valeur associée à la clé "Price" dans le sous-dictionnaire de "Product2".

Les dictionnaires imbriqués permettent de stocker des informations structurées et hiérarchiques, facilitant ainsi l’organisation et l’accès aux données complexes.

Exercice

Dans le notebook Jupyter Favourite_Movies_Dictionary.ipynb, entraînez-vous à ajouter des éléments dans les dictionnaires :

Ajoutez deux nouveaux films et leurs détails (réalisateur, année de sortie, genre) au dictionnaire favourite_movies.

Solution

# Add two new movies to the favourite_movies dictionary
favourite_movies["The Hobbit: An Unexpected Journey"] = {
    "director": "Peter Jackson",
    "release_year": 2012,
    "genre": "Fantasy"
}

favourite_movies["The Lord of the Rings: The Fellowship of the Ring"] = {
    "director": "Peter Jackson",
    "release_year": 2001,
    "genre": "Fantasy"
}

# Print the updated dictionary
print(favourite_movies)

Exercices

Rouvrez le notebook Jupyter Company_Structure.ipynb dans le dossier Dictionaries. Après avoir terminé les exercices, n'oubliez pas de sauvegarder le notebook.

1. Expansion de l'équipe de vente

Les départements de l'entreprise se sont développés, et nous devons mettre à jour nos enregistrements ! L'équipe de vente à New York est passée à 30 employés. Mettez à jour le nombre d'employés des ventes à New York. Ensuite, affichez le dictionnaire mis à jour pour révéler les changements organisationnels.

2. Nouvelle opportunité de marché

Un nouveau département de Data Science avec 8 membres a été établi à New York. Ajoutez le nouveau département de Data Science. Ensuite, affichez le dictionnaire mis à jour.

Solutions

company_departments['New York']['Sales'] = 30
print("Updated company departments dictionary:")
print(company_departments)

company_departments['New York']['Data Science'] = 8
print("\nUpdated company departments dictionary after adding Data Science:")
print(company_departments)

Python propose plusieurs méthodes pour supprimer des éléments d'un dictionnaire. Reprenons notre dictionnaire précédent products_details et supposons que nous voulions supprimer une paire clé-valeur spécifique, par exemple, 'ID' :

# create a dictionary
product_details = {
    "Name": "Smart Office Chair",
    "Category": "Office Furniture",
    "Price": 279.99,
    "In Stock": 50,
    "ID": "1234-5678-9101-1121"
}
# Removes and returns the value associated with 'ID'
removed_value = product_details.pop('ID')
print(removed_value)  # Output: "1234-5678-9101-1121"

print(product_details)  # Output: {'Name': 'Smart Office Chair', 'Category': 'Office Furniture', 'Price': 279.99, 'In Stock': 50}

pop() nous aide à supprimer l'élément avec la clé donnée dans le dictionnaire et renvoie sa valeur. Si la clé n'existe pas, une erreur KeyError est levée.

Instruction del

Une autre façon de supprimer des éléments d'un dictionnaire est d'utiliser l'instruction del. Cette méthode supprime la paire clé-valeur du dictionnaire sans renvoyer la valeur.

# create a dictionary
product_details = {
    "Name": "Smart Office Chair",
    "Category": "Office Furniture",
    "Price": 279.99,
    "In Stock": 50,
    "ID": "1234-5678-9101-1121"
}
# Removes the key-value pair associated with 'ID'
del product_details['ID']

print(product_details)  # Output: {'Name': 'Smart Office Chair', 'Category': 'Office Furniture', 'Price': 279.99, 'In Stock': 50}

Méthode clear()

La méthode clear() supprime tous les éléments du dictionnaire, le laissant vide. Cette méthode est utile lorsque vous voulez rapidement vider le dictionnaire sans supprimer l'objet dictionnaire lui-même.

# create a dictionary
product_details = {
    "Name": "Smart Office Chair",
    "Category": "Office Furniture",
    "Price": 279.99,
    "In Stock": 50,
    "ID": "1234-5678-9101-1121"
}
# Removes all key-value pairs from the dictionary
product_details.clear()

print(product_details)  # Output: {}

La méthode clear() ne renvoie aucune valeur ; elle ne fait que vider le dictionnaire.

Exercice

Rouvrez le notebook Jupyter Company_Structure.ipynb dans le dossier Dictionaries. Après avoir terminé les exercices, n'oubliez pas de sauvegarder le notebook.

Restructuration à Sydney

Le département IT a fermé dans le bureau de Sydney. Supprimez l'entrée IT du bureau de Sydney dans notre dictionnaire company_departments et affichez le dictionnaire mis à jour pour refléter ce changement organisationnel.

Solution

# Remove the IT department from Sydney
del company_departments['Sydney']['IT']

# Print the updated dictionary
print("Updated company departments dictionary after unexpectedly closing IT in Sydney:")
print(company_departments)

Tout comme avec les chaînes de caractères et les listes, vous pouvez parcourir un dictionnaire en utilisant une boucle for. Que se passe-t-il lorsque vous parcourez un dictionnaire ? Voyons :

employ = {
    'name': 'John Doe',
    'role': 'Business Analyst',
    'experience': 5,  # years
    'department': 'Finance'
}

for loop_variable in employ:
    print(loop_variable)

# Output:
# name
# role
# experience
# department

Comme vous pouvez le voir, lorsqu'une boucle for parcourt un dictionnaire, la variable de boucle est assignée à chaque clé du dictionnaire, une à une. Dans l’exemple ci-dessus, loop_variable prend successivement les valeurs name, role, experience et department, qui sont les clés du dictionnaire employ.

Pour accéder aux valeurs du dictionnaire dans la boucle, référencez le dictionnaire en utilisant la clé :

for loop_variable in employ:
    print(employ[loop_variable])

# Output:
# John Doe
# Business Analyst
# 5
# Finance

Vous pouvez également parcourir directement les valeurs d'un dictionnaire en utilisant .values() :

for value in employ.values():
    print(value)

# Output:
# John Doe
# Business Analyst
# 5
# Finance

Vous pouvez aussi parcourir à la fois les clés et les valeurs en utilisant la méthode items() :

employ = {
    'name': 'John Doe',
    'role': 'Business Analyst',
    'experience': 5,  # years
    'department': 'Finance'
}

for key, value in employ.items():
    print('key =', key, ', value =', value)

# Output:
# key = name , value = John Doe
# key = role , value = Business Analyst
# key = experience , value = 5
# key = department , value = Finance

Voyons comment parcourir le dictionnaire imbriqué company :

company = {
    'employee1': {
        'name': 'John Doe',
        'role': 'Business Analyst',
        'experience': 5,
        'department': 'Finance'
    },
    'employee2': {
        'name': 'Jane Smith',
        'role': 'Software Engineer',
        'experience': 3,
        'department': 'IT'
    }
}

total_experience = 0

# Iterate through each employee in the company dictionary
for employee_id, employee_info in company.items():
    # Add the employee's years of experience to the total
    total_experience = total_experience + employee_info["experience"]
    # Print the employee ID
    print(f"Employee ID: {employee_id}")
    # Print each piece of information about the employee
    for key, value in employee_info.items():
        print(f"  {key}: {value}")

# Print the total years of experience across all employees
print(f"\\nTotal years of experience: {total_experience}")

# Output:
# Employee ID: employee1
#   name: John Doe
#   role: Business Analyst
#   experience: 5
#   department: Finance
# Employee ID: employee2
#   name: Jane Smith
#   role: Software Engineer
#   experience: 3
#   department: IT
#
# Total years of experience: 8

Exercice

Rouvrez le notebook Jupyter Company_Structure.ipynb dans le dossier Dictionaries. Après avoir terminé les exercices, n'oubliez pas de sauvegarder le notebook.

1. Décompte des employés par site

Calculez le nombre total d'employés dans chaque site tous départements confondus et présentez les résultats de manière claire et concise.

Pour résoudre ce problème, suivez ces étapes :

1. Créez un dictionnaire vide pour stocker le total de chaque site.
2. Parcourez le dictionnaire company_departments : a. Pour chaque site, additionnez le nombre d'employés de tous les départements. b. Stockez cette somme dans le nouveau dictionnaire, en utilisant le nom du site comme clé.
3. Formatez et affichez les résultats, montrant chaque site et son nombre total d'employés.

Astuce : Vous pouvez utiliser une boucle imbriquée ou la fonction sum() avec les valeurs du dictionnaire pour calculer les totaux.

2. Décompte des employés par département

Calculez et affichez le nombre total d'employés dans chaque département tous sites confondus.

Pour résoudre ce problème, suivez ces étapes :

1. Créez un dictionnaire vide appelé department_totals pour stocker les totaux par département.
2. Parcourez le dictionnaire company_departments :
   • Pour chaque site, parcourez tous les départements et leurs nombres d'employés.
   • Pour chaque département :
     1. Vérifiez si le département existe dans le dictionnaire department_totals.
     2. S'il existe, ajoutez le nombre actuel au total existant.
     3. S'il n'existe pas, créez une nouvelle entrée avec le nombre actuel.
3. Après les boucles, affichez les résultats montrant chaque département et son nombre total d'employés.

3. Quiz

Complétez le code suivant pour créer un programme utilisant un dictionnaire et une boucle while. Le programme doit présenter à l'utilisateur une série de questions, vérifier leurs réponses et maintenir un suivi de leur score.

# Step 1: Create a dictionary to store the questions and their correct answers
questions = {
    "What is ROI an acronym for?": "Return on Investment",
    "What financial statement shows a company's assets, liabilities, and equity?": "Balance Sheet",
    "What does SWOT stand for in business analysis?": "Strengths, Weaknesses, Opportunities, Threats",
    "What metric measures a company's ability to pay short-term obligations?": "Liquidity Ratio"
}

# Step 2: Initialize a variable to keep track of the score
score = ...   # Fill in the initial score (e.g., 0)

# Step 3: Display a welcome message
print("Welcome to the Knowledge Assessment!")
print("Type 'exit' anytime to end the assessment.\\n")

# Step 4: Start the assessment loop using a while loop
while ... :  # Fill in the condition to keep the loop running
    # Step 5: Iterate over the dictionary items (questions and answers)
    for ... , ... in questions.items():   # Fill in the correct variable names for the loop

        # Step 6: Ask the user each question and get their answer
        user_answer = ...(... + " ")   # Fill in the correct variable for the question

        # Step 7: Check if the user wants to exit the assessment
        if user_answer.lower() == "...":  # Fill in the command to exit (e.g., 'exit')
            print("\\nThank you for participating!")
            print(f"Your final score is {score} out of {...}.")   # Fill in the number of questions
            exit()
            
        # Step 8: Compare the user's answer with the correct answer
        if user_answer.strip().lower() == ....lower():   # Fill in the correct variable for the correct answer
            print("Correct!\\n")
            score += ...   # Fill in the correct increment for the score
        else:
            print(f"Incorrect! The correct answer is {...}.\\n")   # Fill in the correct variable for the correct answer

    # Step 9: Display the final score and ask if they want to start the assessment again
    print(f"You've completed the assessment! Your final score is {score} out of {len(questions)}.")

    play_again = input("Would you like to retake the assessment? (yes/no): ").strip().lower()

    if play_again != "yes":
        print("Thank you for participating! Goodbye.")
        break
    else:
        # Step 10: Reset the score if they want to retake the assessment
        score = ...   # Fill in the initial score again (e.g., 0)
        print("\\nStarting a new round!\\n")

Solution

company_departments = {
    "New York": {"Sales": 25, "Marketing": 15, "IT": 30, "HR": 10, "Finance": 20},
    "London": {"Sales": 20, "Marketing": 12, "IT": 25, "HR": 8, "Finance": 15},
    "Tokyo": {"Sales": 18, "Marketing": 10, "IT": 22, "HR": 7, "Finance": 13},
    "Sydney": {"Sales": 15, "Marketing": 8, "IT": 20, "HR": 6, "Finance": 10},
    "Berlin": {"Sales": 12, "Marketing": 6, "IT": 18, "HR": 5, "Finance": 8},
}

# Method 1: Using a for loop
total_employees_by_site = {}

for site, department_counts in company_departments.items():
    total = 0
    for count in department_counts.values():
        total += count
    total_employees_by_site[site] = total

# Method 2: Using the sum() function
total_employees_by_site_alt = {
    site: sum(department_counts.values()) for site, department_counts in company_departments.items()
}

# Both methods produce the same result
print("Method 1 result:", total_employees_by_site)
print("Method 2 result:", total_employees_by_site_alt)

# Initialize an empty dictionary to store the department totals
department_totals = {}

# Iterate through the company_departments dictionary
for location, departments in company_departments.items():
    for department, count in departments.items():
        # Check if the department exists in the department_totals dictionary
        if department in department_totals:
            # If it does, add the current count to the existing total
            department_totals[department] += count
        else:
            # If it doesn't, create a new entry with the current count
            department_totals[department] = count

# Print the results
print("Total employees in each department across all locations:")
for department, total in department_totals.items():
    print(f"{department}: {total}")

# Step 1: Create a dictionary to store the questions and their correct answers
questions = {
    "What is ROI an acronym for?": "Return on Investment",
    "What financial statement shows a company's assets, liabilities, and equity?": "Balance Sheet",
    "What does SWOT stand for in business analysis?": "Strengths, Weaknesses, Opportunities, Threats",
    "What metric measures a company's ability to pay short-term obligations?": "Liquidity Ratio"
}

# Step 2: Initialize a variable to keep track of the score
score = 0   # Initial score is set to 0

# Step 3: Display a welcome message
print("Welcome to the Knowledge Assessment!")
print("Type 'exit' anytime to end the assessment.\\n")

# Step 4: Start the assessment loop using a while loop
while True:
    # Step 5: Iterate over the dictionary items (questions and answers)
    for question, correct_answer in questions.items():

        # Step 6: Ask the user each question and get their answer
        user_answer = input(question + " ")

        # Step 7: Check if the user wants to exit the assessment
        if user_answer.lower() == "exit":
            print("\\nThank you for participating!")
            print(f"Your final score is {score} out of {len(questions)}.")
            exit()

        # Step 8: Compare the user's answer with the correct answer
        if user_answer.strip().lower() == correct_answer.lower():
            print("Correct!\\n")
            score += 1
        else:
            print(f"Incorrect! The correct answer is {correct_answer}.\\n")

    # Step 9: Display the final score and ask if they want to start the assessment again
    print(f"You've completed the assessment! Your final score is {score} out of {len(questions)}.")

    play_again = input("Would you like to retake the assessment? (yes/no): ").strip().lower()

    if play_again != "yes":
        print("Thank you for participating! Goodbye.")
        break
    else:
        # Step 10: Reset the score if they want to retake the assessment
        score = 0
        print("\\nStarting a new round!\\n")

Excellent travail ! Dans ce leçon, vous avez découvert les dictionnaires Python, qui sont des collections de paires clé-valeur.

Vous savez maintenant comment créer des dictionnaires, accéder à leurs valeurs et les modifier, et utiliser diverses méthodes de dictionnaire telles que .get(), .keys(), .values(), et .items(). De plus, vous vous êtes entraîné à parcourir des dictionnaires simples et imbriqués.

Continuez sur cette lancée et poursuivez l'exploration de la puissance des dictionnaires Python !