Fonctions natives
*****************

L'interpréteur Python propose quelques fonctions et types natifs qui
sont toujours disponibles. Ils sont listés ici par ordre alphabétique.

+---------------------------+-------------------------+-------------------------+---------------------------+
| Fonctions natives                                                                                         |
|===========================|=========================|=========================|===========================|
| **A** "abs()" "aiter()"   | **E** "enumerate()"     | **L** "len()" "list()"  | **R** "range()" "repr()"  |
| "all()" "any()" "anext()" | "eval()" "exec()"       | "locals()"  **M**       | "reversed()" "round()"    |
| "ascii()"  **B** "bin()"  | **F** "filter()"        | "map()" "max()"         | **S** "set()" "setattr()" |
| "bool()" "breakpoint()"   | "float()" "format()"    | "memoryview()" "min()"  | "slice()" "sorted()"      |
| "bytearray()" "bytes()"   | "frozenset()"  **G**    | **N** "next()"  **O**   | "staticmethod()" "str()"  |
| *C** "callable()" "chr()" | "getattr()" "globals()" | "object()" "oct()"      | "sum()" "super()"  **T**  |
| "classmethod()"           | **H** "hasattr()"       | "open()" "ord()"  **P** | "tuple()" "type()"  **V** |
| "compile()" "complex()"   | "hash()" "help()"       | "pow()" "print()"       | "vars()"  **Z** "zip()"   |
| **D** "delattr()"         | "hex()"  **I** "id()"   | "property()"            | **_** "__import__()"      |
| "dict()" "dir()"          | "input()" "int()"       |                         |                           |
| "divmod()"                | "isinstance()"          |                         |                           |
|                           | "issubclass()" "iter()" |                         |                           |
+---------------------------+-------------------------+-------------------------+---------------------------+

abs(x)

   Renvoie la valeur absolue d'un nombre. L'argument peut être un
   nombre entier, un nombre à virgule flottante, ou tout objet
   définissant "__abs__()". Si l'argument est un nombre complexe, son
   module est renvoyé.

aiter(async_iterable)

   Renvoie un *itérateur asynchrone* pour l'*itérable asynchrone*
   donné. Équivaut à appeler "x.__aiter__()".

   Remarque : contrairement à "iter()", "aiter()" n'a pas de variante
   à 2 arguments.

   Nouveau dans la version 3.10.

all(iterable)

   Renvoie "True" si tous les éléments de *iterable* sont vrais (ou
   s'il est vide). Équivaut à :

      def all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

awaitable anext(async_iterator[, default])

   Lorsqu'il est attendu, renvoie l'élément suivant à partir de
   l'*itérateur asynchrone* donné, ou *default* s'il est fourni et que
   l'itérateur est épuisé.

   Il s'agit de la variante asynchrone de la fonction native "next()"
   et elle se comporte de la même manière.

   Renvoie un *attendable* en appelant la méthode "__anext__()" de
   *async_iterator*. L'attente renvoie la prochaine valeur de
   l'itérateur. Si *default* est fourni, il est renvoyé si l'itérateur
   est épuisé, sinon "StopAsyncIteration" est levée.

   Nouveau dans la version 3.10.

any(iterable)

   Renvoie "True" si au moins un élément de *iterable* est vrai.
   "False" est renvoyé dans le cas où *iterable* est vide. Équivaut à
   :

      def any(iterable):
          for element in iterable:
              if element:
                  return True
          return False

ascii(object)

   As "repr()", return a string containing a printable representation
   of an object, but escape the non-ASCII characters in the string
   returned by "repr()" using "\x", "\u", or "\U" escapes.  This
   generates a string similar to that returned by "repr()" in Python
   2.

bin(x)

   Convertit un nombre entier en binaire dans une chaîne avec le
   préfixe "0b". Le résultat est une expression Python valide. Si *x*
   n'est pas un "int", il doit définir une méthode "__index__()"
   donnant un nombre entier. Voici quelques exemples :

   >>> bin(3)
   '0b11'
   >>> bin(-10)
   '-0b1010'

   Vous pouvez contrôler l'affichage du préfixe ""0b"" à l'aide d'un
   des moyens suivants.

   >>> format(14, '#b'), format(14, 'b')
   ('0b1110', '1110')
   >>> f'{14:#b}', f'{14:b}'
   ('0b1110', '1110')

   Voir aussi "format()" pour plus d'informations.

class bool([x])

   Return a Boolean value, i.e. one of "True" or "False".  *x* is
   converted using the standard truth testing procedure.  If *x* is
   false or omitted, this returns "False"; otherwise, it returns
   "True".  The "bool" class is a subclass of "int" (see Types
   numériques — int, float, complex). It cannot be subclassed further.
   Its only instances are "False" and "True" (see Valeurs booléennes).

   Modifié dans la version 3.7: *x* est désormais un argument
   exclusivement optionnel.

breakpoint(*args, **kws)

   Cette fonction vous place dans le débogueur lorsqu'elle est
   appelée. Plus précisément, elle appelle "sys.breakpointhook()", en
   lui passant les arguments "args" et "kws". Par défaut,
   "sys.breakpointhook()" appelle "pdb.set_trace()" qui n'attend aucun
   argument. Dans ce cas, c'est purement une fonction de commodité
   donc vous n'avez pas à importer explicitement "pdb" ou à taper plus
   de code pour entrer dans le débogueur. Cependant, il est possible
   d'affecter une autre fonction à "sys.breakpointhook()", que
   "breakpoint()" appellera automatiquement, vous permettant ainsi de
   basculer dans le débogueur de votre choix. Si
   "sys.breakpointhook()" n'est pas accessible, cette fonction lève
   "RuntimeError".

   Lève un évènement d'audit "builtins.breakpoint" avec l'argument
   "breakpointhook".

   Nouveau dans la version 3.7.

class bytearray([source[, encoding[, errors]]])

   Renvoie un nouveau tableau d'octets. La classe "bytearray" est une
   séquence muable de nombres entiers dans l'intervalle 0 <= x < 256.
   Il possède la plupart des méthodes des séquences variables,
   décrites dans Types de séquences muables, ainsi que la plupart des
   méthodes de la classe "bytes", voir Opérations sur les bytes et
   bytearray.

   Le paramètre optionnel *source* peut être utilisé pour initialiser
   le tableau de plusieurs façons :

   * si c'est une *chaîne*, vous devez aussi donner le paramètre
     *encoding* pour l'encodage (et éventuellement *errors*). La
     fonction "bytearray()" convertit ensuite la chaîne en octets via
     la méthode "str.encode()" ;

   * si c'est un *entier*, le tableau a cette taille et est initialisé
     d'octets *null* ;

   * If it is an object conforming to the buffer interface, a read-
     only buffer of the object will be used to initialize the bytes
     array.

   * si c'est un *itérable*, il doit itérer sur des nombres entier
     dans l'intervalle "0 <= x < 256", qui sont utilisés pour
     initialiser le contenu du tableau.

   Sans argument, un tableau vide est créé.

   Voir Séquences Binaires --- bytes, bytearray, memoryview et Objets
   bytearray.

class bytes([source[, encoding[, errors]]])

   Renvoie un nouvel objet *bytes*, qui est une séquence immuable de
   nombres entiers dans l'intervalle "0 <= x < 256". Un "bytes" est
   une version immuable de "bytearray" — avec les mêmes méthodes
   d'accès, et le même comportement lors de l'indexation ou du
   découpage.

   En conséquence, les arguments du constructeur sont les mêmes que
   pour "bytearray()".

   Les objets *bytes* peuvent aussi être créés à partir de littéraux,
   voir Littéraux de chaînes de caractères et de suites d'octets.

   Voir aussi Séquences Binaires --- bytes, bytearray, memoryview,
   Objets bytes, et Opérations sur les bytes et bytearray.

callable(object)

   Renvoie "True" si l'argument *object* semble être appelable, sinon
   "False". Lorsqu'elle renvoie "True", il est toujours possible qu'un
   appel échoue. Cependant, lorsqu'elle renvoie "False", il n'est
   jamais possible d'appeler *object*. Notez qu'une classe est
   toujours appelable (appeler une classe donne une nouvelle instance)
   ; une instance n'est appelable que si sa classe définit une méthode
   "__call__()".

   Nouveau dans la version 3.2: cette fonction a d'abord été supprimée
   avec Python 3.0 puis elle a été remise dans Python 3.2.

chr(i)

   Renvoie la chaîne représentant un caractère dont le code de
   caractère Unicode est le nombre entier *i*. Par exemple, "chr(97)"
   renvoie la chaîne de caractères "'a'", tandis que "chr(8364)"
   renvoie "'€'". Il s'agit de l'inverse de "ord()".

   L'intervalle valide pour cet argument est de "0" à "1114111"
   ("0x10FFFF" en base 16). Une exception "ValueError" est levée si
   *i* est en dehors de l'intervalle.

@classmethod

   Transforme une méthode en méthode de classe.

   A class method receives the class as an implicit first argument,
   just like an instance method receives the instance. To declare a
   class method, use this idiom:

      class C:
          @classmethod
          def f(cls, arg1, arg2): ...

   La forme "@classmethod" est un *décorateur* de fonction — consultez
   Définition de fonctions pour plus de détails.

   Elle peut être appelée soit sur la classe (comme "C.f()") ou sur
   une instance (comme "C().f()"). L'instance est ignorée, sauf pour
   déterminer sa classe. Si la méthode est appelée sur une instance de
   classe fille, c'est la classe fille qui sera donnée en premier
   argument implicite.

   Les méthodes de classe sont différentes des méthodes statiques du
   C++ ou du Java. Si ce sont elles dont vous avez besoin, regardez du
   côté de "staticmethod()" dans cette section. Voir aussi Hiérarchie
   des types standards.

   Modifié dans la version 3.9: les méthodes de classe peuvent
   encapsuler d'autres *descripteurs* comme "property()".

   Modifié dans la version 3.10: les méthodes de classe peuvent
   maintenant hériter des attributs des méthodes ("__module__",
   "__name__", "__qualname__", "__doc__" et "__annotations__") et ont
   un nouvel attribut "__wrapped__".

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=- 1)

   Compile *source* en un objet code ou objet AST. Les objets code
   peuvent être exécutés par "exec()" ou "eval()". *source* peut être
   une chaîne, une chaîne d'octets, ou un objet AST. Consultez la
   documentation du module "ast" pour des informations sur la
   manipulation d'objets AST.

   L'argument *filename* doit désigner le fichier depuis lequel le
   code a été lu. Donnez quelque chose de reconnaissable lorsqu'il n'a
   pas été lu depuis un fichier (typiquement ""<string>"").

   L'argument *mode* indique quel type de code doit être compilé :
   "'exec'" si *source* est une suite d'instructions, "'eval'" pour
   une seule expression, ou "'single'" s'il ne contient qu'une
   instruction interactive (dans ce dernier cas, les résultats
   d'expressions donnant autre chose que "None" sont affichés).

   Les arguments optionnels *flags* et *dont_inherit* contrôlent
   quelles options de compilation seront activées et quelles
   instructions future seront autorisées. Si aucun des deux n'est
   présent (ou que les deux sont à 0), le code est compilé avec les
   mêmes paramètres que le code appelant "compile()". Si l'argument
   *flags* est fourni alors que *dont_inherit* ne l'est pas (ou vaut
   0), les options de compilation et les instructions *futures*
   utilisées sont celles définies par *flags* en plus de celles qui
   auraient été utilisées. Si *dont_inherit* est un entier différent
   de zéro, *flags* est utilisé tel quel — les *flags* (instructions
   futures et options de compilation) valables pour le code encadrant
   *compile* sont ignorés.

   Les instructions *future* sont contrôlées par des bits, il est
   ainsi possible d'en activer plusieurs en les combinant avec un *OU*
   binaire. Les bits requis pour demander une certaine fonctionnalité
   se trouvent dans l'attribut "compiler_flag" de la classe "Feature"
   du module "__future__". Les options du compilateur se trouvent dans
   le module "ast", avec le préfixe "PyCF_".

   L'argument *optimize* indique le niveau d'optimisation du
   compilateur. La valeur par défaut est "-1" qui prend le niveau
   d'optimisation de l'interpréteur tel que reçu via l'option "-O".
   Les niveaux explicites sont : "0" (pas d'optimisation, "__debug__"
   est "True"), "1" (les "assert" sont supprimés, "__debug__" est
   "False") ou "2" (les *docstrings* sont également supprimées).

   Cette fonction lève une "SyntaxError" si la source n'est pas
   valide, et "ValueError" si la source contient des octets *null*.

   Si vous voulez transformer du code Python en sa représentation AST,
   voyez "ast.parse()".

   Lève un évènement d'audit "compile" avec les arguments "source" et
   "filename". Cet événement peut également être levé par une
   compilation implicite.

   Note:

     Lors de la compilation d'une chaîne de plusieurs lignes de code
     avec les modes "'single'" ou "'eval'", celles-ci doivent être
     terminées par au moins un retour à la ligne. Cela permet de
     faciliter la distinction entre les instructions complètes et
     incomplètes dans le module "code".

   Avertissement:

     Il est possible de faire planter l'interpréteur Python avec des
     chaînes suffisamment grandes ou complexes lors de la compilation
     d'un objet AST. Ceci est dû à limitation de la profondeur de la
     pile d'appels.

   Modifié dans la version 3.2: Allowed use of Windows and Mac
   newlines.  Also, input in "'exec'" mode does not have to end in a
   newline anymore.  Added the *optimize* parameter.

   Modifié dans la version 3.5: précédemment, l'exception "TypeError"
   était levée quand un caractère nul était rencontré dans *source*.

   Nouveau dans la version 3.8: "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" peut
   maintenant être passée à *flags* pour permettre une gestion de
   "await", "async for", et "async with" de haut niveau.

