Glossaire

>>>

L’invite de commande utilisée par défaut dans l’interpréteur interactif. On la voit souvent dans des exemples de code qui peuvent être exécutés interactivement dans l’interpréteur.

...

L’invite de commande utilisée par défaut dans l’interpréteur interactif lorsqu’on entre un bloc de code indenté ou entre deux délimiteurs (parenthèses, crochets ou accolades).

3to3

Un outil qui essaie de convertir du code pour Python 2.x en code pour Python 3.x en gérant la plupart des incompatibilités qui peuvent être détectées en analysant la source et parcourant son arbre syntaxique.

2to3 est disponible dans la bibliothèque standard sous le nom de lib2to3; un point d’entrée indépendant est fourni via Tools/scripts/2to3. Cf. 2to3 - Automatise la traduction du code de Python 2 vers Python 3.

classe de base abstraite

Les classes de base abstraites (ABC, suivant l’abréviation anglaise Abstract Base Class) complètent le duck-typing en fournissant un moyen de définir des interfaces pour les cas où d’autres techniques comme hasattr() seraient inélégantes, ou subitement fausse (par exemple avec les méthodes magiques). Les ABC introduisent des sous-classes virtuelles, qui n’héritent pas d’une classe mais qui sont quand même reconnues par isinstance() ou issubclass() (Voir la documentation du module abc). Python contient de nombreuses ABC pour les structures de données (dans le module collections.abc), les nombres (dans le module numbers), les flux (dans le module io), et les chercheurs / chargeurs d’import (dans le module importlib.abc). Vous pouvez créer vos propres ABC avec le module abc.

argument

Une valeur, donnée à une fonction ou à une méthode lors de son appel. Il existe deux types d’arguments :

  • argument nommé: un argument précédé d’un identifiant (comme name=) ou un dictionnaire précédé de **, lors d’un appel de fonction. Par exemple, 3 et 5 sont tous les deux des arguments nommés dans l’appel à complex() ici :

    complex(real=3, imag=5)
    complex(**{'real': 3, 'imag': 5})
    
  • argument positionnel : Un argument qui n’est pas nommé. Les arguments positionnels apparaissent au début de la liste des arguments, ou donnés sous forme d’un itérable précédé par *. Par exemple, 3 et 5 sont tous les deux des arguments positionnels dans les appels suivants :

    complex(3, 5)
    complex(*(3, 5))
    

Les arguments se retrouvent dans le corps de la fonction appelée parmi les variables locales. Voir la section Appels à propos des règles dictant cet affectation. Syntaxiquement, toute expression est acceptée comme argument, et c’est la valeur résultante de l’expression qui sera affectée à la variable locale.

Voir aussi parameter dans le glossaire, la FAQ a aussi une question à propos de la différence entre argument et paramètre et la PEP 362.

gestionnaire de contexte asynchrone

(asynchronous context manager) Un objet contrôlant l’environnement à l’intérieur d’une instruction with en définissant les méthodes __aenter__() et __aexit__(). Introduit dans la PEP 492.

itérable asynchrone

Un objet qui peut être utilisé dans une instruction async for. Sa méthode __aiter__() doit retourner un asynchronous iterator. Introduit dans la PEP 492.

itérateur asynchrone

Un objet qui implémente les méthodes __aiter__() et __anext__(). __anext__ doit retourner un objet awaitable. async for résoud le awaitable retourné par la méthode __anext__() de l’itérateur asynchrone jusqu’à ce qu’il lève une exception StopAsyncIteration. Introduit dans la PEP 492.

attribut

Une valeur associée à un objet et désignée par son nom via une notation utilisant des points. Par exemple, si un objet o a un attribut a, il sera référencé par o.a.

awaitable

Un objet pouvant être utilisé dans une expression await. Peut être une coroutine ou un objet avec une méthode __await__(). Voir aussi PEP 492.

BDFL

Bienveillant dictateur à vie (de Benevolent Dictator For Life), alias Guido van Rossum, le créateur de Python.

fichier binaire

Un objet fichier capable de lire et d’écrire des objets bytes-compatibles.

Voir aussi

Un fichier texte lis et écris des objets str.

Objet bytes-compatible

Un objet gèrant les Buffer Protocol et peut exporter un buffer C-contiguous. Cela inclu les objets bytes, bytearray, et array.array, ainsi que beaucoup d’objets memoryview. Les objets bytes-compatibles peuvent être utilisés pour diverses opérations sur des données binaires, comme la compression, la sauvegard dans un fichier binaire, ou l’envoi sur une socket.

Certaines opérations nécessitent de travailler sur des données binaires variables. La documentation parle de ceux-ci comme des “read-write bytes-like objects”. Par exemple, bytearray, et une memoryview d’un bytearray en sont. D’autres opérations nécessitent de travailler sur des données binaires stockées dans des objets immuables (“read-only bytes-like objects”), par exemples bytes et memoryview d’un objet byte.

bytecode

