2. 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  |                  |                      |
|=====================|===================|====================|==================|======================|
| "abs()"             | "dict()"          | "help()"           | "min()"          | "setattr()"          |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "all()"             | "dir()"           | "hex()"            | "next()"         | "slice()"            |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "any()"             | "divmod()"        | "id()"             | "object()"       | "sorted()"           |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "ascii()"           | "enumerate()"     | "input()"          | "oct()"          | "staticmethod()"     |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "bin()"             | "eval()"          | "int()"            | "open()"         | "str()"              |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "bool()"            | "exec()"          | "isinstance()"     | "ord()"          | "sum()"              |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "bytearray()"       | "filter()"        | "issubclass()"     | "pow()"          | "super()"            |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "bytes()"           | "float()"         | "iter()"           | "print()"        | "tuple()"            |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "callable()"        | "format()"        | "len()"            | "property()"     | "type()"             |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "chr()"             | "frozenset()"     | "list()"           | "range()"        | "vars()"             |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "classmethod()"     | "getattr()"       | "locals()"         | "repr()"         | "zip()"              |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "compile()"         | "globals()"       | "map()"            | "reversed()"     | "__import__()"       |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "complex()"         | "hasattr()"       | "max()"            | "round()"        |                      |
+---------------------+-------------------+--------------------+------------------+----------------------+
| "delattr()"         | "hash()"          | "memoryview()"     | "set()"          |                      |
+---------------------+-------------------+--------------------+------------------+----------------------+

abs(x)

   Donne la valeur absolue d'un nombre. L'argument peut être un nombre
   entier ou un nombre à virgule flottante. Si l'argument est un
   nombre complexe, son module est donné.

all(iterable)

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

any(iterable)

   Donne "True" si au moins un élément de *iterable* est vrai. Faux
   est aussi donné dans le cas où *iterable* est vide, équivaut à :

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

ascii(object)

   Donne, tout comme "repr()", une chaîne contenant une représentation
   affichable d'un objet, en transformant les caractères non ASCII
   donnés par "repr()" en utilisant des séquences d'échappement "\x",
   "\u" ou "\U". Cela génère une chaîne similaire à ce que renvoie
   "repr()" dans Python 2.

bin(x)

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

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

   Que le préfixe "0b" soit souhaité ou non, vous pouvez utiliser les
   moyens suivants.

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

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

class bool([x])

   Donne une valeur booléenne, c'est à dire soit "True", soit "False".
   *x* est converti en utilisant la procédure standard d'évaluation de
   valeur de vérité. Si *x* est faux, ou omis, elle donne "False",
   sinon, elle donne "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 Valeurs booléennes).

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

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

   Le paramètre optionnel *source* peut être utilisé pour initialiser
   l'*array* de quelques manières différentes :

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

   * Si c'est un *entier*, l'*array* aura cette taille et sera
     initialisé de *null bytes*.

   * Si c'est un objet conforme à l'interface *buffer*, un *buffer* en
     lecture seule de l'objet sera utilisé pour initialiser l'*array*.

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

   Sans argument, un *array* de taille vide est crée.

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

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

   Donne un nouvel objet *bytes*, qui est une séquence immuable de
   nombre entiers dans l'intervalle "0 <= x <= 256". Les "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 la
   découpe.

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

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

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

callable(object)

   Donne "True" si l'argument *object* semble être appelable, sinon
   "False". Lorsqu'elle donne vrai, il reste une éventualité pour
   qu'un appel échoue, cependant, lorsqu'elle donne faux, il ne sera
   jamais possible d'appeler *object*. Notez que les classes sont
   appelables (appeler une classe donne une nouvelle instance). Les
   instances sont appelables si leur classe définit une méthode
   "__call__()".

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

chr(i)

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

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

