# 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.

`...`

  The default Python prompt of the interactive shell when entering code for an indented code block, when within a pair of matching left and right delimiters (parentheses, square brackets, curly braces or triple quotes), or after specifying a decorator.

2to3

  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 — Traduction automatique de code en 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`), les nombres (dans le module `numbers`), les flux (dans le module `io`). 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 cette 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, et la question dans la FAQ à propos de la différence entre argument et paramètre.

attribut

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

BDFL

  Dictateur bienveillant à vie (Benevolent Dictator For Life en anglais). Pseudonyme de Guido van Rossum, le créateur de Python.

Objet bytes-compatible

  Un objet gérant le bufferobjects, comme les classes `str`, `bytearray`, ou `memoryview`. Les objets bytes-compatibles peuvent manipuler des données binaires et ainsi servir à leur compression, sauvegarde, ou envoi sur une socket. Certaines actions nécessitent que la donnée binaire soit modifiable, ce qui n’est pas possible avec tous les objets byte-compatibles.

code intermédiaire (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.

  La documentation du module dis fournit une liste des instructions du code intermédiaire.

classe

  Modèle pour créer des objets définis par l’utilisateur. Une définition de classe (class) contient normalement des définitions de méthodes qui agissent sur les instances de la classe.

classic class

  Any class which does not inherit from `object`. See new-style class. Classic classes have been removed in Python 3.

coercition

  The implicit conversion of an instance of one type to another during an operation which involves two arguments of the same type. For example, `int(3.15)` converts the floating point number to the integer `3`, but in `3+4.5`, each argument is of a different type (one int, one float), and both must be converted to the same type before they can be added or it will raise a `TypeError`. Coercion between two operands can be performed with the `coerce` built-in function; thus, `3+4.5` is equivalent to calling `operator.add(*coerce(3, 4.5))` and results in `operator.add(3.0, 4.5)`. Without coercion, all arguments of even compatible types would have to be normalized to the same value by the programmer, e.g., `float(3)+4.5` rather than just `3+4.5`.

nombre complexe

  Extension des nombres réels familiers, dans laquelle tous les nombres sont exprimés sous la forme d’une somme d’une partie réelle et d’une partie imaginaire. Les nombres imaginaires sont les nombres réels multipliés par l’unité imaginaire (la racine carrée de `-1`, souvent écrite `i` en mathématiques ou `j` par les ingénieurs). Python comprend 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 de `math`, utilisez `cmath`. Les nombres complexes sont un concept assez avancé en mathématiques. Si vous ne connaissez pas ce concept, vous pouvez tranquillement les ignorer.

gestionnaire de contexte

  Objet contrôlant l’environnement à l’intérieur d’un bloc `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

  Fonction dont la valeur de retour est une autre fonction. Un décorateur est habituellement utilisé pour transformer une fonction via la syntaxe `@wrapper`, dont les exemples typiques 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

  Any new-style object which defines the methods `__get__()`, `__set__()`, or `__delete__()`. When a class attribute is a descriptor, its special binding behavior is triggered upon attribute lookup. Normally, using a.b to get, set or delete an attribute looks up the object named b in the class dictionary for a, but if b is a descriptor, the respective descriptor method gets called. Understanding descriptors is a key to a deep understanding of Python because they are the basis for many features including functions, methods, properties, class methods, static methods, and reference to super classes.

  Pour plus d’informations sur les méthodes des descripteurs, consultez Implémentation de descripteurs.

dictionnaire

  An associative array, where arbitrary keys are mapped to values. The keys can be any object with `__hash__()` and `__eq__()` methods. Called a hash in Perl.

vue de dictionnaire

  The objects returned from `dict.viewkeys()`, `dict.viewvalues()`, and `dict.viewitems()` are called dictionary views. They provide a dynamic view on the dictionary’s entries, which means that when the dictionary changes, the view reflects these changes. To force the dictionary view to become a full list use `list(dictview)`. See Les vues de dictionnaires.

docstring

  Première chaîne littérale qui apparaît dans l’expression d’une classe, fonction, ou module. Bien qu’ignorée à l’exécution, elles est reconnue par le compilateur et placée dans l’attribut `__doc__` de la classe, de la fonction ou du module. Comme cette chaîne est disponible par introspection, c’est l’endroit idéal pour documenter l’objet.

