Modules internes du langage python - www.jchr.be

CERTAINES fonctions basiques ne figurent pas parmi les instructions de python, mais sont disponibles dans des bibliothèques, ensemble de fonctions spécialisée. Cette page présente quelques modules importants, et internes au langage, c’est-à-dire qu’ils sont installés en même temps que python, à une adresse qui ressemble à /usr/lib/python3/dist-packages/

Cette page ne prétend aucunement à l’exhaustivité.

Attention : n’appelez jamais un script du nom d’un module à importer, il s’importerait lui-même.

Autres modules (.en)

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

Quelques modules externes : TKinter - numpy (brève présentation) – personnels : ECMA-48 (print at, color) - (Nv 2022.08) v2f (stockage de variables dans des fichiers)

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.methode() la méthode 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 methode charge une méthode précise du module, qui ne devra plus être préfixée
from module import * charge toutes les méthodes 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.

del module décharge un module. Attention : tout importation de module fabrique le compile sous l’extension .pyc, dans le sous-répertoire __pycache__. C’est ce fichier sous forme compilée qui sera ensuite chargé.

Pour réellement réimporter le module mon_module, par exemple lors d’une mise au point en mode console :

import importlib  # à ne faire qu’une fois par session python3
importlib.reload(mon_module)

Rappel : Ne nommez jamais un script du nom d’un module à importer : avant d’aller chercher à l’adresse /usr/lib/python3.9, python cherche d’abord le module du même nom + .py dans le répertoire courant, et le script s’importerait lui-même. Si cela est arrivé, il ne suffit pas de changer le nom du script, il faut également supprimer le fichier .pyc qui a été généré lors de l’appel au module.

Informations sur les modules et ses méthodes :

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

À partir de la console (bash), il est possible de sauvegarder dans un fichier les informations sur un module, par exemple cmath :

python3 -c "import cmath ; help("cmath")" > cmath.txt

Sous-modules

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

>>> import os
>>> os.path.split("/home/toto/site/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/site/index.htm")

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

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

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

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

1. Système

1.1 sys (système)

Voir les généralités concernant les modules.

sys.platform affiche la description du système d’exploitation
sys.version affiche la version de python et du compilateur C
sys.version_info affiche la version de python en cinq éléments : majeure, mineure, micro, "finale" et série
hex(sys.hexversion) affiche la version en hexadécimal : '0x30b02f0'
sys.copyright affiche le copyright
sys.path renvoie une liste des chemins d’accès de python (/usr/lib/python3.11…)
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)

À l’intérieur d’un script, pour déterminer le chemin du répertoire où se situe ce script lancé par un double clic :

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

Note : pour les systèmes où les répertoires sont séparés par un autre caractère que /, utiliser cet autre caractère. Pour Microsoft en particulier, utiliser \\, un simple \ étant à l’intérieur d’une chaîne en python un caractère d’échappement (\n, \t, \x…).

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)

var =sys.intern(chaine) permet d’inscrire une chaîne dans une variable interne (à confirmer) ; serait utile pour des raisons de rapidité

1.2 time (temps) ^{Rév. 2024.02}

Voir les généralités concernant les modules.

Dans la plupart des fonctions qui suivent, l’empreinte temporelle 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(r) marque une pause du programme pendant r secondes

ts =time.time() retourne l’empreinte temporelle du présent sous forme de réel.

Pour mesurer des temps d’exécution en vue d’optimiser des routines, il est préférable d’utiliser une des deux fonctions suivantes, qui ne tiennent pas compte des interruptions du système ni de sleep() :

time.thread_time() retourne une empreinte pour le thread en cours ; le nombre renvoyé n’a pas de sens en soi, c’est la différence entre deux appels successifs à la fonction qui a une signification
time.process_time() retourne une empreinte pour le processus en cours ; même remarque. Par exemple :

import time
e =time.time()
t =time.thread_time()
p =time.process_time()
time.sleep(1)
for i in range(100000000) :
  pass

print(time.time() -e)
print(time.thread_time() -t)
print(time.process_time() -p)