class complex([real[, imag]])

   Renvoie un nombre complexe de valeur "real + imag*1j", ou convertit
   une chaîne ou un nombre en nombre complexe. Si le premier paramètre
   est une chaîne, il sera interprété comme un nombre complexe et la
   fonction doit être appelée sans second paramètre. Le second
   paramètre ne peut jamais être une chaîne. Chaque argument peut être
   de n'importe quel type numérique (même complexe). Si *imag* est
   omis, sa valeur par défaut est zéro, le constructeur effectue alors
   une simple conversion numérique comme le font "int" ou "float". Si
   aucun argument n'est fourni, renvoie "0j".

   Pour un objet Python général "x", "complex(x)" délègue à
   "x.__complex__()". Si "__complex__()" n'est pas défini, alors il
   délègue à "__float__()". Si "__float__()" n'est pas défini, alors
   il délègue à "__index__()".

   Note:

     Lors de la conversion depuis une chaîne, elle ne doit pas
     contenir d'espaces autour des opérateurs binaires "+" ou "-". Par
     exemple "complex('1+2j')" est correct, mais "complex('1 + 2j')"
     lève une "ValueError".

   Le type complexe est décrit dans Types numériques — int, float,
   complex.

   Modifié dans la version 3.6: les chiffres peuvent être groupés avec
   des tirets bas comme dans les expressions littérales.

   Modifié dans la version 3.8: revient à "__index__()" si
   "__complex__()" et "__float__()" ne sont pas définies.

delattr(object, name)

   C'est une cousine de "setattr()". Les arguments sont un objet et
   une chaîne. La chaîne doit être le nom de l'un des attributs de
   l'objet. La fonction supprime l'attribut nommé, si l'objet l'y
   autorise. Par exemple "delattr(x, 'foobar')" est l'équivalent de
   "del x.foobar". *name* n'a pas besoin d'être un identifiant Python
   (voir "setattr()").

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

   Créé un nouveau dictionnaire. L'objet "dict" est la classe du
   dictionnaire. Voir "dict" et Les types de correspondances — dict
   pour vous documenter sur cette classe.

   Pour les autres conteneurs, voir les classes natives "list", "set",
   et "tuple", ainsi que le module "collections".

dir([object])

   Sans argument, elle donne la liste des noms dans l'espace de
   nommage local. Avec un argument, elle essaye de donner une liste
   d'attributs valides pour cet objet.

   Si l'objet a une méthode "__dir__()", elle est appelée et doit
   donner une liste d'attributs. Cela permet aux objets implémentant
   "__getattr__()" ou "__getattribute__()" de personnaliser ce que
   donnera "dir()".

   Si l'objet ne fournit pas de méthode "__dir__()", la fonction fait
   de son mieux en rassemblant les informations de l'attribut
   "__dict__" de l'objet, s'il est défini, et depuis son type. La
   liste résultante n'est pas nécessairement complète, et peut être
   erronée quand l'objet a une "__getattr__()" personnalisée.

   Le mécanisme par défaut de "dir()" se comporte différemment avec
   différents types d'objets, car elle préfère donner une information
   pertinente plutôt qu'exhaustive :

   * si l'objet est un module, la liste contiendra les noms des
     attributs du module ;

   * si l'objet est un type ou une classe, la liste contiendra les
     noms de ses attributs et, récursivement, des attributs de ses
     parents ;

   * autrement, la liste contient les noms des attributs de l'objet,
     le nom des attributs de la classe, et récursivement des attributs
     des parents de la classe.

   La liste donnée est triée par ordre alphabétique, par exemple :

   >>> import struct
   >>> dir()   # show the names in the module namespace  
   ['__builtins__', '__name__', 'struct']
   >>> dir(struct)   # show the names in the struct module 
   ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
    '__initializing__', '__loader__', '__name__', '__package__',
    '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
    'unpack', 'unpack_from']
   >>> class Shape:
   ...     def __dir__(self):
   ...         return ['area', 'perimeter', 'location']
   >>> s = Shape()
   >>> dir(s)
   ['area', 'location', 'perimeter']

   Note:

     Étant donné que "dir()" est d'abord fournie pour son côté
     pratique en mode interactif, elle a tendance à fournir un
     ensemble de noms pertinents plutôt qu'un ensemble exhaustif et
     rigoureusement défini, son comportement peut aussi changer d'une
     version à l'autre. Par exemple, les attributs de méta-classes ne
     sont pas donnés lorsque l'argument est une classe.

divmod(a, b)

   Prend deux nombres (qui ne sont pas des nombres complexes) et
   renvoie leur quotient et reste de leur division entière sous forme
   d'une paire de nombres. Avec des opérandes de types différents, les
   règles des opérateurs binaires s'appliquent. Pour deux entiers le
   résultat est le même que "(a // b, a % b)". Pour des nombres à
   virgule flottante le résultat est "(q, a % b)", où *q* est
   généralement "math.floor(a / b)" mais peut valoir 1 de moins. Dans
   tous les cas "q * b + a % b" est très proche de *a*. Si "a % b" est
   différent de zéro, il a le même signe que *b* et "0 <= abs(a % b) <
   abs(b)".

