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)

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

all(iterable)

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

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

any(iterable)

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

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

ascii(object)

Renvoie, tout comme repr(), une chaîne contenant une représentation affichable d'un objet, en transformant les caractères non ASCII renvoyé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'

Pour contrôler l'affichage du préfixe 0b, 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'informations.

class bool([x])

Renvoie 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 renvoie False, sinon, elle renvoie True. La classe bool hérite de la classe int (voir Types numériques — int, float, complex). Il n'est pas possible d'en hériter, ses seules instances sont False et True (voir Valeurs booléennes).

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

breakpoint(*args, **kws)

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

Lève un auditing event builtins.breakpoint avec l'argument breakpointhook.

Nouveau dans la version 3.7.

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

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

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

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

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

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

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

Sans argument, un tableau vide est créé.

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

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

Renvoie un nouvel objet bytes, qui est une séquence immuable de nombres entiers dans l'intervalle 0 <= x < 256. Un bytes est une version immuable de bytearray — avec les mêmes méthodes d'accès, et le même comportement lors de l'indexation ou 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)

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

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

chr(i)

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

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

@classmethod

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

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

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

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

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

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

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

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

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

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

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

The optional arguments flags and dont_inherit control which compiler options should be activated and which future features should be allowed. If neither is present (or both are zero) the code is compiled with the same flags that affect the code that is calling compile(). If the flags argument is given and dont_inherit is not (or is zero) then the compiler options and 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 flags (future features and compiler options) in the surrounding code are ignored.

Compiler options and future statements are specified by bits which can be bitwise ORed together to specify multiple options. The bitfield required to specify a given future feature can be found as the compiler_flag attribute on the _Feature instance in the __future__ module. Compiler flags can be found in ast module, with PyCF_ prefix.

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

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

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

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

Note

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

Avertissement

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

Modifié dans la version 3.2: autorise l'utilisation de retours à la ligne Mac et Windows. Par ailleurs, la chaîne donnée à 'exec' n'a plus besoin de terminer par un retour à la ligne. Ajout du paramètre optimize.

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

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

class complex([real[, imag]])

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

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

Note

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

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

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

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

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 tuple, ainsi que le module collections.

dir([object])

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

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

Si l'objet ne fournit pas de méthode __dir__(), la fonction fait de son mieux en rassemblant les informations de l'attribut __dict__ de l'objet, 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 ensemble de noms pertinents plutôt qu'un ensemble exhaustif et rigoureusement défini, son comportement peut aussi changer d'une version à l'autre. Par exemple, les attributs de méta-classes ne sont pas donnés lorsque l'argument est une classe.

divmod(a, b)

Prend deux nombres (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)

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

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

Équivalent à :

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

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

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

L'argument expression est analysé et évalué comme une expression Python (techniquement, une condition list) en utilisant les dictionnaires globals et locals comme espaces de nommage global et local. Si le dictionnaire globals est présent mais ne contient pas de valeur pour la clé __builtins__, une référence au dictionnaire du module builtins y est insérée avant qu'expression ne soit évaluée. Cela signifie qu'expression a 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 avec les dictionnaires globals et locals dans l'environnement où eval() est appelée. Note, eval() n'a pas accès aux portées imbriquées (non locales) dans l'environnement englobant.

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

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

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

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

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

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

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

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

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

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

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

Note

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

Note

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

filter(function, iterable)

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

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

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

class float([x])

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

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

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
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 général x, float(x) est délégué à x.__float__(). Si __float__() n'est pas défini alors il est délégué à __index__().

Sans argument, 0.0 est renvoyé.

Exemples :

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

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

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

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

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

format(value[, format_spec])

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

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

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

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

class frozenset([iterable])

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

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

getattr(object, name[, default])

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

globals()

