Ce support sur l’algorithmique s’adresse à toute personne désireuse de maîtriser les bases essentielles de la programmation. Pour ap­prendre à programmer, il faut d’abord comprendre ce qu’est vrai­ment 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, condi­tions, 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 algo­rithmes) reprend celui couramment utilisé dans les écoles d’infor­matique 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.

Téléchargements

• Des fichiers complémentaires (63 Ko)

Avant-propos

1. Introduction

Introduction à l'algorithmique

1. Les fondements de l’informatique
   1. 1. Architecture de l’ordinateur
   2. 2. Implémentation de la mémoire
      1. a. Différentes mémoires
      2. b. Programme et mémoire
2. L’algorithmique, l'art de programmer
   1. 1. L’algorithmie, comment et pourquoi ?
      1. a. Exemples de la vie courante
      2. b. Algorithmes
3. Les langages, la mise en œuvre
   1. 1. La programmation
   2. 2. Les différents types de langages
      1. a. Programmation procédurale
      2. b. Programmation orientée objet
      3. c. Programmation fonctionnelle
   3. 3. Python

Les variables et opérateurs

1. Les variables simples
   1. 1. Types, déclaration et affectation
      1. a. Les nombres ou numériques
      2. b. Les caractères
      3. c. Les booléens
      4. d. Les chaînes de caractères
   2. 2. Saisie et affichage
   3. 3. Les constantes
2. Utiliser les variables
   1. 1. Opérateurs mathématiques communs
   2. 2. Opérateurs spécifiques aux entiers
   3. 3. Opérateur spécifique aux réels
   4. 4. Opérateurs de comparaison
   5. 5. Opérateurs logiques pour les booléens
   6. 6. Opérateurs sur les caractères
3. Les opérations sur les chaînes
   1. 1. Concaténation
   2. 2. Extraction
   3. 3. Longueur
4. Et avec les langages ?
   1. 1. Typage
      1. a. Les langages à typage statique
      2. b. Les langages à typage dynamique
      3. c. Langages fortement typés
      4. d. Langages faiblement typés
   2. 2. Opérateurs
   3. 3. Gestion de la mémoire
   4. 4. La gestion des réels
5. Python et les types
   1. 1. Installation
   2. 2. Langage interprété
   3. 3. Typage et affection
      1. a. Convention de nommage
      2. b. Affection et commentaire
      3. c. Opérateurs sur les types
   4. 4. Un premier script
      1. a. ECRIRE en Python
      2. b. LIRE en Python
   5. 5. Opérateurs
      1. a. Opérateurs arithmétiques
      2. b. Opérateurs de comparaison
      3. c. Opérateurs logiques
   6. 6. Chaînes de caractères
6. Exercices
   1. 1. Exercice 1
   2. 2. Exercice 2
   3. 3. Exercice 3
   4. 4. Exercice 4
   5. 5. Exercice 5
   6. 6. Exercice 6

Conditions, tests et booléens

1. Les tests et conditions
   1. 1. Les conditions sont primordiales
   2. 2. Structures conditionnelles
      1. a. SI ALORS SINON
      2. b. CAS PARMI
2. La logique booléenne
   1. 1. Conditions multiples
   2. 2. Algèbre ou logique de Boole
      1. a. ET logique
      2. b. OU logique
      3. c. NON logique
      4. d. Règles de priorités
      5. e. Un exemple concret
3. Les blocs en python
   1. 1. L’importance de l’indentation
   2. 2. Visibilité des variables
   3. 3. Conditions en Python
   4. 4. Instructions conditionnelles
      1. a. SI ALORS SINON
      2. b. Opérateur ternaire
      3. c. CAS PARMI
4. Exercices
   1. 1. Exercice 1
   2. 2. Exercice 2
   3. 3. Exercice 3
   4. 4. Exercice 4

Les boucles

1. Les structures itératives
   1. 1. Itérer pour mieux programmer
   2. 2. Comment itérer proprement ?
