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

.

Voici comment on peut écrire un programme Python qui trie les mots d’une chaîne de caractères par ordre alphabétique :

def trier_mots(chaine):
  # On sépare la chaîne en mots
  mots = chaine.split()

  # On trie les mots
  mots.sort()

  # On les regroupe en une chaîne de caractères
  chaine_triee = " ".join(mots)
  return chaine_triee

# Exemples d'utilisation
print(trier_mots("Le chat mange une souris"))  # Doit afficher "Le chat une mange souris"
print(trier_mots("Voici un exemple de phrase à trier"))  # Doit afficher "à de exemple phrase trier un voici"

Voici comment on peut écrire un programme Python qui supprime les ponctuations d’une chaîne de caractères :

import string

def enlever_ponctuation(chaine):
  # On utilise la constante string.punctuation pour obtenir tous les caractères de ponctuation
  for caractere in string.punctuation:
    chaine = chaine.replace(caractere, "")
  return chaine

# Exemples d'utilisation
print(enlever_ponctuation("Bonjour, comment vas-tu ?"))  # Doit afficher "Bonjour comment vas tu "
print(enlever_ponctuation("Je suis très heureux de te voir !"))  # Doit afficher "Je suis très heureux de te voir "

Ce programme importe la bibliothèque

et utilise la constante

qui contient tous les caractères de ponctuation. Il parcourt ensuite chaque caractère de la chaîne et utilise la méthode

pour remplacer chaque caractère de ponctuation par un espace vide. En fin de boucle, la fonction retourne la chaîne sans les caractères de ponctuation.