Python & IA : Premier Contact

§1 Mais en fait, c'est quoi l'informatique ?

Avant d'écrire une ligne de code, posons-nous la question qui fâche : qu'est-ce que l'informatique ? Si vous répondez « réparer des imprimantes », ce cours va vous faire mal. Asseyez-vous.

Le mot « informatique » vient de la contraction d'information et d'automatique. L'informatique, ce n'est pas la science des ordinateurs (les ordinateurs ne sont que l'outil) — c'est la science du traitement automatique de l'information.

L'informatique repose sur trois piliers fondamentaux :

1. L'information — comment la représenter (nombres, textes, images, sons)
2. L'algorithme — une suite finie d'instructions qui résout un problème
3. La machine — qui exécute les algorithmes (ordinateur, smartphone, microcontrôleur)

Aujourd'hui, nous allons apprendre à parler à une machine en utilisant Python, un langage créé pour être lu par des humains. Et c'est déjà une révolution.

§2 Python : le serpent qui parle

Quelques raisons d'utiliser Python (en vrac) :

• Lisible — on dirait presque de l'anglais.
• Facile à apprendre — la courbe d'apprentissage est un tapis roulant.
• Immense écosystème — des milliers de bibliothèques pour tout faire : maths, IA, web, jeux, astronomie, etc.
• Utilisé dans l'IA — TensorFlow, PyTorch, scikit-learn. Tout est en Python.
• Interprété — pas besoin de compilation. On écrit, on exécute, on voit.

§3 Comment utiliser ce cours : code source, fichiers, REPL

Tout ce que vous voyez dans ce cours — les bouts de code en couleur, les exemples — est conçu pour que vous puissiez les taper vous-même et les exécuter. Un programme informatique, c'est juste un fichier texte qui contient des instructions. Ce fichier s'appelle le code source. Python le lit, le comprend, et l'exécute. Magie. ✨

3.1 Méthode 1 — Le REPL : le terrain de jeu interactif

Le REPL (Read-Eval-Print Loop) est un mode interactif de Python : vous tapez une instruction, Python l'exécute immédiatement et affiche le résultat. C'est parfait pour expérimenter, tester une idée, ou vérifier qu'une fonction marche.

Pour lancer le REPL, ouvrez un terminal et tapez :

# Sur Windows, Mac ou Linux, dans un terminal :
$ python3

Vous verrez apparaître quelque chose comme :

Les trois chevrons >>> sont le prompt du REPL. Python attend vos instructions. Tapez une expression et validez avec Entrée — le résultat s'affiche immédiatement.

>>> 42 + 8
50
>>> print("Hello, IA!")
Hello, IA!
>>> 3.1415 * 2 ** 2
12.566

>>> 12 + 30
42
>>> _ * 2
84

3.2 Méthode 2 — Les fichiers .py : le vrai code

Le REPL, c'est bien pour tester. Mais pour écrire un vrai programme, on crée un fichier avec l'extension .py. Par exemple mon_programme.py.

1. Créez un fichier mon_programme.py dans votre éditeur de texte (VS Code, PyCharm, Sublime Text, ou même le bloc-notes — oui, le bloc-notes, on ne juge pas).
2. Écrivez-y du code Python.
3. Dans un terminal, exécutez : python3 mon_programme.py

Exemple concret :

# Ceci est le contenu de mon_programme.py
print("Quel est le meilleur langage pour l'IA ?")
reponse = "Python, évidemment."
print(reponse)

Dans le terminal :

$ python3 mon_programme.py
Quel est le meilleur langage pour l'IA ?
Python, évidemment.

3.3 Comment utiliser les exemples de ce cours

Les blocs de code colorisés que vous voyez dans ce cours sont prêts à être copiés dans un fichier .py ou tapés dans le REPL.

• Dans le REPL : tapez chaque ligne une par une. Les définitions de fonctions doivent être tapées en une fois — le REPL attendra l'indentation.
• Dans un fichier : copiez tout le bloc, collez-le dans exemple.py, puis lancez python3 exemple.py.
• Modifiez les valeurs ! Le meilleur moyen d'apprendre, c'est de casser les exemples et de voir ce qui se passe.
• Les blocs « Sortie » montrent ce que vous devriez voir. Si ce n'est pas le cas, relisez votre code. Les ordinateurs ne font jamais d'erreur. (Ils exécutent les vôtres à la perfection.)

§4 Les variables : des boîtes avec des noms débiles

Une variable, c'est une boîte dans la mémoire de l'ordinateur, à laquelle on colle une étiquette (un nom). On peut y mettre un nombre, du texte, ou n'importe quoi d'autre. Et on peut changer le contenu plus tard. D'où le nom "variable".

4.1 Les entiers (int) et les réels (float)

# Ceci est un commentaire — Python l'ignore, pas vous.
# Les commentaires commencent par #. Ils sont vos meilleurs amis.

age = 20              # un entier (int)
pi = 3.1415926535    # un réel, ou plutôt un flottant (float)
reponse = 42           # la réponse à l'univers, merci Douglas Adams 📚

print(age)            # affiche 20
print(pi * 2)         # affiche 6.283185307

4.2 Opérations de base

prix_unitaire = 9
quantite = 4
total = prix_unitaire * quantite
print("Total :", total, "euros")

# Et pour 7 articles ? On change juste la variable !
quantite = 7
total = prix_unitaire * quantite
print("Nouveau total :", total, "euros")

4.3 Le problème des flottants

§5 L'instruction if : prendre des décisions (comme un adulte)

Un programme sans condition, c'est une recette de cuisine où on fait exactement la même chose quels que soient les ingrédients. Pas très utile. L'instruction if permet d'exécuter du code uniquement si une condition est vraie.

note = 14

if note >= 10:
    print("Vous avez validé ! 🎉")
else:
    print("Pas de chance. Raté. 😢")

5.1 Conditions à plusieurs branches : elif

note = 16

if note >= 18:
    print("Excellent ! Vous êtes un génie (ou un tricheur).")
elif note >= 14:
    print("Très bien ! Vous avez le droit d'être fier.")
elif note >= 10:
    print("Passable. Ça passe, mais ça ne casse pas des briques.")
else:
    print("Ajourné. Les rattrapages sont dans 2 semaines.")

5.2 Opérateurs de comparaison

argent = 0.80
prix_cafe = 1.20

if argent >= prix_cafe:
    monnaie = argent - prix_cafe
    print("☕  Votre café. Monnaie :", monnaie, "€")
else:
    manque = prix_cafe - argent
    print("⚠️  Pas assez d'argent. Il manque", manque, "€. Va voir tes parents.")

§6 Les fonctions : pourquoi réécrire ce qu'on peut réutiliser ?

Une fonction, c'est une petite machine qui prend des ingrédients en entrée, fait un calcul, et retourne un résultat. En cuisine, on dirait une recette. En programmation, on appelle ça ne pas se répéter (principe DRY : Don't Repeat Yourself).