2. Tant Que
   1. 1. Principe et syntaxe
   2. 2. Exemples
3. Répéter ... Jusqu’à
   1. 1. Principe et syntaxe
   2. 2. Exemple
4. Pour
   1. 1. Principe et syntaxe
   2. 2. Exemples
5. Structures itératives imbriquées
6. Attention danger
7. Itérons en python
   1. 1. Pour
   2. 2. Tant que
   3. 3. Répéter jusqu’à
   4. 4. Boucles imbriquées
   5. 5. Pour aller plus loin
      1. a. Break
      2. b. Continue
      3. c. Boucle-else
8. Exercices
   1. 1. Exercice 1
   2. 2. Exercice 2
   3. 3. Exercice 3
   4. 4. Exercice 4
   5. 5. Exercice 5
   6. 6. Exercice 6
   7. 7. Exercice 7
   8. 8. Exercice 8

Les tableaux et structures

1. Introduction
2. Les tableaux
   1. 1. Tableaux à une dimension
   2. 2. Tableaux à deux dimensions
   3. 3. Tableaux à n dimensions
3. Manipulations simples des tableaux
   1. 1. Tableaux à une dimension
      1. a. Parcours
      2. b. Recherche
      3. c. Réduction
   2. 2. Tableaux à n dimensions
      1. a. Parcours
      2. b. Recherche
4. Structures et enregistrements
   1. 1. Structures
   2. 2. Structures imbriquées
   3. 3. Structures et tableaux
      1. a. Structure contenant un tableau
      2. b. Tableau de structures
5. Mettons en pratique avec Python
   1. 1. Tableau = liste
      1. a. Parcours
      2. b. Opérations sur les listes
      3. c. Copie
      4. d. Pour aller plus loin : l’intention
   2. 2. Tuple
   3. 3. Slicing
      1. a. Listes et tuples
      2. b. Retour sur les chaînes
   4. 4. Dictionnaire
      1. a. Déclaration et accès
      2. b. Opérations
      3. c. Parcours
      4. d. Pour aller plus loin : l’intention
6. Exercices
   1. 1. Exercice 1
   2. 2. Exercice 2
   3. 3. Exercice 3
   4. 4. Exercice 4
   5. 5. Exercice 5
   6. 6. Exercice 6
   7. 7. Exercice 7
   8. 8. Exercice 8
   9. 9. Exercice 9
   10. 10. Exercice 10

Les sous-programmes

1. Procédures et fonctions
   1. 1. Les procédures
      1. a. Paramètres
      2. b. Déclaration
      3. c. Appel
      4. d. Les tableaux en paramètres
   2. 2. Les fonctions
      1. a. Déclaration
      2. b. Appel
2. L'élégance de la récursivité
   1. 1. Récursivité simple
   2. 2. Récursivité multiple
   3. 3. Itération ou récursivité ?
3. Algorithmes avancés sur les tableaux
   1. 1. Procédure échanger
   2. 2. Tri par sélection
   3. 3. Tri à bulles
   4. 4. Tri par insertion
   5. 5. Tri rapide
   6. 6. Tri fusion
   7. 7. Recherche dichotomique
4. Fonctions et procédures avec Python
   1. 1. Les fonctions en Python
   2. 2. Particularités de Python
5. Exercices
   1. 1. Exercice 1
   2. 2. Exercice 2
   3. 3. Exercice 3
   4. 4. Exercice 4
   5. 5. Exercice 5
   6. 6. Exercice 6
   7. 7. Exercice 7
   8. 8. Exercice 8
   9. 9. Exercice 9
   10. 10. Exercice 10
   11. 11. Exercice 11
   12. 12. Exercice 12 - Récursivité

Passons en mode confirmé

1. Les pointeurs et références
   1. 1. Implémentation de la mémoire
   2. 2. Gestion des pointeurs
