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()" "anext()" "any()" | "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()"        | "getattr()" "globals()" | "object()" "oct()"      | "sum()" "super()"  **T**  |
| "chr()" "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(number, /)

   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.

   Ajouté 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, /)
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.

   Ajouté 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, /)

   Renvoie, tout comme "repr()", une chaîne contenant une
   représentation d'un objet destinée à l'affichage, mais en
   transformant les caractères non ASCII renvoyés par "repr()" par
   l'utilisation de séquences d'échappement "\x", "\u" ou "\U". Cela
   génère une chaîne similaire à ce que renvoie "repr()" dans Python
   2.

bin(integer, /)

   Convert an integer number to a binary string prefixed with "0b".
   The result is a valid Python expression. If *integer* is not a
   Python "int" object, it has to define an "__index__()" method that
   returns an integer. Some examples:

   >>> 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')

   See also "enum.bin()" to represent negative values as twos-
   complement.

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

class bool(object=False, /)

   Renvoie une valeur booléenne, c'est-à-dire soit "True", soit
   "False". L'argument est converti en utilisant la procédure standard
   d'évaluation de valeur de vérité. Si l'argument est faux, ou omis,
   elle renvoie "False", sinon, elle renvoie "True". La classe "bool"
   hérite de la classe "int" (voir Types numériques — int, float,
   complex). Il n'est pas possible d'en hériter. Ses seules instances
   sont "False" et "True" (voir Boolean Type - bool).

   Modifié dans la version 3.7: Le paramètre est désormais un argument
   exclusivement positionnel.

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

   Par défaut, le comportement de la fonction "breakpoint()" peut être
   changé par la variable d'environnement "PYTHONBREAKPOINT". Voir
   "sys.breakpointhook()" pour plus de détails.

   Notez que ceci n'est plus garanti si la fonction
   "sys.breakpointhook()" a été remplacée.

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

   Ajouté dans la version 3.7.

class bytearray(source=b'')
class bytearray(source, encoding, errors='strict')

   Renvoie un nouveau tableau d'octets. La classe "bytearray" est une
   séquence mutable 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 mutables, 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* ;

   * si c'est un objet conforme à l'interface tampon, un tampon en
     lecture seule de l'objet est utilisé pour initialiser le tableau
     ;

   * 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, vue mémoire et Objets
   bytearray.

class bytes(source=b'')
class bytes(source, encoding, errors='strict')

   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, vue mémoire,
   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__()".

   Ajouté 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(codepoint, /)

   Return the string representing a character with the specified
   Unicode code point. For example, "chr(97)" returns the string
   "'a'", while "chr(8364)" returns the string "'€'". This is the
   inverse of "ord()".

   The valid range for the argument is from 0 through 1,114,111
   (0x10FFFF in base 16).  "ValueError" will be raised if it is
   outside that range.

@classmethod

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

   Une méthode de classe reçoit implicitement la classe en premier
   argument, tout comme une méthode d'instance reçoit l'instance.
   Voici comment déclarer une méthode de classe :

      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 héritent
   dorénavant des attributs des méthodes ("__module__", "__name__",
   "__qualname__", "__doc__" et "__annotations__") et ont un nouvel
   attribut "__wrapped__".

   Deprecated since version 3.11, removed in version 3.13: les
   méthodes de classe ne peuvent plus encapsuler d'autres
   *descripteurs* comme "property()".

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 chaines de documentation sont également
   supprimées).

   This function raises "SyntaxError" or "ValueError" if the compiled
   source is invalid.

   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: autorise l'utilisation de retours à la
   ligne Mac et Windows. Par ailleurs, la chaîne donnée à "'exec'" n'a
   plus besoin de terminer par un retour à la ligne. Ajout du
   paramètre *optimize*.

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

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

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

   Convert a single string or number to a complex number, or create a
   complex number from real and imaginary parts.

   Exemples :

      >>> complex('+1.23')
      (1.23+0j)
      >>> complex('-4.5j')
      -4.5j
      >>> complex('-1.23+4.5j')
      (-1.23+4.5j)
      >>> complex('\t( -1.23+4.5J )\n')
      (-1.23+4.5j)
      >>> complex('-Infinity+NaNj')
      (-inf+nanj)
      >>> complex(1.23)
      (1.23+0j)
      >>> complex(imag=-4.5)
      -4.5j
      >>> complex(-1.23, 4.5)
      (-1.23+4.5j)

   If the argument is a string, it must contain either a real part (in
   the same format as for "float()") or an imaginary part (in the same
   format but with a "'j'" or "'J'" suffix), or both real and
   imaginary parts (the sign of the imaginary part is mandatory in
   this case). The string can optionally be surrounded by whitespaces
   and the round parentheses "'('" and "')'", which are ignored. The
   string must not contain whitespace between "'+'", "'-'", the "'j'"
   or "'J'" suffix, and the decimal number. For example,
   "complex('1+2j')" is fine, but "complex('1 + 2j')" raises
   "ValueError". More precisely, the input must conform to the
   "complexvalue" production rule in the following grammar, after
   parentheses and leading and trailing whitespace characters are
   removed:

      complexvalue: floatvalue |
                    floatvalue ("j" | "J") |
                    floatvalue sign absfloatvalue ("j" | "J")

   Si l'argument est un nombre, le constructeur le convertit, comme le
   font les classes "int" et "float". Pour les autres objets "x",
   "complex(x)" délègue à "x.__complex__()". Si "__complex__()" n'est
   pas définie, elle délègue à "__float__()". Si "__float__()" n'est
   pas défini, alors elle délègue à  "__index__()".

   If two arguments are provided or keyword arguments are used, each
   argument may be any numeric type (including complex). If both
   arguments are real numbers, return a complex number with the real
   component *real* and the imaginary component *imag*. If both
   arguments are complex numbers, return a complex number with the
   real component "real.real-imag.imag" and the imaginary component
   "real.imag+imag.real". If one of arguments is a real number, only
   its real component is used in the above expressions.

   See also "complex.from_number()" which only accepts a single
   numeric argument.

   If all arguments are omitted, returns "0j".

   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: délègue à "__index__()" si
   "__complex__()" et "__float__()" ne sont pas définies.

   Obsolète depuis la version 3.14: Passing a complex number as the
   *real* or *imag* argument is now deprecated; it should only be
   passed as a single positional argument.

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(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)

   Crée 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()
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
   renvoie "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(iterable, start=0):
          n = start
          for elem in iterable:
              yield n, elem
              n += 1

