Algorithmique : techniques fondamentales de programmation : exemples en Python : nombreux exercices corrigés

Auteur(s) :

Crépin, Ludivine Découvrir l'auteur

Résumé

Présentation des bases de la programmation illustrée d'exercices corrigés. Les algorithmes sont réécrits en Python et les sources, directement utilisables, sont disponibles en téléchargement sur le site de l'éditeur.

Éditeur(s)
- Éditions ENI
Date
- C 2023
Notes
- La couv. porte en plus : "En téléchargement : code source des exemples", "BTS, DUT informatique", "Version en ligne offerte ! pendant 1 an"
- La 4e de couv. indique : Sur www.editions-eni.fr : le code source en Python de la plupart des exemples du livres
- Contient un "flashcode" permettant d'accéder à un contenu via Internet
Langues
- Français
Description matérielle
- 1 vol. (306 p.) : ill. ; 21 cm
Collections
- Ressources informatiques
Sujet(s)
ISBN
- 978-2-409-04184-6
Indice
- 681.21(07) Algorithmes de programmation. Manuels
Quatrième de couverture
- Algorithmique
  Techniques fondamentales de programmation (exemples en Python)
  Ce livre sur l'algorithmique s'adresse à toute personne désireuse de maîtriser les bases essentielles de la programmation. Pour apprendre à programmer, il faut d'abord comprendre ce qu'est vraiment un ordinateur, comment il fonctionne et surtout comment il peut faire fonctionner des programmes, comment il manipule et stocke les données et les instructions, quelle est sa logique. Alors, au fur et à mesure, le reste devient évidence : variables, tests, conditions, boucles, tableaux, fonctions, fichiers, jusqu'aux notions avancées comme les compréhensions de listes et les objets.
  Le langage algorithmique (ou la syntaxe du pseudo-code des algorithmes) reprend celui couramment utilisé dans les écoles d'informatique et dans les formations comme les BTS, DUT, première année d'ingénierie à qui ce livre est principalement destiné et conseillé. Une fois les notions de base acquises, le lecteur trouvera dans ce livre de quoi évoluer vers des notions plus avancées : un chapitre sur les objets ouvre les portes de la programmation dans des langages évolués et puissants comme le C, le C++, le Java, le C# et surtout Python.
  À la fin de chaque chapitre, l'auteur propose de nombreux exercices corrigés permettant de consolider ses acquis.
  Tous les algorithmes de ce livre sont réécrits en Python et les sources, directement utilisables, sont disponibles en téléchargement sur le site www.editions-eni.fr.
