Voici comment vérifier si une clé est présente dans un dictionnaire en utilisant Python:

if key in my_dict:
  # la clé est présente dans le dictionnaire
else:
  # la clé n'est pas présente dans le dictionnaire
#ou
if my_dict.get(key) is not None:
  # la clé est présente dans le dictionnaire
else:
  # la clé n'est pas présente dans le dictionnaire

#ou 
if key in my_dict:
  # la clé est présente dans le dictionnaire
else:
  # la clé n'est pas présente dans le dictionnaire

Voici comment cela fonctionne: l’opérateur

vérifie si une valeur est présente dans un objet itérable, comme une liste ou un dictionnaire. Si la valeur est présente, l’opérateur renvoie

, sinon il renvoie

.

Vous pouvez également utiliser la méthode

de la classe

pour vérifier si une clé est présente dans un dictionnaire. La méthode

renvoie la valeur associée à la clé si elle est présente dans le dictionnaire, ou

sinon. Voici comment cela peut être fait.

Vous pouvez également utiliser la méthode

de la classe

pour vérifier si une clé est présente dans un dictionnaire. La méthode

renvoie

si la clé est présente dans le dictionnaire, et

sinon. Voici comment cela peut être fait :

Le module

(pour “Shell Utilities”) fournit une variété de fonctions pour travailler avec des fichiers et des dossiers, y compris la fonction

qui permet de copier un fichier d’un emplacement à un autre.

La fonction

prend en entrée les chemins d’accès des fichiers source et de destination, sous forme de chaînes de caractères. Si le fichier de destination existe déjà, il sera remplacé par la copie. Si le fichier de destination n’existe pas, il sera créé.

Voici comment utiliser la fonction

pour copier un fichier dans le même dossier :

import shutil

# Copie du fichier d'origine vers le fichier de destination (dans le même dossier)
shutil.copy(source_file, "./" + dest_file)
import shutil

# Copie du fichier d'origine vers le fichier de destination (dans le même dossier)
shutil.copy(source_file, "./" + dest_file)
import shutil

# Copie du dossier d'origine vers le dossier de destination
shutil.copytree(source_folder, dest_folder, recursive=True)

Vous pouvez également utiliser la fonction

pour copier des dossiers en utilisant le paramètre

et en mettant

:

Voici comment cela fonctionne : la fonction booléenne

renvoie

si l’expression qui suit est

, et

si elle est

. En Python, une liste vide est considérée comme

, tandis qu’une liste non vide est considérée comme

.

if not my_list:
  # la liste est vide
else:
  # la liste n'est pas vide

Vous pouvez également utiliser l’instruction

suivie de la longueur de la liste, comme ceci :

if len(my_list) == 0:
  # la liste est vide
else:
  # la liste n'est pas vide

Ou encore, vous pouvez utiliser la méthode

de la classe

, comme ceci:

if my_list.isempty():
  # la liste est vide
else:
  # la liste n'est pas vide

Cela fonctionne parce que la méthode

renvoie

si la liste est vide et

sinon. Cette méthode est disponible à partir de Python 3.9. Si vous utilisez une version antérieure de Python, vous devrez utiliser l’une des deux premières approches.

Voici comment on peut écrire un programme Python qui trie un dictionnaire par valeur en utilisant la fonction

:

def trier_dictionnaire_par_valeur(mon_dictionnaire):
  # On trie le dictionnaire par valeur et on retourne la liste des tuples (clé, valeur) triée
  return sorted(mon_dictionnaire.items(), key=lambda x: x[1])

# Exemple d'utilisation
mon_dictionnaire = { "cle1": 3, "cle2": 1, "cle3": 2 }
trie = trier_dictionnaire_par_valeur(mon_dictionnaire)
print(trie)  # Affiche [("cle2", 1), ("cle3", 2), ("cle1", 3)]

Ce programme utilise la fonction

qui prend en argument le dictionnaire et un paramètre

qui spécifie la fonction de tri à utiliser. On utilise ici une fonction lambda qui retourne la valeur de chaque tuple (clé, valeur). La fonction

