Algorithmique et programmation en Python

Un algorithme est une séquence finie et non ambiguë d'instructions ou d'opérations permettant de résoudre un problème donné ou d'accomplir une tâche. Pensez-y comme une recette de cuisine :

1. Ingrédients (Données d'entrée) : ce dont vous avez besoin au départ.
2. Étapes (Instructions) : des actions claires et précises à suivre dans un ordre déterminé.
3. Plat final (Résultat) : ce que vous obtenez à la fin.

Un algorithme doit toujours être :

• Déterminé : pour les mêmes données d'entrée, il doit toujours produire le même résultat.
• Fini : il doit se terminer après un nombre fini d'étapes.
• Non ambigu : chaque instruction doit être parfaitement claire.

• La recette d'un gâteau.
• Le mode d'emploi d'un appareil électronique.
• L'itinéraire pour aller d'un point A à un point B.
• Trier une pile de cartes par ordre croissant.

En informatique, un algorithme est la logique derrière un programme. Avant d'écrire du code, on pense à l'algorithme : comment résoudre le problème ?

Python est un langage de programmation de haut niveau, interprété, interactif et orienté objet. Créé par Guido van Rossum et sorti en 1991, il est devenu extrêmement populaire grâce à sa simplicité et sa lisibilité. Il est utilisé dans des domaines variés comme le développement web, l'intelligence artificielle, l'analyse de données, et même la création de jeux.

Pourquoi Python ?

• Facile à apprendre : sa syntaxe est proche de l'anglais.
• Polyvalent : il peut être utilisé pour de nombreux types d'applications.
• Grande communauté : beaucoup de ressources et d'aide disponibles.

Environnement de développement : Pour écrire et exécuter du code Python, nous avons besoin d'un environnement.

• IDLE (Integrated Development and Learning Environment) : Souvent installé avec Python, il est simple et suffisant pour débuter.
• Éditeurs en ligne : Des sites comme Replit, trinket.io ou des notebooks (Jupyter) permettent d'écrire et d'exécuter du code directement dans un navigateur, sans installation. C'est très pratique pour commencer !

Premiers pas : afficher un message La première chose que l'on apprend souvent est d'afficher "Bonjour le monde !". En Python, c'est très simple :

print("Bonjour le monde !")

Le mot-clé print() est une fonction qui affiche le texte (ou la valeur) que vous lui donnez entre parenthèses. Le texte doit être placé entre guillemets doubles ou simples.

Syntaxe de base :

• Indentation : Python utilise l'indentation (les espaces en début de ligne) pour définir les blocs de code, là où d'autres langages utilisent des accolades. C'est CRUCIAL ! Une mauvaise indentation provoque une erreur.
• Commentaires : Pour ajouter des notes sans que le code ne soit exécuté, utilisez le symbole #. Tout ce qui suit # sur la même ligne est ignoré.

  # Ceci est un commentaire, il ne sera pas exécuté
  print("Ceci est du code") # Un commentaire peut aussi être sur la même ligne
  

Une variable est un conteneur qui stocke une valeur dans la mémoire de l'ordinateur. C'est comme une boîte à laquelle vous donnez un nom, et dans laquelle vous pouvez ranger quelque chose. Le contenu de la boîte peut changer.

Définition d'une variable : En Python, pas besoin de déclarer le type d'une variable avant de l'utiliser. On lui donne un nom et on lui affecte une valeur.

mon_age = 16
prenom = "Alice"
prix_unitaire = 12.50

Règles pour nommer une variable :

• Doit commencer par une lettre ou un underscore (_).
• Ne peut contenir que des lettres, des chiffres et des underscores.
• Est sensible à la casse (Majuscules/Minuscules : age est différent de Age).
• Ne peut pas être un mot-clé réservé de Python (comme print, if, for).
• Il est recommandé d'utiliser des noms explicites (ex: nombre_eleves plutôt que n).

Types de données : Python gère plusieurs types de données de base :

• int (entiers) : Nombres entiers, positifs ou négatifs, sans décimale. Ex: 5, -10, 0.
• float (flottants) : Nombres à virgule (on utilise un point en programmation). Ex: 3.14, -0.5, 10.0.
• str (chaînes de caractères) : Séquences de caractères (texte) enfermées entre guillemets simples ou doubles. Ex: "Bonjour", 'Python'.
• bool (booléens) : Représentent une valeur de vérité : True (vrai) ou False (faux). Très utilisés pour les conditions.

Vous pouvez connaître le type d'une variable avec la fonction type():

age = 17
print(type(age))        # Affiche <class 'int'>

taille = 1.75
print(type(taille))     # Affiche <class 'float'>

message = "Salut"
print(type(message))    # Affiche <class 'str'>

Affectation de valeurs : L'opérateur = est l'opérateur d'affectation. Il attribue la valeur de droite à la variable de gauche.

x = 10         # x prend la valeur 10
y = x + 5      # y prend la valeur de x (10) + 5, donc y = 15
x = "texte"    # x prend maintenant la valeur "texte" (on peut changer le type !)

Une variable peut changer de valeur et même de type au cours de l'exécution d'un programme.

Opérations de base : On peut effectuer des opérations avec des variables du même type ou compatible.

a = 5
b = 2
resultat_addition = a + b    # 7
resultat_multi = a * b       # 10

nom = "Jean"
prenom = "Dupont"
nom_complet = nom + " " + prenom # "Jean Dupont" (concaténation de chaînes)

Les opérateurs sont des symboles qui réalisent des opérations sur des valeurs et des variables. Une expression est une combinaison de valeurs, variables et opérateurs qui produit une nouvelle valeur.

Opérateurs arithmétiques : Ils sont utilisés pour des calculs mathématiques.

Opérateurs de comparaison : Ils comparent deux valeurs et renvoient un booléen (True ou False).

==Attention : ne confondez pas = (affectation) et <mark> (comparaison d'égalité) !

Opérateurs logiques : Ils combinent des expressions booléennes et renvoient un booléen.

• and (ET logique) : Renvoie True si toutes les conditions sont True. True and True → True True and False → False
• or (OU logique) : Renvoie True si au moins une des conditions est True. True or False → True False or False → False
• not (NON logique) : Inverse la valeur de vérité. not True → False not False → True

Priorité des opérateurs : Comme en mathématiques, les opérateurs ont un ordre de priorité.

1. Parenthèses ()
2. Puissances **
3. Multiplication *, Division /, Division entière //, Modulo %
4. Addition +, Soustraction -
5. Comparaisons ==, !=, <, >, <=, >=
6. Opérateurs logiques not, and, or (dans cet ordre)

resultat = 5 + 3 * 2 → 5 + 6 → 11 (multiplication avant addition) est_vrai = (10 > 5) and (3 < 1) → True and False → False

La structure if permet d'exécuter un bloc de code seulement si une condition est vraie.

Syntaxe :

if condition:
    # Bloc d'instructions à exécuter si la condition est VRAIE
    instruction1
    instruction2
    # ...

• La condition est une expression qui doit renvoyer True ou False (un booléen).
• Le deux-points : est obligatoire après la condition.
• Le bloc d'instructions qui suit doit être indenté (généralement 4 espaces ou une tabulation). C'est ainsi que Python sait quelles instructions appartiennent au if.

age = 18
if age >= 18:
    print("Vous êtes majeur.")
print("Fin du programme.") # Cette ligne s'exécute toujours

Si age est 17, la condition age >= 18 est False, donc le message "Vous êtes majeur." ne s'affiche pas.

La structure if-else offre une alternative : si la condition est vraie, un bloc de code est exécuté ; sinon (si la condition est fausse), un autre bloc de code est exécuté. Il y a toujours deux chemins possibles.

Syntaxe :

if condition:
    # Bloc d'instructions si la condition est VRAIE
    instruction_si_vrai
else:
    # Bloc d'instructions si la condition est FAUSSE
    instruction_si_faux

• Le mot-clé else est suivi d'un deux-points :.
• Le bloc else doit également être indenté.

note = 12
if note >= 10:
    print("Félicitations, vous avez réussi !")
else:
    print("Dommage, vous n'avez pas réussi.")

Si note vaut 9, la condition note >= 10 est False, donc le bloc après else est exécuté.

Pour gérer plusieurs conditions successives, on utilise if-elif-else. elif est une contraction de "else if" (sinon si).

Syntaxe :

if condition1:
    # Instructions si condition1 est VRAIE
elif condition2:
    # Instructions si condition1 est FAUSSE ET condition2 est VRAIE
elif condition3:
    # Instructions si condition1 & condition2 sont FAUSSES ET condition3 est VRAIE
else:
    # Instructions si AUCUNE des conditions précédentes n'est VRAIE

• Python évalue les conditions dans l'ordre, de haut en bas.
• Dès qu'une condition est vraie, le bloc de code correspondant est exécuté, et le reste de la structure if-elif-else est ignoré.
• Le bloc else est facultatif et sert de "cas par défaut" si aucune des conditions if ou elif n'est vraie.

score = 85

if score >= 90:
    print("Mention Très Bien")
elif score >= 80:
    print("Mention Bien")
elif score >= 70:
    print("Mention Assez Bien")
else:
    print("Pas de mention")

Si score est 85, la première condition score >= 90 est False. La deuxième condition score >= 80 est True, donc "Mention Bien" est affiché, et les elif et else suivants sont ignorés. ==L'ordre des conditions est important ! Si on avait testé score >= 70 en premier, le résultat aurait été différent pour un score de 85.==

On peut combiner plusieurs conditions simples en utilisant les opérateurs logiques (and, or, not) pour créer des conditions plus complexes.

age = 20
permis = True

if age >= 18 and permis:
    print("Vous pouvez conduire.")
else:
    print("Vous ne pouvez pas conduire.")

Ici, les deux conditions (age >= 18 ET permis) doivent être vraies pour que le message "Vous pouvez conduire." s'affiche.

jour = "Dimanche"
est_ferie = False

if jour <mark> "Samedi" or jour </mark> "Dimanche" or est_ferie:
    print("C'est le week-end ou un jour férié !")
else:
    print("C'est un jour de semaine travaillé.")

Ici, si au moins une des trois conditions est vraie, le premier message s'affiche.

est_connecte = False

if not est_connecte: # Équivalent à if est_connecte == False:
    print("Veuillez vous connecter.")
else:
    print("Vous êtes connecté.")

L'opérateur not inverse la valeur de vérité de est_connecte.

Combinaison et parenthèses : Utilisez les parenthèses pour clarifier l'ordre d'évaluation des conditions, surtout avec and et or.

temperature = 25
ensoleille = True
vent = False

if (temperature > 20 and ensoleille) or vent:
    print("Conditions favorables pour sortir.")
else:
    print("Restez à la maison.")

Ici, "Conditions favorables" si (température > 20 ET ensoleillé) OU s'il y a du vent.

La boucle for est utilisée pour itérer sur une séquence (comme une liste de nombres, une chaîne de caractères, etc.) ou pour répéter un bloc de code un nombre connu de fois.

Syntaxe :

for element in sequence:
    # Bloc d'instructions à répéter pour chaque élément
    instruction1
    instruction2

• element est une variable qui prendra successivement chaque valeur de la sequence.
• Le deux-points : et l'indentation sont obligatoires.

Fonction range() : Souvent, on veut répéter une action un certain nombre de fois. La fonction range() génère une séquence de nombres.

• range(n) : génère des nombres de 0 à n-1. (Ex: range(5) donne 0, 1, 2, 3, 4)
• range(debut, fin) : génère des nombres de debut à fin-1. (Ex: range(2, 5) donne 2, 3, 4)
• range(debut, fin, pas) : génère des nombres de debut à fin-1 avec un certain pas. (Ex: range(0, 10, 2) donne 0, 2, 4, 6, 8)

for i in range(5): # i prendra les valeurs 0, 1, 2, 3, 4
    print(f"Tour numéro {i+1}") # f-string pour un affichage formaté

Ceci affichera :

Tour numéro 1
Tour numéro 2
Tour numéro 3
Tour numéro 4
Tour numéro 5

Parcours d'éléments : On peut aussi itérer directement sur les éléments d'une chaîne de caractères (que nous verrons plus en détail plus tard).

mot = "Python"
for lettre in mot:
    print(lettre)

Ceci affichera chaque lettre du mot sur une nouvelle ligne.

La boucle while répète un bloc de code tant qu'une condition reste vraie. Le nombre d'itérations n'est pas nécessairement connu à l'avance.

Syntaxe :

while condition:
    # Bloc d'instructions à répéter tant que la condition est VRAIE
    instruction1
    instruction2
    # ...

• La condition est évaluée avant chaque itération. Si elle est True, le bloc est exécuté.
• Le deux-points : et l'indentation sont obligatoires.
• Il est essentiel que quelque chose dans le bloc de code modifie la condition pour qu'elle devienne False à un moment donné, sinon vous aurez une boucle infinie !

compteur = 0
while compteur < 3:
    print(f"Le compteur est à {compteur}")
    compteur = compteur + 1 # ou compteur += 1
print("La boucle est terminée.")

Ceci affichera :

Le compteur est à 0
Le compteur est à 1
Le compteur est à 2
La boucle est terminée.

La condition compteur < 3 devient False lorsque compteur atteint 3, et la boucle s'arrête.

Risque de boucle infinie : Si la condition ne devient jamais fausse, le programme ne s'arrêtera jamais (ou jusqu'à ce que vous le forciez).

# ATTENTION : NE PAS EXÉCUTER CE CODE TEL QUEL, IL NE S'ARRÊTERA JAMAIS !
# while True:
#    print("Je tourne en rond !")

Le choix entre for et while dépend de la situation :

• Utilisez la boucle for quand le nombre d'itérations est connu à l'avance ou quand vous voulez parcourir tous les éléments d'une séquence.

  • Ex: Afficher les nombres de 1 à 10.
  • Ex: Parcourir tous les caractères d'un mot.
  • Ex: Traiter chaque élément d'une liste.

• Utilisez la boucle while quand le nombre d'itérations est inconnu à l'avance et dépend d'une condition qui peut changer au cours de l'exécution.

  • Ex: Demander à l'utilisateur de saisir un mot de passe jusqu'à ce qu'il soit correct.
  • Ex: Simuler un jeu jusqu'à ce qu'un certain score soit atteint.
  • Ex: Lire un fichier ligne par ligne jusqu'à la fin.

Pour calculer la somme des 100 premiers entiers :

• Avec for (nombre d'itérations connu) :

  somme = 0
  for i in range(1, 101): # de 1 à 100 inclus
      somme += i
  print(somme)
  

• Avec while (possible mais moins idiomatique ici) :

  somme = 0
  i = 1
  while i <= 100:
      somme += i
      i += 1
  print(somme)
  

Dans ce cas, for est plus clair et plus concis.

Ces deux instructions spéciales permettent de modifier le comportement normal des boucles.

• break : L'instruction break permet de sortir immédiatement de la boucle en cours. Le programme continue ensuite avec la première instruction qui suit la boucle.

  for i in range(10):
      if i == 5:
          break # Sort de la boucle quand i est 5
      print(i)
  print("Boucle terminée avec break.")
  

  Affichera : 0, 1, 2, 3, 4 puis "Boucle terminée avec break.".

• continue : L'instruction continue permet de sauter le reste de l'itération actuelle et de passer directement à l'itération suivante de la boucle.

  for i in range(5):
      if i == 2:
          continue # Passe au tour suivant si i est 2
      print(i)
  print("Boucle terminée avec continue.")
  

  Affichera : 0, 1, 3, 4 puis "Boucle terminée avec continue.". Le 2 est sauté.

Ces instructions sont utiles pour gérer des cas particuliers au sein d'une boucle, comme arrêter une recherche dès qu'un élément est trouvé (break) ou ignorer des éléments qui ne répondent pas à un critère (continue).

Pour créer une fonction, on utilise le mot-clé def (pour "define").

Syntaxe pour la définition :

def nom_de_la_fonction(parametre1, parametre2, ...):
    # Bloc d'instructions de la fonction
    instruction1
    instruction2
    # ...

• nom_de_la_fonction : doit suivre les mêmes règles de nommage que les variables.
• parametre1, parametre2 : sont des variables locales à la fonction qui recevront des valeurs lors de l'appel. Ils sont facultatifs.
• Le deux-points : et l'indentation sont obligatoires.

Appel de fonction : Pour utiliser une fonction, il faut l'appeler (ou l'exécuter) en utilisant son nom suivi de parenthèses, en y passant les arguments (les valeurs pour les paramètres).

def saluer(nom): # 'nom' est un paramètre
    print(f"Bonjour, {nom} !")

# Appel de la fonction
saluer("Alice")   # "Alice" est l'argument
saluer("Bob")     # "Bob" est un autre argument

Ceci affichera :

Bonjour, Alice !
Bonjour, Bob !

Une fonction peut ne prendre aucun paramètre :

def afficher_heure():
    # Ici, on pourrait récupérer et afficher l'heure actuelle
    print("Il est 10h30.")

afficher_heure()

Une fonction peut effectuer des calculs et renvoyer un résultat à l'endroit où elle a été appelée. On utilise le mot-clé return pour cela.

Syntaxe avec return :

def nom_de_la_fonction(parametre):
    # ... calculs ...
    return resultat

• resultat est la valeur qui sera renvoyée par la fonction.
• Une fois qu'un return est exécuté, la fonction s'arrête immédiatement et renvoie la valeur.
• Une fonction peut retourner une ou plusieurs valeurs (sous forme de tuple).

def additionner(a, b):
    somme = a + b
    return somme # La fonction renvoie la valeur de 'somme'

resultat_calcul = additionner(10, 5) # La valeur 15 est renvoyée et stockée dans 'resultat_calcul'
print(resultat_calcul) # Affiche 15

# On peut aussi utiliser directement le retour de la fonction
print(additionner(3, 7)) # Affiche 10

Fonctions sans retour explicite : Si une fonction n'a pas de return explicite, elle renvoie implicitement la valeur spéciale None (qui signifie "rien" en Python). Les fonctions print() sont un bon exemple : elles affichent quelque chose mais ne renvoient pas de valeur utile.

def afficher_message(message):
    print(message)
    # Pas de return ici

valeur_retour = afficher_message("Hello")
print(valeur_retour) # Affiche "Hello" puis "None"

La portée (scope) d'une variable détermine où elle peut être accédée et modifiée dans le programme.

• Variables locales : Une variable définie à l'intérieur d'une fonction est une variable locale. Elle n'existe que pendant l'exécution de cette fonction et n'est pas accessible en dehors.

  def ma_fonction():
      x = 10 # x est une variable locale
      print(x)
  
  ma_fonction() # Affiche 10
  # print(x) # Erreur ! 'x' n'est pas définie en dehors de la fonction
  

• Variables globales : Une variable définie en dehors de toute fonction (au niveau principal du programme) est une variable globale. Elle est accessible de n'importe où dans le programme, y compris à l'intérieur des fonctions.

  y = 20 # y est une variable globale
  
  def autre_fonction():
      print(y) # Accède à la variable globale y
  
  autre_fonction() # Affiche 20
  print(y)         # Affiche 20
  

• Modification d'une variable globale depuis une fonction : Pour modifier une variable globale à l'intérieur d'une fonction, il faut utiliser le mot-clé global. C'est généralement déconseillé car cela rend le code plus difficile à comprendre et à maintenir.

  compteur_global = 0
  
  def incrementer():
      global compteur_global # Indique qu'on veut modifier la variable globale
      compteur_global += 1
  
  incrementer()
  print(compteur_global) # Affiche 1
  

  En général, il est préférable de passer les variables en paramètres et de retourner les nouvelles valeurs plutôt que de modifier directement les variables globales.

L'utilisation de fonctions apporte de nombreux bénéfices :

1. Réutilisabilité du code : Une fois définie, une fonction peut être appelée plusieurs fois, à différents endroits du programme, évitant ainsi de copier-coller le même code.
2. Modularité et organisation : Les fonctions permettent de découper un gros programme en petites unités logiques et gérables. Chaque fonction a une responsabilité claire.
3. Lisibilité et maintenance : Un code structuré en fonctions est plus facile à lire, à comprendre et à déboguer. Si un problème survient, il est plus simple d'identifier la fonction incriminée.
4. Débogage facilité : Tester des petites fonctions une par une est plus simple que de tester un énorme bloc de code. En cas d'erreur, on sait où chercher.
5. Abstraction : Une fois qu'une fonction est écrite, on n'a plus besoin de savoir comment elle fonctionne en interne, seulement ce qu'elle fait et comment l'utiliser.

Les fonctions sont la pierre angulaire de tout programme bien conçu.

Une liste est une collection ordonnée et modifiable d'éléments. Les éléments d'une liste peuvent être de n'importe quel type (nombres, chaînes de caractères, booléens, et même d'autres listes) et peuvent être de types différents au sein de la même liste.