eval(source, /, globals=None, locals=None)

   Paramètres:
      * **source** ("str" | code object) -- A Python expression.

      * **globals** ("dict" | "None") -- The global namespace
        (default: "None").

      * **locals** (*mapping* | "None") -- The local namespace
        (default: "None").

   Renvoie:
      The result of the evaluated expression.

   Raises:
      Syntax errors are reported as exceptions.

   Avertissement:

     This function executes arbitrary code. Calling it with untrusted
     user-supplied input will lead to security vulnerabilities.

   The *source* argument is parsed and evaluated as a Python
   expression (technically speaking, a condition list) using the
   *globals* and *locals* mappings as global and local namespace.  If
   the *globals* dictionary is present and does not contain a value
   for the key "__builtins__", a reference to the dictionary of the
   built-in module "builtins" is inserted under that key before
   *source* is parsed. Overriding "__builtins__" can be used to
   restrict or change the available names, but this is **not** a
   security mechanism: the executed code can still access all
   builtins. If the *locals* mapping is omitted it defaults to the
   *globals* dictionary.  If both mappings are omitted, the source is
   executed with the *globals* and *locals* in the environment where
   "eval()" is called.  Note, *eval()* will only have access to the
   *nested scopes* (non-locals) in the enclosing environment if they
   are already referenced in the scope that is calling "eval()" (e.g.
   via a "nonlocal" statement).

   Example:

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

   Conseils : l'exécution dynamique d'instructions est gérée par la
   fonction "exec()". Les fonctions "globals()" et "locals()"
   renvoient respectivement les dictionnaires globaux et locaux, qui
   peuvent être utiles lors de l'usage de "eval()" et "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.

   Modifié dans la version 3.13: The *globals* and *locals* arguments
   can now be passed as keywords.

   Modifié dans la version 3.13: The semantics of the default *locals*
   namespace have been adjusted as described for the "locals()"
   builtin.

