(site sans réclame)
Python  –  Manuel  –  Cont@ct  –  S'abonner

Modules internes du langage python - www.jchr.be

Cette page présente quelques modules importants, et internes au langage python 2.x et python 3.x, c'est-à-dire qu'ils sont installés avec python. Cette page ne prétend aucunement à l'exhaustivité.

Quelques modules externes: TKinter - ECMA-48 (print at, color)

Autres modules (.en)

base64, uu, binhex et binascii pour divers encodages
datatime et calendar
fractions
htmlparser et urllib2

0. Notions capitales relatives à tous les modules

Les fonctions spécialisées ont été regroupées dans des modules. Beaucoup de ceux-ci font partie intégrante de python (modules internes), mais il est nécessaire de les appeler au préalable pour avoir accès à leurs fonctions.

import module charge un module appelé module.py
module.fonction() la fonction doit alors être préfixée du nom du module lors de chaque utilisation.

import module as alias permet d'utiliser un alias plus explicite ou plus court:

>>> import math as M
>>> print M.pi           # au lieu de 'print math.pi'

from module import fonction charge une fonction précise du module, qui ne devra plus être préfixée
from module import * charge toutes les fonctions d'un module, qui ne devront donc pas être préfixées. Attention aux synonymes, comme os.open() et open(), qui ne requièrent pas les mêmes paramètres.

Important: ne nommez jamais un script du nom d'un module à importer: python cherche d'abord le module dans le répertoire du script, et votre script s'importerait lui-même.

Informations sur les modules et les fonctions:

dir() liste les modules chargés
dir(module) liste les fonctions et constantes d'un module chargé
module.fonction.__doc__ documente la fonction d'un module chargé
print module.__file__ renvoie la localisation du module sur votre système
help(module) renvoie des informations sur les fonctions d'un module
help(module.fonction) renvoie des informations sur une fonction particulière

Sous-modules

Certains modules (comme os) contient des sous-modules (comme os.path). Il faut en tenir compte lors de l'appel d'une fonction de ce sous-module:

>>> import os
>>> os.path.split("/home/toto/index.htm")
('/home/toto','index.htm')

Il est possible de charger un sous-module sous forme d'alias:

>>> import os.path as P
>>> P.split("/home/toto/index.htm")

Il est encore possible de charger toutes les fonctions d'un sous-module, qui ne devront plus être préfixées:

>>> from os.path import *
>>> split("/home/toto/index.htm")

Attention: from os import * importe les fonctions du module et les sous-modules, mais il sera nécessaire de préfixer les fonctions du sous-module:

>>> from os import *
>>> path.split("/home/toto/index.htm")

1. Système

1.1 sys (système)

sys.platform affiche la description du système d'exploitation
sys.version affiche la version de python et du compilateur C
sys.hexversion affiche la version exprimée en hexadécimal
sys.copyright affiche le copyright
sys.path renvoie une liste des chemins d'accès de python (/usr/lib/python2.5...)
sys.maxint affiche le format du plus grand nombre entier
sys.exit() pour quitter le programme (ou le shell)

sys.argv est la liste des paramètres passés dans la ligne de commande (argv[0] contient le chemin/nom du script):

for x in sys.argv:
  print x

Pour déterminer le chemin du répertoire où se situe un script lancé par un double clic:

import os,sys
chemin=os.path.dirname(sys.argv[0])+"/"

stdout permet de rediriger les sorties vers un fichier:

import sys
svg=sys.stdout # sauvegarde de la sortie normale (console)
sys.stdout=open('fichier','a') # ouverture en ajout
print "Ce que vous voulez"
sys.stdout.close()
sys.stdout=svg # restauration de la sortie normale (console)

sys.stdout.flush() force l'écriture en cas de bufférisation (passage provisoire des données en mémoire avant écriture sur disque)

1.2 time (temps)

Dans la plupart des fonctions qui suivent, l'empreinte temporelle (timestamp) est le nombre de secondes qui séparent une date du début de l'ère Unix, le 01.01.1970 à 00:00:00 UT. L'intervalle géré sur un PC court du vendredi 13 décembre 1901 à 20h45:52 (-2147483648) au mardi 19 janvier 2038 à 04:14:07 (2147483647), soit les limites d'un entier signé codé sur 32 bits.

time.sleep(sec) marque une pause du programme pendant sec secondes

time.clock() retourne l'empreinte temporelle du présent sous forme de réel
time.clock() en Unix, retourne le temps écoulé pour le processus en cours; en Windows, depuis le dernier appel par clock(); plus fiable que time() pour tester l'optimisation des routines

time.ctime(ts) convertit une empreinte temporelle ou à défaut, le temps présent, en chaîne "jour-de-semaine mois jour hh:mm:ss année". Les jours de la semaine sont: Mon, Tue, Wed, Thu, Fri, Sat et Sun; les mois sont: Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec.

