Python 2.5 Quick Reference (Français).

 

Contenu :

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

 

***********************************************************************

Historique. (non traduit)

 

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.

********************************************************************************************

 

 

Invocation Options

python[w] [-dEhimOQStuUvVWxX?] [-c command | scriptFile | - ] [args]

(pythonw does not open a terminal/console; python does).

 

 

Options d’invocation

 

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.

 

*******************************************************************

Variables d’environnement.

 

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

 

**************************************************************************

Mots-clés importants.

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.

 

**************************************************************************

Identifiants.

 

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

 

Chaînes de caractère littérales.

 

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

 

Littérale.

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

 

*************************************************************************

 

Échappement de chaîne littérale.

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.

 

Constantes Booléennes (depuis Python 2.2.1)

 

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

 

***********************************************************************

Nombres.

 

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)

 

************************************************************************

Sequences.

 

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

 

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.

 

Les opérateurs et leur ordre d’évaluation.

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.

 

Les types de base et leurs opérations.

Comparaisons (définies entre tous types).

 

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.

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

 

Opérateurs Booléens.

 

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.

 

Types numériques

 

-        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érateurs sur tous les types numériques.

 

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érateurs binaires sur des entiers et des entiers longs.

 

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.

 

Nombres complexes.

 

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

 

Exceptions numériques.

 

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érations sur tous types de séquences (list, tuple, string)

 

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érations sur des ordres modifiables (type list)

 

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/dictionnaires (type dict)

 

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.

Opérations sur des chaînes (types str & unicode).

 

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érations sur des chaînes de caractères.

 

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

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.

 

Formatage de chaînes avec l’opérateur « % ».

 

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

 

 

Format des codes.

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

« %% ».)

 

Les caractères signaux de conversion.

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

 

Mise en forme de chaînes de caractères (String templating).

 

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'

 

Objets fichiers (File objects)

 

(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érateurs sur les objets fichiers.

Opérations sur des fichiers.

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

 

Exceptions de fichiers.

 

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.

 

 

Ensembles (Sets).

 

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érations d’initialisation principales.

 

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.

 

Date/Heure.

 

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

 

Types avancés.

 

- 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és d’instruction.

 

 

 

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érateurs d’assignation.

 

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.

 

Expressions conditionnelles.

 

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 de contrôle de flux.

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 d’exception.

 

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

 

Assignation d’espaces nommés.

 

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 d’espaces nommés.

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

 

Définition de fonctions.

 

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

 

Définition de classe.

 

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.

 

Types / classes unification.

 

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 chaînes de documentation

 

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"

 

 

Itérateurs.

 

-        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

 

Générateurs.

 

-        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

 

 

Accès aux descripteurs/Attibuts.

 

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

 

Décorateurs pour fonctions et méthodes.

 

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

 

Compléments.

 

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.

 

Compréhensions de listes.

 

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)

 

Vues encapsulées.

 

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.

Fonctions prédéfinies.

 

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

 

Classes d’exception prédéfinies

 

Exception  de base

 

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éthodes standard & opérateurs de redéfinition dans les classes.

 

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éthodes spéciales pour chaque classe.

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

Opérateurs.

 

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

 

Méthodes spéciales d’opérations numériques.

 

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)

 

Conversions

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érations spéciales pour les containers.

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.

 

Informations spéciales d’attributs d’état pour certains types.

 

Tip: utilisez le module inspect pour vérifier si un objet est vivant.

 

Listes & Dictionnaires.

Attributs

Signification

 

__methods__

(list, R/O) : Liste des noms de méthodes de l’objet. Déprécié, utilisez dir() à la place.

 

Modules.

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

 

Classes.

 

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)

Instances.

 

Attributs

Signification

__class__

(class, R/W) : Classes d’instances.

 

__dict__

(dict, R/W) : Attributs.

 

Fonctions définies par l’utilisateur.

 

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.

 

Méthodes définies par l’utilisateur.

 

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.

 

Fonctions prédéfinies & méthodes.

 

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.

 

Codes.

 

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

 

Vues (Frames).

 

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.

 

Suivis (traceback).

 

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)

 

Tranches (Slices).

 

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.

 

Nombres complexes.

 

Attributs

Signification

 

real

(float, R/O) : Partie réelle d’un nombre imaginaire.

 

imag

(float, R/O) : Partie imaginaire d’un nombre imaginaire.

 

xranges

 

Attributs

Signification

 

tolist

(Méthode prédéfinie, R/O) : ?

 

Modules importants

 

sys

 

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

 

Quelques fonctions système.

 

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

 

Système d’Exploitation  (os).

 

Interfaces diverses de système d’exploitation.

 

 

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

 

 

Some os variables

 

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.

 

Quelques fonctions de système d’exploitation.

 

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.

 

posix

 

Interfaces du système d’exploitation Posix.

 

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

 

 

 

Variables posix.

 

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

 

Quelques fonctions Posix.

 

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.

 

Adresse/chemin (path) Posix.

 

Opérations Posix sur les noms d’adresse (pathname).

 

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

Quelques fonctions Posix sur l’adresse/chemin (path).

 

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.

 

Shutil

 

Opérations de haut niveau sur fichiers. (copie, effacement).

 

Fonctions principales Shutil.

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

 

Temps.

Accès à la date/heure est conversions.

 

(Voyez également le module mxDateTime si vous avez un besoin de gestion sophistiqué de la date et de l’heure).

 

Variables.

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

 

Quelques fonctions.

 

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

 

Formatage dans strftime() et strptime() :

 

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

 

Chaîne de caractère (string).

 

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.

 

 

Quelques variables de chaîne.

 

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.

 

Quelques fonctions de chaîne.

 

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.

 

re (sre)

Opérations d’expressions régulières.

 

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

 

Syntaxe régulière d’expression.

 

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équences spéciales.

 

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.

 

Variables.

 

Variable

Signification

error

Exception si la chaîne de format n’est pas un regexp valide.

 

Fonctions.

 

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

 

Objets d’expressions régulières.

 

Les objets RE sont retournés par la fonction de compilation compile.

 

Attributs des objets re.

 

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éthodes des objets re.

 

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.

 

Objets trouvés (Match object).

 

Les objets trouvés (Match objects) sont retournés par les fonctions de correspondance (match) & de recherche (search).

 

Les Attributs des objets trouvés (Match object).

 

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

 

Fonctions des objets trouvés (Match object).

 

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.

 

Math.

 

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

 

Constantes.

 

Nom                     Valeur

 

pi                      3.1415926535897931

e                       2.7182818284590451

 

Fonctions.

 

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 0, m et e sont tous deux 0. Autrement, 0.5 <= abs(m) < 1.0 (la valeur absolue de m est comprise entre 0.5 et 1.0).

 

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

 

getopt

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

 

Fonctions.

 

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

 

 

Liste des modules dans la distribution des paquets de base.

 

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

 

Modules de libraires standards.

 

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. (La Document Type Definition (DTD), ou Définition de Type de Document, est un document permettant de décrire un modèle de document SGML ou XML.)

 

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. (La Document Type Definition (DTD), ou Définition de Type de Document).

 

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

 

 

Conseils d’exploration de zone de travail et idiomes.

 

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.

 

Mode Python pour Emacs.

 

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.