Python en prépa : les bases pour bien démarrer

En prépa scientifique, la première fois que tu ouvres un éditeur Python, tu n'écris pas un jeu vidéo : tu écris trois lignes qui calculent une moyenne, et rien ne s'affiche parce qu'il te manque un print. C'est normal. L'informatique pour tous de MPSI, PCSI et PTSI part de zéro et repose sur un petit noyau de notions qu'il faut posséder à fond avant tout le reste : variables, types, boucles, fonctions, listes. Et si tu vises la MP2I, où l'informatique se fait en OCaml et C, ce sont exactement ces bases qu'on te conseille de réviser en Python avant la rentrée.

Cet article te donne ce noyau, dans l'ordre où on le construit en classe, avec du code commenté que tu peux recopier et tester. On voit les quatre types de base, les opérateurs, les structures de contrôle, les fonctions, les listes et les chaînes, les entrées-sorties, puis les erreurs classiques du débutant et trois exercices corrigés. Nos profs Hadamard, anciens de MP2I et de MPSI option info passés par l'X, l'ENS et CentraleSupélec, voient revenir les mêmes blocages chaque année : on les liste pour que tu les évites dès le départ.

Pourquoi Python en prépa

Les filières scientifiques MPSI, PCSI et PTSI suivent un enseignement d'informatique pour tous, et il se fait en Python 3. Le choix n'est pas anodin : Python a une syntaxe proche du pseudo-code, sans déclaration de type ni gestion mémoire à la main, ce qui laisse te concentrer sur l'algorithme plutôt que sur la plomberie du langage.

Concrètement, Python te sert à trois choses en prépa : programmer des algorithmes (tri, recherche, simulation), faire du calcul numérique et tracer des courbes (avec numpy et matplotlib, vus plus tard), et manipuler des données. La MP2I est le cas à part : l'informatique y est une discipline à part entière, enseignée en OCaml et C (plus SQL) et non en « informatique pour tous » ; Python n'y est pas le langage du programme, mais il reste le meilleur moyen de réviser les bases attendues avant la rentrée, car les notions de cet article (variables, boucles, fonctions) sont les mêmes dans tous les langages. Pour ceux qui prennent l'option informatique en MPSI, OCaml et une vraie théorie des algorithmes s'ajoutent aussi à Python. Si tu hésites encore sur ta filière, notre article sur la filière MP2I détaille la place de l'informatique dans chaque voie.

Variables et types de base

Une variable est un nom qui désigne une valeur. On l'affecte avec le signe = (à lire « reçoit », pas « égale »). Python devine tout seul le type de la valeur, tu n'as rien à déclarer.

n = 42          # int : un entier
prix = 3.5      # float : un nombre à virgule (le point, pas la virgule)
nom = "Hugo"    # str : une chaîne de caractères (entre guillemets)
majeur = True   # bool : un booléen, vaut True ou False

print(n, prix, nom, majeur)   # affiche : 42 3.5 Hugo True

Les quatre types que tu croises en permanence sont donc int (entiers, sans limite de taille en Python), float (nombres à virgule), str (texte) et bool (vrai ou faux). La fonction type() te renseigne en cas de doute, et les fonctions int(), float(), str() convertissent d'un type à l'autre.

age_texte = "17"           # une chaîne, PAS un nombre
age = int(age_texte)       # conversion en entier : 17
print(age + 1)             # 18  → l'addition marche
print(type(3.5))           # <class 'float'>
print(str(2026) + " ans")  # "2026 ans" : on colle deux chaînes

Les opérateurs

Les opérateurs arithmétiques sont ceux que tu attends, avec deux subtilités utiles : / renvoie toujours un flottant, tandis que // donne le quotient entier et % le reste (le fameux modulo, omniprésent en algorithmique).

