2.3 Fonctions intégrées

L'interpréteur Python possède un certain nombre de fonctions intégrées qui sont toujours disponibles. Elles sont listées ci-dessous dans l'ordre alphabétique.

__import__(nom[, global[, local[, depuisliste]]])

Cette fonction est invoquée par l'instruction import. La principale raison de son existence est que vous puissiez la remplacer par une autre fonction qui possède une interface compatible, de façon à changer la sémantique de l'instruction import. Pour des exemples sur comment et pourquoi le faire, voir les modules de la bibliothèque standard ihooks et rexec. Voir aussi le module intégré imp, qui définit quelques opérations utiles à partir desquelles vous pourrez construire votre propre fonction __import__().

Par exemple, l'instruction `import spam' provoque l'appel suivant: __import__('spam', global(), local(), []); l'instruction from spam.jambon import oeufs provoque l'appel de __import__('spam.jambon', global(), local(),['oeufs']). Notez que bien que locals() et ['oeufs'] soient passées comme arguments, la fonction __import__() n'affecte pas de valeur à la variable locale appelée oeufs; ceci est fait par la suite du code qui est généré pour l'instruction import. (En fait, l'implémentation standard n'utilise pas du tout son argument local, et ne se sert de globalque pour déterminer le contexte du package de l'instruction import.)

Quand la variable nom est de la forme package.module, normalement, le package de niveau supérieur (le nom avant le premier point) est retourné, pas le module appelé nom. Cependant, quand un argument depuisliste non vide est fourni, le module de nom nom est retourné. Ceci est fait pour garantir la compatibilité avec le bytecode généré pour les différentes formes de l'instruction import; quand on utilise "import spam.jambon.oeufs", le package de niveau supérieur spam doit être placé dans l'espace de noms qui importe, mais quand on utilise "from spam.jambon import oeufs", le sous-package spam.jambon doit être utilisé pour trouver la variable oeufs. Comme introduction à ce comportement, utilisez getattr()pour extraire les composants désirés. Par exemple, vous pourriez définir la fonction d'aide suivante:

import string

def my_import(nom):
    mod = __import__(nom)
    composants = string.split(noms, '.')
    for comp in composants[1:]:
        mod = getattr(mod, comp)
    return mod

abs(x)

Retourne la valeur absolue d'un nombre. L'argument doit être un entier simple ou long, ou un nombre à virgule flottante. Si l'argument est un nombre complexe, sa magnitude est retournée (racine de la somme des carrés des parties réelle et imaginaire).

apply(fonction, args[, motscles])

L'argument fonction doit être un objet appelable (une fonction ou une méthode définie par l'utilisateur ou intégrée, ou un objet classe) et l'argument args doit être une séquence (si ce n'est pas un tuple, la séquence est d'abord convertie en un tuple). La fonction function est appelée avec args comme liste d'arguments; le nombre d'arguments est la longueur du tuple. (C'est différent d'appeler simplement fonction(args), puisque dans ce cas il y a toujours exactement un argument.) Si l'argument optionnel motscles est présent, il doit s'agir d'un dictionnaire dont les clés sont des chaînes de caractères. Il spécifie les arguments mots-clés à ajouter à la fin de la liste d'arguments.

buffer(objet[, decalage[, taille]])