@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 *decorator* -- consultez la
   documentation sur la définition de fonctions dans 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 c'est elles sont vous avez besoin, regardez du
   côté de "staticmethod()".

   Pour plus d'informations sur les méthodes de classe, consultez la
   documentation sur la hiérarchie des types standards dans Hiérarchie
   des types standards.

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 soit
   être une chaîne, un objet *bytes*, ou un objet AST. Consultez la
   documentation du module "ast" pour des informations sur la
   manipulation d'objets AST.

   L'argument *filename* doit nommer le fichier duquel le code à é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'" si il ne contient qu'une
   instruction interactive (dans ce dernier cas, les résultats
   d'expressions donnant autre chose que "None" seront affichés).

   The optional arguments *flags* and *dont_inherit* control which
   future statements affect the compilation of *source*.  If neither
   is present (or both are zero) the code is compiled with those
   future statements that are in effect in the code that is calling
   "compile()".  If the *flags* argument is given and *dont_inherit*
   is not (or is zero) then the future statements specified by the
   *flags* argument are used in addition to those that would be used
   anyway. If *dont_inherit* is a non-zero integer then the *flags*
   argument is it -- the future statements in effect around the call
   to compile are ignored.

   Les instructions futures sont spécifiées par des bits, il est ainsi
   possible d'en spécifier plusieurs en les combinant avec un *ou*
   binaire. Les bits requis pour spécifier une certaine fonctionnalité
   se trouvent dans l'attribut "compiler_flag" de la classe "Feature"
   du module "__future__".

   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 niveau explicites sont : "0" (pas d'optimisation, "__debug__"
   est "True"), "1" (les "assert" sont supprimés, "__debug__" est
   "False") ou "2" (les *docstrings* sont également supprimés).

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

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

   Note:

     Lors de la compilation d'une chaîne de plusieurs lignes de code
     avec les modes "'single'" ou "'eval'", celle-ci doit être
     terminée d'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 à cause de la 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. Aussi, 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*.

class complex([real[, imag]])

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

   Note:

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

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

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

delattr(object, name)

   C'est un cousin 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".

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

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

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

dir([object])

   Sans arguments, 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 à une méthode "__dir__()", elle est appelée et doit
   donner une liste d'attributs. Cela permet aux objets implémentant
   "__getattr__()" ou "__getattribute__()" de personnaliser ce que
   donnera "dir()".

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

   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 jeu
     intéressant de noms plutôt qu'un ensemble consistant 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ées lorsque l'argument est une classe.

divmod(a, b)

   Prend deux nombres (non complexes) et donne 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 un 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)

   Donne un objet énumérant. *iterable* doit être une séquence, un
   *iterator*, ou tout autre objet supportant l'itération. La méthode
   "__next__()" de l'itérateur donné par "enumerate()" donne un tuple
   contenant un compte (démarrant à *start*, 0 par défaut) et les
   valeurs obtenues de l'itération sur *iterable*.

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

   Équivalent à :

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

eval(expression, globals=None, locals=None)

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

   The *expression* argument is parsed and evaluated as a Python
   expression (technically speaking, a condition list) using the
   *globals* and *locals* dictionaries 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
   *expression* is parsed. This means that *expression* normally has
   full access to the standard "builtins" module and restricted
   environments are propagated.  If the *locals* dictionary is omitted
   it defaults to the *globals* dictionary.  If both dictionaries are
   omitted, the expression is executed in the environment where
   "eval()" is called.  The return value is the result of the
   evaluated expression. Syntax errors are reported as exceptions.
   Example:

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

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

   Conseils : L'exécution dynamique d'instructions est gérée par la
   fonction "exec()". Les fonctions "globals()" et "locals()" donnent
   respectivement les dictionnaires globaux et locaux, qui peuvent
   être utiles lors de l'usage de "eval()" et "exec()".

   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.

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

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

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

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

   Note:

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

   Note:

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

filter(function, iterable)

   Construit un itérateur depuis les éléments d'*iterable* pour
   lesquels *function* donne vrai. *iterable* peut aussi bien être une
   séquence, un conteneur qui supporte 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(fonction, iterable)" est l'équivalent du
   générateur "(item for item in iterable if fonction(item))" si
   *fonction* 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 *fonction* donne
   "False".

class float([x])

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

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

      sign           ::= "+" | "-"
      infinity       ::= "Infinity" | "inf"
      nan            ::= "nan"
      numeric_value  ::= floatnumber | infinity | nan
      numeric_string ::= [sign] numeric_value

   Ici "floatnumber" est un nombre a virgule flottante littéral
   Python, décrit dans Nombres à virgule flottante littéraux. La casse
   n'y est pas significative, donc, par exemple, ""inf"", "" Inf"",
   ""INFINITY"", et "" iNfiNity"" sont tous des orthographes valides
   pour un infini positif.

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

   Pour un objet Python "x", "float(x)" est délégué à "x.__float__()".

   Dans argument, "0.0" est donné.

   Exemples :

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

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

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