def carré(x):
    """Retourne le carré de x."""
    return x ** 2

print(carré(5))   # 25
print(carré(12))  # 144

6.1 Fonction avec plusieurs paramètres

def moyenne(a, b):
    """Calcule la moyenne de deux nombres."""
    return (a + b) / 2

print(moyenne(10, 16))  # 13.0

# On peut aussi "documenter" une fonction avec une docstring (le texte entre """ """)
print(moyenne.__doc__)  # Affiche la docstring : "Calcule la moyenne de deux nombres."

6.2 Fonction conditionnelle : mention ou pas ?

def mention(note):
    """Retourne la mention correspondant à une note sur 20."""
    if note >= 18:
        return "Excellent"
    elif note >= 14:
        return "Très Bien"
    elif note >= 10:
        return "Passable"
    else:
        return "Ajourné"

print(mention(15))  # Très Bien
print(mention(6))   # Ajourné

§7 La récursivité : un serpent qui se mange la queue

Une fonction est dite récursive quand elle s'appelle elle-même. C'est une technique puissante pour résoudre des problèmes qui peuvent être décomposés en sous-problèmes identiques mais plus petits.

7.1 La factorielle — l'exemple classique

La factorielle d'un entier n (notée n!) est le produit de tous les entiers de 1 à n. Par convention, 0! = 1.

def factorielle(n):
    """Calcule n! (n factorielle) de façon récursive.
       Cas de base : si n <= 1, retourne 1.
       Sinon : n * factorielle(n-1)
       """
    if n <= 1:
        return 1
    else:
        return n * factorielle(n - 1)

print(factorielle(5))   # 5! = 5 × 4 × 3 × 2 × 1 = 120
print(factorielle(0))   # 0! = 1 (par convention, et par élégance)

Voici ce qui se passe quand on appelle factorielle(5) :

# L'appel factorielle(5) déclenche :
factorielle(5) = 5 * factorielle(4)
               = 5 * (4 * factorielle(3))
               = 5 * (4 * (3 * factorielle(2)))
               = 5 * (4 * (3 * (2 * factorielle(1))))
               = 5 * (4 * (3 * (2 * 1)))           # cas de base atteint !
               = 5 * (4 * (3 * 2))
               = 5 * (4 * 6)
               = 5 * 24
               = 120