L'argument objet doit être un objet qui supporte l'interface d'appel de buffer (tel que les chaînes, les tableaux, et les buffers). Un nouvel objet buffer sera créé, qui référence l'argument objet. L'objet buffer sera une tranche depuis le début de objet(ou depuis le decalage spécifié). La tranche sera étendue jusqu'à la fin de objet (ou aura la longueur donnée par l'argument taille).

callable(objet)

Retourne vrai si l'argument objet apparaît appelable, faux sinon. Si le résultat est vrai, il est encore possible qu'un appel échoue, mais s'il est faux, appeler objet échouera toujours. Notez que les classes sont appelables (appeler une classe retourne une nouvelle instance); les instances de classes sont appelables si elles possèdent une méthode __call__().

chr(i)

Retourne une chaîne de caractères dont le code ASCII est l'entier i, par exemple, chr(97) retourne la chaîne 'a'. C'est l'inverse de la fonction ord(). L'argument doit être dans l'intervalle [0..255] inclus; ValueError sera déclenché si i est en-dehors de cet intervalle.

cmp(x, y)

Compare les deux objets x et y et retourne un entier selon le résultat. La valeur de retour est négative si x < y, zéro si x == y et strictement positif si x > y.

coerce(x, y)

Retourne un tuple constitué des deux arguments numériques convertis en un type commun, en suivant les règles utilisées dans les opérations arithmétiques.

compile(chaine, fichier, genre)

Compile la chaine en un objet code. Les objets code peuvent être exécutés par une instruction exec ou évalués par un appel à eval(). L'argument fichier doit donner le nom du fichier depuis lequel le code est lu; passez par exemple '<string>' s'il n'a pas été lu depuis un fichier. L'argument genre spécifie quel genre de code doit être compilé; il peut s'agir de 'exec' si chaine consiste en une séquence d'instructions, 'eval' s'il consiste en une expression unique, ou 'single' s'il consiste en une instruction interactive unique (dans ce dernier cas, les instructions d'expressions dont le résultat est autre chose que None seront affichées).

complex(reel[, imag])

Crée un nombre complexe de valeur reel + imag*j ou convertit une chaîne ou un nombre en un nombre complexe. Chaque argument peut être de n'importe quel type numérique (y compris complexe). Si imag est omis, il prend la valeur zéro par défaut et la fonction est une fonction de conversion numérique comme int(), long() et float(); dans ce cas il accepte aussi un argument chaîne qui doit être un nombre complexe valide.

delattr(objet, nom)

C'est un parent de setattr(). Les arguments sont un objet et une chaîne de caractères. La chaîne doit être le nom d'un des attributs de l'objet. La fonction détruit l'attribut nommé, pour autant que l'objet l'autorise. Par exemple, delattr(x, 'foobar') équivaut à del x.foobar.

dir([objet])

Sans argument, retourne la liste des noms dans la table de symboles courante. Avec des arguments, essaie de retourner une liste d'attributs valides pour cet objet. Cette information est tirée des attributs __dict__, __methods__ et __members__ de l'objet, s'ils sont définis. La liste n'est pas nécessairement complète; par exemple, pour les classes, les attributs définis dans les classes de base ne sont pas incluses, et pour les instances de classes, les méthodes ne sont pas incluses. La liste résultante est triée dans l'ordre alphabétique. Par exemple:

>>> import sys
>>> dir()
['sys']
>>> dir(sys)
['argv', 'exit', 'modules', 'path', 'stderr', 'stdin', 'stdout']

divmod(a, b)

Prend deux nombres comme arguments et retourne une paire de nombres constituée de leur quotient et du reste en utilisant la division d'entiers longs. Avec des types d'opérandes mélangés, les règles pour les opérateurs d'arithmétique binaire s'appliquent. Pour les entiers simples et longs, le résultat est le même que (a / b, a % b). Pour les nombres à virgule flottante le résultat est

(q, a %
  b)

, où q est habituellement

math.floor(a /
  b)

mais peut être inférieur de 1 à ce résultat. Dans tous les cas

q *
  b + a % b

est très proche de a, si a % b est non nul il a le même signe que b, et 0 <= abs(a % b) < abs(b).

eval(expression[, global[, local]])

Les arguments sont une chaîne de caractères et deux dictionnaires optionnels. L'argument expression est analysé et évalué comme une expression Python (techniquement parlant, une liste de conditions) en utilisant les dictionnaires global et local comme espaces de noms global et local. Si le dictionnaire local est omis il prend par défaut la valeur du dictionnaire global. Si les deux dictionnaires sont omis, l'expression est exécutée dans l'environnement dans lequel eval a été appelé. La valeur de retour est le résultat de l'expression évaluée. Les erreurs de syntaxe provoquent des exceptions. Exemple:

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

Cette fonction peut aussi servir à exécuter des objets code arbitraires (c'est-à-dire créé par compile()). Dans ce cas, passez un objet code à la place d'une chaîne de caractères. L'objet code doit avoir été compilé en passant 'eval' à l'argument kind.

Astuce: l'exécution dynamique d'instructions est supporté par l'instruction exec. L'exécution d'instructions depuis un fichier est supportée par la fonction execfile(). Les fonctions globals() et locals() retournent les dictionnaires global et local courants, respectivement, qu'il peut être utile de passer pour une utilisation de eval() ou de execfile().

execfile(fichier[, global[, local]])

Cette fonction est similaire à l'instruction exec, mais elle analyse un fichier au lieu d'une chaîne de caractères. Elle diffère de l'instruction import dans la mesure où elle ne se sert pas de l'administration de module - elle lit le fichier sans condition et ne crée pas un nouveau module. ¹

Les arguments sont un nom de fichier et deux dictionnaires optionnels. Le fichier est analysé et évalué comme une séquence d'instructions Python (comme pour un module) en se servant des dictionnaires global et local comme espace de noms global et local. Si le dictionnaire local est omis il prend par défaut la valeur du dictionnaire global. Si les deux dictionnaires sont omis, l'expression est exécutée dans l'environnement dans lequel execfile() a été appelé. La valeur de retour est None.

filter(fonction, liste)

Construit une liste pour ceux des éléments de liste pour lesquels fonction retourne vrai. Si liste est une chaîne ou un tuple, le résultat a aussi ce type; sinon c'est toujours une liste. Si fonction vaut None, on prend la fonction d'identité, c'est-à-dire que tous les éléments de liste qui sont faux (zéro ou vides) sont enlevés.

float(x)

Convertit une chaîne de caractères ou un nombre en un nombre à virgule flottante. Si l'argument est une chaîne, il doit contenir un nombre décimal ou à virgule flottante, éventuellement signé, et qui peut être incorporé dans des blancs; c'est le même comportement que string.atof(x). Sinon, l'argument peut être un entier simple ou long, ou un nombre à virgule flottante, et un nombre à virgule flottante de même valeur (dans la limite de la précision en virgule flottante de Python) est retournée.

Note: Quand on passe une chaîne, les valeurs NaN et Infinity peuvent être retournées, selon la bibliothèque C sous-jacente. L'ensemble spécifique des chaînes acceptées qui donnent ces valeurs de retour dépend entièrement de la bibliothèque C sous-jacente et est notoirement variable.

getattr(objet, nom[, defaut])

Retourne la valeur des attributs nommés de objet. nom doit être une chaîne de caractères. 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') équivaut à x.foobar. Si l'attribut nommé n'existe pas, defaut est retourné s'il existe, sinon AttributeError est déclenchée.

globals()

Retourne un dictionnaire qui représente la table de symboles globaux courante. Il s'agit toujours du dictionnaire du module courant (à l'intérieur d'une fonction ou d'une méthode, c'est le module dans lequel elle est définie, pas le module depuis lequel elle est appelée).

hasattr(objet, nom)

Les arguments sont un objet et une chaîne de caractères. Le résultat est 1 si la chaîne est le nom d'un des attributs de l'objet, 0 sinon. (Cette fonction est implémentée en appelant getattr(object, nom) et en voyant si une exception est déclenchée ou non.)

hash(objet)

Retourne la valeur de hachage de l'objet (s'il en a une). Les valeurs de hachage sont des entiers. Elles servent à comparer rapidement des clés de dictionnaires pendant la consultation d'un dictionnaire. Les valeurs numériques dont le test d'égalité est vrai ont la même valeur de hachage (même si elles sont de types différents, par exemple 1 et 1.0).

hex(x)

Convertit un nombre entier (de n'importe quel taille) en une chaîne hexadécimale. Le résultat est une expression Python valide. Note: ceci retourne toujours un littéral non signé, c'est-à-dire que sur une machine 32 bits, hex(-1) retourne '0xffffffff'. Quand il est évalué sur une machine qui a la même taille de mots, ce littéral est évalué comme -1; avec une taille de mots différente, le résultat peut être un grand nombre positif ou une exception OverflowError peut être déclenchée.

id(object)

Retoune l'`identité' d'un objet. Il s'agit d'un entier (ou d'un entier long) dont on est sûr qu'il est unique et constant pour cet objet pendant son cycle de vie. Deux objets dont le cycle de vie sont disjoints peuvent avoir la même valeur d'id(). (Note d'implémentation: c'est l'adresse de l'objet.)

input([invite])

Equivaut à eval(raw_input(invite)). Avertissement: Cette fonction ne résiste pas aux erreurs de l'utilisateur! Elle s'attend à recevoir une expression Python valide comme donnée d'entrée; si ce n'est pas le cas, une SyntaxError sera déclenchée. D'autres exceptions peuvent être déclenchées si une erreur se produit pendant l'évaluation. (D'ailleurs, parfois c'est exactement ce que vous voulez quand vous écrivez un script rapide pour utilisation en expert.)

Si le module readline a été chargé, alors input() s'en servira pour fournir une édition de ligne sophistiquée et des fonctionnalités d'historique.

Pensez à utiliser la fonction raw_input() pour gérer les entrées utilisateur d'une façon générale.

int(x[, base])

Convertit une chaîne de caractères en un entier simple. Si l'argument est une chaîne, elle doit contenir une nombre décimal, éventuellement signé, représentable comme un entier, et qui peut être incorporé dans des blancs; c'est le même comportement que string.atoi(x[, base]). Le paramètre base donne la base pour la conversion et peut être n'importe quel entier dans l'intervalle [2, 36]. Si base est spécifiée et que x n'est pas une chaîne de caractères, TypeError est déclenchée. Sinon, l'argument peut être un entier simple ou long ou un nombre à virgule flottante. La conversion de nombres à virgule flottante en entier est définie par la sémantique du C; normalement la conversion arrondit à l'entier inférieur.²

intern(chaine)

Fait entrer chaine dans la table des chaînes de caractères ``internalisés'' et retourne la chaîne internalisée - qui est chaine elle-même ou une copie. Internaliser des chaînes est utile pour gagner un peu de performance dans les consultations de dictionnaires - si les clés dans un dictionnaire sont internalisées, et que la clé de consultation est internalisée, les comparaisons de clés (après hachage) par la comparaison de pointeurs au lieu d'une comparaison de chaînes. Normalement, les noms utilisés dans un programme Python sont automatiquement internalisés, et les dictionnaires utilisés pour les conserver les attributs de modules, de classes ou d'instances ont des clés internalisées. Les chaînes internalisées sont immortelles (c'est-à-dire qu'elles ne sont jamais détruites par le ramasse-miettes).

isinstance(objet, classe)

Retourne vrai si l'argument objet est une instance de l'argument classe, ou une sous-classe (directe ou indirecte) de celle-ci. Retourne également vrai si classe est un objet type et que objet est un objet de ce type. Si objet n'est pas une instance de classe ou un objet du type donné, la fonction retourne toujours faux. Si class n'est ni un objet classe ni un objet type, une exception TypeError est déclenchée.

issubclass(classe1, classe2)

Retourne vrai si classe1 est une sous-classe (directe ou indirecte) de classe2. Une classe est considérée comme une sous-classe d'elle-même. Si l'un ou l'autre des arguments n'est pas un objet classe, une exception TypeError est déclenchée.

len(s)

Retourne la longueur (le nombre d'éléments) d'un objet. L'argument doit être une séquence (chaîne de caractères, tuple ou liste) ou un tableau associatif (dictionnaire).

list(sequence)

Retourne une liste dont les éléments sont les mêmes et dans le même ordre que les éléments de sequence. Si sequence est déjà une liste, une copie est effectuée et retournée, comme avec sequence[:]. Par exemple, list('abc') retourne ['a', 'b', 'c'] et list( (1, 2, 3) ) retourne [1, 2, 3].

locals()

Retourne un dictionnaire représentant la table de symboles locaux courante. Avertissement: Le contenu de ce dictionnaire ne doit pas être modifié; les changements peuvent ne pas affecter les valeurs des variables locales utilisées par l'interpréteur.

long(x)

Convertit une chaîne de caractères ou un nombre en un entier long. Si l'argument est une chaîne de caractères, il doit contenir un nombre décimal éventuellement signé d'une taille arbitraire, et qui peut être incorporée dans des espaces; c'est le même comportement que string.atol(x). Sinon, l'argument peut être un entier simple ou long, ou un nombre à virgule flottante, et un entier long de même valeur est retourné. La conversion de nombres à virgule flottante en entier est définie par la sémantique du C; voir la description de int().

map(fonction, liste, ...)

Applique fonction à chaque élément de of liste et retourne la liste des résultats. Si des arguments liste supplémentaires sont passés, fonction doit prendre autant d'arguments que de listes et est appliquée aux éléments de toutes les listes en parallèle; si une liste est plus courte qu'une autre on fait comme si elle était étendue avec des éléments None. Si fonction est None, on prend la fonction d'identité; s'il y a plusieurs listes d'arguments, map() retourne une liste constituée de tuples contenant les éléments correspondants de toutes les listes (c'est-à-dire une espèce d'opération de transposition). Les arguments list peuvent être n'importe quelle sorte de séquence; le résultat est toujours une liste.

max(s[, args...])

Avec un argument unique s, retourne le plus grand élément d'une séquence non vide (par exemple, une chaîne de caractères, un tuple ou une liste). Avec plus d'un argument, retourne le plus grand des arguments.

min(s[, args...])

Avec un argument unique s, retourne le plus petit élément d'une séquence non vide (par exemple, une chaîne de caractères, un tuple ou une liste). Avec plus d'un argument, retourne le plus petit des arguments.

oct(x)

Convertit un nombre entier (de n'importe quel taille) en une chaîne octale. Le résultat est une expression Python valide. Note: ceci retourne toujours un littéral non signé, c'est-à-dire que sur une machine 32 bits, hex(-1) retourne '037777777777'. Quand il est évalué sur une machine qui a la même taille de mots, ce littéral est évalué comme -1; avec une taille de mots différente, le résultat peut être un grand nombre positif ou une exception OverflowError peut être déclenchée.

open(nomfichier[, mode[, taillebuf]])

Retourne un nouvel objet fichier (décrit précédemment dans les Types Intégrés). Les deux premiers arguments sont les mêmes que pour la fonction fopen() de stdio: nomfichier est le nom du fichier à ouvrir, mode indique comment le fichier doit être ouvert: 'r' en lecture, 'w' en écriture (en tronquant un fichier existant), et 'a' en mode ajout (ce qui sur certains systèmes Unix signifie que toutes les écritures ajoutent à la fin du fichier, indépendamment de la position de recherche courante).

Les modes 'r+', 'w+' et 'a+' ouvrent le fichier pour mise à jour (notez que 'w+' tronque le fichier). Ajoutez 'b' au mode pour ouvrir le fichier en mode binaire, sur les systèmes qui différencient les fichiers binaires et texte (sinon il est ignoré). Si le fichier ne peut pas être ouvert, IOError est déclenchée.

Si mode est omis, sa valeur par défaut est 'r'. En ouvrant un fichier binaire, vous devez ajouter 'b' à la valeur du mode pour améliorer la portabilité. (C'est utile même sur les systèmes qui ne traitent pas les fichiers texte et binaires différemment, où cela sert de documentation.) L'argument optionnel taillebuf spécifie la taille de buffer voulue pour le fichier: 0 signifie sans buffer, 1 avec buffer par ligne, et toute autre valeur positive indique l'usage d'un buffer de cette taille (approximativement). Avec une taillebuf négative on prend la valeur par défaut du système, qui est généralement buffer par ligne pour les appareils tty et avec buffer complet pour les autres fichiers. Si ce paramètre est omis, la valeur par défaut du système est utilisée. ³

ord(c)

Retourne la valeur ASCII d'une chaîne constituée d'un caractère ou d'un caractère Unicode. Par exemple, ord('a') retourne l'entier 97, ord(u'2020') retourne 8224. C'est l'inverse de chr() pour les chaînes de caractères et de unichr() pour les caractères Unicode.

pow(x, y[, z])

Retourne x à la puissance y; si z est présent, retourne x à la puissance y, modulo z (calculé plus efficacement que par pow(x, y) % z). Les arguments doivent être de type numérique. Avec des opérandes de types différents, les règles pour les opérateurs arithmétiques binaires s'appliquent. Le type effectif de l'opérande détermine le type du résultat ; si le résultat ne peut pas s'exprimer dans ce type, la fonction déclenche une exception; par exemple, pow(2, -1) ou

pow(2,
  35000)

ne sont pas autorisés.

range([debut, ]fin[, pas])

Fonction qui sert à créer des listes contenant des progressions arithmétiques. On l'utilise le plus souvent dans des boucles for. Les arguments doivent être des entiers simples. Si l'argument pas est omis, il prend par défaut la valeur 1. Si l'argument debut est omis, il prend la valeur 0 par défaut. La forme complète retourne une liste d'entiers simples [debut, debut + pas, debut + 2 * pas, ...]. Si pas est positif,le dernier élément est le plus grand debut + i * pas inférieur à fin; si pas est négatif, le dernier élément est le plus grand debut + i * pas plus grand que fin. pas ne doit pas être nul (sinon ValueError est déclenchée). Exemple:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

raw_input([invite])

Si l'argument invite est présent, il est écrit sur la sortie standard sans saut de ligne à la fin. La fonction lit ensuite une ligne depuis l'entrée, la convertit en une chaîne de caractères (en ôtant le saut de ligne final), et retourne le résultat. Quand EOF est lu, EOFError est déclenchée. Exemple:

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

Si le module readline était chargé, alors raw_input() s'en servira pour fournir des fonctions élaborées d'édition de ligne et d'historique.

reduce(fonction, sequence[, initializer])

Applique la fonction à deux arguments cumulativement aux éléments de sequence, de gauche à droite, de façon à réduire la séquence à une valeur unique. Par exemple, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calcule ((((1+2)+3)+4)+5). Si la valeur optionnelle initializer est présente, elle est placée devant les éléments de la séquence dans le calcul, et sert de valeur par défaut quand la séquence est vide.

reload(module)

Réanalyse et réinitialise un module déjà importé. L'argument doit être un objet module, il doit donc avoir été importé avec succès précédemment. Ceci est utile si vous avez édité le fichier source du module en utilisant un éditeur externe et que vous voulez essayer la nouvelle version sans quitter l'interpréteur Python. La valeur de retour est l'objet module (c'est-à-dire la même que l'argument module).

Il y a un certain nombre de chausses-trappes:

Si le module est syntaxiquement correct mais que l'initialisation échoue, la première instruction import ne fait pas entrer son nom dans l'espace de nom local, mais un objet module (partiellement initialisé) est stocké dans sys.modules. Pour recherger le module il faut d'abord refaire un import (ce qui associera le nom à l'objet partiellement initialisé) avant de pouvoir exécuter un reload().

Quand un module est rechargé, son dictionnaire (contenant les variables globales du module) est conservé. Les redéfinitions de noms écraseront les anciennes définitions, donc ceci ne pose généralement pas de problème. Si la nouvelle version d'un module ne définit pas un nom qui était défini dans par l'ancienne version, l'ancienne définition subsiste. On peut tirer avantage de cette fonctionnalité si le module maintient une table globale ou un cache des objets - avec une instruction try il peut tester la présence de la table et sauter son initialisation au besoin.

Il est autorisé, bien que généralement pas très utile, de recharger les modules intégrés ou chargé dynamiquement, sauf sys, __main__ et __builtin__. Dans de nombreux cas, cependant, les modules d'extension ne sont pas conçus pour être initialisés plus d'une fois, et peuvent planter de façon arbitraire si on les recherge.

Si un module importe des objets depuis un autre module en utilisant from ... import ..., l'appel de reload() pour l'autre module ne redéfinit pas les objets importés depuis celui-ci - une façon de contourner ce problème est de réexécuter l'instruction from, une autre est d'utiliser import et des noms qualifiés (module.name) à la place.

Si un module instancie des instances d'une classe, recharger le module qui définit la classe n'affecte pas les définitions de méthodes des instances - elles continuent à utiliser les anciennes définitions de classes. Il en est de même des classes dérivées.

repr(objet)

Retourne une chaîne contenant une représentation imprimable d'un objet. C'est la même valeur que celle qui résulte des conversions (guillemets inversés). Il est parfois utile de pouvoir accéder à cette opération par une fonction ordinaire. Pour de nombreux types, cette fonction essaie de retourner une chaîne qui produirait un objet de même valeur quand on la passe en argument à eval().

round(x[, n])

Retourne la valeur en virgule flottante x arrondie à n chiffres après la virgule. Si n est omis, il prend la valeur zéro par défaut. Le résultat est un nombre à virgule flottante. Les valeurs sont arrondies au plus proche multiple de 10 à la puissance moins n; si deux multiples sont aussi proches, l'arrondi est toujours fait en partant de 0 (ainsi, par exemple, round(0.5) vaut 1.0 et coderound(-0.5) vaut -1.0).

setattr(objet, nom, valeur)

C'est la fonction miroir de getattr(). Les arguments sont un objet, une chaîne de caractères et une valeur arbitraire. La chaîne de caractères peut renvoyer à un attribut existant ou à un nouvel attribut. La fonction affecte la valeur à l'attribut, dans la mesure où l'objet l'autorise. Par exemple, setattr(x, 'truc', 123) équivaut à x.truc = 123.

slice([debut, ]fin[, pas])

Retourne un objet "tranche" qui représente l'ensemble des indices spécifiés par range(debut, fin, pas). Les arguments debut et pas prennent la valeur None par défaut. Les objets tranche ont des attributs en lecture seule start, stop et step qui retournent simplement les valeurs des arguments (ou leurs valeurs par défaut). Ils n'ont pas d'autre fonctionnalités; cependant elles sont utilisées par Numerical Python et d'autres extensions tierces. Les objets tranche sont aussi générés quand une syntaxe d'indiçage étendu est utilisée, par exemple pour "a[debut:fin:pas]" ou "a[debut:fin, i]".

str(objet)

Retourne une chaîne de caractères contenant une représentation joliment imprimable d'un objet. Pour les chaînes de caractères, retourne la chaîne elle-même. La différence avec repr(objet) est que str(objet) n'essaie pas toujours de retourner une chaîne acceptable comme argument de eval(); son but est de retourner une chaîne imprimable.

tuple(sequence)

Retourne un tuple dont les éléments sont les mêmes et dans le même ordre que les éléments de sequence. Si sequence est déjà un tuple, il est retourné sans changement. Par exemple, tuple('abc') retourne ('a', 'b', 'c') et tuple([1, 2, 3]) retourne (1, 2, 3).

type(objet)

Retourne le type d'un objet. La valeur de retour est un objet type. Le module standard types définit des noms pour tous les types intégrés. For instance:

>>> import types
>>> if type(x) == types.StringType: print "C'est une chaîne"

unichr(i)

Retourne la chaîne Unicode d'un seul caractère dont le code Unicode est l'entier i, par exemple, unichr(97) retourne la chaîne u'a'. C'est l'inverse de ord() pour les chaînes Unicode. L'argument doit être dans l'intervalle [0..65535], bornes incluses. ValueError est déclenchée sinon. Nouveau en version 2.0

unicode(chaine[, encodage[, erreurs]])

Décode chaine en se servant du codec pour encodage. La gestion des erreurs est effectuée d'après erreurs. Le comportement par défaut est de décoder UTF-8 en mode strict, ce qui signifie que les erreurs d'encodage déclenchent ValueError. Voir aussi le module codecs. Nouveau en version 2.0

vars([objet])

Sans arguments, retourne un dictionnaire correspondant à la table se symboles locaux courante. Avec un module, une classe ou un objet instance de classe comme argument (ou tout autre argument doté d'un attribut __dict__), retourne un dictionnaire correspondant à la table de symboles de l'objet. Il ne faut pas modifier le dictionnaire retourné: les effets sur la table de symboles correspondante sont indéfinis.⁴

xrange([debut, ]fin[, pas])

Cette fonction est très proche de range(), mais elle retourne un ``objet xrange'' au lieu d'une liste. Il s'agit d'un type de séquence opaque qui produit les mêmes valeurs que la liste correspondante, sans réellement les stocker toutes simultanément. L'avantage de xrange() sur range() est minime (du fait que xrange() doit tout de même créer les valeurs quand on les lui demande) sauf quand un intervalle très large est utilisé sur une machine limitée en mémoire (MS-DOS par exemple) ou quand tous les éléments de l'intervalle ne sont jamais utilisés (par exemple quand la boucle se termine habituellement par break).

zip(seq1, ...)

Cette fonction retourne une liste de tuples, où chaque tuple contient le i-ème élément de chaque séquence en argument. Il faut au moins une séquence, sinon une TypeError est déclenchée. La liste en retour est tronquée en longueur à la longueur de la séquence argument la plus courte. Quand il y a plusieurs séquences argument qui ont toutes la même longueur, zip() est similaire à map() avec comme argument initial None. Avec une seule séquence comme argument, elle retourne une liste de tuples à 1 élément. Nouveau en version 2.0

Notes

¹: Elle est utilisée relativement rarement donc il n'est pas garanti qu'elle devienne une instruction.

²: C'est très moche - c'est la définition du langage qui devrait obliger l'arrondi à l'entier inférieur.

³: Spécifier une taille de buffer n'a actuellement aucun effet sur les systèmes qui n'ont pas de fonction setvbuf(). L'interface pour spécifier la taille du buffer ne repose pas sur une méthode qui appelle setvbuf(), parce que celle-ci peut provoquer la création d'un fichier image de la mémoire (core dump) quand elle est appelée après qu'une entrée/sortie quelconque a été réalisée, et il n'y a aucun moyen fiable de déterminer si c'est le cas.

⁴: Dans l'implémentation en cours, les associations à des variables locales ne peuvent normalement pas être affectées de cette façon, mais les variables récupérées depuis d'autres espaces (les modules par exemple) peuvent l'être. Ceci peut changer.