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
   *statement*s 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.

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.