format(value[, format_spec])

   Convertit une valeur en sa représentation "formatée", tel que
   décrit par *format_spec*. L'interprétation de *format_spec* dépend
   du type de la valeur, cependant il existe une syntaxe standard
   utilisée par la plupart des types natifs : Mini-langage de
   spécification de format.

   Par défaut, *format_spec* est une chaîne vide qui généralement
   donne le même effet qu'appeler "str(value)".

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

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

   Donne 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 leurs
   documentation.

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

getattr(object, name[, default])

   Donne 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, et que *default* est fourni, il est
   renvoyé, sinon l'exception "AttributeError" est levée.

globals()

   Donne une représentation de la table de symboles globaux sous forme
   d'un dictionnaire. C'est toujours le dictionnaire du module courant
   (dans une fonction ou méthode, c'est le module où elle est définie,
   et non le module d'où elle est appelée).

hasattr(object, name)

   Les arguments sont : un objet et une chaîne. 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" à été levée.)

hash(object)

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

   Note:

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

help([object])

   Invoque le système d'aide natif. (Cette fonction est destinée à
   l'usage en mode interactif.) Soi aucun argument n'est fourni, le
   système d'aide démarre dans l'interpréteur. Si l'argument est une
   chaîne, un module, une fonction, une classe, une méthode, un mot
   clef, ou un sujet de documentation pourtant ce nom est recherché,
   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.

   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éhensible
   et cohérente.

hex(x)

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

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

   Si vous voulez convertir un nombre entier en chaîne hexadécimale,
   en majuscule ou non, préfixée ou non, vous pouvez utiliser les
   moyens suivants :

   >>> '%#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'information.

   Voir aussi "int()" pour convertir une chaîne hexadécimale en un
   entier en lui spécifiant 16 comme 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)

   Donne 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 sont les durées de vie ne se chevauchent pas peuvent
   partager le même "id()".

   **CPython implementation detail:** This is the address of the
   object in memory.

input([prompt])

   Si l'argument *prompt* est donné, il est écrit sur la sortie
   standard sans le retour à la ligne final. La fonction lis ensuite
   une ligne sur l'entrée standard et la convertit en chaîne
   (supprimant le retour à la ligne final) quelle donne. 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.

class int(x=0)
class int(x, base=10)

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

   Si *x* n'est pas un nombre ou si *base* est fourni,  alors *x* doit
   être une chaîne, un "bytes", ou un "bytearray" représentant un
   entier littéral de base *base*. Le littéral peut être précédé d'un
   "+" ou d'un "-" (sans être séparés par un espace), et peut être
   entouré d'espaces. Un littéral de base *n* est composé des symboles
   de 0 à n-1 où "a" jusqu'à "z" (ou "A" à "Z") représentent les
   valeurs de 10 à 35. 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 littéral dans Python,
   donc la base sera 2, 8, 10, ou 16, 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.