produit, selon le système utilisé :

5.5459654331207275
4.544903786999981
4.544953555999996

Notes :

• «thread» et «processus» sont des notions subtiles qui peuvent varier d’un environnement à l’autre. Je ne me risquerai pas à tenter de les définir
• clock() n’existe plus
• voir également timeit

Conversions empreinte / chaînes

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 méthodes sont accessibles par l’index ([0]…), ou par les attributs (tm_year) de classe du tuple :

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) la façon la plus simple de produire une date lisible par un humain à partir du moment présent ou d’un tuple de date si précisé. "format" peut contenir :

En python 2.7, les formatages %C, %D, %s, %u et %z sont valables, sans être documentés.

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=12, tm_mday=25, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=360, 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 permet de lister les zones horaires, tant sous la forme de Europe/Luxembourg que CET (installer le paquet python3-tz) :

import pytz
for i in pytz.all_timezones :
  print(i)

timeit ^{Nv. 2015.01}

Voir les généralités concernant les modules.

Pour tester la rapidité d’une fonction avec la ligne de commande suivante (en UNIX, du moins). L’option -m permet de charger le module, s de définir les chaînes, entre guillemets, sans oublier les éventuelles indentations. Les commandes sont réitérées un nombre suffisant de fois (une puissance de 10) pour atteindre un certain temps, et de tests, le plus rapide est retourné :

$ python3 -m timeit -s "a='azerty'" "a=a[1:]+a[0]"
2000000 loops, best of 5: 149 nsec per loop

-n x fixe à x le nombre de réitérations des commandes (sinon variable)
-r 5 porte à 5 le nombre de tests
-s introduit une chaîne pour une commande à ne faire qu’une fois
-p comportement de time.process() de time
-t comportement de time.time()
-c (?) anciennement clock()

1.3 os (système d’exploitation)

Voir les généralités concernant les modules.

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 (ici en lecture). L’exemple qui suit liste le répertoire courant en Unix :

import os
repertoire =os.popen("ls -l").read()
print(repertoire)

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 GNU/Linux : <module 'posixpath' from '/usr/lib/python3.9/posixpath.py'>
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/python3
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. 0o754 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 python2, un nombre octal commence par 0 (zéro), 0o est néanmoins accepté pour Python 2.6 et 2.7

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 : os.SEEK_SET (ou 0 : à partir du début), os.SEEK_CUR (ou 1, à partir de la position courante), os.SEEK_END (ou 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, permet également de déplacer un fichier :

os.rename("aaa","Bureau/aaa")

Gestion des répertoires

os.getcwd() renvoie le répertoire courant connu du système. Si un script est appelé par l’interface graphique (et que le module sys est importé), il est préférable d’utiliser os.path.dirname(sys.argv[0]), 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(os.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

os.link(fichier, lien) établit un lien matériel, en fait un autre nom pour le même fichier
os.symlink(fichier, lien) établit un lien symbolique (une redirection vers un fichier)
os.readlink(lien) retourne le fichier pointé par le lien symbolique (pas un lien matériel, qui est un vrai nom de ficher)

Pour la différence entre liens matériels et symboliques, voir cette page

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) ajoute /home/toto pour l’utilisateur totoà toute 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 symbolique, un lien matériel renvoie False
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 méthodes du sous-module os.path

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

Module glob ^2015.08.30

Lorsqu’on dispose a priori du répertoire dans lequel cherche un ensemble de fichier, il est possible d’utiliser le module glob, duquel la méthode glob renvoie une liste et iglob un générateur, à partir d’un canevas comprenant les jokers ? (caractère isolé) et * (chaîne de 0, un ou plusieurs caractères) :

#! /usr/bin/python3
import glob
for i in glob.glob("images/G?????e*.jp*") :
  print(i)

retourne Galaxies.jpg et Gutenberg.jpeg si ces deux fichiers se trouvent dans le répertoire images : ils répondent à G·····e[ ].jp[ ] ([ ] symbolise un nombre indéfini de caractère(s), éventuellement aucun). galaxies.jpg ne serait pas valable, à cause du g initial minuscule.

2. Nombres

2.1 (c)math (mathématique)

Voir les généralités concernant les modules.

Voir Opérateurs basiques.

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

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

Attention : int(-2.3) retourne -2, tandis que math.floor(-2.3) retourne -3.

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.copysign(a,b) retourne la valeur de a munie du signe de b (positif si b==0)

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)

