Traitement des données : programmation

La programmation est l'art et la science de donner des instructions à un ordinateur pour qu'il exécute des tâches spécifiques. Un ordinateur ne comprend que le langage binaire (des 0 et des 1), mais les humains écrivent des instructions dans des langages de programmation plus compréhensibles.

Un programme est un ensemble d'instructions logiques et ordonnées, écrites dans un langage de programmation, que l'ordinateur peut comprendre et exécuter pour réaliser une tâche donnée. C'est comme une recette de cuisine pour l'ordinateur.

Un algorithme est la séquence logique et finie d'étapes à suivre pour résoudre un problème ou accomplir une tâche. C'est la "recette" abstraite, indépendante de tout langage de programmation. Le code est la traduction de cet algorithme dans un langage de programmation spécifique.

Il existe de nombreux langages de programmation, chacun avec ses spécificités et ses domaines d'application. Pour ce cours, nous utiliserons Python, un langage populaire pour sa simplicité, sa lisibilité et sa polyvalence. Python est utilisé dans le développement web, l'intelligence artificielle, l'analyse de données, etc.

En programmation, les données sont classées en différents types pour que l'ordinateur sache comment les stocker et les manipuler. Voici les types de données les plus courants en Python :

• Nombres entiers (int) : Ce sont des nombres sans partie décimale, positifs ou négatifs.
  • Exemples : 5, -10, 0, 1000
