Introduction au langage Python : cours, méthodes et exercices corrigés d'informatique ECS1 et ECT1

Q: Pourquoi input renvoie une chaîne et pas un nombre ?

`input` renvoie toujours le texte tapé au clavier, même si ce sont des chiffres : la saisie 40 donne la chaîne `"40"`, et `"40" * 2` vaut `"4040"`. Pour calculer, on convertit : `n = int(input("Nombre : "))` pour un entier, `float(input(...))` pour un nombre à virgule, écrit avec un point.

Q: Quelle différence entre print et return dans une fonction Python ?

`print` affiche une valeur pour le lecteur ; `return` renvoie la valeur au programme et arrête la fonction. Seul le résultat renvoyé peut servir au calcul suivant. Une fonction sans `return` renvoie `None` : `print(f(3))` affiche alors le texte de `f`, puis `None`.

Q: Comment trouver le plus petit n tel que u(n) dépasse un seuil en Python ?

On écrit une boucle `while` dont la condition est le contraire de l'objectif : on initialise le rang `n = 0` et le terme, puis `while u <= A:`, on augmente `n` de 1 et on calcule le terme suivant. À la sortie, `n` est le premier rang tel que u dépasse A. Il faut renvoyer le rang et non le terme si c'est le rang qu'on demande.

Q: Combien de tours fait for k in range(1, n) ?

`range(1, n)` parcourt 1, 2, ..., n − 1 : la borne de droite n'est jamais atteinte, d'où n − 1 tours. Pour aller de 1 à n inclus, on écrit `range(1, n + 1)`. De façon générale, `range(a, b)` fait b − a tours.

Q: Que donnent // et % en Python ?

Pour deux entiers positifs, `a // b` est le quotient et `a % b` le reste de la division euclidienne : 17 // 5 vaut 3 et 17 % 5 vaut 2, car 17 = 5 × 3 + 2. Ils servent à compter des paniers complets et ce qui reste en caisse, à tester la parité avec `n % 2 == 0` ou à séparer les chiffres d'un entier. `/` donne toujours un nombre à virgule : 10 / 5 vaut 2.0.

Q: Comment utiliser sqrt ou arrondir à l'entier supérieur en Python ?

On importe le module `math` : `import math`, puis `math.sqrt(16)` vaut 4.0, `math.floor(7.8)` vaut 7 et `math.ceil(7.2)` vaut 8. On peut aussi écrire `from math import sqrt`, `from math import *` ou `import math as m`. `math.ceil` sert par exemple à arrondir un budget au dirham supérieur.

ECS 1
ECT 1
Offert à l'essai

Premiers programmes en Python : variables et affectation, types de base, opérateurs, entrées et sorties, instructions conditionnelles, boucles for et while, fonctions, avec des exemples tirés de l'économie et de la gestion.

19méthodes
44exercices corrigés
6problèmes
22pièges
35figures

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

Ce chapitre est le premier vrai chapitre de programmation de l'ECS1 et de l'ECT1 au Maroc. Il apprend à écrire un programme en Python sur des calculs tirés de la gestion : les variables et l'affectation, les types int, float, str et bool, les opérateurs /, // et %, la saisie avec input et l'affichage avec print, l'instruction conditionnelle if, elif, else pour un barème à paliers, les boucles for et while (accumulateur, seuil), les fonctions avec def et return, les fonctions lambda et le module math. Les élèves d'ECS1 y trouvent aussi les variables globales, ceux d'ECT1 les instructions break et continue. Il suit la section « Introduction au langage Python » des programmes marocains et prépare aux questions de programmation du CNAEM, posées autrefois en Scilab, et aux algorithmes de l'ISCAE. La page propose un cours où chaque programme est exécuté et sa sortie montrée, des méthodes avec le code à écrire sur la copie, des exercices corrigés pas à pas et des sujets réels du CNAEM et de l'ISCAE réécrits en Python.

Ce que tu sauras faire

Un programme est une suite d'instructions qu'un ordinateur exécute sans se tromper, à condition qu'on les lui donne dans une langue précise. Ce chapitre apprend les premiers mots de cette langue, Python, sur des calculs tirés de la gestion et de la vie d'une association. À la fin, tu dois savoir :