trie alors la liste de tuples en utilisant cette valeur comme clé de tri et retourne le résultat.

Note : si vous voulez trier le dictionnaire en ordre décroissant, il suffit de mettre

dans l’appel à la fonction

.

Voici comment on peut écrire un programme Python qui parcourt un dictionnaire et affiche ses clés et valeurs à l’aide d’une boucle

:

def afficher_dictionnaire(mon_dictionnaire):
  # On parcourt le dictionnaire avec une boucle for
  for cle, valeur in mon_dictionnaire.items():
    # On affiche la clé et la valeur
    print("{} : {}".format(cle, valeur))

# Exemple d'utilisation
mon_dictionnaire = { "cle1": "valeur1", "cle2": "valeur2", "cle3": "valeur3" }
afficher_dictionnaire(mon_dictionnaire)

Ce programme utilise la méthode

qui retourne un objet “view” contenant toutes les paires clé-valeur du dictionnaire. La boucle

parcourt cet objet et affecte les valeurs de la clé et de la valeur à des variables

et

. On peut ensuite utiliser ces variables dans la boucle pour afficher la clé et la valeur de chaque itération.

Voici comment on peut écrire un programme Python qui parcourt une liste en utilisant la boucle

et qui affiche l’index et la valeur de chaque élément de la liste :

ma_liste = [10, 20, 30, 40, 50]

# On parcourt la liste
for i, valeur in enumerate(ma_liste):
  # On affiche l'index et la valeur
  print("Index : {} / Valeur : {}".format(i, valeur))

# Output :
# Index : 0 / Valeur : 10
# Index : 1 / Valeur : 20
# Index : 2 / Valeur : 30
# Index : 3 / Valeur : 40
# Index : 4 / Valeur : 50

La fonction

permet de parcourir une liste tout en retournant à chaque itération l’index et la valeur de l’élément courant. Dans la boucle

, on utilise l’instruction

pour parcourir la liste et récupérer à chaque itération l’index de l’élément courant dans la variable

et sa valeur dans la variable

.

Ainsi, à chaque itération de la boucle, l’index de l’élément courant est affiché ainsi que sa valeur.

Voici comment on peut écrire un programme Python qui crée en toute sécurité (sans lever d’exception) un répertoire imbriqué, c’est-à-dire un répertoire qui peut avoir plusieurs niveaux de profondeur :

import os

def creer_repertoire_imbrique(chemin):
  # On vérifie que le répertoire parent existe
  repertoire_parent = os.path.dirname(chemin)
  if not os.path.exists(repertoire_parent):
    creer_repertoire_imbrique(repertoire_parent)

  # On crée le répertoire s'il n'existe pas encore
  if not os.path.exists(chemin):
    os.mkdir(chemin)

# Exemple d'utilisation
creer_repertoire_imbrique("/dossier/sous-dossier/sous-sous-dossier")

Ce programme vérifie d’abord que le répertoire parent du répertoire à créer existe, en utilisant la fonction

pour obtenir le nom du répertoire parent. S’il n’existe pas, on appelle récursivement la fonction

pour créer le répertoire parent. Une fois que le répertoire parent existe, on vérifie que le répertoire à créer n’existe pas déjà, et on le crée en utilisant la fonction

s’il n’existe pas encore.

Ce programme gère donc de manière récursive la création des répertoires imbriqués, en s’assurant à chaque étape que le répertoire parent existe avant de créer le répertoire en question. De cette manière, aucune exception n’est levée lors de la création du répertoire imbriqué.

Voici comment on peut écrire un programme Python qui fusionne deux dictionnaires :

def fusionner_dictionnaires(dict1, dict2):
  # On crée un nouveau dictionnaire qui contient tous les éléments de dict1 et dict2
  dict_fusionne = {**dict1, **dict2}
  return dict_fusionne

# Exemples d'utilisation
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
dict_fusionne = fusionner_dictionnaires(dict1, dict2)
print(dict_fusionne)  # Affiche {"a": 1, "b": 2, "c": 3, "d": 4}