duck-typing

  Style de programmation qui ne prend pas en compte le type d’un objet pour déterminer s’il respecte une interface, mais qui appelle simplement la méthode ou l’attribut (Si ça a un bec et que ça cancane, ça doit être un canard, duck signifie canard en anglais). En se concentrant sur les interfaces plutôt que les types, du code bien construit améliore sa flexibilité en autorisant des substitutions polymorphiques. Le 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 en anglais). Ce style de développement Python fait l’hypothèse que le code est valide et traite les exceptions si cette hypothèse s’avère fausse. Ce style, propre et efficace, est caractérisé par la présence de beaucoup de mots clés `try` et `except`. Cette technique de programmation contraste avec le style LBYL utilisé couramment dans les langages tels que C.

expression

  A piece of syntax which can be evaluated to some value. In other words, an expression is an accumulation of expression elements like literals, names, attribute access, operators or function calls which all return a value. In contrast to many other languages, not all language constructs are expressions. There are also statements which cannot be used as expressions, such as `print` or `if`. Assignments are also statements, not expressions.

module d’extension

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

objet fichier

  Objet exposant une ressource via une API orientée fichier (avec les méthodes `read()` ou `write()`). En fonction de la manière dont il a été créé, un objet fichier peut interfacer l’accès à 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, une socket réseau, …). Les objets fichiers sont aussi appelés file-like-objects ou streams.

  There are actually three categories of file objects: raw binary files, buffered binary files and text files. Their interfaces are defined in the `io` module. The canonical way to create a file object is by using the `open()` function.

objet fichier-compatible

  Synonyme de objet fichier.

chercheur

  An object that tries to find the loader for a module. It must implement a method named `find_module()`. See PEP 302 for details.

division entière

  Division mathématique arrondissant à l’entier inférieur. 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 à l’entier inférieur. Voir la PEP 328.

fonction

  Suite d’instructions qui renvoie une valeur à son appelant. On peut lui passer des arguments qui pourront être utilisés dans le corps de la fonction. Voir aussi paramètre, méthode et Définition de fonctions.

__future__

  A pseudo-module which programmers can use to enable new language features which are not compatible with the current interpreter. For example, the expression `11/4` currently evaluates to `2`. If the module in which it is executed had enabled true division by executing:

      from __future__ import division

  the expression `11/4` would evaluate to `2.75`. By importing the `__future__` module and evaluating its variables, you can see when a new feature was first added to the language and when it will become the default:

      >>> 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 the `next()` function. Each `yield` 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

  Expression qui donne un itérateur. Elle ressemble à une expression normale, suivie d’une expression `for` définissant une variable de boucle, un intervalle et une expression `if` optionnelle. Toute cette expression 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

GIL

  Voir global interpreter lock.

verrou global de l’interpréteur

  (global interpreter lock en anglais) Mécanisme utilisé par l’interpréteur CPython pour s’assurer qu’un seul fil d’exécution (thread en anglais) n’exécute le 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é contre les accès concourants. Verrouiller l’interpréteur entier rend plus facile l’implémentation de multiples fils d’exécution (multi-thread en anglais), au détriment malheureusement de beaucoup du parallélisme possible sur les machines ayant plusieurs processeurs.

  Cependant, certains modules d’extension, standards ou non, sont conçus de manière à libérer le GIL lorsqu’ils effectuent des tâches lourdes tel que la compression ou le hachage. De la même manière, le GIL est toujours libéré lors des entrées / sorties.

  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 leurs mauvaises performances dans le cas d’un processeur unique. Il est admis que corriger ce problème de performance induit mènerait à une implémentation beaucoup plus compliquée et donc plus coûteuse à maintenir.