enumerate(iterable, start=0)

   Renvoie un objet énumérant. *iterable* doit être une séquence, un
   *itérateur*, ou tout autre objet prenant en charge l'itération. La
   méthode "__next__()" de l'itérateur donné par "enumerate()" renvoie
   un *n*-uplet contenant un compte (démarrant à *start*, 0 par
   défaut) et les valeurs obtenues de l'itération sur *iterable*.

   >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
   >>> list(enumerate(seasons))
   [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
   >>> list(enumerate(seasons, start=1))
   [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

   Équivalent à :

      def enumerate(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

eval(expression[, globals[, locals]])

   Les arguments sont : une chaîne, et optionnellement des locales et
   des globales. S'il est fourni, *globals* doit être un dictionnaire.
   S'il est fourni, *locals* peut être n'importe quel objet *mapping*.

   L'argument *expression* est analysé et évalué comme une expression
   Python (techniquement, une *condition list*) en utilisant les
   dictionnaires *globals* et *locals* comme espaces de nommage global
   et local. Si le dictionnaire *globals* est présent mais ne contient
   pas de valeur pour la clé "__builtins__", une référence au
   dictionnaire du module "builtins" y est insérée avant
   qu'*expression* ne soit évaluée. Ainsi, vous pouvez contrôler quels
   objets natifs sont disponibles pour le code à exécuter en insérant
   votre propre dictionnaire "__builtins__" dans *globals* avant de le
   passer à "eval()". Si le dictionnaire *locals* est omis, sa valeur
   par défaut est le dictionnaire *globals*. Si les deux dictionnaires
   sont omis, l'expression est exécutée avec les dictionnaires
   *globals* et *locals* dans l'environnement où "eval()" est appelée.
   Notez que *eval()* n'a pas accès aux *portées imbriquées* (non
   locales) dans l'environnement englobant.

   La valeur de retour est le résultat de l'expression évaluée. Les
   erreurs de syntaxe sont signalées comme des exceptions. Exemple :

   >>> x = 1
   >>> eval('x+1')
   2

   Cette fonction peut aussi être utilisée pour exécuter n'importe
   quel objet code (tels que ceux créés par "compile()"). Dans ce cas,
   donnez un objet code plutôt qu'une chaîne. Si l'objet code a été
   compilé avec l'argument *mode* à "'exec'", "eval()" renvoie "None".

   Hints: dynamic execution of statements is supported by the "exec()"
   function.  The "globals()" and "locals()" functions return the
   current global and local dictionary, respectively, which may be
   useful to pass around for use by "eval()" or "exec()".

   Si la source donnée est une chaîne, les espaces de début et de fin
   et les tabulations sont supprimées.

   Utilisez "ast.literal_eval()" si vous avez besoin d'une fonction
   qui peut évaluer en toute sécurité des chaînes avec des expressions
   ne contenant que des valeurs littérales.

   Lève un évènement d'audit "exec" avec l'objet de code comme
   argument. Les événements de compilation de code peuvent également
   être levés.

exec(object[, globals[, locals]])

   Cette fonction permet l'exécution dynamique de code Python.
   *object* doit être soit une chaîne soit un objet code. Si c'est une
   chaîne, elle est d'abord analysée en une suite d'instructions
   Python qui sont ensuite exécutés (sauf erreur de syntaxe). [1] Si
   c'est un objet code, il est simplement exécuté. Dans tous les cas,
   le code fourni doit être valide selon les mêmes critères que s'il
   était un script dans un fichier (voir la section Fichier d'entrée
   dans le manuel de référence du langage). Gardez en tête que les
   mots clés "nonlocal", "yield" et "return" ne peuvent pas être
   utilisés en dehors d'une fonction, même dans du code passé à
   "exec()". La fonction renvoie "None".

   Dans tous les cas, si les arguments optionnels sont omis, le code
   est exécuté dans le contexte actuel. Si seul *globals* est fourni,
   il doit être un dictionnaire (et pas une sous-classe de
   dictionnaire) utilisé pour les variables globales et locales. Si
   les deux sont fournis, ils sont utilisés respectivement pour les
   variables globales et locales. *locales* peut être n'importe quel
   objet de correspondance. Souvenez-vous qu'au niveau d'un module,
   les dictionnaires des locales et des globales ne sont qu'un. Si
   "exec" reçoit deux objets distincts dans *globals* et *locals*, le
   code est exécuté comme s'il était inclus dans une définition de
   classe.

   Si le dictionnaire *globals* ne contient pas de valeur pour la clé
   "__builtins__", une référence au dictionnaire du module "builtins"
   y est inséré. Cela vous permet de contrôler quelles fonctions
   natives sont exposées au code exécuté en insérant votre propre
   dictionnaire "__builtins__" dans *globals* avant de le donner à
   "exec()".

   Lève un évènement d'audit "exec" avec l'objet de code comme
   argument. Les événements de compilation de code peuvent également
   être levés.

   Note:

     Les fonctions natives "globals()" et "locals()" renvoient
     respectivement les dictionnaires globaux et locaux, qui peuvent
     être utiles en deuxième et troisième argument de "exec()".

   Note:

     La valeur par défaut pour *locals* se comporte comme la fonction
     "locals()" : il est déconseillé de modifier le dictionnaire
     *locals* par défaut. Donnez un dictionnaire explicitement à
     *locals* si vous désirez observer l'effet du code sur les
     variables locales, après que "exec()" soit terminée.

filter(function, iterable)

   Construit un itérateur depuis les éléments d'*iterable* pour
   lesquels *function* renvoie "True". *iterable* peut aussi bien être
   une séquence, un conteneur qui prend en charge l'itération, ou un
   itérateur. Si *function* est "None", la fonction identité est
   prise, c'est-à-dire que tous les éléments faux d'*iterable* sont
   supprimés.

   Notez que "filter(function, iterable)" est l'équivalent du
   générateur "(item for item in iterable if function(item))" si
   *function* n'est pas "None", et de "(item for item in iterable if
   item)" si *function* est "None".

   Voir "itertools.filterfalse()" pour la fonction complémentaire qui
   donne les éléments d'*iterable* pour lesquels *function* renvoie
   "False".

class float([x])

   Renvoie un nombre a virgule flottante depuis un nombre ou une
   chaîne *x*.

   Si l'argument est une chaîne, elle doit contenir un nombre décimal,
   éventuellement précédé d'un signe, et pouvant être entouré
   d'espaces. Le signe optionnel peut être "'+'" ou "'-'". Un signe
   "'+'" n'a pas d'effet sur la valeur produite. L'argument peut aussi
   être une chaîne représentant un *NaN* (*Not-a-Number* ou *pas un
   nombre* en français), l'infini positif, ou l'infini négatif. Plus
   précisément, l'argument doit se conformer à "floatvalue" tel que
   défini la grammaire suivante, après que les espaces en début et fin
   de chaîne aient été retirées :

      sign        ::= "+" | "-"
      infinity    ::= "Infinity" | "inf"
      nan         ::= "nan"
      digitpart   ::= digit (["_"] digit)*
      number      ::= [digitpart] "." digitpart | digitpart ["."]
      exponent    ::= ("e" | "E") ["+" | "-"] digitpart
      floatnumber ::= number [exponent]
      floatvalue  ::= [sign] (floatnumber | infinity | nan)

   Ici "digit" est un chiffre décimal Unicode (caractère de la
   catégorie générale Unicode "Nd"). La casse n'y est pas
   significative, donc, par exemple, ""inf"", "" Inf"", ""INFINITY""
   et "" iNfiNity"" sont tous des orthographes valides pour un infini
   positif.

   Autrement, si l'argument est un entier ou un nombre à virgule
   flottante, un nombre à virgule flottante de même valeur (en accord
   avec la précision des nombres à virgule flottante de Python) est
   donné. Si l'argument est en dehors de l'intervalle d'un nombre a
   virgule flottante pour Python, "OverflowError" est levée.

   Pour un objet Python général "x", "float(x)" est délégué à
   "x.__float__()". Si "__float__()" n'est pas défini alors il est
   délégué à "__index__()".

   Sans argument, "0.0" est renvoyé.

   Exemples :

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

   Le type *float* est décrit dans Types numériques — int, float,
   complex.

   Modifié dans la version 3.6: les chiffres peuvent être groupés avec
   des tirets bas comme dans les expressions littérales.

   Modifié dans la version 3.7: *x* est désormais un argument
   exclusivement optionnel.

   Modifié dans la version 3.8: revient à "__index__()" si
   "__float__()" n'est pas définie.

format(value[, format_spec])

   Convertit une valeur en sa représentation « formatée », contrôlée
   par *format_spec*. L'interprétation de *format_spec* dépend du type
   de la valeur. Cependant, il existe une syntaxe standard utilisée
   par la plupart des types natifs : Mini-langage de spécification de
   format.

   Par défaut, *format_spec* est une chaîne vide. Dans ce cas, appeler
   cette fonction a généralement le même effet qu'appeler
   "str(value)".

   Un appel à "format(value, format_spec)" est transformé en
   "type(value).__format__(value, format_spec)", qui contourne le
   dictionnaire de l'instance lors de la recherche de la méthode
   "__fornat__()". Une exception "TypeError" est levée si la recherche
   de la méthode atteint "object" et que *format_spec* n'est pas vide,
   ou si *format_spec* ou le résultat ne sont pas des chaînes de
   caractères.

   Modifié dans la version 3.4: "object().__format__(format_spec)"
   lève "TypeError" si *format_spec* n'est pas une chaîne vide.

class frozenset([iterable])

   Renvoie un nouveau "frozenset", dont les objets sont éventuellement
   tirés d'*iterable*. "frozenset" est une classe native. Voir
   "frozenset" et Types d'ensembles — set, frozenset pour la
   documentation sur cette classe.

   Pour d'autres conteneurs, voyez les classes natives "set", "list",
   "tuple", et "dict", ainsi que le module "collections".

getattr(object, name[, default])

   Renvoie la valeur de l'attribut nommé *name* de l'objet *object*.
   *name* doit être une chaîne. Si la chaîne est le nom d'un des
   attributs de l'objet, le résultat est la valeur de cet attribut.
   Par exemple, "getattr(x, 'foobar')" est équivalent à "x.foobar". Si
   l'attribut n'existe pas, mais que *default* est fourni, celui-ci
   est renvoyé. Sinon l'exception "AttributeError" est levée. *name*
   n'a pas besoin d'être un identifiant Python (voir "setattr()").

   Note:

     étant donné que la transformation des noms privés se produit au
     moment de la compilation, il faut modifier manuellement le nom
     d'un attribut privé (attributs avec deux traits de soulignement
     en tête) afin de le récupérer avec "getattr()".

globals()

   Renvoie le dictionnaire implémentant l'espace de nommage du module
   actuel. Pour le code dans les fonctions, il est défini lorsque la
   fonction est définie et reste le même quel que soit le moment où la
   fonction est appelée.