exec(source, /, globals=None, locals=None, *, closure=None)

   Avertissement:

     This function executes arbitrary code. Calling it with untrusted
     user-supplied input will lead to security vulnerabilities.

   This function supports dynamic execution of Python code. *source*
   must be either a string or a code object.  If it is a string, the
   string is parsed as a suite of Python statements which is then
   executed (unless a syntax error occurs). [1] If it is a code
   object, it is simply executed.  In all cases, the code that's
   executed is expected to be valid as file input (see the section
   Fichier d'entrée in the Reference Manual). Be aware that the
   "nonlocal", "yield",  and "return" statements may not be used
   outside of function definitions even within the context of code
   passed to the "exec()" function. The return value is "None".

   In all cases, if the optional parts are omitted, the code is
   executed in the current scope.  If only *globals* is provided, it
   must be a dictionary (and not a subclass of dictionary), which will
   be used for both the global and the local variables.  If *globals*
   and *locals* are given, they are used for the global and local
   variables, respectively.  If provided, *locals* can be any mapping
   object.  Remember that at the module level, globals and locals are
   the same dictionary.

   Note:

     When "exec" gets two separate objects as *globals* and *locals*,
     the code will be executed as if it were embedded in a class
     definition. This means functions and classes defined in the
     executed code will not be able to access variables assigned at
     the top level (as the "top level" variables are treated as class
     variables in a class definition).

   If the *globals* dictionary does not contain a value for the key
   "__builtins__", a reference to the dictionary of the built-in
   module "builtins" is inserted under that key. Overriding
   "__builtins__" can be used to restrict or change the available
   names, but this is **not** a security mechanism: the executed code
   can still access all builtins.

   The *closure* argument specifies a closure--a tuple of cellvars.
   It's only valid when the *object* is a code object containing *free
   (closure) variables*. The length of the tuple must exactly match
   the length of the code object's "co_freevars" attribute.

   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:

     The built-in functions "globals()" and "locals()" return the
     current global and local namespace, respectively, which may be
     useful to pass around for use as the second and third argument to
     "exec()".

   Note:

     The default *locals* act as described for function "locals()"
     below. Pass an explicit *locals* dictionary if you need to see
     effects of the code on *locals* after function "exec()" returns.

   Modifié dans la version 3.11: ajout du paramètre *closure*.

   Modifié dans la version 3.13: The *globals* and *locals* arguments
   can now be passed as keywords.

   Modifié dans la version 3.13: The semantics of the default *locals*
   namespace have been adjusted as described for the "locals()"
   builtin.

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(number=0.0, /)
class float(string, /)

   Return a floating-point number constructed from a number or a
   string.

   Exemples :

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

   If the argument is a string, it should contain a decimal number,
   optionally preceded by a sign, and optionally embedded in
   whitespace.  The optional sign may be "'+'" or "'-'"; a "'+'" sign
   has no effect on the value produced.  The argument may also be a
   string representing a NaN (not-a-number), or positive or negative
   infinity. More precisely, the input must conform to the
   "floatvalue" production rule in the following grammar, after
   leading and trailing whitespace characters are removed:

      sign:          "+" | "-"
      infinity:      "Infinity" | "inf"
      nan:           "nan"
      digit:         <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
      digitpart:     digit (["_"] digit)*
      number:        [digitpart] "." digitpart | digitpart ["."]
      exponent:      ("e" | "E") [sign] digitpart
      floatnumber:   number [exponent]
      absfloatvalue: floatnumber | infinity | nan
      floatvalue:    [sign] absfloatvalue

   Case is not significant, so, for example, "inf", "Inf", "INFINITY",
   and "iNfINity" are all acceptable spellings for positive infinity.

   Otherwise, if the argument is an integer or a floating-point
   number, a floating-point number with the same value (within
   Python's floating-point precision) is returned.  If the argument is
   outside the range of a Python float, an "OverflowError" will be
   raised.

   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__()".

   See also "float.from_number()" which only accepts a numeric
   argument.

   Sans argument, "0.0" est renvoyé.

   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: Le paramètre est désormais un argument
   exclusivement positionnel.

   Modifié dans la version 3.8: délègue à "__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 : Format specification mini-
   language.

   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)".

   A call to "format(value, format_spec)" is translated to
   "type(value).__format__(value, format_spec)" which bypasses the
   instance dictionary when searching for the value's "__format__()"
   method. A "TypeError" exception is raised if the method search
   reaches "object" and the *format_spec* is non-empty, or if either
   the *format_spec* or the return value are not strings.

   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, /)
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:

     For objects with custom "__hash__()" methods, note that "hash()"
     truncates the return value based on the bit width of the host
     machine.

help()
help(request)

   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.

   Notez que si une barre oblique (/) apparaît dans la liste des
   paramètres d'une fonction lorsque vous appelez "help()", cela
   signifie que les paramètres placés avant la barre oblique sont
   strictement positionnels. Pour plus d'informations, voir La FAQ sur
   les arguments positionnels.

   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(integer, /)

   Convert an integer number to a lowercase hexadecimal string
   prefixed with "0x". If *integer* is not a Python "int" object, it
   has to define an "__index__()" method that returns an integer. Some
   examples:

   >>> 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()".

   c'est l'adresse de l'objet en mémoire.

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

input()
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) qu'elle 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"
   avant de lire l'entrée.

   Lève un événement d'audit "builtins.input/result" avec le résultat
   après avoir lu avec succès l'entrée.