isinstance(object, classinfo)

   Donne "True" si *object* est une instance de *classinfo*, ou d'une
   de ses classes filles, directe, indirecte, ou *virtuelle*. Si
   *object* n'est pas un objet du type donné, la fonction donne
   toujours "False". Si *classinfo* est un *tuple* de types (ou
   récursivement, d'autres *tuples*), donne "True" si *object* est une
   instance de n'importe quel de ces types. Si *classinfo* n'est ni un
   type ni un *tuple* de types (et récursivement), une exception
   "TypeError" est levée.

issubclass(class, classinfo)

   Donne "True" si *class* est une classe fille (directe, indirecte,
   ou *virtual*) de *classinfo*. Une classe est considérée sous-classe
   d'elle même. *classinfo* peut être un tuple de classes, dans ce cas
   la vérification sera faite pour chaque classe de *classinfo*. Dans
   tous les autres cas, "TypeError" est levée.

iter(object[, sentinel])

   Donne un objet *iterator*. Le premier argument est interprété très
   différemment en fonction de la présence du second argument. Sans
   second argument, *object* doit être une collection d'objets
   supportant le protocole d'itération (la méthode "__iter__()"), ou
   supportant le protocole des séquences (la méthode "getitem()", avec
   des nombres entiers commençant par "0" comme argument). S'il ne
   supporte aucun de ces protocoles, "TypeError" est levée. Si le
   second argument *sentinel* est fourni, *objet* doit être appelable.
   L'itérateur créé dans ce cas appellera *object* dans argument à
   chaque appel de "__next__()", si la valeur reçue est égale à
   *sentinel* "StopIteration" est levée, autrement la valeur est
   donnée.

   Voir aussi Les types itérateurs.

   Une autre application utile de la deuxième forme de "iter()" est de
   lire les lignes d'un fichier jusqu'à ce qu'un certaine ligne soit
   atteinte. L'exemple suivant lis un fichier jusqu'à ce que
   "readline()" donne une ligne vide :

      with open('mydata.txt') as fp:
          for line in iter(fp.readline, ''):
              process_line(line)

len(s)

   Donne la longueur (nombre d'éléments) d'un objet. L'argument peut
   être une séquence (tel qu'une chaîne, un objet  "bytes", "tuple",
   "list" ou "range") ou une collection (tel qu'un "dict", "set" ou
   "frozenset").

class list([iterable])

   Plutôt qu'être une fonction, "list" est en fait un type de séquence
   variable, tel que documenté dans Listes et Types séquentiels —
   list, tuple, range.

locals()

   Met à jour et donne un dictionnaire représentant la table des
   symboles locaux. Les variables libres sont données par "locals()"
   lorsqu'elle est appelée dans le corps d'une fonction, mais pas dans
   le corps d'une classe.

   Note:

     Le contenu de ce dictionnaire ne devrait pas être modifié, les
     changements peuvent ne pas affecter les valeurs des variables
     locales ou libres utilisées par l'interpréteur.

map(function, iterable, ...)

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

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

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

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

   Elle accepte deux arguments par mot clef optionnels. L'argument
   *key* spécifie une fonction à un argument permettant de trier comme
   pour "list.sort()". L'argument *default* quant à lui fournit 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 donné. C'est cohérent avec d'autres outils
   préservant une stabilité lors du tri, tel que "sorted(iterable,
   key=keyfunc, reverse=True)[0]" et "heapq.nlargest(1, iterable,
   key=keyfunc)".

   Nouveau dans la version 3.4: L'argument exclusivement par mot clef
   *default*.

memoryview(obj)

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

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

   Donne 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 *iterable*. Le plus
   petit élément de l'itérable est donné. Si au moins deux arguments
   positionnels sont fournis le plus petit argument positionnel est
   donné.

   Elle accepte deux arguments par mot clef optionnels. L'argument
   *key* spécifie une fonction à un argument permettant de trier comme
   pour "list.sort()". L'argument *default* quant à lui fournit 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 donne le premier.
   C'est cohérent avec d'autres outils préservant une stabilité lors
   du tri, tel que "sorted(iterable, key=keyfunc)[0]" et
   "heapq.nsmallest(1, iterable, key=keyfunc)".

   Nouveau dans la version 3.4: L'argument exclusivement par mot clef
   *default*.

next(iterator[, default])

   Donne l'élément suivant d'*iterator* en appelant sa méthode
   "__next__()". Si *default* est fourni, il sera donné si l'itérateur
   est épuisé, sinon "StopIteration" est levée.

class object

   Donne un objet vide. "object" est la classe parente de toute les
   classes. C'est elle qui porte les méthodes communes à toutes les
   instances de classes en Python. Cette fonction n'accepte aucun
   argument.

   Note:

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

oct(x)

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

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

   Si vous voulez convertir un nombre entier en chaîne octale, avec ou
   sans le préfixe "0o", vous pouvez utiliser les moyens suivants.

   >>> '%#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'information.

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

   Ouvre *file* et donne un *file object* correspondant. Si le fichier
   ne peut pas être ouvert, une "OSError" est levée.

   *file* est un *path-like object* 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 *I/O* renvoyé, sauf si *closefd* est mis à "False".)

   *mode* est une chaîne optionnelle permettant de spécifier dans quel
   mode le fichier est ouvert. Par défaut, *mode* vaut "'r'" qui
   signifie "ouvrir en lecture pour du texte". "'w'" est aussi une
   valeur classique, permettant d'écrire (vidant le fichier s'il
   existe), ainsi que "'x'" permettant une création exclusive et "'a'"
   pour ajouter à la fin du fichier (qui sur certains systèmes Unix
   signifie que *toutes* les écritures seront des ajouts en fin de
   fichier peu importe la position demandée). En mode texte, si
   *encoding* n'est pas spécifié l'encodage utilisé est dépendant de
   la plateforme : "locale.getpreferredencoding(False)" est appelée
   pour obtenir l'encodage de la locale actuelle. (Pour lire et écrire
   des octets bruts, utilisez le mode binaire en laissant *encoding*
   non spécifié.) Les modes disponibles sont :

   +-----------+-----------------------------------------------------------------+
   | Caractère | Signification                                                   |
   |===========|=================================================================|
   | "'r'"     | ouvre en lecture (par défaut)                                   |
   +-----------+-----------------------------------------------------------------+
   | "'w'"     | ouvre en écriture, tronquant le 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 un fichier pour le modifier (lire et écrire)              |
   +-----------+-----------------------------------------------------------------+
   | "'U'"     | mode *universal newlines* (obsolète)                            |
   +-----------+-----------------------------------------------------------------+

   Les mode par défaut est "'r'" (ouvrir pour lire du texte, synonyme
   de "'rt'"). Pour un accès en lecture écriture binaire, le mode
   "'w+b'" ouvre et vide le fichier. "'r+b'" ouvre le fichier sans le
   vider.

   Tel que mentionné dans Aperçu, Python fait la différence entre les
   I/O binaire et texte. 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 l'éventuelle notion de fichier texte du
     système sous-jacent, tout le traitement est effectué par Python
     lui même, et est ainsi indépendant de la plateforme.

   *buffering* est un entier optionnel permettant de configurer
   l'espace tampon. Donnez 0 pour désactiver l'espace tampon
   (seulement autorisé en mode binaire), 1 pour avoir un *buffer*
   travaillant ligne par ligne (seulement disponible en mode texte),
   ou un entier supérieur à 1 pour donner la taille en octets d'un
   tampon de taille fixe. Sans l'argument *buffering*, les
   comportements par défaut sont les suivants :

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

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

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

   *errors* est une chaîne facultative spécifiant comment les erreurs
   d'encodage et de décodages sont gérées, ce n'est pas utilisable en
   mode binaire. Pléthore 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 chaque octet incorrect par un
     code caractère de la zone *Private Use Area* d'Unicode, de
     *U+DC80* à *U+DCFF*. Ces codes caractères privés seront ensuite
     transformés dans les mêmes octets erronés si le gestionnaire
     d'erreur "surrogateescape" est utilisé lors de l'écriture de la
     donnée. C'est utile pour traiter des fichiers d'un encodage
     inconnu.

   * "'xmlcharrefreplace'" est seulement supporté à l'écriture vers un
     fichier. Les caractères non gérés par l'encodage sont remplacés
     par une référence de caractère XML "&#nnn;".

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

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

   *newline* contrôle comment le mode *universal newlines* fonctionne
   (seulement en mode texte). Il eut ê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 terminer par
     "'\n'", "'\r'", ou "'\r\n'", qui sont remplacés par "'\n'", avant
     d'être données à l'appelant. S'il vaut "'*'", le mode *universal
     newline* est activé mais les fin de lignes ne sont pas remplacés.
     S'il a n'importe quel autre valeur autorisée, les lignes sont
     seulement terminées par la chaîne donnée, qui est rendue tel
     qu'elle.

   * 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 remplacent
     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) sans
   quoi 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 donner un descripteur de fichier ouvert
   (fournir "os.open" en temps qu'*opener* aura le même effet que
   donner "None").

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

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

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

   Le type de *file object* donné 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 donne une classe fille de
   "io.TextIOBase" (spécifiquement : "io.TextIOWrapper"). Lors de
   l'ouverture d'un fichier en mode binaire avec tampon, la classe
   donnée sera une fille de "io.BufferedIOBase". La classe exacte
   varie : en lecture en mode binaire elle donne 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 donnée.

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

      Modifié dans la version 3.3:

      * Le paramètre *opener* a été ajouté.

      * Le mode "'x'" a été ajouté.

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

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

      Modifié dans la version 3.4:

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

   Deprecated since version 3.4, will be removed in version 4.0: Le
   mode "'U'".

      Modifié dans la version 3.5:

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

      * Le gestionnaire d'erreurs "'namereplace'" a été ajouté.

      Modifié dans la version 3.6:

      * Ajout du support des objets implémentant "os.PathLike".

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

