Rappel sur Python et Fonctions

Objectifs

Évaluer le niveau des étudiants via un quizz.
Revoir les bases de Python (variables, types, structures de contrôle, boucles).
Approfondir les fonctions en Python : définition, paramètres, portée des variables.
Introduire la récursivité et les algorithmes de tri simples.

Quizz

Le quizz est disponible ici.

Rappel sur Python

Variables et types de données

Python est un langage dynamiquement typé. Les variables sont créées par simple assignation sans déclaration préalable. Les principaux types sont :

int : entiers
float : nombres décimaux
str : chaînes de caractères
bool : booléens (True ou False)
list, dict, tuple, set : collections
Structures de contrôle

Les conditions permettent d’exécuter du code selon une logique :

if condition:
    # code exécuté si True
elif autre_condition:
    # code exécuté si autre_condition est True
else:
    # code exécuté sinon

Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés pour comparer des valeurs :

== : égal à
!= : différent de
> : supérieur à
< : inférieur à
>= : supérieur ou égal à
<= : inférieur ou égal à

Exemple d’utilisation :

a = 5
b = 10

if a == b:
    print("a est égal à b")
elif a != b:
    print("a est différent de b")
if a < b:
    print("a est inférieur à b")

Boucles

Boucle for : itère sur une séquence (liste, chaîne, range, etc.)

for i in range(5):
    print(i)

Boucle while : exécute le code tant que la condition est vraie

while condition:
    # code exécuté

Syntaxe générale

Python utilise l’indentation pour délimiter les blocs de code (à la place des accolades). Les lignes se terminent sans point-virgule. Les commentaires commencent par #.

Exemple de programme

Voici un exemple de programme simple qui affiche “Hello BTS CIEL” :

print("Hello BTS CIEL")

Fonctions en Python

1. Pourquoi utiliser des fonctions ?

Exemple sans fonction

temp1 = 20
temp2 = 25
# Conversion Celsius → Fahrenheit
print(temp1 * 9/5 + 32)
print(temp2 * 9/5 + 32)

Problème : répétition du même calcul.

Exemple avec fonction

def celsius_vers_fahrenheit(temp):
    return temp * 9/5 + 32

print(celsius_vers_fahrenheit(20))
print(celsius_vers_fahrenheit(25))

Objectifs :

éviter les répétitions
rendre le code plus lisible
découper un problème en sous-problèmes

carre(3)  # 9
carre(2)  # 4

2. Écrire sa première fonction

Syntaxe de base

def nom_fonction(parametre):
    instruction
    return valeur

le return renvoie un résultat
sans return → la fonction renvoie None

Exercice 1

Écrire une fonction carre(nombre) qui retourne le carré d’un nombre.

3. Fonctions avec plusieurs paramètres

def moyenne(a, b):
    return (a + b) / 2

Exercice 2

Écrire une fonction convertir_temp(valeur, unite) :

"C" → retourne la valeur
"F" → retourne la valeur convertie en Fahrenheit

4. Paramètres par défaut

Un paramètre par défaut possède une valeur utilisée si aucun argument n’est fourni lors de l’appel de la fonction.

Cela permet :

de rendre une fonction plus simple à utiliser
d’éviter de répéter des valeurs courantes
d’avoir des comportements par défaut cohérents

Exemple

def seuil_alerte(valeur, seuil=50):
    return valeur > seuil

print(seuil_alerte(40))          # False
print(seuil_alerte(60))          # True
print(seuil_alerte(60, seuil=55))# True

Ici :

seuil vaut 50 par défaut
l’appel peut rester simple dans la majorité des cas
on peut modifier le comportement si nécessaire

Les paramètres avec valeur par défaut doivent être placés à droite dans la définition de la fonction.

Exercice 3

Objectif : manipuler les paramètres optionnels.

Écrire une fonction convertir_temperature(temp, unite="C") qui :

si unite == "C" retourne la température en Celsius
si unite == "F" retourne la température convertie en Fahrenheit

Formule :

F = C × 9/5 + 32

Exemples attendus :

convertir_temperature(20)        # 20
convertir_temperature(20, "F")   # 68

5. Portée des variables : locale vs globale

La portée (ou scope) d’une variable détermine où elle peut être utilisée dans le code.

Variables locales

Une variable définie dans une fonction n’existe que dans cette fonction :

def calculer():
    resultat = 10 * 2
    return resultat

print(calculer())  # 20
print(resultat)    # Erreur : resultat n'existe pas ici

Variables globales

Une variable définie en dehors des fonctions est globale et accessible partout :

seuil = 50

def depasse(valeur):
    return valeur > seuil  # seuil est accessible

print(depasse(60))  # True

Utiliser des variables globales dans les fonctions rend le code difficile à comprendre et peut causer des bugs.

Bonne pratique

Passer toutes les informations nécessaires en paramètres :

def depasse(valeur, seuil):
    return valeur > seuil