hasattr(object, name)

   Les arguments sont : un objet et une chaîne de caractères. Le
   résultat est "True" si la chaîne est le nom d'un des attributs de
   l'objet, sinon "False" (l'implémentation appelle "getattr(object,
   name)" et regarde si une exception "AttributeError" a été levée).

hash(object)

   Renvoie la valeur de hachage d'un objet (s'il en a une). Les
   valeurs de hachage sont des entiers. Elles sont utilisées pour
   comparer rapidement des clés de dictionnaire lors de leur
   recherche. Les valeurs numériques égales ont la même valeur de
   hachage (même si leurs types sont différents, comme pour "1" et
   "1.0").

   Note:

     Pour les objets dont la méthode "__hash__()" est implémentée,
     notez que "hash()" tronque la valeur donnée en fonction du nombre
     de bits de la machine hôte. Voir "__hash__()" pour plus
     d'information.

help([object])

   Invoque le système d'aide natif (cette fonction est destinée à
   l'usage en mode interactif). Si aucun argument n'est fourni, le
   système d'aide démarre dans l'interpréteur. Si l'argument est une
   chaîne, celle-ci est recherchée comme le nom d'un module, d'une
   fonction, d'une classe, d'une méthode, d'un mot clé, ou d'un sujet
   de documentation, et une page d'aide est affichée sur la console.
   Si l'argument est d'un autre type, une page d'aide sur cet objet
   est générée.

   Note that if a slash(/) appears in the parameter list of a function
   when invoking "help()", it means that the parameters prior to the
   slash are positional-only. For more info, see the FAQ entry on
   positional-only parameters.

   Cette fonction est ajoutée à l'espace de nommage natif par le
   module "site".

   Modifié dans la version 3.4: les changements aux modules "pydoc" et
   "inspect" rendent les signatures des appelables plus
   compréhensibles et cohérentes.