• Nombres flottants (float) : Ce sont des nombres à virgule, avec une partie décimale.
  • Exemples : 3.14, -0.5, 2.0 (même si c'est un entier, la présence du .0 en fait un float)
• Chaînes de caractères (str) : Ce sont des séquences de caractères (lettres, chiffres, symboles) entourées de guillemets simples '' ou doubles "".
  • Exemples : 'bonjour', "Python", '123' (ce n'est pas un nombre, c'est une suite de caractères)
• Booléens (bool) : Ce sont des valeurs logiques qui représentent soit le vrai, soit le faux. Il n'y a que deux valeurs possibles : True (vrai) ou False (faux). Ils sont très utilisés pour les conditions.
  • Exemples : True, False

Comprendre les types de données est crucial car ils déterminent quelles opérations peuvent être effectuées sur les valeurs.

En programmation, une variable est un conteneur nommé qui permet de stocker une valeur. Imaginez une boîte avec une étiquette : l'étiquette est le nom de la variable, et la boîte contient une donnée.

La déclaration de variables en Python est implicite : on n'a pas besoin de spécifier le type de la variable avant de l'utiliser. Il suffit de lui affecter une valeur.

L'opérateur d'affectation est le signe égal =. Il permet d'attribuer une valeur à une variable.

age = 17          # 'age' est une variable de type int
nom = "Alice"     # 'nom' est une variable de type str
taille = 1.75     # 'taille' est une variable de type float
est_etudiant = True # 'est_etudiant' est une variable de type bool

Le nom des variables doit être significatif pour rendre le code plus lisible.

Les règles pour le nommage des variables en Python sont :

• Elles doivent commencer par une lettre ou un underscore _.
• Elles ne peuvent contenir que des lettres, des chiffres et des underscores.
• Elles sont sensibles à la casse ( Age est différent de age).
• Il est recommandé d'utiliser des noms en minuscules avec des underscores pour séparer les mots (snake_case), par exemple nombre_eleves.

Les opérateurs sont des symboles spéciaux qui effectuent des opérations sur des valeurs (appelées opérandes).

Opérateurs arithmétiques

Ils sont utilisés pour les calculs mathématiques :

L'opérateur modulo (%) donne le reste d'une division entière. C'est très utile pour vérifier si un nombre est pair (reste 0 à la division par 2) ou pour des opérations cycliques.

Opérateurs de comparaison

Ils sont utilisés pour comparer des valeurs et renvoient un booléen (True ou False).

Opérateurs logiques

Ils combinent des expressions booléennes et renvoient également un booléen.

• and (ET logique) : Renvoie True si toutes les conditions sont True.
  • Exemple : (5 > 3) and (10 < 20) est True
• or (OU logique) : Renvoie True si au moins une des conditions est True.
  • Exemple : (5 == 3) or (10 < 20) est True
• not (NON logique) : Inverse la valeur booléenne.
  • Exemple : not (5 > 3) est False

Les instructions conditionnelles permettent d'exécuter un bloc de code seulement si une certaine condition est vraie.

La syntaxe if/elif/else en Python est la suivante :

if condition1:
    # Bloc de code exécuté si condition1 est True
elif condition2: # elif est l'abréviation de "else if"
    # Bloc de code exécuté si condition1 est False ET condition2 est True
else:
    # Bloc de code exécuté si toutes les conditions précédentes sont False

• if : C'est le début de la structure conditionnelle.
• elif : Optionnel, permet de tester d'autres conditions si la précédente était fausse. Il peut y en avoir plusieurs.
• else : Optionnel, s'exécute si aucune des conditions if ou elif n'était vraie.

L'indentation est cruciale en Python ! Elle définit les blocs de code. Toutes les lignes d'un même bloc (sous un if, elif, else) doivent avoir la même indentation (généralement 4 espaces).

temp = 25

if temp > 30:
    print("Il fait très chaud !")
elif temp > 20: # temp n'est pas > 30, mais est > 20
    print("Il fait bon.")
else:
    print("Il fait frais.")

# Output: Il fait bon.

On peut avoir des conditions multiples en utilisant les opérateurs logiques (and, or, not).

age = 18
permis = True

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

Les boucles bornées (ou boucles for) sont utilisées lorsque l'on sait à l'avance combien de fois on veut répéter un bloc de code, généralement en itérant sur une séquence (comme une liste de nombres ou une chaîne de caractères).

La syntaxe générale est :

for element in sequence:
    # Bloc de code exécuté pour chaque 'element' de la 'sequence'

Exemple d'itération sur une chaîne de caractères :

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

# Output:
# P
# y
# t
# h
# o
# n

La fonction range() est très souvent utilisée avec les boucles for pour générer une séquence de nombres.

• range(n) : génère des nombres de 0 à n-1.
• range(debut, fin) : génère des nombres de debut à fin-1.
• range(debut, fin, pas) : génère des nombres de debut à fin-1 avec un certain pas.

for i in range(5): # i prendra les valeurs 0, 1, 2, 3, 4
    print(f"Numéro : {i}")

# Output:
# Numéro : 0
# Numéro : 1
# Numéro : 2
# Numéro : 3
# Numéro : 4

Les boucles non bornées (ou boucles while) sont utilisées lorsque l'on ne connaît pas à l'avance le nombre de répétitions. Le bloc de code est répété tant qu'une certaine condition est vraie.

La syntaxe while est la suivante :

while condition:
    # Bloc de code exécuté tant que la condition est True

Il est essentiel que la condition de sortie devienne False à un moment donné, sinon la boucle ne s'arrêtera jamais et deviendra une boucle infinie.

compteur = 0
while compteur < 3:
    print(f"Compteur : {compteur}")
    compteur = compteur + 1 # Incrémentation pour s'assurer que la condition deviendra False

# Output:
# Compteur : 0
# Compteur : 1
# Compteur : 2

Exemple de boucle infinie (à éviter) :

# while True:
#     print("Ceci est une boucle infinie ! Appuyez sur Ctrl+C pour l'arrêter.")

Une fonction est définie en Python à l'aide du mot-clé def, suivi du nom de la fonction, de parenthèses () qui peuvent contenir des paramètres, et d'un double point :. Le corps de la fonction est indenté.

La définition d'une fonction ressemble à ceci :

def nom_de_la_fonction(parametre1, parametre2):
    """Docstring: Explique ce que fait la fonction."""
    # Corps de la fonction
    resultat = parametre1 + parametre2
    return resultat # Renvoie une valeur (optionnel)

• def : Mot-clé pour définir une fonction.
• nom_de_la_fonction : Un nom significatif pour la fonction.
• Paramètres : Des variables listées entre parenthèses qui recevront des valeurs lors de l'appel de la fonction.
• return : Mot-clé optionnel pour renvoyer une valeur au code qui a appelé la fonction. Si return n'est pas utilisé, la fonction renvoie implicitement None.

Pour appeler une fonction, il suffit d'utiliser son nom suivi de parenthèses, en passant les arguments (les valeurs concrètes) pour les paramètres.

def saluer(nom):
    print(f"Bonjour, {nom} !")

def ajouter(a, b):
    somme = a + b
    return somme

saluer("Alice") # Appel de la fonction saluer avec "Alice" comme argument
# Output: Bonjour, Alice !

resultat_addition = ajouter(5, 3) # Appel de la fonction ajouter
print(f"La somme est : {resultat_addition}")
# Output: La somme est : 8

La portée d'une variable détermine où elle est accessible dans le programme.

• Variables locales : Définies à l'intérieur d'une fonction. Elles ne sont accessibles qu'à l'intérieur de cette fonction. Elles sont créées lorsque la fonction est appelée et détruites lorsque la fonction se termine.

  def ma_fonction():
      x = 10 # x est une variable locale
      print(x)
  
  ma_fonction() # Output: 10
  # print(x) # Erreur: NameError, x n'est pas défini en dehors de la fonction
  

• Variables globales : Définies en dehors de toute fonction, au niveau principal du script. Elles sont accessibles 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) # On peut accéder à y
  
  autre_fonction() # Output: 20
  print(y)       # Output: 20
  