Création et initialisation : Les listes sont définies en plaçant les éléments entre crochets [], séparés par des virgules.

ma_liste_vide = [] # Une liste vide
nombres = [1, 2, 3, 4, 5]
fruits = ["pomme", "banane", "orange"]
melange = [10, "texte", True, 3.14]

Accès aux éléments (indexation) : Chaque élément d'une liste a un index (une position) qui commence à 0 pour le premier élément.

fruits = ["pomme", "banane", "orange"]

print(fruits[0]) # Affiche "pomme" (le premier élément)
print(fruits[1]) # Affiche "banane"
print(fruits[2]) # Affiche "orange"

# Index négatifs : -1 pour le dernier, -2 pour l'avant-dernier, etc.
print(fruits[-1]) # Affiche "orange"
print(fruits[-2]) # Affiche "banane"

Si vous essayez d'accéder à un index qui n'existe pas, vous obtiendrez une erreur IndexError.

Listes mutables : Les listes sont dites mutables, ce qui signifie que vous pouvez modifier, ajouter ou supprimer des éléments après leur création.

nombres = [1, 2, 3]
nombres[0] = 10 # Modifie le premier élément
print(nombres)  # Affiche [10, 2, 3]

Python offre de nombreuses méthodes (fonctions spécifiques aux objets) pour manipuler les listes.