Tables des matières
- - Algorithmique
  - Techniques fondamentales de programmation
  - Editions ENI
  - Avant-propos
  - Chapitre 1
  - Introduction à l'algorithmique
  - 1. Les fondements de l'informatique15
  - 1.1 Architecture de l'ordinateur15
  - 1.2 Implémentation de la mémoire17
  - 1.2.1 Différentes mémoires18
  - 1.2.2 Programme et mémoire18
  - 2. L'algorithmique, l'art de programmer19
  - 2.1 L'algorithmie, comment et pourquoi ?19
  - 2.1.1 Exemples de la vie courante19
  - 2.1.2 Algorithmes20
  - 3. Les langages, la mise en oeuvre21
  - 3.1 La programmation21
  - 3.2 Les différents types de langages22
  - 3.2.1 Programmation procédurale22
  - 3.2.2 Programmation orientée objet22
  - 3.2.3 Programmation fonctionnelle23
  - 3.3 Python23
  - Chapitre 2
  - Les variables et opérateurs
  - 1. Les variables simples25
  - 1.1 Types, déclaration et affectation26
  - 1.1.1 Les nombres ou numériques27
  - 1.1.2 Les caractères28
  - 1.1.3 Les booléens30
  - 1.1.4 Les chaînes de caractères30
  - 1.2 Saisie et affichage31
  - 1.3 Les constantes33
  - 2. Utiliser les variables34
  - 2.1 Opérateurs mathématiques communs34
  - 2.2 Opérateurs spécifiques aux entiers35
  - 2.3 Opérateur spécifique aux réels36
  - 2.4 Opérateurs de comparaison36
  - 2.5 Opérateurs logiques pour les booléens37
  - 2.6 Opérateurs sur les caractères38
  - 3. Les opérations sur les chaînes39
  - 3.1 Concaténation39
  - 3.2 Extraction40
  - 3.3 Longueur40
  - 4. Et avec les langages ?41
  - 4.1 Typage41
  - 4.1.1 Les langages à typage statique42
  - 4.1.2 Les langages à typage dynamique42
  - 4.1.3 Langages fortement typés42
  - 4.1.4 Langages faiblement typés43
  - 4.2 Opérateurs43
  - 4.3 Gestion de la mémoire44
  - 4.4 La gestion des réels45
  - 5. Python et les types46
  - 5.1 Installation46
  - 5.2 Langage interprété48
  - 5.3 Typage et affection48
  - 5.3.1 Convention de nommage49
  - 5.3.2 Affection et commentaire49
  - 5.3.3 Opérateurs sur les types50
  - 5.4 Un premier script51
  - 5.4.1 ECRIRE en Python51
  - 5.4.2 LIRE en Python52
  - 5.5 Opérateurs52
  - 5.5.1 Opérateurs arithmétiques52
  - 5.5.2 Opérateurs de comparaison53
  - 5.5.3 Opérateurs logiques54
  - 5.6 Chaînes de caractères54
  - 6. Exercices55
  - 6.1 Exercice 155
  - 6.2 Exercice 255
  - 6.3 Exercice 355
  - 6.4 Exercice 455
  - 6.5 Exercice 556
  - 6.6 Exercice 656
  - Chapitre 3
  - Conditions, tests et booléens
  - 1. Les tests et conditions57
  - 1.1 Les conditions sont primordiales57
  - 1.2 Structures conditionnelles58
  - 1.2.1 SI ALORS SINON59
  - 1.2.2 CAS PARMI61
  - 2. La logique booléenne64
  - 2.1 Conditions multiples64
  - 2.2 Algèbre ou logique de Boole65
  - 2.2.1 ET logique65
  - 2.2.2 OU logique66
  - 2.2.3 NON logique67
  - 2.2.4 Règles de priorités68
  - 2.2.5 Un exemple concret69
  - 3. Les blocs en python71
  - 3.1 L'importance de l'indentation71
  - 3.2 Visibilité des variables72
  - 3.3 Conditions en Python74
  - 3.4 Instructions conditionnelles74
  - 3.4.1 SI ALORS SINON74
  - 3.4.2 Opérateur ternaire76
  - 3.4.3 CAS PARMI77
  - 4. Exercices77
  - 4.1 Exercice 177
  - 4.2 Exercice 278
  - 4.3 Exercice 378
  - 4.4 Exercice 478
  - Chapitre 4
  - Les boucles
  - 1. Les structures itératives79
  - 1.1 Itérer pour mieux programmer79
  - 1.2 Comment itérer proprement ?81
  - 2. Tant Que81
  - 2.1 Principe et syntaxe81
  - 2.2 Exemples82
  - 3. Répéter... Jusqu'à84
  - 3.1 Principe et syntaxe84
  - 3.2 Exemple85
  - 4. Pour85
  - 4.1 Principe et syntaxe85
  - 4.2 Exemples86
  - 5. Structures itératives imbriquées87
  - 6. Attention danger89
  - 7. Itérons en python91
  - 7.1 Pour91
  - 7.2 Tant que92
  - 7.3 Répéter jusqu'à93
  - 7.4 Boucles imbriquées93
  - 7.5 Pour aller plus loin94
  - 7.5.1 Break94
  - 7.5.2 Continue94
  - 7.5.3 Boucle-else95
  - 8. Exercices96
  - 8.1 Exercice 196
  - 8.2 Exercice 296
  - 8.3 Exercice 396
  - 8.4 Exercice 496
  - 8.5 Exercice 596
  - 8.6 Exercice 697
  - 8.7 Exercice 797
  - 8.8 Exercice 897
  - Chapitre 5
  - Les tableaux et structures
  - 1. Introduction99
  - 2. Les tableaux99
  - 2.1 Tableaux à une dimension100
  - 2.2 Tableaux à deux dimensions102
  - 2.3 Tableaux à n dimensions104
  - 3. Manipulations simples des tableaux105
  - 3.1 Tableaux à une dimension105
  - 3.1.1 Parcours105
  - 3.1.2 Recherche105
  - 3.1.3 Réduction107
  - 3.2 Tableaux à n dimensions108
  - 3.2.1 Parcours108
  - 3.2.2 Recherche108
  - 4. Structures et enregistrements110
  - 4.1 Structures110
  - 4.2 Structures imbriquées112
  - 4.3 Structures et tableaux113
  - 4.3.1 Structure contenant un tableau113
  - 4.3.2 Tableau de structures114
  - 5. Mettons en pratique avec Python114
  - 5.1 Tableau = liste114
  - 5.1.1 Parcours116
  - 5.1.2 Opérations sur les listes117
  - 5.1.3 Copie118
  - 5.1.4 Pour aller plus loin : l'intention119
  - 5.2 Tuple120
  - 5.3 Slicing121
  - 5.3.1 Listes et tuples121
  - 5.3.2 Retour sur les chaînes122
  - 5.4 Dictionnaire122
  - 5.4.1 Déclaration et accès123
  - 5.4.2 Opérations123
  - 5.4.3 Parcours124
  - 5.4.4 Pour aller plus loin : l'intention125
  - 6. Exercices125
  - 6.1 Exercice 1125
  - 6.2 Exercice 2125
  - 6.3 Exercice 3125
  - 6.4 Exercice 4126
  - 6.5 Exercice 5126
  - 6.6 Exercice 6126
  - 6.7 Exercice 7126
  - 6.8 Exercice 8126
  - 6.9 Exercice 9127
  - 6.10 Exercice 10127
  - Chapitre 6
  - Les sous-programmes
  - 1. Procédures et fonctions129
  - 1.1 Les procédures132
  - 1.1.1 Paramètres132
  - 1.1.2 Déclaration133
  - 1.1.3 Appel135
  - 1.1.4 Les tableaux en paramètres138
  - 1.2 Les fonctions138
  - 1.2.1 Déclaration138
  - 1.2.2 Appel141
  - 2. L'élégance de la récursivité142
  - 2.1 Récursivité simple143
  - 2.2 Récursivité multiple146
  - 2.3 Itération ou récursivité ?149
  - 3. Algorithmes avancés sur les tableaux150
  - 3.1 Procédure échanger151
  - 3.2 Tri par sélection151
  - 3.3 Tri à bulles154
  - 3.4 Tri par insertion155
  - 3.5 Tri rapide157
  - 3.6 Tri fusion159
  - 3.7 Recherche dichotomique161
  - 4. Fonctions et procédures avec Python163
  - 4.1 Les fonctions en Python163
  - 4.2 Particularités de Python165
  - 5. Exercices167
  - 5.1 Exercice 1167
  - 5.2 Exercice 2167
  - 5.3 Exercice 3168
  - 5.4 Exercice 4168
  - 5.5 Exercice 5168
  - 5.6 Exercice 6168
  - 5.7 Exercice 7168
  - 5.8 Exercice 8169
  - 5.9 Exercice 9169
  - 5.10 Exercice 10169
  - 5.11 Exercice 11169
  - 5.12 Exercice 12 - Récursivité169
  - Chapitre 7
  - Passons en mode confirmé
  - 1. Les pointeurs et références171
  - 1.1 Implémentation de la mémoire171
  - 1.2 Gestion des pointeurs172
  - 2. Les listes chaînées175
  - 2.1 Listes simplement chaînées175
  - 2.1.1 Création176
  - 2.1.2 Parcours177
  - 2.1.3 Ajout d'un élément178
  - 2.1.4 Suppression d'un élément181
  - 2.1.5 Insertion d'un élément187
  - 2.2 Listes chaînées circulaires190
  - 2.2.1 Création et parcours190
  - 2.2.2 Ajout d'un élément192
  - 2.2.3 Suppression d'un élément195
  - 2.2.4 Insérer un élément198
  - 2.3 Listes doublement chaînées198
  - 2.3.1 Création et parcours199
  - 2.3.2 Ajout et insertion d'un élément200
  - 2.3.3 Suppression d'un élément202
  - 2.4 Piles et Files205
  - 2.4.1 Piles ou LIFO205
  - 2.4.2 Files ou FIFO207
  - 3. Les arbres210
  - 3.1 Principe210
  - 3.2 Création211
  - 3.3 Parcours en largeur212
  - 3.4 Parcours en profondeur212
  - 3.5 Parcours en infixe213
  - 3.6 Parcours en postfixe213
  - 3.7 Insertion d'une feuille213
  - 3.8 Insertion d'une racine213
  - 3.9 Insertion d'une branche214
  - 3.10 Arbres binaires214
  - 3.10.1 Création214
  - 3.10.2 Parcours en largeur215
  - 3.10.3 Parcours en profondeur217
  - 3.10.4 Parcours en infixe217
  - 3.10.5 Parcours en postfixe218
  - 3.10.6 Ajout d'une feuille219
  - 3.11 Arbres binaires de recherche221
  - 3.11.1 Principe221
  - 3.11.2 Rechercher une valeur222
  - 3.11.3 Ajout d'une feuille223
  - 4. Et avec Python ?225
  - 5. Exercices225
  - 5.1 Exercice 1225
  - 5.2 Exercice 2225
  - 5.3 Exercice 3225
  - Chapitre 8
  - Les fichiers
  - 1. Le système de fichiers227
  - 1.1 Préambule227
  - 1.2 Répertoire et fichier227
  - 1.3 Arborescence de fichiers229
  - 1.4 Chemin absolu ou relatif230
  - 2. Les différents types de fichiers231
  - 2.1 Texte non formaté232
  - 2.2 Texte formaté232
  - 2.2.1 CSV233
  - 2.2.2 XML234
  - 2.2.3 JSON235
  - 3. Manipulation de fichiers236
  - 3.1 Ouvrir et fermer un fichier236
  - 3.2 Lire un fichier238
  - 3.3 Ecrire dans un fichier239
  - 3.4 Pour aller plus loin240
  - 4. Accédons à des fichiers avec Python241
  - 4.1 Ouvrir et fermer un fichier241
  - 4.2 Lire un fichier242
  - 4.2.1 read()242
  - 4.2.2 readline()243
  - 4.2.3 readlines()243
  - 4.2.4 for in244
  - 4.3 Écrire dans un fichier246
  - 4.3.1 write(chaîne)246
  - 4.3.2 print()246
  - 4.4 Parcourir l'arborescence247
  - 4.4.1 Module247
  - 4.4.2 Utilisation de walk248
  - 5. Exercices249
  - 5.1 Exercice 1249
  - 5.2 Exercice 2249
  - 5.3 Exercice 3249
  - 5.4 Exercice 4249
  - 5.5 Exercice 5249
  - 5.6 Exercice 6250
  - 5.7 Pour aller plus loin250
  - 5.7.1 Exercice 7250
  - 5.7.2 Exercice 8250
  - Chapitre 9
  - Commencer avec l'objet
  - 1. Préambule251
  - 2. Le naturel de l'objet252
  - 2.1 Introduction252
  - 2.2 L'objet et la classe253
  - 2.3 Méthodes254
  - 2.4 Visibilité des attributs et méthodes255
  - 2.5 Un aperçu de l'UML256
  - 3. Travailler avec les objets258
  - 3.1 Introduction258
  - 3.2 Instanciation et allocation mémoire258
  - 3.2.1 Constructeur259
  - 3.2.2 Destructeur260
  - 3.3 Appeler les méthodes262
  - 3.3.1 Listes et composition/agrégation263
  - 3.3.2 Arbres binaires en orienté objet268
  - 3.4 Héritage simple.271
  - 4. Pour aller plus loin275
  - 4.1 Polymorphisme275
  - 4.1.1 Objet275
  - 4.1.2 Surcharge de méthodes276
  - 4.1.3 Réécriture de méthodes278
  - 4.2 Héritage multiple281
  - 5. L'objet en Python283
  - 5.1 Objet et classe en Python283
  - 5.2 Utilisation de self pour les méthodes284
  - 5.3 Agrégation et composition286
  - 5.4 Héritage simple et polymorphisme287
  - 5.5 Pour aller plus loin289
  - 5.5.1 Visibilité privée289
  - 5.5.2 Héritage multiple290
  - 5.5.3 Surcharge des opérateurs291
  - 6. Exercices293
  - 6.1 Exercice 1293
  - 6.2 Exercice 2293
  - 6.3 Exercice 3294
  - 6.4 Exercice 4295
  - Index 297
Origine de la notice:
- BPI