class int(number=0, /)
class int(string, /, base=10)

   Return an integer object constructed from a number or a string, or
   return "0" if no arguments are given.

   Exemples :

      >>> int(123.45)
      123
      >>> int('123')
      123
      >>> int('   -12_345\n')
      -12345
      >>> int('FACE', 16)
      64206
      >>> int('0xface', 0)
      64206
      >>> int('01110011', base=2)
      115

   If the argument defines "__int__()", "int(x)" returns
   "x.__int__()".  If the argument defines "__index__()", it returns
   "x.__index__()". For floating-point numbers, this truncates towards
   zero.

   If the argument is not a number or if *base* is given, then it 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: The first parameter is now positional-
   only.

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

   Modifié dans la version 3.11: "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 to an "int" or when converting an "int" into a
   string would exceed the limit. See the integer string conversion
   length limitation documentation.

   Modifié dans la version 3.14: "int()" no longer delegates to the
   "__trunc__()" method.

isinstance(object, classinfo, /)

   Renvoie "True" si *object* est une instance de *classinfo*, ou
   d'une de ses classes filles, directe, indirecte, ou *abstraite*. Si
   *object* n'est pas un objet du type donné, la fonction renvoie
   toujours "False". Si *classinfo* est un *n*-uplet de types (ou
   récursivement, d'autres *n*-uplets) ou une union de types
   différents, renvoie "True" si *object* est une instance de
   n'importe quel de ces types. Si *classinfo* n'est ni un type ni un
   *n*-uplet de types (et récursivement), une exception "TypeError"
   est levée. "TypeError" ne peut pas être levée pour un type invalide
   si une des vérifications précédentes réussit.

   Modifié dans la version 3.10: *classinfo* peut être une union de
   types.

issubclass(class, classinfo, /)

   Renvoie "True" si *class* est une classe fille (directe, indirecte
   ou *abstraite*) de *classinfo*. Une classe est considérée sous-
   classe d'elle-même. *classinfo* peut être un *n*-uplet de classes
   (ou récursivement, d'autres *n*-uplets) ou une union de types, dans
   ce cas elle renvoie "True" si *class* est une sous-classe d'une
   partie de *classinfo*. Dans tous les autres cas, une "TypeError"
   est levée.

   Modifié dans la version 3.10: *classinfo* peut être une union de
   types.

iter(iterable, /)
iter(callable, sentinel, /)

   Return an *iterator* object.  The first argument is interpreted
   very differently depending on the presence of the second argument.
   Without a second argument, the single argument 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 the
   first argument must be a callable object.  The iterator created in
   this case will call *callable* 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(object, /)

   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é).

   "len" lève une "OverflowError" sur des longueurs supérieures à
   "sys.maxsize", par exemple pour "range(2 ** 100)".

class list(iterable=(), /)

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

locals()

   Return a mapping object representing the current local symbol
   table, with variable names as the keys, and their currently bound
   references as the values.

   At module scope, as well as when using "exec()" or "eval()" with a
   single namespace, this function returns the same namespace as
   "globals()".

   At class scope, it returns the namespace that will be passed to the
   metaclass constructor.

   When using "exec()" or "eval()" with separate local and global
   arguments, it returns the local namespace passed in to the function
   call.

   In all of the above cases, each call to "locals()" in a given frame
   of execution will return the *same* mapping object. Changes made
   through the mapping object returned from "locals()" will be visible
   as assigned, reassigned, or deleted local variables, and assigning,
   reassigning, or deleting local variables will immediately affect
   the contents of the returned mapping object.

   In an *optimized scope* (including functions, generators, and
   coroutines), each call to "locals()" instead returns a fresh
   dictionary containing the current bindings of the function's local
   variables and any nonlocal cell references. In this case, name
   binding changes made via the returned dict are *not* written back
   to the corresponding local variables or nonlocal cell references,
   and assigning, reassigning, or deleting local variables and
   nonlocal cell references does *not* affect the contents of
   previously returned dictionaries.

   Calling "locals()" as part of a comprehension in a function,
   generator, or coroutine is equivalent to calling it in the
   containing scope, except that the comprehension's initialised
   iteration variables will be included. In other scopes, it behaves
   as if the comprehension were running as a nested function.

   Calling "locals()" as part of a generator expression is equivalent
   to calling it in a nested generator function.

   Modifié dans la version 3.12: The behaviour of "locals()" in a
   comprehension has been updated as described in **PEP 709**.

   Modifié dans la version 3.13: As part of **PEP 667**, the semantics
   of mutating the mapping objects returned from this function are now
   defined. The behavior in *optimized scopes* is now as described
   above. Aside from being defined, the behaviour in other scopes
   remains unchanged from previous versions.

map(function, iterable, /, *iterables, strict=False)

   Return an iterator that applies *function* to every item of
   *iterable*, yielding the results.  If additional *iterables*
   arguments are passed, *function* must take that many arguments and
   is applied to the items from all iterables in parallel.  With
   multiple iterables, the iterator stops when the shortest iterable
   is exhausted.  If *strict* is "True" and one of the iterables is
   exhausted before the others, a "ValueError" is raised. For cases
   where the function inputs are already arranged into argument
   tuples, see "itertools.starmap()".

   Modifié dans la version 3.14: Added the *strict* parameter.

max(iterable, /, *, key=None)
max(iterable, /, *, default, key=None)
max(arg1, arg2, /, *args, key=None)

   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)".

   Modifié dans la version 3.4: Added the *default* keyword-only
   parameter.

   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 mémoire pour plus d'informations.