print(7 + 2)    # 9    addition
print(7 - 2)    # 5    soustraction
print(7 * 2)    # 14   multiplication
print(7 / 2)    # 3.5  division (toujours un float)
print(7 // 2)   # 3    quotient entier
print(7 % 2)    # 1    reste de la division (7 = 3*2 + 1)
print(2 ** 10)  # 1024 puissance

Les opérateurs de comparaison renvoient un booléen : == (égalité), != (différent), <, <=, >, >=. On les combine avec les opérateurs logiques and, or et not.

print(5 == 5)          # True
print(5 != 3)          # True
print(3 < 5 and 5 < 8) # True : les deux conditions sont vraies
print(not (2 > 10))    # True : 2 > 10 est faux, donc not le rend vrai

# modulo pour tester la parité
print(12 % 2 == 0)     # True : 12 est pair

Les structures de contrôle

C'est ici que le programme se met à décider et à répéter. Deux règles de syntaxe non négociables en Python : chaque en-tête (if, for, while, def) se termine par un deux-points :, et le bloc qui suit est indenté (quatre espaces). L'indentation n'est pas décorative, elle définit ce qui appartient au bloc.

Le test if / elif / else

note = 13

if note >= 16:
    mention = "Très bien"
elif note >= 14:
    mention = "Bien"
elif note >= 12:
    mention = "Assez bien"
else:
    mention = "Pas de mention"

print(mention)   # Assez bien

Python teste les conditions dans l'ordre et s'arrête à la première vraie. Les blocs elif et else sont facultatifs : un if seul suffit quand il n'y a qu'un cas à traiter.

La boucle for

On l'utilise quand on connaît le nombre d'itérations. La fonction range(n) produit les entiers de 0 à n - 1 (la borne haute est exclue, un point à mémoriser).

# somme des entiers de 1 à 100
somme = 0
for i in range(1, 101):   # i prend 1, 2, ..., 100 (101 exclu)
    somme = somme + i
print(somme)              # 5050

# parcourir une liste directement
for lettre in ["a", "b", "c"]:
    print(lettre)         # affiche a, puis b, puis c

La boucle while

On l'utilise quand on ignore le nombre de tours à l'avance et qu'on répète tant qu'une condition reste vraie. Il faut garantir que la condition finira par devenir fausse, sinon la boucle tourne à l'infini.

# combien de fois peut-on diviser 100 par 2 avant de passer sous 1 ?
n = 100
compteur = 0
while n >= 1:
    n = n / 2
    compteur = compteur + 1
print(compteur)   # 7

Les fonctions

Une fonction est un bloc de code nommé, qui reçoit des arguments et renvoie un résultat avec return. Elle évite de recopier le même calcul et rend le programme lisible. On la définit avec def.

def aire_rectangle(largeur, hauteur):
    """Renvoie l'aire d'un rectangle."""
    return largeur * hauteur

a = aire_rectangle(4, 3)   # on appelle la fonction avec 4 et 3
print(a)                   # 12
print(aire_rectangle(10, 2))  # 20 : réutilisable à volonté

Deux points essentiels. D'abord, return renvoie une valeur (que l'appelant peut stocker), alors que print se contente d'afficher à l'écran : ce ne sont pas la même chose. Ensuite, dès que Python rencontre un return, il quitte la fonction immédiatement.

def est_pair(n):
    if n % 2 == 0:
        return True
    else:
        return False

def maximum(a, b):
    if a >= b:
        return a
    return b        # atteint seulement si a < b

print(est_pair(10))    # True
print(maximum(7, 12))  # 12

Les listes et l'indexation

La liste est la structure la plus utilisée en prépa : une suite ordonnée de valeurs, entre crochets. On accède à un élément par son indice, et c'est le point qui piège tout le monde au début : on compte à partir de 0.

notes = [12, 8, 15, 17, 9]

print(notes[0])     # 12  → le PREMIER élément est à l'indice 0
print(notes[3])     # 17  → le quatrième
print(notes[-1])    # 9   → indice négatif : le dernier
print(len(notes))   # 5   → le nombre d'éléments

notes[1] = 10       # on modifie le deuxième élément
notes.append(20)    # on ajoute 20 à la fin
print(notes)        # [12, 10, 15, 17, 9, 20]

Comme une liste est indicée de 0 à len - 1, on la parcourt naturellement avec une boucle for, soit sur les valeurs, soit sur les indices via range(len(...)) quand on a besoin de la position.

