poly python (2)

Cours d’Informatique pour Tous
Jules Svartz
Lycée Masséna

Lycée Masséna
Svartz Page 2/191

Lycée Masséna
Préambule
Ces notes de cours sont issues du cours d’informatique commune (IPT) subi par les élèves du lycée Masséna des
classes de première année MPSI (831), PCSI (833) et de deuxième année MP*, MP, PC*, PC.
Le cours présenté ici est très détaillé, et tous les points ne sont pas nécessairement abordés en classe : il se veut
utile autant pour l’élève qui veut un récapitulatif que pour celui qui souhaite aller plus loin.
Le polycopié se divise en 4 parties, elles-mêmes subdivisées en 13 chapitres. À ceux-ci s’ajoute un dernier chapitre
explicitant brièvement l’usage des modules usuels en Python, notamment Numpy. Les trois premières parties sont
relatives au programme de première année, la quatrième au programme de deuxième année. Le plan choisi est le
suivant :
— La première partie est dévolue à l’« initiation ». Malgré ce nom, elle est fondamentale, notamment les chapitres
2 et 3. Elle se subdivise en 4 chapitres :
— Le chapitre 0 est un chapitre d’introduction à l’informatique, il présente un point de vue historique sur le
développement de cette discipline, les principaux éléments constitutifs d’un ordinateur et le rôle du système
d’exploitation. Le cours présenté ici est habituellement présenté en fin d’année, par choix pédagogique :
il est en effet plus facile d’expliquer précisément le comportement d’un micro-processeur à des élèves qui
savent déja programmer et ont une connaissance du système de numération binaire.
— Le chapitre 1 présente de manière détaillée les éléments au programme concernant la programmation en
Python. Il est en pratique présenté peu à peu en cours et en TP, parallèlement aux chapitres qui suivent.
L’utilisation des modules n’est pas présentée en détail dans ce chapitre mais reléguée en fin de polycopié.
— Le chapitre 2 présente la représentation des nombres (entier et flottants) dans un ordinateur. Il est plus
détaillé que ce que préconise le programme officiel, mais les algorithmes de changements de base sur les
entiers offrent une bonne introduction à l’algorithmique. L’addition des entiers relatifs sur des registres de
taille fixée permet de plus de comprendre le fonctionnement d’un processeur. Enfin, la représentation des
flottants offre un premier avertissement sur les erreurs d’arrondis.
— Le chapitre 3 donne les outils pour l’analyse théorique des algorithmes (terminaison / correction / com-
plexité). C’est un chapitre crucial où sont présentés les algorithmes « basiques » au programme de première
année : parcours de listes, recherche dichotomique ou de motif dans une chaîne de caractères...
— La deuxième partie est dévolue à l’analyse numérique. Elle est très (peut-être trop) détaillée, mais c’est également
un choix pédagogique motivé par l’importance qu’occupent les questions d’analyse numérique dans les concours.
Elle se découpe en 5 chapitres.
— Le chapitre 4 présente une sensibilisation aux erreurs numériques et fait suite au chapitre 2. Peut-être un
peu rébarbative, il explique certains comportements « étranges » observés en TP, à cause de l’utilisation
des nombres flottants.
— Le chapitre 5 présente les deux méthodes au programme pour la résolution d’équations numériques : la
méthode de la dichotomie et la méthode de Newton.
— Le chapitre 6 présente la résolution d’équations linéaires via l’algorithme du pivot de Gauss. Là encore, on
fait attention aux erreurs d’arrondis.
— Le chapitre 7 présente des méthodes d’intégration de fonctions. Bien que la seule méthode au programme
soit la méthode des rectangles (à gauche), on étudie également des méthodes d’ordre supérieur, notamment
la méthode des trapèzes qui fait des apparitions régulières aux concours.
— Le chapitre 8 présente des méthodes de résolution d’équations différentielles. On fait le lien avec le cha-
pitre précédent : les méthodes de résolution sont vues comme des applications des méthodes d’intégration
approchée. Là encore, seule la méthode d’Euler (explicite) est au programme, mais d’autres méthodes font
également l’objet de questions aux concours.
Svartz Page 3/191