ord(c)

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

pow(x, y[, z])

   Donne *x* puissance *y*, et si *z* est présent, donne *x* puissance
   *y* modulo *z* (calculé de manière plus efficiente que "pow(x, y) %
   z"). La forme à deux arguments est équivalent à "x**y".

   Les arguments doivent être de types numériques. Avec des opérandes
   de différents types, les mêmes règles de coercition que celles des
   opérateurs arithmétiques binaires s'appliquent. Pour des opérandes
   de type "int", le résultat sera de même type que les opérandes
   (après coercition) sauf si le second argument est négatif, dans ce
   cas, les arguments sont convertis en "float", et le résultat sera
   un "float" aussi. Par exemple, "10**2" donne "100", alors que
   "10**-2" donne "0.01". Si le second argument est négatif, le
   troisième doit être omis. Si *z* est fourni, *x* et *y* doivent
   être des entiers et *y* positif.

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

   Écrit *objects* dans le flux texte *file*, séparés par *sep* et
   suivis de *end*. *sep*, *end*, *file*, et *flush*, s'ils sont
   présents, doivent être données par mot clef.

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

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

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

   Modifié dans la version 3.3: Ajout de l'argument par mot clef
   *flush*.

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

   Donne 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*
   quand à elle permet de supprimer la valeur d'un attribut, et *doc*
   créé une *docstring* pour l'attribut.

   Une utilisation typique : 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" appellera le *getter*, "c.x =
   value" invoquera le *setter*, et "del x" le *deleter*.

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

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

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

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

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

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

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

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

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

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

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

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

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

   Plutôt qu'être une fonction, "range" est en fait une séquence
   immuable, tel que documenté dans Ranges et Types séquentiels —
   list, tuple, range.

repr(object)

   Donne une chaîne contenant une représentation affichable de
   l'objet. Pour de nombreux types, cette fonction essaye de donner
   une chaîne qui donnera à son tour un objet de mène valeur
   lorsqu'elle est passée à "eval()", sinon la représentation sera une
   chaîne entourée de chevrons contenant le nom du type et quelques
   informations supplémentaires souvent le nom et l'adresse de
   l'objet. Une classe peut contrôler ce que cette fonction donne pour
   ses instances en définissant une méthode "__repr__()".

reversed(seq)

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

round(number[, ndigits])

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

   Pour les types natifs supportant "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 bug, mais dû au fait que la
     plupart des fractions de décimaux ne peuvent pas être représentés
     exactement en nombre a virgule flottante. Voir Arithmétique en
     nombres à virgule flottante : problèmes et limites pour plus
     d'information.

class set([iterable])

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

   D'autres conteneurs existent, typiquement : "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 peut nommer
   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".

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

   Donne un objet "slice" représentant un ensemble d'indices spécifiés
   par "range(start, stop, step)". Les arguments *start* et *step*
   valent "None" par défaut. Les objets *slice* (tranches) ont les
   attributs suivants en lecture seule : "start", "stop", et "step"
   qui valent simplement les trois arguments (ou leurs valeur par
   défaut). Ils n'ont pas d'autres fonctionnalité explicite, cependant
   ils sont utilisés par *Numerical Python* et d'autres bibliothèques
   tierces. Les objets *slice* sont aussi générés par la notation par
   indices étendue. Par exemple "a[start:stop:step]" ou "a[start:stop,
   i]". Voir "itertools.islice()" pour une version alternative donnant
   un itérateur.

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

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

   A deux arguments optionnels qui doivent être fournis par mot clef.

   *key* specifies a function of one argument that is used to extract
   a comparison key from each element in *iterable* (for example,
   "key=str.lower").  The default value is "None" (compare the
   elements directly).

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

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

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

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