Ajout d'éléments :

• append(element) : Ajoute un élément à la fin de la liste.

  fruits = ["pomme", "banane"]
  fruits.append("cerise")
  print(fruits) # Affiche ["pomme", "banane", "cerise"]
  

• insert(index, element) : Insère un élément à une position spécifique.

  fruits.insert(1, "kiwi") # Insère "kiwi" à l'index 1
  print(fruits) # Affiche ["pomme", "kiwi", "banane", "cerise"]
  

Suppression d'éléments :

• remove(valeur) : Supprime la première occurrence d'une valeur spécifiée.

  fruits.remove("banane")
  print(fruits) # Affiche ["pomme", "kiwi", "cerise"]
  

• pop(index) : Supprime l'élément à l'index donné et le renvoie. Si aucun index n'est donné, supprime et renvoie le dernier élément.

  fruit_supprime = fruits.pop(0) # Supprime "pomme" (index 0)
  print(fruit_supprime) # Affiche "pomme"
  print(fruits)         # Affiche ["kiwi", "cerise"]
  

• del (instruction) : Supprime un élément par son index ou une tranche de la liste.

  del fruits[0] # Supprime "kiwi"
  print(fruits) # Affiche ["cerise"]
  

• clear() : Supprime tous les éléments de la liste.

  fruits.clear()
  print(fruits) # Affiche []
  