hex(x)

   Convertit un entier en chaîne hexadécimale préfixée de "0x". Si *x*
   n'est pas un "int", il doit définir une méthode "__index__()" qui
   renvoie un entier. Quelques exemples :

   >>> hex(255)
   '0xff'
   >>> hex(-42)
   '-0x2a'

   Si vous voulez convertir un nombre entier en chaîne hexadécimale,
   en majuscule ou non, préfixée ou non, vous pouvez utiliser l'une
   des méthodes suivantes :

   >>> '%#x' % 255, '%x' % 255, '%X' % 255
   ('0xff', 'ff', 'FF')
   >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
   ('0xff', 'ff', 'FF')
   >>> f'{255:#x}', f'{255:x}', f'{255:X}'
   ('0xff', 'ff', 'FF')

   Voir aussi "format()" pour plus d'informations.

   Voir aussi "int()" pour convertir une chaîne hexadécimale en un
   entier (en affectant 16 à l'argument *base*).

   Note:

     Pour obtenir une représentation hexadécimale sous forme de chaîne
     d'un nombre à virgule flottante, utilisez la méthode
     "float.hex()".

id(object)

   Renvoie l'« identité » d'un objet. C'est un nombre entier garanti
   unique et constant pour cet objet durant sa durée de vie. Deux
   objets dont les durées de vie ne se chevauchent pas peuvent
   partager le même "id()".

   **Particularité de l'implémentation CPython :** c'est l'adresse de
   l'objet en mémoire.

   Raises an auditing event "builtins.id" with argument "id".

input([prompt])

   Si l'argument *prompt* est donné, il est écrit sur la sortie
   standard sans le retour à la ligne final. La fonction lit ensuite
   une ligne sur l'entrée standard et la convertit en chaîne
   (supprimant le retour à la ligne final) quelle renvoie. Lorsque EOF
   est lu, "EOFError" est levée. Exemple :

      >>> s = input('--> ')  
      --> Monty Python's Flying Circus
      >>> s  
      "Monty Python's Flying Circus"

   Si le module "readline" est chargé, "input()" l'utilisera pour
   fournir des fonctionnalités d'édition et d'historique élaborées.

   Lève un évènement d'audit "builtins.input" avec l'argument
   "prompt".

   Lève un évènement d'audit "builtins.input/result" avec l'argument
   "result".

class int([x])
class int(x, base=10)

   Renvoie un entier construit depuis un nombre ou une chaîne *x*, ou
   "0" si aucun argument n'est fourni. Si *x* définit une méthode
   "__int__()", "int(x)" renvoie "x.__int__()". Si *x* définit
   "__index__()", "int(x)" renvoie "x.__index__()" Si *x* définit
   "__trunc__()", "int(x)" renvoie "x.__trunc__()". Les nombres à
   virgule flottante sont tronqués vers zéro.

   If *x* is not a number or if *base* is given, then *x* must be a
   string, "bytes", or "bytearray" instance representing an integer in
   radix *base*.  Optionally, the string can be preceded by "+" or "-"
   (with no space in between), have leading zeros, be surrounded by
   whitespace, and have single underscores interspersed between
   digits.

   Une chaine représentant un entier en base *n* contient des
   chiffres, chacun représentant une valeur de 0 à n-1. Les valeurs 0
   à 9 peuvent être représentées par n'importe lequel des chiffres
   décimaux Unicode. Les valeurs de 10 à 35 peuvent être représentées
   par "a" jusqu'à "z" (ou "A" à "Z"). La *base* par défaut est 10.
   Les valeurs autorisées pour *base* sont 0 et 2 à 36. Les littéraux
   en base 2, 8, et 16 peuvent être préfixés avec "0b"/"0B",
   "0o"/"0O", ou "0x"/"0X" tout comme les littéraux dans le code.
   Fournir 0 comme *base* demande d'interpréter exactement comme un
   entier littéral dans du code Python, donc la base sera 2, 8, 10, ou
   16 en fonction du préfixe. Indiquer 0 comme base interdit les zéros
   en tête, ainsi "int('010', 0)" n'est pas légal, alors que
   "int('010')" l'est tout comme "int('010', 8)".

   Le type des entiers est décrit dans Types numériques — int, float,
   complex.

   Modifié dans la version 3.4: si *base* n'est pas une instance
   d'"int" et que *base* a une méthode "base.__index__", cette méthode
   est appelée pour obtenir un entier pour cette base. Les versions
   précédentes utilisaient "base.__int__" au lieu de "base.__index__".

   Modifié dans la version 3.6: les chiffres peuvent être groupés avec
   des tirets bas comme dans les expressions littérales.

   Modifié dans la version 3.7: *x* est désormais un argument
   exclusivement optionnel.

   Modifié dans la version 3.8: Revient à "__index__()" si "__int__()"
   n'est pas définie.

   Modifié dans la version 3.10.7: "int" string inputs and string
   representations can be limited to help avoid denial of service
   attacks. A "ValueError" is raised when the limit is exceeded while
   converting a string *x* to an "int" or when converting an "int"
   into a string would exceed the limit. See the integer string
   conversion length limitation documentation.

isinstance(object, classinfo)

   Return "True" if the *object* argument is an instance of the
   *classinfo* argument, or of a (direct, indirect, or *virtual*)
   subclass thereof.  If *object* is not an object of the given type,
   the function always returns "False". If *classinfo* is a tuple of
   type objects (or recursively, other such tuples) or a Union Type of
   multiple types, return "True" if *object* is an instance of any of
   the types. If *classinfo* is not a type or tuple of types and such
   tuples, a "TypeError" exception is raised.

   Modifié dans la version 3.10: *classinfo* can be a Union Type.

issubclass(class, classinfo)

   Return "True" if *class* is a subclass (direct, indirect, or
   *virtual*) of *classinfo*.  A class is considered a subclass of
   itself. *classinfo* may be a tuple of class objects (or
   recursively, other such tuples) or a Union Type, in which case
   return "True" if *class* is a subclass of any entry in *classinfo*.
   In any other case, a "TypeError" exception is raised.

   Modifié dans la version 3.10: *classinfo* can be a Union Type.

iter(object[, sentinel])

   Return an *iterator* object.  The first argument is interpreted
   very differently depending on the presence of the second argument.
   Without a second argument, *object* must be a collection object
   which supports the *iterable* protocol (the "__iter__()" method),
   or it must support the sequence protocol (the "__getitem__()"
   method with integer arguments starting at "0").  If it does not
   support either of those protocols, "TypeError" is raised. If the
   second argument, *sentinel*, is given, then *object* must be a
   callable object.  The iterator created in this case will call
   *object* with no arguments for each call to its "__next__()"
   method; if the value returned is equal to *sentinel*,
   "StopIteration" will be raised, otherwise the value will be
   returned.

   Voir aussi Les types itérateurs.

   Une autre application utile de la deuxième forme de "iter()" est de
   construire un lecteur par blocs. Par exemple, lire des blocs de
   taille fixe d'une base de donnée binaire jusqu'à ce que la fin soit
   atteinte :

      from functools import partial
      with open('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

len(s)

   Renvoie la longueur (nombre d'éléments) d'un objet. L'argument peut
   être une séquence (telle qu'une chaîne de caractères ou d'octets,
   un *n*-uplet, une liste ou un intervalle) ou une collection (telle
   qu'un dictionnaire, un ensemble ou un ensemble figé).

   **Particularité de l'implémentation CPython :** "len" raises
   "OverflowError" on lengths larger than "sys.maxsize", such as
   "range(2 ** 100)".

class list([iterable])

   Contrairement aux apparences, "list" n'est pas une fonction mais un
   type séquentiel muable, comme décrit dans Listes et Types
   séquentiels — list, tuple, range.

locals()

   Met à jour et renvoie un dictionnaire représentant la table des
   symboles locaux. Les variables libres sont renvoyées par la
   fonction "locals()" lorsque celle-ci est appelée dans le corps
   d'une fonction, mais pas dans le corps d'une classe. Notez qu’au
   niveau d’un module, "locals()" et "globals()" sont le même
   dictionnaire.

   Note:

     Le contenu de ce dictionnaire ne doit pas être modifié ; les
     changements n'affectent pas les valeurs des variables locales ou
     libres utilisées par l'interpréteur.

map(function, iterable, ...)

   Renvoie un itérateur appliquant *function* à chaque élément de
   *iterable*, et donnant ses résultats au fur et à mesure avec
   "yield". Si d'autres *iterable* sont fournis, *function* doit
   prendre autant d'arguments, et sera appelée avec les éléments de
   tous les itérables en parallèle. Avec plusieurs itérables,
   l'itération s'arrête avec l'itérable le plus court. Pour les cas où
   les arguments sont déjà rangés sous forme de *n*-uplets, voir
   "itertools.starmap()".

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

   Renvoie le plus grand élément d'un itérable, ou l'argument le plus
   grand parmi au moins deux arguments.

   Si un seul argument positionnel est fourni, il doit être
   *itérable*. Le plus grand élément de l'itérable est renvoyé. Si au
   moins deux arguments positionnels sont fournis, l'argument le plus
   grand sera renvoyé.

   Elle accepte deux arguments nommés optionnels. L'argument *key*
   spécifie une fonction à un argument permettant de trier comme pour
   "list.sort()". L'argument *default* fournit quant à lui un objet à
   donner si l'itérable fourni est vide. Si l'itérable est vide et que
   *default* n'est pas fourni, "ValueError" est levée.

   Si plusieurs éléments représentent la plus grande valeur, le
   premier rencontré est renvoyé. C'est cohérent avec d'autres outils
   préservant une stabilité lors du tri, tels que "sorted(iterable,
   key=keyfunc, reverse=True)[0]" et "heapq.nlargest(1, iterable,
   key=keyfunc)".

   Nouveau dans la version 3.4: L'argument nommé (et seulement donné
   par son nom) *default*.

   Modifié dans la version 3.8: l'argument *key* peut être "None".

class memoryview(object)

   Renvoie une « vue mémoire » (*memory view*) créée depuis
   l'argument. Voir Vues de mémoires pour plus d'informations.

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

   Renvoie le plus petit élément d'un itérable ou le plus petit d'au
   moins deux arguments.

   Si un seul argument est fourni, il doit être *itérable*. Le plus
   petit élément de l'itérable est renvoyé. Si au moins deux arguments
   positionnels sont fournis, le plus petit argument positionnel est
   renvoyé.

   Elle accepte deux arguments nommés optionnels. L'argument *key*
   spécifie une fonction à un argument permettant de trier comme pour
   "list.sort()". L'argument *default* fournit quant à lui un objet à
   donner si l'itérable fourni est vide. Si l'itérable est vide et que
   *default* n'est pas fourni, "ValueError" est levée.

   Si plusieurs éléments sont minimaux, la fonction renvoie le premier
   rencontré. C'est cohérent avec d'autres outils préservant une
   stabilité lors du tri, tels que "sorted(iterable, key=keyfunc)[0]"
   et "heapq.nsmallest(1, iterable, key=keyfunc)".

   Nouveau dans la version 3.4: L'argument nommé (et seulement donné
   par son nom) *default*.

   Modifié dans la version 3.8: l'argument *key* peut être "None".

next(iterator[, default])

   Retrieve the next item from the *iterator* by calling its
   "__next__()" method.  If *default* is given, it is returned if the
   iterator is exhausted, otherwise "StopIteration" is raised.

class object

   Return a new featureless object.  "object" is a base for all
   classes. It has methods that are common to all instances of Python
   classes.  This function does not accept any arguments.

   Note:

     "object" n'a *pas* d'attribut "__dict__", vous ne pouvez donc pas
     assigner d'attributs arbitraires à une instance d'"object".

oct(x)

   Convertit un entier en sa représentation octale dans une chaîne
   préfixée de "0o". Le résultat est une expression Python valide. Si
   *x* n'est pas un objet "int", il doit définir une méthode
   "__index__()" qui donne un entier, par exemple :

   >>> oct(8)
   '0o10'
   >>> oct(-56)
   '-0o70'

   If you want to convert an integer number to an octal string either
   with the prefix "0o" or not, you can use either of the following
   ways.

   >>> '%#o' % 10, '%o' % 10
   ('0o12', '12')
   >>> format(10, '#o'), format(10, 'o')
   ('0o12', '12')
   >>> f'{10:#o}', f'{10:o}'
   ('0o12', '12')

   Voir aussi "format()" pour plus d'informations.

open(file, mode='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

   Ouvre *file* et donne un *objet fichier* correspondant. Si le
   fichier ne peut pas être ouvert, une "OSError" est levée. Voir
   Lecture et écriture de fichiers pour plus d'exemple d'utilisation
   de cette fonction.

   *file* est un *objet simili-chemin* donnant le chemin (absolu ou
   relatif au répertoire courant) du fichier à ouvrir ou un nombre
   entier représentant le descripteur de fichier à envelopper (si un
   descripteur de fichier est donné, il sera fermé en même temps que
   l'objet d'entrée-sortie renvoyé, sauf si *closefd* est mis à
   "False").

   *mode* est une chaîne optionnelle permettant de spécifier dans quel
   mode le fichier est ouvert. Par défaut, *mode* vaut "'r'" qui
   signifie « ouvrir en lecture pour du texte ». "'w'" est aussi une
   valeur classique, permettant d'écrire (en effaçant le contenu du
   fichier s'il existe), ainsi que "'x'" permettant une création
   exclusive et "'a'" pour ajouter à la fin du fichier (ce qui, sur
   certains systèmes Unix, signifie que *toutes* les écritures seront
   des ajouts en fin de fichier, sans tenir compte de la position
   demandée). En mode texte, si *encoding* n'est pas spécifié,
   l'encodage utilisé dépend de la plate-forme :
   "locale.getpreferredencoding(False)" est appelée pour obtenir
   l'encodage défini par les paramètres régionaux (pour lire et écrire
   des octets bruts, utilisez le mode binaire sans préciser *encoding*
   non spécifié). Les modes disponibles sont :

   +-----------+-----------------------------------------------------------------+
   | Caractère | Signification                                                   |
   |===========|=================================================================|
   | "'r'"     | ouvre en lecture (par défaut)                                   |
   +-----------+-----------------------------------------------------------------+
   | "'w'"     | ouvre en écriture, en effaçant le contenu du fichier            |
   +-----------+-----------------------------------------------------------------+
   | "'x'"     | ouvre pour une création exclusive, échouant si le fichier       |
   |           | existe déjà                                                     |
   +-----------+-----------------------------------------------------------------+
   | "'a'"     | ouvre en écriture, ajoutant à la fin du fichier s'il existe     |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | mode binaire                                                    |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | mode texte (par défaut)                                         |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | ouvre en modification (lecture et écriture)                     |
   +-----------+-----------------------------------------------------------------+

   Le mode par défaut est "'r'" (ouverture pour lire du texte,
   synonyme de "'rt'"). Les modes "'w+'" et "'w+b'" ouvrent et vident
   le fichier. Les modes "'r+'" et "'r+b'" ouvrent le fichier sans le
   vider.

   Comme mentionné dans Aperçu, Python fait la différence entre les
   entrées-sorties binaires et textes. Les fichiers ouverts en mode
   binaire (avec "'b'" dans *mode*) donnent leur contenu sous forme de
   "bytes" sans décodage. En mode texte (par défaut, ou lorsque "'t'"
   est dans le *mode*), le contenu du fichier est donné sous forme de
   "str", les octets ayant été décodés au préalable en utilisant un
   encodage déduit de l'environnement ou *encoding* s'il est donné.

   Il y a un mode « caractères » supplémentaire autorisé, "’U’", qui
   n'a plus d'effet, et est considéré comme obsolète. Auparavant, il
   activait les *retours à la ligne universels* en mode texte, qui est
   devenu le comportement par défaut dans Python 3.0. Référez-vous à
   la documentation du paramètre newline pour plus de détails.

   Note:

     Python ne dépend pas de la représentation du fichier texte du
     système sous-jacent. Tout le traitement est effectué par Python
     lui-même, et est ainsi indépendant de la plate-forme.

   *buffering* est un entier optionnel permettant de configurer
   l’espace tampon. 0 pour désactiver l’espace tampon (seulement
   autorisé en mode binaire), 1 pour avoir un *buffer* travaillant
   ligne par ligne (seulement disponible en mode texte), ou un entier
   supérieur à 1 pour donner la taille en octets d’un tampon de taille
   fixe. Notez que spécifier une taille de tampon de cette manière
   s'applique aux E/S binaires, mais que "TextIOWrapper" (c'est-à-dire
   les fichiers ouverts avec "mode='r+'") aurait un autre tampon. Pour
   désactiver la mise en mémoire tampon dans "TextIOWrapper",
   envisagez d'utiliser le drapeau "write_through" pour
   "io.TextIOWrapper.reconfigure()".Sans l’argument *buffering*, les
   comportements par défaut sont les suivants :

   * Les fichiers binaires sont mis dans un tampon de taille fixe,
     dont la taille est choisie par une heuristique essayant de
     déterminer la taille des blocs du système sous-jacent, ou en
     utilisant par défaut "io.DEFAULT_BUFFER_SIZE". Sur de nombreux
     systèmes, le tampon sera de 4096 ou 8192 octets.

   * Les fichiers texte « interactifs » (fichiers pour lesquels
     "io.IOBase.isatty()" renvoie "True") utilisent un tampon par
     lignes. Les autres fichiers texte sont traités comme les fichiers
     binaires.

   *encoding* est le nom de l'encodage utilisé pour encoder ou décoder
   le fichier. Il doit seulement être utilisé en mode texte.
   L'encodage par défaut dépend de la plateforme (ce que
   "locale.getpreferredencoding()" donne), mais n'importe quel
   *encodage de texte* pris en charge par Python peut être utilisé.
   Voir "codecs" pour une liste des encodages pris en charge.

   *errors* est une chaîne facultative spécifiant comment les erreurs
   d'encodage et de décodage sont gérées, ce n'est pas utilisable en
   mode binaire. De nombreux gestionnaires d'erreurs standards sont
   disponibles (listés sous Gestionnaires d'erreurs), aussi, tout nom
   de gestionnaire d'erreur enregistré avec "codecs.register_error()"
   est aussi un argument valide. Les noms standards sont :

   * "'strict'" pour lever une "ValueError" si une erreur d'encodage
     est rencontrée. La valeur par défaut, "None", a le même effet.

   * "'ignore'" ignore les erreurs. Notez qu'ignorer les erreurs
     d'encodage peut mener à des pertes de données.

   * "'replace'" insère un marqueur de substitution (tel que "'?'") en
     place des données mal formées.

   * "'surrogateescape'" will represent any incorrect bytes as low
     surrogate code units ranging from U+DC80 to U+DCFF. These
     surrogate code units will then be turned back into the same bytes
     when the "surrogateescape" error handler is used when writing
     data.  This is useful for processing files in an unknown
     encoding.

   * "'xmlcharrefreplace'" est seulement pris en charge à l'écriture
     vers un fichier. Les caractères non gérés par l'encodage sont
     remplacés par une entité XML de la forme "&#nnn;".

   * "'backslashreplace'" remplace les données mal formées par des
     séquences d'échappement Python (utilisant des barres obliques
     inverses).

   * "'namereplace'" (aussi supporté lors de l'écriture) remplace les
     caractères non gérés par des séquences d'échappement "\N{...}".

   *newline* determines how to parse newline characters from the
   stream. It can be "None", "''", "'\n'", "'\r'", and "'\r\n'".  It
   works as follows:

   * Lors de la lecture, si *newline* est "None", le mode *universal
     newlines* est activé. Les lignes lues peuvent se terminer par
     "'\n'", "'\r'", ou "'\r\n'", et sont remplacées par "'\n'", avant
     d'être renvoyées à l'appelant. S'il vaut "''", le mode *universal
     newline* est activé mais les fins de ligne ne sont pas
     remplacées. S'il a n'importe quelle autre valeur autorisée, les
     lignes sont seulement terminées par la chaîne donnée, qui est
     rendue telle quelle.

   * Lors de l'écriture, si *newline* est "None", chaque "'\n'" est
     remplacé par le séparateur de lignes par défaut du système
     "os.linesep". Si *newline* est "''" ou "'\n'" aucun remplacement
     n'est effectué. Si *newline* est un autre caractère valide,
     chaque "'\n'" sera remplacé par la chaîne donnée.

   If *closefd* is "False" and a file descriptor rather than a
   filename was given, the underlying file descriptor will be kept
   open when the file is closed.  If a filename is given *closefd*
   must be "True" (the default); otherwise, an error will be raised.

   Un *opener* personnalisé peut être utilisé en fournissant un
   appelable comme *opener*. Le descripteur de fichier de cet objet
   fichier sera alors obtenu en appelant *opener* avec (*file*,
   *flags*). *opener* doit renvoyer un descripteur de fichier ouvert
   (fournir "os.open" en tant qu'*opener* aura le même effet que
   donner "None").

   Il n'est pas possible d'hériter du fichier nouvellement créé.

   L'exemple suivant utilise le paramètre dir_fd de la fonction
   "os.open()" pour ouvrir un fichier relatif au dossier courant :

      >>> import os
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('This will be written to somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # don't leak a file descriptor

   Le type d'*objet fichier* renvoyé par la fonction "open()" dépend
   du mode. Lorsque "open()" est utilisé pour ouvrir un fichier en
   mode texte ("w", "r", "wt", "rt", etc.), il renvoie une classe
   fille de "io.TextIOBase" (spécifiquement : "io.TextIOWrapper").
   Lors de l'ouverture d'un fichier en mode binaire avec tampon, la
   classe renvoyée sera une fille de "io.BufferedIOBase". La classe
   exacte varie : en lecture en mode binaire elle renvoie une
   "io.BufferedReader", en écriture et ajout en mode binaire c'est une
   "io.BufferedWriter", et en lecture-écriture, c'est une
   "io.BufferedRandom". Lorsque le tampon est désactivé, le flux brut,
   une classe fille de "io.RawIOBase", "io.FileIO" est renvoyée.

   See also the file handling modules, such as "fileinput", "io"
   (where "open()" is declared), "os", "os.path", "tempfile", and
   "shutil".

   Lève un évènement d'audit "open" avec les arguments "file", "mode"
   et "flags".

   Les arguments "mode" et "flags" peuvent avoir été modifiés ou
   déduits de l'appel original.

      Modifié dans la version 3.3:

      * ajout du paramètre *opener*.

      * ajout du mode "'x'".

      * "IOError" était normalement levée, elle est maintenant un
        alias de "OSError".

      * "FileExistsError" est maintenant levée si le fichier ouvert en
        mode création exclusive ("'x'") existe déjà.

      Modifié dans la version 3.4:

      * Il n'est plus possible d'hériter de *file*.

   Deprecated since version 3.4, removed in version 3.10: Le mode
   "'U'".

      Modifié dans la version 3.5:

      * Si l'appel système est interrompu et que le gestionnaire de
        signal ne lève aucune exception, la fonction réessaye l'appel
        système au lieu de lever une "InterruptedError" (voir la **PEP
        475** pour la justification).

      * ajout du gestionnaire d'erreurs "'namereplace'".

      Modifié dans la version 3.6:

      * prise en charge des objets implémentant "os.PathLike".

      * Sous Windows, ouvrir un *buffer* du terminal peut renvoyer une
        sous-classe de "io.RawIOBase" autre que "io.FileIO".

ord(c)

   Renvoie le nombre entier représentant le code Unicode du caractère
   représenté par la chaîne donnée. Par exemple, "ord('a')" renvoie le
   nombre entier "97" et "ord('€')" (symbole euro) renvoie "8364". Il
   s'agit de l'inverse de "chr()".

pow(base, exp[, mod])

   Renvoie *base* puissance *exp* et, si *mod* est présent, donne
   *base* puissance *exp* modulo *mod* (calculé de manière plus
   efficiente que "pow(base, exp) % mod"). La forme à deux arguments
   "pow(base, exp)" est équivalente à l'opérateur puissance :
   "base**exp".

   The arguments must have numeric types.  With mixed operand types,
   the coercion rules for binary arithmetic operators apply.  For
   "int" operands, the result has the same type as the operands (after
   coercion) unless the second argument is negative; in that case, all
   arguments are converted to float and a float result is delivered.
   For example, "pow(10, 2)" returns "100", but "pow(10, -2)" returns
   "0.01".  For a negative base of type "int" or "float" and a non-
   integral exponent, a complex result is delivered.  For example,
   "pow(-9, 0.5)" returns a value close to "3j".

   Pour des opérandes *base* et *exp* de type "int", si *mod* est
   présent, *mod* doit également être de type entier et *mod* doit
   être non nul. Si *mod* est présent et que *exp* est négatif, *base*
   et *mod* doivent être premiers entre eux. Dans ce cas,
   "pow(inv_base, -exp, mod)" est renvoyé, où *inv_base* est un
   inverse de *base* modulo *mod*.

   Voici un exemple de calcul d'un inverse de "38" modulo "97" :

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

   Modifié dans la version 3.8: Pour les opérandes "int", la forme à
   trois arguments de "pow" permet maintenant au deuxième argument
   d'être négatif, permettant le calcul des inverses modulaires.

   Modifié dans la version 3.8: Autorise les arguments par mots-clés.
   Auparavant, seuls les arguments positionnels étaient autorisés.

print(*objects, sep=' ', end='\n', file=None, flush=False)

   Print *objects* to the text stream *file*, separated by *sep* and
   followed by *end*.  *sep*, *end*, *file*, and *flush*, if present,
   must be given as keyword arguments.

   Tous les arguments positionnels sont convertis en chaîne comme le
   fait "str()", puis écrits sur le flux, séparés par *sep* et
   terminés par *end*. *sep* et *end* doivent être des chaînes, ou
   "None", indiquant de prendre les valeurs par défaut. Si aucun
   *objects* n'est donné "print()" écris seulement *end*.

   L'argument *file* doit être un objet avec une méthode
   "write(string)" ; s'il n'est pas fourni, ou vaut "None",
   "sys.stdout" sera utilisé. Puisque les arguments affichés sont
   convertis en chaîne, "print()" ne peut pas être utilisé avec des
   fichiers ouverts en mode binaire. Pour ceux-ci utilisez plutôt
   "file.write(...)".

   Output buffering is usually determined by *file*. However, if
   *flush* is true, the stream is forcibly flushed.

   Modifié dans la version 3.3: ajout de l'argument nommé *flush*.

class property(fget=None, fset=None, fdel=None, doc=None)

   Renvoie un attribut propriété.

   *fget* est une fonction permettant d'obtenir la valeur d'un
   attribut. *fset* est une fonction pour en définir la valeur. *fdel*
   quant à elle permet de supprimer la valeur d'un attribut, et *doc*
   créé une *docstring* pour l'attribut.

   Une utilisation courante : définir un attribut managé "x" :

      class C:
          def __init__(self):
              self._x = None

          def getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "I'm the 'x' property.")

   If *c* is an instance of *C*, "c.x" will invoke the getter, "c.x =
   value" will invoke the setter, and "del c.x" the deleter.

   S'il est donné, *doc* sera la *docstring* de l'attribut. Autrement
   la propriété copiera celle de *fget* (si elle existe). Cela rend
   possible la création de propriétés en lecture seule en utilisant
   simplement "property()" comme un *décorateur* :

      class Parrot:
          def __init__(self):
              self._voltage = 100000

          @property
          def voltage(self):
              """Get the current voltage."""
              return self._voltage

   Le décorateur "@property" transforme la méthode "voltage()" en un
   *getter* d'un attribut du même nom, et donne *"Get the current
   voltage"* comme *docstring* de *voltage*.

   Un objet propriété a les méthodes "getter", "setter" et "deleter"
   utilisables comme décorateurs créant une copie de la propriété avec
   les accesseurs correspondants définis par la fonction de
   décoration. C'est plus clair avec un exemple :

      class C:
          def __init__(self):
              self._x = None

          @property
          def x(self):
              """I'm the 'x' property."""
              return self._x

          @x.setter
          def x(self, value):
              self._x = value

          @x.deleter
          def x(self):
              del self._x

   Ce code est l'exact équivalent du premier exemple. Soyez attentifs
   à bien donner aux fonctions additionnelles le même nom que la
   propriété ("x" dans ce cas).

   L'objet propriété renvoyé à aussi les attributs "fget", "fset" et
   "fdel" correspondants aux arguments du constructeur.

   Modifié dans la version 3.5: Les *docstrings* des objets propriété
   peuvent maintenant être écrits.

class range(stop)
class range(start, stop[, step])

   Contrairement aux apparences, "range" n'est pas une fonction mais
   un type de séquence immuable, comme décrit dans Ranges et Types
   séquentiels — list, tuple, range.

repr(object)

   Return a string containing a printable representation of an object.
   For many types, this function makes an attempt to return a string
   that would yield an object with the same value when passed to
   "eval()"; otherwise, the representation is a string enclosed in
   angle brackets that contains the name of the type of the object
   together with additional information often including the name and
   address of the object.  A class can control what this function
   returns for its instances by defining a "__repr__()" method. If
   "sys.displayhook()" is not accessible, this function will raise
   "RuntimeError".

reversed(seq)

   Renvoie un *itérateur* inversé. *seq* doit être un objet ayant une
   méthode "__reverse__()" ou prenant en charge le protocole séquence
   (la méthode "__len__()" et la méthode "__getitem__()" avec des
   arguments entiers commençant à zéro).

round(number[, ndigits])

   Renvoie *number* arrondi avec une précision de *ndigits* chiffres
   après la virgule. Si *ndigits* est omis (ou est "None"), l'entier
   le plus proche est renvoyé.

   For the built-in types supporting "round()", values are rounded to
   the closest multiple of 10 to the power minus *ndigits*; if two
   multiples are equally close, rounding is done toward the even
   choice (so, for example, both "round(0.5)" and "round(-0.5)" are
   "0", and "round(1.5)" is "2").  Any integer value is valid for
   *ndigits* (positive, zero, or negative).  The return value is an
   integer if *ndigits* is omitted or "None". Otherwise, the return
   value has the same type as *number*.

   Pour tout autre objet Python "number", "round" délègue à
   "number.__round__".

   Note:

     Le comportement de "round()" avec les nombres à virgule flottante
     peut être surprenant : par exemple "round(2.675, 2)" donne "2.67"
     au lieu de "2.68". Ce n'est pas un bogue, mais dû au fait que la
     plupart des fractions de décimaux ne peuvent pas être représentés
     exactement en nombre a virgule flottante. Voir Arithmétique en
     nombres à virgule flottante : problèmes et limites pour plus
     d'information.

class set([iterable])

   Renvoie un nouveau "set", dont les éléments peuvent être extraits
   d'*iterable*. "set" est une classe native. Voir "set" et Types
   d'ensembles — set, frozenset pour la documentation de cette classe.

   D'autres conteneurs existent, comme : "frozenset", "list", "tuple",
   et "dict", ainsi que le module "collections".

setattr(object, name, value)

   This is the counterpart of "getattr()".  The arguments are an
   object, a string, and an arbitrary value.  The string may name an
   existing attribute or a new attribute.  The function assigns the
   value to the attribute, provided the object allows it.  For
   example, "setattr(x, 'foobar', 123)" is equivalent to "x.foobar =
   123".

   *name* need not be a Python identifier as defined in Identifiants
   et mots-clés unless the object chooses to enforce that, for example
   in a custom "__getattribute__()" or via "__slots__". An attribute
   whose name is not an identifier will not be accessible using the
   dot notation, but is accessible through "getattr()" etc..

   Note:

     Since private name mangling happens at compilation time, one must
     manually mangle a private attribute's (attributes with two
     leading underscores) name in order to set it with "setattr()".

