Séance 4 : Modularité 1 (Les Fonctions)

Phase {{ currentPhase === 'all' ? 'Toutes' : currentPhase + ' / ' + phases.length }}

Phase active :

{{ currentPhase === 'all' ? 'Vue d\'ensemble (Toutes les phases)' : phases[currentPhase - 1].title }}

Étape 1

Situation & Démonstration interactive

15 min

Énoncé

« Saisir deux entiers positifs A et B. Déterminer si A est premier, calculer le PGCD de A et B, puis calculer la somme des chiffres de A à l'aide de trois fonctions indépendantes. »

Démonstration des 3 Fonctions en Temps Réel

Cas types :

Entier A (positif) :

A =

Entier B (positif) :

B =

est_premier({{ simA }})

Retourne Booléen (test de divisibilité sans break).

Valeur retournée : {{ isAPrime ? 'Vrai (True)' : 'Faux (False)' }}

pgcd({{ simA }}, {{ simB }})

Retourne Entier (Algorithme d'Euclide).

Valeur retournée : {{ calcPGCD }}

somme_chiffres({{ simA }})

Retourne Entier (Extractions Div/Mod 10).

Valeur retournée : {{ sumDigitsA }}

Exécution Python interactive

Questions de réflexion :

Algorithmique

Python

Étape 2

Notions clés & Normes officielles

15 min

Élément	Algorithmique (Norme Officielle)	Python 3 (Conventions 2024-2025)
En-tête de fonction	`Fonction Nom (pf1: type1, ...) : Type_ret`	`def nom(pf1, pf2):`
Valeur retournée	`Retourner résultat` Un seul type simple	`return résultat`
Appel de la fonction	`res ← Nom(pe1, pe2)`	`res = nom(pe1, pe2)`
Déclaration des objets locaux	T.D.O.L. (Objets propres au module)	Variables locales (détruites en sortie)

Résultat unique et simple

Une fonction retourne un seul résultat de type scalaire (Entier, Réel, Booléen, Caractère, Chaîne).

Concordance des paramètres

Les paramètres effectifs doivent concorder avec les formels en nombre, en ordre et en type.

Proscription de break

L'utilisation de break pour forcer la sortie d'une boucle est formellement interdite.

Étape 3

Algorithme & Programme Python

25 min

Solution Modulaire (Algorithmique) Fonctions & Principal

// 1. Fonction de primalité
Fonction est_premier (n: Entier) : Booléen
DEBUT
    i ← 2
    premier ← n ≥ 2
    Tant que (i * i ≤ n) Et (premier) Faire
        premier ← (n Mod i) ≠ 0
        i ← i + 1
    Fin Tant que
    Retourner premier
FIN

// 2. Fonction calculant le PGCD
Fonction pgcd (a: Entier, b: Entier) : Entier
DEBUT
    Tant que b ≠ 0 Faire
        r ← a Mod b
        a ← b
        b ← r
    Fin Tant que
    Retourner a
FIN

// 3. Fonction somme des chiffres
Fonction somme_chiffres (n: Entier) : Entier
DEBUT
    s ← 0
    temp ← n
    Tant que temp > 0 Faire
        s ← s + (temp Mod 10)
        temp ← temp Div 10
    Fin Tant que
    Retourner s
FIN

// 4. Algorithme Principal
ALGORITHME AnalyseurArithmetique
DEBUT
    Répéter
        Écrire("Donner un entier A positif : ")
        Lire(a)
    Jusqu'à (a > 0)
    
    Répéter
        Écrire("Donner un entier B positif : ")
        Lire(b)
    Jusqu'à (b > 0)
    
    Écrire("A est-il premier ? : ", est_premier(a))
    Écrire("PGCD(A, B) = ", pgcd(a, b))
    Écrire("Somme des chiffres de A = ", somme_chiffres(a))
FIN

Déclarations : T.D.O.L. & T.D.O.G.

T.D.O.L. (est_premier)

Objet	Type / Nature
`i`	Entier
`premier`	Booléen

T.D.O.L. (pgcd)

Objet	Type / Nature
`r`	Entier

T.D.O.L. (somme_chiffres)

Objet	Type / Nature
`s, temp`	Entier

T.D.O.G. (Programme Principal)

Objet	Type / Nature
`a, b`	Entier
`est_premier, pgcd, somme_chiffres`	Fonctions

analyseur_arithmetique.py

# 1. Fonction de primalité sans break
def est_premier(n):
    i = 2
    premier = n >= 2
    while i * i <= n and premier:
        premier = (n % i) != 0
        i = i + 1
    return premier

# 2. Fonction PGCD (Algorithme d'Euclide)
def pgcd(a, b):
    while b != 0:
        r = a % b
        a = b
        b = r
    return a

# 3. Fonction somme des chiffres
def somme_chiffres(n):
    s = 0
    temp = n
    while temp > 0:
        s = s + (temp % 10)
        temp = temp // 10
    return s

# --- Programme Principal ---
a = int(input("Donner un entier A positif : "))
while not (a > 0):
    a = int(input("Donner un entier A positif : "))

b = int(input("Donner un entier B positif : "))
while not (b > 0):
    b = int(input("Donner un entier B positif : "))

print("A est-il premier ? :", est_premier(a))
print("PGCD(A, B) =", pgcd(a, b))
print("Somme des chiffres de A =", somme_chiffres(a))

Conformité Officielle

Portée locale : Les variables i, premier, r, s, temp sont strictement locales à chaque fonction.
Retour de type simple : Chaque fonction renvoie une seule valeur scalaire (bool ou int).
Pas de break : Le contrôle d'arrêt du while respecte la condition logique sans rupture de flux.

Étape 4

Bilan & Auto-évaluation (Quiz)

5 min

Questions flash :

Algo {{ f.resAlgo }}

Python {{ f.resPy }}

Auto-évaluation : Quiz Fonctions (10 questions)

Score : {{ quizScore }} / {{ quizQuestions.length }}

Explication : {{ q.explanation }}

Séance 4 terminée !

Les fonctions n'ont plus de secret. Entraînez-vous sur la série d'exercices ou passez aux procédures.

Série 5 (6 exercices) Séance 5 (Procédures)

Étape {{ currentPhase }} / {{ phases.length }} {{ phases[currentPhase - 1].shortTitle }}