Il est généralement préférable d'éviter de modifier des variables globales à l'intérieur des fonctions pour éviter les effets de bord inattendus et rendre le code plus difficile à déboguer. Les fonctions devraient idéalement communiquer via leurs paramètres et leurs valeurs de retour.

La modularité est le principe de diviser un programme complexe en parties plus petites, indépendantes et gérables, appelées modules ou fonctions.

Les fonctions favorisent la modularité en permettant la décomposition d'un problème en sous-problèmes plus simples. Chaque fonction résout un petit aspect du problème global.

Les avantages des fonctions sont nombreux :

• Réutilisation du code : Une fonction écrite une fois peut être appelée plusieurs fois, évitant la duplication de code.
• Lisibilité : Le code est plus facile à lire et à comprendre car il est organisé en blocs logiques.
• Maintenance : Il est plus facile de trouver et de corriger les erreurs dans une petite fonction que dans un long bloc de code.
• Collaboration : Plusieurs développeurs peuvent travailler sur différentes fonctions simultanément.

La documentation des fonctions est une bonne pratique. On utilise des "docstrings" (chaînes de caractères multilignes juste après la définition de la fonction) pour expliquer ce que fait la fonction, ses paramètres et ce qu'elle retourne.

def calculer_surface_rectangle(longueur, largeur):
    """
    Calcule la surface d'un rectangle.

    Args:
        longueur (float): La longueur du rectangle.
        largeur (float): La largeur du rectangle.

    Returns:
        float: La surface du rectangle.
    """
    surface = longueur * largeur
    return surface

Une chaîne de caractères (str) est une séquence ordonnée de caractères.

• Accès aux caractères (indexation) : Chaque caractère d'une chaîne a un index (position) commençant à 0 pour le premier caractère.

  message = "Bonjour"
  print(message[0]) # Output: B (premier caractère)
  print(message[4]) # Output: o (cinquième caractère)
  print(message[-1])# Output: r (dernier caractère, indexation négative)
  

• Tranches (slicing) : Permet d'extraire une sous-partie d'une chaîne. La syntaxe est [debut:fin:pas]. L'élément à l'index fin n'est pas inclus.

  chaine = "Programmation"
  print(chaine[0:5])   # Output: Progr (du début jusqu'à l'index 4)
  print(chaine[5:])    # Output: ammation (de l'index 5 jusqu'à la fin)
  print(chaine[:4])    # Output: Prog (du début jusqu'à l'index 3)
  print(chaine[::2])   # Output: Pormtn (tous les deux caractères)
  print(chaine[::-1])  # Output: noitammargorP (chaîne inversée)
  

• Méthodes de chaînes : Les chaînes ont de nombreuses méthodes utiles :

  • len(chaine) : Renvoie la longueur de la chaîne.
  • chaine.upper() : Renvoie la chaîne en majuscules.
  • chaine.lower() : Renvoie la chaîne en minuscules.
  • chaine.find(sous_chaine) : Renvoie l'index de la première occurrence de la sous-chaîne, ou -1 si non trouvée.
  • chaine.replace(ancien, nouveau) : Remplace toutes les occurrences d'une sous-chaîne par une autre.

Une liste est une collection ordonnée et mutable (modifiable) d'éléments. Les éléments peuvent être de types différents. Elles sont définies par des crochets [].