class slice(stop)
class slice(start, stop[, step])

   Return a *slice* object representing the set of indices specified
   by "range(start, stop, step)".  The *start* and *step* arguments
   default to "None".  Slice objects have read-only data attributes
   "start", "stop", and "step" which merely return the argument values
   (or their default).  They have no other explicit functionality;
   however, they are used by NumPy and other third-party packages.
   Slice objects are also generated when extended indexing syntax is
   used.  For example: "a[start:stop:step]" or "a[start:stop, i]".
   See "itertools.islice()" for an alternate version that returns an
   iterator.

sorted(iterable, /, *, key=None, reverse=False)

   Renvoie une nouvelle liste triée depuis les éléments d'*iterable*.

   A deux arguments optionnels qui doivent être nommés.

   *key* spécifie une fonction d'un argument utilisé pour extraire une
   clé de comparaison de chaque élément de l'itérable (par exemple,
   "key=str.lower"). La valeur par défaut est "None" (compare les
   éléments directement).

   *reverse*, une valeur booléenne. Si elle est "True", la liste
   d'éléments est triée comme si toutes les comparaisons étaient
   inversées.

   Utilisez "functools.cmp_to_key()" pour convertir l'ancienne
   notation *cmp* en une fonction *key*.

   La fonction native "sorted()" est garantie stable. Un tri est
   stable s'il garantit de ne pas changer l'ordre relatif des éléments
   égaux entre eux. C'est utile pour trier en plusieurs passes (par
   exemple par département puis par salaire).

   The sort algorithm uses only "<" comparisons between items.  While
   defining an "__lt__()" method will suffice for sorting, **PEP 8**
   recommends that all six rich comparisons be implemented.  This will
   help avoid bugs when using the same data with other ordering tools
   such as "max()" that rely on a different underlying method.
   Implementing all six comparisons also helps avoid confusion for
   mixed type comparisons which can call reflected the "__gt__()"
   method.

   Pour des exemples de tris et un bref tutoriel, consultez Guide pour
   le tri.

