Modules internes du langage python

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 suit les recommandations de 1990 pour une orthographe réformée.

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

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.13, 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.maxsize renvoie le format du plus grand nombre entier
sys.maxunicode renvoie le plus haut point de code
sys.exit() pour quitter le programme (ou le shell)

sys.argv est la liste des paramètres passés dans la ligne de commande :

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 chaine en python un caractère d’échappement (\n, \t, \x…). Voir également os.sep

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 chaine 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 jusqu’à sept décimales.

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 / chaines

time.ctime(ts) convertit une empreinte temporelle ou à défaut, le temps présent, en chaine "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() renvoie un objet structuré contenant, à partir de l'empreinte temporelle précisée, ou à défault le moment présent, du fuseau horaire connu du système (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.struct_time(tm_year=2026, tm_mon=3, tm_mday=9, tm_hour=18, tm_min=6, tm_sec=50, tm_wday=0, tm_yday=68, tm_isdst=0)

time.gmtime() renvoie un objet structuré contenant, à partir de l'empreinte temporelle précisée, ou à défault le moment présent, du temps universel (UT, ex-GMT) : (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 de l'objet renvoyé par ces deux méthodes sont accessibles par

• l’index ([0]…) : ts =time.localtime() ; ts[0] contient l'année
• l'attribut : ts =time.localtime() ; ts.tm_hour contient l'heure

Notes:

• le tuple renvoie des entiers, à convertir avec str(var), "%d" %var ou f"{var}" pour l’affichage
• pour ajouter un 0 avant une minute ou une seconde en un chiffre : "%02d" %var ou f"{entier:02d}"

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

time.strftime("format", tup) la façon la plus simple de produire une date lisible par un humain à partir du moment présent.

instant =time.strftime("%Y.%m.%d-%H:%M:%S") # donne qch comme '2026.03.09-16:53:03'

Il est possible d'utiliser 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 chaine à 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 chaines, 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 10 porte à 10 le nombre de tests
-s introduit une chaine 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")
res =os.system() retourne dans res la valeur de retour de la commande-système (0 si tout va bien selon la norme POSIX)

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 retourne le nom du système – UN*X : posix ; nt, os2, mac, ce, riscos…
os.path GNU/Linux : <module 'posixpath' (frozen)>
os.curdir répertoire actuel. UN*X et Win : . , Mac : :
os.pardir répertoire parent. UN*X et Win : .. , Mac <=9 : ::
os.sep séparateur de répertoire - UN*X : /, Win : \, Mac <=9 : :

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. Attention toutefois que le script pourrait utiliser un encodage différent de celui du système du fichier.

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 *, par exemple avec open().

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 chaine de n octets du contenu d’un fichier ouvert en 0 ou 1
os.write(descr,chaine) écrit une chaine 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 chaine 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 pathlib

Le module pathlib est un module interne qui reprend une partie de os.path de façon orientée-objet.

import pathlib

pathlib.Path(chaine) transforme une chaine en objet fichier. À partir de ce moment, l'objet fichier est sensible aux méthodes suivantes :

fichier.read_text(encoding="utf-8") charge le fichier texte selon son encodage
fichier.write_text(montexte, encoding="utf-8") sauvegarde le texte

monfichier.is_file() retourne True si monfichier existe et est un fichier (et non un répertoire)
monrep.is_dir() retourne True si monrep existe et est un répertoir (et non un fichier)

fichier.stem contient le nom sans l'extension
fichier.suffix contient l'extension du nom du fichier

1.4 glob

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, filtrée à partir d’un canevas comprenant les jokers ? (caractère isolé) et * (chaine 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 caractère et (…) un nombre indéfini de caractère(s), éventuellement aucun). galaxies.jpg ne serait pas valable, à cause du g initial minuscule.

1.5 psutil

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

CPU

psutil.cpu_times() renvoie un l'objet scputimes(user=266909.43, nice=97.32, system=95968.01, idle=1318232.21, iowait=9160.04, irq=0.0, softirq=4368.22, steal=0.0, guest=0.0, guest_nice=0.0) ; il est possible d'extraire les données par décalage ou tranche, ou par attribut :