Le code source, en Python, est compilé en un bytecode, la représentation interne à CPython d’un programme Python. Le bytecode est stocké dans un fichier nommé .pyc ou .pyo. Ces caches permettent de charger les fichiers plus rapidement lors de la deuxième exécution (en évitant ainsi de recommencer la compilation en bytecode). On dit que ce langage intermédiaire est exécuté sur une machine virtuelle qui exécute des instructions machine pour chaque instruction du bytecode. Notez que le bytecode n’a pas vocation à fonctionner entre différentes machines virtuelle Python, encore moins entre différentes version de Python.

Une liste des instructions du bytecode se trouve dans la documentation du module dis.

classe

Un modèle pour créer des objets définis par l’utilisateur. Les définitions de classes (class) contiennent normalement des définitions de méthodes qui agissent sur les instances de classe.

coercition

La conversion implicite d’une instance d’un type vers un autre lors d’une opération impliquant deux opérandes de même type. Par exemple int(3.15) convertis explicitement le nombre à virgule flottante en nombre entier (ici, 3), mais dans l’opération 3 + 4.5, les deux opérandes ont un type différent, alors qu’elles doivent avoir le même type pour être additionnées, sans quoi une exception TypeError serait levée. Sans coercition, toutes les opérandes, même de types compatibles, devraient être converties (on parle aussi de cast) explicitement par le développeur, par exemple : float(3) + 4.5 au lieu du simple 3 + 4.5.

nombre complexe

Une extension du système numéral réel familier dans laquelle tous les nombres sont exprimés sous la forme d’une somme d’un réel et d’un imaginaire. Les nombres imaginaures sont de réels multiples d’une unité imaginaire (la racine carrée de -1), souvent écrite i en mathématiques ou j en ingénierie. Python supporte nativement les nombres complexes, écrits avec cette dernière notation; la partie imaginaire est écrite avec un suffixe j, exemple, 3+1j. Pour utiliser les équivalents complexes à math, utilisez cmath. L’utilisation des nombres complexes est une caractéristiques des mathématiques avancées. Si vous n’en avez pas l’utilité, vous pouvez les ignorer en toute tranquilité.

gestionnaire de contexte

Un objet contrôlant l’environnement a l’intérieur d’une instruction with en définissant les méthodes __enter__() et __exit__(). Consultez la PEP 343.

contigu

Un buffer est considéré contigu s’il est soit C-contigu soit Fortran-contigu. Les tableaux de dimension zéro sont C-contigus et Fortran-contigus. Pour un tableau à une dimension, ses éléments doivent être placés en mémoire l’un à côté de l’autre, dans l’ordre croissant de leur indice, commençant à zéro. Pour qu’un tableau multidimensionnel soit C-contigu, le dernier indice doit être celui qui varie le plus rapidement lors du parcours de ses éléments dans l’ordre de leur adresse mémoire. A l’inverse, dans les tableaux Fortran-contigu, c’est le premier indice qui doit varier le plus rapidement.

coroutine

Les coroutines sont une forme généralisées des fonctions. Les fonctions sont accédées en un point et sortent en un point. Les coroutines peuvent être accédées, quittées, reprises en plusieurs points. Elles peuvent être implémentées via l’instruction async def. Voir aussi PEP 492.

fonction coroutine

Une fonction qui donne un objet coroutine. Une fonction coroutine peut être définie par l’instruction async def, et peuvent contenir les mots clefs await, async for, et async with. Elles sont introduites par la PEP 492.

CPython

L’implémentation canonique du langage de programmation Python, tel que distribué sur python.org. Le terme “CPython” est utilisé dans certains contextes lorsqu’il est nécessaire de distinguer cette implémentation des autres comme Jython ou IronPython.

décorateur

Une fonction retournant une autre fonction, utilisé habituellement dans une transformation de fonction via la syntaxe @wrapper. Les exemples habituels pour les décorateurs (decorators) sont classmethod() et staticmethod().

La syntaxe des décorateurs est simplement du sucre syntaxique, les définitions des deux fonctions suivantes sont sémantiquement équivalentes :

def f(...):
    ...
f = staticmethod(f)

@staticmethod
def f(...):
    ...

Quoique moins fréquemment utilisé, le même concept existe pour les classes. Consultez la documentation définitions de fonctions et définitions de classes pour en savoir plus sur les décorateurs.

descripteur

N’importe quel objet définissant les méthodes __get__(), __set__(), ou __delete__(). Lorsque l’attribut d’une classe est un descripteur, son comportement spécial est déclenché lors de la recherche des attributs. En utilisant a.b pour obtenir, affecter, ou effacer un attribut, il recherche l’objet nommé b dans la dictionnaire de la classe pour a, mais si b est un descripteur, la méthode de ce descripteur est alors appelée. Comprendre les descripteurs est la clé d’une compréhension approfondie de Python, ils sont la base de nombre de ses caractéristiques notamment les fonctions, méthodes, propriétés, méthodes de classe, méthodes statiques, et les références aux classes mères.

Pour plus d’informations sur les méthodes des descripteurs, consultez Implementing Descriptors.

dictionnaire

Une structure de donnée associant des clefs et des valeurs. Les clefs peuvent être n’importe quel objet comportant les méthodes __hash__() et __eq__(). Elle s’appelle “hash” en Perl.

vue de dictionnaire