Lycée Masséna
— Le chapitre 9, unique chapitre de la partie 3 (Bases de données), présente les bases de SQL et de l’algèbre
relationnelle. Le choix de présenter l’algèbre relationnelle (pas clairement au programme) est là aussi motivé par
sa présence aux concours.
— La partie 4 (Algorithmique avancée) présente le programme de deuxième année.
— Le chapitre 10 présente les algorithmes de tris « naïfs », c’est-à-dire quadratiques. C’est une bonne occasion
de mettre en pratique les concepts introduits au chapitre 3.
— Le chapitre 11 présente la structure de pile (seule structure abstraite au programme). Pour justifier le
chapitre, plusieurs applications sont données. On présente également une autre structure abstraite, celle de
file.
— Le chapitre 12 introduit la récursivité, en s’appuyant sur le chapitre précédent. Pour ne pas se cantonner
aux exemples « triviaux » d’algorithmes récursifs, on présente notamment un algorithme « Diviser pour
régner ».
— Enfin, le chapitre 13 présente, en lien avec le chapitre précédent, les deux algorithmes de tri efficaces au
programme : le tri fusion et le tri rapide. On donne également un algorithme de calcul de la médiane en
temps linéaire en moyenne, basé sur une variante du tri rapide.
— Le chapitre 14, relégué en annexe, donne une présentation des modules usuels. Bien que leur connaissance ne
soit pas exigible à l’écrit des concours, les écrits proposent souvent des questions où ils sont utilisés (notamment
Numpy), même si certaines fonctions sont données en formulaire. La connaissance des modules est également
utile pour la deuxième épreuve de mathématiques à l’oral de Centrale, ou encore pour effectuer des modélisations
dans un TIPE.
Licence. Cette œuvre est mise à disposition sous licence Attribution - Partage dans les Mêmes Conditions 2.0 France.
Pour voir une copie de cette licence, visitez http://creativecommons.org/licenses/by-sa/2.0/fr/ ou écrivez à
Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
Svartz Page 4/191

TABLE DES MATIÈRES Lycée Masséna
Table des matières
I Initiation 11
0 Ordinateurs, Systèmes d’exploitation et Python 13
0.1 Qu’estcequ’unordinateur?.......................................... 13
0.1.1 Turingetsesmachines......................................... 13
0.1.2 Prémices aux ordinateurs et modèle de Von Neumann . . . . . . . . . . . . . . . . . . . . . . . 15
0.1.3 Lerôledechaqueélément........................................ 16
0.1.4 Avantagesetinconvénients ...................................... 17
0.1.5 Denosjours .............................................. 17
0.1.6 Ordresdegrandeur........................................... 17
0.2 Lesystèmed’exploitation ........................................... 18
0.2.1 Lemultitâche.............................................. 19
0.2.2 Identification des utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
0.2.3 Organisationdesfichiers........................................ 20
0.2.4 Droitsd’accès.............................................. 20
0.3 LelangagePython ............................................... 21
1 Programmation en Python 23
1.1 Typessimplesetexpressions ......................................... 23
1.1.1 Expressions............................................... 23
1.1.2 Entiers.................................................. 24
1.1.3 Flottants ................................................ 25
1.1.4 Booléens................................................. 25
1.2 Variables .................................................... 26
1.2.1 Identificateurs ............................................. 26
1.2.2 Variables ................................................ 27
1.3 Structuresdecontrôle ............................................. 28
1.3.1 Pythonetl’indentation......................................... 28
1.3.2 Instruction conditionnelle if/else (si/sinon) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.3.3 Boucle conditionnelle while (tant que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.3.4 Boucle inconditionnelle for... (pour...) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.3.5 BreaketContinue ........................................... 31
1.3.6 Bouclesimbriquées........................................... 32
1.4 Structuresdedonnées ............................................. 32
1.4.1 Listes .................................................. 32
1.4.2 Tuples.................................................. 35
1.4.3 Chaînesdecaractères ......................................... 36
1.5 Fonctions .................................................... 38
1.5.1 Motivation ............................................... 38
1.5.2 Notionsetsyntaxedebase ...................................... 38
1.5.3 Variableslocalesetglobales...................................... 41
1.5.4 Passageparréférences.......................................... 42
1.5.5 Une fonction : un objet comme les autres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
1.6 Entrées/Sorties................................................. 43
1.6.1 printetinput.............................................. 43
1.6.2 Fonctionspourlesfichiers....................................... 44
Svartz Page 5/191