@staticmethod

   Transforme une méthode en méthode statique.

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

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

   La forme "@staticmethod" est un *decorator* de fonction. Voir la
   description des définitions de fonction dans Définition de
   fonctions pour plus de détails.

   Elle peut être appelée soit sur une classe (tel que "C.f()") ou sur
   une instance (tel que "C().f()"). L'instance est ignorée, sauf pour
   sa classe.

   Les méthodes statiques en Python sont similaires à celles trouvées
   en Java ou en C++. Consultez "classmethod()" pour une variante
   utile pour 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 voudriez
   une référence à la fonction depuis le corps d'une classe, et
   souhaiteriez éviter sa transformation en méthode d'instance. Pour
   ces cas, faites comme suit :

      class C:
          builtin_open = staticmethod(open)

   Pour plus d'informations sur les méthodes statiques, consultez la
   documentation de la hiérarchie des types standards dans Hiérarchie
   des types standards.

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

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

   "str" est la *class* 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])

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

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

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

   Donne un objet mandataire (*proxy object* en anglais) déléguant les
   appels de méthode à une classe parente ou sœur de type *type*.
   C'est utile pour accéder à des méthodes héritées et substituées
   dans la classe. L'ordre de recherche est le même que celui utilisé
   par "getattr()" sauf que *type* lui même est sauté.

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

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

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

   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 chaque méthode doit avoir la même signature lors de
   leur appels 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)

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

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

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

