-
Historique (non
traduit)
-
Options
d’invocations.
-
Variables
d’environnement.
-
Lexique :
Mots
clé, identifiants, phrases littérales, constantes
booléennes,
nombres, séquences, dictionnaires, opérateurs.
- Types de base et leurs
opérations :
« None »,
« bool », types « Numeric » , types « sequence »
, liste,
dictionnaire,
« string » (chaînes de caractères), fichier, réglage (set), date/heure,
types avancés.
- Enoncés d’instruction :
Assignation,
expressions conditionnelles, contrôle de flux, exceptions, espaces nommés, fonction
« def », classe « def ».
Itinérants; Générateurs;
Descripteurs; Décorateurs.
-
Fonctions
prédéfinies.
-
Exceptions
prédéfinies.
-
Méthodes standard
et redéfinition d’opérateurs dans les classes
créées personnellement.
-
Attributs
informatifs spéciaux d'état pour quelques
types.
-
Modules importants : sys, os, posix, posixpath,
shutil, time, string, re, math, getopt.
-
Liste des modules dans leur distribution de base.
Exploration de l’espace de travail
avec la syntaxe de Python pour Emacs.
***********************************************************************
Version 2.5 (What's new?)
Check updates at http://rgruet.free.fr/#QuickRef.
Please report errors, inaccuracies and suggestions to Richard Gruet (pqr at rgruet.net).
Last modified on June 8, 2007,
Upgrated by Richard Gruet for Python 2.5
14 december 2006,
Upgraded by Richard Gruet for Python 2.5
17 Feb 2005,
Upgraded by Richard Gruet for Python 2.4
03 Oct 2003,
Upgraded by Richard Gruet for Python 2.3
11 May 2003, rev 4
Upgraded by Richard Gruet for Python 2.2 (restyled by Andrei)
7 Aug 2001
Upgraded by Simon Brunning for Python 2.1
16 May 2001
Upgraded by Richard Gruet and Simon Brunning for Python 2.0
18 Jun 2000
Upgraded by Richard Gruet for Python 1.5.2
30 Oct 1995
Created by Chris Hoffmann for Python 1.3
Color coding:
Features added in 2.5 since 2.4
Features added in 2.4 since 2.3
Features added in 2.3 since 2.2
Features added in 2.2 since 2.1
Originally based on:
-
Python Bestiary, author: Ken
Manheimer.
-
Python manuals, authors: Guido
van Rossum and Fred Drake.
-
python-mode.el, author: Tim
Peters.
-
and the readers of comp.lang.python.
****************************************************************************************
-
French translation by Guy WALLON – NEUPRE – BELGIUM. Traduit en Français par Guy WALLON – NEUPRE – BELGIQUE
(Juillet 2007 – Dernière mise à jour : 15 décembre 2008).
****************************************************************************************
Useful links :
-
Python's nest: http://www.python.org
-
Official
documentation:
http://www.python.org/doc/
-
Other doc & free books: FAQs, Faqts, Dive
into Python, Python Cookbook, Thinking in Python, Text processing in Python.
-
Getting started: Official site, 7mn to Hello
World (windows).
-
Topics: Databases, Web programming,
XML, Web Services, Parsers, Scientific Computing, GUI programming,
Distributing.
-
Where to find packages: Easy Install,
Python Package Index (PyPI), Vaults of Parnassus, SourceForge (search
"python"), Python Eggs, O'Reilly Python DevCenter, Starship Python.
-
Wiki: moinmoin.
-
Newsgroups: comp.lang.python and
comp.lang.python.announce.
-
Misc pages: Daily Python URL, Kevin
Altis' WebLog, PEAK.
-
Python Development:
http://python.sourceforge.net/
-
Jython (Java impl. of Python):
http://www.jython.org/
-
ActivePython:
http://www.ActiveState.com/ASPN/Python/
-
Help desk: help@python.org
-
2 excellent Python reference books: Python
Essential Reference by David Beazley & Guido Van Rossum (Other New Riders)
and Python in a nutshell by Alex martelli (O'Reilly).
-
Python 2.4 Reference Card (cheatsheet)
by Laurent Pointal, designed for printing (15 pages).
-
Online Python 2.2 Quick Reference by the
New Mexico Tech Computer Center.
********************************************************************************************
Tip: From within the Python interpreter, type help, help(object)
or help("name") to get help.
********************************************************************************************
python[w] [-dEhimOQStuUvVWxX?] [-c command |
scriptFile | - ] [args]
(pythonw does not open a
terminal/console; python does).
Option. Effet.
-d Analyseur en sortie des informations de mise au point. (également PYTHONDEBUG=x)
-E Ignore les variables d’environnement (telles que PYTHONPATH)
-h Affiche un message d’aide et quitte (Autrefois -?)
-i Inspecte interactivement après avoir exécuté le script
(également PYTHONINSPECT=x) et force des messages
d’avertissement même si stdin ne semble pas être une borne.
-m module Cherche le module dans « sys.path »
et exécute le module comme
un script (Implémentation améliorée le module
« runpy » de Python 2.5)
-O Optimise le code binaire généré (également PYTHONOPTIMIZE=x).
Les mises en page sont supprimées.
-OO Enlève les lignes de documentation du code en plus des
optimisations de l’option –O
-Q arg Options de division : -Qold (défaut), -Qwarn, -Qwarnall, -Qnew
-S Ne pas optimiser « import site » à l’initialisation.
-t Avertissement de fin à propos d’un usage inconsistant d’une
étiquette, d’une tabulation (-tt: Avertissement d’erreur).
-u Binaire non mémorisé stdout et stderr. (également
PYTHONUNBUFFERED=x).
-U Force Python à interpréter toutes les phrases littérales en
Unicode littéral.
-v « Verbose » (Bavard) (trace les instructions importées)
(aussi PYTHONVERBOSE=x).
-V Affiche le numéro de version de Python et quitte.
-W arg Contrôle d’avertissement
(arg est action:message:category:module:lineno)
-x Saute la première ligne du code source, autorise l’utilisation
de formes non-unix de # !cmd.
-X Neutralise
les exceptions prédéfinies basées par classes
(pour un suivi des compatibilités
des exceptions)
-c command Spécifie la commande à exécuter (Voir sections suivantes).Ceci
termine la liste des options. (Les options suivantes sont
passées par arguments à la commande).
scriptFile Le nom du
fichier Python (.py) à exécuter. Lu depuis stdin.
- Le programme lit depuis stdin (par défaut : mode interactif si
un tty).
Args Passé au script ou à la commande (dans sys.argv[1:]).
S’il n’y a pas de fichier script ou de commande, Python entre en mode interactif.
**********************************************************************
Les IDEs disponibles dans les distributions standard : IDLE (basé sur tkinter, portable), Pythonwin (sous Windows). Autres IDEs libres : IPython (Interactivité augmentée du processus Python), ERIC, SPE, BOA constructor.
Entête typique d’un module Python :
#!/usr/bin/env python
# -*- coding: latin1 -*-
Depuis la version 2.3, l’encodage
d’un fichier source Python doit être déclaré comme une des deux premières
lignes (ou par les 7 bits Ascii par défaut) [PEP-0263], avec le format :
# -*- coding: encoding -*-
Les encodages standards sont
définis ici : e.g. ISO-8859-1 (aka latin1), iso-8859-15 (latin9), UTF-8... Tous
les encodages ne sont pas supportés, en particulier UTF-16 n’est pas supporté.
-
C’est une erreur de
syntaxe si un module contient une phrase littérale avec un caractère code 8
bits mais qui n’a pas de déclaration d’encodage (c’était un avertissement
auparavant).
-
Depuis 2.5,
« from __future__ import feature » les énoncés d’instruction doivent
être déclarés au début du code du fichier source.
- Personnalisation de site : le fichier sitecustomize.py est chargé automatiquement par Python s’il existe dans le chemin Python (idéalement localisé dans ${PYTHONHOME}/lib/site-packages/).
- Tip: lors du lancement d’un script Python sous windows.
<pythonHome>\python myScript.py args ... peut être réduit à :
myScript.py args ... si <pythonHome> est dans le la variable d’environnement PATH, et peut être ensuite réduite à :
myScript args ... à condition que .py;.pyw;.pyc;.pyo soit ajouté à la variable d’environnement PATHEXT.
*******************************************************************
Variable Effet.
PYTHONHOME Annuaire alternatif de préfixes (ou prefix;exec_prefix).
Le module de recherche de Path par défaut utilise
prefix/lib.
PYTHONPATH Étend le chemin de recherche par défaut pour les
fichiers modules. Le format est le même que pour
l’instruction du processus « $PATH »: un ou plusieurs
nom de chemin de directory séparés par ':' or ';' sans
les espaces de part et d’autre de la ponctuation !
Sous Windows, Python recherche d’abord la clé de
Registre
HKEY_LOCAL_MACHINE\Software\Python\PythonCore\x.y\Python
Path(valeur par défaut) ». Vous pouvez créer une clé
nommée, avec une phrase de valeur par défaut, après que
votre application ait donné le directory racine de votre
application.
Une alternative vous permet de créer un fichier texte,
avec l’extension « .pth », contenant le(s) chemin(s), un
seul chemin par ligne, et placer ce fichier dans le
chemin de recherche de Python (idéalement dans le
directory « site-packages ». Le mieux est de créer un
fichier « .pth » pour chaque application, vous pouvez
ainsi facilement désinstaller vos applications.
PYTHONSTARTUP : Si ceci est le nom d’un fichier en lecture seule, la commande Python contenue dans ce fichier est exécutée avant que le premier prompt soit présenté en mode interactif (pas de valeur par défaut).
PYTHONDEBUG : Si non vide, même action que l’option « -d ».
PYTHONINSPECT : Si non vide, même action que l’option « -I ».
PYTHONOPTIMIZE : Si non vide, même action que l’option « -O ».
PYTHONUNBUFFERED : Si non vide, même action que l’option « -u ».
PYTHONVERBOSE : Si non vide, même action que l’option « -v ».
PYTHONCASEOK : Si non vide, ignore la casse (majuscule/minuscule) dans les noms de fichiers/modules (imports).
**************************************************************************
and del for
is raise assert elif from
lambda return break else
global not try class except if
or while continue
exec import pass
with def finally
in print yield
- (La liste des mots-clés est disponible dans le module standard « keyword ».
- Eléments illégitimes (seulement valables dans des variables « string ») : $ ? (plus @ depuis la version 2.4).
- Une instruction DOIT être sur une seule ligne. Pour répartir un tel énoncé sur plusieurs lignes, utilisez « \ », comme avec le préprocesseur C.
Exception : Vous pouvez toujours scinder une instruction à l’intérieur des paires de (), [], or {}, ou dans des phrases (strings) contenues dans une paire de triple apostrophes (’’’).
- Plus d’un énoncé peut apparaître sur une ligne si le séparateur « ; » est utilisé.
- Un commentaire commence toujours pas « # » et continue jusqu’à la fin de la ligne.
**************************************************************************
(lettre | "_") (lettre | chiffre | "_")*
- Les mots-clés identifiants, attributs, etc. Python sont sensibles à la casse (majuscule/minuscule).
- Formes spéciales : _ident (non importé par 'from module import *'); __ident__ (nom défini par le système); __ident (nom de classe privée mutilantes).
2 possibilités : str (Chaîne standard 8 bits/char dépendant du système, comme ascii, iso 8859-1, utf-8, …) et unicode (chaînes 16 ou 32 bits/char dans le mode utf-16 ou bien 32 bits/char dans le mode utf-32).
"une chaîne de caractères contenue entre deux guillemets (double-quote)"
'une autre chaîne de caractères délimitée par des apostrophes (single quotes) et avec un « " » contenu dans la chaîne de caractères'
'''une chaîne de caractère contenant de nouvelles lignes et des marqueurs apostrophes (’), peut être délimité par des triples apostrophes.'''
"""on peut également utiliser comme délimiteur des triples guillements"""
u'une chaîne de caractère Unicode'
U"un autre chaîne de caractères Unicode"
r'une chaîne de caractère raw (exclusivement considérée en charactères. Même les chiffres sont traités comme des caractères è par d’opération math avec eux, par exemple.) où « \ » (backslash) est pris (littéralisé, traité comme un charactère): utilisable pour des expressions régulières ou des chemin Windows !'
R"une autre chaîne de caractères RAW " – Les chaînes ne peuvent se terminer avec « \ ».
ur'une chaîne raw Unicode'
UR"une autre chaîne RAW unicode "
- Utilisez « \ » à la fin de la ligne pour continuer la chaîne de caractères à la ligne suivante.
- Des chaînes adjacentes sont concaténées, e.g. 'Monty ' 'Python' est la même chose que 'Monty Python'.
-
u'hello'
+ ' world' --> u'hello world' (contraint à l’unicode)
*************************************************************************
Echappement Signification.
\newline Ignoré (escape newline)
\\ Backslash, littéralise la barre oblique inversée (\)
\e Escape (ESC)
\v Tabulation verticale (VT)
\' Apostrophe (')
\f Nouvelle feuille (form feed) (FF)
\000 Caractère avec une valeur octale 000 (triple lettre o).
\" Guillemets (")
\n Fin de ligne (Line Feed) (LF)
\a Cloche (BEL)
\r Retour à la ligne (Carriage Return) (CR)
\xhh Caractère avec valeur hexadécimale hh
\b Effacement arrière (Backspace) (BS)
\t Tabulation horizontale (TAB)
\uxxxx Caractère avec valeur hexadécimale en 16-bit xxxx
(Unicode seulement)
\Uxxxxxxxx Caractère avec valeur hexadécimale en 32-bit xxxxxxxx
(Unicode seulement)
\N{name} Caractère nommé dans une base de données Unicode
(Unicode seulement), e.g. u'\N{Greek Small Letter Pi}' <=> u'\u03c0' (= la lettre minuscule grecque Pi.).
(Réciproquement, dans le module unicodedata, unicodedata.name(u'\u03c0') == 'GREEK SMALL LETTER PI')
\AnyOtherChar Comme si on incluait l’anti-slash ( \ ),
e.g. str('\z') == '\\z'
- NUL byte (\000) n’est pas un marqueur de fin de chaîne; NULs peuvent être inclus dans des chaînes de caractères.
- Des chaînes (et rangées de tableau immuables (tuple)) sont immuables : elles ne peuvent être modifiées.
-
True
-
False
Dans la version 2.2.1, « True » et « False »
sont respectivement l’entier 1 et 0.
Depuis la version 2.3, ils sont à nouveau du type booléen bool.
***********************************************************************
Entier décimal (Decimal integer) : 1234, 1234567890546378940L (ou l)
Entier octal (Octal integer) : 0177, 0177777777777777777L
(débute avec le chiffre 0)
Entier hexadécimal (Hex integer) : 0xFF, 0XFFFFffffFFFFFFFFFFL
(Débute avec le chiffre 0 suivi de la lettre x : 0x ou 0X)
Entier long (Long integer) (précision illimitée) : 1234567890123456L
(Se termine par L ou l) ou long(1234).
Nombre flottant (Float) (double précision) : 3.14e-10, .001, 10., 1E3
Nombre complexe (Complex) : 1J, 2+3J, 4+5j (Se termine par J ou j,
le caractère « + » sépare (les parties réelle et
imaginaire d’un nombre à virgule flottante (float))
Des Entiers et des Entiers Longs se sont vu unifiés depuis la version 2.2 (depuis, le suffixe « L » n’est plus nécessaire)
************************************************************************
- Strings Chaînes de caractères (types « str » et « unicode ») de longueur 0, 1, 2 (voir plus haut) : '', '1', "12", 'hello\n'.
- Tuple (Ligne de tableau invariable) de longueur 0, 1, 2, etc : () (1,) (1,2) # des parenthèses sont optionnelles si len > 0.
-
Listes (type
list) of length 0, 1, 2, etc : [] [1] [1,2]
- L’indexation commence à 0. Des indices négatifs signifient (usuellement) un décompte depuis la fin de la séquence.
- Découpage de séquences (slicing[Index de début : mais moins que l’index [ : step]]. Départ par défaut à 0, fin à len(sequence), par pas de 1.
a = (0,1,2,3,4,5,6,7)
a[3] == 3
a[-1] == 7
a[2:4] == (2, 3)
a[1:] == (1, 2, 3, 4, 5, 6, 7)
a[:3] == (0, 1, 2)
a[:] == (0,1,2,3,4,5,6,7) # Effectue une copie de la séquence.
a[::2] == (0, 2, 4, 6) # Seulement avec des nombres.
a[::-1] = (7, 6, 5, 4, 3 , 2, 1,
0) # Inverse l’ordre.
Dictionnaires (type dict) de longueur 0, 1, 2, etc : {} {1 : 'premier'} {1 : 'premier', 'deuxième': 2, clé:valeur}
Key doit être un type numérique (hashable) ; Les valeurs peuvent être de tous types.
Forte Opérateur Commentaire
, [...] {...} `...` Ligne de tableau, liste &
dictionnaire. création;
conversion de chaîne.
s[i] s[i:j] s.attr f(...) indexation et découpage;
attributs, appels de fonction.
+x, -x, ~x Opérateurs unaires
x**y Puissances (exposant math)
x*y x/y x%y multiplier, diviser, modulo
(reste de la division)
x+y x-y addition, soustraction
x<<y x>>y Déplacement de bits
x&y Et binaire
x^y Ou exclusif binaire
x|y Ou binaire
x<y x<=y x>y x>=y Comparaison, identité, membre,
x==y x!=y x<>y
x is y x is not y
x in s
x not in s
not x Négation booléenne
x and y Et booléen
x or y Ou booléen
Faible lambda args: expr Fonction anonyme
- D’autres noms sont définis dans le module operator (e.g. __add__ et add for +).
- La plupart des opérateurs sont surchargeables.
Comparaison Signification Notes
< Strictement inférieur à (1)
<= Plus petit ou égale à
> Strictement plus grand que
>= Plus grand ou égal à
== égal à
!= or <> n’est pas égal à
is identification d’objet (2)
is not identification négative d’objet (2)
Notes:
- Le fonctionnement des comparaisons peut être surchargé
pour une classe précise par une méthode de définition spéciale __cmp__.
- (1) X < Y < Z < W a une signification particulière à la différence du C.
- (2) Compare les identités de l’object (i.e. id(object)), pas les valeurs des objets.
- None est utilisé comme la valeur par défaut retournée par une fonction. C’est un simple objet prédéfini avec le type NoneType. Pourrait devenir un mot-clé à l’avenir.
- Les entrées qui évaluent None n’affichent pas quand Python est en mode interactif.
- None est maintenant une constante; tenter de modifier une valeur un nom None est maintenant une erreur.
Valeurs booléennes et opérateurs.
Valeur ou opérateur Evalue vers Notes
Prédéfini bool(expr) True si “expr” est vraie, Voir True, False
False dans les autres cas.
None, zéros numériques, Considéré comme False
Séquences vides et
plans de mémoire
Toutes autres valeurs Considérées comme Vraies
not x True si x est False,
sinon False
x or y Si x est False alors y,
sinon x (1)
x and y si x est False alors x,
sinon y (1)
Notes:
- Le comportement d’un test de vérité peut être surchargé pour une classe donnée en définissant une méthode spéciale __nonzero__.
- (1) Évalue le second argument seulement si c’est nécessaire pour déterminer le résultat.
- Entiers flottants (type float) sont implémentés avec C doubles.
- Entiers (type int) sont implémentés avec C longs (signés 32 bits, la valeur maximum est sys.maxint).
- Entiers longs (type long) ont une taille illimités (la seule limite est la ressource (mémoire disponible) de votre système).
- Entiers et entiers longs ont été unifiés depuis la version 2.2 (le suffixe L n’est plus requis). int() retourne un long (entier long) au lieu d’augmenter jusqu’à OverflowError. Des opérations en dépassement de capacité (Overflowing Operations) comme 2<<32 ne déclenche plus un “FutureWarning” et retourne un entier long (long).
- Depuis la version 2.4, un nouveau type “Decimal” est introduit (voyez le module: decimal) pour compenser quelques limitations du type à virgule flottante (floating point type), en particulier avec les fractions. A la différence des nombres flottants (float), les nombres décimaux peuvent être représentés exactement ; l’exactitude est préservée dans les calculs ; la précision est définissable par l’utilisateur via le type « Context » [PEP 327].
Opération Résultat
abs(x) La valeur absolue de x
int(x) x est converti en entier (integer)
long(x) x est converti en entier long (long)
float(x) x est converti en virgule flottante
-x x devient négatif
+x x est inchangé
x + y la somme de x et y
x - y la différence entre x et y
x * y le produit de x par y
x / y division vraie de x par y : 1/2 -> 0.5 (1)
x // y partie entière du quotient de la division de x par y : 1//2 -> 0 (1)
x % y le reste de la division de x par y (modulo)
divmod(x, y) le tuple (rangée invariable d’un tableau) contenant le quotient et le reste de la division de x par y (x//y, x%y)
x ** y x à la puissance y (la même chose que pow(x,y))
Notes:
- (1) / n’est qu’une division entière (sans la partie décimale) (1/2 == 0) tant qu’elle n’a pas été validée par from __future__ importdivision.
- Des classes peuvent surcharger les methodes __truediv__ et __floordiv__ pour redéfinir ces opérateurs.
Opération Résultat
~x les bits de x sont inversés
x ^ y Ou exclusif binaire entre x et y
x & y Et binaire entre x et y
x | y Ou binaire entre x et y
x << n les bits de x sont déplacés vers la gauche de n bits.
x >> n les bits de x sont déplacés vers la droite de n bits.
- Le type de nombre complexe “Complex” représente une paire de données au niveau machine en nombre à double précision et à virgule flottante.
- La partie réelle la valeur imaginaire d’un nombre complexe z peut être retrouvée à travers les attributs z.real and z.imag.
TypeError
Apparaît lors d’une opération arithmétique sur une valeur non numérique.
OverflowError :
Limite numérique dépassée.
ZeroDivisionError
Apparaît lorsque le second argument d’une division (/) ou d’une opération Modulo (%) est 0 (zéro).
Opération Résultat Notes
x in s Vrai (True) si un item de s est égal à x,
sinon Faux (False) (3)
x not in s Faux (False) si un item de s est égal à x,
sinon Vrai (True) (3)
s1 + s2 La concaténation de s1 et s2
s * n, n*s n copies de s concaténées.
s[i] Le iième.
item de s, origine 0 (1)
s[i:j]
s[i:j:step] Parties de s depuis i (i inclus)
jusqu’à j (j exclus).
Valeurs de sauts optionnels :
des valeurs négatives sont possibles
(par défaut, step = 1). (1), (2)
len(s) Longueur de s.
min(s) Item de valeur minimum contenu dans (s).
max(s) Item de valeur maximum contenu dans (s).
reversed(s) Python [2.4] Retourne un itérateur sur (s)
en ordre inverse. s doit être une séquence, pas un
itérateur (utilisez dans ce cas : reversed(list(s)).
[PEP 322]
sorted(iterable
[,cmp]
[, cmp=cmpFct]
[, key=keyGetter]
[, reverse=bool]) Python [2.4] fonctionne comme la nouvelle
instruction list.sort(), mais elle trie
dans une nouvelle liste créée depuis iterable.
Notes:
- (1) si i ou j est négatif, l’index est relatif à la fin de la chaîne, ie len(s)+i ou len(s)+j est remplacé. Mais notez que -0 vaut seulement 0.
- (2) La partie de s depuis i jusqu’à j est définie comme une séquence d’items avec un index k tel que : i<= k < j.
Si i ou j est plus grand que len(s), utilisez len(s).
Si j est omis, utilisez len(s).
Si i est plus grand ou égal à j, la partie sera vide.
- (3) Pour les chaînes de caractères : avant Python 2.3, x devait être une chaîne à un seul caractère; depuis Python 2.3, x in s est vrai (True) si x est une sous-chaîne (substring) de s.
Opération Résultat Notes
s[i] =x L’item i de s est remplacé par x.
s[i:j [:step]] = t La partie de s depuis i jusqu’à j, par sauts de
step, est remplacée par t.
del s[i:j[:step]] comme s[i:j]
= []
s.append(x) ressemble à s[len(s)
: len(s)] = [x]
s.extend(x) ressemble à s[len(s):len(s)]=
x (5)
s.count(x) Retourne le nombre de i pour
lesquels s[i] == x
s.index(x[,
start[, stop]]) Retourne le plus petit i tel que s[i]==x.
Les limites de recherche “start”
et “stop” délimitent une partie
de la liste. (1)
s.insert(i, x) Comme s[i:i] = [x] si I >= 0.
i == -1 insert avant le dernier élément.
s.remove(x) Comme del
s[s.index(x)] (1)
s.pop([i]) Comme x = s[i]; del s[i];
retourne x (4)
s.reverse() intervertit les items de s sur place (3)
s.sort([cmp])
s.sort([cmp=cmpFct]
[, key=keyGetter]
[, reverse=bool]) Trie les items de s sur place (2), (3)
Notes:
- (1) Génère une exception ValueError quand x n’est pas trouvé dans s (i.e. Dépassement de limite (out of range).
- (2) La méthode de tri sort() prend un argument optionnel cmp spécifiant une comparaison d’items de deux listes et retournant -1, 0, or 1 selon que le premier argument est considéré comme plus petit que, égal à ou plus grand que le second argument. Notez que ceci ralenti considérablement les opérations de tri. Depuis 2.4, l’argument cmp peut être spécifié comme un mot-clé, et deux mots-clés arguments optionnels sont ajoutés : key est une fonction qui prend un item de la liste et retourne la clé à utiliser pour la comparaison (plus rapide que cmp); reverse: Si Vrai (True), inverse le sens de la comparaison utilisé.
Depuis Python 2.3, le tri est garanti "stable". Ceci signifie que deux entrées avec des clés égales seront retournées dans le même ordre où elles ont été introduites. Par exemple, vous pouvez trier une liste de personnes par leur nom, puis trier la liste par leur âge, le résultat sera une liste triée selon les âges dont les noms avec le même âge sont triés à leur tour.
- (3) Les méthodes “sort()” et “reverse()” modifient la liste pour économiser de l’espace lorsque le tri ou l’inversion sont effectués sur des listes importantes. Ils ne retournent pas la liste triée ou inversée pour vous rappeler cet effet.
- (4) La méthode “pop()” n’est pas supportée par des séquences mutables autres que des listes. L’argument optionnel i prend comme valeur par défaut -1, ainsi, par défaut, ce sera le dernier élément qui sera remplacé et retourné.
- (5) Génère un “TypeError” lorsque x n’est pas un objet liste.
Opérations sur des valeurs ordonnées
Opération Résultat Notes
len(d) Le nombre d’items dans d.
dict() Crée un dictionnaire vide.
dict(**kwargs) Crée un dictionnaire initialisé avec
l’argument mot-clé kwargs.
dict(iterable) Crée un dictionnaire avec des paires
(clé, valeur) fournies par « iterable ».
dict(d) Crée un dictionnaire qui est une copie
du dictionnaire d.
d.fromkeys(
iterable, value=None) Méthode de classe qui crée un
dictionnaire avec les clés fournies
par itérator avec toutes les
valeurs positionnées à value.
i[k] L’item de d avec la clé k (1)
d[k] = x Positionne d[k] à la valeur x
del d[k] Supprime d[k] de d (1)
d.clear() Supprime tous les items de d.
d.copy() Une copie superficielle de d.
d.has_key(k)
k in d Vrai (True) si d a la clé k,
sinon Faux (False).
d.items() Une copie de la paire de variables
(key, item) de la liste d. (2)
d.keys() Une
copie des clés de la liste d. (2)
d1.update(d2) for
k, v in d2.items(): d1[k] = v.
Depuis 2.4, update(**kwargs) et
update(iterable) peuvent également
être utilisés.
d.values() Une copie des valeurs de la liste d. (2)
d.get(k, defaultval) L’item de d avec la clé k. (3)
d.setdefault
(k[,defaultval]) d[k] si k contenu dans d,
alors defaultval
(également en l’initialisant) (4)
d.iteritems() Retourne un itérateur sur
la paire (key, value).
d.iterkeys() Retourne un itérateur sur
des clés de positionnement.
d.itervalues() Retourne un itérateur sur
des valeurs de positionnement.
d.pop(k[, default]) Supprime la clé k et retourne
la valeur correspondante. Si la clé
n’est pas trouvée, la valeur
par défaut est retournée sinon
une KeyError est générée.
d.popitem() Supprime puis retourne une paire
(key, value) de d.
Notes:
- TypeError est généré si la clé n’est pas acceptable.
- (1) KeyError est générée si la clé k ne se trouve pas dans la plage.
- (2) Les clés et les valeurs sont listées dans un ordre aléatoire.
- (3) Ne génère jamais d’exception si k ne se trouve pas dans la plage, au lieu de cela, il retourne defaultval. defaultval est optionnel, s’il n’est pas fourni, et que k ne se trouve pas dans la plage, None est retourné.
(4) Ne génère jamais d’exception si k ne se trouve pas dans la plage, sans quoi il retourne defaultVal, et ajoute k à la plage avec la valeur defaultVal. defaultVal est optionnel. Lorsqu’il n’est pas fourni, et que k ne se trouve pas dans la plage, None est retourné et ajouté à la plage.
Ces méthodes string remplacent largement (mais pas complètement) les fonctions disponibles dans le module « string » .
Les types str et unicode partagent une classe de base commune basestring.
Opération Résultat Notes
s.capitalize() Retourne une copie de s avec seulement
le premier caractère majuscule.
s.center(width) Retourne une copie de s centrée sur
la chaîne de longueur « width ». (1)
s.count(sub[ ,
start[,end]]) Retourne le nombre d’occurences de la
sous-chaîne sub contenues dans la chaîne s. (2)
s.decode([ encoding[,
errors]]) Retourne une chaîne unicode
représentant le version décodée de la
chaîne s, en utilisant le codec (encoding).
Pratique lorsqu’il faut lire depuis un
fichier ou une fonction I/O qui ne
manipule que des chaînes « str ».
C’est l’inverse de « encode ». (3)
s.encode([ encoding[,
errors]]) Retourne une chaîne (« str ») une version
encodée de s. Le plus souvent utilisée
pour encoder une chaîne Unicode vers une
chaîne « str » en vue de l’imprimer ou de
l’écrire dans un fichier (depuis, ces
fonctions I/O n’acceptent que des
« str »), e.g. u'légère'.encode('utf8').
Egalement utilisée pour encoder une chaîne
« str » en une chaîne « str », e.g.
pour le compresser zip (codec 'zip') ou
encoder uuencode (codec 'uu').
C’est l’invers de « decode ». (3)
s.endswith(suffix
[,start[,end]]) Retourne la valeur Vrai (true) si s se
termine avec le suffixe spécifié
« suffix », sinon, il retourne Faux
(false). Depuis 2.5 le suffixe
“suffix” peut également être un tuple
à tester. (2)
s.expandtabs(
[ tabsize]) Retourne une copie de s où tous les
caractères de tabulation sont développés
en utilisant des espaces. (4)
s.find(sub
[ ,start[,end]]) Retourne l’index le plus bas où la
sous-chaîne s a été trouvée et retourne
-1 si elle n’a pas été trouvée. (2)
s.index(sub
[ ,start[,end]]) Comme “find()”, mais génère une
“ValueError” lorsque la sous-chaîne
n’a pas été trouvée. (2)
s.isalnum() Retourne Vrai (true) si tous les
caractères de s sont alphanumériques,
il retourne Faux (false) autrement. (5)
s.isalpha() Retourne Vrai (true) si tous les
caractères dans s sont alphabétiques,
il retourne Faux (False) autrement. (5)
s.isdigit() Retourne Vrai (true) si tous les
caractères dans s sont des chiffres,
il retourne Faux (false) autrement. (5)
s.islower() Retourne Vrai (True) si tous les
caractères dans s sont en minuscule,
il retourne Faux (false) autrement. (6)
s.isspace() Retourne Vrai (true) si tous les
caractères dans s sont des caractères
blancs, il retourne Faux (false) autrement. (5)
s.istitle() Retourne Vrai (true) si la chaîne s est
définie comme une chaîne de titre, il
retourne Faux (false) autrement. (7)
s.isupper() Retourne Vrai (true) si tous les caractères
dans s sont en majuscule, il retourne Faux
(false) autrement. (6)
separator.join(seq) Retourne la concaténation des chaînes
dans la séquence “seq”, séparées par le
séparateur de chaînes separator, e.g.:
",".join(['A', 'B', 'C']) -> "A,B,C"
s.ljust/rjust/
center(width[,
fillChar=' ']) Retourne s justifié gauche/droite dans une
chaîne le longueur “width”. (1), (8)
s.lower() Retourne une copie de la chaîne s
convertie en minuscules.
s.lstrip([chars] ) Retourne une copie de la chaîne s
avec les caractères à gauche supprimés
(par défaut : « blank chars”).
s.partition(separ) Recherche le séparateur “separ” dans la
chaîne s, et retourne une ligne (tête,
corps, queue) contenant une partie avant lui,
le séparateur, et une partie après lui.
Si le séparateur n’est pas trouvé, il
retourne s et deux chaînes vides.
s.replace(old,
new[, maxCount
=-1]) Retourne une copie de s avec la
première occurrence “maxcount” (-1 : illimité)
de la sous-chaîne old remplacée
par la nouvelle new. (9)
s.rfind(sub[
, start[, end]]) Retourne le plus haut index dans s où
la sous-chaîne “sub” a été trouvée.
Il retourne -1 si « sub » n’a pas été trouvé. (2)
s.rindex(sub[
, start[, end]]) Comme “rfind()”, mais génère une “ValueError”
losque la sous-chaîne n’est pas trouvée. (2)
s.rpartition(separ) Recherche le séparateur “separ” dans s,
en commençant par la fin de s, et retourne
la ligne (queue, corps, tête) (tail, sep, queue)
contenant une partie de la chaîne avant le
séparateur,le séparateur lui-même et une partie de
la chaîne après lui. Si le séparateur n’est pas
trouvé, il retourne deux chaînes vides et s.
s.rstrip([chars]) Retourne une copie de s avec des espaces
de fin de chaîne supprimés
(par défaut : caractères blancs),
e.g. aPath.rstrip('/') va remplacer le
caractère de fin de chaîne '/' de aPath
s’il existe.
s.split([
separator[,
maxsplit]]) Retourne une liste des mots contenus dans s,
en utilisant le séparateur separatpor comme
délimiteur de chaîne. (10)
s.rsplit([
separator[,
maxsplit]]) Comme “split”, mais glisse depuis la fin de
la chaîne. (10)
s.splitlines([
keepends]) Retourne une liste des lignes contenues dans s,
en coupant aux extrémités de la ligne. (11)
s.startswith(
prefix [, start[,
end]]) Retourne Vrai (true) si s commence avec le
préfixe spécifié, autrement, il retourne
Faux (false). Des nombres négatifs peuvent être
utilisés
pour start et end. Depuis
Python 2.5, le
préfixe
prefix peut également être un uplet
(tuple) de chaînes à essayer. (2)
s.strip([chars]) Retourne une copie de s avec les caractères
de début et de fin de chaîne chars (par défaut :
caractère blanc (blank)) supprimés.
s.swapcase() Retourne une copie de s avec les caractères
majuscules convertis en minuscules et
vice et versa.
s.title() Retourne une copie de s au format de titre
(i), les mots commençant par un caractère
majuscule, tous les autres caractères sont
en minuscule.
s.translate(table [,
deletechars]) Retourne une copie de s basée sur la table
de translation “table”. (12)
s.upper() Retourne une copie de s convertie
en majuscule.
s.zfill(width) Retourne une chaîne numérique complétée
de zéros dans une chaîne de longueur “width”.
Notes:
- (1) Le remplissage est fait en utilisant des espaces ou un caractère donné.
- (2) Si l’argument optionnel “start” est fourni, la sous-chaîne « s[start:] » est traitée. Si les arguments optionnels « start » et « end » sont fournis, la sous-chaîne « s[start:end] » est traitée.
- (3) L’encodage par défaut “sys.getdefaultencoding()”, peut être modifié via « sys.setdefaultencoding() ». L’argument optionnel « errors » peut être donné à différents schémas de gestion d’erreur. La valeur par défaut pour « errors » est « strict », cela signifie que l’encodage « errors » génère une valeur d’erreur « ValueError ». Les autres valeurs possibles sont 'ignore' et 'replace'. Voyez également le module des codecs.
- (4) Si l’argument optionnel “tabsize” n’est pas fourni, une taille de la tabulation de 8 caractères est présumée.
- (5) Retourne Faux (False) si la chaîne s ne contient pas au moins un caractère.
- (6) Retourne Faux (False) si la chaîne s ne contient pas au moins un caractères de casse différente.
- (7) Une chaîne au format titre est une chaîne dans laquelle un caractère en majuscule peut seulement suivre un caractère sans casse et un caractère minuscule seulement des caractères avec casse.
- (8) s est retourné si “width” est plus petit que “len(s)”.
- (9) Si l’argument optionnel “maxCount” est fourni, seules, les premières occurrences de “maxCount » sont remplacées.
- (10) Si “separator” n’est pas spécifié ou est “None”, chaque chaîne d’espace blanc est un séparateur. Si « maxsplit” est fourni, au moins “maxsplit” de déplacement sont effectués.
- (11) Les ruptures de lignes ne sont pas incluses dans la liste résultante tant que “keepends » est donné et Vrai (true).
- (12) “table” doit être une chaîne de 256 caractères. Tous les caractères occurrents dans l’argument optionnel “deletechars” sont supprimés avant la translation.
« formatString % args » --> Évalue pour une chaîne de caractères.
- “formatString” mêle du texte normal avec C “printf format filed” :
%[flag][width][.precision] formatCode
où “formatCode” est un des c, s, i, d, u, o, x, X, e, E, f, g, G, r, % (Voir la table ci-dessous).
- Les caractères signaux -, +, blanc (blank), # et 0 sont compris, interprétés (Voyez la table ci-dessous).
- La largeur (“Width”) et la précision (“precision”) peut être un * pour spécifier qu’un argument entier (« integer ») donne les largeur et précision actuelles.
Exemples de largeur et de précision :
Format de la chaîne (string) Résultat
'%3d' % 2 ' 2'
'%*d' % (3, 2) ' 2'
'%-3d' % 2 '2 '
'%03d' % 2 '002'
'% d' % 2 ' 2'
'%+d' % 2 '+2'
'%+3d' % -2 ' -2'
'%- 5d' % 2 ' 2 '
'%.4f' % 2
'2.0000'
'%.*f' %
(4, 2) '2.0000'
'%0*.*f' %
(10, 4, 2) '00002.0000'
'%10.4f' %
2 ' 2.0000'
'%010.4f' % 2 '00002.0000'
- %s convertit chaque type d’argument en chaîne de caractère (« string ») (utilise la fonction str())
- args peut être un simple argument ou une ligne d’arguments.
'%s has
%03d quote types.' % ('Python', 2) == 'Python has 002 quote types.'
- La partie droite peut également être adaptée :
a = '%(lang)s has %(c)03d quote types.' % {'c':2, 'lang':'Python'}
(La fonction vars() est très aisée à mettre en oeuvre dans la mise en forme de la partie droite.)
Code Signification
d Entier décimal signé.
i Entier décimal signé.
o Octal non signé.
u Décimal non signé.
x Hexadécimal non signé (minuscule).
X Hexadécimal non signé (majuscule).
e Format exponentiel à virgule flottante (minuscule).
E Format exponentiel à virgule flottante (majuscule).
f Format décimal à virgule flottante.
F Format décimal à virgule flottante.
g Comme "e" si l’exposant est plus grand que -4
ou plus petit que « precision », sinon "f".
G Comme "E" si l’exposant est plus grand que -4
ou inférieur à “precision”, sinon "F".
c Simple caractère 5accepte les entiers et
les caractères simples de chaîne).
r Chaîne de caractères (convertit tout type d’objet Python en
utilisant « repr() »).
s Chaîne de caractère (convertit tout type d’objet Python en
utilisant « str() »).
% Aucun argument n’est converti, a pour conséquence un caractère
"%" dans le résultat. (Les spécifications complètes sont
« %% ».)
Caractère Signification.
# La conversion de la valeur utilisera une « forme
alternative ».
0 La conversion sera remplie de 0 (zéro).
- La valeur convertie est laissée ajustée (surcharge "-").
(Un espace) Un blanc (blank) sera posé avant un nombre positif
(ou une chaîne vide) suite à une conversion signée.
+ Un caractère ("+" or "-") précèdera le résultat de la
conversion (surcharge le caractère signal "espace").
Depuis la version 2.4 [PEP 292] le module “string” fournit un nouveau mécanisme de substitution de variables dans des chaînes « template ».
Les variables qui doivent être substituées commencent par le caractère « $ ». Les valeurs actuelles sont fournies à un dictionnaire via la méthode de substitution (« sustitute ») ou de substitution/sauvegarde (« safe-substitute ») (substitute envoie une erreur de clé « KeyError » si une clé est manquante tandis que « safe_substitute » l’ignore :
t = string.Template('Hello $name, you won $$$amount') #
(note $$ pour littéraliser, transformer en littéral $)
t.substitute({'name':
'Eric', 'amount': 100000}) # -> u'Hello Eric, you won$100000'
(Type file). Créé avec les fonctions prédéfinies “open()” [préféré] ou de son alias « file() ». Peut aussi bien être créé par les fonctions d’autres modules.
Les noms de fichiers unicode sont maintenant supportés pour toutes les fonctions recevant ou retournant des noms de fichiers :(open, os.listdir, etc.).
Opération
Résultat
f.close()
Ferme le fichier f.
f.fileno()
Obtient la référence (fd) du fichier f lié à un flux.
f.flush()
Mise à zéro du tampon interne du fichier f.
f.isatty()
1 si le fichier f est connecté par un développement genre télétexte “tty-like dev”,sinon 0. (TTY = Text TeletYpe)
f.next()
Retourne la prochaine ligne d’entrée du fichier f ou génère une “StopIteration” si « EOF » est présenté.Les fichiers sont leurs propres itérateurs. next est implicitement appelé par les constructeurs comme avec « for line in f: print line ».
f.read([size])
Lit au moins le nombre de bytes défini avec “size” du fichier f et retourne un objet chaîne (« string »). Si “size” est omis, lire jusqu’à “EOF” (Fin du fichier).
f.readline()
Lit une ligne entière du fichier f. La ligne retournée a le caractère de fin de chaîne« \n », possible exception à la fin du fichier « EOF ». Retourne '' en fin de fichier “EOF”.
f.readlines()
Lit jusqu’à la fin du fichier “EOF” avec “readline()” et retourne une liste des lignes lues.
f.xreadlines()
Retourne un objet genre “sequence” pour la lecture ligne par ligne sans la lecture entière du fichier en mémoire. Depuis 2.2, utilisez de préférence : for line in f (voyez ci-dessous).
for line in f: do
something...
Lit successivement chaque ligne du fichier (en utilisant “readline”).
f.seek(offset[, whence=0])
Positionne le fichier f, comme "fseek()" de stdio en C.
whence == 0 indexation absolue.
whence == 1 alors déplacement (offset) relatif à la position actuelle.
whence == 2 alors déplacement (offset) relatif à la fin du fichier.
(whence = d’où, de quelle origine)
f.tell()
Retourne la position actuelle dans le fichier (byte offset = Déplacement de byte).
f.truncate([size])
Tronque la taille du fichier f. Si “size” est présent, f est tronqué au mieux à cette taille, autrement f est tronqué à la position courante (ce qui signifie qu’il reste inchangé).
f.write(str)
Ecrit une chaîne str dans le fichier f.
f.writelines(list)
Ecrit la liste des lignes list dans le fichier f. Aucun “Fin de Ligne” “EOL” n’est ajouté.
EOFError :
Fin de Fichier surgit lors de la lecture (peut être généré plusieurs fois, e.g. si le fichier f est un télétype « tty »).
IOError :
Un autre échec d’opération I/O d’un I/O connexe.
Depuis 2.4, Python a deux nouveaux types prédéfinis dans les dernières implémentations C [PEP 218]: « set » et « frozenset » (définition immuable). Les ensembles sont des collections désordonnées d’éléments uniques (non dupliqué). Les éléments doivent être indexables. “frozenset” sont indexables (ainsi, ils peuvent faire partie d’autres ensembles) tant que les ensembles sets ne le sont pas. Tous les ensembles sont itérables.
Depuis 2.3, les classes “Set” et “ImmutableSet” sont disponibles dans le module “sets”. Ce module persiste dans la librairie standard de la version 2.4 en supplément des types prédéfinis.
Opération
Résultat
set/frozenset([iterable=None])
[en utilisant des types prédéfinis] Construit un ensemble “set” ou un « frozenset » depuis l’itérable itérable fourni (par défaut : empty), e.g.set([1,2,3]), set("hello").
Set/ImmutableSet([iterable=None])
[en utilisant le module “sets”] Construit un ensemble “Set” ou un « ImmutableSet » depuis l’itérable fourni (par défaut: empty), e.g. Set([1,2,3]).
len(s)
Cardinalité de l’ensemble s. Longueur, taille de s.
elt in s / not in s
Vrai (True) si l’élément “elt” appartient/n’appartient pas à l’ensemble s.
for elt in s: process
elt...
Réitère sur les éléments de l’ensemble s.
s1.issubset(s2)
Vrai (True) si chaque élément de s1 se retrouve dans s2.
s1.issuperset(s2)
Vrai (True) si chaque élément de s2 se retrouve dans s1.
s.add(elt)
Ajoute l’élément “elt” à l’ensemble s (s’il n’existe déjà pas).
s.remove(elt)
Supprime l’élément « elt » de l’ensemble s. Une erreur de clé « KeyError » est générée si l’élément « elt » n’est pas trouvé.
s.clear()
Supprime tous les éléments de cet ensemble “s” (n’agit pas sur les ensembles immuables “immutable sets” !).
s1.intersection(s2) or s1&s2
Retourne un nouvel ensemble contenant les éléments communs aux deux ensembles « s1 » et « s2 ».
s1.union(s2) or s1|s2
Retourne un nouvel ensemble contenant les éléments de « s1 » et « s2 ».
s1.difference(s2) or s1-s2
Retourne un nouvel ensemble contenant les éléments se trouvant dans “s1” mais pas dans “s2”.
s1.symmetric_difference(s2) or s1^s2
Retourne un nouvel élément contenant les éléments qui se trouvent dans un des deux ensembles « s1 et « s2 » mais pas dans les deux en même temps.
s.copy()
Retourne une copie superficielle de l’ensemble “s”. (1)
s.update(iterable)
Ajoute toutes les valeurs de « iterable » à l’ensemble « s ».
(1) En C/C++, une copie “superficielle” (shallow
copy) d’un objet toutes les valeurs des champs membres. Ceci fonctionne
correctement si les champs sont des valeurs, mais la valeur pointée par
allocation dynamique de mémoire. En C++, c’est le pointeur qui sera copié, pas
la zone mémoire vers laquelle il pointe. – le champ dans l’objet original et sa
copie pointeront vers la même zone mémoire dynamique ce qui n’est pas vraiment
ce que vous désirez. Le constructeur de copies par défaut et l’opérateur
d’assignation créent des copies superficielles (shallow copy).
Une copie complète (deep copy) copie tous les
champs et fait des copies des champs pointés en mémoire dynamique. Pour
exécuter une copie « profonde », vous devez écrire un constructeur de
copie puis surcharger l’opérateur d’assignation.
Une copie « profonde » nécessite :
Si un objet a des pointeurs vers de la mémoire allouée
dynamiquement, et que la mémoire allouée dynamiquement doit être copiée quand
l’objet original est copié, alors une copie « profonde » est
recommandée.
Une classe qui a besoin de copies
« profondes » a généralement besoin de :
1) un destructeur pour effacer dynamiquement la mémoire
allouée.
2) un constructeur de copie pour exécuter la copie de la
mémoire allouée dynamiquement.
3) un opérateur d’assignation surchargé pour effectuer
la copie de la mémoire dynamique allouée.
Python n’a pas de types “Date” ou “Time” intrinsèque mais fournit deux modules prédéfinis :
time: accès à l’heure et aux conversions
datetime : classes date, time,
datetime, timedelta, tzinfo.
...voyez également le module tiers : “mxDateTime”.
- Voyez les manuels pour plus de détails.
- Objets “Module”
- Objets “Classe” (class)
- Objets “Instance de Classe” (Class instance)
- Objets “type” (voir le module : “types”)
- Objets “fichier” (File) (voir plus haut)
- Objets “Slice”
- Objet “ellipse” (Ellipsis), utilisé par les notations de tranches étendues (extended slice notation) (unique, nammée « Ellipsis »).
- Objet Null (unique, nammé “None”)
- Objets XRange
- Types appelables (callable) :
o Définis par l’utilisateur (écrits en Python):
§ Les Objets fonction « function » définis par l’utilisateur.
§ Les objets méthodes « Method » définis par l’utilisateur.
o Prédéfinis (écrits en C):
§ Les objets fonction “Function” prédéfinis.
§ Les objets méthodes “Method” prédéfinis.
- Types internes :
o Les objets code (exécutables Python compilés binaires : I)
o Les objets forme « Frame » (exécution de frames)
o Les objets de surveillance « Traceback » (surveillance de la pile d’exception).
Enoncé
Résultat
Pass
Enoncé Null
del name[, name]*
Noms name(s) non reliés aux objets. L’objet sera indirectement (et automatiquement) effacé seulement tant qu’il ne sera pas référencé.
print[>> fileobject,] [s1 [, s2 ]* [,]
Ecrit vers sys.stdout, ou vers l’objet fichier (fileobject) s’il est fourni. Positionne des espaces entre les arguments. Place une nouvelle ligne newline à la fin jusqu’à ce que le rapport se termine par une virgule. Afficher (print) n’est pas requis en fonctionnement interactif, taper simplement une expression va afficher sa valeur tant que la valeur n’est pas “None”.
exec x [in globals [, locals]]
Exécute x dans l’espace nommé fourni. Par défaut, le nom de l’espace courant. x peut être une chaîne “string”, Ouvre un objet genre fichier (file) ou un objet fonction (function). « locals” peut être n’importe quel type de traçage (mapping), et pas seulement un type régulier du dictionnaire de Python.
callable(value,... [id=value] , [*args], [**kw])
Appelle la fonction appelable “callable” avec des paramètres. Les paramètres peuvent être passés par nom ou être omis si la fonction définit des valeurs par défaut.
E.g. si “callable” est définie comme “def callable(p1=1, p2=2)"
"callable()" <=> "callable(1, 2)"
"callable(10)" <=> "callable(10, 2)"
"callable(p2=99)" <=> "callable(1, 99)"
*args est une ligne d’arguments de position.
**kw est un dictionnaire d’arguments mots-clés.
Opérateur Résultat Notes
a = b Assignation basique –
assigne l’objet b au label a. (1)(2)
a += b Strictement équivalent à : a = a + b (3)
a -= b Strictement équivalent à : a = a -b (3)
a *= b Strictement équivalent à : a = a * b (3)
a /= b Strictement équivalent à : a = a / b (3)
a //= b Strictement équivalent à : a = a // b (3)
a %= b Strictement équivalent à : a = a % b (3)
a **= b Strictement équivalent à : a = a ** b (3)
a &= b Strictement équivalent à : a = a & b (3)
a |= b Strictement équivalent à : a = a | b (3)
a ^= b Strictement équivalent à : a = a ^ b (3)
a >>= b Strictement équivalent à : a = a >> b (3)
a <<= b Strictement équivalent à : a = a << b (3)
Notes:
- (1) Peut décompacter des lignes invariables d’un tableau (tuple), des listes (list) et des chaînes (string) :
first, second = l[0:2] #
équivalent à : first=l[0]; second=l[1]
[f, s] = range(2) #
équivalent à : f=0; s=1
c1,c2,c3 = 'abc' #
équivalent à : c1='a'; c2='b'; c3='c'
(a, b), c, (d, e, f) =
['ab', 'c', 'def'] #
équivalent à: a='a'; b='b'; c='c'; d='d';
e='e'; f='f'
Cas particulier : x,y = y,x # permute x et y.
- (2) Possibilité d’assignations multiples :
a = b = c = 0
list1 = list2 =
[1, 2, 3] #
list1 et list2 pointent vers la même liste
(l1 est l2)
- (3) N’est pas exactement équivalent -a n’est évalué qu’une seule fois. Aussi, où cela est possible, une opération de modification in situ est préférable à un remplacement.
Des expressions conditionnelles (pas des assignations (statements)) ont été ajoutées depuis la version 2.5 [PEP 308]:
result = (quandVrai if condition else quandFaux)
est équivalent à :
if condition :
result = quandVrai
else:
result = quandFaux
() ne sont pas indispensables mais recommandées.
Assignation Résultat
if condition:
suite
[elif condition:
suite]*
[else:
suite]
Assignation usuelle if/else if/else. Voyez également les expressions conditionnelles.
while condition:
suite
[else:
suite]
Assignation usuelle while. Le « else: suite » est exécutée après que la boucle se termine, tant que la boucle n’est pas interrompue par un break.
for element in sequence:
suite
[else:
suite]
Se poursuit sur tous les éléments de la séquence, assignant chaque élément à « element ». Utilisez la fonction prédéfinie « range » pour poursuivre un certain nombre de fois. Le « else: suite » est exécuté à la fin sauf si la boucle se termine avec un “break”.
Break
Quitte immédiatement un boucle for ou while.
Continue
Passe à l’itération suivante d’une boucle for ou while.
return [result]
Quitte une fonction (ou une méthode) et retourne un résultat (utilise un uplet (tuple) pour retourner plusieurs valeurs). Si aucun result n’est fourni, il retourne None.
yield expression
(Seulement utilisé à l’intérieur du corps d’une fonction “generator”, à l’extérieur, un test « try..finall »). Il « Retourne » l’expression évaluée.
Assignation
Résultat
assert expr[, message]
expr est évalué. Si faux, génère une exception “AssertionError” avec message. Avant 2.3, inhibé si __debug__ est égale à 0.
try:
block1
[except [exception [, value]:
handler]+
[else:
else-block]
L’assignation contenue dans « block1 » est exécutée. Si une exception survient, regardez dans les conditions d’exception pour trouver l’exception. Si des résultats ou des except sont découverts, exécute la prise en main (handler) de la condition. Si aucune exception ne survient, le « else-block » dans la condition « else » est exécuté après le block1. Si « exception » a une valeur, elle est introduite dans la variable « value ». « exception » peut également être un uplet (tuple) d’exceptions, e.g. except(KeyError, NameError), e: print e.
try:
block1
finally:
final-block
Les assignations dans block1 sont exécutées. S’il n’y a aucune exception, on exécute « final-block » (même si block1 s’est terminé avec un « return », « break » ou l’assignation « continue »). Si une exception devait survenir, « final-block » est ré-exécuté et une exception est générée. Typiquement utilisé pour s’assurer qu’une ressource (fichier, verrou, etc.) alloué avant le « try » est libérée (dans le « final-block ») intépendemment des résultats de l’exécution de block1. Voyez également l’assignation suivante.
try:
block1
[except [exception [, value]:
handler1]+
[else:
else-block]
finally:
final-block
Non défini try/except/finally.
Equivalent à un try...except encapsulé dans un try..finally [PEP341].
Voyez également l’assignation suivante.
with allocate-expression
[as variable]
with-block
Alternative à la structure try...finally [PEP343]. allocate-expression doit être évélué avec un objet qui supporte le contexte du protocole de gestion (management protocol), représentant une ressource. Cet objet peut retourner une valeur qui, optionnellement, peut être accolée à variable (variable n’est pas assignée au résultat de l’expression). L’objet peut alors exécuter le code set-up avant que with-block soit exécuté et que quelque code de nettoyage clean-up soit exécuté après que block soit terminé, même si block génère une exception.
Les objets standards Python tels que fichiers (file) et verroux (lock) supportent le contexte du protocole de gestion :
with open('/etc/passwd', 'r') as f: # Fichier fermé automatiquement
à la sortie de block.
for line in f:
print line
with threading.Lock(): # Verrouille automatiquement réinstallé à la
do something... sortie de “block”.
Vous pouvez également écrire vos propres contextes de gestion.
Dans 2.5 l’assignation doit être rendue possible par : from
__future__
import with_statement.
L’assignation sera toujours disponible sous Python 2.6.
raise exceptionInstance
Génère une instance de classe dérivée de Exception (forme préférré à raise).
raise exceptionClass [, value [, traceback]]
Génère une exception de la classe donnée exceptionClass” avec la valeur optionnelle « value ». L’argument “traceback” définit un objet « traceback » à utiliser lors de l’écriture de l’exception de « backtrace ».
raise
Une assignation générée sans argument génère à nouveau la dernière exception générée dans la fonction courante.
- Une exception est une instance de la classe “exception” (avant 2.0, elle pouvait être une seule chaîne).
- Les classes “Exception” doivent être dérivées de la classe prédefinie : « Exception », e.g.:
class
TextException(Exception): pass
try:
if bad:
raise TextException()
except Exception:
print 'Oops' # Ceci sera affiché parce que
“TextException » est
une sous-classe de
« Exception ».
- Lorsqu’un message d’erreur est affiché pour une exception non traitée, le nom de la classe est affiché, puis une virgule et un espace, et finalement l’instance convertie en une chaîne en utilisant la fonction prédéfinie « str() ».
- Toutes les classes “exception” prédéfinies dérivent de “StandardError », lui-même dérivé de « Exception ».
- [PEP 352] : Des exceptions peuvent maintenant être des classes de nouveau style et elles sont toutes prédéfinies.
La hiérarchie des exceptions prédéfinies a légèrement été réorganisée avec l’introduction de la classe de base BaseException. Générer des chaînes comme des exceptions est maintenant désapprouvé (danger).
Les fichiers modules importés doivent être localisés dans un directory listé dans le chemin Python (sys.path).
Depuis 2.3, il peuvent se trouver dans un fichier zip [e.g. sys.path.insert(0, "aZipFile.zip")].
Importations absolue/relative (depuis 2.5 [PEP328]):
- Des dispositifs doivent être rendus disponibles par : from __future__ import absolute_import: Ce sera probablement adopté pour la version 2.7.
- Les importations sont normalement relatives : les modules sont d’abord recherchés dans le directory/paquet courant, et ensuite dans les modules prédéfinis, ayant pour résultat de possibles ambiguïtés.
(e.g. masquer un symbole prédéfini).
- Lorsqu’un nouveau dispositif est disponible :
- import X va rechercher le module X dans le chemin sys.path en premier lieu (importation absolue).
- import .X (avec un point) va rechercher X dans le paquet courant pour commence, ensuite dans les paquets prédéfinis (importation relative).
- import ..X (avec deux points) va rechercher X dans le paquet contenant le paquet courant, etc...
Packages (>1.5): un paquet est un espace de nom qui renvoie à un directory qui inclus un (des) module(s) et le module d’initialisation spécial __init__.py (qui peut être vide).
Packages/directories peut être encapsulé. Vous adressez un module de symbole via [package.[package...].module.symbol.
[1.51: Sur Mac et Windows, le choix des noms de dossier de module doit maintenant assortir le choix comme utilisé dans le rapport d'importation]
Dispositif
Résultat
import module1 [as name1] [, module2]*
Modules d’importation. Les membres du module doivent être mentionnés par leur qualification avec [package.]module name, e.g.: ()
import sys; print sys.argvimport
package1.subpackage.module
package1.subpackage.module.foo
module1 renommé en name1, si supporté.
from module import name1 [as
othername1][, name2]*
Des noms d’importations depuis le module dans l’espace nommé courant
from sys
import argv; print argv
from
package1 import module; module.foo()
from
package1.module import foo; foo()
name1 renommé en othername1, si supporté.
[2.4] Vous pouvez mettre des parenthèses autour de la liste des noms dans un dispositif from module import names (PEP 328).
from module import * Importe tous les noms dans le module, excepté ceux commençant par "_". A utiliser avec parcimonie, faites attention aux collisions de noms !
from sys
import *; print argv
from
package.module import *; print x
Seulement légal au niveau le plus élevé du module.
Si le module définit un attribut __all__, seuls les noms listés dans __all__ seront importés.
NB: "from package import *" importe seulement le symbole défini dans le fichier __init__.py du paquet, pas ceux dans le module du paquet !
global name1 [, name2] Ces noms proviennent d’une vue globale (cela signifie habituellement qu’ils proviennent du module) plutôt que du local (ceci signifie habituellement seulement dans la fonction).
E.g. dans une fonction sans assignation globale, on présume que “X” est le nom qui n’a pas été utilisé dans la fonction ou dans le module jusqu’ici :
- Essayer de lire depuis "x" -> NameError
- Essayer d’écrire vers "x" -> crée un "x" local à la fonction.
Si "x" n’est pas défini dans la fonction, mais se trouve dans le module, alors :
- Essayer de lire depuis "x", récupère la valeur depuis le module
- Essayer d’écrire vers "x", crée un "x" local à la fonction.
Mais notez que "x[0]=3" commence par une recherche de "x", puis utilisera un "x" global si un "x" local n’a pas été trouvé.
def funcName ([paramList]):
suite
Crée un objet “fonction” (function) et lui lie le nom « funcName ».
paramList ::= [param [, param]*]
param ::= value | id=value
| *id | **id
- Les arguments sont passés par valeur, ainsi, seuls les arguments représentant des objets mutables peuvent être modifiés (sont des paramètres “inout”).
- Utilisez return pour retourner (None) depuis la fonction, ou « return value » pour retourner la valeur. Utiliser une ligne d’un uplet (tuple) retourner plus d’une valeur : e.g. return 1, 2, 3
- Les arguments Keyword arg=value spécifient une valeur par défaut (évaluée au moment de la définition de la fonction). Ils peuvent seulement apparaître à la fin de la liste des paramètres : e.g. foo(x, y=1, s='')
- Le pseudo argument *args capture un uplet (tuple) tous les arguments qui ne sont pas des mots-clés restants passés à la fonction : e.g. if def foo(x, *args): ... est appelé foo(1, 2, 3), alors les arguments agrs contiendront (2,3).
- Le pseudo argument **kwargs capture un dictionnaire de tous les arguments keyword en excès : e.g. if def foo(x, **kwargs): ... est appelé foo(1, y=2, z=3), alors kwargs contiendra {'y':2, 'z':3}. if def foo(x, *args, **kwargs): ... est appelé foo(1, 2, 3, y=4,z=5), alors args contiendra (2, 3), et kwargs contiendra {'y':4, 'z':5}
- args et kwargs sont des noms conventionnels, mais d’autres noms peuvent être utilisés également.
- *args et **kwargs peuvent être “transférés” (individuellement ou ensemble) vers une autre fonction : e.g.
def f1(x, *args, **kwargs):
f2(*args, **kwargs)
Voyez également “fonctions anonymes” (lambdas).
class className [(super_class1[, super_class2]*)]:
suite
Crée un objet classe et lui assigne le nom de classe « className ».
suite peut contenir des définitions locales de méthodes de classe et des assignations d’attributs de classe.
Examples:
class MyClass (class1, class2):
...
Crée un objet classe hérité de class1 et de class2. Assigne au nouvel objet classe le nom « MyClass ».
class MyClass: ...
Crée un objet classe de base (n’héritant de rien). Assigne au nouvel objet classe le nom « MyClass ». Depuis 2.5 la syntaxe équivalente class MyClass(): ... est autorisés.
class MyClass (object): ...
Crée un nouveau style de classe (new-style) (Hérité de “object” construit une classe « new-style class » - disponible depuis Python 2.2-). Assigne au nouvel objet classe le nom « MyClass”.
- Le premier argument d’une instance de méthode de classe (opération) a toujours pour objectif l’instance objet, appelé 'self' par convention.
- La méthode statique spéciale __new__(cls[,...]) est appelée lorsque l’instance est créée. Le premier argument est une classe (Class), les autres arguments sont dirigés vers __init__(), plus de détails ici.
- La méthode spéciale __init__() est appelée lorsqu’une instance est créée.
- La méthode spéciale __del__() est appelée lorsqu’il n’y a aucune référence à un objet.
- Créer une instance par “appel” à un objet classe est possible avec des arguments (ainsi : instance=apply(aClassObject, args...) crée une instance !)
- Avant 2.2 il n’était pas possible au sous-classes prédéfinie aux classe telles que des listes (list), dictionnaires (dict) (vous deviez les « relier” en utilisant les modules « UserDict » & « UserList »); depuis 2.2 vous pouvez les sous-classer directement (voyez Types/Classes unification).
Example:
class c (c_parent):
def __init__(self, name):
self.name = name
def print_name(self):
print "I'm", self.name
def call_parent(self):
c_parent.print_name(self)
instance =
c('tom')
print instance.name
'tom'
instance.print_name()
"I'm tom"
Appel la super classe parent en accédant directement aux méthodes de la classe parent et en passant self explicitement (voyez call_parent dans l’exemple ci-dessus).
Bien d’autres méthodes spéciales sont disponibles pour l’implémentation d’opérateurs arithmétiques, des séquences, indexation de classements, etc.
Les méthodes de classe ont seulement une différence
spécifique avec les fonctions – elles doivent avoir comme premier argument
supplémentaire ajouté au début de la liste des paramètres, mais vous ne
devez pas donner de valeur à ce paramètre lors de l’appel de la méthode,
Python le fournira lui-même. Cette variante particulière fait référence à
l’objet lui-même, et par convention, on lui donne le nom de self.
Les types de base int, float, str, list, tuple, dict et file sont maintenant (2.2) traités comme des classes dérivées de l’objet classe de base, et peuvent être sous-classés :
x = int(2) # fonction de transformation est maintenant (depuis 2.2) un
constructeur pour les types de base.
y = 3 # <=> int(3) (litteraux sont des instances des nouveaux types
de base)
print type(x), type(y) # int, int
assert isinstance(x, int) # remplace isinstance(x, types.IntType)
assert issubclass(int, object) # type de base dérivé de la classe de base
'object'.
s =
"hello" #
<=> str("hello")
assert
isinstance(s,
str)
f = 2.3 # <=> float(2.3)
class MyInt(int): pass # peut sous-classer les types de base.
x,y = MyInt(1), MyInt("2")
print x, y, x+y # => 1,2,3
class MyList(list): pass
l =
MyList("hello")
print l # ['h', 'e', 'l', 'l', 'o']
Les classes de nouveau style « New-style classes » étendent les objets. Les classes d’ancien style « Old-style classes » ne le font pas.
Les modules, classes et fonctions peuvent être documentées en plaçant une chaîne littérale, elle-même comme première donnée dans la « suite ». La documentation peut être recherchée par l’emploi de '__doc__'
attribute
from the module, class or function.
Example:
class C:
"A description of C"
def __init__(self):
"Une description du constructeur"
# etc.
c.__doc__ == "Une description de C".
c.__init__.__doc__ == "Une description du constructeur"
- Un itérateur énumère les éléments d’une collection. C’est un objet avec une simple méthode “next” qui retourne l’élément suivant ou génère un « StopIteration ».
- Vous pouvez atteindre un itérateur vers obj via la nouvelle fonction prédéfinie « iter(obj) », qui appelle obj.__class__.__iter__().
- Une collection peut être son propre itérateur en implémentant ensemble __iter__() et next().
- Des collections prédéfinies (listes, rangées d’un tableau, chaînes de caractères, dictionnaires) implémentent __iter__(); les dictionaires (plans (maps)) énumèrent leur clés (keys); les fichiers énumèrent leurs lignes.
- Vous pouvez construire une liste ou un rangée dans un tableau depuis un itérateur, e.g. list(anIterator).
- Python utilise des itérateurs implicites pour boucler :
o
for elt in
collection:
o
if elt in
collection:
o en assignant des rangées de tableau : x,y,z= collection
- Un générateur est une fonction qui se souvient de son état, de sa position entre deux appels et produit une nouvelle valeur à chaque invocation. Les valeurs sont retournées (une à la fois) en utilisant le mot-clé « yield ». « while return » ou « raise StopIteration() » sont utilisés pour modifier la fin des valeurs. (Le mot-clef yield utilisé dans une fonction permet de faire de cette fonction un générateur.)
- Une utilisation typique est la production d’identifiants (IDs), de noms, ou de numéros de série. Des applications de fantaisie comme « nanothreads » (nano processus) sont également possibles.
- Dans 2.2, le dispositif doit être disponible au travers de l’énoncé de l’instruction : from __future__ importgenerators (non requis depuis 2.3+).
- Pour utiliser un générateur : appelez la fonction generator pour obtenir un objet générateur, ensuite appelez generator.next() pour obtenir la prochaine valeur jusqu’à ce que StopIteration soit généré.
- La version 2.4 introduit des expressions de générateurs [PEP 289] similaires aux énumérations de compréhensions, sauf qu’ils créent un générateur qui retournera les éléments un par un, except that they create a generator that will return elements one by one, qui convient à de longues séquences :
linkGenerator
= (link for link in get_all_links() if not link.followed)
for
link in linkGenerator:
...process
link...
Le générateur d’expression doit apparaître entre parenthèses.
- [PEP342] Les générateurs avant 2.5 pouvaient produire des sorties (output). Maintenant, des valeurs peuvent être passées au générateur via leur méthode send(value).yield est maintenant une expression qui retourne une valeur, ainsi val = (yield i) voudra transformer en générateur i (yield i) à l’appelant (caller), et voudra réciproquement évaluer la valeur « sent » en retour de l’appelant (caller), ou None.
Deux autres nouvelles méthodes de générateur permettent des contrôles additionnels :
- throw(type, value=None, traceback=None) est utilisé pour générer une exception à l’intérieur du générateur (apparaît comme généré par l’expression « yield »).
- close() génère une nouvelle exception GeneratorExit à l’intérieur du générateur pour terminer l’itération.
Example:
def genID(initialValue=0):
v = initialValue
while v < initialValue + 1000:
yield "ID_%05d" % v
v += 1
return #
or: raise StopIteration()
generator = genID() # Crée un générateur
for i in range(10):
print generator.next() # Génère 10 valeurs
- Les descripteurs sont des objets implémentant au moins la première de ces trois méthodes représentant le protocole du descripteur :
__get__(self, obj, type=None) -->
value
__set__(self, obj, value)
__delete__(self, obj)
Python utilise maintenant de manière transparente les descripteurs pour décrire et accéder aux attributs et méthodes de classe de type nouveau « new-style classes » (i.e. dérivé de object). )
- Les descriteurs prédéfinis permettent de définir :
o Static methods (méthodes statiques) : utilise staticmethod(f) pour rendre la méthode f(x) statique (non lié(unbound)).
o Class methods (méthode de classe) : c’est comme une statique mais prend Class comme premier argument => Use f = classmethod(f) pour faire de la méthode f(theClass, x) une méthode de classe.
o
Properties (propriété) : Une propriété (property)
est une instance du nouveau type de propriété prédéfini, qui implémente le
protocole du descripteur pour les attributs => Use propertyName
= property(fget=None, fset=None, fdel=None,
doc=None) pour définir une propriété dans et hors d’une classe. Alors vous y
accédez comme propertyName ou obj.propertyName.
o Slots. Un nouveau style de classe peut définir un attribut de classe __slots__ pour contraindre la liste des noms d’attributs assignables, to constrain the list of assignable attribute names, pour éviter typos (ce qui n’est normalement pas détecté par Python et permet la création de nouveaux attributs), e.g. __slots__ = ('x', 'y')
o Note : En accord avec de récentes discussions, le réel objectif de slots ne semble pas très clair (optimisation ?), et leur emploi doit probablement être déconseillé.
- [PEP 318] Un décorateur (decorator) D est noté @D sur la ligne précédant la fonction/méthode qu’il décore :
@D
def f(): ...
et est équivalent à:
def f(): ...
f = D(f)
- Plusieurs décorateurs peuvent être appliqués en cascade :
@A
@B
@C
def f(): ...
est équivalent à:
f = A(B(C(f)))
- Un décorateur est juste une fonction qui prend le fct qui doit être décoré et retourne la même fonction ou quelle qu’autre nouvelle chose appelable.
- Les fonctions de décoration peuvent prendre des arguments suivants :
@A
@B
@C(args)
devient :
def f(): ...
_deco = C(args)
f = A(B(_deco(f)))
- Les décorateurs @staticmethod et @classmethod remplacent plus élégamment la déclaration équivalente f = staticmethod(f) et f = classmethod(f).
lambda [param_list]: returnedExpr
Crée une fonction anonyme.
returnedExpr doit être une expression, pas un énoncé d’instruction (e.g., pas "if xx:...", "print xxx", etc.) et donc ne peut contenir des caractères NL (newlines). Utilisé le plus souvent pour les fonctions filter(), map(), reduce(), et les rappels de services de GUI.
result = [expression for item1 in
sequence1 [if condition1]
[for item2 in sequence2 ... for
itemN in sequenceN]
]
est
équivalent à:
result =
[]
for item1 in sequence1:
for item2 in sequence2:
...
for itemN in sequenceN:
if (condition1) and
further conditions:
result.append(expression)
Depuis 2.2 les vues encapsulées (nested scopes) ne demande d’être spécialement disponibles à une directive from __future__ importnested_scopes, et sont toujours usitées.
Les fonctions prédéfinies sont définies dans un module _builtin__ importé automatiquement.
Les fonctions prédéfinies.
Fonction
Résultat
__import__(name[, globals[,locals[,from list]]])
Importe le module dans le contexte fourni (voyez les références de librairies pour plus de détails)
abs(x)
Retourne la valeur absolue du nombre x.
all(iterable)
Retourne Vrai (True) si bool(x) est Vrai (True) pour la valeur all de x dans itérable.
any(iterable)
Retourne Vrai (True) si bool(x) est Vrai (True) pour la valeur any de x dans itérable.
apply(f, args[, keywords])
Appelle la fonction/méthode f avec les arguments args les motsclés optionnels. Déconseillé depuis 2.3, il remplace apply(func, args,keywords) par func(*args, **keywords) [details].
basestring()
Une superclasse abstraite de str et unicode; ne peut pas être appelée ou instanciée directement, utilisez de préférence dans : isinstance(obj,basestring).
bool([x])
Convertit une valeur en booléen en utilisantla procédure standard de teste de vérité. Si x est faux (false) ou omis, il retourne Faux (False); autrement il retourne Vrai (True). bool est également une classe/type, sous-classe (subclass) ou entier (int). La classe bool ne peut pas être sous classée ultérieurement. Ses seules instances sont Vrai (True) et Faux (False). Voyez également les opérateurs booléens.
buffer(object[, offset[, size]])
Retourne un tampon buffer depuis une tranche d’objet, qui doit supporter l’interface d’appel du buffer (Chaîne (string), tableaux (array), buffer). Fonction non essentielle, voyez [details].
callable(x)
Retourne Vrai (True) si x est appelable, sinon Faux (False).
chr(i)
Retourne une chaîne d’un unique caractère dont le code ASCII est i.
classmethod(function)
Retourne une méthode de classe pour une fonction function. Une méthode de classe reçoit la classe comme premier argument implicite, exactement comme une méthode d’instance reçoit l’instance. Pour déclarer une méthode de classe, utilisez l’idiome suivant :
class C:
def f(cls, arg1, arg2, ...): ...
f = classmethod(f)
Ensuite appelez-le sur par classe C.f() ou par une instance C().f(). L’instance est ignorée sauf pour sa propre classe. Si une méthode de classe est appelée pour une classe dérivée, l’objet classe dérivé est passé en premier argument impliqué. Depuis 2.4 vous pouvez alternativement utilise la notation de décorateur decorator:
class C:
@classmethod
def f(cls, arg1, arg2, ...): ...
cmp(x,y)
Retourne négatif, 0 ou positif si x est respectivement <, ==, > à y.
coerce(x,y)
Retourne un uplet (tuple) des deux arguments numériques convertis dans un type commun. Fonction non essentielle voir [details].
compile(string, filename, kind[, flags[, dont_inherit]]) Compile une chaîne string en un objet code. filename est utilisé dans un message d’erreur peut être n’importe quelle chaîne. C’est habituellement le fichier d’où le code est lu, ou e.g. '<string>' s’il n’est pas lu depuis le fichier. kind peut être évalué ('eval') si string est un unique énoncé d’instruction, ou 'single' qui affiche la sortie des énoncés d’expression qui évaluent vers quelque chose d’autre que None, ou est exécutable 'exec'. Les nouveaux arguments flags et dont_inherit concerne de futurs énoncés d’instructions.
complex(real[, image])
Crée un objet complexe complex (peut également être fait en utilisant le suffixe J ou j, e.g. 1+3J).
delattr(obj, name)
Efface les attributs nommés name de l’objet obj <=> del obj.name.
dict([mapping-or-sequence])
Retourne un nouveau dictionnaire initialisé depuis l’argument optionnel (ou un dictionnaire vide si aucun argument n’est fourni). L’argument doit être une séquence (ou quelque chose d’itérable) ou une paire « clé, valeur » (key, value).
dir([object])
Sans arguments, retourne une liste de noms dans la table courante de symboles. Avec un module, une classe ou un objet instance de classe comme argument, il retourne dans ses attributs de dictionnaire.
divmod(a,b)
Retourne un uplet (tuple) avec le quotient de la division, le reste de la division (a/b,a%b)
enumerate(iterable)
C’est un itérateur iterator qui retourne des paires indexe/valeur (index, value) de l’itérable iterable, e.g. List(enumerate('Py')) -> [(0, 'P'), (1, y')]
eval(s[, globals[, locals]])
Evalue la chaîne s, représentant une unique expression Python, dans les contextes optionnels global et local.
s ne doit avoir aucun NUL ni newlines.
s peut aussi être un objet code.
locals peut être tout type mapping, et pas seulement un dictionnaire régulier de Python.
Example:
x = 1; assert eval('x + 1') == 2
(Pour exécuter des instructions plutôt qu’une seule expression, utilisez l’instruction Python exec ou la fonction prédéfinie execfile)
execfile(file[, globals[,locals]])
Exécute un fichier sans créer de nouveau module, à la différence de import.
locals peut être tout type mapping, et pas seulement un dictionnaire régulier de Python.
file(filename[,mode[,bufsize]])
Ouvre un fichier et retourne un nouvel objet fichier file. C’est un alias de open.
filter(function,sequence)
Construit une liste depuis ces éléments d’une séquence pour laquelle la fonction function retourne Vrai (true). La fonction function prend un paramètre.
float(x)
Convertit un nombre ou une chaîne x en un nombre à virgule flottante.
frozenset([iterable])
Retourne un objet frozenset (ensemble immuable) don’t les éléments (immuables) sont pris depuis iterable, ou Vide (empty) par défaut. Voyez également Sets.
getattr(object,name[,default]))
Va chercher les attributs nommés appelé de object, e.g. getattr(x, 'f') <=> x.f). Si non trouvé, génère une erreur d’attribut AttributeError ou retourne la valeur default si elle a été spécifiée.
globals()
Retourne un dictionnaire contenant les variables globales courantes.
hasattr(object, name)
Retourne Vrai (True) si l’objet object a un nom d’attribut appelé name.
hash(object)
Retourne la valeur la valeur de contrôle (hash value) de l’objet (s’il en a une).
help([object])
Appelle le système d’aide prédéfini. Pas d’argument -> mode d’aide interactive. Si l’objet est une chaîne (nom de module, de fonction, de classe, de méthode, mot-clé ou élément de documentation), une page d’aide est affichée sur la console; autrement une page d’aide (help page) sur l’objet object est généré.
hex(x)
Convertit un nombre x en chaîne hexadécimale.
id(object)
Retourne un identifiant unique entier (integer) pour l’objet object. Depuis 2.5 retourne toujours des nombres non négatifs.
input([prompt])
Affiche prompt s’il est fourni. Lit l’entrée et l’évalue.
Utilise line
editing / history si le module readline est disponible.
int(x[, base])
Convertit un nombre ou une chaîne en un entier simple (plain integer). Le paramètre optionnel base spécifie dans quelle base il faut convertir valeur représentée dans la chaîne.
intern(aString)
Entre la chaîne aString dans la table des chaînes internalisées et retourne la chaîne. Depuis 2.3, les chaînes internalisées ne sont plus immortelles 'immortal' (jamais collectées comme des inutiles « garbage »), voyez [details].
isinstance(obj, classInfo)
Retourne Vrai (true) si l’objet obj est une instance de classe classInfo ou un objet de type classInfo (classInfo peut également être un uplet de classes ou de types).
If issubclass(A,B) then isinstance(x,A)
=> isinstance(x,B).
issubclass(class1, class2)
Retourne Vrai (true) si la première classe class1 est dérivée de la seconde classe class2 (ou si class1 est class2).
iter(obj[,sentinel])
Retourne un itérateur iterator sur obj. Si sentinel est absent, obj doit être une collection implémentant soit __iter__() soit __getitem__().
Si sentinel est donné, obj sera appelé sans argument; Si la valeur retournée est égale à sentinel, StopIteration sera généré, autrement la valeur sera retournée. Voyez Itérateurs (Iterators).
len(obj)
Retourne la longueur (le nombre d’items) d’un objet (séquence, dictionnaire, ou instance de classe implémentant __len__).
list([seq])
Crée une liste vide ou une liste avec les mêmes éléments que seq. seq peut être une séquence, un conteneur qui supporte l’itération, ou un objet iterator. Si seq est déjà une liste, il retourne une copie de celle-ci.
locals()
Retourne un dictionnaire contenant les variables locales courantes.
long(x[, base])
Convertit un nombre ou une chaîne en un entier long. Le paramètre optionnel base spécifie la base dans laquelle convertir les valeurs dans la chaîne.
map(function, sequence[, sequence, ...])
Retourne une liste des résultats de l’application de la fonction function sur chacun des items de la (des) séquence(s). Si plus d’une séquence est fournie, la fonction est appelée avec un argument liste (list) composé de l’item correspondant dans chaque séquence, substituant les valeurs manquantes par None lorsque toutes les séquences n’ont pas la même longueur. Si function est None, il retourne la liste des items de la séquence (ou un uplet (tuples) s’il y a plus d’une séquence). => Vous pouvez également considérer d’utiliser des compréhensions de liste (list comprehensions) à la place de map().
max(iterable[, key=func])
max(v1, v2, ...[, key=func])
Avec un unique argument iterable, il retourne le plus grand item d’un iterable non vide (comme une chaîne, une rangée ou une liste). Avec plus d’un argument, il retourne le plus grand des arguments. L’argument optionnel key est une fonction func qui prend un seul argument et est appelée pour chaque valeur dans la liste.
min(iterable[, key=func])
min(v1, v2, ...[, key=func])
Avec un seul argument iterable, il retourne le plus petit item de iterable non vide (comme une chaîne, rangée ou liste). Avec plus d’un argument, il retourne le plus petit argument. L’argument optionnel key est une fonction func qui prend un seul argument est appelée pour chacun des items de la liste.
object()
Retourne un nouvel objet sans particularité. object est une classe de base pour tout nouveau style de classe, ses méthodes sont communes à toutes les instances de ce nouveau type de classes.
oct(x)
Convertit un nombre x en une chaîne octale.
open(filename [, mode='r',
[bufsize]])
Retourne un nouvel objet fichier. Voyez également l’alias file(). Utilisez codecs.open() à la place pour ouvrir un fichier encodé et exécuter transparent encoding / decoding.
- filename est le nom du fichier qui doit être ouvert.
- mode indique comment le fichier doit être ouvert :
- 'r' en lecture
- 'w' en écriture (en tronquant un fichier existant)
- 'a' l’ouvre pour ajouter, compléter
- '+' (apposé à chacun des modes précédents) ouvre un fichier pour
sa mise à jour (notez que 'w+' tronque le fichier)
- 'b' (apposé à chacun des modes précédents) ouvre un fichier en
mode binaire.
- 'U' (ou 'rU') ouvre un
fichier en lecture en mode Universal
Newline : toutes les variantes de fin de ligne (EOL) (CR, LF,
CR+LF) sont transformées en simple saut de ligne (Line Feed)
LF ('\n').
- bufsize est 0 pour ne pas buffériser, 1 pour ligne bufférisée, négatif ou omis la valeur système par défaut, >1 pour un tampon de la taille donnée.
ord(c)
Retourne une valeur d’entier (integer) ASCII de c (une chaîne de longueur 1). Fonctionne avec des caractères Unicode.
pow(x, y [, z])
Retourne x à la puissance y [modulo z]. Voir également l’opérateur **.
property([fget[, fset[, fdel[, doc]]]])
Retourne une propriété attribut pour des classes « nouveau style » (new-style classes) (classes dérivant d’un objet object). fget, fset, et fdel sont des fonctions pour aller chercher la valeur de propriété, positionner la valeur de propriété, et supprimer la valeur de propriété, respectivement.
Usage typique :
class C(object):
def __init__(self): self.__x = None
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__xx = property(getx,
setx, delx, "I'm the 'x'property.")
range([start,] end [, step])
Retourne la liste des entiers “ints” de >= start et < end.
Avec 1 argument, liste depuis 0..argument-1.
Avec 2 arguments, liste depuis start..end-1.
Avec 3 arguments, liste depuis start jusqu’à end par pas “step”.
raw_input([prompt])
Affiche le prompt s’il est fourni, puis lit la chaîne depuis une entrée standard (std input) (sans caractère de fin de chaîne \n). Voyez également input().
reduce(f, list [, init])
Applique la fonction binaire f aux items de la liste list pour la réduire à une seule valeur. Si init est fourni, il est “ajouté” en début de liste.
reload(module)
Il réinitialise et re-analyse un module déjà importé. Pratique si, en mode interactif, vous devez recharger un module après l’avoir réparé. Si module a une syntaxe correcte mais contient une erreur au niveau de l’initialisation, vous devez l’importer une nouvelle fois avant de pouvoir appeler reload().
repr(object)
Retourne une chaîne contenant une affichable et, si possible, évaluable représentation d’un objet. <=> `object` (en utilisant des apostrophes inversées). Classe redéfinissable (__repr__). Voyez également str().
round(x, n=0)
Retourne la valeur en virgule flottante de x, arrondie au nombre de décimales n après le point décimal.
set([iterable])
Retourne un objet set dont les éléments sont pris depuis un itérable iterable, ou Vide (empty) par défaut. Voyez également Sets.
setattr(object, name, value)
C’est une contre partie de getattr().setattr(o, 'foobar', 3) <=> o.foobar = 3. Crée un attribut s’il n’existe pas !
slice([start,] stop[, step])
Retourne un objet slice représentant une zone (range), avec les attributs R/O : start, stop, step.
sorted(iterable[, cmp[, key[,
reverse]]])
Retourne une nouvelle liste triée depuis les items contenus dans un itérable iterable. Ceci est différent de list.sort() par le fait qu’il trie la liste en place et ne s’applique pas aux séquences immuables comme des chaînes (string) ou des rangées de tableau (tuple). Voyez la méthode sequences.sort.
staticmethod(function)
Retourne une méthode statique (static method) pour une fonction function. Une méthode statique ne peut pas recevoir un premier argument implicite. Pour déclarer une méthode statique, utilisez cet idiome :
class C:
def f(arg1, arg2, ...): ...
f = staticmethod(f)
Ensuite appelez-la dans la classe C.f() ou dans une instance C().f(). L’instance est ignorée pour ses propres classes.
Depuis 2.4 vous pouvez également utiliser le notation de décorateur (decorator) :
class C:
@staticmethod
def f(arg1, arg2, ...): ...
str(object)
Retourne une chaîne contenant une belle représentation affichable de l’objet objet. Classe surchargeable (__str__). Voyez également repr().
sum(iterable[, start=0])
Retourne la somme d’une séquence de nombres (pas de chaîne), plus la valeur du paramètre. Il retourne start lorsque la séquence est vide (empty).
super( type[, object-or-type])
Retourne une super-classe de type type. Si le second argument est omis, le super-objet retourné est non lié. Si le second argument est un objet, issubclass(type2, type) doit être vrai (true).
Utilisation typique :
class C(B):
def meth(self, arg):
super(C, self).meth(arg)
tuple([seq])
Crée un uplet (tuple) ou une rangée avec les mêmes éléments que seq. Un tuple (uplet) est une liste de valeurs qu’il n’est pas possible de modifier. seq peut être une séquence, un conteneur qui supporte l’itération ou un objet itérateur (iterator object). Si seq est déjà un uplet (tuple), il se retourne lui-même, (pas une copie).
type(obj)
Retourne un type d’objet [voyez le module types]
représentant le type de obj. Exemple : import types if type(x) == types.StringType:
print 'It is a string'. NB: il est
préférable d’utilise à la place : if isinstance(x,
types.StringType)...
unichr(code)
Retourne une chaîne Unicode de 1 caractère log à partir de la valeur code fournie.
unicode(string[, encoding[,error]]])
Crée une chaîne Unicode depuis une chaîne codée 8-bit, en utilisant le nom de l’encodage donné dans encoding et le traitement de l’erreur ('strict', 'ignore', ou 'replace'}. Pour les objets qui fournissent une méthode __unicode__(), il appellera cette méthode sans argument pour créer la chaîne Unicode.
vars([object])
Sans arguments, retourne un dictionnaire correspondant à la table courante des symboles. Avec un module, un classe (class) ou un objet instance de classe (instance object) a un argument, il retourne un dictionnaire correspondant à la table des symboles de l’objet object. Utilisable avec l’opérateur de formatage de chaîne "%".
xrange(start [, end [, step]])
Comme range(), mais ne doit pas actuellement stocker une liste entière en une seule fois.
Bon pour une utilisation dans des boucles "for" lorsqu’il y a une grande zone de données (range) à gérer et une petite mémoire.
zip(seq1[, seq2,...])
[Non, ceci n’est pas un outil de compression ! Pour cela, reportez-vous au module zipfile]
Retourne une ligne invariable de tableau (tuple) où chaque rangée contient le nième élément de chacune des séquences d’argument. Depuis 2.4, retourne une liste vide (empty) s’il est appelé sans arguments (anciennement, était généré par TypeError).
La mère de toutes les exceptions (était une Exception avant 2.5). New-style class. exception.args est un uplet (tuple) des arguments qui sont passés au constructeur.
KeyboardInterrupt & SystemExit ont été sortis de Exception parce qu’ils ne représentent pas réellement des erreurs, ainsi maintenant, un try:...except Exception: voudra seulement trouver les erreurs tandis que un try:...except: (ou plus simplement try:..except BaseException:) cherchera tout.
KeyboardInterrupt
Lors de la saisie d’une clé d’interruption par l’utilisateur (souvent `CTRL-C'). Avant 2.5 il était dérivé de Exception.
SystemExit
Lors d’un sys.exit(). Avant 2.5 il était dérivé de Exception.
Exception
Base de toutes les erreurs error. Avant 2.5 c’était la base de toutes les exceptions.
StandardError
Classe de base pour toutes les exceptions prédéfinies; dérivé de la classe d’origine (root class) Exception.
ArithmeticError
Classe de base pour les erreurs arithmétiques.
FloatingPointError
Quand une opération en virgule flottante échoue.
OverflowError
Pour des opérations arithmétiques excessivement longues.
ZeroDivisionError
Lors d’une division ou une opération module avec un 0 comme second argument.
AssertionError
Lorsqu’une instruction d’insertion échoue.
AttributeError
Lorsque le référence ou l’assignation d’un attribut échoue.
EnvironmentError
[new in 1.5.2]
Lors d’une erreur externe à Python; la rangée des arguments d’erreur est (errno, errMsg...).
IOError
[changed in 1.5.2]
Lorsque les opérations de relations en I/O échouent.
OSError
[new in 1.5.2]
Utilisé par les modules de gestion d’exception de l’OS (Sysytème d’exploitation) os.error.
WindowsError
Lorsqu’une erreur spécifique à Windows survient ou lorsque le numéro de l’erreur ne correspond pas à une valeur errno.
EOFError
Fin de Fichier (EOF) immédiat par input() raw_input().
ImportError
Lors d’un défaut d’importation à trouver un module (module) ou un nom (name).
KeyboardInterrupt
Déplacé sous BaseException.
LookupError
Classe de base pour IndexError, KeyError.
IndexError
Lors d’un indice inférieur à la séquence (out-of-range).
KeyError
Lors d’une référence à une clé d’organisation d’un dictionnaire inexistante.
MemoryError
Lors de dépassement de mémoire récupérable.
NameError
Défaillance à trouver un nom local ou global (non qualifié).
UnboundLocalError
On fait référence à une variable local non assignée.
ReferenceError
Sur une tentative d’accéder à un objet de récupération de mémoire (garbage-collected object) via une procuration de référence faible.
RuntimeError
Passe-partout démodé ! Définissez plutôt une erreur appropriée.
NotImplementedError
[new in 1.5.2]
Pour une méthode non implémentée.
SyntaxError
Pour une erreur de syntaxe rencontrée par l’analyseur du code.
IndentationError
Pour une erreur d’indentation de la syntaxe rencontrée par l’analyseur du code.
TabError
Pour une alternance impropre de caractères d’espacement et de tabulations.
SystemError
Pour une erreur non fatal de l’interpréteur. - bug – le rapporte !
TypeError
Pour le passage d’un type non approprié à un opérateur prédéfini ou une fonction.
ValueError
Pour une erreur d’argument non couverte par TypeError ou plus précise.
UnicodeError
Pour un encodage en relation avec Unicode ou pour une erreur de décodage.
UnicodeDecodeError
Pour une erreur de décodage Unicode.
UnicodeEncodeError
Pour une erreur d’encodage Unicode.
UnicodeTranslateError
Pour une erreur de traduction Unicode.
StopIteration
Généré la méthode d’itérateur next() pour signaler qu’il n’y a pas d’autre valeur après.
SystemExit
Déplacé vers BaseException.
Warning
Classe de base pour les avertissements (voyez le module warning).
DeprecationWarning
Avertir en cas de code désapprouvé.
FutureWarning
Avertissement au sujet d’un constructeur dont le code sera changé sémantiquement dans le futur.
ImportWarning
Avertissement à propos d’une probable erreur dans le module d’importation import (e.g. __init__.py manquant).
OverflowWarning
Avertissement d’un dépassement de capacité lors d’opérations numériques N’existera plus dans Python 2.5.
PendingDeprecationWarning
Avertissement à propos d’un code qui sera désapprouvé dans le futur.
RuntimeWarning
Avertissement à propos d’un comportement, déroulement douteux.
SyntaxWarning
Avertissement à propos d’une syntaxe douteuse.
UnicodeWarning
En essayant de comparer un chaîne Unicode et une chaîne 8-bit qui ne peut être traduite en Unicode en utilisant l’encodage ASCII par défaut (Générait un UnicodeDecodeError avant 2.5).
UserWarning
Avertissement généré par le code utilisateur.
Méthode standard et transformation d’opérateurs en méthodes spéciales '__method__' et ainsi peuvent être redéfinies (la plupart du temps dans des classes définies par l’utilisateur), e.g.:
class C:
def __init__(self, v): self.value = v
def __add__(self, r): return self.value
+ r
a = C(3) # Trie comme l’appel à C.__init__(a, 3)
a + 4 # est équivalent à a.__add__(4)
Méthode
Description.
__new__(cls[, ...])
Création d’instance (en construction). Si __new__ retourne une instance de cls alors __init__ est appelé avec le reste des arguments (…), autrement __init__ ne sera pas invoqué. Pour plus de détails, voyez here.
__init__(self, args)
Initialisation d’instance (en construction).
__del__(self)
Appelé lors de la cession d’objet (refcount devient 0)
__repr__(self)
Conversions de repr() et `...` (apostrophes inverses).
__str__(self)
Enoncé d’instruction str() et print.
__cmp__(self,other)
Compare self à other et retourne <0, 0, ou >0. Implémente >,
<, == etc...
__index__(self)
[PEP357] Autorise l’usage de tout objet comme index d’un nombre entier (integer)(e.g. pour fragmenter). Doit retourner une valeur unique d’entier (integer) ou un entier long.
__lt__(self, other)
Appelé pour comparer si self < other. Peut retourner quelque chose, ou peut générer une exception.
__le__(self, other)
Appelé pour comparer si self <= other. Peut retourner quelque chose, ou peut générer une exception.
__gt__(self, other)
Appelé pour comparer si self > other. Peut retourner quelque chose, ou peut générer une exception.
__ge__(self, other)
Appelé pour comparer si self >= other. Peut retourner quelque chose, ou peut générer une exception.
__eq__(self, other)
Appelé pour comparer si self == other. Peut retourner quelque chose, ou peut générer une exception.
__ne__(self, other)
Appelé pour comparer si self != other (et self <> other). Peut retourner quelque chose, ou peut générer une exception.
__hash__(self)
Calcule un code de contrôle de 32 bits; hash() et options de dictionnaire. Depuis 2.5 peut égélement retourner un entier long, dans quel cas, le code de contrôle de cette valeur sera pris en compte.
__nonzero__(self)
Retourne 0 ou 1 pour le test de vérité d’une valeur. Quand cette méthode n’est pas définie, __len__() est appelé si défini; autrement toutes les instances de classes sont considérée comme « Vrai » (true).
__getattr__(self, name)
Appelé lorsque la recherche d’attributs ne trouve pas name. Voyez également __getattribute__.
__getattribute__(self, name)
Comme __getattr__ mais toujours appelé lorsque l’on accède à l’attribut name.
__setattr__(self, name, value)
Appelé lors du positionnement d’un attribut (dedans, n’utilisez pas "self.name = value", utilisez plutôt "self.__dict__[name] = value").
__delattr__(self, name)
Appelé
pour supprimer l’attribut name.
__call__(self, *args, **kwargs)
Appelé lorsqu’une instance est appelée comme une fonction : obj(arg1, arg2,...) est un raccourci de obj.__call__(arg1, arg2, ...).
Voyez la liste dans le module operator. Les noms des fonctions Operator sont disponibles avec deux variantes, avec ou sans les doubles traits de soulignement devant et derrière le nom (e.g. __add__ ou add).
Opérateur Méthode spéciale
self + other __add__(self, other)
self - other __sub__(self, other)
self * other __mul__(self,
other)
self / other __div__(self,
other) ou __truediv__(self,other) si
__future__.division est actif.
self // other __floordiv__(self,
other)
self % other __mod__(self,
other)
divmod(self,other) __divmod__(self, other)
self ** other __pow__(self,
other)
self & other __and__(self,
other)
self ^ other __xor__(self,
other)
self | other __or__(self,
other)
self << other __lshift__(self,
other)
self >> other __rshift__(self,
other)
nonzero(self) __nonzero__(self) (utilisé lors de tests booléens)
-self __neg__(self)
+self __pos__(self)
abs(self) __abs__(self)
~self __invert__(self) (au niveau binaire)
self += other __iadd__(self,
other)
self -= other __isub__(self,
other)
self *= other __imul__(self,
other)
self /= other __idiv__(self,
other) ou __itruediv__(self,other)
si __future__.division est en action.
self //= other __ifloordiv__(self,
other)
self %= other __imod__(self,
other)
self **= other __ipow__(self,
other)
self &= other __iand__(self,
other)
self ^= other __ixor__(self,
other)
self |= other __ior__(self, other)
self <<= other __ilshift__(self,
other)
self >>= other __irshift__(self,
other)
Fonctions prédéfinies Méthodes spéciales
int(self) __int__(self)
long(self) __long__(self)
float(self) __float__(self)
complex(self) __complex__(self)
oct(self) __oct__(self)
hex(self) __hex__(self)
coerce(self, other) other) __coerce__(self, other)
Des équivalents pour tous les opérateurs binaires du côté droit existent; ils sont appelés lorsque l’instance de classe se trouve du côté droit de l’opérateur :
a + 3 appelle __add__(a, 3)
3 + a appelle __radd__(a, 3)
Opération Méthode Spéciale
Notes
Toutes les séquences et suites :
len(self) __len__(self)
Longueur de l’objet, >= 0. Longueur == faux (false).
self[k] __getitem__(self, k)
Cherche l’élément à l’indice (clé k) (indices commencent starts à 0). Ou si k est un objet fractionné, retourne la fraction.
__missing__(self, key)
Raccordement (Hook) appelé lorsque key n’est pas trouvé dans le dictionnaire, retourne la valeur par défaut.
self[k] = value __setitem__(self,
k, value)
Met l’élément à l’indice/cle/fraction k.
del self[k]
__delitem__(self, k)
Efface l’élément à l’indice/clé/fraction k.
elt in self et elt
not in self
__contains__(self, elt) et not __contains__(self, elt)
Plus efficace que la séquence d’itération standard thru.
iter(self) __iter__(self)
Retourne un itérateur sur des éléments (cles pour organiser, ordonner)
<=> self.iterkeys()). Voyez Itérateurs.
Séquences
Méthodes générales
Plus :
self[i:j] __getslice__(self, i, j)
Déconseillé depuis 2.0, remplacé par __getitem__ avec un objet franctionné comme paramètre.
self[i:j] = seq __setslice__(self,
i, j, seq)
Déconseillé depuis 2.0, remplacé par __setitem__ avec un objet fractionné comme paramètre.
del self[i:j] __delslice__(self, i, j)
Comme self[i:j] = []. Déconseillé depuis 2.0, remplacé par __delitem__ avec un objet fragmenté comme paramètre.
self * n __mul__(self, n)
(__repeat__ dans la documentation officielle mais ne fonctionne pas !)
self + other __add__(self, other)
(__concat__ dans la documentation officielle mais ne fonctionne pas !)
Adressage
Méthodes générales
Plus :
hash(self) __hash__(self)
Valeur contrôlée (hash) d’un objet self est utilisée pour des clés de dictionnaire.
Tip: utilisez le module inspect pour vérifier si un objet est vivant.
Attributs
Signification
__methods__
(list, R/O) : Liste des noms de méthodes de l’objet.
Déprécié, utilisez dir() à la place.
Attributs
Signification
__doc__
(string/None, R/O): Document chaîne (<=> __dict__['__doc__'])
__name__
(string, R/O): nom du module (également dans __dict__['__name__'])
__dict__
(dict, R/O): espace nom du module.
__file__
(Chaîne (string)/non défini (undefined), R/O) : nom du chemin où se trouvent les fichiers .pyc, .pyo or .pyd (Non défini pour les modules liés statiquement à l’interpréteur). Avant 2.3 utilisez sys.argv[0] au lieu de chercher à trouver le nom du fichier script courant.
__path__
(Liste (list)/non défini (undefined), R/W) : Liste du chemin du directory où la paquet a été trouvé (pour les paquets seulement).
Attributs
Signification
__doc__
(string/None, R/W) : document chaîne (<=> __dict__['__doc__'])
__name__
(string, R/W) : Nom de la classe (également dans __dict__['__name__'])
__module__
(string, R/W) : Nom du module d’où la classe a été définie.
__bases__
(tuple, R/W) : Classes parents.
__dict__
(dict, R/W) : Attributs (espace nom de classe)
Attributs
Signification
__class__
(class, R/W) : Classes d’instances.
__dict__
(dict, R/W) : Attributs.
Attributs
Signification
__doc__
(string/None, R/W) : Document chaîne.
__name__
(chaîne, R/O): Nom de fonction.
func_doc
(R/W) : Semblable à __doc__
func_name
(R/O, R/W depuis 2.4) : Semblable à __name__.
func_defaults
(tuple/None, R/W) : Valeurs d’arguments par défaut s’il y en a.
func_code
(code, R/W) : Le code objet représentant le corps de la fonction compilé.
func_globals
(dict, R/O) : Fait référence au dictionnaire des variables globales de fonction.
Attributs
Signification
__doc__
(string/None,
R/O) : Document chaîne.
__name__
(string, R/O) : Nom de méthode (semblable à im_func.__name__)
im_class
(class, R/O) : Classe définissant la méthode (peut être une classe de base).
im_self
(instance/None, R/O) : Objet instance cible (None si non lié)
im_func
(function, R/O) : Objet fonction.
Attributs
Signification
__doc__
(string/None, R/O) : Document chaîne.
__name__
(string, R/O) : Nom de fonction.
__self__
[methods
only] Objet cible.
__members__
Liste des noms d’attributs : ['__doc__','__name__','__self__'])
Déconseillé, utilisez dir()
à la place.
Attributs
Signification
co_name
(string, R/O) : Nom de fonction.
co_argcount
(int, R/0) : Nombre d’arguments positionnés.
co_nlocals
(int, R/O) : Nombre de variables locales (incluant les arguments).
co_varnames
(tuple, R/O) : Noms des variables locales (en commençant par les arguments).
co_code
(string, R/O) : Séquence d’instructions en code 8-bits.
co_consts
(tuple, R/O) : Littéraux utilisés par le code 8-bits, le premier est un document fonction (ou None).
co_names
(tuple, R/O) : Noms utilisés par le code 8-bits.
co_filename
(string, R/O) : Noms de fichier à partir duquel le code a été compilé.
co_firstlineno
(int, R/O) : Numéro de la première ligne de la fonction.
co_lnotab
(string, R/O) : Chaîne encodant le déplacement du code 8-bits du nombre lignes.
co_stacksize
(int, R/O) : Nécessite la taille de la pile (en incluant les variables locales).
co_flags
(int, R/O) : Drapeaux (flag) pour l’interpréteur, le bit 2 est positionné si la fonction utilise la syntaxe "*arg", le bit 3 est positionné si la fonction utilise la syntaxe '**keywords'.
Attributs
Signification
f_back
(frame/None, R/O) : Vue précédante de la pile (vers l’appelant).
f_code
(code, R/O) : Objet code en cours d’exécution dans la vue.
f_locals
(dict, R/O) : Variables locales.
f_globals
(dict, R/O) : Variables globales.
f_builtins
(dict, R/O) : Noms prédéfinis (intrinsèques).
f_restricted
(int, R/O) : Drapeau (flag) indiquant si la fonction est exécutée en mode restrictif.
f_lineno
(int, R/O) : Numéro de ligne courante.
f_lasti
(int, R/O) : Instruction précise (index vers le code 8-bits).
f_trace
(function/None, R/W) : Suivi de débogage appelé au démarrage de chaque ligne.
f_exc_type
(Type/None, R/W) : Le type d’exception le plus récent.
f_exc_value
(any, R/W) : La valeur d’exception la plus récente.
f_exc_traceback
(traceback/None, R/W) : Suivi d’exception le plus récent.
Attributs
Signification
tb_next
(frame/None, R/O) : Niveau suivant dans le suivi de la pile (Vers la vue où a eu lieu l’exception)
tb_frame
(frame, R/O) : Vue d’exécution du niveau courant.
tb_lineno
(int, R/O) : Numéro de ligne où est survunue l’exception.
tb_lasti
(int, R/O) : Instruction précise (index dans le code 8-bits)
Attributs
Signification
start
(any/None, R/O) : Limite inférieure incluse.
stop
(any/None, R/O) : Linmite supérieure incluse.
step
(any/None, R/O) : Valeur, longueur du saut.
Attributs
Signification
real
(float, R/O) : Partie réelle d’un nombre imaginaire.
imag
(float, R/O) : Partie imaginaire d’un nombre imaginaire.
Attributs
Signification
tolist
(Méthode prédéfinie, R/O) : ?
Paramètres et fonctions spécifiques au système.
Quelques variables système.
Variable
Contenu.
argv
La liste des arguments de la ligne de commande passée au script Python. sys.argv[0] est le nom d’un script.
builtin_module_names
Une liste de chaînes donnant les noms de tous les modules écrits en C et qui sont liés avec cet interpréteur.
byteorder
Ordre natif de byte, soit 'big'(-endian), soit 'little'(-endian).
check_interval
Combien de fois tester les commitateurs de bande ou des signaux (mesuré en nombre d’instructions de machine virtuelle).
copyright
Une chaîne contenant le copyright concernant l’interpréteur Python.
exec_prefix
prefix
Directory principal où les fichiers Python dépendant de la machine ont été installés, e.g. 'C:\\Python23', '/usr'.
executable
Nom de l’exécutable binaire de l’interpréteur Python (e.g.
'C:\\Python23\\python.exe',
'/usr/bin/python').
exitfunc
L’utilisateur peut positionner une fonction sans paramètre. Il sera cherché avant que l’interpréteur n’existe. Déconseillé depuis 2.4. Le code doit utiliser le module existant atexit.
last_type,
last_value,
last_traceback
Positionné seulement lors d’une exception non prise en main et l’interpréteur affiche une erreur. Utilisé par le les débogueurs.
maxint
Valeur maximum positive d’un entier (integer). Depuis 2.2 les entiers (integer) et les entiers longs (long) sont unifiés, ainsi, les entiers (integer) n’ont plus de limite (sauf celle de la mémoire disponible).
maxunicode
Le point de code le plus grand supporté pour un caractère Unicode.
modules
Dictionnaire des modules qui ont déjà été chargés.
path
Chemin de recherche pour les modules externes. Peut être modifié par le programme. sys.path[0] == Directory où le script courant est exécuté.
platform
La plateforme courante, e.g. "sunos5", "win32"
ps1, ps2
Prompts à utiliser en mode ineractif, normalement ">>>" et "..."
stdin, stdout, stderr
Objet fichier (File) utilisé dans les opérations d’entrée/sortie (I/O). Un peut être redirigé en lui assignant un nouvel objet fichier (ou n’importe que lobjet : avec une méthode write(string) pour stdout/stderr, ou avec une méthode readline() pour stdin). __stdin__, __stdout__ and __stderr__ sont les valeurs par défaut.
subversion
Info à propos de la version Python dans le dépôt Subversion : ligne (de tableau)(nom de l’interpréteur, non de branche, plage de révision), e.g. ('CPython','tags/r25', '51908').
version
Chaîne contenant les infos de version de l’interpréteur Python.
version_info
Ligne (de tableau) contenant des infos sur la version Python -(major (majeure), minor (mineure), micro, level (niveau), serial (numéro de série)).
winver
Numéro de version utilisé pour former des clés de registre sur les plateformes Windows (e.g. '2.2').
Fonction
Résultat
_current_frames()
Retourne la vue courante de la pile pour tous les processus en cours, comme un dictionnaire répertoriant les identifiants de processus vers la vue de la pile la plus importante actuellement active dans ce processus au moment où la fonction est appelée.
displayhook
La fonction utilisée pour montrer la sortie provoquée par les commandes terminées en mode interactif – par défaut, la fonction prédéfinie repr(). __displayhook__ est la valeur originale.
excepthook
Peut être positionné pour une fonction définie par l’utilisateur, vers qui des fonctions non attrappées sont passées. __excepthook__ est la valeur originale.
exit(n)
Quitter, sortir avec le statut n (habituellement 0 signifie OK). Génère l’exception SystemExit (et donc peut être intercepté ou ignoré par le programme).
getrefcount(object)
Retourne la référence count de l’objet. Généralement 1 de plus que ce que vous pouviez attendre, à cause de l’objet argument de référence temporaire.
getcheckinterval() / setcheckinterval(interval)
Positionne / Initialise les processus de l’interpréteur en basculant de l’un à l’autre à intervalle régulier (en nombre d’instructions en bytecode, par défaut : 10 jusque 2.2, 100 depuis 2.3).
settrace(func)
Initialise une fonction de suivi : appelée avant que chaque ligne de code ne se termine.
setprofile(func)
Initialise une fonction de pour de meilleures performances lors de la création du profil.
exc_info()
Infos sur l’exception qui est en cours de traitement ; ceci est une ligne (de tableau) (tuple) (exc_type, exc_value, exc_traceback). Attention : assigne la valeur du suivi retournée par traceback vers une variable locale dans une fonction traitant une exception qui provoquera une référence circulaire.
setdefaultencoding(encoding)
Modifie l’encodage par défaut Unicode – par défaut 7-bit ASCII.
getrecursionlimit()
Recherche la profondeur maximum de récursivité.
setrecursionlimit()
Initialise la profondeur maximum de récursivité (par défaut : 1000).
"synonyme" pour ces modules spécifiques aux systèmes d’exploitation (nt, mac, posix...) est propre à l’environnement courant. Ce module-ci utilise posix chaque fois que cela est possible.
(Voyez également l’utilitaire platform.py de M.A. Lemburg (maintenant inclus dans 2.3+)
Variable
Signification
name
Nom du module spécifique au système d’exploitation (e.g. "posix", "mac", "nt")
path
Module spécifique au système d’exploitation pour les
manipulations de chemin. Sous Unix, os.path.split() <=> posixpath.split().
curdir
Chaîne utilisée pour représenter le directory courant (eg '.')
pardir
Chaîne utilisée pour représenter le directory parent (eg '..').
sep
Chaîne utilisée pour séparer les directories ('/' ou '\'). Typiquement : Utilisez os.path.join() pour construire des chemins portables.
altsep
Autre séparateur si appliquable (None autrement).
pathsep
Caractère utilisé pour séparer chaque composant du chemin (comme dans $PATH), eg. ';' pour Windows.
linesep
Ligne de séparartion comme utilisé dans les fichiers textes, '\n' sous Unix, '\r\n' sous Dos/Win, '\r' sur Mac.
Fonction
Résultat
makedirs(path[, mode=0777])
Création récursive de direcories (crée les directories intermédiaires requis); os.error s’il échoue.
removedirs(path)
Suppression récursive de directories (supprime les directories intermédiares vides); échoue et génère os.error si les directories ne sont pas vides.
renames(old, new)
Remplacement récursif de noms de directories; génère os.error s’il échoue.
urandom(n)
Retourne une chaîne contenant n bytes (8 bits) d’une donnée pseudo-aléatoire.
Base de temps Unix TAI.
Une autre, plus rare, variante de représentation du nombre du temps Unix est l’encodage TAI. Parce que TAI n’a pas de secondes de compensation, chaque jour fait exactement 86 400 secondes de long, cet encodage est actuellement un calcul purement linéaire des secondes écoulées depuis le 1970-01-01T00:00:00 TAI. Ceci permet un calcul d’intervalles de temps plus aisés. Les valeurs de temps de ce système ne présente pas l’ambiguïté que possède le système strictement conforme au système POSIX ou le système pilotés par NTP (NTP : Temps du Serveur (informatique) pour Windows NT 2000 XP NOVELL UNIX.).
Dans ces systèmes, il est nécessaire de consulter la table des secondes de compensation (secondes ajoutées pour compenser le décalage dans la rotation de la terre) pour une conversion correcte entre le temps UTC et une représentation pseudo Unix du temps. Ceci ressemble à la manière dont les tables des fuseaux horaires qui doivent être consultées pour converti de et vers un temps civil. La table des secondes de compensation doit être tenue à jour (depuis la publication du bulletin des secondes de compensation) plus fréquemment que les tables des fuseaux horaires, parce que les secondes de compensation surviennent plus souvent que les variations de l’heure d’été/hiver (daylight saving time).
(Un système de temps Unix standard doit consulter une table de secomdes de compensation pour convert de et vers un temps TAI, mais ceci est requis plus rarement.)
Ce système basé sur le temps TAI, en dépit de sa ressemblance superficielle, n’est pas un système de temps Unix. Il encode des périodes avec des valeurs sensiblement différentes du système de temps Unix POSIX, et n’a pas de simple relation mathématique avec UTC qui est mandaté par POSIX
Posix time = Unix Time : est un système qui décrit des points du temps (date/heure) : c’est un nombre de secondes écoulées depuis minuit (temps universel coordonné – UTC) le 01 janvier 1970, sans tenir compte des secondes d’ajustement (ajoutées pour corriger les variations de rotation de la terre). Ce système est utilisé sur pratiquement tous les systèmes informatiques, même ceux différents d’Unix. Ce n’est ni une représentation linéaire du temps ni une représentation vraie du UTC (ainsi, il est fréquement confondu avec les deux) comme le temps qu’il représente est un temps universel coordonné (UTC), il n’y a pas moyen de représenter le temps UTC en secondes écoulées (e.g. 1998-12-31 23:59:60).
Le Epoch Unix est le temps 00:00:00 UTC du 01 janvier 1970.
Mais il y a un problème avec cette définition : c’est que UTC (temps universel coordonné) n’existe dans sa forme courante que depuis 1972. On utilise la norme de formatage des dates ISO 8601 dans laquelle l’Epoch Unix est 1970-01-01T00:00:00Z.
Le nombre du temps Unix au temps Epoch Unix est zéro, il s’incrémente exactement de 86 400 (sans unités : secondes, dixièmes de secondes … puisque, par définition, c’est un nombre flottant.) par jour écoulé depuis epoch.
Ainsi, 2004-09-16T00:00:00Z, représente 12 677 jours après epoch, est représenté par le nombre (flottant) du temps Unix 12 677 × 86 400 = 1 095 292 800.
Ce système peut également être étendu au temps précédant epoch, en utilisant des nombres négatifs; ainsi 1957-10-04T00:00:00Z, représente 4472 jours avant epoch (01/01/1970), est représenté par le nombre (flottant) du temps Unix -4472 × 86 400 = -386 380 800.
A l’intérieur de chaque jour, le nombre du temps Unix est calculé par le même procédé que ci-dessus, à minuit UTC (00:00:00Z), et s’incrémente de exactement un (1) à chaque seconde depuis minuit.
Ainsi, 2004-09-16T17:55:43.54Z, il s’est écoulé 64 543.54 secondes depuis minuit le 16/09/2004 dans notre exemple ci-dessus. Cette date/heure est représentée par le nombre (flottan) du temps Unix 1 095 292 800 (temps écoulé depuis 01/01/1970 jusqu’au 16/09/2004) + 64 543.54 (temps écoulé depuis minuit ce jour 16/09/2004)= 1 095 357 343.54.
Pour les dates précédant epoch (le 01/01/1970, minuit), le nombre (flottant) du temps Unix décroît, il devient négatif.
Ceci signifie donc que dans un jour UTC normal, d’une durée de 86 400 s, le nombre du temps Unix évolue de manière continue après minuit. Par exemple, à la fin de la journée utilisée dans l’exemple précédent, la progression de la représentation du temps Unix (UTC) ressemble à ceci :
Evolution du Temps Unix dans une journée normale UTC
TAI UTC Unix time
2004-09-17T00:00:30.75 2004-09-16T23:59:58.75 1 095 379 198.75 2004-09-17T00:00:31.00 2004-09-16T23:59:59.00 1 095 379 199.00 2004-09-17T00:00:31.25 2004-09-16T23:59:59.25 1 095 379 199.25 2004-09-17T00:00:31.50 2004-09-16T23:59:59.50 1 095 379 199.50 2004-09-17T00:00:31.75 2004-09-16T23:59:59.75 1 095 379 199.75 2004-09-17T00:00:32.00 2004-09-17T00:00:00.00 1 095 379 200.00 2004-09-17T00:00:32.25 2004-09-17T00:00:00.25 1 095 379 200.25 2004-09-17T00:00:32.50 2004-09-17T00:00:00.50 1 095 379 200.50 2004-09-17T00:00:32.75 2004-09-17T00:00:00.75 1 095 379 200.75 2004-09-17T00:00:33.00 2004-09-17T00:00:01.00 1 095 379 201.00 2004-09-17T00:00:33.25 2004-09-17T00:00:01.25 1 095 379 201.25
Ne pas importer ce module directement, importez le système d’exploitation à la place ! (voyez également le module : shutil pour la fonction de copie ou de suppression de fichier).
Variable
Signification
environ
Dictionnaire des variables environnementales, e.g. posix.environ['HOME'].
error
Exception générée suite à une erreur POSIX.
La valeur correspondante est un uplet (tuple) du numéro de code d’erreur errn et de la chaîne perror().
Fonction
Résultat
chdir(path)
Modifie le directory courant vers path.
chmod(path, mode)
Modifie le mode du chemin path en mode numérique.
close(fd)
Ferme le fichier descripteur fd ouvert avec posix.open.
_exit(n)
Sortie immédiate, sans nettoyage, sans SystemExit, etc... Doit être utilisé pour quitter un processus enfant (child process).
execv(p, args)
"Devient" l’exécutable p avec les arguments args.
getcwd()
Retourne une chaîne représentant le directory de travail courant.
getcwdu()
Retourne une chaîne Unicode représentant le directory de travail courant.
getpid()
Retourne l’identificateur du processus courant.
getsid()
Appelle le système d’appel getsid() [Unix].
fork()
Comme l’instruction C fork(). Retourne 0 à l’enfant, l’identificateur enfant (pid) au parent [N’est pas implémenté sous Windows].
kill(pid, signal)
Comme l’instruction C kill [N’est pas implémentée sous Windows].
listdir(path)
Liste les noms (de base) des entrées du chemin du directory, excluant '.' et '..'. Si le chemin est une chaîne Unicode, alors les chaînes seront retournées.
lseek(fd, pos, how)
Initialise la position courante dans le fichier fd à la position pos, exprimé en un déplacement (offset) relatif au début du fichier (how = 0), vers la position courante (how = 1), ou vers la fin du fichier (how = 2).
mkdir(path[, mode])
Crée le chemin d’un directory nommé avec le mode numérique mode (par défaut 0777).
open(file, flags, mode)
Comme l’instruction C open(). Retourne un descripteur de fichier. Utilsez plutôt une fonction objet de fichier au lieu de cette instruction de bas niveau.
pipe()
Crée un canal (pipe). Retourne la paire de descripteurs de fichier (r, w) [N’est pas implémenté sous Windows].
popen(command, mode='r', bufSize=0)
Ouvre un canal (pipe) vers/ou depuis command. Le résultat est un objet fichier d’où on lit/écrit, comme indiqué par mode qui devient 'r' ou 'w'. Utilisez-le pour trouver une commande de sortie (mode 'r' (read)), ou pour l’alimenter (mode 'w' (write)).
remove(path)
Voyez unlink.
rename(old,
new)
Renome/remplace le directory old par new. [Une erreur est placée si le nom visé existe déjà].
renames(old, new)
Directory récursif ou Fonction de renommage de fichier. Travaille comme rename(), sauf que le création de tout directory intermédiaire implique de réaliser correctement le nouveau nom de chemin en premier lieu. Après avoir renomméles correspondance avec les directories à l’extrème droite du chemin seront enlevés en utilisant removedirs().
rmdir(path)
Supprime l’adresse path du directory vide.
read(fd, n)
Lit n bytes depuis le descriteur de fichier fd et retourne une chaîne.
stat(path)
Retourne st_mode,
st_ino, st_dev, st_nlink, st_uid, st_gid, st_size,
st_atime, st_mtime, st_ctime.
[st_ino, st_uid, st_gid sont factices sous
Windows].
system(command)
Exécute la chaîne command dans un sous espace. Retourne le statut de sortie (exit status) du sous espace (habituellement, 0 signifie OK). Depuis 2.4 utilisez subprocess.call() à la place.
times()
Retourne le temps CPU accumulé en secondes (utilisateur (user), système (system), utilisateur des enfants (children's user), le système enfant (children's sys), s’écoulent en temps réel) [les 3 derniers ne sont pas implémentés sous Windows].
unlink(path)
Désuni ("supprime") le chemin du fichier (pas le
directory !). Comme : remove.
utime(path,
(aTime, mTime))
Positionne lea date/heure du dernier accès ou modification du fichier à la série de valeurs données aTime, mTime.
wait()
Attend la fin du processus enfants. Retourne une série de pid, exit_status [N’est pas implémenté sous Windows].
waitpid(pid, options)
Attend que le processus pid se termine. Retourne un uplet (tuple) de pid, exit_status [n’est pas implémenté sous Windows].
walk(top[,
topdown=True [, onerror=None]])
Génère une liste de noms de fichier dans une arborescence d’un directory, en parcourant l’arborescence de bas en haut. Pour chaque directory dans l’arborescence initiée depuis le directory top (en incluant top lui-même), il rend (yield) un série de 3 termes (dirpath, dirnames, filenames) – Pour plus d’infos, voyez here. Voyez également os.path.walk().
write(fd, str)
Ecrit la chaîne str dans le fichier fd. Retourne le nombre de bytes écrits.
N’importez pas ce module directement, importez le système d’exploitation (OS) à la place puis référez-vous à son mudule os.path. (e.g. os.path.exists(p))!
Fonction
Résultat
abspath(p)
Retourne l’adresse absolue du chemin p, en tenant compte du directory de travail courant.
commonprefix(list)
Retourne le plus long préfixe de chemin (en prenant caractère par caractère) c’est le préfixe de tous les chemins dans la liste list (ou '' si la liste list est vide).
dirname/basename(p)
Directory et partie de noms dans le chemin p. Voyez également split.
exists(p)
Retourne Vrai (True) si la chaîne p est un chemin existant (fichier ou directory). Voyez également lexists.
expanduser(p)
Retourne une chaîne qui est (une copie de) p avec l’expansion du « ~ » effectuée (cf. les noms trop longs sous DOS).
expandvars(p)
Retourne une chaîne qui est (une copie de) p avec les variables d’environnement déployées. [Windows : cas significatif è doit utiliser la notation Unix : $var, et non pas %var%].
getmtime(filepath)
Retourne la date/heure de la dernière modification du chemin filepath (nombre entier (integer) de seconde depuis epoch).
getatime(filepath)
Retourne la date/heure du dernier accès à filepath (Nombre entier (integer) de secondes depuis epoch).
getsize(filepath)
Retourne la taille en bytes de filepath. Génère os.error si le fichier est inexistant ou inaccessible.
isabs(p)
Retourne Vrai (True) si la chaîne p est un chemin absolu.
isdir(p)
Retourne Vrai (True) si la chaîne p est un directory.
islink(p)
Retourne Vrai (True) si la chaîne p est un lien symbolique.
ismount(p)
Retourne Vrai (True) si la chaîne p est un point de montage (mount point) [vrai (true) pour tous les directories sous Windows].
join(p[,q[,...]])
Joint, unit un ou plusieurs composants de chemin en un chemin utilisable par l’OS courant.
lexists(path)
Retourne Vrai (True) si le fichier spécifié dans le chemin path existe sinon, c’est un lien symbolique (différent de exists).
split(p)
Dédouble p dans (tête, pied) (head, tail) où tail est le dernier composant du nom de chemin et head est tout ce qui conduit à lui. <=> (dirname(p), basename(p)).
splitdrive(p)
Dédouble le chemin p dans une paire ('drive:', tail) [Windows].
splitext(p)
Dédouble le path p dans (root, ext) où le dernier composant de root ne contient pas de période et ext est vide ou commence avec une période.
walk(p, visit, arg)
Appelle la fonction visit avec les arguments (arg, dirname, names) pour chaque directory récursivement dans l’arbre racine à partir de p (en incluant p lui-même s’il est un directory). L’argument dirname spécifie le directory visité, l’argument names liste les fichiers dans le directory. La fonction visit peut modifier des noms pour influencer le positionnement des directories visités sous dirname, e.g. pour éviter certaines parties de l’arborescence. Voyez également os.walk() comme alternative.
Opérations de haut niveau sur fichiers. (copie, effacement).
Le module Shutil permet des opérations de haut niveau sur des fichiers et des collections de fichiers.
Fonction
Résultat
copy(src, dest)
Copie le contenue du fichier src vers le fichier dest,
en conservant les bits de permissions du fichier. Si dest est un
directory, un fichier avec le même nom de base que src est créé (ou
surchargé) dans le directory spécifié. src et dest sont des
noms de chemin donnés comme des chaînes de caractères.
copy2(src, dst)
Similaire à copy(), mais la dernière date/heure de la dernière modification est copiée telle qu’elle. C’est similaire à la commande Unix cp -p.
copytree(src, dest[, symlinks])
Copie récursivement l’arborescence entière d’un directory
dont la racine a été définie dans src vers dest (lequel ne doit
pas déjà exister). Si symlinks est Vrai (true), les liens symboliques
dans src sont conservés tels quels dans dest ; s’il est
manquant ou égale à Faux (false), le contenu des fichiers liés est copié dans dest.
Il est créé même s’il manque des directories parents. Les permissions et les
temps des directories sont copiée avec copystat(), les fichiers individuels
sont copiés en utilisant copy2().Si une exception survient, une erreur Error
est générée avec une liste de raisons.
Modifé dans la version 2.3 : Error est généré si une
quelconque exception survient, au lieu d’afficher un message.
Modifié dans la version 2.5 : Créer des directories
intermédiaires nécessite de créer dst, au lieu de générer une erreur.
Les permissions et les temps des directories sont copiés en utilisant copystat().
move(src, dest)
Déplace récursivement un fichier ou un directory vers une nouvelle localisation
rmtree(path[, ignore_errors[, onerror]])
Supprime une arborescence de directory complète, ignorant les erreurs si ignore_errors est Vrai (true) ; si cet argument est omis, il génère une exception ; ou en appelant onerror(func, path, sys.exc_info()) si il est supporté, avec les arguments de la fonction func (fonction par défaut), et le chemin path (fichier concerné). Cette fonction échoue lorsque le fichier est en lecture seule (Read Only).
copyfile(src, dst)
Copie le contenu du fichier nommé src vers le fichiers nommé dst. La localisation de destination doit être en lecture/écriture; autrement, une exception IOError sera générée. Si dst existe déjà, il sera remplacé. Des fichiers spéciaux comme un caractère ou des périphériques de blocs et des canaux ne peuvent pas être copiés avec cette fonction. src et dst sont des noms de chemin donnés sous forme de chaînes.
copyfileobj(fsrc, fdst[, length])
Compie le contenu de l’objet genre fichier fsrc vers l’objet genre fichier fdst. L’entier (integer) length, s’il est fourni, est la taille du tampon. En particulier, une valeur de longueur négative signifie que l’on copie les données sans boucler sur la source de données mal construite; par défaut, la donnée est lue mal construite pour éviter une consommation incontrôlée de la mémoire.
copymode(src, dst)
Copie les bits de permission depuis src vers dst. Les contenus du fichier, ses propriétés et son groupe ne sont pas affectés. src et dst sont des noms de chemin donnés sous la forme de chaînes de caractères.
copystat (src, dst)
Copie les bits de permission, la date/heure du dernier accès et la date/heure de la dernière modification depuis src vers dst. Les contenus des fichiers, ses propriétés, et le groupe ne sont pas affectés. src et dst sont les noms de chemins donnés sous la forme de chaîne de caractères.
exception Error
Cette exception collecte les exceptions qui sont générée lors du déroulement d’opérations sur de multiples fichiers. Pour copytree, l’argument exception est une liste de rangées de tableau de 3 cellules (srcname, dstname, exception).
(Voyez également le module mxDateTime si vous avez un besoin de gestion sophistiqué de la date et de l’heure).
L'utilisation de l'ancienne appellation standard temps moyen de Greenwich (GMT, de l'anglais Greenwich Mean Time) qui s'était imposée par la prépondérance de la marine britannique durant le XIXe siècle et fut plus tard rebaptisé temps universel (UT, de l'anglais Universal time) est désormais déconseillée parce que sa définition est ambiguë, au contraire d'UTC (Temps Universel Compensé) qui doit être préférée.
Variable
Signification
altzone
Décalage signé, en secondes, depuis le fuseau horaire local (DST (Daylight Saving Time)) : heure d’été/hiver), à l’ouest du méridien d’origine (méridien 0).
daylight
Différent de 0 (zéro) si un fuseau horaire DST (heure été/hiver) a été spécifié.
timezone
Le décalage du fuseau horaire local (non-DST), en secondes à l’ouest du UTC (Universal Time Coordinated : Temps coordonné universel).
tzname
Un tableau (nom du fuseau horaire local non-DST, nom du fuseau horaire local DST).
Fonction
Résultat
clock()
Sous Unix : temps (date/heure) du processeur courant en nombre flottant exprimé en secondes.
Sous Windows: (Wall time, aussi appelé real-world time ou encore wall-clock time, fait référence au temps écoulé depuis un évènement) Temps écoulé, en secondes depuis le premier appel à cette fonction, en nombre flottant (précision < 1µs).
time()
Retourne un nombre flottant représentant le temps UTC écoulé, exprimé en secondes, depuis Epoch. (Voir Unix time, ou POSIX time).
gmtime([secs]), localtime([secs])
Retourne un uplet (tableau invariable – tuple) de 9 cellules représentant le temps. Le temps courant est présenté si secs n’est pas fourni.
Depuis 2.2, retourne un objet struct_time (toujours accessible comme un tableau) avec les attributs suivants :
Index Attribute Values
0 tm_year Année (e.g. 1993)
1 tm_mon Mois [1,12]
2 tm_mday Jour [1,31]
3 tm_hour Heure [0,23]
4 tm_min Minute [0,59]
5 tm_sec Seconde [0,61]; Le nombre 61
comptabilise la seconde de
compensation et (très rarement) la
double seconde de compensation.
6 tm_wday Jour de la semaine [0,6], Lundi est 0.
7 tm_yday Jour Julien [1,366]
8 tm_isdst Le drapeau de Heure été/hiver :
0, 1 ou -1; -1
passé à mktime() devrait normalement fonctionner.
asctime([timeTuple]),
Une chaîne de 24 caractères (tableau invariable – Tuple) de la forme suivante : 'Mon Apr 03 08:31:14 2006'. Le temps courant est utilisé si les secondes ne sont pas disponibles.
ctime([secs])
Equivalent à asctime(localtime(secs)).
mktime(timeTuple)
L’inverse de localtime(). Il retourne un nombre flottant (float) représentant un nombre de secondes.
strftime(format[, timeTuple])
Formate un uplet (tableau invariable – Tuple) de temps comme une chaîne, en accord avec le format (voyez la table suivante). Le temps courant si les secondes ne sont pas disponibles.
strptime(string[, format])
Analyse une chaîne représentant un temps en accord avec la table des formats ci-dessous (même format que pour strftime(), voyez ci-dessous), par défaut, le format utilisé est "%a %b %d %H:%M:%S %Y" = format asctime.
Il retourne un temps (date/heures sous la forme d’un tableau invariable/ struct_time.
sleep(secs)
Suspend l’exécution pour secs secondes. secs peut être un nombre flottant (float).
Directive Signification
%a Abréviation locale du nom du jour de la semaine. (Lu, Ma …)
%A Nom local complet du jour de la semaine.
%b Abréviation locale du nom du mois.
%B Nom local complet du mois.
%c Accorde la représentation locale de la date et heure.
%d Jour du mois en nombre décimal [01,31].
%H Heure (Horloge 24 Hrs.) en nombre décimal [00,23].
%I Heure (Horloge 12 Hrs.) en nombre décimal [01,12].
%j Jour de l’année en nombre décimal [001,366].
%m Mois en nombre décimal [01,12].
%M Minute en nombre décimal [00,59].
%p Equivalent local de AM ou PM.
%S Secondes en nombre décimal [00,61]. Oui, 61 ! Voyez OSIX.
%U Numéro d’ordre de la semaine dans l’année (Dimanche est
le premier jour de la semaine) en nombre décimal
[00,53]. Tous les jours d’une nouvelle année précédant
le premier Dimanche sont considérés comme faisant partie
de la 1° semaine, la semaine 0.
%w Jour de la semaine en nombre décimal [0(Dimanche),6].
%W Numéro d’ordre de la semaine dans l’année (Lundi est le
premier jour de la semaine) en nombre décimal [00,53].
Tous les jours d’une nouvelle année précédant le premier
Dimanche sont considérés comme faisant partie de la
première semaine (semaine 0).
%x Accorde l’affichage selon la représentation locale de la
date.
%X Accorde l’affichage selon la représentation locale du
temps.
%y Année sans le siècle en nombre décimal [00,99].
%Y Année avec le siècle en nombre décimal.
%Z Nom du fuseau horaire (ou par aucun caractère si le
fuseau horaire n’existe pas).
%% Un caractère littéral "%".
Opérations communes sur des chaînes de caractères.
Comme pour Python 2.0, plus (mais pas toutes) les fonctionnalités disponibles dans ce module string ont été remplacées par des méthodes prédéfinies – Voyez les détails des opérations sur les chaînes.
Variable.
Signification.
Digits
La chaîne '0123456789'.
hexdigits, octdigits
Chiffres hexadécimaux et octaux légaux.
Letters, uppercase, lowercase, whitespace
Chaîne (lettre, majuscule, minuscule, espace blanc) contenant les caractères appropriés.
ascii_letters,
ascii_lowercase, ascii_uppercase
La même chose mais en prenant en compte les réglages courants.
index_error
Exception générée par index() si aucune sous chaîne n’est trouvée.
Fonction.
Résultat.
expandtabs(s, tabSize)
Retourne une copie de la chaîne s avec les tabulations développées.
find/rfind(s,
sub[, start=0[, end=0])
Retourne l’index le plus petit/grand dans s où la sous chaîne sub a été trouvée de manière à ce que sub soit contenu entièrement dans s[start:end].
Il retourne -1 si sub n’est pas trouvé.
ljust/rjust/center(s,
width[, fillChar=' '])
Retourne une copie de la chaîne s; alignement gauche/droite, justifié/centré dans un champ de largeur donnée width. Si la sous chaîne est plus petite que le largeur width, elle sera complété par des espaces ou un caractère donné fillChar=. La chaîne s n’est jamais tronquée.
lower/upper(s)
Retourne une chaîne qui est une copie de s en minuscule/majuscule (lowercase/uppercase).
split(s[,
sep=whitespace[, maxsplit=0]])
Retourne une liste contenant les mots de la chaîne s, Retourne une liste contenant les mots de la chaîne s, en utilisant la chaîne sep comme séparateur des mots.
rsplit(s[,
sep=whitespace[, maxsplit=0]])
La même chose que split plus haut, mais démarre l’inventaire des mots depuis la fin de la chaîne jusqu’à son début ; e.g. 'A,B,C'.split(',', 1) == ['A', 'B, C'] mais 'A,B,C'.rsplit(',', 1) == ['A,B', 'C'].
join(words[,
sep=' '])
Concatène une liste ou un tableau de mots en faisant intervenir des séparateurs; c’est l’inverse de split.
replace(s,
old, new[, maxsplit=0]
Retourne une copie de la chaîne s avec toutes les occurrences de la sous-chaîne old remplacées par new. Limite aux premières substitutions précisées dans maxsplit s’il est spécifié.
strip(s[, chars=None])
Retourne une chaîne qui est (une copie de) s sans les caractères de remplissage ou de liaison (par défaut : espace blanc), s’il y en a.
Egalement :
lstrip, rstrip.
Prend en main les chaînes Unicode. Implémenté dans le nouveau module sre, re n’a qu’une seule entrée pour plus de compatibilité.
Les mises en forme sont spécifiées sous la forme de chaînes.
Tip: Utilisez les chaînes raw (e.g. r'\w*') pour littéraliser l’antislash barre oblique inverse) (backslash).
Forme
Description
.
Apparie tout caractère (en incluant la nouvelle ligne si le drapeau DOTALL est spécifié).
^
Apparie le début de la chaîne (de chaque chaîne en mode MULTILINE).
$
Apparie la fin de chaîne (de chaque chaîne si en mode MULTILINE).
*
0 (zéro) ou plus de la précédente expression régulière (autant de fois que possible).
+
1 ou plus de la précédente s expression régulière (autant de fois que possible).
?
0 (zéro) ou 1 occurrence de la précédente expression régulière.
*?, +?, ??
Comme *, + et ? mais apparie aussi peu de caractères que possible.
{m,n}
Apparie depuis m jusqu’à n répétitions du précédent RE.
{m,n}?
Idem, essaye d’apparier aussi peu de caractères que possible.
[ ]
Définit un groupe, un jeu de caractères : e.g. '[a-zA-Z]' pour apparier toutes les lettres (voyez également \w \S).
[^ ]
Définit un groupe, un jeu de caractères complété : apparie si char n’est pas dans le groupe/jeu.
\
Empêche l’interprétation des caractères spéciaux '*?+&$|()' et introduit des séquences spéciales (voyez plus bas).
Du fait des règles Python applicables aux chaînes, écrire sous la forme '\\' ou r'\' dans la chaîne de formatage.
\\
Apparie un littéral '\'; Du fait des règles Python applicables aux chaînes, écrire sous la forme '\\\\' dans la chaîne de formatage, ou mieux en utilisant la chaîne raw : r'\\'.
|
Spécifie une alternative : 'foo|bar' apparie 'foo' ou 'bar'.
(...)
Apparie tout RE à l’intérieur de (), et délimite un groupe.
(?:...)
Idem mais ne délimite pas de groupe (ne capture pas les parenthèses).
(?P<name>...)
Apparie tout RE à l’intérieur de (), et délimite un groupe nommé name, (e.g. r'(?P<id>[a-zA-Z_]\w*)' définit un groupe nommé id).
(?P=name)
Apparie ce qui a été trouvé par un groupe nommé précédent name.
(?=...)
Apparie si ... apparie ensuite, mais ne consomme rien de la chaîne : e.g. 'Isaac (?=Asimov)' apparie 'Isaac' seulement s’il est suivi de 'Asimov'.
(?!...)
Apparie ... s’il n’est pas apparié ensuite. La version négative de (?=...).
(?<=...)
Apparie si la position courante dans la chaîne est précédé par un appariement pour ... qui se termine à la position courante. Ceci est appelé une affirmation positive de regard arrière (positive lookbehind assertion).
(?<!...)
Apparie si la position courante dans la chaîne n’est pas précédé par un appariement pour ... . Ceci est appelé une affirmation négative de regard arrière (negative lookbehind assertion).
(?(group)A|B)
[2.4+] group est soit un identifiant d’une groupe numérique soit un nom de groupe défini précédemment avec (?Pgroup...) dans une expression.
Si le groupe spécifié s’apparie, le format de l’expression régulière A sera testé avec la chaîne; si le groupe ne s’apparie pas, le format B sera utilisé à la place.
(?#...)
Un commentaire; ignoré.
(?letters)
letters est un ou plusieurs de 'i','L', 'm', 's', 'u', 'x'. Positionne les drapeaux correspondants (re.I, re.L, re.M, re.S, re.U, re.X) pour l’entièreté de RE. Voyez la fonction compile() pour l’équivalence des drapeaux.
Séquence
Description
\number
Apparie le contenu du groupe du même number; les groupes sont numérotés à partir de 1.
\A
Apparie seulement au début de la chaîne.
\b
Une chaîne vide au début et à la fin du mot word : '\bis\b' apparie 'is', mais pas 'his'.
\B
Chaîne vide NON au début ou à la fin du mot.
\d
Tout chiffre décimal (<=> [0-9]).
\D
Tout caractère non décimal (<=> [^0-9]).
\s
Tout caractère d’espace blanc (<=> [ \t\n\r\f\v]).
\S
Tout caractère qui n’est pas un espace blanc (<=> [^ \t\n\r\f\v]).
\w
Tout caractère alphanumérique (dépendant du drapeau local LOCALE).
\W
Tout caractère non alphanumérique (dépendant du drapeau LOCALE).
\Z
Apparie seulement à la fin de la chaîne.
Variable
Signification
error
Exception si la chaîne de format n’est pas un regexp valide.
Fonction
Résultat
compile(pattern[,flags=0])
Compile une chaîne de formatage RE en un objet d’expression régulière.
Drapeaux (combinable avec |):
I ou IGNORECASE <=> (?i)
Appariement sensible à la casse.
L ou LOCALE <=> (?L)
Rend \w, \W, \b, \B dépendant dans le LOCALE courant.
M ou MULTILINE <=> (?m)
Apparie chaque nouvelle ligne et non seulement le début/fin de
chaque chaîne entière.
S ou DOTALL <=> (?s)
'.' apparie ALL caractères, en incluant une nouvelle ligne.
U ou UNICODE <=> (?u)
Rend \w, \W, \b, and \B dépendant de la base de donnée des
propriétés des caractères Unicodes.
X or VERBOSE <=> (?x)
Ignore les espaces blancs à l’extérieur des jeux de caractères.
escape(string)
Retourne (une copie de) la chaîne string avec tous les caractères non alphanumériques précédés du signe antislash (barre oblique inverse).
match(pattern, string[, flags])
Si aucun ou plusieurs caractères au début de string apparient la chaîne de formatage RE, il retourne une instance de l’objet correspondant MatchObject ou None s’il ne trouve pas.
search(pattern, string[, flags])
Scanne à travers la chaîne string pour localiser le format d’appariement, retourne une instance de l’objet MatchObject correspondant, ou None s’il ne trouve pas.
split(pattern, string[, maxsplit=0])
Scinde string en chacune des occurrences de pattern. Si les parenthèses de capture sont utilisées dans le format, les occurrences des formats et sous formats sont également retournées.
findall(pattern, string)
Retourne une liste des correspondances qui ne se recouvrent pas dans le format pattern, soit une liste de groupes, soit une liste de tableaux si le format a plus d’un groupe.
sub(pattern,
repl, string[, count=0])
Retourne la chaîne string obtenue par le remplacement de (premier count) le plus à gauche des occurrences non recouvertes du format pattern (une chaîne ou un objet de RE) dans string par repl; repl peut être une chaîne ou une fonction appelée avec un simple argument MatchObj, lequel doit retourner la chaîne de remplacement.
subn(pattern,
repl, string[, count=0])
Le même que sub(), mais retourne un tableau (newString, numberOfSubsMade).
Les objets RE sont retournés par la fonction de compilation compile.
Attribut
Description
flags
Arguments drapeaux utilisés lorsque l’objet RE est compilé, ou 0 si none est fourni.
groupindex
Dictionnaire de {group name : group number} dans le format.
pattern
Chaîne de format à partir de laquelle l’objet RE est compilé.
Méthode
Résultat
match(string[, pos][, endpos])
Si aucun ou plusieurs caractères au début de la chaîne correspondent à cette expression régulière, il retourne l’instance « MatchObject » correspondante. Il retourne None si la chaîne ne correspond pas à la forme; notez que ceci est différent d’une recherche de correspondance d’une chaîne de longueur égale à zéro (zero-length).
Le second paramètre optionnel pos fournit un index dans la chaîne où la recherche doit débuter; par défaut il est à 0 (zéro). Ceci n’est pas complètement équivalent au découpage de la chaîne; le caractère de format '' correspond au début réel de la chaîne et à la position juste après le caractère de nouvelle ligne (newline), mais n’est pas nécessairement à l’index où la recherche a commencé.
Le paramètre optionnel endpos limite la distance sur laquelle la chaîne sera recherchée; ce sera si la chaîne fait endpos caractères de long, ainsi seuls les caractères depuis pos jusqu’à endpos seront recherchés pour une correspondance.
search(string[, pos][, endpos])
Scanne à travers la chaîne à la recherche d’une correspondance de la chaîne régulière, et retourne une instance MatchObject de la correspondance trouvée. Il retourne None s’il n’y a aucune position de correspondance dans la chaîne; notez que ceci est différent d’une recherche d’une correspondance à une chaîne de 0 caractère à certains endroits de la chaîne.
Les paramètres otionnels pos et endpos ont la même signification que dans la méthode match().
split(string[, maxsplit=0])
Identique à la fonction split(), utilisant une forme compilée.
findall(string)
Identique à la fonction findall(), utilisant la forme compilée.
sub(repl, string[, count=0])
Identique à la fonction sub(), utilisant la forme compilée.
subn(repl, string[, count=0])
Identique à la fonction subn(), utilisant la forme compilée.
Les objets trouvés (Match objects) sont retournés par les fonctions de correspondance (match) & de recherche (search).
Attribut
Description
Pos
Valeur de la position pos passée aux fonctions de correspondance et de recherche; l’index dans la chaîne est celui à partir duquel le moteur RE entame sa recherche.
endpos
Valeur de la position finale endpos passée aux fonctions de correspondance et de recherche; l’index dans la chaîne est celui que l’engin RE ne dépassera pas.
re
Objet RE dont le résultat des fonctions de correspondance et de recherche a été produit dans cette instance MatchObj.
string
La chaîne passée à match() ou search().
Fonction
Résultat
group([g1, g2, ...])
Retourne un ou plusieurs groupes de correspondance. Si un argument, le résultat est une chaîne; si des arguments multiples, le résultat est un tableau avec un item par argument. Si g1 est 0, la valeur qu’il retourne est est une chaîne entière de la correspondance trouvée; si 1 <= gi <= 99, il retourne le groupe de chaînes correspondantes #gi (ou None si aucun groupe semblable); gi peut également être un nom de groupe.
groups()
Retourne un tableau de tous les groupes correspondants; des groupes ne participant pas à la correspondance ont une valeur égale à None. Il retourne une chaîne à la place d’un tableau si len(tuple)== 1.
start(group), end(group)
Retourne les indices de début et de fin de la sous chaîne retrouvée par group (ou None si group existe mais ne contribue pas au résultat.
span(group)
Retourne le tableau à deux entrées (start(group), end(group)); peut être (None, None) si group ne contribue pas au résultat.
Pour les fonctions sur les nombres complexes, reportez-vous au module cmath. Pour des calculs intensifs, voyez les pages traitant du Python numérique (Numerical Python) et du Python et les calculs scientifiques (Scientific computing).
Nom Valeur
pi 3.1415926535897931
e 2.7182818284590451
Nom
Résultat
acos(x)
Retourne l’arc cosinus (mesuré en radians) de x.
asin(x)
Retourne l’arc sinus (mesuré en radians) de x.
atan(x)
Retourne l’arc tangente (mesuré en radians) de x.
atan2(y, x)
Retourne l’arc tangente (mesuré en radians) de y/x. Le résultat se situe entre -pi et pi. A la différence de atan(y/x), les signe des deux x et y sont pris en compte.
ceil(x)
Retourne la valeur plafond de x sous la forme d’un nombre flottant (float). C’est la plus petit valeur intégrale >= x.
cos(x)
Retourne le cosinus de x (mesuré en radians).
cosh(x)
Retourne le cosinus hyperbolique de x.
degrees(x)
Convertit l’angle x de radians en degrés.
exp(x)
Retourne e élevé à la puissance x.
fabs(x)
Retourne la valeur absolue du nombre flottant x.
floor(x)
Retourne le nombre plancher de x sous la forme d’un nombre flottant. C’est la plus grande valeur intégrale <= x.
fmod(x, y)
Retourne fmod(x, y), en accord avec la plateforme C. x % y est différent.
frexp(x)
Retourne la mantisse du nombre exponentiel x, comme
la paire (m, e). m est un nombre flottant et e est un
entier (integer), comme x = m * 2.**e. Si x est
hypot(x, y)
Retourne la distance euclidienne sqrt(x*x + y*y).
ldexp(x,
i)
x * (2**i)
log(x[,
base])
Retourne le logarithme de x dans la base base donnée. Si base n’est pas spécifiée, il retourne le logarithme naturel (base e) de x.
log10(x)
Retourne le logarithme en base 10 de x.
modf(x)
Retourne la partie fractionnelle et la partie entière de x. Les eux résultats reçoivent le signe de x. La partie entière est retournée sous la forme d’un nombre flottant (float).
pow(x, y)
Retourne x**y (x à la puissance y). Notez que si y=2, il est plus efficace d’utilise x*x.
radians(x)
Convertit l’angle x de degrés en radians.
sin(x)
Retourne le sinus de x (calculé en radians).
sinh(x)
Retourne le sinus hyperbolique de x.
sqrt(x)
Retourne la racine carrée de x.
tan(x)
Retourne la tangente de x (mesurée en radians).
tanh(x)
Retourne la tangente hyperbolique de x
Analyseur pour les options en ligne de commande.
Ceci était l’analyseur standard jusqu’à Python 2.3, il est maintenant remplacé par optparse. [Voyez également : Richard Gruet's simple parser getargs.py (le simple analyseur getargs.py de Richard Gruet) (petite promotion personnelle)]
getopt(list, optstr) – Similaire au C. <optstr> sont des lettres optionnel
de mise en forme. Placez ':' après la lettre si
l’option contient des arguments. E.g.
# L’invocation était "python test.py -c hi -a arg1 arg2"
opts, args =
getopt.getopt(sys.argv[1:], 'ab:c:')
# opts seront
[('-c', 'hi'), ('-a', '')]
# args seront
['arg1', 'arg2']
Prédéfinis et contenu dans le directory Python Lib. Le sous-directory Lib/site-packages contient des paquets et des modules spécifiques aux plateformes.
[Distributions principales (Windows, Unix), quelques modules spécifiques au système d’exploitation peuvent être manquants].
Opération
Résultat
__builtin__
Permet un accès direct à tous les identifiants “prédéfinis” (built-in) de Python, e.g. __builtin__.open est le nom complet de la fonction prédéfinie open().
__future__
Futures définitions d’instructions. Utilisé pour l(introduction progressive de nouvelles entités dans le langage.
__main__
Représente la vision (autrement anonymous) dans la quelle le programme principal de l’interpréteur travaille – les commandes sont lue comme des entrées standards, depuis un fichier de script, ou d’un prompt interactif.
Le terme typique pour chercher si un code est exécuté comme un script (en opposition à être importé):
if
__name__ == '__main__':
main() # (ce code est exécuté comme un script).
aifc
Remplit les fichiers AIFF-C et AIFF pour analyse. (AIFF
est un format de fichier audionumérique développé par Apple pour stocker les
sons sur les ordinateurs de la marque)
anydbm
Interface générique vers tous les clones dbm. (dbhash,
gdbm, dbm,
dumbdbm).
asynchat
Une classe supportant les protocoles des styles « discussion » (chat-style) (commande/réponse).
asyncore
Infrastructure de base pour des supports clients et serveurs asynchrones.
atexit
Enregistrer les fonctions qui ont été appelées à la sortie de l’interpréteur Python.
audiodev
Classes pour la manipulation d’éléments audio (actuellement seulement pour Sun et SGI).
audioop
Manipule des données raw audio. Python 2.5 : Supporte l’encodage a-LAW.
base64
Conversions de/vers l’encodage des transports en base64 comme au moyen de RFC-1521.
BaseHTTPServer
Classe de base de serveur http.
Bastion
Utilitaire de "Bastionification" (contrôle
l’accès aux variables d’instances).
bdb
Une classe de base de débogage générique de Python.
binascii
Convertit de binaire vers ASCII.
binhex
Pour Macintosh compression/décompression binaire/hexadécimal.
bisect
Algorithme de bissection.
(Procédure permettant d'étudier la fidélité d'un instrument composé d' items qui, tous, prévoient les mêmes modalités de cotation (par exemple, attribution d'un score compris entre 1 à 4 selon le niveau de réussite ou le type d'opinion exprimé). Elle consiste à répartir aléatoirement les items en deux sous-ensembles, à calculer pour chaque individu le score sur chacun des deux sous-ensembles (somme des scores relatifs aux différents items) et à étudier la corrélation qui existe entre les deux séries de résultats : calcul du coefficient r de Bravais- Pearson par exemple.
Cette démarche est parfois considérée comme une solution intermédiaire entre l'approche qui consiste à évaluer l' équivalence de deux formes parallèles et celle qui a pour but de vérifier l' homogénéité (ou consistance interne ) d'un instrument. Lorsque la position des items au sein de l'instrument a été déterminée au hasard, on établit souvent les sous-ensembles formés par les items impairs d'une part (le 1er, le 3e, le 5e, etc.) et les items pairs d'autre part.
On considère en général que la fidélité du dispositif est satisfaisante si la valeur du coefficient de corrélation atteint ou dépasse 0.80. )
bsddb
(Optionnel) interface améliorée de la base de données BSD [paquet].
bz2
Compression BZ2.
calendar
Fonctions d’affichage de calendrier.
cgi
Englobe
les WWW Forms Common Gateway Interface (CGI).
CGIHTTPServer
Serveur HTTP CGI-savvy.
cgitb
Outil de suivi pour des scripts pour CGI.
chunk
Lit les blocs de données IFF.
cmath
Fonctions mathématiques pour les nombres complexes. Voyez également math.
cmd
Une classe générique pour des interpréteurs de commande orientés ligne.
cmp
Comparaison efficace de fichiers, sortie booléenne
seulement.
cmpcache
La même chose mais cherche le résultat 'stat'
pour gagner en vitesse.
code
Utilitaires nécessaires pour émuler un interpréteur interactif Python.
codecs
Recherche les encodages Unicode existants et enregistre les derniers nouveaux. Python 2.5 : support pour codecs incrémentaux.
codeop
Utilitaires pour compile, peut-être de manière incomplète, du code source Python.
collections
Conteneur de types de données de hautes performances. Actuellement, le seul type de données est une file d’attente double. Python 2.5 : le type deque a maintenant une méthode remove. Nouveau type defaultdict.
colorsys
Fonctions de conversions entre RGB et d’autres systèmes de gestion des couleurs.
commands
Exécute des commandes du shell via os.popen [Unix].
compileall
Force "compilation" de tous les fichiers .py dans un directory.
ConfigParser
Configure l’analyser de fichier (tout comme les fichiers .ini de Windows).
Cookie
Gestion
d’état HTTP (cookies).
copy
Opérations génériques de copies superficielles ou complètes.
copy_reg
Aide pour fournir l’extensibilité pour les modules pickle/cPickle.
cPickle
Rapide, implémentation C de pickle.
cProfile
Rapide, implémentation C de profile.
crypt
Fonction de test de mots de passe [Unix].
cStringIO
Rapide, implémentation C de StringIO.
csv
Outils pour lire les fichiers avec la virgule comme séparateurs (avec variantes). Python 2.5 : Plusieurs perfectionnements.
ctypes
Librairie de “Fonctions étrangères” ("Foreign function") pour Python. Fournit des types de données compatibles C, et permet d’appeler des fonctions dans des librairies dll/partagées (dlls/shared). Peut être utilisé pour habiller ces librairies en Python pur.
curses
Manipulation terminale pour l’affichage de position de caractère [Unix/OS2/DOS seulement].
datetime
Types Date/Heure amélioré (date, time (heure), datetime (date + heure), timedelta (diffréence de temps)). Python 2.5 : Nouvelle méthode strptime(string, format) pour la classe datetime.
dbhash
Interface
compatible (g)dbm vers bsdhash.hashopen.
decimal
Arithmétique en décimal à virgule flottante.
difflib
Outil pour comparer des séquences et calculer les modifications requises pour convertir l’une vers l’autre. Python 2.5 : Améliore la méthode SequenceMatcher.get_matching_blocks().
dircache
Liste triée des fichiers dans un directory, en utilisant un cache.
dircmp
Définit une classe pour y construire un directory
différent.
dis
Désassembleur Bytecode.
distutils
Système d’installation de paquets. Python 2.5 : Fonction setup augmentée de nouveau paramètre mots-clés requires, provides, obsoletes, et download_url [PEP314].
distutils.command.register
Enregistre un module dans l’index de paquets Python (PyPI). Cette commande supplémentaire ajoute la commande d’enregistrement aux scripts distutil.
distutils.debug
distutils.emxccompiler
distutils.log
dl
Appelle des fonctions C dans des objets partagés [Unix].
doctest
Cadre d’essais d’unité basés sur des exemples fonctionnels embarqués dans docstrings. Python 2.5 : Nouvelle option SKIP. Nouvel argument d’encodage pour la fonction testfile().
DocXMLRPCServer
Création de serveurs XML-RPC d’auto documentation, utilisant pydoc pour créer un document HTML API à la volée. Python 2.5 : Nouvel attribut rpc_paths.
dospath
Opérations communes sur les noms de path DOS.
dumbdbm
Un clone allégé et lent mais simple de dbm clone.
dump
Affiche le code Python qui reconstruit une variable.
dummy_thread
dummy_threading
Assistant pour rendre l’écriture plus aisée de code où les tâches (processus) (threads) sont supportées, mais qui tournent sur des versions Python sans support de tâche. Les modules factices font tourner les tâches séquentiellement.
email
Un paquet pour l’analyse, la prise en main et la génération de messages email. La nouvelle version 3.0 lançait diverses APIs dépréciées et supprime le support pour les versions Pyton antérieure à la 2.3. Python 2.5 : Mise à jour vers la version 4.0.
encodings
Nouveaux codecs : idna (chaînes IDNA), koi8_u (Ukrénien), palmos (PalmOS 3.5), punycode (Codec Punycode IDNA), string_escape (Codec Python string_escape : remplace les caractères non imprimables w/ en chaîne modifiée style Python). Nouveaux codecs dans 2.4 : HP Roman8, ISO_8859-11, ISO_8859-16, PCTP-154, TIS-620; codecs Chinois, Japonais et Coréen.
errno
Symboles du système errno standard. La valeur de chaque symbole est la valeur entière (integer) correspondante.
exceptions
Classe basée sur la hiérarchie des exceptions prédéfinies.
fcntl
Le système d’appels fcntl() et ioctl() [Unix].
filecmp
Comparaison de fichiers et directory.
fileinput
Classe d’aide pour écrire rapidement un parcours de tous les fichiers d’entrées standards. Python 2.5 : Rendu plus flexible (Noms de fichiers Unicode, paramètres de mode mode, etc...).
find
Trouve des fichiers en correspondance avec le modèle de
hiérarchie de directory.
fnmatch
Nom de fichier en correspondance avec les modèles de shell.
formatter
Sortie formatante générique.
fpectl
Commande d’exception en virgule flottante [Unix].
fpformat
Fonctions de formatage général en virgule flottante.
ftplib
Une classe client FTP. Basée sur RFC 959.
functools
Des outils pour la programmation style fonctionnel. Voyez dans la fonction particulière partial() [PEP309].
gc
Exécute une collection de défauts, obtient les statuts de débogage GC, et et accorde les paramètres GC. Python 2.5 : Nouvelle fonction get_count(). gc.collect() Prend un nouvel argument generation.
gdbm
Réinterprétation GNU de dbm [Unix].
getopt
Exécution standard en ligne de commande. Voir également optparse.
getpass
Utilitaire pour aller chercher le mot de passe et/ou le nom d’utilisateur courant.
gettext
Support d’internationalisation et de localisation.
glob
Utilitaire de "globbing" de nom de fichier. (Globbing est le processus d’expansion d’un nom de fichier non spécifique contenant des caractères jocker , de remplacement à l’intérieur d’un ensemble de noms de fichiers spécifiques qui existent dans la dépôt dans un ordinateur, serveur ou réseau. Un caractère « wildcard » (de remplacement) est un symbole qui prend la place de un ou plusieurs caractères. Les caractères de remplacement les plus communs sont le point d’inrerrogation (?) pour un caractère unique et l’astérisque (*) pour une chaîne continue de caractères.)
gopherlib
Interface protocole client Gopher. (Gopher : un système
qui pré-date le WEB pour organiser et afficher des fichiers sur des serveurs
Internet. Un serveur Gopher présente son contenu comme une liste de fichiers
structurée hiérarchiquement. Avec l’ascendance du WEB, plusieurs bases de
données Gopher furent converties en sites Web qui peuvent être plus aisément
accessibles via les moteurs de recherche Web.)
grp
Le groupe database [Unix].
grep
Utilitaires 'grep'.
gzip
Lit/écrit des fichiers gzippés.
hashlib
Messages bloqués et empreintes numérique.
heapq
Assistant queue de tri (queue de priorité). Python 2.5 : nsmallest() et
nlargest() prennent un paramètre mot-clé key.
hmac
HMAC
(Keyed-Hashing for Message Authentication).
hotshot.stones
Assistant pour exécuter le test de performances pystone sous le profiler Hotshot.
htmlentitydefs
Références de l’entité des caractères HTML.
htmllib
Utilitaires d’analyse HTML2.
HTMLParser
Simple analyser HTML et XHTML.
httplib
Classe client HTTP1.
idlelib
(Paquet) Librairie de support pour l’environnement de développement IDLE.
ihooks
S’accroche dans les mécanismes d’importation.
imageop
Manipule des données images raw.
imaplib
Client IMAP4. Basé sur RFC 2060.
imghdr
Reconnaissance de fichiers images basée sur leurs quelques premiers bytes.
imp
Accès aux importations internes.
imputil
Propose un moyen d’écrire des liens d’importation personnalisés.
inspect
Va chercher les informations au sujet d’objets Python vivants.
itertools
Outils pour travailler avec des itérateurs et des séquences en phases d’inactivité. Python 2.5 : islice() accepte None pour les arguments start & step.
keyword
Liste des mots-clés de Python.
knee
Une ré implémentation du module d’importation
hiérarchique.
linecache
Cache ligne depuis des fichiers.
linuxaudiodev
Support /dev/audio Linux. Remplacé par ossaudiodev(Linux).
locale
Support pour le formatage de nombres utilisant les
initialisations courantes. Python 2.5 : format() modifié; Nouvelles
fonctions format_string() et currency().
logging
(paquet) Outils pour la notation structurés dans le style log4j.
macpath
Opérations sur les noms de chemin (ou relatifs) pour le Macintosh [Mac].
macurl2path
Module spécifique pour le Mac pour la conversion entre les noms de chemin et les URLs [Mac].
mailbox
Classes pour prise en main des boites courriel style Unix, MMDF, et MH. Python 2.5 : ajouté la possibilité de modifier des boites courriel en plus de les lire.
mailcap
Prise en main de fichiers Mailcap (RFC 1524).
marshal
Sérialisation interne d’objets Python.
markupbase
Support partagé pour le scannage de déclaration de type de documents en HTML et XHTML.
math
Fonctions mathématiques. Voyez également cmath.
md5
Algorithme de sommaire de message MD5. Python 2.5 : Maintenant un seul ensemble autour de la nouvelle librairie hashlib.
mhlib
Interface (courriel) MH.
mimetools
Divers outils utilisés par des programmes d’écriture/lecture MIME.
mimetypes
Devine le type MIME d’un fichier.
MimeWriter
Editeur générique MIME. Déconseillé depuis la version 2.3. Utilisez le paquet email à la place.
mimify
“Mimification” et “démimification” de messages courriels.
mmap
Interface vers les fichiers en mémoire – ils se comportent comme des chaînes modifiables.
modulefinder
Outils qui trouve quel module un programme Python utilise, sans faire tourne le programme actuellement.
msilib
Lit/écrit des fichiers de l’installateur Microsoft [Windows].
msvcrt
Opérations sur fichiers et console spécifique Windows [Windows].
multifile
Une interface style readline() vers une partie d’un message complexe.
mutex
Exclusion mutuelle – pour une utilisation avec le module sched. Voyez également le module standard de segmentation en tâches (threading), et glock.
netrc
Analyse en encapsule le format de fichier netrc.
new
Création d’objets internes d’exécution (interface vers les fonctions de création d’objets de l’interpréteur).
nis
Interface vers NIS de Sun (Pages jaunes) [Unix]. Python 2.5 : Nouvel argument domain vers nis.match() et nis.maps().
nntplib
Une classe client NNTP. Basée sur RFC 977.
ntpath
Opérations communes sur les noms de chemin Windows [Windows].
nturl2path
Convertit un nom de chemin NT en un fichier URL et vice versa [Windows].
olddifflib
Ancienne version de difflib (assistants pour calculer les différences entre des objets) ?
operator
Opérateurs standards pareils à des fonctions. Python 2.5 : itemgetter() et attrgetter() maintenant supportent des champs multiples.
optparse
Bibliothèque d’options d’analyse en ligne de commande améliorée (voyez également getopt). Python 2.5 : mise à niveau de la librairie Optik 1.51.
os
Routine de système d’exploitation pour Mac, DOS, NT, ou Posix dépendant du système sur lequel on se trouve. Python 2.5 : os.stat() retourne les valeurs de temps sous la forme de nombre flottant; nouvelles constantes vers os.lseek(); nouvelles fonctions wait3() et wait4(); sur FreeBSD, os.stat() retourne un temps sans la résolution en nanoseconde.
os.path
Manipulations communes de noms de chemin.
os2emxpath
Support os.path pour OS/2 EMX.
packmail
Crée une archive système auto extractible.
parser
Analyse des arborescences d’accès Python.
pdb
Un débogueur Python.
pickle
Pickling (sauve/sérialise et restaure/désérialise) d’objets Python (une implémentation C plus rapide existe dans le module prédéfini : cPickle). Python 2.5 : la valeur retournée par __reduce__() doit être différente de None.
pickletools
Outils d’analyse et de désassemblage de pickles.
pipes
Modèles de conversions de pipeline [Unix].
pkgutil
Outils pour étendre le chemin de recherche pour un paquet donné. Python 2.5 : support des blocks d’importation PEP302; travaille pour les paquets au format d’archive ZIP.
platform
Va chercher des informations au sujet de la plateforme sous-jacente.
poly
Polynômes.
popen2
Engendre une commande avec transfert de données vers son stdin, stdout, et optionnellement stderr. Remplacé par le module subprocess depuis 2.4.
poplib
Une classe client POP3.
posix
Appels les plus communs au système POSIX [Unix].
posixfile
(Déprécié depuis 1.5, utilisez fcntl.lockf() à la place) Objets genre fichier avec support de verrouillage [Unix].
posixpath
Opérations communes sur les noms de chemin POSIX.
pprint
Support vers des listes bien imprimées, uplet (tableaux invariables) et dictionnaire récursivement.
pre
Support pour des expressions régulières (RE) – voyez également re.
profile
Classe pour le code Python de profilage. Python 2.5 : Voyez également la nouvelle implémentation C cProfile.
pstats
Classe pour de reports d’impression de code Python profilé. Python 2.5 : nouvel argument stream vers le constructeur Stats.
pty
Utilitaires de pseudo terminal [Linux, IRIX].
pwd
La base de donnée des mots de passe [Unix].
py_compile
Routine pour "compiler" un fichier .py en un fichier .pyc.
pyclbr
Analyse un fichier Python et recherche classes et méthodes.
pydoc
Génère une documentation Python en HTML ou texte pour une utilisation interactive.
pyexpat
Interface vers l’analyseur XML Expat. Python 2.5 : utilise maintenant la version 2.0 de l’analyseur expat.
PyUnit
Cadre de teste d’unité inspiré de JUnit. Voyez unittest.
Queue
Une queue multi producteur, multi-utilisateur.
quopri
Conversions de/vers l’encodage de transport imprimable comme avec RFC 1521.
rand
Ne pas utiliser à moins que vous ne vouliez une compatibilité avec le rand() du C.
random
Générateurs de variables aléatoires.
re
Regular Expressions (Expressions régulières).
readline
Interface GNU
readline [Unix].
reconvert
Convertit d’anciennes expressions régulières ("regex")
dans la nouvelle syntaxe ("re").
regexp
Compatibilité arrière pour le module "regexp"
en utilisant "regex".
regex_syntax
Drapeaux pour regex.set_syntax().
regsub
Basé sur Regexp, partage et remplace en utilisant
le module obsolète regex.
repr
Implémentation alternative de repr().
resource
Information d’utilisation des ressources [Unix].
rexec
Facilités d’exécution restrictive ("safe" exec,
eval, etc).
rfc822
Analyse les entêtes de courriels RFC-8222.
rgbimg
Lit/écrit des fichiers 'SGI RGB'.
rlcompleter
Mots de commandes pour GNU readline 2.0 [Unix]. Python 2.5 : Ne dépend pas plus de readline; maintenant fonctionne sur de plateformes non-Unix.
robotparser
Analyseur de fichiers robot.txt, utile pour des robots web.
sched
Une classe généralement utile de générateur d’évènement.
select
Attente de demandes I/O.
sets
Une implémentation d’initialisation de type de donnée basée sur des dictionnaires (voyez Sets).
sgmllib
Un analyseur pour SGML, utilisant une classe dérivée d’un
DTD statique. (
sha
Algorithme de sommaire de messages SHA-1. Python 2.5 : Maintenant un meilleur ensemble autour de la nouvelle librairie hashlib.
shelve
Contrôle des rangements des objets pickled. (Le
module pickle implémente un fondamental mais puissant
algorithme de sérialisation dé-sérialisation un objet structure Python. Pickling
est le processus par lequel un objet hiérarchie de Python est converti en un
flux de bytes, et un unpickling est l’opération inverse où un flux de
bytes est converti en un objet hiérarchie. Pickling (et unpickling)
est alternativement reconnu comme serialization, marshalling,
ou flattening, toutefois, pour
éviter des confusions, utilisez les termes pickling et unpickling.)
shlex
Classe analyseur lexical pour des syntaxes simples genre shell.
shutil
Fonctions utilitaires pour la copie de fichiers et d’arborescences.
signal
Positionne les prises en main d’évènements asynchrones.
SimpleHTTPServer
Serveur HTTP Simple.
SimpleXMLRPCServer
Serveur XML-RPC simple. Python 2.5 : nouvel attribut rpc_paths.
site
Module Append de recherche de chemins des paquets tiers vers sys.path.
smtpd
Un serveur SMTP RFC 2821.
smtplib
Une classe client SMTP/ESMTP.
sndhdr
Quelques routines qui aident à la reconnaissance des sons.
socket
Opérations d’interface de connexion et quelques fonctions relatives. Maintenant supporte timeouts à travers la fonction settimeout(t). Supporte également SSL sous Windows. Python 2.5 : Maintenant supporte l’interface de connexion AF_NETLINK sous Linux; nouvelles méthodes d’interface recv_buf(buffer), recvfrom_buf(buffer), getfamily(), gettype() et getproto().
SocketServer
Des classes d’interface de connexion générique.
spwd
Accédez à la base de donnée masquée des mots de passe UNIX [Unix].
sqlite3
Interface DB-API 2.0 pour base de données SQLite.
sre
Support pour expressions régulières (RE). Voyez re.
stat
Constantes/fonctions pour interpréter les résultats des systèmes opérationnels.
statcache
Maintient un cache d’informations sur des fichiers stat().
statvfs
Constantes pour la structure d’interprétation statvfs telle que celle retournée par os.statvfs() et os.fstatvfs() (s’ils existent).
string
Une collection d’opérations sur les chaînes (Voyez Strings).
StringIO
Objets genre fichiers qui lisent/écrivent un tampon de chaînes (un implémentation C rapide existe dans le module prédéfini cStringIO).
stringprep
Normalisation et manipulation de chaînes Unicode.
struct
Permet les conversions entre des valeurs Python et des structures C représentées en chaînes Python. Python 2.5 : nouvelles méthodes plus rapides pack() et unpack()); pack et unpack depuis/vers un objet tampon (buffer) via les méthodes pack_into et unpack_from.
subprocess
Gestion de sous-processus. Remplacement pour os.system, os.spawn*,
os.popen*, popen2.* [PEP324]
sunau
Analyseur de contenu de fichiers audio Sun et NeXT.
sunaudio
Interprèté les enteêtes audio sun.
symbol
Grammaire des symboles non-terminaux de Python (depuis "graminit.h").
symtable
Interface vers la table des symboles internes du compilateur.
sys
Paramètres et fonctions spécifiques au système.
syslog
Routines de librairies Unix syslog [Unix].
tabnanny
Teste le code source Python pour des indentations ambiguës.
tarfile
Outils pour lire/créer des archives TAR. Python 2.5 : nouvelle méthode TarFile.extractall().
telnetlib
Classe client TELNET. Basé sur RFC 854.
tempfile
Fichiers et noms de fichiers temporaires.
termios
Contrôle TTY style POSIX [Unix].
(TTY : c'est un terminal. Il y a tous les tty0->tty99
qui sont les terminaux virtuels (que l’on peut renvoyer vers le port com) et
les ttyS0, ttyS1 qui sont les ports com1 et com2
utilisés comme sortie quand il n'y avait pas encore d'écran ! Ces sorties sont
utilisées avec des lcd dans des applications embarquées ne nécessitant pas un
affichage de qualité (machine à café, quelques photocopieurs, imprimantes...)
TTY : Text TeletYpe
en mode texte, soit on appuie sur les touches fenêtre de ton clavier, soit on
appuie sur ctrl+alt+f1. On peut remplacer le f1 par toutes les touches fX : ça
ouvrira une instance du ttyX ;))
(Comment pour lancer une autre instance du shell
(équivalent de start de l'interpréteur de commande de Windows) qui
permettait de lancer un autre interpréteur de commande.
En tapant ./commande, on ouvre un nouvel
environnement (si c'est un script qui instancie des variables, comme un nouveau
PATH, elles ne seront pas visibles, elles seront "oubliées"
quand le programme se terminera), sinon, pour lancer un programme dans le même
environnement, il faut taper . programme)
test
Paquet pour Python des tests de régression.
(Ce test fait suite à une modification de l'application
(du fait d'une mise à jour ou de l'aboutissement du test de recette) : il faut
alors vérifier que l'application n'a pas perdu de fonctionnalités lors de
l'ajout de nouvelles fonctionnalités ou la modification de fonctionnalités
existantes.
Ce n'est là qu'une poignée de tests, tout comme les
modèles de conceptions décrits dans un autre article ne sont qu'une
partie de l'iceberg, et ne saurait englober l'ensemble des possibilités face
auxquelles une équipe de développement peut se retrouver. Le test est un métier
à part entière, et connaître son fonctionnement permet de mieux collaborer lors
de l'élaboration de suites de tests... Les outils de tests les plus connus sont
JUnit (Java, porté pour .NET,
Python, Perl, Delphi...), JTest
(Java), TeamTest
et SilkTest.)
textwrap
Outils pour envelopper des paragraphes de texte.
thread
Multi processus de contrôle (voyez également threading ci-dessous).
(Tout le monde a entendu parler de système multi-tâches.
Un tel système est capable d'exécuter plusieurs programmes en parallèle sur une
même machine. Mais attention : dans la quasi totalité des cas il n'y a jamais
deux programmes différents qui s'exécutent au même instant. La raison en est
simple : la plupart du temps, une machine n'a qu'un seul processeur et ce
dernier n'est capable de réaliser qu'une seule chose à la fois. Mais alors,
comment se fait-il qu'on arrive malgré tout à exécuter plusieurs applications
en même temps (ou quasiment) ?
La plupart des systèmes d'exploitation sont équipés d'un
ordonnanceur de tâches. Ce composant logiciel a pour mission de donner à tour
de rôle le processeur aux programmes (on dit au processus) en cours
d'exécution. La durée pendant laquelle un processus est actif est en fait
très courte et c'est grâce à cette activation cyclique et brève que
l'utilisateur a l'impression que plusieurs choses sont en cours d'exécution sur
sa machine.
Bien souvent le problème est encore plus complexe. En
effet, sur les systèmes récents, le processus est en fait inactif : il permet
juste de partager les données d'une application. Mais les partager pour qui ?
Et bien, pour les tâches (threads) ! En fait, une application qui s'exécute est
représentée par un processus et par au moins une tâche (thread) (un processus
pouvant contenir plusieurs threads). La meilleure traduction française de thread
me semble être une tâche.
threading
Nouveau module de “threading” (lancer de tâches), émulant un sous-ensemble du modèle de lancer de tâches de Java. Python 2.5 : nouvelle fonction stack_size([size]) permet d’aller chercher/initialiser la taille de la pile pour les tâches créées.
threading_api
(Documentation du module de lancer de tâches).
time
Accès et conversion du temps (Time).
timeit
Outils d’évaluation.
Tix
Extension de gadgets pour Tk.
(Widget est un mot anglais qui est apparu aux États-Unis
dans les années 1920. Il est la concaténation de l'expression "wise gadget".
De manière générale, il est utilisé pour désigner un objet banal et
quelconque, mais utile. En français on peut le
traduire par « machin » ou gadget.
En informatique, le mot widget
recouvre deux notions distinctes en relation avec les interfaces graphiques,
il peut désigner :
Un composant
d'interface graphique, un élément de base d'une liste déroulante,
(bouton, etc.)( En informatique,
un composant d'interface graphique (aussi appelé widget en anglais ou encore control)
est un élément de base d'une interface graphique
avec lequel un utilisateur
peut interagir (par exemple une fenêtre
ou une zone de texte).
Ces composants sont généralement regroupés dans des boîtes à outils
graphiques (appelée toolkit
en anglais). Une fois assemblée par un programmeur, ces composants forment une interface graphique
complète.
L'appellation control est connotée microsoft.
L'appellation widget est utilisée dans tous les autres cas.)
un widget de bureau,
un petit outil qui permet d'obtenir des informations (météo, actualité, dictionnaire, carte routière,
pense-bête (en anglais post-it),
traducteur
etc.)(Un widget est un objet (accessoire) qui peuvent être présenté sur
le bureau d'un système d’exploitation, ou sur une page web personnalisée (comme
sur Yahoo, Google ou Live...) et qui offre des fonctionnalités ou des
informations rapide à utiliser. Les widgets tendent à avoir une prise en main
des plus intuitive.)
Tkinter
Interface Python vers Tcl/Tk.
toaiff
Convertit des fichiers son "arbitrairement" vers AIFF (Format audio Apple et SGI).
token
Constantes Token (depuis "token.h"). (Boîtier générant des nombres synchronisés à un dispositif d'authentification informatique.)
tokenize
« Tokenizeur » pour code source Python.
trace
Outils pour tracer (suivre, surveiller) l’exécution d’une fonction, d’un programme.
traceback
Extrait, formate et affiche les informations à propos des suivis de l’évolution de la pile Python.
tty
Utilitaires de terminal [Unix].
turtle
Graphiques turtle (la tortue) genre LogoMation.
types
Définit des noms pour tous les symboles de type dans l’interpréteur standard.
tzparse
Analyse une spécification de fuseau horaire.
unicodedata
Interface vers les propriétés Unicode. Python 2.5 : Mise à jour vers Unicode DB 4.1.0; Version 3.2.0 encore disponible comme unicodedata.ucd_3_2_0.
unittest
Cadre de test d’unité de Python, basé sur JUnit de Erich Gamma et Kent
Beck.
urllib
Ouvre une librairie URL.
urllib2
Une librairie extensible pour ouvrir des URLs en utilisant une variété de protocoles.
urlparse
Analyse (absolue et relative) des URLs.
user
Ensemble qui permet la personnalisation de code pour le faire exécuter.
UserDict
Un adaptateur qui permet le sous-classement de classes dictionnaires prédéfinies (inutile avec les classes de nouveau style (new-style classes). Depuis Python 2.2, dict est sous-classable).
UserList
Un adaptateur qui permet le sous-classement de classes prédéfinies list (inutile avec les classes de nouveau style (new-style classes). Depuis Python 2.2, list est sous-classable).
UserString
Un adaptateur qui permet le sous-classement de classes prédéfinies str (inutile avec les classes de nouveau style (new-style classes). Depuis Python 2.2, str est sous-classable).
util
Quelques fonction utiles qui ne s’adaptent pas ailleurs
!!
uu
Implémentation des fonctions UUencode et UUdecode.
uuid
Objets UUID en accord avec RFC 4122.
warnings
Elément Python du sous-système d’avertissement. Avertissements d’issue et avertissements de filtres non sollicités.
wave
Objet pour analyser des fichiers WAVE.
(Le terme stuff est utilisé par Carl Lagoze pour désigner un objet manipulé dans une bibliothèque numérique. Une recherche bibliographique nous a montré que d’autres auteurs avaient commencé à l’utiliser.)
weakref
Weak
reference support for Python. Also allows the creation of proxy
objects. Python 2.5: new methods iterkeyrefs(), keyrefs(),
itervaluerefs() et valuerefs().
(Une weak reference est une référence qui ne
protège pas l’objet référencié depuis la collection réalisée « garbage
collector ». Un objet référencié seulement par weak references est
considéré comme inaccessible (ou accessible « weakly ») et ainsi peut
être collecté à tout moment. Des Weak references sont utilisées pour
prévenir des références circulaires et pour pouvoir maintenir dans la mémoire
des objets référencés mais inutiles. Plusieurs langages orientés objets,
“garbage collected” produisent des références “weak”, comme Java, Python,
REALbasic et ActionScript 3.0. - garbage collection (GC) est une
forme de gestion automatique de mémoire. Le « garbage collector” (collecteur
d’inutiles) ou “collector” tente de reprendre “garbage” (inutile)
(fait référence à des objets, données ou autres régions de la mémoire d’un
système informatique (ou d’autres ressources système), qui ne sera pas utilisé
dans de futurs calculs par le système, ou par un programme s’y déroulant. En
tant que systèmes informatiques, tous ont des quantités finies de mémoire, il
est fréquemment nécessaire de “délocaliser” “garbage” et de le retourner
sur le tas, ou un « memory pool » (Une solution plus efficace est de
pré allouer un nombre de blocs mémoire ayant la même taille appelé la « memory
pool ».), ainsi, la mémoire sous-jacente pour être réutilisée.), ou la
mémoire utilisée par des objets auxquels il ne sera jamais fait accès ou qui
auront subit une mutation par l’application. « Garbage collection”
a été inventé par John McCarthy autour de 1959 pour résoudre des problèmes de
gestion manuelle de mémoire dans son langage de programmation Lisp.)
webbrowser
Lanceur d’URL indépendant de la plateforme. Python 2.5 : quelques améliorations (plus de navigateurs supportés, etc.).
whatsound
Quelques routines qui aident à reconnaître des fichiers
son.
whichdb
Devine quel paquet doit être utilisé pour ouvrir un fichier db.
whrandom
Générateur de nombres aléatoires de Wichmann-Hill (obsolète, utilisez random à la place).
winsound
Interface
sonore pour Windows [Windows].
wsgiref
Utilitaires WSGI et implémentation de références.
xdrlib
Implémente (un sous élément de) Sun XDR (eXternal Data Representation).
xmllib
Un analyseur pour XML, utilisant le classe dérivée
comme DTD statique. (
xml.dom
Classes pour exécuter XML en utilisant le DOM (Document Object Model)(Modèle d’objet document). Python 2.3 : de nouveaux modules expatbuilder, minicompat, NodeFilter, xmlbuilder.
xml.etree.ElementTree
Sous-ensemble de librairie ElementTree de Fredrik Lundh pour l’exécution du XML.
xml.sax
Classes pour l’exécution de XML en utilisant l’API SAX.
xmlrpclib
Une interface client XML-RPC pour Python. Python 2.5 : Supporte des objets retournant des temps (Datetime) pour le type de données XML-RPC.
xreadlines
Fournit un objet genre séquence pour lire un fichier ligne par ligne sans lire l’entièreté du fichier en mémoire. Déconseillé depuis la version 2.3. Utilisez for line in file à la place. Remplacé depuis 2.4.
zipfile
Lit/écrit des fichiers zippé PK. Python 2.5 : Supporte la version ZIP64, une archive.zip peut maintenant être plus grande que 4 GB.
zipimport
Importateur d’archive Zip.
zlib
Compression compatible avec gzip. Python 2.5 : Compress et Decompressobjects supportent maintenant la méthode copy().
zmod
Demonstration de concepts mathématiques obtus (« abstruse »
= de compréhension difficile).
dir(object)
Liste d’attributs valides de object (qui peut être un module, un objet type ou classe)
dir()
Liste des noms dans la table locale des symboles.
if __name__
== '__main__':
main()
Invoque, appelle main() s’il fonctionne comme un script.
map(None, lst1, lst2, ...)
Fusionne des listes; voyez également zip(lst1, lst2, ...).
b = a[:]
Crée une copie b de la séquence a.
b = list(a)
Si a est une liste, en créer une copie.
a,b,c = 1,2,3
Assignation multiple, la même chose que a=1; b=2; c=3.
for key,
value in dic.items():
...
Fonctionne également dans ce contexte.
if 1 < x <= 5:
...
Fonctionne si prévu.
for line
in fileinput.input():
...
Exécute chaque fichier dans les arguments de la ligne de commande, une ligne à la fois.
_
(underscore) (trait de soulignement) en mode interactif, fait référence à la dernière valeur affichée.
Les bonus Emacs sont disponibles ici.
(La suite n’a pas été révisée, probablement pas à jour – toute contribution est la bienvenue -)
Type C-c ? Lorsqu’on est en mode Python pour une aide
extensive.
INDENTATION
Principalement pour écrire du nouveau code :
TAB Indente la ligne de
manière appropriée.
LFD Insère une nouvelle ligne
puis indente.
DEL Réduit l’indentation ou
supprime un caractère simple.
Principalement pour réindenter un code existant :
C-c : devine py-indent-offset
en fonction du contenu du fichier; change localement.
C-u C-c : ditto, mais change
globalement.
C-c TAB Réindente une région
pour l’assortir à son contexte.
C-c < Déplace une région
vers la gauche avec py-indent-offset.
C-c > Déplace une région
vers la droite avec py-indent-offset.
MARQUAGE & MANIPULATION DE REGION DE CODE :
C-c C-b Marque un bloc de
lignes.
M-C-h Marque la plus petite
définition incluse.
C-u M-C-h Marque la plus
petite classe incluse.
C-c # Région commentée de
code.
C-u C-c # Région non
commentée de code.
DEPLACEMENT DE POINT :
C-c C-p Déplace vers
l’emplacement du point précédant.
C-c C-n Déplace vers
lemplacement du point suivant.
C-c C-u Déplace vers le début
du bloc courent.
M-C-a Déplace vers le début
de la définition.
C-u M-C-a Déplace au début de
la classe.
M-C-e Déplace à la fin de la
définition.
C-u M-C-e Déplace à la fin de
la classe.
EXECUTION DE CODE PYTHON :
C-c C-c Envoie l’entièreté
du tampon vers l’interpréteur Python.
C-c | Envoie la région
courente.
C-c ! Démarre la fenêtre de
l’interpréteur Python; ceci sera utilisé subséquemment par C-c C-c or C-c |
commands
VARIABLES :
py-indent-offset Indentation
incrémentale.
py-block-comment-prefix
Chaîne de commentaire utilisée par py-comment-region.
py-python-command Commande de
processus qui invoque l’interpréteur Python.
py-scroll-process-buffer “t”
signifie toujours déroule le tampon du process Python.
py-temp-directory Directory
utilisé pour les fichiers temporaires (so nécessaire).
py-beep-if-tab-change Sonne
la cloche si la largeur de tabulation a été modifiée.