cmath

Le module cmath reprend la plupart des méthodes 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)

Voir les généralités concernant les modules.

Le module random regroupe des méthodes 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 (différents) choisis d’une liste
random.shuffle(liste) mélange les éléments d’une liste, en modifiant directement la variable :

>>> liste =[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(liste)
>>> liste

random.randint(borne1,borne2) renvoie un entier au hasard entre deux bornes (incluses) ; préférer le suivant
random.randrange(borne) renvoie un entier entre 0 (inclus) et la borne (exclue)
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

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 méthodes 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

Voir les généralités concernant les modules.

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

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

decimal.setcontext(decimal.ExtendedContext) permet

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

decimal.getcontext().prec = n permet de décider de la précision des «réels» :

>>> import decimal
>>> decimal.Decimal(1) /decimal.Decimal(7)
Decimal("0.1428571428571428571428571429") # 28 chiffres significatifs par défaut
>>> decimal.getcontext().prec =43
>>> decimal.Decimal(1) /decimal.Decimal(7)
Decimal("0.1428571428571428571428571428571428571428571")

Essai jusqu’à 25 000 décimales. Attention cependant : certaines fonctions, telle que complex(), reviennent à la précision par défaut de 16 ou 17 décimales pour la mantisse.

2.4 fractions

Voir les généralités concernant les modules.

import fractions # avec s!

f =fractions.Fraction(1 /7) convertit un «réel» en objet comprenant le numérateur et le dénominateur :

• f.numerator contient le numérateur de la fraction
• f.denominator contient le dénominateur de la fraction

>>> import decimal, fractions
>>> fractions.Fraction(1/7)
Fraction(2573485501354569, 18014398509481984)
>>> fractions.Fraction(decimal.Decimal(1) / decimal.Decimal(7))
Fraction(1428571428571428571428571429, 10000000000000000000000000000)

3. Chaînes

3.1 str et string

Voir les généralités concernant les modules.

Voir également chaîne dans le manuel sur python3 -- Révision le 2024.05.08

Le module str est interne à python3 et ne soit pas être importé. Les objets str (c’est-à-dire les chaîne) peuvent être traités de deux façons, en utilisant la forme variable.methode(params) ou str.methode(variable, params) :

>>> "spam".upper()
'SPAM'
>>> str.upper("spam")
'SPAM'

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 : ch2 =chaine.methode(), voire chaine =chaine.methode().

Dans les exemples suivants, la chaîne se présente sous la variable ch.

Casse

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

Note : les minuscules et majuscules de tous les alphabets les distinguant sont concernées, en ce compris les lettres accentuées (Unicode seulement ?) :

>>> "ὼçбų".upper()
'ῺÇБŲ'

Découpe et assemblage

ch.split() renvoie une liste de tous les mots (séparation : l’espace) d’une chaîne-phrase
ch.split(". ") le séparateur peut être une chaîne autre que l’espace
ch.split(" ", n) on peut limiter le nombre de séparations effectuées

ch.rsplit("/", n) permet de séparer une chaîne en commençant par la fin. Cet exemple permet de séparer un fichier du chemin :

>>> "/home/toto/musique/AlertezLesBebes.ogg".rsplit("/", 1)
['/home/toto/musique', 'AlertezLesBebes.ogg']

" ".join(liste) concaténation d’une liste (ou tuple) de chaînes (le liant est ici l’espace)

Note : les clés d’un dictionnaire ou les éléments d’un ensemble peuvent également être concaténés à condition qu’ils soient tous caractères ou chaînes, mais sans ordre.

Épluchage

ch.strip() ôte tout type d’espace (voir string.whitespace) en début et fin de chaîne
ch.lstrip() ôtent les espaces (ou autres caractères si précisés) en début de chaîne
ch.rstrip() ôtent les espaces (ou autres caractères si précisés) en fin de chaîne

ch.strip(chars), ch.lstrip(chars) et ch.rstrip(chars) ôte les caractères précisés dans la chaîne chars

Il est donc possible de conserver certains types d’espaces en précisant lesquels enlever :

>>> " \neggs !\t ".strip(" \n")
'eggs !\t'

Remplissage

ch.ljust(n) remplit d’espaces à gauche pour que la chaîne fasse n caractères
ch.rjust(n) remplit d’espaces à droite pour que la chaîne fasse n caractères
ch.center(n) entoure la chaîne d’espaces pour qu’elle fasse n caractères

ch.zfill(n) ajoute des 0 à gauche pour que la chaîne fasse n caractères

ch.ljust(n, char), ch.rjust(n, char) et ch.center(n, char) permettent de remplacer l’espace par un caractère

ch.expandtabs(n) transforme les tabulations en espaces (mesure de 8 par défaut) :

>>> "\t1\t12345\t1".expandtabs(4)
'    1   12345   1'

Comptage et recherche de caratères

ch.count(ssch, debut, fin) compte les occurrences de la sous-chaîne dans la chaîne, éventuellement entre deux positions
ch.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
ch.find(ssch, debut) renvoie la première position d’une sous-chaîne dans une ch, en définissant les positions de début
ch.find(ssch, debut, fin) idem, définissant en plus la position de fin (non incluse : 4 pour permettre la position 3)
ch.rfind(ssch,debut,fin) pareil, mais en commençant par la fin

ch.startswith("pref") renvoie True si la chaîne commence par le prefixe
ch.endswith("xyz") renvoie True si la chaîne termine par xyz

Remplacements de caractères

ch.replace(ssch1,ssch2) remplace, si elle existe, une sous-chaîne par une autre
ch.replace(ssch1,ssch2, n) idem, en limitant le nombre de remplacement à n

Pour remplacer plusieurs caractères en une fois (module chargé avec import str) :

>>> rempl=str.maketrans("abc", "123")
>>> "abracadabra".translate(rempl)
'12r131d12r1'

• str.maketrans(ch1, ch2) définit un protocole de remplacement pour translate (a par 1, b par 2...)
• translate(rempl) assigne les remplacements définis à la chaîne abracadabra

Le résultat de str.maketrans("abc", "123") étant un dictionnaire des rangs unicodes des caractères (en l’occurrence {97: 49, 98: 50, 99: 51}), il est possible de créer à la main le protocole de remplacement en utilisant les rangs unicode. C’est fastidieux mais nécessaire pour préciser qu’un caractère doit disparaître, en lui associant None. Le plus simple est de définir la formule de remplacement des caractères à remplacer puis de lui ajouter (avec update()!) le·s caractère·s à faire disparaître :

>>> rempl =str.maketrans("ac", "13")
>>> rempl.update({ord("d"): None})
>>> "abcde".translate(rempl)
'1b3e'

En python 2, il était possible d’ôter des lettres en définissant comme second argument la chaîne des caractères à faire disparaître ; dans ce cas, la suppression avait lieu avant le remplacement :

>>> rempl =str.maketrans("abc", "123")
>>> "abxcydze".translate(rempl, "xyz")
'123de'

Tests de chaînes

ch.isdigit() renvoie True si la chaîne n’est constituée que de chiffres
ch.isalpha() renvoie True si la chaîne n’est constituée que de lettres (éventuellement accentuées, mais sans espace)
ch.isalnum() renvoie True si la chaîne est alphanumérique
ch.islower() renvoie True si la chaîne n’est constituée que de minuscules
ch.isupper() renvoie True si la chaîne n’est constituée que de majuscules
ch.istitle() renvoie True si chaque début de mot est en majuscule
ch.isspace() renvoie True si la chaîne est constituée d’espaces, tabulations \t (\x09), fins de ligne \n (\x0a), retour-chariots \r (\x0d), \v (\x0b) ou \f (\x0c)

En python2, ce module possédait les méthodes de conversions de chaînes en nombres string.atoi(), string.atol() et string.atof(), qui doublaient les méthodes internes int(), long() et float(), voir Variables numériques. Notez que long() n’existe plus en python3, tous les entiers étant «longs».

string

Le module string contient une série de constantes (import string au préalable) :

string.ascii_letters : 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
string.ascii_lowercase : 'abcdefghijklmnopqrstuvwxyz'
string.ascii_uppercase : 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
string.digits : '0123456789'
string.hexdigits : '0123456789abcdefABCDEF'
string.octdigits : '01234567'
string.punctuation : '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
string.whitespace : ' \t\n\r\x0b\x0c'
string.printable : la somme de toutes les précédentes

Note :

• dans string.punctuation, \\ code pour la barre inverse \, \' pour le guillemet simple '
• dans string.whitespace, \x0b code pour \v, \x0c pour \f

En python2, les trois premières avaient un autre nom : string.letters, string.lowercase et string.uppercase.

string.capwords() transforme la première lettre de chaque mot en majuscule, ce qui correspond à title() du module str.

3.2 Chaîne Unicode

Voir les généralités concernant les modules.

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", "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 les généralités concernant les modules.

Rév. python3 2020.12.28

import re importe le module permettant les expressions régulières

Les expressions rationnelles, ou expressions régulières, décrivent une multiplicité de chaînes à partir d’un ensemble de règles. L’ensemble de règles que l’on donne est appelé motif (pattern), par exemple [A-Z]{3}5 pour trois majuscules latines non accentuées suivies du chiffre 5, soit 26 **3 =17 576 chaînes différentes. Ce motif permet des comparaisons, des recherches ou remplacements dans une chaîne, ou un éclatement d’une chaîne selon un séparateur…

Note : les expressions rationnelles ne sont pas universelles, chaque langage pouvant utiliser ses propres variantes ; voir également les expressions régulières en R, pour Libreoffice et les recherches de fichiers dans l’environnement Mate-Desktop.

Codages de caractères

. désigne n’importe quel caractère sauf un retour-chariot (fin de ligne volontaire)
\d désigne un chiffre; équivaut à [0-9]
\D désigne un caractère sauf les chiffres
\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 page, nouvelle ligne)
\S désigne un caractère non espace tels que défini à la ligne précédente
\b désigne le backspace (0x08), mais seulement dans un intervalle