Les objets donnés par les méthodes dict.keys(), dict.values(), et dict.items() sont des vues de dictionnaire. Ce sont des vues, dynamiques, des entrées du dictionnaire, ce qui signifie que lorsque le dictionnaire change, la vue change. Pour transformer une vue en vrai liste, utilisez list(dictview). Voir Dictionary view objects.

docstring

Une chaîne littérale étant la première expression d’une classe, fonction, ou module. Bien qu’ignoré à l’exécution, elles sont reconnues par le compilateur, et placées dans l’attribut __doc__ de sa classe, fonction, ou module respectif. Puisque cette chaîne est disponible par introspection, c’est l’endroit idéal pour documenter l’objet.

duck-typing

Un style de programmation qui ne prend pas en compte le type d’un objet pour déterminer s’il respecte une interface, mais qui qui appelle simplement la méthode ou l’attribut (Si ça a un bec et que ça cancane, c’est un canard). En se concentrant sur les interfaces plutôt que les types, du code bien construit améliore sa flexibilité en autorisant des substitutions polymorphiques. Un code orienté duck-typing évite de vérifier les types via type() ou isinstance(), (notez cependant que le duck-typing peut travailler de pair avec les classes de base abstraites.) À la place, le duck-typing utilise plutôt hasattr() ou la programmation EAFP.

EAFP

Il est plus simple de demander pardon que demander la permission (Easier to Ask for Forgiveness than Permission). Ce style de développement Python fait l’hypothèse que le code est valide, et attrape les exceptions si cette hypothèse s’avèrait fausse. Ce style, propre et efficace, est caractérisé par la présence de beaucoup de mot clé try et except. Cette technique de programmation contraste avec le style LBYL présent couramment dans des langages tel que C.

expression

Une suite logique de termes et chiffres conformes à la syntaxe Python dont l’évaluation fournit une valeur. En d’autres termes, une expression est une suite d’éléments tels que des noms, opérateurs, littéraux, accès d’attributs, méthodes ou fonctions qui aboutissent à une valeur. Contrairement à beaucoup d’autres langages, les différentes constructions du langage ne sont pas toutes des expressions. Il y a également des instructions qui ne peuvent pas être utilisées comme expressions, tel que if. Les affectations sont également des instructions et non des expressions.

module d’extension

Un module écrit en C ou C++, utilisant l’API C de Python pour interagir avec Python et le code de l’utilisateur.

objet fichier

Un objet exposant une ressource via une API orientée fichier (avec les méthodes read() ou write()). En fonction de la manière dont ils ont été créés, les objets fichiers peuvent exposer un fichier sur le disque, ou un autre type de stockage ou de communication (typiquement l’entrée standard, la sortie standard, un tampon en mémoire, des sockets, ...). Les objets fichiers sont aussi appelés file-like-objects ou streams.

Il existe en réalité trois catégories de fichiers objets : les fichiers binaires bruts, les fichiers binaire bufferisés, et les fichiers texte. Leurs interfaces sont définies dans le module io. Le moyen le plus simple et direct de créer un objet fichier est d’utiliser la fonction open().

objet fichier-compatible

Un synonyme de objet fichier.

finder

Un objet qui essaye de trouver un loader pour le module étant importé.

Depuis Python 3.3, il existe deux types de finder: meta path finders à utiliser avec sys.meta_path, et path entry finders à utiliser avec sys.path_hooks.

Voir PEP 302, PEP 420 et PEP 451 pour plus de détails.

division entière

Division mathématique arrondissant à l’entier le plus petit. L’opérateur de la division entière est //. Par exemple l’expression 11 // 4 vaut 2, contrairement à 11 / 4 qui vaut 2.75. Notez que (-11) // 4 vaut -3 car l’arrondi se fait par le bas. Voir la PEP 328.

fonction

Une suite d’instructions qui renvoient une valeur à celui qui l’appelle. On peut aussi lui passer des arguments qui pourront être utilisés dans le corps de la fonction. Voir aussi paramètre, méthode, et Function definitions.

annotation de fonction

Une métadonnée quelconque, associée au paramètre d’une fonction ou sa valeur de retour. Sa syntaxe est documentée dans la section Function definitions. Les annotations sont accessibles via l’attribut spécial __annotations__ d’une fonction.

Python ne prend pas en compte les annotations. Leur but est d’être interprétées par d’autres bibliothèques ou outils. Voir la PEP 3207, qui décrit certains usages.

__future__

Un pseudo-module que les développeurs peuvent utiliser pour activer de nouvelles fonctionnalités du langage qui ne sont pas compatibles avec l’interpréteur utilisé.

En important le module __future__ et en affichant ses variables, vous pouvez voir quand une nouvelle fonctionnalité à été rajoutée dans le langage, et quand elle devient le comportement par défaut :

>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
ramasse-miettes

(garbage collection) Le mécanisme permettant de libérer de la mémoire lorsqu’elle n’est plus utilisée. Python utilise un ramasse-miettes par comptage de référence, et un ramasse-miettes cyclique capable de détecter et casser les références circulaires.

générateur

