La récursivité n'est pas au programme de première

def factorielle_iterative(n):
    """n! par boucle bornee. Precondition : n entier >= 0."""
    p = 1
    for i in range(2, n + 1):
        p = p * i
    return p

def factorielle_recursive(n):
    """n! en s'appelant elle-meme. Precondition : n entier >= 0."""
    if n <= 1:            # cas de base : sans lui, aucun arret
        return 1
    return n * factorielle_recursive(n - 1)

for n in range(0, 200):
    assert factorielle_iterative(n) == factorielle_recursive(n) == math.factorial(n)

Les $200$ cas coïncident, et coïncident avec math.factorial.

La limite.

import sys
print(sys.getrecursionlimit())          # 1000
factorielle_recursive(100000)           # RecursionError: maximum recursion depth exceeded

La version itérative, elle, calcule $100000!$ sans difficulté — un nombre de plus de $450000$ chiffres.

Ce que cela révèle. Chaque appel non terminé occupe un cadre dans la pile d'exécution : la récursion consomme de la mémoire proportionnellement à sa profondeur, là où la boucle n'en consomme pas du tout. Python fixe une limite de $1000$ appels imbriqués, non par avarice, mais pour transformer une récursion sans fin en une erreur lisible plutôt qu'en un plantage de la machine.

Pourquoi elle est réservée à la terminale : la récursion demande de raisonner sur un cas de base et une décroissance — exactement le variant de boucle de ce chapitre, mais appliqué à un mécanisme qu'on ne voit pas se dérouler. Le programme de première préfère qu'on maîtrise d'abord la boucle, dont la trace s'écrit ligne à ligne, comme dans les premiers exercices de TD.