Licence CC BY-SA

Notions de Python avancées

Découvrez Python plus en profondeur

Dernière mise à jour :
Auteur :
Catégorie :
Temps de lecture estimé : 12 heures

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

8 commentaires

Bravo pour tout ce travail (même si je n'ai pas vraiment eu le temps de jeter un œil attentif à ce tuto). Mais je crois comprendre qu'il devrait entrer dans cette collection de tutos. Auquel cas, ne faudrait-il pas un petit bloc d'information dans l'intro avec un lien vers le tuto pour débutant. En effet, tout le monde n'accèdera pas à ce tuto via ZdS, certains le trouveront via google ou autre. Réciproquement, le tuto pour débutant devrait avoir un bloc (dans son intro et/ou sa conclusion) avec un lien vers ce tuto. Un truc du genre :

Ce tutoriel exige des notions avancées de programmation en langage Python. Si vous n'avez jamais pratiqué, Zeste de Savoir vous propose également un tutoriel d'introduction plus accessible. Pour cela, il vous suffit de cliquer ici : Apprendre à programmer avec Python 3.

+2 -0

Bonjour, Dans le paragraphe consacré aux descripteurs il y a ce code:

@property def celsius(self): return self.value @celsius.setter def celsius(self, value): # le nom de cette méthode a peu d'importance self.value = value

Je ne suis pas d'accord avec le commentaire. Le nom de la méthode est important. J'ai essayé de le remplacer par toto et le code ne marche plus. On n'a pas le code de la méthode celcius.setter, mais je suppose que cette méthode intègre la méthode setter à l'objet puis retourne l'objet qui se retrouve dans la variable de classe celsius grâce au décorateur.

pendant que j'y suis, dans le code de la classe my_property

class my_property: def init(self, fget, fset, fdel): self.fget = fget self.fset = fset self.fdel = fdel def get(self, instance, owner): return self.fget(instance) def set(self, instance, value): return self.fset(instance, value) def delete(self, instance): return self.fdel(instance)

les méthodes set et delete retournent quelque chose. Cela me paraît étrange.

+0 -0

Bonjour,

Je venais juste de croiser ton message sur OCR, la modification a été faite et poussée sur le dépôt Git. La demande de validation a aussi été effectuée, ça ne devrait pas prendre beaucoup de temps vu l'ampleur de la modification :)

Pour les méthodes __set__ et __delete__ et leur return, c'est simplement pour relayer le retour, même si celui-ci devrait toujours être None.

Merci.

Édité par entwanne

Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte