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)
base64,
uu,
binhex et
binascii
pour divers encodages
datatime et
calendar
fractions
htmlparser et
urllib2
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.
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
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")
sys.platform affiche la descrition 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)
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 (
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_year | année en quatre chiffres |
| time.localtime()[1] | time.localtime().tm_mon | mois de 1 à 12 |
| time.localtime()[2] | time.localtime().tm_mday | jour de 1 à 31 |
| time.localtime()[3] | time.localtime().tm_hour | nombre d'heures de 0 à 23 |
| time.localtime()[4] | time.localtime().tm_min | nombre de minutes de 0 à 59 |
| time.localtime()[5] | time.localtime().tm_sec | nombre de secondes de 0 à 61 |
| time.localtime()[6] | time.localtime().tm_wday | jour de la semaine en chiffre (lundi=0) |
| time.localtime()[7] | time.localtime().tm_yday | jour de l'année de 1 à 366 |
| time.localtime()[8] | time.localtime().tm_isdst | 1 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:
| %a | pour Mon, Tue, Wed, Thu, Fri, Sat out Sun |
| %A | pour Monday, Tuesday, Wednesday, Thursday, Friday, Saturday ou Sunday |
| %b | pour Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov ou Dec |
| %B | pour January, February, March, April, May, June, July, Augustus, September, October, November ou December |
| %c | la 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 |
| %d | le jour du mois, de 01 à 31 |
| %D | (non documenté python 2.7) voir %x |
| %H | l'heure en chiffres, de 01 à 23 |
| %I | l'heure en chiffres, de 01 à 12 |
| %p | AM ou PM |
| %P | am ou pm |
| %j | le jour de l'année, de 001 à 366 |
| %m | le mois en chiffres, de 01 à 12 |
| %M | la minute en chiffres, de 00 à 59 |
| %s | (non documenté python 2.7) empreinte temporelle sous forme de chaîne |
| %S | la 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) |
| %U | la semaine (commençant par un dimanche) en chiffre, de 00 à 53; les jours avant le premier dimanche appartiennent à la semaine 00 |
| %w | le jour de la semaine en chiffre, de 0 (dimanche) à 6 (samedi) |
| %W | la semaine (commençant par un lundi) en chiffre, de 00 à 53; les jours avant le premier lundi appartiennent à la semaine 00 |
| %x | la date selon la représentation conforme à la locale |
| %X | l'heure selon la représentation conforme à la locale |
| %y | l'année sur deux chiffres, de 00 à 99 |
| %Y | l'année sur quatre chiffres, de 1901 à 2038 |
| %z | (non documenté python 2.7, valable python 3) nombre de secondes de décalage horaire? |
| %Z | la zone horaire |
| %% | permet d'afficher le caractère % |
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
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.dir+"chemin"+os.dir+"fichier" devrait fonctionner 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
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...
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).
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 * . Par contre, avec import os, 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
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
Le sous-module os.path est automatiquement chargé avec import os on peut également le charger à part avec import os.path. Il permet un traitement extéruer des fichiers (noms, taille, chemin...) sans qu'il ne soit nécessaire de les ouvrir: on travaille sur leur nom et non sur leur descripteur.
os.path.getsize(fichier) retourne la taille (entier long)
os.path.getatime(fichier) retourne la date du dernier accès à un fichier (en nombre de secondes, voir 1.2 'time'
os.path.getmtime(fichier) retourne la date de la dernière modification d'un fichier (idem)
os.path.split(cheminfichier) retourne un tuple avec la gauche et la droite du dernier séparateur de répertoire
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 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.splitext(fichier) retourne un tuple avec l'adresse sans l'extension et l'extension
if os.path.exists(fichier): TRUE si le fichier existe
if os.path.isfile(fichier): TRUE si l'objet est un fichier
if os.path.isdir(fichier): TRUE si l'objet est un répertoire
if os.path.islink(fichier): TRUE si l'objet est un lien
if os.path.ismount(chemin): TRUE si le répertoir est un point de montage
if os.path.isabs(fichier): TRUE si le nom du fichier comporte le chemin complet
os.path.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.
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) permet des réponses dans les quatres quadrants selon les signes respectifs de y et 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"
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()
Le module random regroupe des fonctions de hasard et probabilités.
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.seed(n) (ré-)initialise le générateur de nombres pseudo-aléatoires
Note: le module whrandom possède également ces premières fonctions; seed y accepte jusqu'à trois paramètres.
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
random.BPF, random.LOG4, random.NV_MAGICCONST, random.SG_MAGICCONST et random.TWOPI sont les variables disponibles.
decimal (nouveauté python 2.3) permet de traiter les nombres 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
print decimal.Decimal(1) % decimal.Decimal(".1") # donne Decimal("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".
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 qu'un 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 un 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.
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","iso-8859-15","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'
éà
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.
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
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(...)
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)
(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...
. 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: ( ) [ ] { } . $ ^ | ? + * \
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.
\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
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')
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 de la console). Attention au préfixage des paramètres avec curses.
Sous Windows, on peut par exemple télécharger WCurses.zip et copier tout le répertoire "curses\" décompressé parmi les librairies de python (par exemple dans le répertoire C:\python26\Lib).
Information officielle par ordre alphabétique (.en)
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
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).
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: iso-8859-15 -*-
"""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 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
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,
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
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
Le module collections comporte quatre classes complétant les collections de Python: deque, OrderedDict, UserDict, UserList, defaultdict, namedtuple et 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:
>>> collections.Counter([1,3,5,4,5,2,1,1,5,4])
Counter({1: 3, 5: 3, 4: 2, 2: 1, 3: 1})
Le module Double-Ended QUEue traite des listes manipulables par le début ou la fin
deq=collections.deque((1,2,3,4,5,6)) initialise une variable deque
>>> deq deque([1, 2, 3, 4, 5, 6])
deq.append(el) ajoute un élément en queue d'objet
deq.appendleft(el) ajoute un élément en début d'objet
deq.extend([a,b,c]) ajoute des éléments en queue d'objet
deq.extendleft([a,b,c]) ajoute des éléments en début d'objet
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.
>>> 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().
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 forme de dictionnaires ou de listes de paires.
>>> a=collections.OrderedDict({"c":123, "a":987}); a
OrderedDict([('a', 4), ('h', 6)])
>>> a.update({"j":456}); a
OrderedDict([('a', 4), ('h', 6), ('j', 456)])
>>> a.update([(5,9)]); a
OrderedDict([('a', 4), ('h', 6), ('j', 456), (5, 9)])
a.pop(cle) retourne la valeur et supprime la paire clé/valeur selon la clé précisée
a.popitem(last=True) retourne et supprime la dernière paire clé/valeur
a.popitem(last=False) retourne et supprime la première paire clé/valeur
Ces trois modules permettent la sauvegarde, sous forme de fichiers, des objets python (chaînes, nombres, listes, tuples, dictionnaires...), et leur récupération.
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é.
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()
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
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.
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.
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'