Apprendre à programmer avec Python 3

Avant-propos
1. Avant-propos
1-A. La couverture
Préface
2. Préface
2-A. Choix d'un premier langage de programmation
2-B. Présentation du langage Python
2-B-1. Caractéristiques du langage
2-C. Pour le professeur qui souhaite utiliser cet ouvrage comme support de cours
2-D. Versions du langage
2-E. Distribution de Python et bibliographie
2-F. Exemples du livre
2-G. Remerciements
À l'école des sorciers
3. À l'école des sorciers
3-A. Boîtes noires et pensée magique
3-B. Magie blanche, magie noire
3-C. La démarche du programmeur
3-D. Langage machine, langage de programmation
3-E. Édition du code source - Interprétation
3-F. Mise au point d'un programme - Recherche des erreurs (debug)
3-F-1. Erreurs de syntaxe
3-F-2. Erreurs sémantiques
3-F-3. Erreurs à l'exécution
3-G. Recherche des erreurs et expérimentation
Premiers pas
4. Premiers pas
4-A. Calculer avec Python
4-B. Données et variables
4-C. Noms de variables et mots réservés
4-D. Affectation (ou assignation)
4-E. Afficher la valeur d' une variable
4-F. Typage des variables
4-G. Affectations multiples
4-H. Opérateurs et expressions
4-I. Priorité des opérations
4-J. Composition
Contrôle du flux d'exécution
5. Contrôle du flux d'exécution
5-A. Séquence d'instructions
5-B. Sélection ou exécution conditionnelle
5-C. Opérateurs de comparaison
5-D. Instructions composées - blocs d'instructions
5-E. Instructions imbriquées
5-F. Quelques règles de syntaxe Python
5-F-1. Les limites des instructions et des blocs sont définies par la mise en page
5-F-2. Instruction composée : en-tête, double point, bloc d'instructions indenté
5-F-3. Les espaces et les commentaires sont normalement ignorés
Instructions répétitives
6. Instructions répétitives
6-A. Ré-affectation
6-B. Répétitions en boucle - l'instruction while
6-B-1. Commentaires
6-B-2. Remarques
6-B-3. Élaboration de tables
6-B-4. Construction d'une suite mathématique
6-C. Premiers scripts, ou comment conserver nos programmes
6-C-1. Problèmes éventuels liés aux caractères accentués
Principaux types de données
7. Principaux types de données
7-A. Les données numériques
7-A-1. Le type integer
7-B. Le type float
7-C. Les données alphanumériques
7-C-1. Le type string
7-C-1-A. Remarques
7-C-1-B. Triple quotes
7-C-2. Accès aux caractères individuels d'une chaîne
7-C-3. Opérations élémentaires sur les chaînes
7-D. Les listes (première approche)
Fonctions prédéfinies
8. Fonctions prédéfinies
8-A. Affichage : la fonction print()
8-B. Interaction avec l'utilisateur : la fonction input()
8-B-1. Remarque importante
8-C. Importer un module de fonctions
8-D. Un peu de détente avec le module turtle
8-E. Véracité/fausseté d'une expression
8-F. Révision
8-F-1. Contrôle du flux - utilisation d'une liste simple
8-F-2. Boucle while - instructions imbriquées
Fonctions originales
9. Fonctions originales
9-A. Définir une fonction
9-A-1. Fonction simple sans paramètres
9-A-2. Fonction avec paramètre
9-A-3. Utilisation d'une variable comme argument
9-A-3-A. Remarque importante
9-A-4. Fonction avec plusieurs paramètres
9-A-4-A. Notes
9-B. Variables locales, variables globales
9-C. Vraies fonctions et procédures
9-C-1. Notes
9-D. Utilisation des fonctions dans un script
9-D-1. Notes
9-E. Modules de fonctions
9-F. Typage des paramètres
9-G. Valeurs par défaut pour les paramètres
9-H. Arguments avec étiquettes
Utilisation de fenêtres et de graphismes
10. Utilisation de fenêtres et de graphismes
10-A. Interfaces graphiques (GUI)
10-B. Premiers pas avec tkinter
10-B-1. Examinons à présent plus en détail chacune des lignes de commandes exécutées
10-C. Programmes pilotés par des événements
10-C-1. Exemple graphique :tracé de lignes dans un canevas
10-C-2. Exemple graphique : deux dessins alternés
10-C-3. Exemple graphique : calculatrice minimaliste
10-C-4. Exemple graphique : détection et positionnement d'un clic souris
10-D. Les classes de widgets tkinter
10-E. Utilisation de la méthode grid() pour contrôler la disposition des widgets
10-F. Composition d'instructions pour écrire un code plus compact
10-G. Modification des propriétés d'un objet - Animation
10-H. Animation automatique - Récursivité
Manipuler des fichiers
11. Manipuler des fichiers
11-A. Utilité des fichiers
11-B. Travailler avec des fichiers
11-C. Noms de fichiers - le répertoire courant
11-D. Les deux formes d'importation
11-E. Écriture séquentielle dans un fichier
11-E-1. Notes
11-F. Lecture séquentielle d'un fichier
11-F-1. Notes
11-G. L'instruction break pour sortir d'une boucle
11-H. Fichiers texte
11-H-1. Remarques
11-I. Enregistrement et restitution de variables diverses
11-J. Gestion des exceptions : les instructions try - except - else
Approfondir les structures de données
12. Approfondir les structures de données
12-A. Le point sur les chaînes de caractères
12-A-1. Indiçage, extraction, longueur
12-A-2. Extraction de fragments de chaînes
12-A-3. Concaténation, répétition
12-A-4. Parcours d'une séquence : l'instruction for - in ...
12-A-5. Appartenance d'un élément à une séquence : l'instruction in utilisée seule
12-A-6. Les chaînes sont des séquences non modifiables
12-A-7. Les chaînes sont comparables
12-A-8. La norme Unicode
12-A-9. Séquences d'octets : le type bytes
12-A-10. L'encodage Utf-8
12-A-11. Conversion (encodage/décodage) des chaînes
12-A-11-A. Conversion d'une chaîne bytes en chaîne string
12-A-11-B. Conversion d'une chaîne string en chaîne bytes
12-A-11-C. Conversions automatiques lors du traitement des fichiers
12-A-11-D. Cas des scripts Python
12-A-12. Accéder à d'autres caractères que ceux du clavier
12-A-13. Les chaînes sont des objets
12-A-14. Fonctions intégrées
12-A-15. Formatage des chaînes de caractères
12-A-16. Formatage des chaînes « à l'ancienne »
12-B. Le point sur les listes
12-B-1. Définition d'une liste - accès à ses éléments
12-B-2. Les listes sont modifiables
12-B-3. Les listes sont des objets
12-B-4. Techniques de slicing avancé pour modifier une liste
12-B-4-A. Insertion d'un ou plusieurs éléments n'importe où dans une liste
12-B-4-B. Suppression/remplacement d'éléments
12-B-5. Création d'une liste de nombres à l'aide de la fonction range()
12-B-6. Parcours d'une liste à l'aide de for, range() et len()
12-B-7. Une conséquence importante du typage dynamique
12-B-8. Opérations sur les listes
12-B-9. Test d'appartenance
12-B-10. Copie d'une liste
12-B-10-A. Petite remarque concernant la syntaxe
12-B-11. Nombres aléatoires - histogrammes
12-B-12. Tirage au hasard de nombres entiers
12-C. Les tuples
12-C-1. Opérations sur les tuples
12-D. Les dictionnaires
12-D-1. Création d'un dictionnaire
12-D-2. Opérations sur les dictionnaires
12-D-3. Test d'appartenance
12-D-4. Les dictionnaires sont des objets
12-D-5. Parcours d'un dictionnaire
12-D-6. Les clés ne sont pas nécessairement des chaînes de caractères
12-D-7. Les dictionnaires ne sont pas des séquences
12-D-8. Construction d'un histogramme à l'aide d'un dictionnaire
12-D-9. Contrôle du flux d'exécution à l'aide d'un dictionnaire
Classes, objets, attributs
13. Classes, objets, attributs
13-A. Utilité des classes
13-B. Définition d'une classe élémentaire
13-C. Attributs (ou variables) d'instance
13-D. Passage d'objets comme arguments dans l'appel d'une fonction
13-E. Similitude et unicité
13-F. Objets composés d'objets
13-G. Objets comme valeurs de retour d'une fonction
13-H. Modification des objets
Classes, méthodes, héritage
14. Classes, méthodes, héritage
14-A. Définition d'une méthode
14-A-1. Définition concrète d'une méthode dans un script
14-A-2. Essai de la méthode, dans une instance quelconque
14-B. La méthode constructeur
14-B-1. Exemple
14-C. Espaces de noms des classes et instances
14-D. Héritage
14-E. Héritage et polymorphisme
14-E-1. Commentaires
14-F. Modules contenant des bibliothèques de classes
Classes et interfaces graphiques
15. Classes et interfaces graphiques
15-A. Code des couleurs : un petit projet bien encapsulé
15-A-1. Cahier des charges de notre programme
15-A-2. Mise en œuvre concrète
15-A-3. Commentaires
15-B. Petit train : héritage, échange d'informations entre classes
15-B-1. Cahier des charges
15-B-2. Implémentation
15-B-3. Commentaires
15-C. OscilloGraphe : un widget personnalisé
15-C-1. Expérimentation
15-C-2. Cahier des charges
15-C-3. Implémentation
15-D. Curseurs : un widget composite
15-D-1. Présentation du widget Scale
15-D-2. Construction d'un panneau de contrôle à trois curseurs
15-D-2-A. Commentaires
15-D-2-B. Propagation des événements
15-E. Intégration de widgets composites dans une application synthèse
15-E-1. Commentaires
Et pour quelques widgets de plus ...
16. Et pour quelques widgets de plus ...
16-A. Les boutons radio
16-A-1. Commentaires
16-B. Utilisation de cadres pour la composition d'une fenêtre
16-B-1. Commentaires
16-C. Comment déplacer des dessins à l'aide de la souris
16-C-1. Commentaires
16-D. Widgets complémentaires, widgets composites
16-D-1. Combo box simplifié
16-D-1-A. Commentaires
16-D-2. Le widget Text assorti d'un ascenseur
16-D-2-A. Gestion du texte affiché
16-D-2-B. Commentaires
16-D-3. Le widget Canvas assorti d'un ascenseur
16-D-3-A. Commentaires
16-E. Application à fenêtres multiples - paramétrage implicite
16-E-1. Commentaires
16-F. Barres d'outils - expressions lambda
16-F-1. Métaprogrammation - expressions lambda
16-F-2. Passage d'une fonction (ou d'une méthode) comme argument
16-G. Fenêtres avec menus
16-G-1. Cahier des charges de l'exercice
16-G-2. Première ébauche du programme
16-G-2-A. Analyse du script
16-G-3. Ajout de la rubrique Musiciens
16-G-3-A. Analyse du script
16-G-4. Ajout de la rubrique Peintres
16-G-4-A. Analyse du script
16-G-5. Ajout de la rubrique Options
16-G-6. Menu avec cases à cocher
16-G-7. Menu avec choix exclusifs
16-G-8. Contrôle du flux d'exécution à l'aide d'une liste
16-G-9. Pré-sélection d'une rubrique
Analyse de programmes concrets
17. Analyse de programmes concrets
17-A. Jeu des bombardes
17-A-1. Prototypage d'une classe Canon
17-A-1-A. Commentaires
17-A-2. Ajout de méthodes au prototype
17-A-2-A. Commentaires
17-A-3. Développement de l'application
17-A-3-A. Commentaires
17-A-4. Développements complémentaires
17-A-4-A. Commentaires
17-B. Jeu de Ping
17-B-1. Principe
17-B-2. Programmation
17-B-2-A. Cahier des charges du logiciel à développer
Gestion d'une base de données
18. Gestion d'une base de données
18-A. Les bases de données
18-A-1. SGBDR - Le modèle client/serveur
18-A-2. Le langage SQL
18-A-3. SQLite
18-A-4. Création de la base de données. Objets « connexion » et « curseur ».
18-A-5. Connexion à une base de données existante
18-A-6. Recherches sélectives dans une base de données
18-A-7. La requête select
18-B. Ébauche d'un logiciel client pour PostgreSQL
18-B-1. Décrire la base de données dans un dictionnaire d'application
18-B-2. Définir une classe d'objets-interfaces
18-B-2-A. Commentaires
18-B-3. Construire un générateur de formulaires
18-B-3-A. Commentaires
18-B-4. Le corps de l'application
18-B-4-A. Commentaires
Applications web
19. Applications web
19-A. Pages web interactives
19-A-1. Un serveur web en pur Python !
19-A-2. Première ébauche : mise en ligne d'une page web minimaliste
19-A-3. Ajout d'une deuxième page
19-A-4. Présentation et traitement d'un formulaire
19-A-5. Analyse de la communication et des erreurs
19-A-6. Structuration d'un site à pages multiples
19-A-7. Prise en charge des sessions
19-B. Réalisation concrète d'un site web interactif
19-B-1. Le script
19-B-2. Les « patrons » HTML
19-C. Autres développements
Communications à travers un réseau & Multithreading.
20. Communications à travers un réseau & Multithreading.
20-A. Les sockets
20-A-1. Construction d'un serveur rudimentaire
20-A-1-A. Commentaires
20-A-2. Construction d'un client rudimentaire
20-A-2-A. Commentaires
20-B. Gestion de plusieurs tâches en parallèle à l'aide de threads
20-B-1. Client réseau gérant l'émission et la réception simultanées
20-B-1-A. Commentaires
20-B-2. Serveur réseau gérant les connexions de plusieurs clients en parallèle
20-B-2-A. Commentaires
20-C. Jeu des bombardes, version réseau
20-C-1. Programme serveur : vue d' ensemble
20-C-2. Protocole de communication
20-C-2-A. Remarques complémentaires
20-C-3. Programme serveur : première partie
20-C-4. Synchronisation de threads concurrents à l'aide de verrous (thread locks)
20-C-4-A. Utilisation
20-C-5. Programme serveur : suite et fin
20-C-5-A. Commentaires
20-C-6. Programme client
20-C-6-A. Commentaires
20-C-6-B. Conclusions et perspectives :
20-D. Utilisation de threads pour optimiser les animations.
20-D-1. Temporisation des animations à l'aide de after()
20-D-2. Temporisation des animations à l'aide de time.sleep()
20-D-3. Exemple concret
20-D-3-A. Commentaires
Installation de Python
21. Installation de Python
21-A. Sous Windows
21-B. Sous Linux
21-C. Sous Mac OS
21-D. Installation de Cherrypy
21-E. Installation de pg8000
Solutions des exercices
22. Solutions des exercices
Licence associée à cet ouvrage
23. Licence associée à cet ouvrage
23-A. Vous êtes libres :
23-B. Selon les conditions suivantes :