min(iterable, /, *, key=None)
min(iterable, /, *, default, key=None)
min(arg1, arg2, /, *args, key=None)

   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)".

   Modifié dans la version 3.4: Added the *default* keyword-only
   parameter.

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

next(iterator, /)
next(iterator, default, /)

   Donne l'élément suivant de l'*itérateur* en appelant sa méthode
   "__next__()". Si *default* est fourni, il est renvoyé quand
   l'itérateur est épuisé, sinon une "StopIteration" est levée.

class object

   This is the ultimate base class of all other classes. It has
   methods that are common to all instances of Python classes. When
   the constructor is called, it returns a new featureless object. The
   constructor does not accept any arguments.

   Note:

     "object" instances do *not* have "__dict__" attributes, so you
     can't assign arbitrary attributes to an instance of "object".

oct(integer, /)

   Convert an integer number to an octal string prefixed with "0o".
   The result is a valid Python expression. If *integer* is not a
   Python "int" object, it has to define an "__index__()" method that
   returns an integer. For example:

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

   Si vous voulez convertir un nombre entier en une chaîne octale,
   avec ou sans le préfixe "0o", vous pouvez utiliser l'une des
   méthodes suivantes.

   >>> '%#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'exemples 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* is an optional string that specifies the mode in which the
   file is opened.  It defaults to "'r'" which means open for reading
   in text mode. Other common values are "'w'" for writing (truncating
   the file if it already exists), "'x'" for exclusive creation, and
   "'a'" for appending (which on *some* Unix systems, means that *all*
   writes append to the end of the file regardless of the current seek
   position).  In text mode, if *encoding* is not specified the
   encoding used is platform-dependent: "locale.getencoding()" is
   called to get the current locale encoding. (For reading and writing
   raw bytes use binary mode and leave *encoding* unspecified.)  The
   available modes are:

   +-----------+-----------------------------------------------------------------+
   | 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, un
   synonyme pour "'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é.

   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* is an optional integer used to set the buffering
   policy.  Pass 0 to switch buffering off (only allowed in binary
   mode), 1 to select line buffering (only usable when writing in text
   mode), and an integer > 1 to indicate the size in bytes of a fixed-
   size chunk buffer. Note that specifying a buffer size this way
   applies for binary buffered I/O, but "TextIOWrapper" (i.e., files
   opened with "mode='r+'") would have another buffering. To disable
   buffering in "TextIOWrapper", consider using the "write_through"
   flag for "io.TextIOWrapper.reconfigure()". When no *buffering*
   argument is given, the default buffering policy works as follows:

   * Binary files are buffered in fixed-size chunks; the size of the
     buffer is "max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)" when
     the device block size is available. On most systems, the buffer
     will typically be 128 kilobytes long.

   * les fichiers texte « interactifs » (fichiers pour lesquels
     "io.IOBase.isatty()" renvoie "True") utilisent un tampon ligne
     par ligne. Les autres fichiers textes 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 renvoie
   "locale.getencoding()"), 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'" représentera tous les octets incorrects comme
     des points de code de substitution de l'intervalle bas U+DC80 à
     U+DCFF. Ces points de code de substitution sont ensuite
     retransformés dans les mêmes octets lorsque le gestionnaire
     d'erreurs "surrogateescape" est utilisé pour l'écriture des
     données. C'est utile pour traiter des fichiers d'un encodage
     inconnu.

   * "'xmlcharrefreplace'" is only supported when writing to a file.
     Characters not supported by the encoding are replaced with the
     appropriate XML character reference "&#*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* contrôle comment interpréter les retours à la ligne. Il
   peut être "None", "''", "'\n'", "'\r'", et "'\r\n'". Il fonctionne
   comme suit :

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

   Si *closefd* est "False" et qu'un descripteur de fichier est fourni
   plutôt qu'un nom de fichier, le descripteur de fichier sera laissé
   ouvert lorsque le fichier sera fermé. Si un nom de fichier est
   donné, *closefd* doit rester "True" (la valeur par défaut) ; sinon,
   une erreur est levée.

   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 descripteur de 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.

   Consultez aussi les modules de gestion de fichiers tels que
   "fileinput", "io" (où "open()" est déclarée), "os", "os.path",
   "tempfile", et "shutil".

   Raises an auditing event "open" with arguments "path", "mode",
   "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*.

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

   Modifié dans la version 3.11: le mode "'U`" a été enlevé.