Une fonction qui renvoie un itérateur de générateur. Cela ressemble à une fonction normale, en dehors du fait qu’elle contient une ou des expressions yield pruduisant une série de valeurs utilisable dans une boucle for, ou récupérées une à une via la fonction next().

Fait généralement allusion à une fonction générateur, mais peut faire allusion à un itérateur de générateur dans certains contextes. Dans les cas où le sens voulu n’est pas clair, utiliser les termes complets évite l’ambiguité.

itérateur de générateur

Un objet crée par une fonction générateur.

Chaque yield suspend temporairement l’exécution, se rappelant de l’endroit et de l’état de l’exécution (incluant les variables locales et les try en cours). Lorsque l’itérateur de générateur reprend, il reprend où il en était (contrairement à une fonction qui prendrait un nouveau départ à chaque invocation).

expression génératrice

Une expression qui donne un itérateur. Cela ressemble à une expression normale, suivie d’une expression for définissant une variable de boucle, d’un range, et d’une expression, optionnelle, if. Cette expression combinée génère des valeurs pour la fonction qui l’entoure :

>>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
285
fonction générique

Une fonction composée de plusieurs fonctions implémentant les mêmes opérations pour différents types. L’implémentation à utiliser est déterminé lors de l’appel est déterminée par un algorithme de répartition.

Voir aussi single dispatch, le décorateur functools.singledispatch(), et la PEP 443.

GIL

Voir global interpreter lock.

verrou global de l’interpréteur

Le mécanisme utilisé par l’interpréteur CPython pour s’assurer qu’un seul thread n’execute du bytecode à la fois. Cela simplifie l’implémentation de CPython en rendant le modèle objet (incluant des parties critiques comme la classe native dict) implicitement protégé des accès concourants. Vérouiller l’interpréteur entier le rend plus facile à rendre multi-thread, en perdant malheureusement la majorité du parallélisme possible sur les machines ayant plusieurs processeurs.

Cependant, certains modules d’extension, standards ou non, sont construits de manière à libérer le GIL lorsqu’ils effectuent des tâches lourdes tel que la compression ou le hachage. Aussi, le GIL est toujours libéré lors des lectures et écritures.

Les tentatives précédentes d’implémenter un interpréteur Python avec une granularité de verrouillage plus fine ont toutes échouées, à cause de leur performances sur un seul processeur. Il est admis que corriger c’est problèmes de performance induits mènerai vers une implémentation compliquée et donc plus coûteuse à maintenir.

hachable

Un objet est hachable s’il a une empreinte (hash) qui ne change jamais. (et il a besoin d’une méthode __hash__()) et peut être comparé à d’autres objets (avec la méthode __eq__()). Les objets hachables dont __eq__ dit être équivalents, ont aussi la même empreinte.

La hachabilité permet à un objet d’être utilisé comme clef de dictionnaire, ou en temps que membre d’un set, car ces structures de données utilisent ce hash.

Tous les types immuables fournis par Python sont hachables, et aucun type mutable (comme les listes ou les dictionnaires) ne l’est. Toutes les instances de classes définies par les utilisateurs sont hachables par défaut, elles sont toutes différentes selon __eq__, sauf comparées à elles mêmes, et leur empreinte (hash) est calculée à partir de leur id().

IDLE

Un environnement de développement intégré pour Python. IDLE est un éditeur et interpréteur basique livré avec la distribution standard de Python.

immuable

Un objet dont la valeur ne change pas. Les nombres, les chaînes et les tuples sont immuables. Ils ne peuvent être modifiés. Un nouvel objet doit être créé si une valeur différente doit être stockée. Ils jouent un rôle important aux endroits où une valeur de hash constante est requise, typiquement en clef de dictionnaire.

chemin d’import

Une liste de chemins dans lesquels le path based finder cherche les modules à importer. Typiquement lors d’un import cette liste vient de sys.path, mais pour les sous paquets, elle peut aussi venir de l’attribut __path__ du paquet parent.

importer

Le processus rendant le code d’un module disponible dans un autre.

importateur

Un objet qui trouve et charge un module, en même temps un finder et un loader.

interactif

Python a un interpréteur interactif, ce qui signifie que vous pouvez écrire des expressions et instructions à l’invite de l’interpréteur, qui va les exécuter immédiatement, et vous en présenter le résultat. Démarrez juste python (probablement depuis un menu de votre ordinateur). C’est un moyen puissant pour tester de nouvelles idées ou étudier de nouveaux modules (souvenez vous de help(x)).

interprété

Python est un langage interprété, en opposition aux langages compilés, bien que la frontière soit floue du à la présence d’un compilateur en bytecode. Cela signifie que les fichiers sources peuvent être exécutés directement, sans avoir à compiler un fichier exécutable intermédiaire. Les langages interprétées ont généralement un cycle de développement / débug plus rapide, et ils s’exécutent généralement plus lentement. Voir aussi interactif.

arrêt de l’interpréteur

Lorsqu’on lui demande de s’arrêter, l’interpréteur Python entre dans une phase spéciale où il libère graduellement les ressources allouées, comme les modules ou quelques structures de données internes. Il fait aussi quelques appels au ramasse-miettes. Cela peut déclencher l’exécution de code dans des destructeurs ou des fonctions de rappels de weakrefs. Le code exécuté lors de l’arrêt peut rencontrer quelques exception puisque les ressources sur lesquels il pourrait s’appuyer pourraient ne plus fonctionner, (typiquement les modules de la bibliothèque ou le mécanisme de warning).

La principale raison qu’a l’interpréteur de s’arrêter est lorsque le module __main__ ou le script en cours d’exécution à terminé de s’exécuter.

itérable

Un objet capable de donner ses éléments un à un. Pour lister quelques exemples d’itérables, on pourrait lister tout les types séquence (comme list, str, et tuple), et quelques autres comme dict, objets fichiers, ou tout objet de toute classe ayant une méthode __iter__() ou __getitem__(). Les itérables peuvent être utilisés dans des boucles for ou tout autre endroit où une séquence est requise (zip(), map(), ...). Lorsqu’un itérable est passé comme argument à la fonction native iter(), elle donnera un itérateur de cet itérable. Cet itérateur n’est valable que pour une passe sur le jeu de valeurs. Lors de l’utilisation d’itérables, il n’est habituellement pas nécessaire d’appeler iter() ou de s’occuper d’objet itérateurs. L’instruction for fait ça automatiquement pour vous, créant une variable temporaire anonyme pour garder l’itérateur durant la boucle. Voir aussi itérateur, séquence, et générateur.

itérateur

Un objet représentant un flux de donnée. Des appels successifs à la méthode __next__() de l’itérateur (ou le donner à la fonction native next()) donne successivement les objets du flux. Lorsque plus aucune donnée n’est disponible, une exception StopIteration est lancée. À ce point, l’itérateur est épuisé et tous les appels suivants à sa méthode __next__() lanceront encore une exception StopIteration. Les itérateurs doivent avoir une méthode __iter__() qui renvoie l’objet itérateur lui même, tel que chaque itérateur soit aussi itérable et puisse être utilisé dans la plupart des endroits où d’autres itérables sont attendus. Une exception notable serait un code qui tenterai plusieurs itérations complètes. Un objet conteneur, (tel que list) produit un nouvel itérateur neuf à chaque fois qu’il est donné à la fonction iter() où qu’il est utilisé dans une boucle for. Faire ceci sur un itérateur donnerai simplement le même objet itérateur épuisé utilisé dans son itération précédente, le faisant ressembler à un conteneur vide.

Plus d’informations ici : Les types Itérateurs.

fonction clef

Une fonction clef, est un objet appelable qui renvoie une valeur utilisée pour trier ou organiser. Par exemple la fonction local.strxfrm() sert à produire une fonction clef de tri prennant en compte les conventions de tri spécifiques aux paramètres régionaux courants.

Plusieurs outils dans Python acceptent des fonctions clef pour maîtriser comment les éléments dont triés ou groupés. Typiquement les fonctions min(), max(), sorted(), list.sort(), heapq.merge(), heapq.nsmallest(), heapq.nlargest(), et itertools.groupby().

Il existe plusieurs moyens de créer une fonction clef. Par exemple, la méthode str.lower() peut servir en fonction clef pour effectuer des recherches insensibles à la casse. Aussi, il est possible de créer des fonctions clef avec des expressions lambda, comme lambda r: (r[0], r[2]). Finalement le module operator fournit des constructeurs de fonctions clef : attrgetter(), itemgetter(), et methodcaller(). Voir Comment Trier pour avoir des exemple de création et d’utilisation de fonctions clés.

argument nommé

Voir argument.

lambda

Une fonction anonyme sous forme d’une expression, et ne contenant qu’une expression, exécutée lorsqu’elle est appelée. La syntaxe pour créer des fonctions lambda est: lambda [arguments]: expression

LBYL

Regarde devant avant de tomber, (Look before you leap). Ce style de programmation consiste à vérifier des conditions avant d’effectuer des appels ou des accès. Ce style contraste avec le style EAFP et se caractérise par la présence de beaucoup d’instructions if.

Dans un environnement multi-thread, le style LBYL peut engendrer une séquence critique (race condition) entre “regarder” et “tomber”. Par exemple, le code if key in mapping: return mapping[key] peut échouer si un autre thread supprime la clef key du mapping après le test mais avant l’accès. Ce problème peut être résolu avec des verrous (locks) ou avec l’approche EAFP.

list

Un type natif de sequence dans Python. En dépit de son nom, une list ressemble plus à un array qu’à une liste chaînée puisque les accès se font en O(1).

liste en compréhension

Un moyen compacte de manipuler tous ou partie des éléments d’une séquence renvoyant une liste avec les résultats. result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] génère une liste de chaînes de caractères contenant les nombres paires sous forme hexadécimale (0x...) de 0 à 255. La clause if est optionnelle. Si elle est omise, tous les éléments du range(256) seront utilisés.

loader

Un objet qui charge un module. Il doit définir une méthode nommée load_module(). Un loader est typiquement donné par un finder. Voir PEP 302 pour les détails et importlib.ABC.Loader pour sa classe de base abstraite.

mapping

Un conteneur acceptant de rechercher des éléments par clef et implémente les méthodes des classes de base abstraites collections.abc.Mapping ou collections.abc.MutableMapping. Les classes suivantes sont des exemples de mapping: dict, collections.defaultdict, collections.OrderedDict, et collections.Counter.

meta path finder

Un finder donné par une recherche dans sys.meta_path. Les meta path finders ressemblent, mais sont différents de path entry finders.

Voir importlib.abc.MetaPathFinder pour les méthodes que les meta path finders doivent implémenter.

metaclasse

La classe d’une classe. Les définitions de classe créent un nom pour la classe, un dictionnaire et une liste de classes patentes. La métaclasse a pour rôle de réunir ces trois paramètres pour construire la classe. La plupart des langages orientés objet fournissent une implémentation par défaut. Ce qui rend Python spécial, c’est de proposer de créer des métaclasses personnalisées. La plupart des utilisateurs n’ont pas besoin de cet outil, mais lorsque le besoin survient, les métaclasses sont souvent des solutions élégantes, puissantes, et utiles. Elles ont été utilisées pour journaliser les accès à des propriétés, rendre un objet sûr pour une utilisation en environnement multi-thread, suivre la création d’objets, implémenter des singleton, et bien d’autres tâches.

Plus d’informations à ce sujet : Customizing class creation.

méthode

Une fonction définie dans une classe. Lorsqu’elle est appelée comme un attribut d’une instance, la méthode reçoit l’instance en premier argument (qui par convention est nommé self). Voir function et nested scope.

ordre de résolution des méthodes

L’ordre de résolution des méthodes (MRO de Method Resolution Order) est l’ordre par lequel les membres sont recherchées dans les classes parentes. Voir The Python 2.3 Method Resolution Order pour plus de détails sur l’algorithme utilisé par l’interpréteur Python depuis la version 2.3.

module

L’unité élémentaire de l’organisation du code en Python. Les modules ont un espace de noms pouvant contenir n’importe quel objet Python. Charger des modules est appelé importer.

Voir aussi paquet.

module spec

Un espace de nom contenant les informations, relatives à l’import, utilisés pour charger un module. C’est une instance de la classe importlib.machinery.ModuleSpec.

MRO

Voir ordre de résolution des méthodes.

mutable

Un objet mutable peut changer de valeur tout en gardant le même id(). Voir aussi immuable.

named tuple

Une classe qui, comme tuple a ses éléments accessibles par leur indice, mais en plus accessibles par leur nom (par exemple, time.localtime() donne un objet ressemblant à un tuple, dont year est accessible par son indice : t[0] ou par son nom : t.tm_year).

Un named tuple peut être un type natif tel que time.struct_time ou il peut être construit comme une simple classe. Un named tuple complet peut aussi être créé via la fonction collections.namedtuple(). Cette dernière approche fournit automatiquement des fonctionnalités supplémentaires, tel qu’une représentation lisible comme Employee(name='jones', title='programmer').

espace de nom

L’endroit où une variable est stockée. Les espaces de noms sont en fait des dictionnaires. Il existe des espaces de noms globaux, natifs, ou imbriqués dans les objets (dans les méthodes). Les espaces de noms sont modulaires afin d’éviter les conflits de noms. Par exemple, les fonctions builtins.open et os.open() sont différenciées par leurs espaces de nom. Les espaces de noms aident aussi à la lisibilité et maintenabilité en rendant clair quel module implémente une fonction. Par exemple, écrire random.seed() ou itertools.islice() rend clair que ces fonctions sont implémentées respectivement dans les modules random et itertools.

paquet espace de nom

Un paquet tel que défini dans la PEP 421 qui ne sert qu’à contenir des sous paquets. Les paquets-espace de nom peuvent n’avoir aucune représentation physique, et plus spécifiquement ne sont pas comme un paquet classique puisqu’ils n’ont pas de fichier __init__.py.

Voir aussi module.

portée imbriquée

La possibilité de toucher une variable déclarée dans une définition englobante. Typiquement, une fonction définie à l’intérieur d’une autre fonction aura accès aux variables de cette autre fonction. Souvenez-vous cependant que cela ne fonctionne que pour accéder à des variables, pas pour les assigner. Les variables locales sont lues et assignées dans l’espace de nom le plus proche. Tout comme les variables globales qui sont stockés sur l’espace de noms global, le mot clef nonlocal permet d’écrire dans l’espace de nom dans lequel est déclaré la variable.

nouvelle classe

Ancien nom pour l’implémentation actuelle des classes, pour tous les objets. Dans les anciennes versions de Python, seulement les nouvelles classes pouvaient utiliser les nouvelles fonctionnalités tel que __slots__, les descripteurs, les propriétés, __getattribute__(), les méthodes de classe, et les méthodes statiques.

objet

N’importe quelle donnée comportant des états sous forme d’attributs ou de valeurs, et un comportement (des méthodes). C’est aussi (object) l’ancêtre commun à absolument toutes les nouvelles classes.

paquet

Un module qui peut contenir des sous modules ou des sous paquets. Techniquement, un paquet est un module qui a un attribut __path__.