prévoir la valeur et le type d'une expression, et écrire la trace d'un petit programme ;
ranger des valeurs dans des variables, les mettre à jour, les échanger ;
lire une saisie au clavier, la convertir et afficher un résultat ;
écrire une instruction conditionnelle qui couvre tous les cas d'un barème ;
répéter un calcul avec une boucle for ou une boucle while, et choisir la bonne ;
écrire une fonction à partir d'un énoncé, qui renvoie son résultat au lieu de l'afficher ;
utiliser les fonctions du module math et tester un programme sur des valeurs connues.

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

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

Type	Exemples	Conversion
`int` (entier exact, sans limite)	`7`, `-12`	`int("12")`, `int(3.99)` vaut 3
`float` (approché, point décimal)	`12.5`, `3.5e-2`	`float("2.5")`
`str` (texte)	`"Tetouan"`, `"45"`	`str(45)`
`bool`	`True`, `False`

Écriture	Résultat	À retenir
`7 / 2`, `10 / 5`	`3.5`, `2.0`	toujours un `float`
`17 // 5`, `17 % 5`	`3`, `2`	$a = bq + r$ , $0 \le r < b$
`2 3 2`	`512`	`**` se lit de droite à gauche
`-2 ** 2`	`-4`	`**` avant le signe
`"ab" * 3`	`'ababab'`	répétition

Priorités : **, signe -, puis * / // %, puis + -, puis comparaisons, not, and, or.

Une méthode du chapitre Extrait gratuit

Méthode Écrire une boucle while à seuil qui s'arrête

Quand l’utiliser

« Déterminer le plus petit $n$ tel que... », « au bout de combien de jours... », « calculer une valeur approchée à $\varepsilon$ près ».

Rappel de cours

Trois parties : initialisation, condition (négation de l'objectif), mise à jour. À la sortie, la condition est fausse pour la première fois. Le rang et la valeur atteinte sont deux variables différentes.

Démarche

Initialiser le rang et la valeur au rang de départ.
Écrire while suivi du contraire de l'objectif : objectif $u_n > A$ , condition u <= A.
Dans le bloc, avancer le rang de 1 et calculer la nouvelle valeur.
Après la boucle, renvoyer ce que la question demande (le rang ou la valeur).
Vérifier que la mise à jour rapproche bien de l'arrêt.

Rédaction type

Gabarit à compléter :

n = 0              # rang de départ
u = 1              # mettre ici u_0
while u <= 1000:   # contraire de l'objectif u > 1000
    n = n + 1
    u = 3 * u      # mettre ici la relation
print(n)           # le rang, pas le terme

Exemple traité

Question. Un nombre d'adhérents part de 120 et augmente de 15 % par an (hypothèse d'école). Au bout de combien d'années dépasse-t-il 300 ?

annee = 0
adh = 120
while adh <= 300:
    annee = annee + 1
    adh = adh * 1.15
print(annee, round(adh, 1))

Le programme affiche :

7 319.2

Il faut 7 ans ; à la sixième année, on n'avait encore qu'environ 277,6 adhérents.

Erreurs fréquentes

Écrire la condition de l'objectif (while adh > 300) : la boucle ne fait aucun tour.
Oublier annee = annee + 1 : la boucle ne s'arrête plus ou renvoie 0.
Renvoyer la valeur atteinte quand on demande le rang.

Pour s’entraîner

Exercices 21, 22, 23, 27, 30, 31 et 35, problèmes 3, 5 et 6.

Un exercice corrigé Extrait gratuit

Exercice Premier rang qui dépasse un seuil ★★☆

On pose $S_n = \sum_{k=1}^{n} \frac{1}{k}$ . Écrire une fonction rang_somme(A) qui renvoie le plus petit entier $n$ tel que $S_n > A$ . Que renvoie rang_somme(10) ?
On définit $u_0 = 1$ et $u_{n+1} = u_n^2 + 1$ . Écrire une fonction rang_suite(a) qui renvoie le plus petit $n$ tel que $u_n \ge a$ . Que renvoie rang_suite(10 ** 6) ?

Indications

Méthode 12 : on ne connaît pas le nombre de tours, d'où while. La condition de la boucle est le contraire de la condition d'arrêt.
On renvoie le rang n, pas le terme.

Analyse : comment trouver l’idée

On avance terme par terme tant que le seuil n'est pas atteint ; à la sortie, la condition est fausse pour la première fois, et n est le rang cherché. On a admis que les deux suites dépassent n'importe quel seuil : sinon la boucle ne s'arrêterait pas.

Correction détaillée

def rang_somme(A):
    # plus petit n tel que 1/1 + ... + 1/n > A
    s = 0
    n = 0
    while s <= A:
        n = n + 1
        s = s + 1 / n
    return n