Renvoie 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 de caractères. Le résultat est True si la chaîne est le nom d'un des attributs de l'objet, sinon False (l'implémentation appelle getattr(object, name) et regarde si une exception AttributeError a été levée).

hash(object)

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

Note

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

help([object])

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

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

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

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

hex(x)

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

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

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

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

Voir aussi format() pour plus d'informations.

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

Note

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

id(object)

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

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

Raises an auditing event builtins.id with argument id.

input([prompt])

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

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

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

Lève un auditing event builtins.input avec l'argument prompt avant de lire l'entrée.

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

class int([x])

class int(x, base=10)

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

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 une 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.8: revient à __index__() si __int__() n'est pas défini.

isinstance(object, classinfo)

Renvoie True si object est une instance de classinfo, ou d'une de ses classes filles, directe, indirecte, ou abstraite. Si object n'est pas un objet du type donné, la fonction renvoie toujours False. Si classinfo est un n-uplet de types (ou récursivement, d'autres n-uplets), renvoie True si object est une instance de n'importe quel de ces types. Si classinfo n'est ni un type ni un n-uplet de types (et récursivement), une exception TypeError est levée.

issubclass(class, classinfo)

Renvoie True si class est une classe fille (directe, indirecte ou abstraite) de classinfo. Une classe est considérée sous-classe d'elle-même. classinfo peut être un n-uplet de classes, 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])

Renvoie un objet itérateur. La signification du premier argument dépend grandement de la présence du second. Sans cet argument, object doit être une collection d'objets prenant en charge le protocole d'itération (la méthode __iter__()) ou le protocole des séquences (la méthode getitem(), avec des nombres entiers commençant par 0 comme argument). S'il ne gère aucun de ces protocoles, TypeError est levée. Si le second argument sentinel est fourni, object doit être appelable. L'itérateur créé dans ce cas appelle object sans argument à chaque appel de __next__(). Si la valeur reçue est égale à sentinel StopIteration est levée, sinon la valeur est renvoyé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)

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

CPython implementation detail: len raises OverflowError on lengths larger than sys.maxsize, such as range(2 ** 100).

class list([iterable])

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

locals()

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

Note

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

map(function, iterable, ...)

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

max(iterable, *[, key, default])

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

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

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

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

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

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

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

class memoryview(obj)

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

min(iterable, *[, key, default])

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

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

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

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

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

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

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

next(iterator[, default])

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

class object

Renvoie un objet vide. object est la classe parente de toutes 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 arbitraires à une instance d'object.

oct(x)

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

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

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

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

Voir aussi format() pour plus d'informations.

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

Open file and return a corresponding file object. If the file cannot be opened, an OSError is raised. See Lecture et écriture de fichiers for more examples of how to use this function.

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

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

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

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

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

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

Note

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

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

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

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

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

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

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

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

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

• 'surrogateescape' représente 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 pris en charge à l'écriture vers un fichier. Les caractères non gérés par l'encodage sont remplacés par une entité XML de la forme &#nnn;.

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

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

newline contrôle comment le mode retours à la ligne universels fonctionne (seulement en mode texte). Il peut être None, '', '\n', '\r', et '\r\n'. Il fonctionne comme suit :

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

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

Si closefd est False et qu'un descripteur de fichier est fourni plutôt qu'un nom de fichier, le descripteur de fichier sera laissé ouvert lorsque le fichier sera fermé. Si un nom de fichier est donné, closefd doit rester True (la valeur par défaut) 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 renvoyer un descripteur de fichier ouvert (fournir os.open en tant qu'opener aura le même effet que donner None).

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

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

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

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

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

Lève un auditing event open avec les arguments file, mode, flags.

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

Modifié dans la version 3.3:

• ajout du paramètre opener.

• ajout du mode 'x'.

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

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

Modifié dans la version 3.4:

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

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

Modifié dans la version 3.5:

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

• ajout du gestionnaire d'erreurs 'namereplace'.

Modifié dans la version 3.6:

• prise en charge des objets implémentant os.PathLike.

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

ord(c)

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

pow(base, exp[, mod])

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

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.

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

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

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

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

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

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

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

Tous les arguments positionnels sont convertis en chaîne comme le fait str(), puis écrits sur le flux, séparés par sep et terminés par end. sep et end doivent être des chaînes, ou None, indiquant de prendre les valeurs par défaut. Si aucun objects n'est donné print() é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 nommé flush.

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

Renvoie un attribut propriété.

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class range(stop)

class range(start, stop[, step])

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

repr(object)

Renvoie une chaîne contenant une représentation affichable de l'objet. Pour de nombreux types, cette fonction essaye de renvoyer une chaîne qui donnera à son tour un objet de même 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 renvoie pour ses instances en définissant une méthode __repr__().

reversed(seq)

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

round(number[, ndigits])

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

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

class set([iterable])

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

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

setattr(object, name, value)

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

Renvoie une tranche 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 « tranches » ont les attributs suivants en lecture seule : start, stop, et step qui valent simplement les trois arguments (ou leurs valeurs par défaut). Ils n'ont pas d'autre fonctionnalité explicite, cependant ils sont utilisés par Numerical Python et d'autres bibliothèques tierces. Les objets « tranches » sont aussi générés par la notation par indice étendue. Par exemple a[start:stop:step] ou a[start:stop, i]. Voir itertools.islice() pour une version alternative renvoyant un itérateur.

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

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

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

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

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

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

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

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

@staticmethod

Transforme une méthode en méthode statique.

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

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

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

Une méthode statique peut être appelée sur une classe (par exemple, C.f()) comme sur une instance (par exemple, 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')

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

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

sum(iterable, /, start=0)

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

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

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

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

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

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

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

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

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

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

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 appel dans tous les cas (parce que l'ordre des appels est déterminée à l'exécution, parce que l'ordre s'adapte aux changements dans la hiérarchie, et parce que l'ordre peut inclure des classes sœurs inconnues avant l'exécution).

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

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

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

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

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

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

class tuple([iterable])

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

class type(object)

class type(name, bases, dict)

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

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

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

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

Voir aussi Objets type.

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

vars([object])

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

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

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

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

zip(*iterables)

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

Renvoie un itérateur de n-uplets, où le i^e n-uplet contient le i^e é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 renvoie un itérateur sur des n-uplets d'un élément. Sans argument, elle renvoie 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 à 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 ; par conséquent le n-uplet obtenu contient le résultat de n appels à l'itérateur. Cela a pour effet de diviser la séquence en morceaux de taille n.

zip() ne doit être utilisée avec des itérables de longueurs différentes que lorsque les dernières données des itérables les plus longs peuvent être ignorées. Si ces 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ée pour les importations (import hooks, voir la PEP 302) pour le même résultat sans perturber du code s'attendant à trouver l'implémentation par défaut. L'usage direct de __import__() est aussi déconseillé en faveur de importlib.import_module().

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

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

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

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

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

L'instruction import spam.ham appelle :

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

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

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

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

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

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

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

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

Notes

1

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