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 viaTools/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 parisinstance()
ouissubclass()
(Voir la documentation du moduleabc
). Python contient de nombreuses ABC pour les structures de données (dans le modulecollections.abc
), les nombres (dans le modulenumbers
), les flux (dans le moduleio
), et les chercheurs / chargeurs d’import (dans le moduleimportlib.abc
). Vous pouvez créer vos propres ABC avec le moduleabc
. - 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
et5
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
et5
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.
- 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.
- BDFL
- Bienveillant dictateur à vie (de Benevolent Dictator For Life), alias Guido van Rossum, le créateur de Python.
- fichier binaire
A file object able to read and write bytes-like objects.
Voir aussi
Un fichier texte lis et écris des objets
str
.- Objet bytes-compatible
- An object that supports the Buffer Protocol, like
bytes
,bytearray
ormemoryview
. Bytes-like objects can be used for various operations that expect binary data, such as compression, saving to a binary file or sending over a socket. Some operations need the binary data to be mutable, in which case not all bytes-like objects can apply. - bytecode
Python source code is compiled into bytecode, the internal representation of a Python program in the CPython interpreter. The bytecode is also cached in
.pyc
and.pyo
files so that executing the same file is faster the second time (recompilation from source to bytecode can be avoided). This « intermediate language » is said to run on a virtual machine that executes the machine code corresponding to each bytecode. Do note that bytecodes are not expected to work between different Python virtual machines, nor to be stable between Python releases.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ération3 + 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 exceptionTypeError
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 simple3 + 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 écritei
en mathématiques ouj
en ingénierie. Python supporte nativement les nombres complexes, écrits avec cette dernière notation; la partie imaginaire est écrite avec un suffixej
, exemple,3+1j
. Pour utiliser les équivalents complexes àmath
, utilisezcmath
. 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. - 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) sontclassmethod()
etstaticmethod()
.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. - 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()
ouisinstance()
, (notez cependant que le duck-typing peut travailler de pair avec les classes de base abstraites.) À la place, le duck-typing utilise plutôthasattr()
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
etexcept
. 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()
ouwrite()
). 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 fonctionopen()
.- objet fichier-compatible
- Un synonyme de objet fichier.
- finder
- An object that tries to find the loader for a module. It must
implement either a method named
find_loader()
or a method namedfind_module()
. See PEP 302 and PEP 420 for details andimportlib.abc.Finder
for an abstract base class. - division entière
- Division mathématique arrondissant à l’entier le plus petit. L’opérateur de la division entière est
//
. Par exemple l’expression11 // 4
vaut2
, contrairement à11 / 4
qui vaut2.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
- A function which returns an iterator. It looks like a normal function
except that it contains
yield
statements for producing a series of values usable in a for-loop or that can be retrieved one at a time with thenext()
function. Eachyield
temporarily suspends processing, remembering the location execution state (including local variables and pending try-statements). When the generator resumes, it picks-up where it left-off (in contrast to functions which start fresh on every 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.
All of Python’s immutable built-in objects are hashable, while no mutable containers (such as lists or dictionaries) are. Objects which are instances of user-defined classes are hashable by default; they all compare unequal (except with themselves), and their hash value is derived from their
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 dehelp(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
, ettuple
), et quelques autres commedict
, objets fichiers, ou tout objet de toute classe ayant une méthode__iter__()
ou__getitem__()
. Les itérables peuvent être utilisés dans des bouclesfor
ou tout autre endroit où une séquence est requise (zip()
,map()
, …). Lorsqu’un itérable est passé comme argument à la fonction nativeiter()
, 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’appeleriter()
ou de s’occuper d’objet itérateurs. L’instructionfor
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 nativenext()
) donne successivement les objets du flux. Lorsque plus aucune donnée n’est disponible, une exceptionStopIteration
est lancée. À ce point, l’itérateur est épuisé et tous les appels suivants à sa méthode__next__()
lanceront encore une exceptionStopIteration
. 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 quelist
) produit un nouvel itérateur neuf à chaque fois qu’il est donné à la fonctioniter()
où qu’il est utilisé dans une bouclefor
. 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()
, etitertools.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 expressionslambda
, commelambda r: (r[0], r[2])
. Finalement le moduleoperator
fournit des constructeurs de fonctions clef :attrgetter()
,itemgetter()
, etmethodcaller()
. 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 clauseif
est optionnelle. Si elle est omise, tous les éléments durange(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 etimportlib.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
oucollections.abc.MutableMapping
. Les classes suivantes sont des exemples de mapping:dict
,collections.defaultdict
,collections.OrderedDict
, etcollections.Counter
. - meta path finder
- A finder returned by a search of
sys.meta_path
. Meta path finders are related to, but different from path entry finders. - 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
- Method Resolution Order is the order in which base classes are searched for a member during lookup. See The Python 2.3 Method Resolution Order.
- 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
- A namespace containing the import-related information used to load a module.
- 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 fonctioncollections.namedtuple()
. Cette dernière approche fournit automatiquement des fonctionnalités supplémentaires, tel qu’une représentation lisible commeEmployee(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
etos.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, écrirerandom.seed()
ouitertools.islice()
rend clair que ces fonctions sont implémentées respectivement dans les modulesrandom
etitertools
. - 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. - 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 fonctiongetrefcount()
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
, etbytes
. Notez quedict
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 ajoutantcount()
,index()
,__contains__()
, et__reversed__()
. Les types qui implémentent cette interface étendue peuvent s’enregistrer explicitement en utilisantregister()
.- 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 dansvariable_name[1:3:5]
. Cette notation utilise des objetsslice
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
, oufor
. - 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 exemplesys.float_info
, ou les valeurs données paros.stat()
sont des struct sequence. - encodage de texte
- Un codec qui convertit des chaînes de caractères Unicode en octets.
- fichier texte
A file object able to read and write
str
objects. Often, a text file actually accesses a byte-oriented datastream and handles the text encoding automatically.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 viatype(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 fonctionbytes.splitlines()
pour d’autres usages. - view
- The objects returned from
dict.keys()
,dict.values()
, anddict.items()
are called dictionary views. They are lazy sequences that will see changes in the underlying dictionary. To force the dictionary view to become a full list uselist(dictview)
. See Dictionary view objects. - 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.
- 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.