def rang_suite(a):
    # u_0 = 1, u_{n+1} = u_n**2 + 1 ;
    # plus petit n tel que u_n >= a
    u = 1
    n = 0
    while u < a:
        u = u * u + 1
        n = n + 1
    return n

print(rang_somme(10))
print(rang_suite(10 ** 6))

Le programme affiche :

12367
6

Pour la seconde : $u_1 = 2$ , $u_2 = 5$ , $u_3 = 26$ , $u_4 = 677$ , $u_5 = 458\,330$ , $u_6 = 210\,066\,388\,901$ ; $u_5 < 10^6 \le u_6$ .

Interprétation : la somme des inverses grandit si lentement qu'il faut 12 367 termes pour dépasser 10, alors que la suite $u_n$ dépasse le million dès le rang 6.

Méthodes à retenir

Seuil : while avec la condition contraire de l'arrêt (s <= A pour s'arrêter à s > A), mise à jour du terme et du rang dans la boucle, return n après. Voir la méthode 12.

Dans le chapitre complet

Le cours détaillé, toute la fiche « L'essentiel », 19 méthodes, 22 pièges corrigés, la carte mentale, 44 exercices corrigés, 6 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. Programme 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, opérations
- 2.1 Les quatre types de base
- 2.2 Les opérations arithmétiques
- 2.3 Priorités et parenthèses
- 2.4 Convertir une valeur
3. Variables et affectation
- 3.1 Une variable, un nom posé sur une valeur
- 3.2 Mettre à jour une variable
- 3.3 La trace d'un programme
- 3.4 Échanger deux variables
4. Entrées et sorties
- 4.1 Lire au clavier : input
- 4.2 Afficher : print
- 4.3 Mettre en forme : les f-strings
5. Booléens et instruction conditionnelle
- 5.1 Comparer deux valeurs
- 5.2 Combiner des conditions : and, or, not
- 5.3 L'instruction conditionnelle
- 5.4 Couvrir tous les cas
6. La boucle for
- 6.1 Répéter un bloc avec range
- 6.2 Compteur et accumulateur
- 6.3 Parcourir une chaîne
- 6.4 Boucles imbriquées
7. La boucle while
- 7.1 Répéter tant qu'une condition est vraie
- 7.2 La boucle à seuil
- 7.3 Une boucle doit s'arrêter
- 7.4 Choisir entre for et while
8. Fonctions
- 8.1 Définir et appeler une fonction
- 8.2 Afficher n'est pas renvoyer
- 8.3 return arrête la fonction
- 8.4 Renvoyer deux valeurs
- 8.5 Composer des fonctions
- 8.6 Variables locales
- 8.7 Fonctions anonymes : lambda
9. Modules
10. Tester un programme
- 10.1 Des valeurs calculées à la main
- 10.2 Les assertions
11. Variables globales
- 11.1 Lire ou modifier une variable globale
- 11.2 L'instruction global
- 11.3 Bonne pratique
11. Interrompre une boucle : break et continue
- 11.1 Sortir d'une boucle : break
- 11.2 Passer au tour suivant : continue
- 11.3 Écrire sans break ni continue

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
Lire une saisie, la convertir et afficher un résultat
Utiliser // et %
Écrire une instruction conditionnelle qui couvre tous les cas
Écrire une condition booléenne juste
Choisir entre for et while
Régler les bornes d'une boucle for
Accumuler avec une boucle : somme, produit, compteur, moyenne
Calculer un terme d'une suite récurrente
Écrire une boucle while à seuil qui s'arrête
Écrire une fonction à partir d'un énoncé et la réutiliser
Prévoir l'effet d'un appel
Lire un message d'erreur et corriger un programme
Traduire un pseudo-code ou un programme Scilab en Python
Importer un module et utiliser une fonction documentée
Prévoir la sortie d'un programme qui utilise une variable globale
Interrompre ou sauter un tour avec break et continue, et réécrire sans eux

Les exercices corrigés

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

Application directe (17)

Valeur et type d'expressions
Le tableau d'état d'un programme
Échanger deux variables, de trois façons
Le prix TTC d'un article saisi au clavier
Convertir une durée
Billets et centimes
La mention d'une note
L'année bissextile
Combien de tours ?
Sommes et produits avec une boucle for
Compléter un compteur dans une boucle
Afficher ou renvoyer
Importer math et calculer
Trouver toutes les erreurs
Définir et appeler une fonction lambda
Le ticket de caisse mis en forme
break et continue : prévoir l'affichage

Entraînement (21)

La prime d'ancienneté
Le taux de rotation du personnel
La somme des carrés des chiffres
Une suite définie par la moyenne des deux termes précédents
Les tables de multiplication de 1 à N
Prévoir l'affichage de conditions imbriquées
Premier rang qui dépasse un seuil
Un seuil avec l'exponentielle
La fonction rang
La factorielle, puis une fonction qui l'appelle
Une fonction définie par morceaux
Sommes simples et doubles
Le seuil de rentabilité d'une coopérative
Prévoir l'effet d'appels sur les variables
Corriger un programme à partir de ses messages d'erreur
Les racines réelles d'un trinôme
Le plus grand de trois nombres sans max
Un programme à prédire avec global
Le compteur de tickets qui lève UnboundLocalError
Le premier jour où la collecte atteint l'objectif
Redemander une quantité tant qu'elle est négative

Approfondissement (6)

La méthode de Héron à epsilon près
Une fonction à boucle while et son nombre d'itérations
Lire deux boucles et conjecturer
Une somme de puissances sur factorielles sans factorielle
Le coefficient binomial
Nombres égaux à la somme des cubes de leurs chiffres

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.

Les points d'aide du comité d'entreprise
CNAEM 2018, filière ECT, Gestion, management et informatique, dossier 4, question 2, complétée
La catégorie d'un client
CNAEM 2021, filière ECT, Gestion, management et informatique, dossier 4, question 4, complétée
Calcul d'un terme et seuil d'une suite
CNAEM 2017, filière ECT, Mathématiques, exercice 2, questions 2.6 et 2.7, complétées
Les nombres de Fibonacci
CNAEM 2021, filière ECT, Mathématiques, problème 2, question 1.6, complétée
Seuil d'une suite récurrente d'ordre 3
CNAEM 2023, filière ECS, Mathématiques et informatique, problème, partie 2, question 2.7.3, complétée
La suite de Syracuse
ISCAE 2019, concours de la Grande École, épreuve de comptabilité-gestion, épreuve 3 « Informatique », sujet 1, complété

Questions fréquentes

Pourquoi input renvoie une chaîne et pas un nombre ?

input renvoie toujours le texte tapé au clavier, même si ce sont des chiffres : la saisie 40 donne la chaîne "40", et "40" * 2 vaut "4040". Pour calculer, on convertit : n = int(input("Nombre : ")) pour un entier, float(input(...)) pour un nombre à virgule, écrit avec un point.

Quelle différence entre print et return dans une fonction Python ?

print affiche une valeur pour le lecteur ; return renvoie la valeur au programme et arrête la fonction. Seul le résultat renvoyé peut servir au calcul suivant. Une fonction sans return renvoie None : print(f(3)) affiche alors le texte de f, puis None.

Comment trouver le plus petit n tel que u(n) dépasse un seuil en Python ?

On écrit une boucle while dont la condition est le contraire de l'objectif : on initialise le rang n = 0 et le terme, puis while u <= A:, on augmente n de 1 et on calcule le terme suivant. À la sortie, n est le premier rang tel que u dépasse A. Il faut renvoyer le rang et non le terme si c'est le rang qu'on demande.

Combien de tours fait for k in range(1, n) ?

range(1, n) parcourt 1, 2, ..., n − 1 : la borne de droite n'est jamais atteinte, d'où n − 1 tours. Pour aller de 1 à n inclus, on écrit range(1, n + 1). De façon générale, range(a, b) fait b − a tours.

Que donnent // et % en Python ?

Pour deux entiers positifs, a // b est le quotient et a % b le reste de la division euclidienne : 17 // 5 vaut 3 et 17 % 5 vaut 2, car 17 = 5 × 3 + 2. Ils servent à compter des paniers complets et ce qui reste en caisse, à tester la parité avec n % 2 == 0 ou à séparer les chiffres d'un entier. / donne toujours un nombre à virgule : 10 / 5 vaut 2.0.

Comment utiliser sqrt ou arrondir à l'entier supérieur en Python ?

On importe le module math : import math, puis math.sqrt(16) vaut 4.0, math.floor(7.8) vaut 7 et math.ceil(7.2) vaut 8. On peut aussi écrire from math import sqrt, from math import * ou import math as m. math.ceil sert par exemple à arrondir un budget au dirham supérieur.

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.