Modification d'éléments : Comme vu précédemment, on modifie un élément en utilisant son index :

nombres = [1, 2, 3]
nombres[1] = 20
print(nombres) # Affiche [1, 20, 3]

Longueur d'une liste (len()) : La fonction len() renvoie le nombre d'éléments dans une liste.

ma_liste = [10, 20, 30, 40]
print(len(ma_liste)) # Affiche 4

Parcourir une liste signifie accéder à chaque élément de la liste, généralement pour effectuer une opération sur chacun d'eux.

• Boucle for directe sur les éléments : C'est la méthode la plus simple et la plus courante.

  fruits = ["pomme", "banane", "orange"]
  for fruit in fruits:
      print(f"J'aime manger des {fruit}s.")
  

  Ceci affichera :

  J'aime manger des pommes.
  J'aime manger des bananes.
  J'aime manger des oranges.
  

• Boucle for avec index (range(len())) : Utile quand vous avez besoin de l'index de l'élément (par exemple pour modifier l'élément ou accéder à un autre élément par son index).

  notes = [15, 12, 18]
  for i in range(len(notes)):
      print(f"La note à l'index {i} est {notes[i]}.")
      notes[i] = notes[i] + 1 # Augmente chaque note de 1
  print(notes) # Affiche [16, 13, 19]
  

Exemples d'algorithmes simples sur les listes :

• Recherche d'un élément :

  nombres = [4, 8, 2, 10, 5]
  recherche = 10
  trouve = False
  for n in nombres:
      if n == recherche:
          trouve = True
          break # On a trouvé, on peut arrêter la recherche
  if trouve:
      print(f"{recherche} est dans la liste.")
  else:
      print(f"{recherche} n'est pas dans la liste.")
  

• Calcul de la somme des éléments :

  prix = [12.5, 3.0, 7.99]
  somme_totale = 0
  for p in prix:
      somme_totale += p
  print(f"Le total des prix est : {somme_totale}€")
  

Une liste peut contenir d'autres listes. C'est ainsi que l'on peut représenter des structures comme des tableaux à deux dimensions, souvent appelées matrices.

Création et accès :

matrice = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrice[0])     # Affiche la première ligne : [1, 2, 3]
print(matrice[1][1])  # Affiche l'élément à la ligne 1, colonne 1 (index 0-based) : 5
print(matrice[2][0])  # Affiche l'élément à la ligne 2, colonne 0 : 7