7.2 La suite de Fibonacci — le lapin qui se reproduit

def fibonacci(n):
    """Retourne le n-ième terme de la suite de Fibonacci."""
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55
print(fibonacci(20))  # 6765

§8 Fonctions d'ordre supérieur : quand les fonctions cuisinent d'autres fonctions

En Python, les fonctions sont des objets de première classe. Ça signifie qu'on peut les passer en argument à d'autres fonctions, les retourner, les mettre dans des listes. C'est terriblement puissant.

8.1 Dérivée numérique — la fonction qui dérive les fonctions

Souvenez-vous de la définition de la dérivée : f'(x) ≈ (f(x+h) - f(x)) / h quand h est très petit. En Python, on peut écrire une fonction derive qui prend n'importe quelle fonction f et retourne une nouvelle fonction qui est sa dérivée approchée.

def derive(f, h=1e-7):
    """Retourne une fonction qui calcule la dérivée approchée de f."""
    def derivée(x):
        return (f(x + h) - f(x)) / h
    return derivée

# Testons sur f(x) = x², dont la dérivée est f'(x) = 2x
def carré(x):
    return x ** 2

derive_carré = derive(carré)

print(derive_carré(3))   # devrait être proche de 6
print(derive_carré(10))  # devrait être proche de 20

8.2 Fonction anonyme : le lambda

Quand une fonction est si triviale qu'elle ne mérite même pas de nom, on utilise lambda — une fonction expression sans nom, écrit en une ligne.

# Les deux lignes ci-dessous sont équivalentes :
def double(x): return x * 2
double = lambda x: x * 2

print(double(7))  # 14

# Le vrai intérêt de lambda : l'utiliser directement dans une fonction d'ordre supérieur
derive_cube = derive(lambda x: x ** 3)
print(derive_cube(2))  # f(x)=x³ → f'(x)=3x² → f'(2)=12, résultat approché : ~12

8.3 Dichotomie — la méthode du « couper au milieu »

La dichotomie (ou méthode de bissection) permet de trouver une racine d'une fonction continue f sur un intervalle [a, b] où f(a) et f(b) sont de signes opposés. On coupe l'intervalle en deux, on regarde de quel côté se trouve le zéro, et on recommence jusqu'à être assez précis.

def dichotomie(f, a, b, epsilon=1e-10):
    """Trouve une racine de f sur [a, b] par dichotomie.
       f(a) et f(b) doivent être de signes opposés.
       """
    while b - a > epsilon:
        m = (a + b) / 2
        if f(m) == 0:
            return m
        elif f(a) * f(m) < 0:
            b = m
        else:
            a = m
    return (a + b) / 2

# Trouvons √2 en résolvant f(x) = x² - 2 = 0
racine_de_2 = dichotomie(lambda x: x**2 - 2, 0, 2)
print("√2 ≈", racine_de_2)
print("Vérification :", racine_de_2**2)

def dichotomie_rec(f, a, b, epsilon=1e-10):
    if b - a < epsilon:
        return (a + b) / 2
    m = (a + b) / 2
    if f(m) == 0:
        return m
    elif f(a) * f(m) < 0:
        return dichotomie_rec(f, a, m, epsilon)
    else:
        return dichotomie_rec(f, m, b, epsilon)

print(dichotomie_rec(lambda x: x**2 - 2, 0, 2))

§9 Pour aller plus loin : les questions qui fâchent

9.1 Récursif vs itératif ?

La récursivité est élégante, l'itération est efficace. En IA, on utilise les deux. Le parcours d'arbre de décision ? Récursif. La descente de gradient ? Itératif. Savoir passer de l'un à l'autre est un signe de maturité.

9.2 float vs int : pourquoi tant de haine ?

Python gère les entiers de taille arbitraire (vous pouvez calculer 10**1000 sans sourciller). Mais les flottants sont limités à ~15 chiffres décimaux significatifs et peuvent valoir inf ou nan (Not a Number). En IA, on utilise massivement des flottants — mais en 32 bits, pas en 64, pour économiser la mémoire GPU. Ça s'appelle le mixed precision training.

9.3 Et les boucles ?

On ne les a pas vues dans ce cours ? C'est normal. Elles seront l'objet du cours 2, avec for, while, les listes et les dictionnaires. La récursivité peut remplacer les boucles... mais ce n'est pas toujours une bonne idée.

§10 Le mot de la fin

Vous avez survécu à votre premier cours d'informatique. Vous avez manipulé des variables, écrit des conditions, créé des fonctions, fait de la récursivité, et même implémenté une dérivée numérique et un solveur par dichotomie. Pas mal pour une première fois.