Ce document est relatif à une vieille version de Python qui n'est plus soutenue. Mettez à jour votre version et lisez Bienvenue sur la documentation de la version stable actuelle de Python.

# 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()` | `delattr()` | `hash()` | `memoryview()` | `set()`
`all()` | `dict()` | `help()` | `min()` | `setattr()`
`any()` | `dir()` | `hex()` | `next()` | `slice()`
`ascii()` | `divmod()` | `id()` | `object()` | `sorted()`
`bin()` | `enumerate()` | `input()` | `oct()` | `staticmethod()`
`bool()` | `eval()` | `int()` | `open()` | `str()`
`breakpoint()` | `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()` |

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

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

`breakpoint`(*args, **kws)

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

  Nouveau dans la version 3.7.

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)

  Return `True` if the object argument appears callable, `False` if not. If this returns `True`, it is still possible that a call fails, but if it is `False`, calling object will never succeed. Note that classes are callable (calling a class returns a new instance); instances are callable if their class has a `__call__()` method.

  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 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 c'est elles sont vous avez besoin, regardez du côté de `staticmethod()`.

  Pour plus d'informations sur les méthodes de classe, consultez 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).

  Les arguments optionnels flags et dont_inherit contrôlent quelle instructions future affecte la compilation de source. Si aucun des deux n'est présent (ou que les deux sont à 0) le code est compilé avec les mêmes instructions future que le code appelant `compile()`. Si l'argument flags est fourni mais que dont_inherit ne l'est pas (ou vaut 0), alors les instructions futures utilisées seront celles spécifiées 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é seul -- les instructions futures déclarées autour de l'appel à compile sont ignorées.

  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[, locals]])

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

  L'argument expression est analysé et évalué comme une expression Python (techniquement, une condition list) en utilisant les dictionnaires globals et locals comme espaces de nommage globaux et locaux. Si le dictionnaire globals est présent mais ne contient pas de valeur pour la clé `'__builtins__'`, une référence au dictionnaire du module `builtins` y est inséré avant qu'expression ne soit évalué. Cela signifie qu'expression à normalement un accès complet à tout le module `builtins`, et que les environnements restreints sont propagés. Si le dictionnaire locals est omis, sa valeur par défaut est le dictionnaire globals. Si les deux dictionnaires sont omis, l'expression est exécutée dans l'environnement où `eval()` est appelé. La valeur donnée par eval est le résultat de l'expression évaluée. Les erreurs de syntaxe sont rapportées via des exceptions. Exemple :

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

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

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

  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 uniquement positionnels. Pour plus d'informations, voir La FAQ sur les arguments positionels.

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

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

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

`isinstance`(object, classinfo)

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

`issubclass`(class, classinfo)

  Return `True` if class is a subclass (direct, indirect or virtual) of classinfo. A class is considered a subclass of itself. classinfo may be a tuple of class objects, in which case every entry in classinfo will be checked. In any other case, a `TypeError` exception is raised.

`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 construire un lecteur par blocs. Par exemple, lire des blocs de taille fixe d'une base de donnée binaire jusqu'à ce que la fin soit atteinte :

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

`len`(s)

  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. Notez qu’au niveau d’un module, `locals()` `globals()` sont le même dictionnaire.

  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.

class `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)

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

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

  Note

  Python ne dépend pas de 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 3.9: 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.

class `range`(stop)
class `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 spécifie une fonction d'un argument utilisé pour extraire une clef de comparaison de chaque élément de l'itérable (par exemple, `key=str.lower`). La valeur par défaut est `None` (compare les éléments directement).

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

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

  La fonction native `sorted()` est garantie stable. Un tri est stable s'il 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. Consultez 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()`).

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

  In addition to method lookups, `super()` also works for attribute lookups. One possible use case for this is calling descriptors in a parent or sibling class.

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

class `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 points d'entrées pour les importations (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.