Pour accéder à un élément, on utilise une double indexation : matrice[ligne][colonne].

Parcours de matrices : Pour parcourir tous les éléments d'une matrice, on utilise des boucles imbriquées (une boucle dans une autre).

for ligne in matrice:
    for element in ligne:
        print(element, end=" ") # end=" " pour afficher sur la même ligne
    print() # Pour passer à la ligne suivante après chaque ligne de la matrice

Ceci affichera :

1 2 3
4 5 6
7 8 9

Applications simples : Les listes de listes sont utilisées pour représenter :

• Des grilles de jeu (morceau de papier, Sudoku).
• Des images (chaque élément est un pixel).
• Des données tabulaires.

La fonction input() permet de demander à l'utilisateur de saisir des informations au clavier.

Syntaxe :

variable = input("Message d'invite : ")

• Le message d'invite est le texte affiché à l'utilisateur pour lui indiquer ce qu'il doit saisir.
• La fonction input() renvoie toujours la saisie de l'utilisateur sous forme de chaîne de caractères (str).

nom = input("Quel est votre nom ? ")
print(f"Bonjour, {nom} !")

Conversion de type : Comme input() renvoie toujours une chaîne, si vous attendez un nombre, vous devez le convertir.

• int() : Convertit une chaîne en entier.
• float() : Convertit une chaîne en nombre flottant.

