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.

Voici un exemple de code Python qui vérifie si une chaîne est un palindrome ou non :

def est_palindrome(s):
    # On retire les espaces et on met tout en minuscule
    s = s.replace(" ", "").lower()

    # On inverse la chaîne
    s_inverse = s[::-1]

    # On compare la chaîne et son inverse
    if s == s_inverse:
        return True
    else:
        return False

# Testons avec quelques exemples
print(est_palindrome("radar")) # True
print(est_palindrome("Bonjour")) # False
print(est_palindrome("Bob")) # True

Ce code fonctionne en suivant ces étapes :

1. On enlève les espaces de la chaîne et on met tous les caractères en minuscule, pour éviter les problèmes de casse et d’espaces.
2. On inverse la chaîne en utilisant la slicing syntax
   [start:end:step]

   avec un

   step

   de

   -1

   .

3. On compare la chaîne originale et son inverse, et on renvoie
   True

   si elles sont égales et

   False

   sinon.

Pour installer Docker sur Ubuntu 22.10, vous pouvez suivre ces étapes:

1. Assurez-vous que votre système est à jour en exécutant la commande suivante: sudo apt update
2. Installez les packages nécessaires pour ajouter des référentiels tiers à APT: sudo apt install apt-transport-https ca-certificates curl gnupg-agent software-properties-common
3. Ajoutez la clé GPG du dépôt Docker officiel: curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add –
4. Ajoutez le dépôt Docker à votre liste de sources APT: sudo add-apt-repository “deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable”
5. Mettez à jour votre liste de packages: sudo apt update
6. Installez Docker CE: sudo apt install docker-ce docker-ce-cli containerd.io
7. Vérifiez que Docker est en cours d’exécution: sudo systemctl status docker
8. ous devriez voir un message indiquant que Docker est en cours d’exécution. Si vous voulez démarrer Docker automatiquement au démarrage de votre système, exécutez la commande suivante: sudo systemctl enable docker
9. Pour utiliser Docker sans avoir à utiliser sudo, ajoutez votre utilisateur au groupe docker: sudo usermod -aG docker $USER
10. Vous devrez vous déconnecter et vous reconnecter pour que cette modification prenne effet.Une fois que Docker est installé et en cours d’exécution, vous pouvez vérifier que tout fonctionne correctement en exécutant la commande suivante: docker run hello-world
11. Cela devrait télécharger l’image “hello-world” depuis Docker Hub et exécuter un conteneur à partir de cette image. Si tout fonctionne correctement, vous devriez voir un message de bienvenue.

En Python, les tuples et les listes sont des structures de données similaires qui permettent de stocker une série d’éléments. Cependant, il y a quelques différences importantes entre ces deux types :

1. Les tuples sont immuables, c’est-à-dire que vous ne pouvez pas ajouter, supprimer ou modifier des éléments d’un tuple une fois qu’il a été créé. Les listes, en revanche, sont mutables et vous pouvez facilement ajouter, supprimer ou modifier des éléments.
2. Les tuples sont généralement plus rapides à créer et à manipuler que les listes, car ils sont immuables. Cependant, cela dépend de l’opération que vous effectuez.
3. Les tuples sont définis avec des parenthèses
   ()

   , tandis que les listes sont définies avec des crochets

   []

   .

Voici un exemple de création et de modification de tuples et de listes en Python :

# Création d'un tuple et d'une liste
tuple = (1, 2, 3)
list = [1, 2, 3]

# Tentative de modification d'un élément du tuple (échoue)
try:
    tuple[0] = 0
except TypeError:
    print("Impossible de modifier un élément d'un tuple")

# Modification d'un élément de la liste
list[0] = 0
print(list)  # imprime [0, 2, 3]

# Tentative d'ajout d'un élément au tuple (échoue)
try:
    tuple.append(4)
except AttributeError:
    print("Impossible d'ajouter un élément à un tuple")

# Ajout d'un élément à la liste
list.append(4)
print(list)  # imprime [0, 2, 3, 4]