[ ] définit un seul caractère par une succession de caractères possibles, selon des intervalles et des exclusions :

• [a-dgr0-5] permet les minuscules a à d , les minuscules g et r ainsi que les chiffres de 0 à 5
• ^ exclut un ou plusieurs caractère·s : [^F-K] exclut les majuscules de F à K
  
• . désigne, entre [ ], uniquement le point
• "[\\\]" désigne, entre [ ], le caractère \
• [A-Za-z] ne suffit pas pour toutes les lettres sans les chiffres : il manque les accentuées ; il faut utiliser [^0-9,.:;!?«» \t\n\v\f\r]

Groupements et quantifications

() permet de traiter un groupe de caractères ou un choix
| permet un choix entre plusieurs (ensembles de) caractères : (so|siè)cle représente socle ou siècle ; (a|p)m équivaut à [ap]m

? 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 (inclu) 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 : ( ) [ ] { } . $ ^ | ? + * \ : \(, \), \+, \\… pour rechercher les signes ( ) + \

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

import re doit figurer au début du script, ou avoir été validé dans une console python.

match renvoie un objet <re.Match> qui a valeur booléenne (True ou False) pour la comparaison stricte d’un motif et d’une chaîne :

import re
rep =re.match("[A-Z]{4}\d+", "BCDE123")
if rep: print("La chaîne correspond entièrement à l’expression régulière")

