Notions de Python avancées

Python est simple.

C’est probablement ce que l’on vous a dit de nombreuses fois, et ce que vous avez constaté en apprenant et pratiquant ce langage. Mais derrière cette simplicité apparente existent un certain nombre de concepts plus complexes qui forment la puissance de ce langage.

En Python, on s’intéresse plus au comportement des objets qu’à leur nature. Ainsi, l’interface des objets (c’est-à-dire l’ensemble de leurs attributs et méthodes) est quelque chose de très important, c’est entre autres ce qui les définit.

En effet, une grande partie des outils du langage sont génériques — tels les appels de fonctions ou les boucles for — c’est-à-dire qu’ils peuvent s’appliquer à des types différents. Python demande simplement à ces types de respecter une interface en implémentant un certain nombre de méthodes spéciales. Ces interfaces et méthodes seront décrites dans le cours.

Le pré-requis pour suivre ce tutoriel est de connaître Python, même à un niveau intermédiaire. Il est simplement nécessaire de savoir manipuler les structures du langage (conditions, boucles, fonctions), les types de base (nombres, chaînes de caractères, listes, dictionnaires), et d’avoir des notions de programmation objet en Python. Connaître le mécanisme des exceptions est un plus.

Ce cours se divise en chapitres consacrés chacun à une spécificité du langage. Ces dernières ne devraient plus avoir de secret pour vous une fois la lecture terminée.

Je tiens aussi à préciser que ce cours s’adresse principalement aux utilisateurs de Python 3, et n’est pas valable pour les versions de Python inférieures.

Mise en bouche

1. Conteneurs

   1. Les conteneurs, c'est in

   2. C'est pas la taille qui compte

   3. Objets indexables

   4. Les slices

   5. Module collections

   6. TP : Une liste chaînée en Python

2. Itérables

   1. for for lointain

   2. Utilisation des iterables

   3. Utilisation avancée : le module itertools

   4. L'unpacking

   5. TP : Itérateur sur listes chaînées

3. Objets mutables et hashables

   1. Mutables

   2. Égalité et identité

   3. Hashables

   4. TP : Égalité entre listes

Ainsi font fonctions

1. Callables

   1. Fonctions, classes et lambdas

   2. Paramètres de fonctions

   3. Call-me maybe

   4. Utilisation des callables

   5. Modules operator et functools

   6. TP : itemgetter

2. Annotations et signatures

   1. Annotations

   2. Inspecteur Gadget

   3. Signatures

   4. TP : Vérification de signature

3. Décorateurs

   1. D&CO, une semaine pour tout changer

   2. Décorateurs paramétrés

   3. Envelopper une fonction

   4. TP : Arguments positionnels

Plus loin, un peu plus loin

1. Générateurs

   1. Dessine-moi un générateur

   2. Altérer un générateur avec send

   3. Méthodes des générateurs

   4. Déléguer à un autre générateur avec yield from

   5. Listes et générateurs en intension

   6. Liste ou générateur ?

   7. TP : map

2. Gestionnaires de contexte

   1. with or without you

   2. La fonction open

   3. Fonctionnement interne

   4. Simplifions-nous la vie avec la contextlib

   5. Réutilisabilité et réentrance

   6. TP : Redirection de sortie (redirectstdout)

3. Accesseurs et descripteurs

   1. L'attribut de Dana

   2. Les descripteurs

   3. Les propriétés

   4. Les méthodes

   5. TP : Méthodes

La rentrée des classes

1. Types

   1. Instance, classe et métaclasse

   2. Le vrai constructeur

   3. Paramètres d'héritage

   4. TP : Liste immutable

2. Métaclasses

   1. Quel est donc ce type ?

   2. Les métaclasses

   3. Utiliser une fonction comme métaclasse

   4. TP : Types immutables

3. Classes abstraites

   1. Module abc

   2. isinstance

   3. issubclass

   4. Collections abstraites

   5. TP: Reconnaissance d'interfaces

Pour quelques exercices de plus

1. Décorateurs

   1. Vérification de types

   2. Mémoïsation

   3. Fonctions génériques

   4. Récursivité terminale

2. Gestionnaires de contexte

   1. Changement de répertoire

   2. Transformer un générateur en gestionnaire de contexte

   3. Suppression d'erreurs

3. Accesseurs et descripteurs

   1. Propriétés

4. Métaclasses

   1. Évaluation paresseuse

   2. Types immutables

Ce cours touche maintenant à sa fin. Puisse-t-il vous avoir fait découvrir de nouveaux concepts du Python, ou l’envie de voir encore plus loin.

Ce cours ne couvre en effet qu’un nombre restreint de domaines, qui pourraient chacun être plus approfondis. Il y aurait encore tant à dire, sur les coroutines, sur les utilisations de l’interpréteur, sur les outils, les bibliothèques, les frameworks. À elle seule, la bibliothèque standard regorge encore de nombreuses choses, et je vous invite à voguer dans les pages de sa documentation.

Nous nous sommes ici surtout intéressés aux pages de documentation sur les types et le modèle de données. Mais elle comporte bien d’autres sections comme des tutoriaux, des recettes, la description de l’API C, etc.

Cependant, bien que cette documentation soit assez complète, elle ne l’est pas autant que le code source de l’interpréteur CPython. Écrit en C, son code reste très accessible et permet de mieux comprendre les mécanismes internes du langage.

Si vous souhaitez en apprendre plus sur la philosophie du langage, ou sur la bonne utilisation des concepts décrits dans le cours, je vous renvoie à cet article sur le code pythonique.

Je tiens aussi à remercier les différents contributeurs ayant aidé à l’élaboration de ce projet :

• Vayel, pour ses longues et intensives relectures ;
• nohar, pour les précisions apportées tout le long de l’écriture du tutoriel ;
• Bibibye, pour les nombreuses typographies corrigées ;
• yoch, pour ses diverses corrections.

Notez enfin que ce cours est diffusé sous licence Creative Commons Attribution-ShareAlike 4.0 et que toute contribution est bienvenue. Les sources sont disponibles à l’adresse suivante : https://github.com/entwanne/cours_python_avance