@staticmethod

   Transforme une méthode en méthode statique.

   Une méthode statique ne reçoit pas de premier argument
   implicitement. Voilà comment déclarer une méthode statique :

      class C:
          @staticmethod
          def f(arg1, arg2, ...): ...

   La forme "@staticmethod" est un *décorateur* de fonction. Consultez
   Définition de fonctions pour plus de détails.

   A static method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()"). Moreover, they can be called
   as regular functions (such as "f()").

   Static methods in Python are similar to those found in Java or C++.
   Also, see "classmethod()" for a variant that is useful for creating
   alternate class constructors.

   Comme pour tous les décorateurs, il est possible d'appeler
   "staticmethod" comme une simple fonction, et faire quelque chose de
   son résultat. Ça peut être nécessaire dans le cas où vous voudriez
   une référence à la fonction depuis le corps d'une classe, et
   souhaiteriez éviter sa transformation en méthode d'instance. Pour
   ces cas, faites comme suit :

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

   Pour plus d'informations sur les méthodes statiques, consultez
   Hiérarchie des types standards.

   Modifié dans la version 3.10: Static methods now inherit the method
   attributes ("__module__", "__name__", "__qualname__", "__doc__" and
   "__annotations__"), have a new "__wrapped__" attribute, and are now
   callable as regular functions.

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

   Renvoie une version d'*object* sous forme de "str". Voir "str()"
   pour plus de détails.

   "str" est la *classe* native des chaînes de caractères. Pour des
   informations générales à propos des chaînes, consultez Type
   Séquence de Texte — str.

sum(iterable, /, start=0)

   Additionne *start* et les éléments d'un *iterable* de gauche à
   droite et en donne le total. Les éléments de l'*iterable* sont
   normalement des nombres, et la valeur de *start* ne peut pas être
   une chaîne de caractères.

   Pour certains cas, il existe de bonnes alternatives à "sum()". La
   bonne méthode, et rapide, de concaténer une séquence de chaînes est
   d'appeler "''.join(séquence)". Pour additionner des nombres à
   virgule flottante avec une meilleure précision, voir "math.fsum()".
   Pour concaténer une série d'itérables, utilisez plutôt
   "itertools.chain()".

   Modifié dans la version 3.8: le paramètre *start* peut être passé
   comme un argument nommé.

class super([type[, object-or-type]])

   Renvoie un objet mandataire (*proxy object* en anglais) déléguant
   les appels de méthode à une classe parente ou sœur de *type*. C'est
   utile pour accéder aux méthodes héritées qui ont été remplacées
   dans une classe.

   Le *object-or-type* détermine quel *ordre de résolution des
   méthodes* est utilisé pour la recherche. La recherche commence à
   partir de la classe qui suit immédiatement le *type*.

   Par exemple, si "__mro__" de *object-or-type* est "D -> B -> C -> A
   -> object" et la valeur de *type* est "B", alors "super()"
   recherche "C -> A -> object".

   L'attribut "__mro__" de *object-or-type* liste l'ordre de recherche
   de la méthode de résolution utilisée par "getattr()" et "super()".
   L'attribut est dynamique et peut changer lorsque la hiérarchie
   d'héritage est modifiée.

   Si le second argument est omis, l'objet *super* obtenu n'est pas
   lié. Si le second argument est un objet, "isinstance(obj, type)"
   doit être vrai. Si le second argument est un type,
   "issubclass(type2, type)" doit être vrai (c'est utile pour les
   méthodes de classe).

   Il existe deux autres cas d'usage typiques pour *super*. Dans une
   hiérarchie de classes à héritage simple, *super* peut être utilisé
   pour obtenir la classe parente sans avoir à la nommer
   explicitement, rendant le code plus maintenable. Cet usage se
   rapproche de l'usage de *super* dans d'autres langages de
   programmation.

   The second use case is to support cooperative multiple inheritance
   in a dynamic execution environment.  This use case is unique to
   Python and is not found in statically compiled languages or
   languages that only support single inheritance.  This makes it
   possible to implement "diamond diagrams" where multiple base
   classes implement the same method.  Good design dictates that such
   implementations have the same calling signature in every case
   (because the order of calls is determined at runtime, because that
   order adapts to changes in the class hierarchy, and because that
   order can include sibling classes that are unknown prior to
   runtime).

   Dans tous les cas, un appel typique à une classe parente ressemble
   à :

      class C(B):
          def method(self, arg):
              super().method(arg)    # This does the same thing as:
                                     # super(C, self).method(arg)

   En plus de la recherche de méthodes, "super()" fonctionne également
   pour la recherche d'attributs. Un cas d'utilisation possible est
   l'appel d'un *descripteur* d'une classe parente ou sœur.

   Notez que "super()" fait partie de l'implémentation du processus de
   liaison de recherche d'attributs pointés explicitement comme
   "super().__getitem__(name)". Il le fait en implémentant sa propre
   méthode "__getattribute__()" pour rechercher les classes dans un
   ordre prévisible supportant l'héritage multiple coopératif. En
   conséquence, "super()" n'est pas défini pour les recherches
   implicites via des instructions ou des opérateurs tels que
   "super()[name]".

   Notez aussi que, en dehors de sa forme sans arguments, "super()"
   peut être utilisée en dehors des méthodes. La forme à deux
   arguments est précise et donne tous les arguments exactement,
   donnant les références appropriées. La forme sans arguments
   fonctionne seulement à l'intérieur d'une définition de classe,
   puisque c'est le compilateur qui donne les détails nécessaires à
   propos de la classe en cours de définition, ainsi qu'accéder à
   l'instance courante pour les méthodes ordinaires.

   Pour des suggestions pratiques sur la conception de classes
   coopératives utilisant "super()", consultez guide to using super().