print(depasse(60, 50))  # True

Avantages :

La fonction est claire et prévisible
Facile à tester
Pas de dépendances cachées

Bug classique : modification d’une variable globale

unite = "C"

def afficher_temperature(valeur):
    return str(valeur) + " " + unite

print(afficher_temperature(25))

Questions :

D’où vient la variable unite ?
Peut-on comprendre la fonction sans lire tout le programme ?

Problèmes:

La fonction dépend d’une variable extérieure
Le comportement peut changer sans modifier la fonction

Le bug apparaît lors d’une modification :

unite = "F"
print(afficher_temperature(25))

La fonction n’a pas changé mais son comportement oui

Une fonction ne doit pas dépendre de variables définies ailleurs. Toutes les informations nécessaires doivent être passées en paramètres

def afficher_temperature(valeur, unite):
    return str(valeur) + " " + unite

print(afficher_temperature(25, "C"))
print(afficher_temperature(25, "F"))

La fonction est maintenant claire,prévisible et réutilisable.

Un autre bug : tentative de modification d’une variable globale

total_mesures = 0

def ajouter_mesure(valeur):
    total_mesures = total_mesures + valeur

Erreur à l’exécution UnboundLocalError: local variable 'total_mesures' referenced before assignment

Python considère total_mesures comme une variable locale à la fonction. Elle est utilisée avant d’être définie dans ce contexte.

Mauvaise solution (à éviter)

total_mesures = 0

def ajouter_mesure(valeur):
    global total_mesures
    total_mesures += valeur

Problèmes:

Ça fonctionne, mais le comportement est caché et dépend d’une variable globale.
Le code devient difficile à déboguer et à tester.
Risque d’effets de bord imprévisibles.

Bonne solution

def ajouter_mesure(total, valeur):
    return total + valeur

total_mesures = ajouter_mesure(total_mesures, 10)

Avantages :

Pas de variable globale.
Fonction testable et réutilisable.
Pas d’effet de bord.

Exercice 4 – Analyse de bug

Ce programme contient un problème de conception. Explique le problème et corrige-le.

etat = "OK"

def verifier(valeur):
    if valeur > 80:
        etat = "ALERTE"
    return etat

Exercice 5 – Comprendre la portée des variables

Que va afficher ce code et pourquoi ?

x = 10

def f():
    x = 5
    return x

print(f())
print(x)

Exercice 6 – Corriger un bug de portée

Ce code contient une erreur. Identifie le problème et corrige-le :

etat = "OK"

def verifier(valeur):
    if valeur > 80:
        etat = "ALERTE"
    return etat

Introduction à la récursivité

Qu’est-ce que la récursivité ?

La récursivité est une technique où une fonction s’appelle elle-même pour résoudre un problème. Imaginez que vous devez monter un escalier : pour atteindre la dernière marche, vous devez d’abord monter la marche précédente, et ainsi de suite jusqu’à la première marche. La récursivité fonctionne de la même manière : une fonction résout un problème en le divisant en sous-problèmes plus petits et similaires.

Pourquoi utiliser la récursivité ?

Simplicité : Certaines tâches sont plus faciles à décrire avec la récursivité (par exemple, parcourir des dossiers imbriqués).
Élégante : Le code peut être plus court et plus lisible que des boucles complexes.

Comment ça marche ?

Pour qu’une fonction récursive fonctionne, elle doit avoir :

Un cas de base : une condition qui arrête la récursivité (sinon, la fonction s’appellerait à l’infini).
Un cas récursif : la fonction s’appelle elle-même avec un problème plus petit.

Exemple simple : le compte à rebours

def compte_a_rebours(n):
    if n == 0:  # Cas de base : on s’arrête à 0
        print("C’est parti !")
    else:
        print(n)
        compte_a_rebours(n - 1)  # Appel récursif avec n-1

compte_a_rebours(3)

Résultat :

3
2
1
C’est parti !

Explication :

La fonction affiche n, puis s’appelle elle-même avec n-1.
Quand n atteint 0, le cas de base est déclenché et la récursivité s’arrête.

Exemple 2 : Calculer la longueur d’une liste

On compte le nombre d’éléments dans une liste.

def longueur(liste):
    if not liste:  # Cas de base : liste vide
        return 0
    else:
        return 1 + longueur(liste[1:])  # 1 + longueur du reste

print(longueur([10, 20, 30]))  # Résultat : 3

Exercice 7 : Dire bonjour

Écrivez une fonction récursive dire_bonjour(n) qui affiche “Bonjour !” n fois.

Exercice 8 : Compter jusqu’à n

Écrivez une fonction récursive compter_jusqua(n) qui affiche les nombres de 1 à n.

Exercice 9 : Trouver un élément dans une liste

Écrivez une fonction récursive est_present(liste, element) qui vérifie si un élément est dans une liste.

Ne pas oublier le cas de base pour éviter les appels infinis !