Voir aussi paquet classique et paquet espace de nom.

paramètre

Une entité nommée, dans la définition d’une fonction (ou méthode, décrivant un argument (ou dans certains cas des arguments) que la fonction accepte. Il existe cinq sorte de paramètres :

  • positional-or-keyword: dit d’un argument qui peut être passé soit par sa position soit en temps que paramètre nommé. C’est le type de paramètre par défaut, par exemple, foo et bar dans l’exemple suivant :

    def func(foo, bar=None): ...
    
  • positional-only: un argument qui ne peut être donné que par sa position. Python n’a pas de syntaxe pour déclarer de tels paramètre, cependant des fonctions natives, comme abs() en utilisent.

  • keyword-only: définit un argument qui ne peut être fournit que par nom. Les paramètres keyword-only peuvent être définis en utilisant un seul paramètre var-positional, ou en ajoutant une étoire (*) seule dans la liste des paramètres avant avant eux. Comme kw_only1 et kw_only2 ici :

    def func(arg, *, kw_only1, kw_only2): ...
    
  • var-positional: spécifie qu’une séquence d’arguments positionels peut être fourni (en plus de tous les arguments positionels déjà acceptés par d’autres paramètres). Un tel paramètre peut être définit en préfixant son nom par une *, par exemple args ici :

    def func(*args, **kwargs): ...
    
  • var-keyword: spécifie qu’une quantité arbitraire d’arguments peuvent être passés par nom (en plus de tous les arguments nommés déjà acceptés par d’autres paramètres). Un tel paramètre est définit en préfixant le nom du paramètre par **, par exemple, kwargs ci-dessus.

Les paramètres peuvent décrire aussi bien des paramètres optionnels ou obligatoires, aussi que des valeurs par défaut pour les paramètres optionnels.

Voir aussi argument dans le glossaire, la question sur la différence entre les arguments et les paramètre dans la FAQ, la classe inspect.Parameter, la section Function definitions, et la PEP 362.

chemin

Un seul emplacement dans l’import path que le path based finder consulte pour trouver des modules à importer.

path entry finder

Un finder donné par un appelable sur un sys.path_hooks (çàd un path entry hook) qui sait où trouver des modules lorsqu’on lui donne un path entry.

Voir importlib.abc.PathEntryFinder pour les méthodes qu’un path entry finder doit implémenter.

path entry hook

Un appelable dans la liste sys.path_hook qui donne un path entry finder s’il sait où trouver des modules pour un path entry donné.

path based finder

L’un des meta path finders par défaut qui cherche des modules dans un import path.

portion

Un jeu de fichiers dans un seul dossier (pouvant être stockés sous forme de fichier zip) qui contribuent à l’espace de nom d’un paquet, tel que définit dans la PEP 420.

augment positionnel

Voir argument.

API provisoire

Une API provisoire est une API délibérément exclue des garanties de rétrocompatibilité de la bibliothèque standard. Bien que des changements majeurs de telles interfaces ne sont pas attendus, tant qu’elles sont marquées provisoires, des changement cassant la rétrocompatibilité (jusqu’à sa suppression complète) peuvent survenir s’ils semblent nécessaires. Ces modifications ne seront pas effectuées gratuitement, ils ne surviendront seulement si de sérieux problèmes sont découvert, qui n’avaient pas étés repérés avant l’ajout de l’API.

Même pour les API provisoires, les changement cassant la rétrocompatibilité sont des “solutions de dernier recours”, tout ce qui est possible sera fait pour tenter de résoudre les problème en conservant la rétrocompatibilité.

Ce processus permet à la bibliothèque standard de continuer à évoluer avec le temps, sans se bloquer longtemps sur des erreurs d’architecture. Voir la PEP 411 pour plus de détails.

paquet provisoire

Voir provisional API.

Python 3000

Surnom de la série des Python 3.x (très vieux surnom donné à l’époque pour Python 3 n’était qu’un futur lointain). Aussi abrégé “Py3k”.

Pythonique

Une idée, ou un bout de code, qui suit de près la philosophie de Python, parfois en opposition avec les concepts rencontrés dans d’autres langages. Typiquement, la coutume en Python est de parcourir les éléments d’un itérable en utilisant for. Beaucoup de langages n’ont pas cette possibilité, donc les gens qui ne sont pas habitués à Python pourraient parfois utiliser un compteur à la place :

for i in range(len(food)):
    print(food[i])

Plutôt qu’utiliser la méthode, plus propre et élégante, donc Pythonique :

for piece in food:
    print(piece)
nom qualifié

Un nom, comprenant des points, montrant le “chemin” de l’espace de nom globale d’un module à une class, fonction, ou méthode définie dans ce module, tel que défini dans la PEP 3155. Pour les fonctions et classes de premier niveau, le nom qualifié est le même que le nom de l’objet :

>>> class C:
...     class D:
...         def meth(self):
...             pass
...
>>> C.__qualname__
'C'
>>> C.D.__qualname__
'C.D'
>>> C.D.meth.__qualname__
'C.D.meth'

Lorsqu’il est utilisé pour nommer des modules, le nom qualifié complet signifie le chemin complet (séparé par des points) vers le module, incluant tous les paquet parents, typiquement: email.mime.text

>>> import email.mime.text
>>> email.mime.text.__name__
'email.mime.text'
nombre de références

Le nombre de références à un objet. Lorsque le nombre de références à un objet descend à zéro, l’objet est désalloué. Le comptage de référence n’est généralement pas visible dans le code Python, mais c’est un élément clef de l’implémentation CPython. Le module sys défini une fonction getrefcount() que les développeurs peuvent utiliser pour obtenir le nombre de référence d’un objet donné.

paquet classique

Un paquet traditionnel, tel qu’un dossier contenant un fichier __init__.py.

Voir aussi paquet espace de nom.

__slots__

Une déclaration dans une classe qui économise de la mémoire en pré-allouant de l’espace pour les instances des attributs, et le dictionnaire des instances. Bien que populaire, cette technique est difficile à maîtriser et devrait être réservée à de rares cas avec un grand nombre d’instances dans une application où la mémoire est un sujet critique.

séquence

Un itérable qui gère l’accès efficient à ses éléments par un indice sous forme de nombre entier via la méthode spéciale __getitem__() et qui défini une méthode __len__() qui donne sa taille. Voici quelques séquences natives : list, str, tuple, et bytes. Notez que dict a aussi une méthode __getitem__() et une méthode __len__(), mais il est considéré comme un mapping plutôt qu’une séquence, car ses accès se font par une clef arbitraire immuable plutôt qu’un nombre entier.

La class abstraite de base collections.abc.Sequence défini une interface plus riche qui va au delà des simples __getitem__() et __len__(), en ajoutant count(), index(), __contains__(), et __reversed__(). Les types qui implémentent cette interface étendue peuvent s’enregistrer explicitement en utilisant register().

distribution simple

Une forme de distribution, comme les fonction génériques, où l’implémentation est choisie en fonction du type d’un seul argument.

tranche

slice, un objet contenant habituellement une portion de séquence. Une tranche est crée en utilisant la notation [] avec des : entre les nombres lorsque plusieurs sont fournis, tel que dans variable_name[1:3:5]. Cette notation utilise des objets slice en interne.

méthode spéciale

special method: Une méthode appelée implicitement par Python pour exécuter une opération sur un type, tel qu’une addition. De telles méthodes ont des noms commençant et terminant par des doubles tirets bas. Les méthodes spéciales sont documentées dans Special method names.

instruction

Une instruction (statement) fait partie d’une suite, (un “bloc” de code). Une instruction est soit une expression soit une ou plusieurs constructions basées sur un mot-clef, tel qu’un if, while, ou for.

struct sequence

Un uplet (tuple) dont les éléments sont nommés. Les struct sequences exposent une interface similaires au named tuple par le fait que leurs éléments peuvent être accédés par nom d’attribut ou par indice. Cependant, elles n’ont aucune des méthodes du named tuple, comme collections.somenamedtuple._make() ou _asdict(). Par exemple sys.float_info, ou les valeurs données par os.stat() sont des struct sequence.

encodage de texte

Un codec qui convertit des chaînes de caractères Unicode en octets.

fichier texte

Un objet fichier capable de lire et d’écrire des objets str. Souvent, un fichier texte (text file) accède en fait à flux de donnée en octets, et gère l’encodage de texte automatiquement.

Voir aussi

Un fichier binaire lit et écrit des objets bytes.

chaîne entre triple guillemets

Une chaîne qui est assembée par trois guillemets simples (') ou trois guillemets doubles ("). Bien qu’elles ne fournissent aucune fonctionalité qui ne serait pas disponnible avec les chaînes entre guillemets, elles sont utiles pour moultes raisons. Elles vous autorisent à insérer des guillemets simples et doubles dans une chaîne sans avoir à les protéger, et elles peuvent s’étendre sur plusieurs lignes sans avoir à les terminer par un \, les rendant ainsi particulièrement utile pour les chaînes de documentation (docstrings).

type

Le type d’un objet Python détermine quel genre d’objet c’est. Tous les objets ont un type. Le type d’un objet peut être obtenu via son attribut __class__ ou via type(obj).

retours à la ligne universels

Une manière d’interpréter des flux de texte dans lesquels toutes les fin de lignes suivantes sont reconnues: la convention Unix '\n', la convention Windows '\r\n', et l’ancienne convention Macintosh '\r'. Voir la PEP 278 et la PEP 3116, ainsi que la fonction bytes.splitlines() pour d’autres usages.

environnement virtuel

Un environnement isolé, coopérant à son isolement à l’execution, qui permet aux utilisateurs de Python et aux applications d’installer et de mettre à jour des paquets sans interférer avec d’autres applications Python fonctionnant sur le même système.

Voir aussi pyvenv - Creating virtual environments.

machine virtuelle

Un ordinateur défini entièrement par du logiciel. La machine virtuelle (virtual machine) de Python exécute le bytecode donné par le compilateur de bytecode.

Le Zen de Python

Liste de principes et de philosophies utiles pour comprendre et utiliser le langage. Cette liste peut être obtenue en tapant “import this” dans une invite Python interactive.