2. Les listes chaînées
   1. 1. Listes simplement chaînées
      1. a. Création
      2. b. Parcours
      3. c. Ajout d’un élément
      4. d. Suppression d’un élément
      5. e. Insertion d’un élément
   2. 2. Listes chaînées circulaires
      1. a. Création et parcours
      2. b. Ajout d’un élément
      3. c. Suppression d’un élément
      4. d. Insérer un élément
   3. 3. Listes doublement chaînées
      1. a. Création et parcours
      2. b. Ajout et insertion d’un élément
      3. c. Suppression d’un élément
   4. 4. Piles et Files
      1. a. Piles ou LIFO
      2. b. Files ou FIFO
3. Les arbres
   1. 1. Principe
   2. 2. Création
   3. 3. Parcours en largeur
   4. 4. Parcours en profondeur
   5. 5. Parcours en infixe
   6. 6. Parcours en postfixe
   7. 7. Insertion d’une feuille
   8. 8. Insertion d’une racine
   9. 9. Insertion d’une branche
   10. 10. Arbres binaires
       1. a. Création
       2. b. Parcours en largeur
       3. c. Parcours en profondeur
       4. d. Parcours en infixe
       5. e. Parcours en postfixe
       6. f. Ajout d’une feuille
   11. 11. Arbres binaires de recherche
       1. a. Principe
       2. b. Rechercher une valeur
       3. c. Ajout d’une feuille
4. Et avec Python??
5. Exercices
   1. 1. Exercice 1
   2. 2. Exercice 2
   3. 3. Exercice 3

Les fichiers

1. Le système de fichiers
   1. 1. Préambule
   2. 2. Répertoire et fichier
   3. 3. Arborescence de fichiers
   4. 4. Chemin absolu ou relatif
2. Les différents types de fichiers
   1. 1. Texte non formaté
   2. 2. Texte formaté
      1. a. CSV
      2. b. XML
      3. c. JSON
3. Manipulation de fichiers
   1. 1. Ouvrir et fermer un fichier
   2. 2. Lire un fichier
   3. 3. Écrire dans un fichier
   4. 4. Pour aller plus loin
4. Accédons à des fichiers avec Python
   1. 1. Ouvrir et fermer un fichier
   2. 2. Lire un fichier
      1. a. read()
      2. b. readline()
      3. c. readlines()
      4. d. for in
   3. 3. Écrire dans un fichier
      1. a. write(chaîne)
      2. b. print()
   4. 4. Parcourir l’arborescence
      1. a. Module
      2. b. Utilisation de walk
5. Exercices
   1. 1. Exercice 1
   2. 2. Exercice 2
   3. 3. Exercice 3
   4. 4. Exercice 4
   5. 5. Exercice 5
   6. 6. Exercice 6
   7. 7. Pour aller plus loin
      1. a. Exercice 7
      2. b. Exercice 8

Commencer avec l'objet

1. Préambule
2. Le naturel de l'objet
   1. 1. Introduction
   2. 2. L’objet et la classe
   3. 3. Méthodes
   4. 4. Visibilité des attributs et méthodes
   5. 5. Un aperçu de l’UML
3. Travailler avec les objets
   1. 1. Introduction
   2. 2. Instanciation et allocation mémoire
      1. a. Constructeur
      2. b. Destructeur
   3. 3. Appeler les méthodes
      1. a. Listes et composition/agrégation
      2. b. Arbres binaires en orienté objet
   4. 4. Héritage simple
4. Pour aller plus loin
   1. 1. Polymorphisme
      1. a. Objet 
      2. b. Surcharge de méthodes
      3. c. Réécriture de méthodes
   2. 2. Héritage multiple
5. L’objet en Python
   1. 1. Objet et classe en Python
   2. 2. Utilisation de self pour les méthodes
   3. 3. Agrégation et composition
   4. 4. Héritage simple et polymorphisme
   5. 5. Pour aller plus loin
      1. a. Visibilité privée
      2. b. Héritage multiple
      3. c. Surcharge des opérateurs
6. Exercices
   1. 1. Exercice 1
   2. 2. Exercice 2
   3. 3. Exercice 3
   4. 4. Exercice 4