Apprendre à programmer avec C et Python

Violeta Felea
Victor Felea
Jean-Pierre Steen
Violeta Felea, Victor Felea et Jean-Pierre Steen
Apprendre à programmer
avec C et Python
Apprendre à
programmer
avec C et Python
dut et licence 1
informatique
bts services
informatiques
aux organisations
dut et licence 1 informatique
bts services informatiques
aux organisations
Apprendre à programmer avec C et Python
Cours et exercices corrigés
Destiné aux étudiants des premiers cycles de l’enseignement supérieur
qui débutent dans le développement des applications informatiques,
cet ouvrage aborde la pratique de deux langages de programmation,
C et Python. Il comprend une synthèse de leur présentation, de nombreux
problèmes résolus et des exercices d’approfondissement.
La résolution des problèmes est traitée suivant le cycle de développement
analyse – conception – codage. L’analyse du problème conduit à la
conception d’un algorithme répondant aux exigences exprimées. Chaque
solution algorithmique est proposée, dans chacun des deux langages.
Violeta Felea est maître de conférences en informatique à l’université de Franche-Comté.
Ses travaux concernent les algorithmes et les systèmes parallèles et distribués.
Victor Felea est professeur honoraire en informatique à l’université AI. I. Cuza de Iasi, en Roumanie,
où il enseigne les algorithmes et les systèmes d’exploitation de bases de données.
Il est auteur de plusieurs manuels d’informatique dans le domaine des bases de données.
Jean-Pierre Steen est professeur honoraire en informatique à l’université de Lille 1 et mathématicien
formé au calcul numérique.
ISBN 978-2-311-40199-8
9 782311 401998
www.VUIBERT.fr
Sommaire
1. C et Python - fondements
2. Approche de programmation modulaire
3. Problèmes corrigés
4. Modélisation : exemples de jeux programmés
5. Exercices d’approfondissement
Index
Bibliographie
• Cours complet
• Algorithmes, codages, tests
• Problèmes intégralement résolus
Python.indd 1 04/08/15 16:19
• Exercices d’approfondissement

i
i
“ProgrammationExos” — 2015/8/12 — 14:37 — page i — #1 i
i
i
i
i
i
Table des matières
Retrouvez des compléments numériques en accès libre
sur le site www.Vuibert.fr à la page du livre.
Préface iii
1 C et Python – fondements 1
1.1 Cycle de développement informatique . . . . . . . . . . . . . . . . . . 1
1.2 Variables, types, expressions . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Instructions................................. 26
1.4 Structure du programme principal . . . . . . . . . . . . . . . . . . . . 43
2 Approche de programmation modulaire 45
2.1 Fonctions : paramètres et appels . . . . . . . . . . . . . . . . . . . . . 45
2.2 Modularité en langage algorithmique . . . . . . . . . . . . . . . . . . . 46
2.3 Modularité en langage C . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.4 Modularité en langage Python . . . . . . . . . . . . . . . . . . . . . . 54
2.5 Optimisation des performances de la récursivité . . . . . . . . . . . . . 61
2.6 Fonctions de bibliothèque . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.7 Compilation et exécution des programmes . . . . . . . . . . . . . . . . 73
3 Problèmes corrigés 77
3.1 Constantes, variables, expressions . . . . . . . . . . . . . . . . . . . . . 77
3.2 Primitives – Instruction simple – Bloc d’instructions . . . . . . . . . . 84
3.3 Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . 93
3.4 Instructions répétitives . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
3.5 Modularité ................................. 152
3.6 Typescomposites.............................. 201
3.7 Techniques algorithmiques . . . . . . . . . . . . . . . . . . . . . . . . . 253
4 Modélisation : exemples de jeux programmés 309
5 Exercices proposés 343
5.1 Constantes, variables, expressions . . . . . . . . . . . . . . . . . . . . . 343
5.2 Primitives – Instruction simple – Bloc d’instructions . . . . . . . . . . 344
5.3 Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . 346
5.4 Instructions répétitives . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
5.5 Modularité ................................. 349

i
i
“ProgrammationExos” — 2015/8/12 — 14:37 — page ii — #2 i
i
i
i
i
i
ii Table des matières
5.6 Typescomposites.............................. 355
5.7 Techniques algorithmiques . . . . . . . . . . . . . . . . . . . . . . . . . 370
5.8 Modélisation ................................ 378
Index 397
Index des termes génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
Index des notions algorithmiques . . . . . . . . . . . . . . . . . . . . . . . . 399
Index des notions en langage C . . . . . . . . . . . . . . . . . . . . . . . . . 400
Index des notions en langage Python . . . . . . . . . . . . . . . . . . . . . . 401
Bibliographie 403

i
i
“ProgrammationExos” — 2015/8/12 — 14:37 — page 45 — #51 i
i
i
i
i
i
CHAPITRE 2
Approche de programmation modulaire
La conception modulaire est une technique de conception de logiciel qui s’appuie sur
la composition du logiciel en parties séparées. Dans la phase d’analyse du problème,
une analyse du découpage du problème en sous-problèmes s’impose. Cette analyse
devrait déceler la fonctionnalité d’un algorithme, ses données d’entrée, ses données en
sortie ou les données, en entrée, à modifier.
La section suivante présente les principes génériques de la modularité. Les trois
autres sections abordent la mise en place de ces principes dans le langage algorithmique,
ainsi que dans les langages C et Python.
2.1 Fonctions : paramètres et appels
La modularité fait partie des bonnes pratiques de la conception logicielle. Il s’agit
de définir des parties de code, appelées génériquement fonctions, répondant à une
fonctionnalité précise, pouvant à la fois apporter de la généricité
1
et de la réutilisation.
Une conception modulaire facilite la lisibilité du code et sa maintenance.
Les fonctions doivent pouvoir être reliées les unes aux autres. Par conséquent,
deux notions les caractérisent : le paramétrage (les fonctions peuvent prendre des
paramètres, afin d’échanger des données entre elles) et l’appel (ces fonctions doivent
pouvoir être appelées et peuvent en appeler d’autres). Afin que l’appel puisse être
réalisé, une fonction doit être déclarée.
La définition d’une fonction précise, d’un point de vue syntaxique :
– son entête (appelée aussi dans les langages de programmation signature ou proto-
type), nécessaire pour la fonction qui l’appelle. Ceci constitue ainsi l’interfaçage
entre la fonction appelante et la fonction appelée. L’entête précise : le nom de la
fonction et les paramètres, notés par des identificateurs de paramètres séparés
par des virgules ;
– son corps, qui comprend la partie de déclaration de variables locales et les
instructions liées au traitement.
1
La généricité (ou la programmation générique) consiste à définir des algorithmes/programmes iden-
tiques opérant sur des données différentes.