Rappel sur Python et fonctions

Objectifs

Revoir les bases du langage Python : variables, types, conditions, boucles.
Se remémorer la logique de programmation structurée.
Comprendre l’intérêt des fonctions et leur rôle dans la modularisation du code.
Introduire la récursivité comme outil de résolution de problèmes simples.

Quizz

Le quizz est disponible ici.

1. Python : syntaxe et types

Python est un langage interprété, typé dynamiquement et très lisible. Les variables sont créées par affectation, sans déclaration préalable.

x = 10
nom = "Alice"
valide = True

Les types principaux sont :

int : nombres entiers
float : nombres décimaux
str : chaînes de caractères
bool : booléens (True / False)
list : listes
tuple : tuples
set : ensembles
dict : dictionnaires

Listes, tuples, ensembles, dictionnaires

list : collection ordonnée, mutable, accepte les doublons.
```
notes = [12, 15, 13]
notes.append(16)
```
tuple : collection ordonnée, immuable.
```
point = (10, 20)
```

set : ensemble non ordonné, sans doublons.

tags = {"python", "sql", "python"}
print(tags)

dict : structure clé → valeur.

etudiant = {"nom": "Ali", "note": 15}
print(etudiant["nom"])

2. Structures de contrôle

Condition `if`

if condition:
    # code exécuté si la condition est vraie
elif autre_condition:
    # code exécuté si la seconde condition est vraie
else:
    # code exécuté sinon

Opérateurs de comparaison

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

Exemple :

a = 5
b = 10

if a < b:
    print("a est plus petit que b")

3. Boucles

Boucle `for`

La boucle for permet d’itérer sur une séquence.

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

Boucle `while`

La boucle while s’exécute tant qu’une condition est vraie.

compteur = 0
while compteur < 3:
    print(compteur)
    compteur += 1

Indentation

Python repose sur l’indentation pour définir les blocs. Une mauvaise indentation provoque une erreur de syntaxe.

4. Pourquoi utiliser des fonctions ?

Une fonction encapsule un calcul ou une logique réutilisable. Elle permet d’éviter la duplication du code et d’améliorer la lisibilité.

Exemple sans fonction

temp1 = 20
temp2 = 25
print(temp1 * 9/5 + 32)
print(temp2 * 9/5 + 32)

Exemple avec fonction

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

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

La seconde version est plus lisible, plus maintenable et plus facilement réutilisable.

5. Définition d’une fonction

def nom_fonction(parametre):
    instruction
    return valeur

def : mot-clé pour définir une fonction
parametre : donnée transmise à la fonction
return : résultat renvoyé par la fonction

Sans return, la fonction renvoie None.

Exemple

def carre(x):
    return x * x

print(carre(3))
print(carre(5))

Fonctions avec plusieurs paramètres

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

print(moyenne(10, 20))

Paramètres par défaut

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

print(seuil_alerte(40))
print(seuil_alerte(60))
print(seuil_alerte(60, 55))

Ici, seuil prend la valeur 50 si aucun autre argument n’est fourni.

Les paramètres avec valeur par défaut doivent être placés après les paramètres obligatoires.

6. Portée des variables (scope)

La portée d’une variable décrit la zone du programme où elle est accessible.

Variable locale

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

print(calculer())

resultat existe uniquement dans la fonction.

Variable globale

seuil = 50

def depasse(valeur):
    return valeur > seuil

print(depasse(60))

Les variables globales peuvent être utilisées, mais elles rendent le code moins explicite et plus fragile.

Bonnes pratiques

Il vaut mieux passer les informations nécessaires en arguments plutôt que de dépendre de variables externes.

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

print(depasse(60, 50))

Cas classique de bug

total_mesures = 0

def ajouter_mesure(valeur):
    total_mesures = total_mesures + valeur

Ce code provoque une erreur car Python considère total_mesures comme une variable locale à la fonction.

La bonne solution consiste à renvoyer une valeur et à la réaffecter à l’extérieur :

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

total_mesures = 0
total_mesures = ajouter_mesure(total_mesures, 10)

7. Récursivité

La récursivité consiste à faire appel à la fonction elle-même. Cela permet de résoudre certains problèmes en les décomposant en sous-problèmes plus petits.

Pour qu’une fonction récursive fonctionne correctement, il faut :

un cas de base qui arrête la récursion
un appel récursif avec un problème plus petit

Exemple : compte à rebours

def compte_a_rebours(n):
    if n == 0:
        print("C'est parti !")
    else:
        print(n)
        compte_a_rebours(n - 1)

compte_a_rebours(3)

Exemple : longueur d’une liste

def longueur(liste):
    if not liste:
        return 0
    return 1 + longueur(liste[1:])

print(longueur([10, 20, 30]))

Le point clé est de définir un cas de base pour éviter des appels infinis.

8. Exercices de révision

Exercice 1

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

Exercice 2

Écrire une fonction convertir_temp(valeur, unite) qui :

retourne la valeur si unite == "C"
convertit en Fahrenheit si unite == "F"

Exercice 3

Que va afficher le code suivant ?

x = 10

def f():
    x = 5
    return x

print(f())
print(x)

Exercice 4

Écrire une fonction récursive dire_bonjour(n) qui affiche "Bonjour !" n fois.

Exercice 5

Écrire une fonction récursive est_present(liste, element) qui vérifie si un élément appartient à une liste.

9. À retenir

Les variables stockent des données.
Les conditions permettent de prendre des décisions.
Les boucles évitent de recopier du code.
Les fonctions rendent le programme modulaire et lisible.
La portée des variables est essentielle pour éviter les bugs.
La récursivité est une technique utile quand un problème se décompose naturellement en sous-problèmes plus petits.

TD

Le travail dirigé de la séance est disponible ici.