>>> psutil.cpu_times()[1]
97.32
>>> psutil.cpu_times()[2:4]
(95968.01, 1318232.21)
>>> psutil.cpu_times().idle
1318232.21

Note : si vous en avez besoin, vous savez ce dont il s'agit.

psutil.cpu_percent() donne le pourcentage de charge de travail des CPU (interval donne le délai d'attente entre deux mesures, percpu=True donne le détail de chaque CPU) :

>>> for i in range(5) : psutil.cpu_percent(interval=0.5)
15.4
15.4
16.7
20.0
15.0
>>> for i in range(5) : psutil.cpu_percent(interval=0.5, percpu=True)
[14.3, 9.1, 13.3, 5.1]
[5.2, 12.1, 10.0, 21.0]
[10.3, 13.1, 13.4, 8.1]
[14.4, 11.1, 7.0, 15.3]
[4.1, 11.1, 10.2, 25.0]

Mémoire et disques

psutil.virtual_memory() renvoie un objet indiquant les paramètres de la mémoire ; chaque indicateur est interrogeable séparément selon ce qui indiqué pour psutil.cpu_times(). Il s'agit bien de la mémoire vive (virtuel me semble prêter à confusion).

>>> psutil.virtual_memory()
svmem(total=8208707584, available=5741068288, percent=30.1, used=1533108224, free=1483874304, active=2336067584, inactive=2463657984, buffers=289820672, cached=4901904384, shared=781352960, slab=1145671680)

psutil.swap_memory() interroge les paramètres de la mémoire SWAP :

>>> psutil.swap_memory()
sswap(total=7998533632, used=248856576, free=7749677056, percent=3.1, sin=332992512, sout=1501429760)

psutil.disk_partitions() renvoie une liste d'objets, un par partitition accessible au système. sdisk signifie probablement SCSI-disk, rotational devrait remplacer ssd en cas d'ancien disque dur. Il s'agit d'un résumé de /etc/fstab sans la SWAP.

>>> psutil.disk_partitions()
[sdiskpart(device='/dev/sda2', mountpoint='/', fstype='btrfs', opts='rw,relatime,ssd,discard=async,space_cache=v2,subvolid=256,subvol=/@rootfs'), sdiskpart(device='/dev/sda4', mountpoint='/plus', fstype='ext4', opts='rw,relatime'), sdiskpart(device='/dev/sda3', mountpoint='/home', fstype='btrfs', opts='rw,relatime')]

Processus

psutil.pids() renvoie la liste des tous les identifiants de processus en cours

psutil.Process(282720) renvoie les informations sur le processus 282720

>>> psutil.Process(282720)
psutil.Process(pid=282720, name='kworker/u17:2', status='idle', started='22:14:55')

D'autres attributs sont interrogeables : psutil.Process(58486).exe(), cwd(), cmdline(), ppid(), parent(), children(), status()...

Senseurs

psutil.sensors_temperatures(), psutil.sensors_fans(), psutil.sensors_battery()

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

2.5 num2words

Nv 2024.12.13 - Voir les généralités concernant les modules.

Permet de traduire les nombres en mots pour les langues suivantes : ar, cz, de, dk, en, es, fi, fr, he, id, it, ja, kn, ko, lt, lv, nl, no, pl, pt, ro, ru, sl, sr (croate), th, tr, uk, vi (vietnamien) et quelques «régionalismes»

>>> import num2words
>>> num2words.num2words(43, lang="fr")
'quarante-trois'
>>> num2words.num2words(43, lang="fr", to="ordinal")
'quarante-troisième'
>>> num2words.num2words(43, lang="fr", to="ordinal_num")
'43me'
>>> num2words.num2words(72198, lang="fr_BE")
'septante-deux mille cent nonante-huit'
>>> num2words.num2words(82, lang="fr_CH")
'huitante-deux'

3. Chaines

3.1 str et string

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

Voir également chaine 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 chaine) 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 chaine 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 chaine 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 chaine en capitale
ch.capitalize() passe la première lettre de la chaine 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 chaine-phrase
ch.split(". ") le séparateur peut être une chaine 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 chaine 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 chaines (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 chaines, mais sans ordre.

Épluchage

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

ch.strip(chars), ch.lstrip(chars) et ch.rstrip(chars) ôte les caractères précisés dans la chaine 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 chaine fasse n caractères
ch.rjust(n) remplit d’espaces à droite pour que la chaine fasse n caractères
ch.center(n) entoure la chaine d’espaces pour qu’elle fasse n caractères

ch.zfill(n) ajoute des 0 à gauche pour que la chaine 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-chaine dans la chaine, éventuellement entre deux positions
ch.find(ssch) renvoie la position d’une sous-chaine dans une chaine (0 pour la première position, -1 si la sous-chaine ne s’y trouve pas
ch.find(ssch, debut) renvoie la première position d’une sous-chaine 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 chaine commence par le prefixe
ch.endswith("xyz") renvoie True si la chaine termine par xyz

Remplacements de caractères

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

Pour remplacer plusieurs caractères en une fois :

>>> 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 chaine 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 disparaitre, 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 disparaitre :

>>> 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 chaine des caractères à faire disparaitre ; dans ce cas, la suppression avait lieu avant le remplacement :

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

Tests de chaines

ch.isdigit() renvoie True si la chaine n’est constituée que de chiffres
ch.isalpha() renvoie True si la chaine n’est constituée que de lettres (éventuellement accentuées, mais sans espace)
ch.isalnum() renvoie True si la chaine est alphanumérique
ch.islower() renvoie True si la chaine n’est constituée que de minuscules
ch.isupper() renvoie True si la chaine 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 chaine 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 chaines 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 readline pour input()

Nv 2024.12.23 - Voir les généralités concernant les modules.

Le simple fait d’importer le module interne readline donne de la souplesse à la fonction input() du script, les flèches gauche et droite permettant de parcourir la chaine en cours d’édition, les flèches haut et bas de se déplacer dans un éventuel historique.

Ce module permet également d’avoir un contrôle sur l’historique des saisies, de par exemple le sauvegarder pour le rappeler lors d’une nouvelle utilisation du script. Par défaut, le fichier de l’historique est ~/.history, mais il est possible de préciser entre les parenthèses un nom de fichier spécifique à chaque input().

readline.read_history_file(nomdefichier) importe un historique de saisies, avec erreur si le fichier n’existe pas
readline.write_history_file(nomdefichier) sauvegarde l’historique des saisies
readline.append_history_file(n, nomdefichier) ajoute les n derniers éléments de l’historique au fichier de sauvegarde
readline.set_auto_history(False) désactive l’historique, True pour le rétablir

readline.add_history(chaine) ajoute une entrée à l’historique
readline.clear_history() vide l’historique
readline.get_history_length() renvoie la longueur de l’historique
readline.remove_history_item(n) enlève la ligne n (0 est la première)
readline.replace_history_item(n, chaine) remplace la ligne n par la chaine précisée

D’autres fonctions sont également listées (et brièvement explicitées) dans une console avec python3 -c "import readline ; help(readline)" (au moins en Unix).

3.3 re (expressions régulières)

Rév. 2024.12.12 – Voir les généralités concernant les modules.

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

Les expressions rationnelles, ou expressions régulières, décrivent une multiplicité de chaines à 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 chaines différentes. Ce motif permet des comparaisons, des recherches ou remplacements dans une chaine, ou un éclatement d’une chaine 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, les éditeurs de textes pluma / ?gedit et vim ainsi que 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 un chiffre ou une lettre (latine ou non, diacritiques acceptés), pas la ponctuation
\W désigne un caractère qui ne soit ni lettre ni chiffre
\s désigne un caractère "espace" (incluant \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
• l’antislash est codé \\\\ dans une chaine de formatage (et [\\\] entre []).
• [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 chaines 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 (coder \\b) limite de mot : \\broc permet roc, roche… mais pas croc ni croche (également valable pour les fins de mots)
\B (coder \\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 chaine recherchée doit correspondre à un début de ligne
$ en fin d’expression indique que la chaine recherchée doit correspondre à une fin de ligne

D’autres éléments de motif sont également listés (et brièvement explicités) dans une console avec python3 -c "import re ; help(re)" (du moins en Unix).

Utilisation

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

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

>>> rep =re.match("[A-Z]{4}\d+", "BCDE123")
>>> bool(rep)
True

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

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

re.findall(motif, chaine) renvoie une liste de toutes les occurrences trouvées dans la chaine selon le motif utilisé.

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

>>> re.sub("[a-z]{2}", "-", "AbCde002ft3") # toute paire de minuscules non accentuée sera remplacée par un tiret
'AbC-002-3'

re.subn(motif, rempl, chaine) renvoie un tuple contenant le résultat et le nombre de remplacements effectués :

>>> texte, nbr =re.subn("[a-z]{2}", "-", "AbCde002ft3")
>>> print(texte, nbr, sep=" •• ")
'AbC-002-3' •• 2

re.split(motif, chaine, n) débite une chaine dans une liste, avec une éventuelle limite d’occurrence

>>>re.split("\d{2}", "ab92cde14fg") # le séparateur est ici toute chaine 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}")
>>> motif.split("ab92cde14fg")
['ab', 'cde', 'fg']

Motif frugal («non greedy»)

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

\w* induit par défaut un comportement gourmand (greedy), optant pour la plus grande suite de caractères possible entre a et Z : a1Z2aZa3Z. La liste des morceaux de chaine qui en résulte est ['---', '==='].

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

\w*? est la forme frugale (non greedy), qui impose les chaines de découpe les plus réduite possibles a1Z, aZ et a3Z, éclatant la chaine en une liste plus longue : ['---', '2', '', '==='] ('' est la chaine vide située entre aZ et a3Z).

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

Conservation d’un motif recherché

Nv 2024.11.22

Il est possible de réinjecter une chaine désignée par un motif de recherche dans la chaine de remplacement en l’entourant de parenthèses et en utilisant \1 (\2…) dans la chaine de remplacement :

>>> re.sub("([rd]a)", "\\1!", "Abracadabra")
'Abra!cada!bra!'

Rappel : dans une chaine, l’antislash se code \\

D’autres fonctions sont également listées (et brièvement explicitées) dans une console avec python3 -c "import re ; help(re)" (du moins en Unix).

3.4 Levenshtein (comparaison de chaines)

Voir les généralités concernant les modules. Corrections le 2026.05.29

Ce module concerne différentes façons de tester la distance entre deux chaines, par exemple le nombre de substitutions, insertions et suppressions de caractère, ou la similarité de 0 à 1.0. Sur Debian, le module à installer s’appelle python3-levenshtein, mais l’importation du module demande une capitale :

>>> import Levenshtein

Levenshtein.distance(str1, str2) mesure le nombre d’opérations (ajouter, enlever ou modifier un caractère) pour passer de str1 à str2 (sensible à la casse: majuscules et minuscules sont considérées comme différentes). Les fonctions suivantes explicitent le fonctionnement :

Levenshtein.editops() produit une liste reprenant la suite des opérations permettant de passer d’une chaine à l’autre :

>>> c =Levenshtein.editops("Tintin", "Topor")
>>> c
[('delete', 1, 1), ('replace', 2, 1), ('replace', 3, 2), ('replace', 4, 3), ('replace', 5, 4)]

Levenshtein.inverse(Levenshtein.editops("Tintin", "Topor")) renvoi la liste des opérations inverses, de str2 à str1.

[('replace', 1, 1), ('replace', 2, 2), ('replace', 3, 3), ('replace', 4, 4), ('insert', 5, 5)]

apply_edit applique les changements selon (une partie de) la liste, permettant d’en visualiser les étapes :

>>> c =Levenshtein.editops("Tintin", "Topor")
>>> for i in range(len(c) +1) :
…   Levenshtein.apply_edit(c[:i], "Tintin", "Topor")
'Tintin'
'Tntin'
'Totin'
'Topin'
'Topon'
'Topor'

Levenshtein.hamming(str1, str2) retourne le nombre de lettres de même rang différentes ; les éventuelles lettres manquantes comptent pour une différence.

Levenshtein.jaro(str1, str2) retourne un indice de similitude entre 0 et 1.0 ; les résultats sont parfois surprenants.

Levenshtein.ratio(str1, str2) retourne un indice de similitude entre 0 et 1.0 ; il s’agit du nombre de lettres communes si les deux mots sont de même longueur, avec une correction si les longueurs sont différentes

…et jaro_winkler(), matching_blocks(), median(), median_improve(), opcodes(), quickmedian(), seqratio(), setmedian(), setratio, subtract_edit

3.5 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 chaine à 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 chaine à 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

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

ascii =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 chaine 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.6 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 chaine francophone : 3,14
locale.atof("3,14") transforme une chaine 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 chaines :

>>> 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 chaine "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 locale et icu

Corr. 2026.06.13 - Voir les généralités concernant les modules.

Le tri sur des chaines est par défaut celui de l'ordre ASCII, ou Unicode, où les lettres accentuées sont reportées viennent nécessairement après les autres, comme la deuxième lettre de "mûr" renvoie ce mot après "mure". Un tri plus «naturel» fait apparaitre «mûr» avant «mure».

locale

Il faut d'abord importer le module locale et imposer la locale ("fr_FR.UTF-8", "fr_CH.UTF-8", "fr_BE.UTF-8", "fr_CH.UTF-8", fr_FR.ISO-8859-1, fr_FR.ISO-8859-15...) selon celle·s disponible·s sur le système :

import locale
locale.setlocale(locale.LC_COLLATE, "fr_FR.UTF-8")

Le tri naturel peut dès lors être précisé lors d'un tri :

>>> sorted(["Ô","z","K","é","§","#","ç","3"], key=locale.strxfrm)
['#', '§', '3', 'ç', 'é', 'K', 'Ô', 'z']

Pour un tri naturel qui sépare les majuscules et les minuscules (sur la première lettre seulement), tentez :

sorted(["ô","z","K","É","§","#","à", "ci", "ça"], key=lambda s: (s[0].islower(), locale.strxfrm(s)))
['#', '§', 'É', 'K', 'à', 'ça', 'ci', 'ô', 'z']

icu

International Components for Unicode

Ce module nécessite l'installation du module python3-icu (python-pyicu en python2) selon votre version de python. Dans un script Python, le module est importé avec :

import icu

Il est nécessaire créer un collateur pour une locale donnée (selon la variante du système) :

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 : sorted() ne modifie jamais la liste en place. Il faut récupérer le résultat :

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

On peut choisir parmi trois formes de tri avec coll.setStrength(icu.Collator.XXX), où XXX est remplacé par :

PRIMARY qui ignore accents et casse ("e" == "é" == "E")
SECONDARY qui distingue les accents, ignore la casse (e == E, mais "e" != "é")
TERTIARY qui distingue accents et casse ("e" != "E", "é" != "É")

Attention : la distinction de casse ne se fait (et encore pas toujours) entre mots similaires : Mur, mur, Mûr, mur...

4. Sauvegarde des données

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

5.1 pickle

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.

Sauvegarder des variables

dumps(objet) (dumps avec s) transforme un objet-python en chaine 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 chaine 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 shelve

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

Les autres objets (nombres, tuples, listes, objets binaires, mais éventuellement des chaines…) sont sauvegardés avec le module shelve (les clés doivent être des chaines). 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 chaines 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.

cles =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 ensuite 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.

5.3 dbm (anciennement anydbm)

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

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

mabase =dbm.open("fichier.dbm","c") crée une base de données (et y permet l’écriture)
mabase["clef1"] =valeur stocke une valeur sous forme de chaine ou de variable-chaine
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.

6. Internet

6.1 urllib3 (téléchargement)

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

Concernait auparavant urllib – revu 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 chaine 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">

7. binaire codé ASCII

2025.03.18 – pour plus de précisions, voir cette page

binascii est le module qui permet d’encoder des fichiers binaire en ASCII imprimable ou de décoder. Cela a été très important aux premiers temps des réseaux (Usenet, e-mails…) mais perd de son importance. Pour rappel, un fichier «binaire» est constitué des 256 valeurs possibles de l’octet, de 0 à 255. L’ASCII ne concerne que les 128 premières valeurs, théoriquement de 0 à 127 ; néanmoins, peu d’octets en dessous de 32 sont utilisés, comme le 8 (tabuation), le 10 (nouvelle ligne), le 13 (retour chariot)…

Pour les fonctions qui suivent, les données doivent être fournies en objet bytes, les résultats sont sous le même format, ce qui est pratique pour les sauvegardes de fichier «binaires».

base64

Trois octets (soit 24 bits) sont découpés en quatre paquets de 6 bits («hexets»), convertis en nombres de 0 à 63, codés de A-Z, a-z, 0-9 et "+/" pour les deux derniers. Les données doivent être spécifiées en objet bytes, ce qui peut demander un encodage supplémentaire.

b2a_base64 transforme un objet bytes en chaine ASCII. Comme tout groupe de trois octets est tranformé en groupe de quatre caractères ASCII, le résultat obtenu est parfois complété par un ou deux signes =.

>>> import binascii
>>> octets =bytes("Hé!", "utf-8")
>>> binascii.b2a_base64(octets)
b"SMOpIQ==\n"

a2b_base64 transforme un objet bytes obtenu par la fonction précédente en une suite d’octets terminé par un octet de fin de ligne sauf avec newline=False. Pour restaurer une chaine, une transformation supplémentaire peut être nécessaire.

>>> chaine =binascii.a2b_base64(b"SMOpIQ==\n")
>>> print(chaine)
b"H\xc3\xa9!"
>>> print(str(chaine, "utf-8"))
Hé!

uu

Note : Le module spécifique «uu» est retiré de la version 3.13 de Python

L’encodage uu a surtout été utilisé sur Usenet. Les valeurs de 0 à 63 sont codées avec les caractères chr(valeur +32) : l’espace vaut zéro, le point d’exclamation 1, etc. Avec backtick=True, le backtick ` remplace l’espace pour la valeur nulle.

>>> octets =bytes("Hé!", "utf-8")
>>> binascii.b2a_uu(octets, backtick=True)
b"$2,.I(0``\n"

Le premier caractère, $ dans cet exemple, donne le nombre d’octets convertis. Son rang étant 36, il avertit que le nombre d’octets encodés (pas le nombre utilisés pour l’encodage) est de quatre. En général, une ligne commence par M pour 45 octets (et 60 de code) ; la dernière varie.

binascii.a2b_uu(b"$2,.I(0``\n")
b"H\xc3\xa9!"

Attention : une première et une dernière ligne sont ajoutées.

Hexadécimal

Cette façon utilise exactement deux caractères par octets.

>>> binascii.b2a_hex(bytes("Hé!", "utf-8"))
b"48c3a921"

>>> binascii.a2b_hex(b"48c3a921")
b"H\xc3\xa9!"
>>> binascii.b2a_hex(bytes("Hé!", "utf-8"), sep="-")
b"48-c3-a9-21"

bytes_per_sep=n permet de décider le nombre d’octets entre deux séparateurs (à partir de la gauche si n est négatif.

quoted-printable

Ce technique permet de conserver la lisibilité du texte purement ASCII et ne code que les caractères spéciaux. Il s’agit donc de la même fonction que la précédente, mais seulement pour ce qui est avant l’octet 32 et au delà de l’octet 127, ainsi que du caractère =, codé =3D.

>>> octets =bytes("Hé!", "utf-8")
>>> binascii.b2a_qp(octets)
b"H=C3=A9!"

• quotetabs=False permet de ne pas coder les tabulations
• istext=True ne code pas les fins de lignes, octets 13+10 sinon
• header=False ?

>>> a2b_qp(b"H=C3=A9!", header=False)
b"H\xc3\xa9!"