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(x)¶
Return the absolute value of a number. The argument may be an integer, a floating-point number, or an object implementing
__abs__()
. If the argument is a complex number, its magnitude is returned.
- aiter(async_iterable)¶
Renvoie un itérateur asynchrone pour l'itérable asynchrone donné. Équivaut à appeler
x.__aiter__()
.Remarque : contrairement à
iter()
,aiter()
n'a pas de variante à 2 arguments.Ajouté dans la version 3.10.
- all(iterable)¶
Renvoie
True
si tous les éléments de iterable sont vrais (ou s'il est vide). Équivaut à :def all(iterable): for element in iterable: if not element: return False return True
- awaitable anext(async_iterator)¶
- awaitable anext(async_iterator, default)
Lorsqu'il est attendu, renvoie l'élément suivant à partir de l'itérateur asynchrone donné, ou default s'il est fourni et que l'itérateur est épuisé.
Il s'agit de la variante asynchrone de la fonction native
next()
et elle se comporte de la même manière.Renvoie un attendable en appelant la méthode
__anext__()
de async_iterator. L'attente renvoie la prochaine valeur de l'itérateur. Si default est fourni, il est renvoyé si l'itérateur est épuisé, sinonStopAsyncIteration
est levée.Ajouté dans la version 3.10.
- any(iterable)¶
Renvoie
True
si au moins un élément de iterable est vrai.False
est renvoyé dans le cas où iterable est vide. Équivaut à :def any(iterable): for element in iterable: if element: return True return False
- ascii(object)¶
Renvoie, tout comme
repr()
, une chaîne contenant une représentation d'un objet destinée à l'affichage, mais en transformant les caractères non ASCII renvoyés parrepr()
par l'utilisation de séquences d'échappement\x
,\u
ou\U
. Cela génère une chaîne similaire à ce que renvoierepr()
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'
Vous pouvez contrôler l'affichage du préfixe
"0b"
à l'aide d'un des moyens suivants.>>> format(14, '#b'), format(14, 'b') ('0b1110', '1110') >>> f'{14:#b}', f'{14:b}' ('0b1110', '1110')
Voir aussi
format()
pour plus d'informations.
- class bool(object=False, /)¶
Return a Boolean value, i.e. one of
True
orFalse
. The argument is converted using the standard truth testing procedure. If the argument is false or omitted, this returnsFalse
; otherwise, it returnsTrue
. Thebool
class is a subclass ofint
(see Types numériques — int, float, complex). It cannot be subclassed further. Its only instances areFalse
andTrue
(see Boolean Type - bool).Modifié dans la version 3.7: The parameter is now positional-only.
- breakpoint(*args, **kws)¶
This function drops you into the debugger at the call site. Specifically, it calls
sys.breakpointhook()
, passingargs
andkws
straight through. By default,sys.breakpointhook()
callspdb.set_trace()
expecting no arguments. In this case, it is purely a convenience function so you don't have to explicitly importpdb
or type as much code to enter the debugger. However,sys.breakpointhook()
can be set to some other function andbreakpoint()
will automatically call that, allowing you to drop into the debugger of choice. Ifsys.breakpointhook()
is not accessible, this function will raiseRuntimeError
.Par défaut, le comportement de la fonction
breakpoint()
peut être changé par la variable d'environnementPYTHONBREAKPOINT
. Voirsys.breakpointhook()
pour plus de détails.Notez que ceci n'est plus garanti si la fonction
sys.breakpointhook()
a été remplacée.Lève un évènement d'audit
builtins.breakpoint
avec l'argumentbreakpointhook
.Ajouté dans la version 3.7.
- class bytearray(source=b'')
- class bytearray(source, encoding)
- class bytearray(source, encoding, errors)
Renvoie un nouveau tableau d'octets. La classe
bytearray
est une séquence mutable de nombres entiers dans l'intervalle 0 ≤ x < 256. Il possède la plupart des méthodes des séquences variables, décrites dans Types de séquences mutables, ainsi que la plupart des méthodes de la classebytes
, 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éthodestr.encode()
;si c'est un entier, le tableau a cette taille et est initialisé d'octets null ;
si c'est un objet conforme à l'interface tampon, un tampon en lecture seule de l'objet est utilisé pour initialiser le tableau ;
si c'est un itérable, il doit itérer sur des nombres entier dans l'intervalle
0 <= x < 256
, qui sont utilisés pour initialiser le contenu du tableau.
Sans argument, un tableau vide est créé.
Voir Séquences Binaires — bytes, bytearray, vue mémoire et Objets bytearray.
- class bytes(source=b'')
- class bytes(source, encoding)
- 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
. Unbytes
est une version immuable debytearray
— avec les mêmes méthodes d'accès, et le même comportement lors de l'indexation ou du découpage.En conséquence, les arguments du constructeur sont les mêmes que pour
bytearray()
.Les objets bytes peuvent aussi être créés à partir de littéraux, voir Littéraux de chaînes de caractères et de suites d'octets.
Voir aussi Séquences Binaires — bytes, bytearray, vue mémoire, Objets bytes, et Opérations sur les bytes et bytearray.
- callable(object)¶
Return
True
if the object argument appears callable,False
if not. If this returnsTrue
, it is still possible that a call fails, but if it isFalse
, 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.Ajouté dans la version 3.2: cette fonction a d'abord été supprimée avec Python 3.0 puis elle a été remise dans Python 3.2.
- chr(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 quechr(8364)
renvoie'€'
. Il s'agit de la réciproque deord()
.L'intervalle valide pour cet argument est de
0
à1114111
(0x10FFFF
en base 16). Une exceptionValueError
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 (commeC().f()
). L'instance est ignorée, sauf pour déterminer sa classe. Si la méthode est appelée sur une instance de classe fille, c'est la classe fille qui sera donnée en premier argument implicite.Les méthodes de classe sont différentes des méthodes statiques du C++ ou du Java. Si ce sont elles dont vous avez besoin, regardez du côté de
staticmethod()
dans cette section. Voir aussi Hiérarchie des types standards.Modifié dans la version 3.9: les méthodes de classe peuvent encapsuler d'autres descripteurs comme
property()
.Modifié dans la version 3.10: Class methods now inherit the method attributes (
__module__
,__name__
,__qualname__
,__doc__
and__annotations__
) and have a new__wrapped__
attribute.Deprecated since version 3.11, removed in version 3.13: les méthodes de classe ne peuvent plus encapsuler d'autres descripteurs comme
property()
.
- compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)¶
Compile source en un objet code ou objet AST. Les objets code peuvent être exécutés par
exec()
oueval()
. source peut être une chaîne, une chaîne d'octets, ou un objet AST. Consultez la documentation du moduleast
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 queNone
sont affichés).Les arguments optionnels flags et dont_inherit contrôlent quelles options de compilation seront activées et quelles instructions future seront autorisées. Si aucun des deux n'est présent (ou que les deux sont à 0), le code est compilé avec les mêmes paramètres que le code appelant
compile()
. Si l'argument flags est fourni alors que dont_inherit ne l'est pas (ou vaut 0), les options de compilation et les instructions futures utilisées sont celles définies par flags en plus de celles qui auraient été utilisées. Si dont_inherit est un entier différent de zéro, flags est utilisé tel quel — les flags (instructions futures et options de compilation) valables pour le code encadrant compile sont ignorés.Les instructions future sont contrôlées par des bits, il est ainsi possible d'en activer plusieurs en les combinant avec un OU binaire. Les bits requis pour demander une certaine fonctionnalité se trouvent dans l'attribut
compiler_flag
de la classeFeature
du module__future__
. Les options du compilateur se trouvent dans le moduleast
, avec le préfixePyCF_
.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__
estTrue
),1
(lesassert
sont supprimés,__debug__
estFalse
) ou2
(les chaines de documentation sont également supprimées).Cette fonction lève une
SyntaxError
si la source n'est pas valide, etValueError
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 argumentssource
etfilename
. 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 modulecode
.Avertissement
il est possible de faire planter l'interpréteur Python avec des chaînes suffisamment grandes ou complexes lors de la compilation d'un objet AST. Ceci est dû à limitation de la profondeur de la pile d'appels.
Modifié dans la version 3.2: autorise l'utilisation de retours à la ligne Mac et Windows. Par ailleurs, la chaîne donnée à
'exec'
n'a plus besoin de terminer par un retour à la ligne. Ajout du paramètre optimize.Modifié dans la version 3.5: précédemment, l'exception
TypeError
était levée quand un caractère nul était rencontré dans source.Ajouté dans la version 3.8:
ast.PyCF_ALLOW_TOP_LEVEL_AWAIT
peut maintenant être passée à flags pour permettre une gestion haut niveau deawait
,async for
etasync with
.
- class complex(number=0, /)¶
- class complex(string, /)
- class complex(real=0, imag=0)
Convert a single string or number to a complex number, or create a complex number from real and imaginary parts.
Examples:
>>> complex('+1.23') (1.23+0j) >>> complex('-4.5j') -4.5j >>> complex('-1.23+4.5j') (-1.23+4.5j) >>> complex('\t( -1.23+4.5J )\n') (-1.23+4.5j) >>> complex('-Infinity+NaNj') (-inf+nanj) >>> complex(1.23) (1.23+0j) >>> complex(imag=-4.5) -4.5j >>> complex(-1.23, 4.5) (-1.23+4.5j)
If the argument is a string, it must contain either a real part (in the same format as for
float()
) or an imaginary part (in the same format but with a'j'
or'J'
suffix), or both real and imaginary parts (the sign of the imaginary part is mandatory in this case). The string can optionally be surrounded by whitespaces and the round parentheses'('
and')'
, which are ignored. The string must not contain whitespace between'+'
,'-'
, the'j'
or'J'
suffix, and the decimal number. For example,complex('1+2j')
is fine, butcomplex('1 + 2j')
raisesValueError
. More precisely, the input must conform to thecomplexvalue
production rule in the following grammar, after parentheses and leading and trailing whitespace characters are removed:complexvalue ::=
floatvalue
|floatvalue
("j" | "J") |floatvalue
sign
absfloatvalue
("j" | "J")If the argument is a number, the constructor serves as a numeric conversion like
int
andfloat
. For a general Python objectx
,complex(x)
delegates tox.__complex__()
. If__complex__()
is not defined then it falls back to__float__()
. If__float__()
is not defined then it falls back to__index__()
.If two arguments are provided or keyword arguments are used, each argument may be any numeric type (including complex). If both arguments are real numbers, return a complex number with the real component real and the imaginary component imag. If both arguments are complex numbers, return a complex number with the real component
real.real-imag.imag
and the imaginary componentreal.imag+imag.real
. If one of arguments is a real number, only its real component is used in the above expressions.If all arguments are omitted, returns
0j
.Le type complexe est décrit dans Types numériques — int, float, complex.
Modifié dans la version 3.6: les chiffres peuvent être groupés avec des tirets bas comme dans les expressions littérales.
Modifié dans la version 3.8: délègue à
__index__()
si__complex__()
et__float__()
ne sont pas définies.
- delattr(object, name)¶
C'est une cousine de
setattr()
. Les arguments sont un objet et une chaîne. La chaîne doit être le nom de l'un des attributs de l'objet. La fonction supprime l'attribut nommé, si l'objet l'y autorise. Par exempledelattr(x, 'foobar')
est l'équivalent dedel x.foobar
. name n'a pas besoin d'être un identifiant Python (voirsetattr()
).
- class dict(**kwarg)
- class dict(mapping, **kwarg)
- class dict(iterable, **kwarg)
Crée un nouveau dictionnaire. L'objet
dict
est la classe du dictionnaire. Voirdict
et Les types de correspondances — dict pour vous documenter sur cette classe.Pour les autres conteneurs, voir les classes natives
list
,set
, ettuple
, ainsi que le modulecollections
.
- dir()¶
- dir(object)
Sans argument, elle donne la liste des noms dans l'espace de nommage local. Avec un argument, elle essaye de donner une liste d'attributs valides pour cet objet.
If the object has a method named
__dir__()
, this method will be called and must return the list of attributes. This allows objects that implement a custom__getattr__()
or__getattribute__()
function to customize the waydir()
reports their attributes.If the object does not provide
__dir__()
, the function tries its best to gather information from the object's__dict__
attribute, if defined, and from its type object. The resulting list is not necessarily complete and may be inaccurate when the object has a custom__getattr__()
.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)¶
Take two (non-complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using integer division. With mixed operand types, the rules for binary arithmetic operators apply. For integers, the result is the same as
(a // b, a % b)
. For floating-point numbers the result is(q, a % b)
, where q is usuallymath.floor(a / b)
but may be 1 less than that. In any caseq * b + a % b
is very close to a, ifa % b
is non-zero it has the same sign as b, and0 <= 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é parenumerate()
renvoie un n-uplet contenant un compte (démarrant à start, 0 par défaut) et les valeurs obtenues de l'itération sur iterable.>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter'] >>> list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] >>> list(enumerate(seasons, start=1)) [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
Équivalent à :
def enumerate(iterable, start=0): n = start for elem in iterable: yield n, elem n += 1
- eval(source, /, globals=None, locals=None)¶
- Paramètres:
source (
str
| code object) -- A Python expression.globals (
dict
|None
) -- The global namespace (default:None
).locals (mapping |
None
) -- The local namespace (default:None
).
- Renvoie:
The result of the evaluated expression.
- Raises:
Syntax errors are reported as exceptions.
Avertissement
This function executes arbitrary code. Calling it with user-supplied input may lead to security vulnerabilities.
The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals mappings as global and local namespace. If the globals dictionary is present and does not contain a value for the key
__builtins__
, a reference to the dictionary of the built-in modulebuiltins
is inserted under that key before expression is parsed. That way you can control what builtins are available to the executed code by inserting your own__builtins__
dictionary into globals before passing it toeval()
. If the locals mapping is omitted it defaults to the globals dictionary. If both mappings are omitted, the expression is executed with the globals and locals in the environment whereeval()
is called. Note, eval() will only have access to the nested scopes (non-locals) in the enclosing environment if they are already referenced in the scope that is callingeval()
(e.g. via anonlocal
statement).Example:
>>> x = 1 >>> eval('x+1') 2
Cette fonction peut aussi être utilisée pour exécuter n'importe quel objet code (tels que ceux créés par
compile()
). Dans ce cas, donnez un objet code plutôt qu'une chaîne. Si l'objet code a été compilé avec l'argument mode à'exec'
,eval()
renvoieNone
.Conseils : l'exécution dynamique d'instructions est gérée par la fonction
exec()
. Les fonctionsglobals()
etlocals()
renvoient respectivement les dictionnaires globaux et locaux, qui peuvent être utiles lors de l'usage deeval()
etexec()
.Si la source donnée est une chaîne, les espaces de début et de fin et les tabulations sont supprimées.
Utilisez
ast.literal_eval()
si vous avez besoin d'une fonction qui peut évaluer en toute sécurité des chaînes avec des expressions ne contenant que des valeurs littérales.Lève un évènement d'audit
exec
avec l'objet de code comme argument. Les événements de compilation de code peuvent également être levés.Modifié dans la version 3.13: The globals and locals arguments can now be passed as keywords.
Modifié dans la version 3.13: The semantics of the default locals namespace have been adjusted as described for the
locals()
builtin.
- exec(source, /, globals=None, locals=None, *, closure=None)¶
Avertissement
This function executes arbitrary code. Calling it with user-supplied input may lead to security vulnerabilities.
This function supports dynamic execution of Python code. source must be either a string or a code object. If it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax error occurs). [1] If it is a code object, it is simply executed. In all cases, the code that's executed is expected to be valid as file input (see the section Fichier d'entrée in the Reference Manual). Be aware that the
nonlocal
,yield
, andreturn
statements may not be used outside of function definitions even within the context of code passed to theexec()
function. The return value isNone
.In all cases, if the optional parts are omitted, the code is executed in the current scope. If only globals is provided, it must be a dictionary (and not a subclass of dictionary), which will be used for both the global and the local variables. If globals and locals are given, they are used for the global and local variables, respectively. If provided, locals can be any mapping object. Remember that at the module level, globals and locals are the same dictionary.
Note
When
exec
gets two separate objects as globals and locals, the code will be executed as if it were embedded in a class definition. This means functions and classes defined in the executed code will not be able to access variables assigned at the top level (as the "top level" variables are treated as class variables in a class definition).Si le dictionnaire globals ne contient pas de valeur pour la clé
__builtins__
, une référence au dictionnaire du modulebuiltins
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()
.The closure argument specifies a closure--a tuple of cellvars. It's only valid when the object is a code object containing free (closure) variables. The length of the tuple must exactly match the length of the code object's
co_freevars
attribute.Lève un évènement d'audit
exec
avec l'objet de code comme argument. Les événements de compilation de code peuvent également être levés.Note
The built-in functions
globals()
andlocals()
return the current global and local namespace, respectively, which may be useful to pass around for use as the second and third argument toexec()
.Note
The default locals act as described for function
locals()
below. Pass an explicit locals dictionary if you need to see effects of the code on locals after functionexec()
returns.Modifié dans la version 3.11: ajout du paramètre closure.
Modifié dans la version 3.13: The globals and locals arguments can now be passed as keywords.
Modifié dans la version 3.13: The semantics of the default locals namespace have been adjusted as described for the
locals()
builtin.
- filter(function, iterable)¶
Construit un itérateur depuis les éléments d'iterable pour lesquels function renvoie
True
. iterable peut aussi bien être une séquence, un conteneur qui prend en charge l'itération, ou un itérateur. Si function estNone
, 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 pasNone
, et de(item for item in iterable if item)
si function estNone
.Voir
itertools.filterfalse()
pour la fonction complémentaire qui donne les éléments d'iterable pour lesquels function renvoieFalse
.
- class float(number=0.0, /)¶
- class float(string, /)
Return a floating-point number constructed from a number or a string.
Examples:
>>> float('+1.23') 1.23 >>> float(' -12345\n') -12345.0 >>> float('1e-003') 0.001 >>> float('+1E6') 1000000.0 >>> float('-Infinity') -inf
If the argument is a string, it should contain a decimal number, optionally preceded by a sign, and optionally embedded in whitespace. The optional sign may be
'+'
or'-'
; a'+'
sign has no effect on the value produced. The argument may also be a string representing a NaN (not-a-number), or positive or negative infinity. More precisely, the input must conform to thefloatvalue
production rule in the following grammar, after leading and trailing whitespace characters are removed:sign ::= "+" | "-" infinity ::= "Infinity" | "inf" nan ::= "nan" digit ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd> digitpart ::=
digit
(["_"]digit
)* number ::= [digitpart
] "."digitpart
|digitpart
["."] exponent ::= ("e" | "E") [sign
]digitpart
floatnumber ::=number
[exponent
] absfloatvalue ::=floatnumber
|infinity
|nan
floatvalue ::= [sign
]absfloatvalue
Case is not significant, so, for example, "inf", "Inf", "INFINITY", and "iNfINity" are all acceptable spellings for positive infinity.
Otherwise, if the argument is an integer or a floating-point number, a floating-point number with the same value (within Python's floating-point precision) is returned. If the argument is outside the range of a Python float, an
OverflowError
will be raised.Pour un objet Python général
x
,float(x)
est délégué àx.__float__()
. Si__float__()
n'est pas défini alors il est délégué à__index__()
.Sans argument,
0.0
est renvoyé.Le type float est décrit dans Types numériques — int, float, complex.
Modifié dans la version 3.6: les chiffres peuvent être groupés avec des tirets bas comme dans les expressions littérales.
Modifié dans la version 3.7: The parameter is now positional-only.
Modifié dans la version 3.8: délègue à
__index__()
si__float__()
n'est pas définie.
- format(value, format_spec='')¶
Convertit une valeur en sa représentation « formatée », contrôlée par format_spec. L'interprétation de format_spec dépend du type de la valeur. Cependant, il existe une syntaxe standard utilisée par la plupart des types natifs : 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)
.A call to
format(value, format_spec)
is translated totype(value).__format__(value, format_spec)
which bypasses the instance dictionary when searching for the value's__format__()
method. ATypeError
exception is raised if the method search reachesobject
and the format_spec is non-empty, or if either the format_spec or the return value are not strings.Modifié dans la version 3.4:
object().__format__(format_spec)
lèveTypeError
si format_spec n'est pas une chaîne vide.
- class frozenset(iterable=set())
Renvoie un nouveau
frozenset
, dont les objets sont éventuellement tirés d'iterable.frozenset
est une classe native. Voirfrozenset
et Types d'ensembles — set, frozenset pour la documentation sur cette classe.Pour d'autres conteneurs, voyez les classes natives
set
,list
,tuple
, etdict
, ainsi que le modulecollections
.
- getattr(object, name)¶
- getattr(object, name, default)
Renvoie la valeur de l'attribut nommé name de l'objet object. name doit être une chaîne. Si la chaîne est le nom d'un des attributs de l'objet, le résultat est la valeur de cet attribut. Par exemple,
getattr(x, 'foobar')
est équivalent àx.foobar
. Si l'attribut n'existe pas, mais que default est fourni, celui-ci est renvoyé. Sinon l'exceptionAttributeError
est levée. name n'a pas besoin d'être un identifiant Python (voirsetattr()
).Note
étant donné que la transformation des noms privés se produit au moment de la compilation, il faut modifier manuellement le nom d'un attribut privé (attributs avec deux traits de soulignement en tête) afin de le récupérer avec
getattr()
.
- globals()¶
Renvoie le dictionnaire implémentant l'espace de nommage du module actuel. Pour le code dans les fonctions, il est défini lorsque la fonction est définie et reste le même quel que soit le moment où la fonction est appelée.
- hasattr(object, name)¶
Les arguments sont : un objet et une chaîne de caractères. Le résultat est
True
si la chaîne est le nom d'un des attributs de l'objet, sinonFalse
(l'implémentation appellegetattr(object, name)
et regarde si une exceptionAttributeError
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
et1.0
).Note
For objects with custom
__hash__()
methods, note thathash()
truncates the return value based on the bit width of the host machine.
- help()¶
- help(request)
Invoque le système d'aide natif (cette fonction est destinée à l'usage en mode interactif). Si aucun argument n'est fourni, le système d'aide démarre dans l'interpréteur. Si l'argument est une chaîne, celle-ci est recherchée comme le nom d'un module, d'une fonction, d'une classe, d'une méthode, d'un mot clé, ou d'un sujet de documentation, et une page d'aide est affichée sur la console. Si l'argument est d'un autre type, une page d'aide sur cet objet est générée.
Notez que si une barre oblique (/) apparaît dans la liste des paramètres d'une fonction lorsque vous appelez
help()
, cela signifie que les paramètres placés avant la barre oblique sont strictement positionnels. Pour plus d'informations, voir La FAQ sur les arguments positionnels.Cette fonction est ajoutée à l'espace de nommage natif par le module
site
.
- hex(x)¶
Convertit un entier en chaîne hexadécimale préfixée de "0x". Si x n'est pas un
int
, il doit définir une méthode__index__()
qui renvoie un entier. Quelques exemples :>>> hex(255) '0xff' >>> hex(-42) '-0x2a'
Si vous voulez convertir un nombre entier en chaîne hexadécimale, en majuscule ou non, préfixée ou non, vous pouvez utiliser l'une des méthodes suivantes :
>>> '%#x' % 255, '%x' % 255, '%X' % 255 ('0xff', 'ff', 'FF') >>> format(255, '#x'), format(255, 'x'), format(255, 'X') ('0xff', 'ff', 'FF') >>> f'{255:#x}', f'{255:x}', f'{255:X}' ('0xff', 'ff', 'FF')
Voir aussi
format()
pour plus d'informations.Voir aussi
int()
pour convertir une chaîne hexadécimale en un entier (en affectant 16 à l'argument base).Note
pour obtenir une représentation hexadécimale sous forme de chaîne d'un nombre à virgule flottante, utilisez la méthode
float.hex()
.
- id(object)¶
Renvoie l'« identité » d'un objet. C'est un nombre entier garanti unique et constant pour cet objet durant sa durée de vie. Deux objets dont les durées de vie ne se chevauchent pas peuvent partager le même
id()
.Particularité de l'implémentation CPython : c'est l'adresse de l'objet en mémoire.
Lève un évènement d'audit
builtins.id
avec l'argumentid
.
- input()¶
- input(prompt)
Si l'argument prompt est donné, il est écrit sur la sortie standard sans le retour à la ligne final. La fonction lit ensuite une ligne sur l'entrée standard et la convertit en chaîne (supprimant le retour à la ligne final) qu'elle renvoie. Lorsque EOF est lu,
EOFError
est levée. Exemple :>>> s = input('--> ') --> Monty Python's Flying Circus >>> s "Monty Python's Flying Circus"
Si le module
readline
est chargé,input()
l'utilisera pour fournir des fonctionnalités d'édition et d'historique élaborées.Lève un évènement d'audit
builtins.input
avec l'argumentprompt
avant de lire l'entrée.Lève un événement d'audit
builtins.input/result
avec le résultat après avoir lu avec succès l'entrée.
- class int(number=0, /)¶
- class int(string, /, base=10)
Return an integer object constructed from a number or a string, or return
0
if no arguments are given.Examples:
>>> int(123.45) 123 >>> int('123') 123 >>> int(' -12_345\n') -12345 >>> int('FACE', 16) 64206 >>> int('0xface', 0) 64206 >>> int('01110011', base=2) 115
If the argument defines
__int__()
,int(x)
returnsx.__int__()
. If the argument defines__index__()
, it returnsx.__index__()
. If the argument defines__trunc__()
, it returnsx.__trunc__()
. For floating-point numbers, this truncates towards zero.If the argument is not a number or if base is given, then it must be a string,
bytes
, orbytearray
instance representing an integer in radix base. Optionally, the string can be preceded by+
or-
(with no space in between), have leading zeros, be surrounded by whitespace, and have single underscores interspersed between digits.Une chaine représentant un entier en base n contient des chiffres, chacun représentant une valeur de 0 à n-1. Les valeurs 0 à 9 peuvent être représentées par n'importe lequel des chiffres décimaux Unicode. Les valeurs de 10 à 35 peuvent être représentées par
a
jusqu'àz
(ouA
àZ
). La base par défaut est 10. Les valeurs autorisées pour base sont 0 et 2 à 36. Les littéraux en base 2, 8, et 16 peuvent être préfixés avec0b
/0B
,0o
/0O
, ou0x
/0X
tout comme les littéraux dans le code. Fournir 0 comme base demande d'interpréter exactement comme un entier littéral dans du code Python, donc la base sera 2, 8, 10, ou 16 en fonction du préfixe. Indiquer 0 comme base interdit les zéros en tête, ainsiint('010', 0)
n'est pas légal, alors queint('010')
l'est tout commeint('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éthodebase.__index__
, cette méthode est appelée pour obtenir un entier pour cette base. Les versions précédentes utilisaientbase.__int__
au lieu debase.__index__
.Modifié dans la version 3.6: les chiffres peuvent être groupés avec des tirets bas comme dans les expressions littérales.
Modifié dans la version 3.7: The first parameter is now positional-only.
Modifié dans la version 3.8: Revient à
__index__()
si__int__()
n'est pas définie.Modifié dans la version 3.11: le repli vers
__trunc__()
est obsolète.Modifié dans la version 3.11:
int
string inputs and string representations can be limited to help avoid denial of service attacks. AValueError
is raised when the limit is exceeded while converting a string to anint
or when converting anint
into a string would exceed the limit. See the integer string conversion length limitation documentation.
- 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 toujoursFalse
. Si classinfo est un n-uplet de types (ou récursivement, d'autres n-uplets) ou une union de types différents, renvoieTrue
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 exceptionTypeError
est levée.TypeError
ne peut pas être levée pour un type invalide si une des vérifications précédentes réussit.Modifié dans la version 3.10: classinfo peut être une union de types.
- issubclass(class, classinfo)¶
Renvoie
True
si class est une classe fille (directe, indirecte ou abstraite) de classinfo. Une classe est considérée sous-classe d'elle-même. classinfo peut être un n-uplet de classes (ou récursivement, d'autres n-uplets) ou une union de types, dans ce cas elle renvoieTrue
si class est une sous-classe d'une partie de classinfo. Dans tous les autres cas, uneTypeError
est levée.Modifié dans la version 3.10: classinfo peut être une union de types.
- iter(object)¶
- iter(object, sentinel)
Return an iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, object must be a collection object which supports the iterable protocol (the
__iter__()
method), or it must support the sequence protocol (the__getitem__()
method with integer arguments starting at0
). If it does not support either of those protocols,TypeError
is raised. If the second argument, sentinel, is given, then object must be a callable object. The iterator created in this case will call object with no arguments for each call to its__next__()
method; if the value returned is equal to sentinel,StopIteration
will be raised, otherwise the value will be returned.Voir aussi Les types itérateurs.
Une autre application utile de la deuxième forme de
iter()
est de construire un lecteur par blocs. Par exemple, lire des blocs de taille fixe d'une base de donnée binaire jusqu'à ce que la fin soit atteinte :from functools import partial with open('mydata.db', 'rb') as f: for block in iter(partial(f.read, 64), b''): process_block(block)
- len(s)¶
Renvoie la longueur (nombre d'éléments) d'un objet. L'argument peut être une séquence (telle qu'une chaîne de caractères ou d'octets, un n-uplet, une liste ou un intervalle) ou une collection (telle qu'un dictionnaire, un ensemble ou un ensemble figé).
Particularité de l'implémentation CPython :
len
lève uneOverflowError
sur des longueurs supérieures àsys.maxsize
, par exemple pourrange(2 ** 100)
.
- class list
- class list(iterable)
Contrairement aux apparences,
list
n'est pas une fonction mais un type séquentiel mutable, comme décrit dans Listes et Types séquentiels — list, tuple, range.
- locals()¶
Return a mapping object representing the current local symbol table, with variable names as the keys, and their currently bound references as the values.
At module scope, as well as when using
exec()
oreval()
with a single namespace, this function returns the same namespace asglobals()
.At class scope, it returns the namespace that will be passed to the metaclass constructor.
When using
exec()
oreval()
with separate local and global arguments, it returns the local namespace passed in to the function call.In all of the above cases, each call to
locals()
in a given frame of execution will return the same mapping object. Changes made through the mapping object returned fromlocals()
will be visible as assigned, reassigned, or deleted local variables, and assigning, reassigning, or deleting local variables will immediately affect the contents of the returned mapping object.In an optimized scope (including functions, generators, and coroutines), each call to
locals()
instead returns a fresh dictionary containing the current bindings of the function's local variables and any nonlocal cell references. In this case, name binding changes made via the returned dict are not written back to the corresponding local variables or nonlocal cell references, and assigning, reassigning, or deleting local variables and nonlocal cell references does not affect the contents of previously returned dictionaries.Calling
locals()
as part of a comprehension in a function, generator, or coroutine is equivalent to calling it in the containing scope, except that the comprehension's initialised iteration variables will be included. In other scopes, it behaves as if the comprehension were running as a nested function.Calling
locals()
as part of a generator expression is equivalent to calling it in a nested generator function.Modifié dans la version 3.12: The behaviour of
locals()
in a comprehension has been updated as described in PEP 709.Modifié dans la version 3.13: As part of PEP 667, the semantics of mutating the mapping objects returned from this function are now defined. The behavior in optimized scopes is now as described above. Aside from being defined, the behaviour in other scopes remains unchanged from previous versions.
- map(function, iterable, *iterables)¶
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 iterables sont fournis, function doit prendre autant d'arguments, et est 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, voiritertools.starmap()
.
- max(iterable, *, key=None)¶
- max(iterable, *, default, key=None)
- max(arg1, arg2, *args, key=None)
Renvoie le plus grand élément d'un itérable, ou l'argument le plus grand parmi au moins deux arguments.
Si un seul argument positionnel est fourni, il doit être itérable. Le plus grand élément de l'itérable est renvoyé. Si au moins deux arguments positionnels sont fournis, l'argument le plus grand sera renvoyé.
Elle accepte deux arguments nommés optionnels. L'argument key spécifie une fonction à un argument permettant de trier comme pour
list.sort()
. L'argument default fournit quant à lui un objet à donner si l'itérable fourni est vide. Si l'itérable est vide et que default n'est pas fourni,ValueError
est levée.Si plusieurs éléments représentent la plus grande valeur, le premier rencontré est renvoyé. C'est cohérent avec d'autres outils préservant une stabilité lors du tri, tels que
sorted(iterable, key=keyfunc, reverse=True)[0]
etheapq.nlargest(1, iterable, key=keyfunc)
.Modifié dans la version 3.4: Added the default keyword-only parameter.
Modifié dans la version 3.8: l'argument key peut être
None
.
- class memoryview(object)
Renvoie une « vue mémoire » (memory view) créée depuis l'argument. Voir Vues mémoire pour plus d'informations.
- min(iterable, *, key=None)¶
- min(iterable, *, default, key=None)
- min(arg1, arg2, *args, key=None)
Renvoie le plus petit élément d'un itérable ou le plus petit d'au moins deux arguments.
Si un seul argument est fourni, il doit être itérable. Le plus petit élément de l'itérable est renvoyé. Si au moins deux arguments positionnels sont fournis, le plus petit argument positionnel est renvoyé.
Elle accepte deux arguments nommés optionnels. L'argument key spécifie une fonction à un argument permettant de trier comme pour
list.sort()
. L'argument default fournit quant à lui un objet à donner si l'itérable fourni est vide. Si l'itérable est vide et que default n'est pas fourni,ValueError
est levée.Si plusieurs éléments sont minimaux, la fonction renvoie le premier rencontré. C'est cohérent avec d'autres outils préservant une stabilité lors du tri, tels que
sorted(iterable, key=keyfunc)[0]
etheapq.nsmallest(1, iterable, key=keyfunc)
.Modifié dans la version 3.4: Added the default keyword-only parameter.
Modifié dans la version 3.8: l'argument key peut être
None
.
- next(iterator)¶
- next(iterator, default)
Donne l'élément suivant de l'itérateur en appelant sa méthode
__next__()
. Si default est fourni, il est renvoyé quand l'itérateur est épuisé, sinon uneStopIteration
est levée.
- class object¶
This is the ultimate base class of all other classes. It has methods that are common to all instances of Python classes. When the constructor is called, it returns a new featureless object. The constructor does not accept any arguments.
- 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 une chaîne octale, avec ou sans le préfixe
0o
, vous pouvez utiliser l'une des méthodes suivantes.>>> '%#o' % 10, '%o' % 10 ('0o12', '12') >>> format(10, '#o'), format(10, 'o') ('0o12', '12') >>> f'{10:#o}', f'{10:o}' ('0o12', '12')
Voir aussi
format()
pour plus d'informations.
- open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)¶
Ouvre file et donne un objet fichier correspondant. Si le fichier ne peut pas être ouvert, une
OSError
est levée. Voir Lecture et écriture de fichiers pour plus d'exemples d'utilisation de cette fonction.file est un objet simili-chemin donnant le chemin (absolu ou relatif au répertoire courant) du fichier à ouvrir ou un nombre entier représentant le descripteur de fichier à envelopper (si un descripteur de fichier est donné, il sera fermé en même temps que l'objet d'entrée-sortie renvoyé, sauf si closefd est mis à
False
).mode is an optional string that specifies the mode in which the file is opened. It defaults to
'r'
which means open for reading in text mode. Other common values are'w'
for writing (truncating the file if it already exists),'x'
for exclusive creation, and'a'
for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform-dependent:locale.getencoding()
is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are:Caractère
Signification
'r'
ouvre en lecture (par défaut)
'w'
ouvre en écriture, en effaçant le contenu du fichier
'x'
ouvre pour une création exclusive, échouant si le fichier existe déjà
'a'
ouvre en écriture, ajoutant à la fin du fichier s'il existe
'b'
mode binaire
't'
mode texte (par défaut)
'+'
ouvre en modification (lecture et écriture)
Le mode par défaut est
'r'
(ouverture pour lire du texte, un synonyme pour'rt'
). Les modes'w+'
et'w+b'
ouvrent et vident le fichier. Les modes'r+'
et'r+b'
ouvrent le fichier sans le vider.Comme mentionné dans Aperçu, Python fait la différence entre les entrées-sorties binaires et textes. Les fichiers ouverts en mode binaire (avec
'b'
dans mode) donnent leur contenu sous forme debytes
sans décodage. En mode texte (par défaut, ou lorsque't'
est dans le mode), le contenu du fichier est donné sous forme destr
, les octets ayant été décodés au préalable en utilisant un encodage déduit de l'environnement ou encoding s'il est donné.Note
Python ne dépend pas de la représentation du fichier texte du système sous-jacent. Tout le traitement est effectué par Python lui-même, et est ainsi indépendant de la plate-forme.
buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable when writing in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. Note that specifying a buffer size this way applies for binary buffered I/O, but
TextIOWrapper
(i.e., files opened withmode='r+'
) would have another buffering. To disable buffering inTextIOWrapper
, consider using thewrite_through
flag forio.TextIOWrapper.reconfigure()
. When no buffering argument is given, the default buffering policy works as follows: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 est de 4096 ou 8192 octets ;les fichiers texte « interactifs » (fichiers pour lesquels
io.IOBase.isatty()
renvoieTrue
) utilisent un tampon ligne par ligne. Les autres fichiers textes sont traités comme les fichiers binaires.
encoding est le nom de l'encodage utilisé pour encoder ou décoder le fichier. Il doit seulement être utilisé en mode texte. L'encodage par défaut dépend de la plateforme (ce que renvoie
locale.getencoding()
), mais n'importe quel encodage de texte pris en charge par Python peut être utilisé. Voircodecs
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 uneValueError
si une erreur d'encodage est rencontrée. La valeur par défaut,None
, a le même effet.'ignore'
ignore les erreurs. Notez qu'ignorer les erreurs d'encodage peut mener à des pertes de données.'replace'
insère un marqueur de substitution (tel que'?'
) en place des données mal formées.'surrogateescape'
représentera tous les octets incorrects comme des points de code de substitution de l'intervalle bas U+DC80 à U+DCFF. Ces points de code de substitution sont ensuite retransformés dans les mêmes octets lorsque le gestionnaire d'erreurssurrogateescape
est utilisé pour l'écriture des données. C'est utile pour traiter des fichiers d'un encodage inconnu.'xmlcharrefreplace'
is only supported when writing to a file. Characters not supported by the encoding are replaced with the appropriate XML character reference&#nnn;
.'backslashreplace'
remplace les données mal formées par des séquences d'échappement Python (utilisant des barres obliques inverses).'namereplace'
(aussi supporté lors de l'écriture) remplace les caractères non gérés par des séquences d'échappement\N{...}
.
newline contrôle comment interpréter les retours à la ligne. Il peut être
None
,''
,'\n'
,'\r'
, et'\r\n'
. Il fonctionne comme suit :Lors de la lecture, si newline est
None
, le mode universal newlines est activé. Les lignes lues peuvent se terminer par'\n'
,'\r'
, ou'\r\n'
, et sont remplacées par'\n'
, avant d'être renvoyées à l'appelant. S'il vaut''
, le mode universal newline est activé mais les fins de ligne ne sont pas remplacées. S'il a n'importe quelle autre valeur autorisée, les lignes sont seulement terminées par la chaîne donnée, qui est rendue telle quelle.Lors de l'écriture, si newline est
None
, chaque'\n'
est remplacé par le séparateur de lignes par défaut du systèmeos.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 resterTrue
(la valeur par défaut) ; sinon, une erreur est levée.Un opener personnalisé peut être utilisé en fournissant un appelable comme opener. Le descripteur de fichier de cet objet fichier sera alors obtenu en appelant opener avec (file, flags). opener doit renvoyer un descripteur de fichier ouvert (fournir
os.open
en tant qu'opener aura le même effet que donnerNone
).Il n'est pas possible d'hériter du descripteur de fichier nouvellement créé.
L'exemple suivant utilise le paramètre dir_fd de la fonction
os.open()
pour ouvrir un fichier relatif au dossier courant :>>> import os >>> dir_fd = os.open('somedir', os.O_RDONLY) >>> def opener(path, flags): ... return os.open(path, flags, dir_fd=dir_fd) ... >>> with open('spamspam.txt', 'w', opener=opener) as f: ... print('This will be written to somedir/spamspam.txt', file=f) ... >>> os.close(dir_fd) # don't leak a file descriptor
Le type d'objet fichier renvoyé par la fonction
open()
dépend du mode. Lorsqueopen()
est utilisé pour ouvrir un fichier en mode texte (w
,r
,wt
,rt
, etc.), il renvoie une classe fille deio.TextIOBase
(spécifiquement :io.TextIOWrapper
). Lors de l'ouverture d'un fichier en mode binaire avec tampon, la classe renvoyée sera une fille deio.BufferedIOBase
. La classe exacte varie : en lecture en mode binaire elle renvoie uneio.BufferedReader
, en écriture et ajout en mode binaire c'est uneio.BufferedWriter
, et en lecture-écriture, c'est uneio.BufferedRandom
. Lorsque le tampon est désactivé, le flux brut, une classe fille deio.RawIOBase
,io.FileIO
est renvoyée.Consultez aussi les modules de gestion de fichiers tels que
fileinput
,io
(oùopen()
est déclarée),os
,os.path
,tempfile
, etshutil
.Raises an auditing event
open
with argumentspath
,mode
,flags
.Les arguments
mode
etflags
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 deOSError
.FileExistsError
est maintenant levée si le fichier ouvert en mode création exclusive ('x'
) existe déjà.
Modifié dans la version 3.4:
Il n'est plus possible d'hériter de file.
Modifié dans la version 3.5:
Si l'appel système est interrompu et que le gestionnaire de signal ne lève aucune exception, la fonction réessaye l'appel système au lieu de lever une
InterruptedError
(voir la PEP 475 pour la justification).ajout du gestionnaire d'erreurs
'namereplace'
.
Modifié dans la version 3.6:
prise en charge des objets implémentant
os.PathLike
.Sous Windows, ouvrir un buffer du terminal peut renvoyer une sous-classe de
io.RawIOBase
autre queio.FileIO
.
Modifié dans la version 3.11: le mode
'U`
a été enlevé.
- 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 entier97
etord('€')
(symbole euro) renvoie8364
. Il s'agit de la réciproque dechr()
.
- pow(base, exp, mod=None)¶
Renvoie base puissance exp et, si mod est présent, donne base puissance exp modulo mod (calculé de manière plus efficiente que
pow(base, exp) % mod
). La forme à deux argumentspow(base, exp)
est équivalente à l'opérateur puissance :base**exp
.The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For
int
operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example,pow(10, 2)
returns100
, butpow(10, -2)
returns0.01
. For a negative base of typeint
orfloat
and a non-integral exponent, a complex result is delivered. For example,pow(-9, 0.5)
returns a value close to3j
. Whereas, for a negative base of typeint
orfloat
with an integral exponent, a float result is delivered. For example,pow(-9, 2.0)
returns81.0
.Pour des opérandes base et exp de type
int
, si mod est présent, mod doit également être de type entier et mod doit être non nul. Si mod est présent et que exp est négatif, base et mod doivent être premiers entre eux. Dans ce cas,pow(inv_base, -exp, mod)
est renvoyé, où inv_base est un inverse de base modulo mod.Voici un exemple de calcul d'un inverse de
38
modulo97
:>>> 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 depow
permet maintenant au deuxième argument d'être négatif, permettant le calcul des inverses modulaires.Modifié dans la version 3.8: autorise les arguments nommés. Auparavant, seuls les arguments positionnels étaient autorisés.
- print(*objects, sep=' ', end='\n', file=None, flush=False)¶
Écrit objects dans le flux texte file, séparés par sep et suivis de end. Les arguments sep, end, file, et flush, s'ils sont présents, doivent être passés en arguments nommés.
Tous les arguments positionnels sont convertis en chaîne comme le fait
str()
, puis écrits sur le flux, séparés par sep et terminés par end. sep et end doivent être des chaînes, ouNone
, indiquant de prendre les valeurs par défaut. Si aucun objects n'est donnéprint()
écrit seulement end.L'argument file doit être un objet avec une méthode
write(string)
; s'il n'est pas fourni, ou vautNone
,sys.stdout
est utilisé. Puisque les arguments affichés sont convertis en chaîne,print()
ne peut pas être utilisée avec des fichiers ouverts en mode binaire. Pour ceux-ci utilisez plutôtfile.write(...)
.Que la sortie utilise un tampon ou non est souvent décidé par file. Cependant, si l'argument flush est vrai, le tampon du flux est vidé explicitement.
Modifié dans la version 3.3: ajout de l'argument nommé flush.
- class property(fget=None, fset=None, fdel=None, doc=None)¶
Renvoie un attribut propriété.
fget est une fonction permettant d'obtenir la valeur d'un attribut. fset est une fonction pour en définir la valeur. fdel quant à elle permet de supprimer la valeur d'un attribut, et doc crée une chaîne de documentation (docstring) pour l'attribut.
Une utilisation courante est de définir un attribut managé
x
:class C: def __init__(self): self._x = None def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I'm the 'x' property.")
Si c est une instance de C,
c.x
appelle l'accesseur (getter en anglais),c.x = value
invoque le mutateur (setter), etdel x
le destructeur (deleter).Si elle est fournie, doc est la chaîne de documentation de l'attribut. Autrement la propriété copie celle de fget (si elle existe). Cela rend possible la création de propriétés en lecture seule en utilisant simplement
property()
comme décorateur :class Parrot: def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage
The
@property
decorator turns thevoltage()
method into a "getter" for a read-only attribute with the same name, and it sets the docstring for voltage to "Get the current voltage."- @getter¶
- @setter¶
- @deleter¶
A property object has
getter
,setter
, anddeleter
methods usable as decorators that create a copy of the property with the corresponding accessor function set to the decorated function. This is best explained with an example:class C: def __init__(self): self._x = None @property def x(self): """I'm the 'x' property.""" return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x
Ce code est l'exact équivalent du premier exemple. Soyez attentifs à bien donner aux fonctions additionnelles le même nom que la propriété (
x
dans ce cas).L'objet propriété renvoyé possède aussi les attributs
fget
,fset
etfdel
correspondants aux arguments du constructeur.
Modifié dans la version 3.5: les chaînes de documentation des objets property sont maintenant en lecture-écriture.
- __name__¶
Attribute holding the name of the property. The name of the property can be changed at runtime.
Ajouté dans la version 3.13.
- class range(stop)
- class range(start, stop, step=1)
Contrairement aux apparences,
range
n'est pas une fonction mais un type de séquence immuable, comme décrit dans Ranges et Types séquentiels — list, tuple, range.
- repr(object)¶
Return a string containing a printable representation of an object. For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to
eval()
; otherwise, the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object. A class can control what this function returns for its instances by defining a__repr__()
method. Ifsys.displayhook()
is not accessible, this function will raiseRuntimeError
.This class has a custom representation that can be evaluated:
class Person: def __init__(self, name, age): self.name = name self.age = age def __repr__(self): return f"Person('{self.name}', {self.age})"
- reversed(seq)¶
Return a reverse iterator. seq must be an object which has a
__reversed__()
method or supports the sequence protocol (the__len__()
method and the__getitem__()
method with integer arguments starting at0
).
- round(number, ndigits=None)¶
Renvoie number arrondi avec une précision de ndigits chiffres après la virgule. Si ndigits est omis (ou est
None
), l'entier le plus proche est renvoyé.Pour les types natifs prenant en charge
round()
, les valeurs sont arrondies au multiple de 10 puissance moins ndigits, si deux multiples sont équidistants, l'arrondi se fait vers la valeur paire (par exempleround(0.5)
etround(-0.5)
valent tous les deux0
, etround(1.5)
vaut2
). 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 estNone
). 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 exempleround(2.675, 2)
donne2.67
au lieu de2.68
. Ce n'est pas un bogue, mais dû au fait que la plupart des fractions de décimaux ne peuvent pas être représentés exactement en nombre a virgule flottante. Voir Floating-Point Arithmetic: Issues and Limitations pour plus d'information.
- class set
- class set(iterable)
Renvoie un nouvel
ensemble
, dont les éléments sont extraits d'iterable s'il est fourni.set
est une classe native. Voirset
et Types d'ensembles — set, frozenset pour la documentation de cette classe.D'autres conteneurs existent, comme :
frozenset
,list
,tuple
, etdict
, ainsi que le modulecollections
.
- setattr(object, name, value)¶
C'est le complément de
getattr()
. Les arguments sont : un objet, une chaîne et une valeur de type arbitraire. La chaîne name peut désigner un attribut existant ou un nouvel attribut. La fonction assigne la valeur à l'attribut, si l'objet l'autorise. Par exemple,setattr(x, 'foobar', 123)
équivaut àx.foobar = 123
.name n'a pas besoin d'être un identifiant Python tel que défini dans Identifiants et mots-clés sauf si l'objet choisit de l'imposer, par exemple en personnalisant
__getattribute__()
ou via__slots__
. Un attribut dont le nom n'est pas un identifiant ne sera pas accessible en utilisant la notation pointée, mais est accessible viagetattr()
etc.Note
étant donné que la transformation des noms privés se produit au moment de la compilation, il faut modifier manuellement le nom d'un attribut privé (attributs avec deux traits de soulignement en tête) afin de le définir avec
setattr()
.
- class slice(stop)¶
- class slice(start, stop, step=None)
Return a slice object representing the set of indices specified by
range(start, stop, step)
. The start and step arguments default toNone
.- start¶
- stop¶
- step¶
Slice objects have read-only data attributes
start
,stop
, andstep
which merely return the argument values (or their default). They have no other explicit functionality; however, they are used by NumPy and other third-party packages.
Slice objects are also generated when extended indexing syntax is used. For example:
a[start:stop:step]
ora[start:stop, i]
. Seeitertools.islice()
for an alternate version that returns an iterator.
- sorted(iterable, /, *, key=None, reverse=False)¶
Renvoie une nouvelle liste triée depuis les éléments d'iterable.
Possède deux arguments optionnels qui doivent être spécifiés par arguments nommés.
key spécifie une fonction à un argument utilisée pour extraire une clé de comparaison de chaque élément de l'itérable (par exemple,
key=str.lower
). La valeur par défaut estNone
(compare les éléments directement).reverse est une valeur booléenne. Si elle est
True
, la liste d'éléments est triée comme si toutes les comparaisons étaient inversées.Utilisez
functools.cmp_to_key()
pour convertir l'ancienne notation cmp en une fonction key.La fonction native
sorted()
est garantie stable. Un tri est stable s'il garantit de ne pas changer l'ordre relatif des éléments égaux entre eux. C'est utile pour trier en plusieurs passes (par exemple par direction puis par salaire).L'algorithme de tri utilise uniquement l'opérateur
<
pour comparer les éléments. Alors que la définition d'une méthode__lt__()
est suffisante pour trier, la PEP 8 recommande que les six comparaisons riches soient implémentées. Cela contribue à éviter les bogues lors de l'utilisation des mêmes données avec d'autres outils de tri (tels quemax()
) qui reposent sur une méthode sous-jacente différente. L'implémentation des six comparaisons permet également d'éviter toute confusion lors de comparaisons de types mixtes qui peuvent appeler la méthode__gt__()
.Pour des exemples de tris et un bref tutoriel, consultez Sorting Techniques.
- @staticmethod¶
Transforme une méthode en méthode statique.
Une méthode statique ne reçoit pas de premier argument implicitement. Voici comment déclarer une méthode statique :
class C: @staticmethod def f(arg1, arg2, argN): ...
La forme
@staticmethod
est un décorateur de fonction. Consultez Définition de fonctions pour plus de détails.A static method can be called either on the class (such as
C.f()
) or on an instance (such asC().f()
). Moreover, the static method descriptor is also callable, so it can be used in the class definition (such asf()
).Les méthodes statiques en Python sont similaires à celles que l'on trouve en Java ou en C++. Consultez
classmethod()
pour une variante utile permettant de créer des constructeurs alternatifs.Comme pour tous les décorateurs, il est possible d'appeler
staticmethod
comme une simple fonction, et faire quelque chose de son résultat. Ça peut être nécessaire dans le cas où vous souhaitez une référence à la fonction depuis le corps d'une classe, et voulez éviter sa transformation en méthode d'instance. Dans ce cas, faites comme suit :def regular_function(): ... class C: method = staticmethod(regular_function)
Pour plus d'informations sur les méthodes statiques, consultez Hiérarchie des types standards.
Modifié dans la version 3.10: Static methods now inherit the method attributes (
__module__
,__name__
,__qualname__
,__doc__
and__annotations__
), have a new__wrapped__
attribute, and are now callable as regular functions.
- class str(object='')
- class str(object=b'', encoding='utf-8', errors='strict')
Renvoie une version d'object sous forme de
str
. Voirstr()
pour plus de détails.str
est la classe native des chaînes de caractères. Pour des informations générales à propos des chaînes, consultez Type Séquence de Texte — str.
- sum(iterable, /, start=0)¶
Additionne start et les éléments d'un iterable de gauche à droite et en donne le total. Les éléments de l'iterable sont normalement des nombres, et la valeur de start ne peut pas être une chaîne de caractères.
For some use cases, there are good alternatives to
sum()
. The preferred, fast way to concatenate a sequence of strings is by calling''.join(sequence)
. To add floating-point values with extended precision, seemath.fsum()
. To concatenate a series of iterables, consider usingitertools.chain()
.Modifié dans la version 3.8: le paramètre start peut être passé comme un argument nommé.
Modifié dans la version 3.12: Summation of floats switched to an algorithm that gives higher accuracy and better commutativity on most builds.
- class super¶
- class super(type, object_or_type=None)
Renvoie un objet mandataire (proxy object en anglais) déléguant les appels de méthode à une classe parente ou sœur de type. C'est utile pour accéder aux méthodes héritées qui ont été remplacées dans une classe.
object_or_type détermine quel ordre de résolution des méthodes est utilisé pour la recherche. La recherche commence à partir de la classe qui suit immédiatement le type.
For example, if
__mro__
of object_or_type isD -> B -> C -> A -> object
and the value of type isB
, thensuper()
searchesC -> A -> object
.The
__mro__
attribute of the class corresponding to object_or_type lists the method resolution search order used by bothgetattr()
andsuper()
. The attribute is dynamic and can change whenever the inheritance hierarchy is updated.Si le second argument est omis, l'objet super obtenu n'est pas lié. Si le second argument est un objet,
isinstance(obj, type)
doit être vrai. Si le second argument est un type,issubclass(type2, type)
doit être vrai (c'est utile pour les méthodes de classe).When called directly within an ordinary method of a class, both arguments may be omitted ("zero-argument
super()
"). In this case, type will be the enclosing class, and obj will be the first argument of the immediately enclosing function (typicallyself
). (This means that zero-argumentsuper()
will not work as expected within nested functions, including generator expressions, which implicitly create nested functions.)Il existe deux autres cas d'usage typiques pour super. Dans une hiérarchie de classes à héritage simple, super peut être utilisée pour obtenir la classe parente sans avoir à la nommer explicitement, rendant le code plus maintenable. Cet usage se rapproche de l'usage de super dans d'autres langages de programmation.
Le second est la gestion d'héritage multiple coopératif dans un environnement d'exécution dynamique. Cet usage est unique à Python, il ne se retrouve ni dans les langages compilés statiquement, ni dans les langages ne gérant que l'héritage simple. Cela rend possible d'implémenter un héritage en diamant dans lequel plusieurs classes parentes implémentent la même méthode. Une bonne conception implique que ces implémentations doivent avoir la même signature lors de leur appel dans tous les cas (parce que l'ordre des appels est déterminée à l'exécution, parce que l'ordre s'adapte aux changements dans la hiérarchie, et parce que l'ordre peut inclure des classes sœurs inconnues avant l'exécution).
Dans tous les cas, un appel typique à une classe parente ressemble à :
class C(B): def method(self, arg): super().method(arg) # This does the same thing as: # super(C, self).method(arg)
En plus de la recherche de méthodes,
super()
fonctionne également pour la recherche d'attributs. Un cas d'utilisation possible est l'appel d'un descripteur d'une classe parente ou sœur.Note that
super()
is implemented as part of the binding process for explicit dotted attribute lookups such assuper().__getitem__(name)
. It does so by implementing its own__getattribute__()
method for searching classes in a predictable order that supports cooperative multiple inheritance. Accordingly,super()
is undefined for implicit lookups using statements or operators such assuper()[name]
.Notez aussi que, en dehors de sa forme sans argument,
super()
peut être utilisée en dehors des méthodes. La forme à deux arguments est précise et contient tous les arguments nécessaires, donnant les références appropriées. La forme sans argument fonctionne seulement à l'intérieur d'une définition de classe, puisque c'est le compilateur qui donne les détails nécessaires à propos de la classe en cours de définition, ainsi qu'accéder à l'instance courante pour les méthodes ordinaires.Pour des suggestions pratiques sur la conception de classes coopératives utilisant
super()
, consultez guide to using super().
- class tuple
- class tuple(iterable)
Ce n'est pas une fonction,
tuple
est en fait un type de séquence immuable, comme documenté dans N-uplets et Types séquentiels — list, tuple, range.
- class type(object)¶
- class type(name, bases, dict, **kwds)
With one argument, return the type of an object. The return value is a type object and generally the same object as returned by
object.__class__
.La fonction native
isinstance()
est recommandée pour tester le type d'un objet, car elle prend en compte l'héritage.With three arguments, return a new type object. This is essentially a dynamic form of the
class
statement. The name string is the class name and becomes the__name__
attribute. The bases tuple contains the base classes and becomes the__bases__
attribute; if empty,object
, the ultimate base of all classes, is added. The dict dictionary contains attribute and method definitions for the class body; it may be copied or wrapped before becoming the__dict__
attribute. The following two statements create identicaltype
objects:>>> class X: ... a = 1 ... >>> X = type('X', (), dict(a=1))
See also:
Les arguments nommés fournis à la forme à trois arguments sont passés au mécanisme de métaclasse approprié (généralement
__init_subclass__()
) de la même manière que les arguments nommés dans une définition de classe (en plus de metaclass).Voir aussi Personnalisation de la création de classes.
Modifié dans la version 3.6: Subclasses of
type
which don't overridetype.__new__
may no longer use the one-argument form to get the type of an object.
- vars()¶
- vars(object)
Return the
__dict__
attribute for a module, class, instance, or any other object with a__dict__
attribute.Objects such as modules and instances have an updateable
__dict__
attribute; however, other objects may have write restrictions on their__dict__
attributes (for example, classes use atypes.MappingProxyType
to prevent direct dictionary updates).Without an argument,
vars()
acts likelocals()
.Une exception
TypeError
est levée si un objet est spécifié mais qu'il n'a pas d'attribut__dict__
(par exemple, si sa classe définit l'attribut__slots__
).Modifié dans la version 3.13: The result of calling this function without an argument has been updated as described for the
locals()
builtin.
- zip(*iterables, strict=False)¶
Itère sur plusieurs itérables en parallèle, produisant des n-uplets avec un élément provenant de chacun.
Exemple :
>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']): ... print(item) ... (1, 'sugar') (2, 'spice') (3, 'everything nice')
Plus formellement :
zip()
renvoie un itérateur de n-uplets, où le ie n-uplet contient le ie élément de chacun des itérables passés en arguments.Une autre façon de voir
zip()
est qu'elle transforme les lignes en colonnes et les colonnes en lignes, fournissant la matrice transposée.zip()
est paresseuse : les éléments ne sont traités qu'au moment où l'on itère, par exemple avec une bouclefor
ou en les plaçant dans uneliste
.Il faut savoir que les itérables passés à
zip()
peuvent avoir des longueurs différentes ; parfois par conception, parfois à cause d'un bogue dans le code qui a préparé ces itérables. Python propose trois approches différentes pour traiter ce problème :par défaut,
zip()
s'arrête lorsque l'itérable le plus court est épuisé. Elle ignore les éléments restants dans les itérables plus longs, coupant le résultat à la longueur de l'itérable le plus court :>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum'])) [(0, 'fee'), (1, 'fi'), (2, 'fo')]
zip()
est souvent utilisée dans les cas où les itérables sont supposés être de même longueur. Dans ce cas, il est recommandé d'utiliser l'optionstrict=True
. Cela produit la même chose que lazip()
habituelle :>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True)) [('a', 1), ('b', 2), ('c', 3)]
Mais, contrairement au comportement par défaut, elle lève une
ValueError
si un itérable est épuisé avant les autres :>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True): ... print(item) ... (0, 'fee') (1, 'fi') (2, 'fo') Traceback (most recent call last): ... ValueError: zip() argument 2 is longer than argument 1
Sans l'argument
strict=True
, tout bogue entraînant des itérables de longueurs différentes est réduit au silence, se manifestant éventuellement comme un bogue difficile à trouver dans une autre partie du programme.les itérables plus courts peuvent être remplis avec une valeur constante pour que tous les itérables aient la même longueur. C'est le cas pour
itertools.zip_longest()
.
Cas extrêmes : avec un seul argument itérable,
zip()
renvoie un itérateur de « 1-uplet ». Sans argument, elle renvoie un itérateur vide.Trucs et astuces :
il est garanti que les itérables sont évalués de gauche à droite. Cela rend possible de grouper une séquence de données en groupes de taille n via
zip(*[iter(s)]*n, strict=True)
. Cela duplique le même itérateurn
fois ; par conséquent le n-uplet obtenu contient le résultat den
appels à l'itérateur. Cela a pour effet de diviser la séquence en morceaux de taille n.zip()
peut être utilisée conjointement avec l'opérateur*
pour dézipper une liste :>>> x = [1, 2, 3] >>> y = [4, 5, 6] >>> list(zip(x, y)) [(1, 4), (2, 5), (3, 6)] >>> x2, y2 = zip(*zip(x, y)) >>> x == list(x2) and y == list(y2) True
Modifié dans la version 3.10: ajout de l'argument
strict
.
- __import__(name, globals=None, locals=None, fromlist=(), level=0)¶
Note
c'est une fonction avancée qui n'est pas fréquemment nécessaire, contrairement à
importlib.import_module()
.Cette fonction est invoquée via l'instruction
import
. Elle peut être remplacée (en important le modulebuiltins
et en y remplaçantbuiltins.__import__
) afin de changer la sémantique de l'instructionimport
, 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 deimportlib.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'instructionimport
.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'environnementPYTHONCASEOK
est ignorée.
Notes