age_str = input("Quel est votre âge ? ")
age_int = int(age_str) # Convertit la chaîne en entier
print(f"Dans 5 ans, vous aurez {age_int + 5} ans.")

prix_str = input("Entrez un prix : ")
prix_float = float(prix_str)
print(f"Le prix avec TVA (20%) est : {prix_float * 1.2:.2f}€") # .2f pour 2 décimales

Gestion des erreurs de saisie : Si l'utilisateur saisit du texte alors qu'un nombre est attendu, une erreur se produira (par exemple ValueError). Pour des programmes plus robustes, il faut gérer ces erreurs, par exemple avec des boucles while et des blocs try-except (concept avancé pour la Seconde, mais bon à savoir).

# Exemple simple de gestion d'erreur (avancé pour Seconde)
# while True:
#     try:
#         nombre = int(input("Entrez un nombre entier : "))
#         break # Sort de la boucle si la conversion réussit
#     except ValueError:
#         print("Saisie invalide. Veuillez entrer un nombre entier.")
# print(f"Le nombre saisi est : {nombre}")

La fonction print() est utilisée pour afficher des informations à l'utilisateur. Pour rendre ces informations claires et lisibles, on peut utiliser différentes techniques de formatage.

• Affichage simple :

  print("Bonjour")
  print("Le résultat est :", 10 + 5) # print gère l'affichage de plusieurs types
  

