Fonctions avancées et programmes combinés

Rappel : définir une fonction

`python
def carre(x):
return x * x
`

Une fonction prend des paramètres (ici x) et renvoie un résultat avec return. L'intérêt principal d'une fonction est d'éviter de répéter le même code plusieurs fois dans un programme.

Combiner une fonction et une liste

On peut écrire une fonction qui calcule et renvoie une liste de termes d'une suite jusqu'à un rang donné :

`python
def termes_suite(u0, r, n):
u = u0
termes = [u]
for i in range(n):
u = u + r
termes.append(u)
return termes

print(termes_suite(3, 5, 4))
`

Ce programme affiche [3, 8, 13, 18, 23], les termes $u_0$ à $u_4$ de la suite arithmétique de premier terme $3$ et de raison $5$.

Combiner une fonction et un algorithme de seuil

`python
def rang_seuil(u0, r, seuil):
u = u0
n = 0
while u <= seuil:
u = u + r
n = n + 1
return n

print(rang_seuil(3, 5, 100))
`

Cette fonction renvoie directement le rang à partir duquel la suite dépasse seuil, sans avoir à réécrire la boucle while chaque fois qu'on change les paramètres.

Une fonction de simulation paramétrée

On peut transformer le programme de simulation de la loi binomiale vu précédemment en une fonction réutilisable avec différents paramètres :

`python
import random

def simuler_binomiale(n, p, k, nb_simulations):
compteur = 0
for simulation in range(nb_simulations):
succes = 0
for i in range(n):
if random.random() < p:
succes = succes + 1
if succes == k:
compteur = compteur + 1
return compteur / nb_simulations

frequence = simuler_binomiale(10, 0.3, 3, 5000)
print("Fréquence estimée :", frequence)
`

Intérêt : une fois la fonction simuler_binomiale écrite, on peut l'appeler avec n'importe quelles valeurs de n, p, k et nb_simulations, sans dupliquer le code.

Exemples

✅ Exemple simple — Fonction renvoyant une liste

`python
def puissances_de_deux(n):
resultat = []
valeur = 1
for i in range(n):
resultat.append(valeur)
valeur = valeur * 2
return resultat

print(puissances_de_deux(5))
`

Ce programme affiche [1, 2, 4, 8, 16].

📘 Exemple intermédiaire — Fonction de seuil pour une suite géométrique

`python
def rang_seuil_geometrique(v0, q, seuil):
v = v0
n = 0
while v < seuil:
v = v * q
n = n + 1
return n

print(rang_seuil_geometrique(2, 1.5, 50))
`

Cette fonction renvoie le plus petit rang $n$ pour lequel $v_n \geqslant 50$, pour la suite géométrique $v_0=2$, raison $q=1{,}5$.

🔴 Exemple avancé — Fonction combinant liste et simulation

`python
import random

def liste_frequences(n, p, nb_simulations):
resultats = []
for k in range(n + 1):
compteur = 0
for simulation in range(nb_simulations):
succes = 0
for i in range(n):
if random.random() < p:
succes = succes + 1
if succes == k:
compteur = compteur + 1
resultats.append(compteur / nb_simulations)
return resultats

print(liste_frequences(3, 0.5, 2000))
`

Cette fonction renvoie la liste des fréquences estimées de $P(X=0)$, $P(X=1)$, $P(X=2)$ et $P(X=3)$ pour $X \sim \mathcal{B}(3\,;\,0{,}5)$ : une approximation de toute la loi de probabilité de $X$.

À retenir

- Une fonction permet de réutiliser un même calcul (termes d'une suite, seuil, simulation) avec des paramètres différents, sans dupliquer le code.
- On peut combiner librement fonctions, listes, boucles for/while et conditions pour construire des programmes plus complets.
- Bien choisir les noms des paramètres d'une fonction rend le programme plus facile à lire et à réutiliser.