• Création et modification de listes :

  ma_liste = [10, "pomme", 3.14, True]
  print(ma_liste) # Output: [10, 'pomme', 3.14, True]
  
  # Modification d'un élément
  ma_liste[1] = "orange"
  print(ma_liste) # Output: [10, 'orange', 3.14, True]
  

• Accès aux éléments (indexation) : Comme pour les chaînes, on utilise les index.

  nombres = [1, 2, 3, 4, 5]
  print(nombres[0])  # Output: 1
  print(nombres[-1]) # Output: 5
  

• Méthodes de listes :

  • len(liste) : Renvoie le nombre d'éléments dans la liste.
  • liste.append(element) : Ajoute un élément à la fin de la liste.
  • liste.insert(index, element) : Insère un élément à un index spécifique.
  • liste.pop(index) : Supprime et renvoie l'élément à l'index donné (le dernier si aucun index).
  • liste.remove(valeur) : Supprime la première occurrence de la valeur spécifiée.
  • liste.sort() : Trie la liste sur place (modifie la liste originale).
  • sorted(liste) : Renvoie une nouvelle liste triée sans modifier l'originale.

  fruits = ["banane", "pomme"]
  fruits.append("cerise")
  print(fruits) # Output: ['banane', 'pomme', 'cerise']
  
  fruits.sort()
  print(fruits) # Output: ['banane', 'cerise', 'pomme']
  

Un tuple est une collection ordonnée et immuable (non modifiable) d'éléments. Ils sont définis par des parenthèses ().

• Définition et immutabilité : Une fois créé, les éléments d'un tuple ne peuvent pas être modifiés, ajoutés ou supprimés.

  mon_tuple = (1, "deux", 3.0)
  print(mon_tuple) # Output: (1, 'deux', 3.0)
  
  # mon_tuple[0] = 5 # Erreur: TypeError: 'tuple' object does not support item assignment
  

