Bases de Python en prépa : cours, méthodes et exercices corrigés

Q: Quelle est la différence entre print et return en Python ?

`print` affiche une valeur à l'écran ; `return` arrête la fonction et donne la valeur de l'appel. Seul `return` permet de réutiliser le résultat dans un calcul ou dans une autre fonction. Une fonction sans `return` renvoie `None`. Dans un sujet de concours qui demande une fonction qui « renvoie » ou « retourne », afficher le résultat au lieu de le renvoyer est une erreur.

Q: Quelle différence entre / et // en Python ?

`/` donne toujours un flottant : `6 / 3` vaut `2.0`. `//` donne le quotient de la division euclidienne et `%` son reste : pour a ≥ 0 et b > 0, on a a = bq + r avec q = `a // b`, r = `a % b` et 0 ≤ r < b. Ces deux opérateurs servent à tester la parité, convertir une durée ou extraire les chiffres d'un entier.

Q: Comment choisir entre une boucle for et une boucle while ?

On se demande si l'on connaît le nombre de tours avant d'entrer. Si oui, on écrit une boucle `for`, qui s'arrête d'elle-même. Sinon (seuil, condition d'arrêt), on écrit une boucle `while`, avec une initialisation, une condition, une mise à jour, et une quantité entière positive qui décroît strictement à chaque tour pour être sûr qu'elle s'arrête. Exemple : le premier entier dont le carré dépasse 1000 demande un `while`.

Q: Combien de tours fait for i in range(a, b) ?

`for i in range(n)` fait n tours, avec `i` de 0 à n - 1. `for i in range(a, b)` fait b - a tours si a ≤ b, et aucun sinon, avec `i` de a à b - 1. Pour aller de 1 à n, on écrit `range(1, n + 1)`. Deux boucles imbriquées de n et m tours exécutent le corps n × m fois.

Q: Pourquoi Python affiche UnboundLocalError ?

Un nom affecté quelque part dans une fonction est local dans toute la fonction. Si la fonction lit ce nom avant de l'affecter, en pensant lire la variable globale du même nom, Python lève une `UnboundLocalError`. Une fonction peut lire une variable globale seulement si elle n'affecte nulle part ce nom. Les variables locales disparaissent à la fin de l'appel.

Q: Comment échanger deux variables en Python ?

On écrit `a, b = b, a` : Python calcule d'abord les deux valeurs de droite, puis les range dans `a` et `b`. De même, `a, b = b, a + b` met à jour deux variables avec leurs anciennes valeurs, ce qui sert pour les suites récurrentes. L'affectation `x = e` est une instruction, pas une égalité : la comparaison s'écrit `==`.

MPSI
PCSI
PTSI
TSI 1
TPC 1
Offert à l'essai

Expressions et types de base, variables et affectation, instructions conditionnelles et boucles, fonctions et spécification, premiers programmes complets en Python.

20méthodes
36exercices corrigés
4problèmes
22pièges
43figures

Les nombres sont ceux du chapitre complet ; chaque filière voit la partie qui correspond à son programme.

Python est le langage de l'informatique commune des classes préparatoires : on y écrit des expressions typées (int, float, bool, str), des instructions conditionnelles, des boucles for et while, et des fonctions qui renvoient leur résultat par return. Ce chapitre donne la syntaxe et les réflexes qui servent dans tous les autres. Il est au programme de MPSI, PCSI, PTSI, TSI et TPC, au Maroc et en France ; les épreuves d'informatique du CNC, de CCINP et de Mines-Ponts posent des questions de ce niveau, reprises dans les exercices. Ce cours de Python pour la prépa propose des exercices Python corrigés, avec l'analyse, le programme et sa sortie, ainsi que les messages d'erreur à reconnaître.

Ce que tu sauras faire

Ce chapitre donne les bases du langage Python : ce qu'est une valeur, une variable, une instruction, une boucle, une fonction. Tous les autres chapitres d'informatique s'écrivent avec ces outils. À la fin, tu dois savoir :

prévoir la valeur et le type d'une expression, et lire un message d'erreur ;
utiliser des variables, échanger deux valeurs et suivre l'état des variables dans un tableau ;
écrire une instruction conditionnelle qui couvre tous les cas ;
écrire une boucle for ou while, compter ses tours et t'assurer qu'elle s'arrête ;
écrire une fonction qui reçoit ses données en paramètres et renvoie son résultat, et prévoir l'effet d'un appel sur les variables ;
écrire la spécification d'une fonction, la protéger par une assertion et la tester.

L'essentiel : Valeurs, opérations, variables Extrait gratuit

Un extrait de la fiche « L'essentiel » du chapitre. Les démonstrations sont dans le cours détaillé.

Type	Exemples	Conversion
`int`	`0`, `-7`, `2026`	`int(x)` : troncature d'un flottant, lecture d'une chaîne de chiffres
`float`	`3.5`, `3.1e-2`	`float(x)`
`bool`	`True`, `False`
`str`	`"tamr"`	`str(x)`
(aucune valeur)	`None`

Priorité (de la plus forte à la plus faible)	Opérations
1	`**`
2	signe `-x`
3	`*`, `/`, `//`, `%`
4	`+`, `-`
5	`==`, `!=`, `<`, `>`, `<=`, `>=`
6, 7, 8	`not`, puis `and`, puis `or`

À retenir Opérations et affectation

À priorité égale, Python calcule de gauche à droite, sauf **, de droite à gauche (2 ** 3 ** 2 vaut 512), et les comparaisons, qui s'enchaînent (0 < x < 10).
/ donne toujours un flottant : 6 / 3 vaut 2.0. Pour $a \geq 0$ et $b > 0$ : $a = bq + r$ avec $q$ = a // b, $r$ = a % b et $0 \leq r < b$ .
x = e calcule e, puis range la valeur dans x : c'est une instruction, pas une égalité. == compare.
a, b = b, a échange ; a, b = b, a + b met à jour deux variables avec leurs anciennes valeurs.
and et or sont paresseux : i < len(L) and L[i] == 0 ne lit jamais L[i] hors de la liste.
Un flottant s'écrit avec un point : x = 12,5 crée le couple (12, 5).

Une méthode du chapitre Extrait gratuit

Méthode Écrire une fonction à partir d'un énoncé de concours

Quand l’utiliser

Une question demande « Écrire la fonction nom(param) qui reçoit... et qui retourne... ».

Rappel de cours

La signature imposée (nom, paramètres et leur ordre, type renvoyé) ne se change pas. Une fonction renvoie son résultat par return ; print ne fait qu'afficher.

Démarche

Recopier l'en-tête exact : def nom(param):.
Écrire la spécification en commentaire : types reçus, hypothèses, ce qui est renvoyé.
Traiter à la main l'exemple de l'énoncé, puis un cas limite (liste vide, zéro).
Écrire le corps, avec des noms parlants et un commentaire court sur chaque étape non évidente.
Vérifier que tous les chemins se terminent par un return du bon type.

Rédaction type

def occurrences(L, x):
    # L : liste ; x : valeur
    # renvoie le nombre d'éléments de L égaux à x (int)
    nb = 0
    for y in L:
        if y == x:
            nb = nb + 1
    return nb

« Q.3 : la fonction parcourt une fois la liste et compte les éléments égaux à x ; elle renvoie un entier, 0 pour une liste vide. »

Exemple traité

print(occurrences([7, 2, 7, 7, 5], 7), occurrences([], 7))

Le programme affiche :

3 0

Erreurs fréquentes

Changer le nom ou l'ordre des paramètres : la fonction ne correspond plus à la question, et les questions suivantes qui l'appellent non plus.
Afficher le résultat au lieu de le renvoyer.
Renvoyer un type différent de celui demandé : les correcteurs du concours CCINP (rapport 2021, filière PSI) refusent les chaînes "True" et "False" quand un booléen est demandé.
Écraser un paramètre en l'initialisant (L = [] en début de fonction) : on perd la donnée reçue.

Pour s’entraîner

Exercices 10 et 15, problèmes 1 et 4.

Un exercice corrigé Extrait gratuit

Exercice Sommes, puissances, pairs et indices ★☆☆

Q.3. Écrire la fonction som_puiss(x, n) qui reçoit en paramètres un réel x non nul et un entier positif n, et qui renvoie la valeur de la somme $x^0 + x^1 + x^2 + \dots + x^n$ .

Q.5. Écrire la fonction pairs(L) qui reçoit une liste L d'entiers positifs et renvoie une nouvelle liste contenant les nombres pairs de L. Exemple : pairs([15, 42, 7, 25, 42, 10]) renvoie [42, 42, 10].

Q.6. Écrire la fonction impairs(L) qui reçoit une liste L d'entiers positifs et renvoie le nombre d'éléments impairs de L.

Q.7. Écrire la fonction indices(x, L) qui reçoit un nombre x et une liste de nombres L, et renvoie une nouvelle liste contenant les indices des occurrences de x dans L. Exemple : indices(7, [15, 7, 42, 7, 7, 25, 7, 17]) renvoie [1, 3, 4, 6].

Indications

Q.3, méthode 9 : chaque puissance s'obtient à partir de la précédente en multipliant par x ; inutile de la recalculer.
Q.5 et Q.7 : une liste de résultats commence vide et se remplit par append.
Q.7 : on a besoin des indices, donc on parcourt range(len(L)).

Correction détaillée

Q.3. Analyse. On garde dans p la puissance courante : au tour k, p vaut $x^k$ ; on l'ajoute, puis on la multiplie par x pour le tour suivant.

def som_puiss(x, n):
    # x réel non nul, n entier positif
    # renvoie x**0 + x**1 + ... + x**n
    s = 0
    p = 1                   # p = x ** k au tour k
    for k in range(n + 1):
        s = s + p
        p = p * x
    return s

print(som_puiss(2, 10), som_puiss(0.5, 3))

Le programme affiche :

2047 1.875

Contrôle : $1 + 2 + \dots + 2^{10} = 2^{11} - 1 = 2047$ , et $1 + 0{,}5 + 0{,}25 + 0{,}125 = 1{,}875$ . La fonction fait $n + 1$ tours et $2(n + 1)$ opérations ; recalculer x ** k à chaque tour en ferait davantage.

Q.5, Q.6 et Q.7. Analyse. Pour Q.5 et Q.6, le parcours par élément suffit : seule la valeur compte. Pour Q.7, il faut renvoyer des positions : on parcourt les indices.

def pairs(L):
    # renvoie la liste des éléments pairs de L
    R = []
    for x in L:
        if x % 2 == 0:
            R.append(x)
    return R

def impairs(L):
    # renvoie le nombre d'éléments impairs de L
    nb = 0
    for x in L:
        if x % 2 == 1:
            nb = nb + 1
    return nb

def indices(x, L):
    # renvoie la liste des indices i tels que L[i] == x
    R = []
    for i in range(len(L)):
        if L[i] == x:
            R.append(i)
    return R

print(pairs([15, 42, 7, 25, 42, 10]))
print(impairs([15, 42, 7, 25, 42, 10]))
print(indices(7, [15, 7, 42, 7, 7, 25, 7, 17]))
print(indices(3, [15, 7]))

Le programme affiche :

[42, 42, 10]
3
[1, 3, 4, 6]
[]

Interprétation : quand $x$ n'apparaît pas, indices renvoie la liste vide, ce qui est la bonne réponse et non une erreur.

Méthodes à retenir

Liste de résultats : R = [] avant la boucle, R.append(...) dedans, return R après. Parcours par élément pour les valeurs, par indice pour les positions. Voir les méthodes 4 et 9.

Dans le chapitre complet

Le cours détaillé, toute la fiche « L'essentiel », 20 méthodes, 22 pièges corrigés, la carte mentale, 36 exercices corrigés, 4 problèmes de concours, les fiches à mémoriser et l'assistant qui répond à tes questions. Ce chapitre est offert : il s’ouvre en entier avec un compte d’essai gratuit.

Ouvrir l'essai gratuit Une question ? WhatsApp

Plan du cours

1. Programmes et interpréteur
- 1.1 Un programme, une suite d'instructions
- 1.2 Entrées, traitement, sorties
- 1.3 Lire un message d'erreur
2. Valeurs, types, expressions
- 2.1 Valeurs et types
- 2.2 Opérations arithmétiques
- 2.3 Priorités et parenthèses
- 2.4 Conversions
3. Variables et affectation
- 3.1 Variable et affectation
- 3.2 Mettre à jour une variable
- 3.3 Échanger deux variables
- 3.4 Instruction et expression
- 3.5 Une première fonction
4. Booléens et instructions conditionnelles
- 4.1 Comparaisons
- 4.2 Les opérateurs and, or, not
- 4.3 L'instruction conditionnelle
- 4.4 Couvrir tous les cas
5. La boucle for
- 5.1 Répéter un bloc avec range
- 5.2 Parcourir une chaîne ou une liste
- 5.3 Compteur, accumulateur, drapeau
- 5.4 Boucles imbriquées
6. La boucle while et les sorties anticipées
- 6.1 Répéter tant qu'une condition est vraie
- 6.2 La boucle à seuil
- 6.3 Une boucle doit s'arrêter
- 6.4 Choisir entre for et while
- 6.5 Sortir d'une boucle avant la fin
7. Fonctions
- 7.1 Définir et appeler une fonction
- 7.2 Renvoyer plusieurs valeurs
- 7.3 Composer des fonctions
- 7.4 Portée des variables
- 7.5 Appel par valeur et effet de bord
- 7.6 Modules
8. Spécifier et vérifier une fonction
- 8.1 Signature et spécification
- 8.2 Assertions
- 8.3 Tester une fonction
9. Compléments du programme marocain
- 9.1 Lire au clavier : input et eval
- 9.2 Afficher un résultat mis en forme : les f-strings
- 9.3 Division entière et reste d'un entier négatif
- 9.4 L'instruction continue
- 9.5 Arguments à valeur par défaut, arguments nommés
- 9.6 Modifier une variable globale : global
- 9.7 Fonctions lambda et fonctions imbriquées

Les méthodes du chapitre

Chaque méthode est une fiche : quand l'utiliser, le rappel de cours, les étapes, la rédaction attendue sur la copie, un exemple traité, les erreurs à éviter.

Prévoir la valeur et le type d'une expression
Écrire la trace d'un programme en tableau
Échanger deux variables et mettre à jour plusieurs variables en même temps
Utiliser // et % : division euclidienne, parité, durées, chiffres
Écrire une instruction conditionnelle qui couvre tous les cas
Écrire une condition booléenne juste et la renvoyer directement
Choisir entre for et while
Régler les bornes d'une boucle for
Accumuler : somme, produit, compteur, moyenne, liste de résultats
Écrire une boucle while à seuil qui s'arrête
Chercher avec sortie anticipée : « il existe » et « pour tout »
Calculer les termes d'une suite récurrente
Écrire une fonction à partir d'un énoncé de concours
Réutiliser les fonctions des questions précédentes
Prévoir l'effet d'un appel sur les variables
Protéger une fonction par assert et la tester
Lire un message d'erreur et corriger un programme
Traduire un pseudo-code en Python
Lire une saisie, la convertir et afficher un résultat mis en forme
Prévoir la sortie d'un programme qui utilise global, continue, des arguments par défaut ou une lambda

Les exercices corrigés

Chaque exercice a ses indications, sa correction rédigée et ce qu'il faut en retenir.

Application directe (15)

Valeur et type d'expressions
Le tableau d'état d'un programme
Convertir une durée
L'année bissextile
La classe d'une adresse IP
Combien de tours ?
Sommes, puissances, pairs et indices
Types de moyennes
Une case du bord
Afficher ou renvoyer
Importer et comparer
Trouver toutes les erreurs
Saisir deux entiers, afficher la division euclidienne
Résoudre une équation du second degré saisie au clavier
break et continue

Entraînement (16)

Nombres égaux à la somme des cubes de leurs chiffres
Factorielles dans une liste
Les nombres parfaits
Les coefficients binomiaux
Premier rang qui dépasse un seuil
La suite de Syracuse
Deux suites récurrentes
L'exponentiation rapide traduite d'un pseudo-code
Sommes simples et doubles
Prévoir la portée des variables
Que calcule ce programme ?
Profil d'une grotte
Retrouver un identifiant binaire
Corriger un test de doublons
Un programme à prédire avec global
Volume et masse d'un ellipsoïde

Approfondissement (5)

Placer des particules sur un segment
Un générateur pseudo-aléatoire
La date du lendemain
Un test de primalité plus rapide
Fonctions en paramètre et fonctions lambda

Les problèmes de concours

Des extraits de sujets réels, corrigés en entier, avec la durée conseillée et les méthodes mobilisées.

Diviseurs, nombres premiers et PGCD
CNC 2026, filière MP, épreuve d'informatique, exercice « Plus grand diviseur commun », questions 1 à 7, complétées
Chiffres d'un entier et palindromes
CNC 2026, filière PSI, épreuve d'informatique, exercice « Nombre palindrome », questions 1 à 6
La formule d'Euler pour π
CNC 2022, filière TSI, épreuve d'informatique, exercice « Approximation du nombre π », questions 1 à 6, complétées
Clés de contrôle d'un numéro
CCINP 2023, filière TSI, épreuve d'informatique, partie I, questions 1 à 4, et partie II, questions 5 et 6, complétées

Questions fréquentes

Quelle est la différence entre print et return en Python ?

print affiche une valeur à l'écran ; return arrête la fonction et donne la valeur de l'appel. Seul return permet de réutiliser le résultat dans un calcul ou dans une autre fonction. Une fonction sans return renvoie None. Dans un sujet de concours qui demande une fonction qui « renvoie » ou « retourne », afficher le résultat au lieu de le renvoyer est une erreur.

Quelle différence entre / et // en Python ?

/ donne toujours un flottant : 6 / 3 vaut 2.0. // donne le quotient de la division euclidienne et % son reste : pour $a \geq 0$ et $b > 0$ , on a $a = bq + r$ avec $q$ = a // b, $r$ = a % b et $0 \leq r < b$ . Ces deux opérateurs servent à tester la parité, convertir une durée ou extraire les chiffres d'un entier.

Comment choisir entre une boucle for et une boucle while ?

On se demande si l'on connaît le nombre de tours avant d'entrer. Si oui, on écrit une boucle for, qui s'arrête d'elle-même. Sinon (seuil, condition d'arrêt), on écrit une boucle while, avec une initialisation, une condition, une mise à jour, et une quantité entière positive qui décroît strictement à chaque tour pour être sûr qu'elle s'arrête. Exemple : le premier entier dont le carré dépasse 1000 demande un while.

Combien de tours fait for i in range(a, b) ?

for i in range(n) fait $n$ tours, avec i de 0 à $n - 1$ . for i in range(a, b) fait $b - a$ tours si $a \leq b$ , et aucun sinon, avec i de $a$ à $b - 1$ . Pour aller de 1 à $n$ , on écrit range(1, n + 1). Deux boucles imbriquées de $n$ et $m$ tours exécutent le corps $n \times m$ fois.

Pourquoi Python affiche UnboundLocalError ?

Un nom affecté quelque part dans une fonction est local dans toute la fonction. Si la fonction lit ce nom avant de l'affecter, en pensant lire la variable globale du même nom, Python lève une UnboundLocalError. Une fonction peut lire une variable globale seulement si elle n'affecte nulle part ce nom. Les variables locales disparaissent à la fin de l'appel.

Comment échanger deux variables en Python ?

On écrit a, b = b, a : Python calcule d'abord les deux valeurs de droite, puis les range dans a et b. De même, a, b = b, a + b met à jour deux variables avec leurs anciennes valeurs, ce qui sert pour les suites récurrentes. L'affectation x = e est une instruction, pas une égalité : la comparaison s'écrit ==.

Comment y accéder

Ce chapitre fait partie des chapitres offerts : il s'ouvre en entier avec un compte d'essai gratuit. Créer un compte d'essai ou se connecter. Pour l'accès complet, les tarifs ou une question, écris-nous sur WhatsApp.

Bases de Python en prépa : cours, méthodes et exercices corrigés

Ce que tu sauras faire

L'essentiel : Valeurs, opérations, variables Extrait gratuit

Une méthode du chapitre Extrait gratuit

Un exercice corrigé Extrait gratuit

Plan du cours

Les méthodes du chapitre

Les exercices corrigés

Application directe (15)

Entraînement (16)

Approfondissement (5)

Les problèmes de concours

Questions fréquentes

Comment y accéder

Toute ta prépa au même endroit