search(motif, chaine) permet de savoir si un motif se retrouvent au moins une fois dans une chaîne, rep.group() contient la première occurrence trouvée

import re
rep =re.search("[A-Z]{2}", "BC000D-E77cFGI")
if rep : print(rep.group()) # un groupe de deux majuscules est bien inclu dans "aBCDE123"

sub(motif, rempl, chaine[, n]) permet des substitutions dans une chaîne, avec une éventuelle limite d’occurrence : la chaîne transformée est disponible

>>> import re
>>> rep =re.sub("[a-z]{2}", "-", "AbCde002ft3") # tout couple de minuscule >>> non accentuée sera remplacé par un tiret
>>> print(rep)
'AbC-002-3'

subn idem, limite le nommbre de remplacement possibles effectués) :

>>> import re
>>> rep =re.sub("[a-z]{2}", "-", "AbCde002ft3", 1)
>>> print(rep)
'AbC-002ft3'

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

>>>print(re.split("\d{2}", "ab92cde14fg")) # le séparateur est ici toute chaîne de deux chiffres
['ab', 'cde', 'fg']

Compilation de motif

il est possible de compiler préalablement le motif, pour ensuite l’utiliser en préfixe des méthodes décrites ci-dessus :

>>> motif =re.compile("\d{2}")
>>> print(motif.split("ab92cde14fg"))
['ab', 'cde', 'fg']