tuple([iterable])

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

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

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

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

   Avec trois arguments, renvoie un nouveau type. C'est
   essentiellement une forme dynamique de l'instruction "class". La
   chaîne *name* est le nom de la classe et deviendra l'attribut
   "__name__" ; le *tuple* *bases* contient les classes mères et
   deviendra l'attribut "__bases__" ; et le dictionnaire *dict* est
   l'espace de nommage contenant les définitions du corps de la
   classe, il est copié vers un dictionnaire standard pour devenir
   l'attribut "__dict__". Par exemple, les deux instructions suivantes
   créent deux instances identiques de "type" :

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

   Voir aussi Objets type.

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

vars([object])

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

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

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

zip(*iterables)

   Construit un itérateur agrégeant les éléments de tous les
   itérables.

   Donne un itérateur de tuples, où le *i*-ième tuple contiens le
   *i*-ième élément de chacune des séquences ou itérables fournis.
   L'itérateur s'arrête lorsque le plus petit itérable fourni est
   épuisé. Avec un seul argument itérable, elle donne un itérateur sur
   des *tuples* d'un élément. Sans arguments, elle donne un itérateur
   vide. Équivalent à :

      def zip(*iterables):
          # zip('ABCD', 'xy') --> Ax By
          sentinel = object()
          iterators = [iter(it) for it in iterables]
          while iterators:
              result = []
              for it in iterators:
                  elem = next(it, sentinel)
                  if elem is sentinel:
                      return
                  result.append(elem)
              yield tuple(result)

   Il est garanti que les itérables soient évalués de gauche a droite.
   Cela rend possible de grouper une séquence de données en groupes de
   taille *n* via "zip(*[iter(s)]*n)". Cela duplique le *même*
   itérateur "n" fois tel que le tuple 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()" ne devrait être utilisée avec des itérables de longueur
   différente que lorsque les dernières données des itérables les plus
   longs peuvent être ignorées. Si c'est valeurs sont importantes,
   utilisez plutôt "itertools.zip_longest()".

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

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

__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 *import hooks* (voir la **PEP 302**)
   pour le même résultat sans gêner 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) implique de n'effectuer que 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 le plus haut (le nom jusqu'au premier point)
   est donné, et *pas* le module nommé par *name*. Cependant,
   lorsqu'un argument *fromlist* est fourni, le module nommé par
   *name* est donné.

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

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

   L'instruction "import ham.ham" appelle :

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

   Notez comment "__import__()" donne le module le plus haut ici 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 donné 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: Des valeurs négatives pour *level* ne
   sont plus gérées (ce qui change la valeur par défaut pour 0).

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