ord(character, /)

   Return the ordinal value of a character.

   If the argument is a one-character string, return the Unicode code
   point of that character.  For example, "ord('a')" returns the
   integer "97" and "ord('€')" (Euro sign) returns "8364".  This is
   the inverse of "chr()".

   If the argument is a "bytes" or "bytearray" object of length 1,
   return its single byte value. For example, "ord(b'a')" returns the
   integer "97".

pow(base, exp, mod=None)

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

   When arguments are builtin 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". Whereas, for a
   negative base of type "int" or "float" with an integral exponent, a
   float result is delivered. For example, "pow(-9, 2.0)" returns
   "81.0".

   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 nommés.
   Auparavant, seuls les arguments positionnels étaient autorisés.

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

   Écrit *objects* dans le flux texte *file*, séparés par *sep* et
   suivis de *end*. Les arguments *sep*, *end*, *file*, et *flush*,
   s'ils sont présents, doivent être passés en arguments nommés.

   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()" écrit 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" est utilisé. Puisque les arguments affichés sont
   convertis en chaîne, "print()" ne peut pas être utilisée avec des
   fichiers ouverts en mode binaire. Pour ceux-ci utilisez plutôt
   "file.write(...)".

   Que la sortie utilise un tampon ou non est souvent décidé par
   *file*. Cependant, si l'argument *flush* est vrai, le tampon du
   flux est vidé explicitement.

   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ée une chaîne de documentation (*docstring*) pour l'attribut.

   Une utilisation courante est de 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.")

   Si *c* est une instance de *C*, "c.x" appelle l'accesseur (*getter*
   en anglais), "c.x = value" invoque le mutateur (*setter*), et "del
   x" le destructeur (*deleter*).

   Si elle est fournie, *doc* est la chaîne de documentation de
   l'attribut. Autrement la propriété copie celle de *fget* (si elle
   existe). Cela rend possible la création de propriétés en lecture
   seule en utilisant simplement "property()" comme *décorateur* :

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

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

   The "@property" decorator turns the "voltage()" method into a
   "getter" for a read-only attribute with the same name, and it sets
   the docstring for *voltage* to "Get the current voltage."

   @getter

   @setter

   @deleter

      A property object has "getter", "setter", and "deleter" methods
      usable as decorators that create a copy of the property with the
      corresponding accessor function set to the decorated function.
      This is best explained with an example:

         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é possède aussi les attributs "fget",
      "fset" et "fdel" correspondants aux arguments du constructeur.

   Modifié dans la version 3.5: les chaînes de documentation des
   objets *property* sont maintenant en lecture-écriture.

   __name__

      Attribute holding the name of the property. The name of the
      property can be changed at runtime.

      Ajouté dans la version 3.13.

class range(stop, /)
class range(start, stop, step=1, /)

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

   This class has a custom representation that can be evaluated:

      class Person:
         def __init__(self, name, age):
            self.name = name
            self.age = age

         def __repr__(self):
            return f"Person('{self.name}', {self.age})"

reversed(object, /)

   Return a reverse *iterator*.  The argument must be an object which
   has a "__reversed__()" method or supports the sequence protocol
   (the "__len__()" method and the "__getitem__()" method with integer
   arguments starting at "0").

round(number, ndigits=None)

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

   Pour les types natifs prenant en charge "round()", les valeurs sont
   arrondies au multiple de 10 puissance moins *ndigits*, si deux
   multiples sont équidistants, l'arrondi se fait vers la valeur paire
   (par exemple "round(0.5)" et "round(-0.5)" valent tous les deux
   "0", et "round(1.5)" vaut "2"). *ndigits* accepte tout nombre
   entier (positif, zéro, ou négatif). La valeur renvoyée est un
   entier si *ndigits* n'est pas donné (ou est "None"). Sinon elle est
   du même type que *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 Floating-Point
     Arithmetic:  Issues and Limitations pour plus d'information.