notes = [12, 8, 15, 17, 9]

# parcours par valeurs : calculer la moyenne
total = 0
for note in notes:
    total = total + note
moyenne = total / len(notes)
print(moyenne)          # 12.2

# parcours par indices : trouver le maximum et sa position
imax = 0
for i in range(len(notes)):
    if notes[i] > notes[imax]:
        imax = i
print(imax, notes[imax])  # 3 17

Ces listes deviennent le socle des algorithmes classiques de première année, comme le tri et la recherche, dont on mesure le coût en nombre d'opérations. On les approfondit dans nos articles sur l'algorithmique, le tri et la complexité et sur les structures de données (piles, files, arbres).

Les chaînes de caractères

Une chaîne (str) se manipule presque comme une liste : elle est indicée à partir de 0, on connaît sa longueur avec len, et on la parcourt avec une boucle for. Différence importante : une chaîne est non modifiable (on ne peut pas faire mot[0] = "X"), on en construit une nouvelle à la place.

mot = "prepa"

print(mot[0])       # 'p'  → premier caractère
print(mot[-1])      # 'a'  → dernier
print(len(mot))     # 5
print(mot + "!")    # "prepa!"  → concaténation
print(mot.upper())  # "PREPA"   → en majuscules

# compter les voyelles d'un mot
voyelles = 0
for c in mot:
    if c in "aeiouy":
        voyelles = voyelles + 1
print(voyelles)     # 2

L'opérateur in teste l'appartenance : "a" in "prepa" vaut True. Il fonctionne aussi bien sur les chaînes que sur les listes, et c'est un outil très pratique pour éviter une boucle de recherche.

Entrées et sorties

Pour afficher, on utilise print, qui accepte plusieurs valeurs séparées par des virgules. Pour lire une saisie au clavier, on utilise input, qui renvoie toujours une chaîne : il faut convertir avant de calculer.

# f-string : la façon moderne et lisible d'afficher
nom = "Léa"
age = 17
print(f"{nom} a {age} ans")   # Léa a 17 ans

# lecture au clavier, avec conversion
rayon = float(input("Rayon du cercle ? "))   # input renvoie du texte
perimetre = 2 * 3.14159 * rayon
print(f"Périmètre = {perimetre}")

Les f-strings (une chaîne préfixée par f) insèrent la valeur d'une variable directement entre accolades. C'est plus lisible que d'enchaîner des concaténations avec str(), et c'est la forme à privilégier.

Les erreurs classiques du débutant

En TP, les mêmes messages d'erreur reviennent sans cesse. Les connaître à l'avance te fait gagner un temps précieux.

1. Confondre = et ==. = affecte, == compare. Dans un if ou un while, c'est toujours ==.
2. Oublier les deux-points ou l'indentation. Chaque if, for, while, def finit par : et ouvre un bloc indenté de quatre espaces. Un décalage incohérent donne une IndentationError.
3. L'indice hors limites. Une liste de n éléments a des indices de 0 à n - 1. Aller jusqu'à liste[n] déclenche une IndexError.
4. Ne pas convertir input. input renvoie une chaîne. input() + 1 plante avec une TypeError ; il faut int(input()) ou float(input()).
5. Confondre print et return. Une fonction qui affiche ne renvoie rien d'exploitable (elle renvoie None). Pour réutiliser un résultat, il faut return.
6. Tester l'égalité de deux flottants. 0.1 + 0.2 == 0.3 vaut False à cause de la précision binaire. On teste abs(a - b) < 1e-9 à la place.
7. La boucle while infinie. Si la condition ne devient jamais fausse (on oublie de faire évoluer la variable testée), le programme tourne sans fin. Vérifie toujours que la condition d'arrêt sera atteinte.

Les bonnes pratiques dès le départ

Prendre de bonnes habitudes tout de suite t'évite de les corriger péniblement plus tard, quand le correcteur de concours regarde ton code.