hachable

  An object is hashable if it has a hash value which never changes during its lifetime (it needs a `__hash__()` method), and can be compared to other objects (it needs an `__eq__()` or `__cmp__()` method). Hashable objects which compare equal must have the same hash value.

  La hachabilité permet à un objet d’être utilisé comme clé de dictionnaire ou en tant que membre d’un ensemble (type 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

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

immuable

  Objet dont la valeur ne change pas. Les nombres, les chaînes et les n-uplets 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 quand une valeur de hash constante est requise, typiquement en clé de dictionnaire.

integer division

  Mathematical division discarding any remainder. For example, the expression `11/4` currently evaluates to `2` in contrast to the `2.75` returned by float division. Also called floor division. When dividing two integers the outcome will always be another integer (having the floor function applied to it). However, if one of the operands is another numeric type (such as a `float`), the result will be coerced (see coercion) to a common type. For example, an integer divided by a float will result in a float value, possibly with a decimal fraction. Integer division can be forced by using the `//` operator instead of the `/` operator. See also __future__.

importer

  Processus rendant le code Python d’un module disponible dans un autre.

importateur

  Objet qui trouve et charge un module, en même temps un chercheur et un chargeur.

interactif

  Python a un interpréteur interactif, ce qui signifie que vous pouvez écrire des expressions et des instructions à l’invite de l’interpréteur. L’interpréteur Python va les exécuter immédiatement et vous en présenter le résultat. Démarrez juste `python` (probablement depuis le menu principal 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 en raison de la présence d’un compilateur en code intermédiaire. 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és ont généralement un cycle de développement / débogage plus court que les langages compilés. Cependant, ils s’exécutent généralement plus lentement. Voir aussi interactif.

itérable

  An object capable of returning its members one at a time. Examples of iterables include all sequence types (such as `list`, `str`, and `tuple`) and some non-sequence types like `dict` and `file` and objects of any classes you define with an `__iter__()` or `__getitem__()` method. Iterables can be used in a `for` loop and in many other places where a sequence is needed (`zip()`, `map()`, …). When an iterable object is passed as an argument to the built-in function `iter()`, it returns an iterator for the object. This iterator is good for one pass over the set of values. When using iterables, it is usually not necessary to call `iter()` or deal with iterator objects yourself. The `for` statement does that automatically for you, creating a temporary unnamed variable to hold the iterator for the duration of the loop. See also iterator, sequence, and generator.

itérateur

  An object representing a stream of data. Repeated calls to the iterator’s `next()` method return successive items in the stream. When no more data are available a `StopIteration` exception is raised instead. At this point, the iterator object is exhausted and any further calls to its `next()` method just raise `StopIteration` again. Iterators are required to have an `__iter__()` method that returns the iterator object itself so every iterator is also iterable and may be used in most places where other iterables are accepted. One notable exception is code which attempts multiple iteration passes. A container object (such as a `list`) produces a fresh new iterator each time you pass it to the `iter()` function or use it in a `for` loop. Attempting this with an iterator will just return the same exhausted iterator object used in the previous iteration pass, making it appear like an empty container.

  Vous trouverez davantage d’informations dans Les types itérateurs.

fonction clé

  Une fonction clé est un objet appelable qui renvoie une valeur à fins de tri ou de classement. Par exemple, la fonction `locale.strxfrm()` est utilisée pour générer une clé de classement prenant en compte les conventions de classement 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.nsmallest()`, `heapq.nlargest()`, et `itertools.groupby()`.

  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 au besoin 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

  An anonymous inline function consisting of a single expression which is evaluated when the function is called. The syntax to create a lambda function is `lambda [parameters]: expression`

LBYL

  Regarde devant avant de tomber, (Look before you leap en anglais). 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 avec plusieurs fils d’exécution (multi-threaded en anglais), le style LBYL peut engendrer un séquencement critique (race condition en anglais) entre le « regarde » et le « tomber ». Par exemple, le code `if key in mapping: return mapping[key]` peut échouer si un autre fil d’exécution supprime la clé 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

  A built-in Python sequence. Despite its name it is more akin to an array in other languages than to a linked list since access to elements is O(1).

liste en compréhension (ou liste en intension)

  A compact way to process all or part of the elements in a sequence and return a list with the results. `result = ["0x%02x" % x for x in range(256) if x % 2 == 0]` generates a list of strings containing even hex numbers (0x..) in the range from 0 to 255. The `if` clause is optional. If omitted, all elements in `range(256)` are processed.

chargeur

  An object that loads a module. It must define a method named `load_module()`. A loader is typically returned by a finder. See PEP 302 for details.

magic method

  An informal synonym for special method.

Tableau de correspondances

  Un conteneur permettant d’accéder à des éléments par clef et implémente les méthodes spécifiées dans `Mapping` ou `~collections.MutableMapping :ref:`classes de base abstraites`. Les classes suivantes sont des exemples de mapping: `dict`, `collections.defaultdict`, `collections.OrderedDict`, et `collections.Counter`.

métaclasse

  Classe d’une classe. Les définitions de classe créent un nom pour la classe, un dictionnaire de classe et une liste de classes parentes. 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. La particularité de Python est la possibilité de créer des métaclasses personnalisées. La plupart des utilisateurs n’aura jamais besoin de cet outil, mais lorsque le besoin survient, les métaclasses offrent des solutions élégantes et puissantes. Elles sont utilisées pour journaliser les accès à des propriétés, rendre sûr les environnements multi-threads, suivre la création d’objets, implémenter des singletons et bien d’autres tâches.

  Plus d’informations sont disponibles dans : Personnalisation de la création de classes.

méthode

  Fonction définie à l’intérieur d’une classe. Lorsqu’elle est appelée comme un attribut d’une instance de cette classe, la méthode reçoit l’instance en premier argument (qui, par convention, est habituellement nommé `self`). Voir function et nested scope.

ordre de résolution des méthodes

  L’ordre de résolution des méthodes (MRO pour Method Resolution Order en anglais) est, lors de la recherche d’un attribut dans les classes parentes, la façon dont l’interpréteur Python classe ces 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

  Objet utilisé pour organiser une portion unitaire de code en Python. Les modules ont un espace de noms et peuvent contenir n’importe quels objets Python. Charger des modules est appelé importer.

  Voir aussi paquet.

MRO

  Voir ordre de résolution des méthodes.

muable

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

n-uplet nommé

  (named-tuple en anglais) Classe qui, comme un n-uplet (tuple en anglais), a ses éléments accessibles par leur indice. Et en plus, les éléments sont accessibles par leur nom. Par exemple, `time.localtime()` donne un objet ressemblant à un n-uplet, dont year est accessible par son indice : `t[0]` ou par son nom : `t.tm_year`).

  Un n-uplet nommé peut être un type natif tel que `time.struct_time` ou il peut être construit comme une simple classe. Un n-uplet nommé 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 noms

  The place where a variable is stored. Namespaces are implemented as dictionaries. There are the local, global and built-in namespaces as well as nested namespaces in objects (in methods). Namespaces support modularity by preventing naming conflicts. For instance, the functions `__builtin__.open()` and `os.open()` are distinguished by their namespaces. Namespaces also aid readability and maintainability by making it clear which module implements a function. For instance, writing `random.seed()` or `itertools.izip()` makes it clear that those functions are implemented by the `random` and `itertools` modules, respectively.

portée imbriquée

  The ability to refer to a variable in an enclosing definition. For instance, a function defined inside another function can refer to variables in the outer function. Note that nested scopes work only for reference and not for assignment which will always write to the innermost scope. In contrast, local variables both read and write in the innermost scope. Likewise, global variables read and write to the global namespace.

nouvelle classe

  Any class which inherits from `object`. This includes all built-in types like `list` and `dict`. Only new-style classes can use Python’s newer, versatile features like `__slots__`, descriptors, properties, and `__getattribute__()`.

  More information can be found in New-style and classic classes.

objet

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

paquet

  module Python qui peut contenir des sous-modules ou des sous-paquets. Techniquement, un paquet est un module qui possède un attribut `__path__`.

paramètre

  A named entity in a function (or method) definition that specifies an argument (or in some cases, arguments) that the function can accept. There are four types of parameters:

  - positional-or-keyword: l’argument peut être passé soit par sa position, soit en tant que argument 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: l’argument ne peut être donné que par sa position. Python n’a pas de syntaxe pour déclarer de tels paramètres, cependant des fonctions natives, comme `abs()`, en utilisent.

  - var-positional: une séquence d’arguments positionnels peut être fournie (en plus de tous les arguments positionnels déjà acceptés par d’autres paramètres). Un tel paramètre peut être défini en préfixant son nom par une `*`. Par exemple args ci-après :

        def func(*args, **kwargs): ...

  - var-keyword: une quantité arbitraire d’arguments peut être passée, chacun étant nommé (en plus de tous les arguments nommés déjà acceptés par d’autres paramètres). Un tel paramètre est défini en préfixant le nom du paramètre par `**`. Par exemple, kwargs ci-dessus.

  Les paramètres peuvent spécifier des arguments obligatoires ou optionnels, ainsi que des valeurs par défaut pour les arguments optionnels.

  See also the argument glossary entry, the FAQ question on the difference between arguments and parameters, and the Définition de fonctions section.

PEP

  Python Enhancement Proposal. A PEP is a design document providing information to the Python community, or describing a new feature for Python or its processes or environment. PEPs should provide a concise technical specification and a rationale for proposed features.

  PEPs are intended to be the primary mechanisms for proposing major new features, for collecting community input on an issue, and for documenting the design decisions that have gone into Python. The PEP author is responsible for building consensus within the community and documenting dissenting opinions.

  See PEP 1.

argument positionnel

  Voir argument.

Python 3000

  Surnom donné à la série des Python 3.x (très vieux surnom donné à l’époque où Python 3 représentait un futur lointain). Aussi abrégé Py3k.

Pythonique

  Idée, ou bout de code, qui colle aux idiomes de Python plutôt qu’aux concepts communs rencontrés dans d’autres langages. Par exemple, il est idiomatique en Python de parcourir les éléments d’un itérable en utilisant `for`. Beaucoup d’autres langages n’ont pas cette possibilité, donc les gens qui ne sont pas habitués à Python utilisent parfois un compteur numérique à 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

nombre de références

  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 clé de l’implémentation CPython. Le module `sys` définit une fonction `getrefcount()` que les développeurs peuvent utiliser pour obtenir le nombre de références à un objet donné.

`__slots__`

  A declaration inside a new-style class that saves memory by pre-declaring space for instance attributes and eliminating instance dictionaries. Though popular, the technique is somewhat tricky to get right and is best reserved for rare cases where there are large numbers of instances in a memory-critical application.

séquence

  An iterable which supports efficient element access using integer indices via the `__getitem__()` special method and defines a `len()` method that returns the length of the sequence. Some built-in sequence types are `list`, `str`, `tuple`, and `unicode`. Note that `dict` also supports `__getitem__()` and `__len__()`, but is considered a mapping rather than a sequence because the lookups use arbitrary immutable keys rather than integers.

tranche

  An object usually containing a portion of a sequence. A slice is created using the subscript notation, `[]` with colons between numbers when several are given, such as in `variable_name[1:3:5]`. The bracket (subscript) notation uses `slice` objects internally (or in older versions, `__getslice__()` and `__setslice__()`).

méthode spéciale

  (special method en anglais) Méthode appelée implicitement par Python pour exécuter une opération sur un type, comme 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 Méthodes spéciales.

instruction

  Une instruction (statement en anglais) est un composant d’un « bloc » de code. Une instruction est soit une expression, soit une ou plusieurs constructions basées sur un mot-clé, comme `if`, `while` ou `for`.

struct sequence

  A tuple with named elements. Struct sequences expose an interface similiar to named tuple in that elements can be accessed either by index or as an attribute. However, they do not have any of the named tuple methods like `_make()` or `_asdict()`. Examples of struct sequences include `sys.float_info` and the return value of `os.stat()`.

chaîne entre triple guillemets

  Chaîne qui est délimitée par trois guillemets simples (`'`) ou trois guillemets doubles (`"`). Bien qu’elle ne fournisse aucune fonctionnalité qui ne soit pas disponible avec une chaîne entre guillemets, elle est utile pour de nombreuses raisons. Elle vous autorise à insérer des guillemets simples et doubles dans une chaîne sans avoir à les protéger et elle peut s’étendre sur plusieurs lignes sans avoir à terminer chaque ligne par un `\`. Elle est 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

  A manner of interpreting text streams in which all of the following are recognized as ending a line: the Unix end-of-line convention `'\n'`, the Windows convention `'\r\n'`, and the old Macintosh convention `'\r'`. See PEP 278 and PEP 3116, as well as `str.splitlines()` for an additional use.

environnement virtuel

  Environnement d’exécution isolé (en mode coopératif) 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

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

Le zen de Python

  Liste de principes et de préceptes utiles pour comprendre et utiliser le langage. Cette liste peut être obtenue en tapant « `import this` » dans une invite Python interactive.