class set(iterable=(), /)

   Renvoie un nouvel "ensemble", dont les éléments sont extraits
   d'*iterable* s'il est fourni. "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, /)

   C'est le complément de "getattr()". Les arguments sont : un objet,
   une chaîne et une valeur de type arbitraire. La chaîne *name* peut
   désigner un attribut existant ou un nouvel attribut. La fonction
   assigne la valeur à l'attribut, si l'objet l'autorise. Par exemple,
   "setattr(x, 'foobar', 123)" équivaut à "x.foobar = 123".

   *name* n'a pas besoin d'être un identifiant Python tel que défini
   dans Names (identifiers and keywords) sauf si l'objet choisit de
   l'imposer, par exemple en personnalisant "__getattribute__()" ou
   *via* "__slots__". Un attribut dont le nom n'est pas un identifiant
   ne sera pas accessible en utilisant la notation pointée, mais est
   accessible *via* "getattr()" etc.

   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 définir avec "setattr()".

class slice(stop, /)
class slice(start, stop, step=None, /)

   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 are also generated when slicing 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*.

   start
   stop
   step

      These read-only attributes are set to the argument values (or
      their default).  They have no other explicit functionality;
      however, they are used by NumPy and other third-party packages.

   Modifié dans la version 3.12: Slice objects are now *hashable*
   (provided "start", "stop", and "step" are hashable).

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

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

   Possède deux arguments optionnels qui doivent être spécifiés par
   arguments nommés.

   *key* spécifie une fonction à un argument utilisée 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* est 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 direction 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 the reflected "__gt__()"
   method.

   Pour des exemples de tris et un bref tutoriel, consultez Les
   techniques de tri.

@staticmethod

   Transforme une méthode en méthode statique.

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

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

   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, the static method
   *descriptor* is also callable, so it can be used in the class
   definition (such as "f()").

   Les méthodes statiques en Python sont similaires à celles que l'on
   trouve en Java ou en C++. Consultez "classmethod()" pour une
   variante utile permettant de créer des constructeurs alternatifs.

   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 souhaitez
   une référence à la fonction depuis le corps d'une classe, et voulez
   éviter sa transformation en méthode d'instance. Dans ce 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(*, encoding='utf-8', errors='strict')
class str(object)
class str(object, encoding, errors='strict')
class str(object, *, errors)

   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.

   For some use cases, there are good alternatives to "sum()". The
   preferred, fast way to concatenate a sequence of strings is by
   calling "''.join(sequence)".  To add floating-point values with
   extended precision, see "math.fsum()".  To concatenate a series of
   iterables, consider using "itertools.chain()".

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

   Modifié dans la version 3.12: Summation of floats switched to an
   algorithm that gives higher accuracy and better commutativity on
   most builds.

   Modifié dans la version 3.14: Added specialization for summation of
   complexes, using same algorithm as for summation of floats.