• Concaténation de chaînes (avec +) : Fonctionne uniquement avec des chaînes de caractères.

  prenom = "Marie"
  nom = "Curie"
  print("Nom complet : " + prenom + " " + nom)
  

  Si vous voulez combiner des nombres et des chaînes, vous devez convertir les nombres en chaînes avec str().

  age = 30
  print("J'ai " + str(age) + " ans.")
  

• Formatage avec f-strings (chaînes formatées) : C'est la méthode la plus moderne et la plus recommandée en Python 3.6+. Elles sont simples et puissantes. Vous préfixez la chaîne avec f ou F, et vous pouvez inclure des expressions Python entre accolades {}.

  produit = "Ordinateur"
  prix = 1200.50
  stock = 5
  
  print(f"Le {produit} coûte {prix}€ et il reste {stock} unités.")
  print(f"Prix total pour 2 unités : {prix * 2}€")
  print(f"Prix avec TVA (20%) : {prix * 1.2:.2f}€") # .2f formate à 2 décimales
  

Lire des fichiers permet à votre programme de traiter des données qui ne sont pas saisies directement par l'utilisateur, mais stockées sur le disque.

Étapes pour lire un fichier :

1. Ouvrir le fichier avec la fonction open().
2. Lire son contenu.
3. Fermer le fichier.