time.localtime() convertit une empreinte temporelle, ou à défault le moment présent, en tuple «temps local» (année, mois, jour, heures(24), minutes, secondes, jour de la semaine (0=lundi), jour de l'année (1-366), 1 si décalage de l'heure d'été)
time.gmtime() convertit une empreinte temporelle, ou à défault le moment présent, en tuple «temps universel» (année, mois, jour, heures(24), minutes, secondes, jour de la semaine (0=lundi), jour de l'année (1-366), 1 si décalage de l'heure d'été)

Les valeurs du tuple retourné par ces deux fonctions sont accessibles par l'index, ou par les attributs de classe du tuple:

time.localtime()[0]time.localtime().tm_yearannée en quatre chiffres
time.localtime()[1]time.localtime().tm_monmois de 1 à 12
time.localtime()[2]time.localtime().tm_mdayjour de 1 à 31
time.localtime()[3]time.localtime().tm_hournombre d'heures de 0 à 23
time.localtime()[4]time.localtime().tm_minnombre de minutes de 0 à 59
time.localtime()[5]time.localtime().tm_secnombre de secondes de 0 à 61
time.localtime()[6]time.localtime().tm_wdayjour de la semaine en chiffre (lundi=0)
time.localtime()[7]time.localtime().tm_ydayjour de l'année de 1 à 366
time.localtime()[8]time.localtime().tm_isdst1 en cas de jour en période d'heure d'été

time.asctime() convertit un tuple au format localtime/gmtime en chaîne au format ctime
time.mktime() convertit un tuple au format localtime/gmtime en empreinte temporelle

time.strftime(format[,tuple]) retourne une chaîne selon un formatage et un tuple de date (ou à défaut, le temps présent). Le format peut contenir:

%%pour afficher le caractère %
%apour Mon, Tue, Wed, Thu, Fri, Sat ou Sun
%Apour Monday, Tuesday, Wednesday, Thursday, Friday, Saturday ou Sunday
%bpour Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov ou Dec
%Bpour January, February, March, April, May, June, July, Augustus, September, October, November ou December
%cla date et l'heure au format ctime()
%C(non documenté python 2.7) 19 ou 20: les deux premiers chiffres de l'année en quatre chiffres
%dle jour du mois, de 01 à 31
%D(non documenté python 2.7) voir %x
%Hl'heure en chiffres, de 01 à 23
%Il'heure en chiffres, de 01 à 12
%pAM ou PM (sic)
%Pam ou pm (sic)
%jle jour de l'année, de 001 à 366
%mle mois en chiffres, de 01 à 12
%Mla minute en chiffres, de 00 à 59
%s(non documenté python 2.7) empreinte temporelle sous forme de chaîne
%Sla seconde, en chiffres, de 00 à 61 (il peut exister des secondes additionnelles en fin de semestre)
%u(non documenté python 2.7) le jour de la semaine en chiffre, de 1 (lundi) à 7 (dimanche)
%Ula semaine (commençant par un dimanche) en chiffre, de 00 à 53; les jours avant le premier dimanche appartiennent à la semaine 00
%wle jour de la semaine en chiffre, de 0 (dimanche) à 6 (samedi)
%Wla semaine (commençant par un lundi) en chiffre, de 00 à 53; les jours avant le premier lundi appartiennent à la semaine 00
%xla date selon la représentation conforme à la locale
%Xl'heure selon la représentation conforme à la locale
%yl'année sur deux chiffres, de 00 à 99
%Yl'année sur quatre chiffres, de 1901 à 2038
%z(non documenté python 2.7) "0200" pour 2h de décalage horaire.
%Zla zone horaire

Les formatages %C, %D, %s, %u et %z sont valables en python3

time.strptime(chaine,"format"]) retourne un tuple au format localtime/gmtime basé sur l'interprétation d'une chaîne à travers les éléments de formatage représentés ci-dessus:

>>> time.strptime("2012.12.25","%Y.%M.%d")
time.struct_time(tm_year=2012, tm_mon=1, tm_mday=25, tm_hour=0, tm_min=12, tm_sec=0, tm_wday=2, tm_yday=25, tm_isdst=-1)

time.timezone contient la valeur du décalage en secondes de l'heure locale avec le temps universel (négatif si 0h local arrive avant 0hUT)
time.altzone contient la valeur du décalage en secondes de l'heure locale d'été avec le temps universel (négatif si 0h local arrive avant 0hUT)
time.daylight =1 si l'heure d'été est à considérer
time.tzname est un tuple contenant les noms de la zone horaire et de son homologue «heure d'été» en cours
time.tzset() initialise la zone horaire

Le module pytz existe également (installer le paquet python-tz)

import pytz
for i in pytz.all_timezones:
  print i

1.3 os (système d'exploitation)

os.system() permet une commande de console bash ou DOS: os.system("dir")

os.popen permet de récupérer la sortie d'une commande-système, à passer comme le nom d'un fichier que l'on ouvre. Dans l'exemple qui suit, acpi retourne une chaîne contenant la température du processeur:

sortie = os.popen("acpi -t", "r")
texte = sortie.read()
sortie.close()
print texte

os.uname() renvoie le tuple (os, station, kernel, datekernel, processeur) de la machine exécutant le script.

Les variables d'environnement permettent d'écrire des chemins d'accès indépendamment de la plateforme:

os.name Nom du système UN*X: posix ; nt, os2, mac, ce, riscos...
os.path UN*X: <module 'posixpath' from '/usr/lib/python2.5/posixpath.pyc>
os.curdir répertoire actuel. UN*X et Win: . , Mac: :
os.pardir répertoire parent. UN*X et Win: .. , Mac: ::
os.sep séparateur de répertoire - UN*X: /, Win: \, Mac: :

Avec python, os.pardir+os.sep+"repertoire"+os.sep+"fichier" devrait fonctionner pour remonter d'un répertoire, ouvrir un autre et désigner un fichier, pour toute plateforme.

os.altsep UN*X: None
os.pathsep séparateur de chemins - UN*X: : , Win: ;
os.defpath retourne ou détermine le chemin des exécutables.

Avec UN*X, print os.defpath donne :/bin:/usr/bin
Pour les déterminer: os.path=':bin:/usr/bin:/usr/X11R6/bin'

os.linesep séparateur de paragraphes - UN*X: '\n' (octet 10), Mac: \r (octet 13), Win: \r\n

os.walk produit un générateur capable de délivrer de façon récursive une série de tuples de trois éléments: le premier est le nom du répertoire, le second la liste de ses sous-répertoires et le troisième la liste de ses fichiers.

#! /usr/bin/python
# -*- coding: latin-1 -*-
import os
for rep, sous, fich in os.walk("/home/toto"):
  print "\nRép:",rep
  print "  S-R:",sous
  print "  Fic:",fich

Les droits

En UN*X, un fichier n'est pas nécessairement accessible à tous en ce qui concerne la lecture, l'écriture ou l'exécution (pour un répertoire, l'exécution équivaut à l'ouverture).

os.chown(fichier,usr,grp) fixe le propriétaire et le groupe, exprimés sous forme de nombres
os.chmod(fichier, mode) fixe les attributs du fichier en trois chiffres octaux. Le premier concerne le propriétaire du fichier, le second un groupe, et le troisième tout le monde. Chaque chiffre a une valeur de 0 à 7, addition de 4 s'il doit être lisible, 2 modifiable et 1 exécutable. 0754 donne tous les droits (4+2+1) au propriétaire, les droits de lecture et d'exécution (4+1) pour le groupe spécifié et uniquement de lecture (4) à tout le monde (rappel: un nombre commençant par un zéro désigne un nombre octal. Rappel: en python3, un nombre octal commence par 0o (zéro + lettre 'o').
os.access(fichier,mode) retourne TRUE selon les possibilités d'accès à un fichier. mode = os.F_OK pour l'existence, os.R_OK pour la lecture, os.W_OK pour la modification, os.X_OK pour l'exécution du fichier (ou l'ouverture du répertoire).

Édition de fichiers

Cette partie double la gestion des fichiers disponible dans le python "sans module". De ce fait, il risque d'avoir des doublons si vous importez de la façon suivante: from os import * . Avec import os, par contre, file() de python ne sera pas confondu avec os.file() du module os.

descr=open(chaine,flags,mode) ouvre un fichier. flags admet les variables suivantes: O_RDONLY (=0), O_WRONLY (=1), O_RDWR (=2), O_CREAT (=64), O_APPEND (=1024), O_BINARY (MS seulement)... on les compose en les additionnant ou avec le "ou" logique "|". mode (facultatif): voir les droits ci-dessus.

os.read(descr,n) retourne une chaîne de n octets du contenu d'un fichier ouvert en 0 ou 1
os.write(descr,chaine) écrit une chaîne dans un fichier (en écrasant ou en ajout selon le mode d'ouverture)
os.close(descr) ferme un fichier
os.lseek(descr,n,mode) positionne le curseur d'un fichier selon un offset n, selon le mode: SEEK_SET (=0: à partir du début), SEEK_CUR (=1, à partir de la position courante), SEEK_END (=2: à partir de la fin)
os.remove(fichier) détruit un fichier si droit d'écriture
os.rename(ancien,nouveau) renomme un fichier ou un répertoire

Gestion des répertoires

os.getcwd() renvoie le répertoire courant connu du système. Si un script est appelé par l'interface graphique, os.path.dirname(sys.argv[0]) est plus exact
os.chdir(repertoire) pénètre dans un répertoire existant
os.chdir("..") (UN*X ou MS) ou chdir("::") (Mac) ou plus universellement chdir(os.pardir) remonte d'un niveau de répertoire

os.listdir(getcwd()) renvoie une liste de tous les objets du répertoire courant
os.walk(rep) est un générateur renvoyant des tuples ('répertoire',[sous-répertoires],[fichiers])

import os
for rep, sous, fich in os.walk("/home/toto"):
  print "\nRép:",rep
  print "  S-R:",sous
  print "  Fic:",fich

os.mkdir(repertoire,mode) crée un répertoire dans le répertoire courant, mode 0777 par défaut
os.makedirs(chemin,mode) crée tout un chemin dans le répertoire courant, mode 0777 par défaut
os.rmdir(repertoire) détruit un répertoire (en principe vide) si droit d'écriture

Sous-module os.path

Le sous-module os.path est automatiquement chargé avec import os, mais peut être chargé à part avec import os.path. Il indique les attributs d'un fichier (nom, taille, chemin...) sans qu'il ne soit nécessaire de l'ouvrir: c'est le système qui répond.

os.path.getsize(fichier) retourne la taille (entier long)
os.path.getmtime(fichier) retourne la date de la dernière modification d'un fichier (idem)
os.path.getatime(fichier) retourne la date du dernier accès à un fichier (en nombre de secondes, voir 1.2 'time'

os.path.dirname(cheminfichier) retourne la partie de l'adresse à gauche du dernier séparateur de répertoire (/, \, :...)
os.path.basename(cheminfichier) retourne la partie de l'adresse à droite du dernier séparateur de répertoire
os.path.split(cheminfichier) retourne un tuple avec les résultats de dirname et basename
os.path.abspath(fichier) renvoie l'adresse absolue du nom de fichier précisé
os.path.expanduser(fichier) complète une chaîne commençant par ~/
os.path.realpath(adresse) élimine les /. et réduit les /rep/..
os.path.splitext("nom.ext") retourne le tuple ('nom', '.ext')

os.path.exists(fichier) renvoie True si le fichier existe
os.path.isfile(fichier) renvoie True si l'objet est un fichier
os.path.isdir(fichier) renvoie True si l'objet est un répertoire
os.path.islink(fichier) renvoie True si l'objet est un lien
os.path.ismount(chemin) renvoie True si le répertoire est un point de montage
os.path.isabs(fichier) renvoie True si le nom du fichier comporte le chemin complet

dir(os.path) informe sur les fonctions du sous-module os.path

Voir également la recette pour naviguer dans un répertoire ou lister les fichiers.

2. Nombres

2.1 (c)math (mathématique)

Voir Opérateurs basiques.

math.__doc__ ne nous renseigne que sur sa conformité au C.

math.pi retourne une approximation de la constante pi: 3.1415926535897931
math.degrees() et radians() transforment en degrés ou en radians
math.cos(), math.sin(), math.tan() rapports trigonométriques usuels
math.acos(), math.asin(), math.atan() rapports trigonométriques inverses
math.cosh(), math.sinh(), math.tanh() rapports trigonométriques hyperboliques

math.atan2(y,x) donne l'arctangente de la valeur y/x

math.e retourne une approximation de la constante e: 2.7182818284590451
math.exp() exponentielle à base e
math.log() logarithme naturel (base e)
math.log10() logarithme en base 10

math.pow(x,y) renvoie x à la puissance y
math.sqrt() renvoie la racine carrée
math.hypot(x,y) renvoie l'hypothénuse pour un triangle rectangle de côtés x et y

math.fabs() renvoie la valeur absolue (notation décimale)
math.fmod(x,y) renvoie le reste (notation décimale) de x modulo y
math.modf() renvoie un tuple (partie décimale, partie entière) d'un "réel"
math.ldexp(x,y) renvoie x*y**2, soit x fois y exposant 2
math.frexp() renvoie un tuple (x,y), où x est la fraction du nombre 2**y:

>>> frexp(9)
(0.5625, 4)

math.ceil() arrondissement par excès d'un nombre "réel"
math.floor() arrondissement par défaut d'un nombre "réel"

cmath

Le module cmath reprend la plupart des fonctions du module math pour les nombres complexes a+bj :

cmath.pi, cmath.e, cmath.log, cmath.log10, cmath.exp, cmath.sqrt
cmath.cos(), cmath.sin(), cmath.tan(), cmath.acos(), cmath.asin(), cmath.atan()
cmath.cosh(), cmath.sinh(), cmath.tanh(), cmath.acosh(), cmath.asinh(), cmath.atanh()

2.2 random (hasard)

Le module random regroupe des fonctions de hasard et probabilités. Le module whrandom (intégrant l'algorithme Wichmann-Hill), qui présentait des améliorations au niveau de la réinitialisation de la «graine aléatoire», est supprimé depuis python 2.5.

random.choice(liste) choisit un élément d'une liste: random.choice([1,'a',125,'ouiche'])
random.sample(liste,n) renvoie une liste de n éléments choisis d'une liste
random.shuffle(liste) mélange les éléments d'une liste

random.randint(borne1,borne2) renvoie un entier au hasard entre deux bornes (incluses); préférer le suivant
random.randrange(borne1,borne2,pas) renvoie un entier entre la première borne (incluse) et la deuxième (exclue); le pas est optionnel
random.randrange(borne2) renvoie un entier entre 0 (inclus) et la deuxième un entier (exclu)

random.seed(n) (ré-)initialise le générateur de nombres pseudo-aléatoires

random.random() renvoie un "réel" compris dans l'intervalle [0,1[
random.uniform(r1,r2) renvoie un "réel" compris dans l'intervalle [r1,r2[

Les fonctions suivantes génèrent des nombres pseudo-aléatoires selon des distributions particulières: random.betavariate, random.cunifvariate, random.expovariate, random.gammavariate, random.gauss, random.lognormvariate, random.normalvariate, random.paretovariate, random.vonmisesvariate et random.weibullvariate. Exemple:

print random.gauss(moyenne,ecart_type) sort un "réel" selon les probabilités d'une distribution normale (d'autant plus probable que proche de la moyenne)

random.BPF, random.LOG4, random.NV_MAGICCONST, random.SG_MAGICCONST et random.TWOPI sont les variables disponibles.

2.3 decimal

decimal (nouveauté python 2.3) permet de traiter les nombres "réels" (exprimé sous forme de chaîne) tels qu'ils sont, et non leur équivalent binaire:

import decimal
print 1 % .1     # l'imprécision sur l'équivalent binaire de .1 donnera le reste .09999999999999995, ou .1
print decimal.Decimal(1) % decimal.Decimal(".1") # donne 0.0 puisque qu'il n'y a pas de reste
print decimal.negInf # donne Decimal("-Infinity"): de nouveau "nombres" existent dans ce module

decimal.setcontext(decimal.ExtendedContext) permet

>>> decimal.Decimal(0)/decimal.Decimal(0)
Decimal("NaN")

Les modules math et cmath peuvent traiter les nombres issus du module decimal, mais les réponses sont converties en nombres "réels".

3. Chaînes

3.1 string (chaînes)

Voir également chaîne dans le manuel.

Il est possible de ne pas charger le module string, en utilisant la forme variable.fonction(). Attention! la chaîne d'origine n'est pas affectée par les modifications, le résultat doit être récupéré par une variable: variable=chaine.fonction().

Pour une variable dénommée chaine:

chaine.upper() convertit en majuscule
chaine.lower() convertit en minuscule
chaine.capitalize() passe la première lettre de la chaîne en capitale
chaine.title() passe la première lettre de chaque mot de la chaîne en capitale
chaine.swapcase() transforme minuscules en majuscules et inversement

chaine.split() renvoie une liste de tous les mots (séparation: l'espace) d'une chaîne-phrase
chaine.split('*') le séparateur peut être une chaîne autre que l'espace
chaine.split(' ',n) on peut limiter le nombre de séparations effectuées
' '.join(liste) concaténation d'une liste (ou tuple) de chaînes (le séparateur est ici l'espace)
string.join(liste,'sep') cette forme oblige à charger le module au préalable

chaine.startswith('pref') renvoie True si la chaîne commence par le prefixe
chaine.endswith('suf') renvoie True si la chaîne termine par le suffixe
chaine.strip() ôte les espaces en début et fin de chaîne
chaine.lstrip() / chaine.rstrip() ôtent les espaces en début / fin de chaîne
chaine.strip('car') ôte les caractères précisés en début et fin de chaîne
chaine.ljust(n) remplit d'espaces à gauche pour que la chaîne fasse n caractères
chaine.rjust(n) remplit d'espaces à droite pour que la chaîne fasse n caractères
chaine.center(n) entoure la chaîne d'espaces pour qu'elle fasse n caractères
chaine.zfill(n) ajoute des 0 à gauche pour que la chaîne fasse n caractères
chaine.expandtabs(n) transforme les tabulations en n espaces (8 par défaut)

chaine.count(ssch,debut,fin) compte les occurrences de la sous-chaîne dans la chaîne, éventuellement entre deux positions
chaine.find(ssch) renvoie la position d'une sous-chaîne dans une chaîne (0 pour la première position, -1 si la sous-chaîne ne s'y trouve pas
chaine.find(ssch,debut,fin) renvoie la position d'une sous-chaine dans une chaine, en définissant les positions de début et de fin
chaine.rfind(ssch,debut,fin) pareil, mais en commençant par la fin

chaine.replace(ssch1,ssch2,n) remplace une sous-chaîne par une autre (éventuellement en limitant à n occurrences)
rempl=string.maketrans(ch1,ch2) définit un protocole de remplacements pour translate
chaine.translate(rempl[,suppr]) assigne les remplacements définis à une chaîne, avec une éventuelle chaîne des caractères à supprimer (dans ce cas, la suppression a lieu avant le remplacement). Exemple:

from string import maketrans # style d'importation permettant de ne pas préfixer la fonction
rempl=maketrans("()&","[]§")
chaine="(Eggs&Spam)"
print chaine.translate(rempl)

isdigit(), isalpha(), isalnum(), islower(), isupper(), istitle(), isspace() testent des chaînes.

string.whitespace, string.lowercase, string.uppercase, string.letters, string.digits, string.hexdigits, string.octdigits, string.punctuation, string.printable sont des chaînes de caractères spécifiques:

>>> print string.punctuation
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
>>>string.whitespace
'\t\n\x0b\x0c\r '

...tabulation, nouvelle ligne, nouvelles lignes sans retour, retour à la ligne sans saut de ligne. \n peut dépendre du système.

Notes: les fonctions de conversions de chaînes en nombres string.atoi(), string.atol() et string.atof() sont abandonnées en faveur des fonctions internes int(), long() et float(), voir Variables numériques.

3.2 Chaîne Unicode

Avec une console en ISO-8859-1. Documentation expérimentale.

unicode(chaine,[encodage,errors='']) crée une chaîne de type Unicode u""
Par défaut, c'est encodage "ascii" qui sera appliqué, ne traitant que les caractères ascii (<128). Les autres codages sont "utf-8","latin-1","utf-85","cp1252","cp850"...
error='strict' (par défaut) renvoie l'erreur UnicodeDecodeError en cas de mauvais codage
error='replace' remplace tout caratère non reconnu par \ufffd
error='ignore' supprime les caractères non reconnus

ustr.encode("encodage"[,errors="strict"]) errors peut valoir 'ignore', 'replace'
str.decode(encodage)

>>> u'éà'
u'\xe9\xe0'
>>> u"éà".encode("utf-8")
'\xc3\xa9\xc3\xa0'
>>> '\xc3\xa9\xc3\xa0'.decode("utf-8")
u'\xe9\xe0'
>>> print u'\xe9\xe0'
éà

Tests de chaîne Unicode

Pour la chaîne unicode ustr, les comparateurs rendent True sous condition:

ustr.isalpha() caractères alphabétiques
ustr.isdigit(), ustr.isnumeric(...) et ustr.isdecimal() caractères numériques
ustr.isalnum() si tous les caractères sont alphabétiques ou numériques
ustr.isspace() caractères espace , tabulation, retour...: " \t\n\r\v"
ustr.islower() ne contient aucun caractères majuscules
ustr.isupper() ne contient aucun caractères minuscules
ustr.istitle() si tous les premiers caractères des mots (et eux seuls) sont en capitale

Ces tests renvoient toujours False en cas de chaîne vide.

Formatage

ustr.center(n[,car]) retourne une chaîne entourée d'espaces dans une chaîne de n caractères. car propose un autre caractère de remplissage que l'espace.
ustr.zfill(n) remplit la gauche d'un nombre avec autant de zéros qu'il faut pour arriver à n caractères (ne limite pas la longueur de la chaîne à n caractères)
ustr.expandtabs(n) retourne une chaîne où des espaces remplacent les tabulations pour un alignement sur les colones octuples si n n'est pas précisé

ustr.lower() retourne une chaîne Unicode en minuscules (même les lettres accentuées
ustr.upper() retourne une chaîne Unicode en majuscules (même les lettres accentuées
ustr.swapcase() retourne une chaîne avec changement de casse
ustr.capitalize() retourne une chaîne avec la première lettre en capitale
ustr.title() retourne une chaîne avec la première lettre de chaque mot en capitale

ustr.ljust(n[,"c"]) aligne ustr à gauche dans une chaîne de n caractères avec un remplissage d'espaces; "c" peut remplacer l'espace de remplissage éventuel
rjust(n[,c]) aligne à droite dans une chaîne de n caractères; c peut remplacer l'espace de remplissage éventuel
ustr.strip([c]) retourne une chaîne débarrassée des espaces (au sens large) l'entourant. c pour "éplucher" d'autres caractères
ustr.lstrip([c]) seulement à gauche
ustr.rstrip([c]) seulement à droite

Compter, chercher, remplacer

ustr.count(usub[,start,end]) nombre de fois que la sous-chaîne se retrouve dans la chaîne ustr, éventuellement limitée à [start,end]. Attention: u"blabla" ne se retrouve qu'une fois dans u"blablabla"
ustr.find(str[,start,end]) renvoie la première occurrence de str dans ustr, éventuellement limité dans la portion [start:end] de la chaîne (-1 si inexistante)
ustr.rfind() renvoie la dernière occurrence de str dans ustr, éventuellement limité dans la portion [start:end] de la chaîne (-1 si inexistante)
ustr.index() et rindex() comme find() mais ValueError au lieu de -1
ustr.replace(old,new[,nb]) remplace les [n premières] occurrences old par new

ustr.startswith(sub[,start,end]) True si la chaîne commence avec sub (ou si sub est situé à la position start. sub peut être un tuple de chaînes à tester
ustr.endswith(...)

Éclatements et liaisons

ustr.partition(chaine) renvoie un tuple en trois parties: la partie de chaîne Unicode jusqu'au séparateur, le séparateur puis le reste de la chaîne Unicode
ustr.rpartition(chaine) La première partie de la chaîne Unicode court jusqu'au dernier séparateur, le séparateur et puis le reste.
ustr.split([sep,max]) renvoie une liste de chaînes découpées par un séparateur, avec un éventuel nombre maximal de coupures. split([None,max]) pour un nombre limité de coupures avec l'espace comme séparateur
ustr.rsplit([sep,max])
ustr.splitlines()
u"sep".join(liste) retourne une chaîne résultat de la concaténation des chaînes d'une liste de chaînes (avec un éventuel séparateur)

ustr.translate(table) retourne une chaîne où des caractères sont remplacés selon une table (ne semble pas fonctionner comme dans le module string)

3.3 re (expressions régulières)

(Voir également les expressions régulières en PHP et pour les recherches de fichier dans l'environnement Gnome)

Les expressions rationnelles, ou expressions régulières, permettent de décrire une multiplicité de chaînes à partir d'un ensemble de règles. Il s'agit d'une extension des ? représentant un caractère quelconque et * pour un ensemble quelconque de caractères dans la recherche de fichiers. L'ensemble de règles que l'on donne est appelé motif (pattern), par exemple trois majuscules suivies du chiffre 5. Ce motif permet des comparaisons, des recherches ou remplacements dans une chaîne, ou un éclatement d'une chaîne selon un séparateur...

Règles

. désigne n'importe quel caractère sauf un retour-chariot
\w désigne une lettre ou un chiffre (équivaut à [A-Za-z0-9])
\W désigne un caractère qui ne soit ni lettre ni chiffre
\s désigne un caractère "espace" (équivaut à [ \t\r\f\n]: '  ', tabulation, retour-chariot, saut de ligne, nouvelle ligne)
\S désigne un caractère non espace tels que défini à la ligne précédente
\d désigne un chiffre; équivaut à [0-9]
\D désigne un caractère sauf les chiffres
\b désigne le backspace (0x08), mais seulement dans un intervalle

[] désigne un caractère selon des intervalles et des exclusions: [a-d0-5] permet un caractère qui va de a à d ou de 0 à 5.
    À l'intérieur de [], ^ exclut un caractère: [a-z^q] décrit l'intervalle de a à z , sans le q
() permet de traiter un groupe de caractères ou un choix
| permet un choix entre des (ensembles de) caractères: (a|p)m représente am ou pm

? le caractère (ou groupe) qui précède est optionnel: roc(he)? représente roc ou roche
* le caractère (ou groupe) qui précède est répété un nombre indéfini de fois (dont 0 fois)
+ le caractère (ou groupe) qui précède est présent au moins une fois: m+ représente m, mm, mmm...
{n} le caractère (ou groupe) qui précède est répété exactement n fois
{n,m} le caractère (ou groupe) qui précède est répété de n à m fois: (la){1,3} représente la, lala ou lalala

[A-Z]{3,5}\d+ représente les chaînes constituées de trois à cinq majuscules suivies d'au moins un chiffre

\ permet de définir littéralement un caractère qui sert normalement au codage: ( ) [ ] { } . $ ^ | ? + * \

Demande-plancher (non greedy)

Les quantifiants ?, +, * et {} acceptent une demande-plancher (non greedy), s'ils sont suivi d'un ?:

import re
rep=re.match(".*7",'abcd7e7')
if rep: print rep.group()
rep=re.match(".*?7",'abcd7e7')
if rep: print rep.group()

Ces deux motifs définissent une chaîne commençant par un nombre indéterminé de caractères et terminant par '7'. La première forme prend la plus grande suite de caractères indéterminés et le dernier '7': abcd7e7. La seconde forme est économe (non greedy): elle ne prend que les 4 premiers caractères indéterminés et le premier '7': abcd7.

Limites de mots et de lignes

\b limite de mot: \broc permet roc, roche... mais pas croc ni croche (également valable pour les fins de mots)
\B pas de limite de mot: roc\B permet croche, roche... mais pas roc ni accroc (également valable pour les débuts de mots)
^ en début d'expression indique que la chaîne recherchée doit correspondre à un début de ligne
$ en fin d'expression indique que la chaîne recherchée doit correspondre à une fin de ligne

Utilisation

match permet la comparaison stricte d'un motif et d'une chaîne:

import re
rep= re.match("[A-Z]{4}\d+",'aBCDE123')
if rep: print rep.group()

search permet de savoir si un motif se retrouvent au moins une fois dans une chaîne. Dans l'exemple suivante, le ? limite la réponse à BCDE1

import re
rep=re.search("[A-Z]{4}\d+?",'aBCDE123')
if rep: print rep.group() # "4 majuscules et au moins un chiffre" est bien inclus dans 'aBCDE123'

sub(motif,rempl,chaine[,n])permet des substitutions dans une chaîne, avec une éventuelle limite d'occurrence

import re
print re.sub("[A-Z]{2}",'0','ABCDE123') # tout couple de majuscules sera remplacé par 0

subn idem, mais rend un tuple avec la nouvelle chaîne et le nombre de remplacements effectués

split(motif,chaine[,n]) débite une chaîne dans une liste, avec une éventuelle limite d'occurrence

import re
print re.split("\d{2}",'ab92cde14ze') # le séparateur est ici toute chaîne de deux chiffres

Note: il est possible de compiler préalablement le motif, pour ensuite utiliser en préfixe des fonctions décrites ci-dessus:

import re
motif=re.compile("\d{2}")
print motif.split('ab92cde14ze')

3.4 curses (print at, couleurs)

Ce module permet la saisie plus souple de caractère (et des touches de contrôle) et l'affichage plus poussé (couleurs, endroit précis) dans une console. Attention au préfixage des paramètres avec curses.

Sous Windows, on peut par exemple utiliser wcurses.

Information officielle par ordre alphabétique (.en)

Quoi qu'il en soit, il faut évidemment importer la bibliothèque avec import curse, import wcurse ou import mcurse selon le cas.

Initialiser le processus

ecran = curses.initscr() définit un écran sur lequel tout va se passer

curses.noecho() permet de ne pas voir répéter sur l'écran ce qui est frappé au clavier
curses.cbreak() permet de ne pas devoir saisir avec [Enter] le caractère entré
curses.curs_set(0) rend le curseur invisible

Fenêtres

fenetre= curses.newwin(hauteur,largeur,origine_y,origine_x) définit un espace dont les dimensions ne peuvent excéder les dimensions de la fenêtre console ouverte: hauteur + origine_y ne peut excéder le nombre de lignes, largeur + origine_x le nombre de colonnes (par exemple 23 et 79 pour une console 24*80).

fenetre.refresh() affiche réellement les caractères "écrits" par les fonctions suivantes
fenetre.addch(car) "écrit" un caractère à la position du curseur
fenetre.addstr(chaine,mode) "écrit" une chaîne à la position du curseur (mode: voir plus bas)
fenetre.addch(y,x,car) "écrit" un caractère à la position indiquée
fenetre.addstr(y,x,chaine,mode) "écrit" une chaîne à la position indiquée
fenetre.move(y,x) place le curseur à la position précisée. On peut de ce fait séparer le placement du curseur de la sortie de caractère (voir exemple).

Terminer

curses.curs_set(1) rend le curseur visible si nécessaire
curses.nocbreak() rétablit la nécessité de saisir à l'aide de [Enter]
curses.echo() rétablit la répétition à l'écran du caractère saisi

curses.endwin() sort du processus et retour à la ligne de commande

#! /usr/bin/python
# -*- coding: utf-85 -*-
"""Exemple minimal pour l'utilisation de curses - 2007-01-26 - www.jchr.be - GPL-2"""
import curses, time
ecran= curses.initscr()
fenetre= curses.newwin(20,50,0,0)
fenetre.move(10,15)  # placement du curseur ligne 10/colonne 15
fenetre.addch('*')   # prévoit l'écriture de '*' à la position du curseur
fenetre.refresh()    # écrit réellement ce qui a été prévu par addch() et addstr()
time.sleep(2)        # attend deux secondes avant de...
curses.endwin()      # ...revenir à la console

L'espace pad (à préciser)

L'espace pad peut être plus grand que la fenêtre

plage= curses.newpad(200,200)
plage.addch(y,x,car,mode) "écrit" un caractère; x, y et mode facultatifs
plage.addstr(y,x,chaine,mode) "écrit" une chaîne x, y et mode facultatifs
plage.move(y,x) déplace le curseur
plage.refresh(0,0,y1,x1,y2,x2) affiche réellement les caractère écrits, requiert 6 paramètres

Saisie

fenetre.getch() saisie d'un caractère, retourne le code ascii<256
fenetre.nodelay() n'attend pas
fenetre.halfdelay(n) attend n millisecondes
fenetre.keypad(1) mode permettant à getch de récupérer un code pour les touches spéciales (flèches, fonctions...)
fenetre.keypad(0) annule cette fonctionnalité

Des constantes contiennent les codes des touches spéciales:
curses.KEY_LEFT, KEY_RIGHT, KEY_UP et KEY_DOWN; curses.KEY_F0 jusqu'à KEY_F63
curses.KEY_HOME, KEY_PREVIOUS ou KEY_PPAGE, KEY_NEXT, KEY_BACKSPACE, KEY_ENTER, KEY_PRINT, KEY_BREAK
...

[Tab] renvoie 9, [Esc]= 27, [Del]= 330, [Ins]= 331,

Modes et couleurs

Les fonctions de sorties addch et addstr utilisent le paramètre mode (facultatif): curses.A_BLINK (texte clignotant), A_BOLD (brillant), A_DIM (moins brillant), A_REVERSE (vidéo-inverse), A_STANDOUT (le plus clair), A_UNDERLINE (souligné)

Ces mêmes fonctions de sorties permettent la définition de paires de couleurs préalablement définies
curses.init_pair(1,c_texte,c_fond) définit la paire 1 pour les couleurs de texte et de fond
ecran.addstr("Texte", curses.color_pair(1)) écrit la chaîne en utilisant la paire 1

Les couleurs sont curses.COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE

Caractères semi-graphiques

Il est possible de composer des tableaux avec des lignes, croisements et coins: curses.ACS_ULCORNER, ACS_LLCORNER, ACS_URCORNER, ACS_LRCORNER, ACS_RTEE, ACS_LTEE, ACS_BTEE, ACS_TTEE, ACS_HLINE, ACS_VLINE, ACS_PLUS

PLUS= croisement, ULCORNER= coin haut/gauche, UR= haut/droit, LL= bas gauche, LR= bas droite;
Bords: TTEE= croisement de haut; BTEE= croisement de bas; LTEE= croisement de gauche; RTEE= croisement de droite;
VLINE= ligne verticale, HLINE= ligne horizontale

Il existe aussi certains caractères supplémentaires, comme curses.ACS_BULLET, ACS_DEGREE, ACS_PLMINUS

Un exemple d'utilisation (dont un tracé de tableau) sous forme de jeu de taquin

Informations complémentaires ici

4. Collections

Le module collections comporte quatre classes complétant les collections de Python: deque, OrderedDict, UserDict, UserList, defaultdict, namedtuple et counter.

4.1 Counter

Python 3: Counter dénombre les occurrences des valeurs trouvées dans une collection, sous forme d'un dictionnaire où les clés sont les valeurs d'origine et les valeurs les occurrences d'origine:

>>> import collections
>>> collections.Counter([1,3,5,4,5,2,1,1,5,4])
Counter({1: 3, 5: 3, 4: 2, 2: 1, 3: 1})

4.2 deque

Le module Double-Ended QUEue traite des listes manipulables par le début ou la fin

>>> import collections
>>> deq=collections.deque((1,2,3,4,5,6)); deq
deque([1, 2, 3, 4, 5, 6])

deq.append((6,7) ajoute un élément en queue d'objet (ici, le tuple (6,7)
deq.appendleft("ah!") ajoute un élément en début d'objet (ici, la chaîne "ah!"
deq.extend(["a","b","c"]) ajoute des éléments en queue d'objet
deq.extendleft(["z","y","x","w"]) ajoute des éléments en début d'objet

Attention: dans ce dernier cas, l'objet donne deque(['w', 'x', 'y', 'z', 1, 2, 3...])

el=deq.pop() enlève et retourne le dernier élément de l'objet
el=deq.popleft() enlève et retourne le premier élément de l'objet

deq.clear() vide l'objet de tous les éléments
deq.remove(val) enlève la première occurrence d'une valeur. ValueError: deque.remove(x): x not in deque si elle n'est pas rencontrée. Précaution:

deq=collections.deque([1,2,3,4,5,6])
if 7 in deq:
  deq.remove(7)
else:
  return None

deq.rotate(n) rotation des éléments de n rangs vers la droite. Si n est négatif, vers la gauche.

>>> import collections
>>> deq=collections.deque([1,2,3,4,5,6])
>>> deq.rotate(-2); deq
deque([3,4,5,6,1,2])

Voir ici pour les fonctions enumerate(), sorted(), reversed().

4.3 OrderedDict

Cette nouvelle classe concerne des dictionnaires qui se souviennent de l'ordre dans lequel on y a introduit les paires clé/valeur. Une redéfinition de clé laisse la paire concernée à sa place; un effacement suivi d'une réintroduction la place à la fin du dictionnaire. Il est possible d'introduire les éléments sous la forme habituelle aux dictionnaires ou de listes de paires.

>>> import collections
>>> dico=collections.OrderedDict({"c":123, "a":987}); dico
OrderedDict([('a', 987), ('c', 123)])
>>> dico[j]=456; dico
OrderedDict([('a', 4), ('c', 123), ('j', 456)])
>>> dico.update([(5,9),("f","fuji")]); dico
OrderedDict([('a', 4), ('c', 123), ('j', 456), (5, 9),("f","fuji")])

dico.pop(cle) retourne la valeur et supprime la paire clé/valeur selon la clé précisée
dico.popitem(last=True) retourne et supprime la dernière paire clé/valeur
dico.popitem(last=False) retourne et supprime la première paire clé/valeur

5. Sauvegarde des données

Ces trois modules permettent la sauvegarde, sous forme de fichiers, des objets python (chaînes, nombres, listes, tuples, dictionnaires...), et leur récupération.

5.1 pickle ou cPickle

Le module pickle permet de transformer un objet python (nombre, liste, dictionnaire...) en un format archivable sous forme de fichier-texte, et de rétablir l'objet à partir d'un tel fichier.

cPickle est la réécriture en C du module pickle pour un gain de rapidité.

Sauvegarder des variables

dumps(objet) (dumps avec s) transforme un objet-python en chaîne 'pickle':

>>>pickle.dumps({1:["oui"],3:"sdfg"})
"(dp0\nI1\n(lp1\nS'oui'\np2\nasI3\nS'sdfg'\np3\ns."

arch=pickle.Pickler(monfichier) initialise objet d'archive selon le descripteur fichier d'un fichier préalablement ouvert
arch.dump(objet) (dump sans s)sauvegarde l'objet

#! /usr/bin/python
# -*- coding: latin-1 -*-
import pickle
var=[1,[5,6],'thrs',(1,2,3,4),{1:'un',2:'deux'}]

fich=open('variable.txt','w')
pickle.dump(var,fich)
fich.close()

Récupérer des variables

loads(chaine) (loads avec s) transforme une chaîne 'pickle' en objet-python:

>>>pickle.loads("(dp0\nI1\n(lp1\nS'oui'\np2\nasI3\nS'sdfg'\np3\ns.")
{1:["oui"],3:"sdfg"}

objet=pickle.load(fich) (load sans s) récupère l'objet sauvegardé dans un fichier

#! /usr/bin/python
# -*- coding: latin-1 -*-
import pickle

fich=open('variable.txt','r')
var=pickle.load(fich)
fich.close()
print objet

5.2 anydbm

Les bases de données manipulées par anydbm sont des dictionnaires où les clés et les valeurs sont nécessairement des chaînes, et sauvegardés sous forme de fichiers.

mabase=anydbm.open('fichier','c') crée une base de données (et y permet l'écriture)
mabase['clef1']=valeur stocke une valeur sous forme de chaîne ou de variable-chaîne
mabase.close() stocke les valeurs sur le disque et ferme la base de données

Les changements effectués sur un fichier ouvert en création ou écriture ne seront pris en compte que lors de sa fermeture.

mabase=anydbm.open('fichier') ouvre une base de données en lecture seule
variable=mabase['clef1'] lit une variable selon la clé
mabase=anydbm.open('fichier','w') ouvre une base de données en écriture

#! /usr/bin/python
import anydbm

mabase=anydbm.open('fichier','c')
mabase['cle1']='Bonjour'
mabase['cle2']='tout le monde!'
mabase.close()

pour lire:

#! /usr/bin/python
import anydbm

mabase=anydbm.open('fichier','c')
for i in mabase:
  print i,mabase[i],
mabase.close()

Les bases de données du module anydbm se manipulent comme des dictionnaires:

mabase.pop('cle') retourne et supprime l'entrée indexée par 'cle'
mabase.has_key('cle') vérifie (True) que la clé existe dans la base de données
len(mabase) retourne le nombre d'enregistrements de la base de données
mabase.clear() supprime tous les enregistrements de la base de données
del mabase['clef1'] supprime une entrée selon la clé

Notes: les clés ne sont pas nécessairement inscrites dans l'ordre chronologique ou alphabétique des clés; d'autre part, les données ne sont pas stockées sur disque sous forme de ficher-texte et ne sont donc pas éditables par un éditeur de texte; enfin, la taille minimale d'un fichier anydbm est de 12 Kio.

5.3 shelve

Les autres objets (nombres, tuples, listes, objets binaires, mais éventuellement des chaînes...) sont sauvegardés avec le module shelve (les clés doivent être des chaînes). Les octets inférieurs à 32 ou supérieurs à 127 étant codés sur quatre octets (\xhh), un fichier binaire prend beaucoup de place dans un fichier shelve.

Cette base de données est un fichier, elle s'ouvre et se ferme comme un fichier:

mabase=shelve.open('nomdefichier'[,'r'])
 ...
mabase.close()

'r' pour une lecture seule d'une base de données existante, erreur si elle n'existe pas
'w' pour lecture/écriture d'une base de données existante, erreur si elle n'existe pas
'n' pour une nouvelle base de données, écrase une éventuelle base existante
'c' pour la lecture et l'écriture d'une base de données existante, la crée si elle n'existe pas

#! /usr/bin/python
# -*- coding: latin-1 -*-
import shelve

mabase=shelve.open('fichier','c')
mabase['cle1']=[2,1,9,7,[8,5,4,8],5,0]
mabase['cle2']=266
mabase['cle3']={2:456,5:789}
mabase['cle4']=(4,5,6,7,8,9)
mabase['cle5']="les chaînes sont permises"
mabase.close()

mabase=shelve.open('fichier','r')
for i in mabase:
  print mabase[i]
mabase.close()

Il est également possible d'y inclure des fichiers binaires (dans l'exemple qui suit, image.jpg doit exister, dans le répertoire courant pour cet exemple):

#! /usr/bin/python
import shelve

fichier=open('image.jpg','rb')   # rb pour lecture d'un fichier binaire
img=fichier.read() # contient le fichier binaire
fichier.close()

mabase=shelve.open('fichier','c')
mabase['cle']=img
mabase.close()

Les variables se gèrent comme des clés/valeurs des dictionnaires.

liste=mabase.keys() rassemble toutes les clés des données sauvées dans le fichier
var=mabase.pop("cle2") retourne la valeur définie par "cle2" et supprime la paire clé/valeur de mabase
if "cle3" in mabase: ou if mabase.has_key("cle3"): teste l'existence de la clé "cle3" dans mabase
len(mabase) retourne le nombre d'enregistrements de la base de données
del mabase['cle2'] supprime la paire cle2/donnée de mabase

Attention: si une variable var tirée de mabase["cle1"] est modifiée, il est nécessaire de préciser mabase["cle1"]=var avant de fermer la base de donnée pour que les modifications y soient enregistrées. Pour ne pas devoir préciser ces changements, il est possible de préciser lors de l'ouverture:
mabase=shelve.open("fichier", writeback=True)
Pour une base de données comportant beaucoup de variables, cela peut ralentir le système.

6. Internet

6.1 urllib (téléchargement)

descr=urlopen(url) ouvre tout fichier. Le descripteur permet ensuite le travail

fichier=read(descr) assigne le contenu du fichier à la variable fichier
ligne=readline(descr) assigne (une par) une ligne du contenu du fichier à la variable ligne
liste=readlines(descr) assigne chaque ligne comme élément d'une liste
descr.close() ferme le fichier

quote(chaine) remplace les caractères spéciaux par leur équivalent %xx
quote(chaine,safe="&?") permet le non-remplacement des caractères spécifiés par safe
quote_plus(chaine) idem, mais remplace les espaces par des '+' (admet également safe)
unquote(chaine) remplace les %xx par les caractères
unquote_plus(chaine) idem, mais remplace les '+' par ' '

urlencode(dictionnaire) encode une chaine de requête à partir d'un dictionnaire (ou de tuples de paires)

>>> urllib.urlencode({"val":456,"sens":"page up"})
'sens=page+up&val=456'