Motif frugal (non greedy)

Les quantifiants ?, +, * et {} rendent un motif «frugal» s’ils sont suivi d’un ? :

>>> print(re.split("a\w*Z", "---a1Z2aZa3Z==="))
['---', '===']
>>> print(re.split("a\w*?Z", "---a1Z2aZa3Z==="))
['---', '2', '', '===']

La première forme est gourmande (greedy) car le motif opte pour la plus grande suite de lettres ou chiffres entre a et Z : a1Z2aZa3Z. La liste des morceaux de chaîne qui en résulte est ['---', '==='].

La seconde forme est frugale (non greedy) car le motif produit les chaînes de découpe a1Z, aZ et a3Z, éclatant la chaîne en une liste plus longue : ['---', '2', '', '==='] ('' est la chaîne vide située entre aZ et a3Z).

3.4 curses (print at, couleurs)

Voir les généralités concernant les modules.

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 méthodes 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/python3
"""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

3.5 locale

Voir les généralités concernant les modules.

Ce module s’occupe de conformer certains résultats à la façon dont on écrit les nombres ou trie les noms, en tenant compte par exemple des accents en français. Après l’importation du module, il faut appeler la locale par défaut (supposition sera faite que la locale du système d’exploitation est francophone) :

>>> locale.setlocale(locale.LC_ALL, "")

locale.str(3.14) transforme un nombre «réel» en chaîne francophone : 3,14
locale.atof("3,14") transforme une chaîne numérique francophone : 3.14

locale.currency(1056, symbol=True, grouping=True) donne '1.056,00 €' (international=True pour EUR plutôt que €)

locale.getlocale() et locale.getdefaultlocale(envvars=("LC_ALL", "LC_CTYPE", "LANG", "LANGUAGE")) renvoient par exemple ('fr_BE', 'UTF-8')

Ce module permet le tri naturel d’un ensemble de chaînes :

>>> import locale
>>> locale.setlocale(locale.LC_ALL, "")
>>> sorted(["C", "e", "â", "sa", "s b" ], key=locale.strxfrm)
['â', 'C', 'e', 'sa', 's b']

Plus d’informations avec help(locale)

4. Collections

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

4.1 deque

Voir les généralités concernant les modules.

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 le manuel pour les fonctions enumerate(), sorted(), reversed().

4.2 Counter

Voir les généralités concernant les modules.

Cette collection a été intégrée dans Python2.7 (module collections).

Counter dénombre les occurrences des valeurs trouvées dans une collection, sous forme d’un dictionnaire où les clés sont les valeurs rencontrées et les valeurs le nombre de fois où les valeurs ont été trouvées :

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

4.3 OrderedDict

Voir les généralités concernant les modules.

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

Cette collection a été intégrée dans Python 2.7 (module collections).

4.4 tri avec icu ^{Ajout 2017.03}

Voir les généralités concernant les modules.

Il faut d’abord installer sur votre système le module python3-icu (python-pyicu en python2) selon votre version de python. Dans votre script, le module est importé dans les deux cas avec :

import icu

Il faut ensuite indiquer la locale désirée :

coll =icu.Collator.createInstance(icu.Locale("fr_FR.UTF-8"))

…puis utiliser cette méthode avec sorted() :

litri =sorted(["a", "z", "œ", "é"], key=coll.getSortKey)
print(litri)

Note : ne jamais oublier de récupérer la liste triée dans une variable, sorted() ne triant pas la liste elle-même :

li =["a", "z", "œ", "é"]
litri =sorted(li, key=coll.getSortKey)
print(li, litri)

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

Voir les généralités concernant les modules.

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"})
b'\x80\x03}q\x00(K\x01]q\x01X\x03\x00\x00\x00ouiq\x02aK\x03X\x04\x00\x00\x00sdfgq\x03u.'

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

Cela semble pourtant plus simple :

#! /usr/bin/python3
import pickle
var =[{1:"un",2:"deux"},1,[5,6],"thrs",(1,2,3,4)]

with open("variable.bin","wb") as fd :
  pickle.dump(var, fd)

Récupérer des variables

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

>>>pickle.loads(b'\x80\x03}q\x00(K\x01]q\x01X\x03\x00\x00\x00ouiq\x02aK\x03X\x04\x00\x00\x00sdfgq\x03u.')
{1:["oui"], 3:"sdfg"}

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

#! /usr/bin/python3
import pickle

with open("variable.bin","rb") as fd :
  objet =pickle.load(fd)
print(objet)

5.2 anydbm (pour mémoire)

Voir les généralités concernant les modules.

Ce module n’existe plus sous python3, mais y est remplacé par dbm.

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

mabase =dbm.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.

#! /usr/bin/python3
import dbm

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

mabase =dbm.open("fichier") ouvre une base de données en lecture seule
mabase =dbm.open("fichier","w") ouvre une base de données en écriture
variable =mabase["clef1"] lit une variable selon la clé (c’était le cas sous anybdm)

#! /usr/bin/python3
import dbm
mabase =dbm.open("fichier","c")
print(mabase["cle1"])
mabase.close()

Les bases de données du module dbm sont censées se manipuler comme des dictionnaires (c’était le cas pour anybdm sous python2), mais un message d’erreur prévient qu’un objet dbm n’est pas itérable.

TypeError: '_dbm.dbm' object is not iterable

Il s’agit pourtant bien d’une collection ayant une longueur (len(mabase)), mais mabase.has_key("cle") prévient que

AttributeError: '_dbm.dbm' object has no attribute 'has_key'

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

Voir les généralités concernant les modules.

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/python3
import shelve

mabase =shelve.open("fichier", "c") # l’extension ".db" est ajoutée
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/python3
import shelve

fichier =open("fondnoir.png","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

for i in mabase :
  print(i)
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 urllib3 (téléchargement)

Voir les généralités concernant les modules.

Concernait auparavant urllib -- révu le 2023.10.17

Le module urllib3 doivent être installé (existe en Debian sous le nom python3-urllib. Il est indispensable de l’importer. La séquence qui suit devrait permettre de charger une page Internet.

import urllib3
conn =urllib3.PoolManager()
requete =conn.request("GET", "http://debian.org/")
bytxt =requete.data
print(bytxt)

Les données sont renvoyées sous forme d’objet bytes même pour une page HTML (au format texte). La transformation en chaîne se fait avec ch =bytxt.decode(codage), codage devant correspondre au type d’encodage de la page, le plus souvent en UTF-8 mais pas toujours. Il faut donc repérer la codification sur la page, qui ressemble à une des deux lignes ci-dessous et est situé entre <head> et </head> :

<meta charset="utf-8">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">