Fonction open() : open(nom_du_fichier, mode)

• nom_du_fichier : le chemin vers le fichier (ex: "donnees.txt").
• mode :
  • 'r' : mode lecture (read). C'est le mode par défaut.
  • 'w' : mode écriture (write). Crée le fichier s'il n'existe pas, ou écrase son contenu s'il existe.
  • 'a' : mode ajout (append). Crée le fichier s'il n'existe pas, ou ajoute à la fin s'il existe.

Lecture ligne par ligne : Le plus courant est de lire un fichier ligne par ligne, souvent avec une boucle for.

# Supposons que 'mon_fichier.txt' contient :
# Ligne 1
# Ligne 2
# Ligne 3

try: # Utiliser try-except pour gérer les erreurs si le fichier n'existe pas
    with open("mon_fichier.txt", "r") as fichier: # 'with' assure la fermeture automatique
        for ligne in fichier:
            print(ligne.strip()) # .strip() enlève les espaces et retours chariot en début/fin de ligne
except FileNotFoundError:
    print("Le fichier 'mon_fichier.txt' n'a pas été trouvé.")

• La clause with open(...) as fichier: est la meilleure pratique car elle garantit que le fichier est automatiquement fermé, même en cas d'erreur.
• fichier est l'objet fichier qui permet de lire.
• readline() : lit une seule ligne à la fois.
• readlines() : lit toutes les lignes et les renvoie sous forme de liste de chaînes.
• read() : lit tout le contenu du fichier comme une seule chaîne.

Fermeture du fichier : Si vous n'utilisez pas with, vous devez explicitement fermer le fichier avec fichier.close() pour libérer les ressources.

# Exemple sans 'with' (moins recommandé)
# fichier = open("mon_fichier.txt", "r")
# contenu = fichier.read()
# print(contenu)
# fichier.close() # TRÈS IMPORTANT !

Écrire dans des fichiers permet à votre programme de sauvegarder des données de manière persistante.

Étapes pour écrire un fichier :

1. Ouvrir le fichier avec open() en mode écriture ou ajout.
2. Écrire le contenu.
3. Fermer le fichier.

Mode d'écriture ('w') :

• Si le fichier n'existe pas, il est créé.
• Si le fichier existe, son contenu est entièrement effacé avant d'écrire.

message = "Bonjour, ceci est la première ligne.\n"
message += "Ceci est la deuxième ligne."

with open("nouveau_fichier.txt", "w") as fichier:
    fichier.write(message) # Écrit la chaîne dans le fichier
    fichier.write("\nUne autre ligne.") # Ajoute une ligne (il faut ajouter le \n)

print("Fichier 'nouveau_fichier.txt' créé et écrit.")

Mode d'ajout ('a') :

• Si le fichier n'existe pas, il est créé.
• Si le fichier existe, le nouveau contenu est ajouté à la fin sans effacer l'existant.

with open("nouveau_fichier.txt", "a") as fichier:
    fichier.write("\nCeci est ajouté à la fin.")

print("Contenu ajouté au fichier.")

Gestion des erreurs : L'écriture peut aussi échouer (disque plein, permissions insuffisantes). L'utilisation de try-except est également recommandée ici.

Ces bases de l'algorithmique et de la programmation en Python vous donnent les outils nécessaires pour commencer à résoudre des problèmes et à créer vos propres programmes !