dict3 = {"e": 5, "f": 6}
dict4 = {"f": 7, "g": 8}
dict_fusionne = fusionner_dictionnaires(dict3, dict4)
print(dict_fusionne)  # Affiche {"e": 5, "f": 7, "g": 8}

Ce programme utilise l'opérateur ** pour fusionner les deux dictionnaires en un seul.
Si les deux dictionnaires ont des clés en commun,
la valeur associée à la clé du second dictionnaire écrasera la valeur du premier dictionnaire

on peut aussi faire:
Ce programme parcourt les deux dictionnaires et ajoute chaque élément au nouveau dictionnaire

dict_fusionne

. Il utilise les boucles

for

et les méthodes

items()

et

[cle] = valeur

pour parcourir et ajouter chaque élément. En fin de boucle, le dictionnaire

dict_fusionne

contient tous les éléments des deux dictionnaires originaux.

def fusionner_dictionnaires(dict1, dict2):
  # On crée un nouveau dictionnaire vide qui va accueillir la fusion
  dict_fusionne = {}

  # On parcourt les deux dictionnaires et on ajoute leurs éléments au nouveau dictionnaire
  for cle, valeur in dict1.items():
    dict_fusionne[cle] = valeur
  for cle, valeur in dict2.items():
    dict_fusionne[cle] = valeur

  return dict_fusionne

# Exemples d'utilisation
dict1 = { "cle1": "valeur1", "cle2": "valeur2" }
dict2 = { "cle3": "valeur3", "cle4": "valeur4" }
dict_fusionne = fusionner_dictionnaires(dict1, dict2)
print(dict_fusionne)  # Affiche { "cle1": "valeur1", "cle2": "valeur2", "cle3": "valeur3", "cle4": "valeur4" }

Voici comment on peut écrire un programme Python qui crée une pyramide en utilisant la bibliothèque

:

import turtle

def creer_pyramide(longueur_cote, niveaux):
  # On initialise turtle
  turtle.speed("fastest")
  turtle.hideturtle()

  # On définit la longueur des côtés et le nombre de niveaux
  cote = longueur_cote
  niveaux = niveaux

  # On dessine la pyramide
  for i in range(niveaux):
    turtle.begin_fill()
    for j in range(4):
      turtle.forward(cote)
      turtle.right(90)
    turtle.end_fill()
    turtle.up()
    turtle.forward(cote // 2)
    turtle.right(90)
    turtle.forward(cote // 2)
    turtle.down()
    cote = cote // 2

# Exemple d'utilisation
creer_pyramide(200, 4)
turtle.done()

def creer_pyramide(hauteur):
  # On vérifie que la hauteur est valide
  if hauteur < 1:
    raise ValueError("La hauteur doit être au moins égale à 1")

  # On construit chaque ligne de la pyramide
  for i in range(hauteur):
    # On calcule le nombre d'espaces à insérer
    espaces = " " * (hauteur - i - 1)
    # On calcule le nombre de caractères à insérer
    caracteres = "*" * (i * 2 + 1)
    # On affiche la ligne
    print(espaces + caracteres + espaces)

# Exemple d'utilisation
creer_pyramide(5)

Voici comment on peut écrire un programme Python qui trouve la taille (résolution) d’une image

import os
from PIL import Image

def trouver_taille_image(nom_fichier):
  # On vérifie que le fichier existe
  if not os.path.exists(nom_fichier):
    raise ValueError("Le fichier {} n'existe pas".format(nom_fichier))

  # On ouvre l'image
  image = Image.open(nom_fichier)

  # On retourne la taille sous forme de tuple (largeur, hauteur)
  return image.size

# Exemples d'utilisation
print(trouver_taille_image("mon_image.jpg"))  # Affiche (640, 480) par exemple
print(trouver_taille_image("autre_image.png"))  # Affiche (800, 600) par exemple

Ce programme utilise la bibliothèque

(Python Imaging Library) pour ouvrir l’image et récupérer ses dimensions. La méthode

retourne un tuple

qui représente la résolution de l’image.

Note : n’oubliez pas d’installer la bibliothèque

avant de lancer ce programme, en utilisant par exemple la commande

.