class super
class super(type, object_or_type=None, /)

   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.

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

   For example, if "__mro__" of *object_or_type* is "D -> B -> C -> A
   -> object" and the value of *type* is "B", then "super()" searches
   "C -> A -> object".

   The "__mro__" attribute of the class corresponding to
   *object_or_type* lists the method resolution search order used by
   both "getattr()" and "super()".  The attribute is dynamic and can
   change whenever the inheritance hierarchy is updated.

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

   When called directly within an ordinary method of a class, both
   arguments may be omitted ("zero-argument "super()""). In this case,
   *type* will be the enclosing class, and *obj* will be the first
   argument of the immediately enclosing function (typically "self").
   (This means that zero-argument "super()" will not work as expected
   within nested functions, including generator expressions, which
   implicitly create nested functions.)

   Il existe deux autres cas d'usage typiques pour *super*. Dans une
   hiérarchie de classes à héritage simple, *super* peut être utilisée
   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.

   Le second est la gestion d'héritage multiple coopératif dans un
   environnement d'exécution dynamique. Cet usage est unique à Python,
   il ne se retrouve ni dans les langages compilés statiquement, ni
   dans les langages ne gérant que l'héritage simple. Cela rend
   possible d'implémenter un héritage en diamant dans lequel plusieurs
   classes parentes implémentent la même méthode. Une bonne conception
   implique que ces implémentations doivent avoir la même signature
   lors de leur appel dans tous les cas (parce que l'ordre des appels
   est déterminée à l'exécution, parce que l'ordre s'adapte aux
   changements dans la hiérarchie, et parce que l'ordre peut inclure
   des classes sœurs inconnues avant l'exécution).

   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.

   Note that "super()" is implemented as part of the binding process
   for explicit dotted attribute lookups such as
   "super().__getitem__(name)". It does so by implementing its own
   "__getattribute__()" method for searching classes in a predictable
   order that supports cooperative multiple inheritance. Accordingly,
   "super()" is undefined for implicit lookups using statements or
   operators such as "super()[name]".

   Notez aussi que, en dehors de sa forme sans argument, "super()"
   peut être utilisée en dehors des méthodes. La forme à deux
   arguments est précise et contient tous les arguments nécessaires,
   donnant les références appropriées. La forme sans argument
   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().

   Modifié dans la version 3.14: "super" objects are now "pickleable"
   and  "copyable".

class tuple(iterable=(), /)

   Ce n'est pas 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, /, **kwargs)

   With one argument, return the type of an *object*.  The return
   value is a type object and generally the same object as returned by
   "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))

   See also:

   * Documentation on attributes and methods on classes.

   * Objets type

   Les arguments nommés fournis à la forme à trois arguments sont
   passés au mécanisme de métaclasse approprié (généralement
   "__init_subclass__()") de la même manière que les arguments nommés
   dans une définition de classe (en plus de *metaclass*).

   Voir aussi Personnalisation de la création de classes.

   Modifié dans la version 3.6: Subclasses of "type" which don't
   override "type.__new__" may no longer use the one-argument form to
   get the type of an object.

vars()
vars(object, /)

   Return the "__dict__" attribute for a module, class, instance, or
   any other object with a "__dict__" attribute.

   Objects such as modules and instances have an updateable "__dict__"
   attribute; however, other objects may have write restrictions on
   their "__dict__" attributes (for example, classes use a
   "types.MappingProxyType" to prevent direct dictionary updates).

   Without an argument, "vars()" acts like "locals()".

   Une exception "TypeError" est levée si un objet est spécifié mais
   qu'il n'a pas d'attribut "__dict__" (par exemple, si sa classe
   définit l'attribut "__slots__").

   Modifié dans la version 3.13: The result of calling this function
   without an argument has been updated as described for the
   "locals()" builtin.

zip(*iterables, strict=False)

   Itère sur plusieurs itérables en parallèle, produisant des
   *n*-uplets avec un élément provenant de chacun.

   Exemple :

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

   Plus formellement : "zip()" renvoie un itérateur de *n*-uplets, où
   le *i*^e *n*-uplet contient le *i*^e élément de chacun des
   itérables passés en arguments.

   Une autre façon de voir "zip()" est qu'elle transforme les lignes
   en colonnes et les colonnes en lignes, fournissant la matrice
   transposée.

   "zip()" est paresseuse : les éléments ne sont traités qu'au moment
   où l'on itère, par exemple avec une boucle "for" ou en les plaçant
   dans une "liste".

   Il faut savoir que les itérables passés à "zip()" peuvent avoir des
   longueurs différentes ; parfois par conception, parfois à cause
   d'un bogue dans le code qui a préparé ces itérables. Python propose
   trois approches différentes pour traiter ce problème :

   * par défaut, "zip()" s'arrête lorsque l'itérable le plus court est
     épuisé. Elle ignore les éléments restants dans les itérables plus
     longs, coupant le résultat à la longueur de l'itérable le plus
     court :

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

   * "zip()" est souvent utilisée dans les cas où les itérables sont
     supposés être de même longueur. Dans ce cas, il est recommandé
     d'utiliser l'option "strict=True". Cela produit la même chose que
     la "zip()" habituelle :

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

     Mais, contrairement au comportement par défaut, elle lève une
     "ValueError" si un itérable est épuisé avant les autres :

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

     Sans l'argument "strict=True", tout bogue entraînant des
     itérables de longueurs différentes est réduit au silence, se
     manifestant éventuellement comme un bogue difficile à trouver
     dans une autre partie du programme.

   * les itérables plus courts peuvent être remplis avec une valeur
     constante pour que tous les itérables aient la même longueur.
     C'est le cas pour "itertools.zip_longest()".

   Cas extrêmes : avec un seul argument itérable, "zip()" renvoie un
   itérateur de « 1-uplet ». Sans argument, elle renvoie un itérateur
   vide.

   Trucs et astuces :

   * il est garanti que les itérables sont évalués de gauche à droite.
     Cela rend possible de grouper une séquence de données en groupes
     de taille *n* via "zip(*[iter(s)]*n, strict=True)". Cela duplique
     le *même* itérateur "n" fois ; par conséquent le *n*-uplet obtenu
     contient le résultat de "n" appels à l'itérateur. Cela a pour
     effet de diviser la séquence en morceaux de taille *n*.

   * "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: ajout de l'argument "strict".

__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()".

   La fonction importe le module *name*, utilisant potentiellement
   *globals* et *locals* pour déterminer comment interpréter le nom
   dans le contexte d'un paquet. *fromlist* donne le nom des objets ou
   sous-modules qui devraient être importés du module *name*.
   L'implémentation standard n'utilise pas l'argument *locals* et
   n'utilise *globals* que pour déterminer le contexte du paquet de
   l'instruction "import".

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