• Cas d'utilisation :

  • Lorsque vous voulez vous assurer que les données ne seront pas accidentellement modifiées.
  • Pour retourner plusieurs valeurs d'une fonction.
  • Comme clés dans un dictionnaire (les listes ne peuvent pas l'être car elles sont mutables).

• Comparaison avec les listes :

  Caractéristique	Liste (List)	Tuple (Tuple)
  Mutabilité	Mutable (modifiable)	Immutable (non modifiable)
  Syntaxe	[]	()
  Performance	Légèrement moins rapide pour l'accès	Généralement plus rapide pour l'accès
  Utilisation	Collections d'éléments homogènes ou hétérogènes qui peuvent changer	Collections d'éléments hétérogènes dont la structure est fixe

Il existe plusieurs façons de parcourir (itérer sur) les éléments d'une séquence (chaîne, liste, tuple).

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

  prenoms = ["Alice", "Bob", "Charlie"]
  for p in prenoms:
      print(f"Bonjour {p}")
  

• Boucle for avec index : Si vous avez besoin de l'index de chaque élément, utilisez range(len(sequence)) ou la fonction enumerate().

  for i in range(len(prenoms)):
      print(f"L'index {i} contient {prenoms[i]}")
  
  # Avec enumerate() (plus pythonique)
  for index, prenom in enumerate(prenoms):
      print(f"L'index {index} contient {prenom}")
  

• Compréhension de listes (introduction) : Une manière concise de créer des listes. Elle permet de construire une nouvelle liste en appliquant une expression à chaque élément d'une séquence existante.

  nombres = [1, 2, 3, 4, 5]
  carres = [n * n for n in nombres] # Crée une nouvelle liste avec les carrés
  print(carres) # Output: [1, 4, 9, 16, 25]
  
  pairs = [n for n in nombres if n % 2 == 0] # Avec une condition
  print(pairs) # Output: [2, 4]
  

  La compréhension de listes est une fonctionnalité puissante et compacte de Python.

Les programmes ont souvent besoin de lire des données à partir de fichiers ou d'écrire des résultats dans des fichiers.

Ouverture et fermeture de fichiers

Pour manipuler un fichier, il faut d'abord l'ouvrir avec la fonction open().

open(nom_du_fichier, mode)

• nom_du_fichier : Le chemin vers le fichier (ex: 'mon_fichier.txt').
• mode : Spécifie l'opération que l'on souhaite faire.
  • 'r' (read) : Lecture seule (le fichier doit exister). C'est le mode par défaut.
  • 'w' (write) : Écriture (crée le fichier s'il n'existe pas, écrase son contenu s'il existe).
  • 'a' (append) : Ajout (crée le fichier s'il n'existe pas, ajoute le contenu à la fin s'il existe).

Après avoir opéré sur le fichier, il est crucial de le fermer avec la méthode .close(). Cela libère les ressources et assure que toutes les écritures sont bien enregistrées.

# Créez un fichier "exemple.txt" avec du texte dedans pour tester
# Contenu de exemple.txt :
# Ligne 1
# Ligne 2

fichier = open('exemple.txt', 'r')
contenu = fichier.read() # Lit tout le contenu du fichier
print(contenu)
fichier.close()

fichier_ecriture = open('nouveau_fichier.txt', 'w')
fichier_ecriture.write("Ceci est la première ligne.\n")
fichier_ecriture.write("Ceci est la deuxième ligne.")
fichier_ecriture.close()

Utilisation de with open(...) (recommandé)

Le mot-clé with est la méthode préférée pour travailler avec des fichiers car il garantit que le fichier est automatiquement fermé, même en cas d'erreur.

with open('exemple.txt', 'r') as f:
    contenu = f.read()
    print(contenu)
# Le fichier est automatiquement fermé ici, même s'il y a une erreur

Après avoir lu le contenu d'un fichier, on doit souvent le traiter.

• Lecture ligne par ligne : C'est souvent plus efficace pour les grands fichiers.

  • f.readline() : Lit une seule ligne.
  • f.readlines() : Lit toutes les lignes et les renvoie sous forme de liste de chaînes.
  • Itération directe sur l'objet fichier (le plus courant) :

  with open('exemple.txt', 'r') as f:
      for ligne in f:
          print(ligne.strip()) # .strip() supprime les espaces blancs (y compris le saut de ligne \n)
  

• Séparation des données (split) : Si chaque ligne contient plusieurs informations séparées par un caractère (comme une virgule ou un point-virgule), la méthode .split() est très utile.

  ligne_csv = "Nom,Age,Ville"
  parties = ligne_csv.split(',') # Sépare la chaîne par la virgule
  print(parties) # Output: ['Nom', 'Age', 'Ville']
  

• Conversion de types : Les données lues à partir de fichiers sont toujours des chaînes de caractères. Il faut les convertir si on veut faire des opérations numériques.

  nombre_str = "123"
  nombre_int = int(nombre_str)
  print(nombre_int + 1) # Output: 124 (opération numérique possible)
  
  prix_str = "19.99"
  prix_float = float(prix_str)
  print(prix_float * 2) # Output: 39.98
  

Les exceptions sont des événements qui perturbent le déroulement normal d'un programme. Une bonne gestion des exceptions rend un programme plus robuste.

Le bloc try-except permet de "tenter" d'exécuter un code et de "capturer" les erreurs si elles se produisent.

try:
    # Bloc de code où une erreur pourrait survenir
    resultat = 10 / 0 # Ceci va provoquer une erreur de division par zéro
except ZeroDivisionError:
    # Bloc de code exécuté si une ZeroDivisionError se produit
    print("Erreur : Division par zéro impossible !")
except ValueError:
    # Bloc de code exécuté si une ValueError se produit
    print("Erreur : Problème de valeur.")
except Exception as e: # Capture tout autre type d'erreur
    print(f"Une erreur inattendue s'est produite : {e}")
else:
    # Bloc de code exécuté si aucune exception n'a été levée dans le try
    print("L'opération s'est déroulée sans erreur.")
finally:
    # Bloc de code toujours exécuté, qu'il y ait eu une erreur ou non
    print("Fin de l'opération (avec ou sans erreur).")

Types d'erreurs courants

• ZeroDivisionError : Tentative de diviser par zéro.
• FileNotFoundError : Tentative d'ouvrir un fichier qui n'existe pas.
• ValueError : Une fonction reçoit un argument de type correct mais de valeur inappropriée (ex: int("abc")).
• TypeError : Une opération ou fonction est appliquée à un objet de type inapproprié (ex: 10 + "texte").
• IndexError : Tentative d'accéder à un index hors des limites d'une séquence.
• NameError : Tentative d'utiliser une variable ou une fonction non définie.

La gestion des exceptions permet à votre programme de ne pas "planter" et de donner des messages d'erreur utiles à l'utilisateur. C'est une pratique essentielle pour les applications réelles.