class tuple([iterable])

   Plutôt qu'être une fonction, "tuple" est en fait un type de
   séquence immuable, comme documenté dans N-uplets et Types
   séquentiels — list, tuple, range.

class type(object)
class type(name, bases, dict, **kwds)

   Avec un argument, renvoie le type d'*object*. La valeur renvoyée
   est un objet type et généralement la même que la valeur de
   l'attribut "object.__class__".

   La fonction native "isinstance()" est recommandée pour tester le
   type d'un objet, car elle prend en compte l'héritage.

   With three arguments, return a new type object.  This is
   essentially a dynamic form of the "class" statement. The *name*
   string is the class name and becomes the "__name__" attribute. The
   *bases* tuple contains the base classes and becomes the "__bases__"
   attribute; if empty, "object", the ultimate base of all classes, is
   added.  The *dict* dictionary contains attribute and method
   definitions for the class body; it may be copied or wrapped before
   becoming the "__dict__" attribute. The following two statements
   create identical "type" objects:

   >>> class X:
   ...     a = 1
   ...
   >>> X = type('X', (), dict(a=1))

   Voir aussi Objets type.

   Keyword arguments provided to the three argument form are passed to
   the appropriate metaclass machinery (usually "__init_subclass__()")
   in the same way that keywords in a class definition (besides
   *metaclass*) would.

   See also Personnalisation de la création de classes.

   Modifié dans la version 3.6: Les sous-classes de "type" qui ne
   redéfinissent pas "type.__new__" ne doivent plus utiliser la forme
   à un argument pour récupérer le type d'un objet.

vars([object])

   Renvoie l'attribut "__dict__" d'un module, d'une classe, d'une
   instance ou de n'importe quel objet avec un attribut "__dict__".

   Certains objets, comme les modules et les instances, ont un
   attribut "__dict__" modifiable ; cependant, d'autres objets peuvent
   avoir des restrictions en écriture sur leurs attributs "__dict__"
   (par exemple, les classes utilisent un "types.MappingProxyType"
   pour éviter les modifications directes du dictionnaire).

   Sans argument, "vars()" se comporte comme "locals()". Notez que le
   dictionnaire des variables locales n'est utile qu'en lecture, car
   ses écritures sont ignorées.

   A "TypeError" exception is raised if an object is specified but it
   doesn't have a "__dict__" attribute (for example, if its class
   defines the "__slots__" attribute).

zip(*iterables, strict=False)

   Iterate over several iterables in parallel, producing tuples with
   an item from each one.

   Example:

      >>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
      ...     print(item)
      ...
      (1, 'sugar')
      (2, 'spice')
      (3, 'everything nice')

   More formally: "zip()" returns an iterator of tuples, where the
   *i*-th tuple contains the *i*-th element from each of the argument
   iterables.

   Another way to think of "zip()" is that it turns rows into columns,
   and columns into rows.  This is similar to transposing a matrix.

   "zip()" is lazy: The elements won't be processed until the iterable
   is iterated on, e.g. by a "for" loop or by wrapping in a "list".

   One thing to consider is that the iterables passed to "zip()" could
   have different lengths; sometimes by design, and sometimes because
   of a bug in the code that prepared these iterables.  Python offers
   three different approaches to dealing with this issue:

   * By default, "zip()" stops when the shortest iterable is
     exhausted. It will ignore the remaining items in the longer
     iterables, cutting off the result to the length of the shortest
     iterable:

        >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
        [(0, 'fee'), (1, 'fi'), (2, 'fo')]

   * "zip()" is often used in cases where the iterables are assumed to
     be of equal length.  In such cases, it's recommended to use the
     "strict=True" option. Its output is the same as regular "zip()":

        >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
        [('a', 1), ('b', 2), ('c', 3)]

     Unlike the default behavior, it raises a "ValueError" if one
     iterable is exhausted before the others:

     >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):  
     ...     print(item)
     ...
     (0, 'fee')
     (1, 'fi')
     (2, 'fo')
     Traceback (most recent call last):
       ...
     ValueError: zip() argument 2 is longer than argument 1

     Without the "strict=True" argument, any bug that results in
     iterables of different lengths will be silenced, possibly
     manifesting as a hard-to-find bug in another part of the program.

   * Shorter iterables can be padded with a constant value to make all
     the iterables have the same length.  This is done by
     "itertools.zip_longest()".

   Edge cases: With a single iterable argument, "zip()" returns an
   iterator of 1-tuples.  With no arguments, it returns an empty
   iterator.

   Tips and tricks:

   * The left-to-right evaluation order of the iterables is
     guaranteed. This makes possible an idiom for clustering a data
     series into n-length groups using "zip(*[iter(s)]*n,
     strict=True)".  This repeats the *same* iterator "n" times so
     that each output tuple has the result of "n" calls to the
     iterator. This has the effect of dividing the input into n-length
     chunks.

   * "zip()" peut être utilisée conjointement avec l'opérateur "*"
     pour dézipper une liste :

        >>> x = [1, 2, 3]
        >>> y = [4, 5, 6]
        >>> list(zip(x, y))
        [(1, 4), (2, 5), (3, 6)]
        >>> x2, y2 = zip(*zip(x, y))
        >>> x == list(x2) and y == list(y2)
        True

   Modifié dans la version 3.10: Added the "strict" argument.

__import__(name, globals=None, locals=None, fromlist=(), level=0)

   Note:

     C'est une fonction avancée qui n'est pas fréquemment nécessaire,
     contrairement à "importlib.import_module()".

   Cette fonction est invoquée via l'instruction "import". Elle peut
   être remplacée (en important le module "builtins" et en y
   remplaçant "builtins.__import__") afin de changer la sémantique de
   l'instruction "import", mais c'est extrêmement déconseillé, car il
   est plus simple d'utiliser des points d'entrée pour les
   importations (*import hooks*, voir la **PEP 302**) pour le même
   résultat sans perturber du code s'attendant à trouver
   l'implémentation par défaut. L'usage direct de "__import__()" est
   aussi déconseillé en faveur de "importlib.import_module()".

   The function imports the module *name*, potentially using the given
   *globals* and *locals* to determine how to interpret the name in a
   package context. The *fromlist* gives the names of objects or
   submodules that should be imported from the module given by *name*.
   The standard implementation does not use its *locals* argument at
   all and uses its *globals* only to determine the package context of
   the "import" statement.

   *level* permet de choisir entre importation absolue ou relative.
   "0" (par défaut) force à effectuer uniquement des importations
   absolues. Une valeur positive indique le nombre de dossiers parents
   relativement au dossier du module appelant "__import__()" (voir la
   **PEP 328**).

   Lorsque la variable *name* est de la forme "package.module",
   normalement, le paquet de plus haut niveau (le nom jusqu'au premier
   point) est renvoyé, et *pas* le module nommé par *name*. Cependant,
   lorsqu'un argument *fromlist* est fourni, le module nommé par
   *name* est renvoyé.

   Par exemple, l'instruction "import spam" renvoie un code
   intermédiaire (*bytecode* en anglais) ressemblant au code suivant :

      spam = __import__('spam', globals(), locals(), [], 0)

   L'instruction "import spam.ham" appelle :

      spam = __import__('spam.ham', globals(), locals(), [], 0)

   Notez comment "__import__()" renvoie ici le module de plus haut
   niveau parce que c'est l'objet lié à un nom par l'instruction
   "import".

   En revanche, l'instruction "from spam.ham import eggs, sausage as
   saus" donne :

      _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
      eggs = _temp.eggs
      saus = _temp.sausage

   Ici le module "spam.ham" est renvoyé par "__import__()". De cet
   objet, les noms à importer sont récupérés et assignés à leurs noms
   respectifs.

   Si vous voulez simplement importer un module (potentiellement dans
   un paquet) par son nom, utilisez "importlib.import_module()".

   Modifié dans la version 3.3: les valeurs négatives pour *level* ne
   sont plus prises en charge (et sa valeur par défaut est 0).

   Modifié dans la version 3.9: Quand les options "-E" ou "-I" sont
   précisées dans la ligne de commande, la variable d'environnement
   "PYTHONCASEOK" est ignorée.

-[ Notes ]-

[1] Notez que l'analyseur n'accepte que des fin de lignes de style
    Unix. Si vous lisez le code depuis un fichier, assurez-vous
    d'utiliser la conversion de retours à la ligne pour convertir les
    fin de lignes Windows et Mac.