• Des noms parlants. moyenne, compteur, indice_max plutôt que a, x, truc. Un compteur de boucle peut rester i, mais une vraie donnée mérite un vrai nom.
• Des commentaires utiles. Le commentaire (précédé de #) explique le pourquoi, pas le quoi. # incrémente i est inutile ; # on s'arrête dès qu'on a trouvé la cible a de la valeur.
• Des fonctions courtes. Une fonction fait une chose. Si elle dépasse quinze lignes ou fait trois tâches distinctes, découpe-la.
• Une indentation homogène. Quatre espaces, jamais un mélange espaces / tabulations. Configure ton éditeur pour insérer quatre espaces avec la touche Tab.
• Tester au fur et à mesure. N'écris pas cinquante lignes avant de lancer. Teste chaque fonction sur un cas simple dont tu connais le résultat.

Trois mini-exercices corrigés

Exercice 1, compter les nombres pairs

Énoncé. Écris une fonction nb_pairs(liste) qui renvoie le nombre d'entiers pairs d'une liste.

Solution. On parcourt la liste et on teste la parité avec le modulo.

def nb_pairs(liste):
    compteur = 0
    for x in liste:
        if x % 2 == 0:   # x est pair
            compteur = compteur + 1
    return compteur

print(nb_pairs([3, 8, 4, 7, 10]))  # 3  (8, 4 et 10)
print(nb_pairs([1, 3, 5]))         # 0

Exercice 2, le maximum d'une liste

Énoncé. Écris une fonction maximum(liste) qui renvoie la plus grande valeur d'une liste non vide, sans utiliser la fonction max de Python.

Solution. On garde en mémoire le meilleur candidat, initialisé au premier élément, et on le met à jour au fil du parcours.

def maximum(liste):
    plus_grand = liste[0]        # on part du premier élément
    for x in liste:
        if x > plus_grand:
            plus_grand = x       # on a trouvé mieux
    return plus_grand

print(maximum([4, 9, 2, 15, 7]))  # 15
print(maximum([-3, -8, -1]))      # -1

Piège à éviter : initialiser plus_grand à 0. Sur une liste de valeurs toutes négatives, la fonction renverrait alors 0 à tort. On part toujours du premier élément réel.

Exercice 3, la factorielle avec une boucle

Énoncé. Écris une fonction factorielle(n) qui calcule n! = 1 × 2 × … × n, avec factorielle(0) valant 1.

Solution. On accumule le produit dans une variable, initialisée à 1 (élément neutre de la multiplication).

def factorielle(n):
    resultat = 1
    for k in range(1, n + 1):   # k prend 1, 2, ..., n
        resultat = resultat * k
    return resultat

print(factorielle(0))   # 1  (la boucle ne tourne pas, range(1, 1) est vide)
print(factorielle(5))   # 120  (1*2*3*4*5)

Remarque le rôle de range(1, n + 1) : la borne haute étant exclue, il faut écrire n + 1 pour que k atteigne bien n. C'est l'une des sources d'erreur les plus fréquentes sur les boucles, à surveiller systématiquement.

Ce qu'il faut retenir

• Quatre types de base : int, float, str, bool. Une saisie input arrive toujours en chaîne, à convertir avant tout calcul.
• Les opérateurs : attention à // (quotient), % (reste), et à == qui compare là où = affecte.
• Les structures de contrôle : if / elif / else pour décider, for quand le nombre de tours est connu, while quand on a une condition d'arrêt.
• Les fonctions : def, des arguments, un return qui renvoie (et n'est pas un print).
• Les listes et chaînes : indicées à partir de 0, parcourues au for, borne haute exclue dans range.
• Les pièges : = contre ==, indentation, indice hors limites, égalité de flottants, while infinie.

Ces bases sont le point de départ de toute l'informatique de prépa. Une fois qu'elles sont solides, tu passes aux algorithmes de tri et de recherche, puis aux structures de données et à l'analyse de complexité. Si tu veux aller plus loin en informatique, la filière MP2I et l'option info en MPSI en font une matière à part entière.

Le seul secret, en Python comme dans le reste de la prépa, c'est la régularité : mieux vaut coder vingt minutes chaque jour que trois heures d'affilée la veille du TP. Chez Hadamard, nos profs, anciens taupins passés par l'informatique, t'aident à débloquer les bases avant qu'un retard ne s'installe.