Modules

1
 Modules
Les modules sont des fichiers qui contiennent des variables, des
fonctions etc., déjà définies, qu'on peut importer et utiliser.
Module = « bibliothèque »
Les objets définis dans le module sont accessible par le :
« fully qualified name » = nom_module.nom_objet
>>> import math
>>> math.pi
3.141592653589793
>>> math.sin(math.pi / 2)
1.0

Avec le mot-clé as on peut utiliser un « alias » pour le nom du module :

>>> import math as m
>>> m.pi
2
3.141592653589793
 Modules
Un soupçon de librairie standard :
● string, re

● os, sys, subprocess

● datetime, calendar, collections, array

● math, cmath, decimal, fractions, random,

statistics
● zlib

● ssl, email, html, urllib, http

● audioop, wave

● tkinter, turtle

● ...

3
 Modules
On peut importer des objets spécifiques avec from:
>>> from math import sin, pi
>>> sin(pi / 2) # notez absence de « math. »
1.0

On peut aussi importer tous les objets définis dans le module:

>>> from math import *

Mais en général, c'est une mauvaise idée !

(namespace pollution)

4
 Modules
Importation de plusieurs modules :

import math
import decimal

ou

import math, decimal

5
 Modules
Deux fonctions très utiles pour explorer un objet (les modules en
particulier!) : help() et dir()

>>> import math

>>> dir(math)
['__doc__', '__file__', '__name__',
'__package__', 'acos', 'acosh', 'asin', 'asinh',
'atan', 'atan2', 'atanh', 'ceil', 'copysign',
'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc',
'exp', 'expm1', 'fabs', 'factorial', 'floor',
'fmod', 'frexp', 'fsum', 'gamma', 'hypot',
'isinf', 'isnan', 'ldexp', 'lgamma', 'log',
'log10', 'log1p', 'modf', 'pi', 'pow', 'radians',
'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
>>> 6
>>> import math
>>> help(math)

NAME
math

DESCRIPTION
This module is always available. It provides access to the
mathematical functions defined by the C standard.

FUNCTIONS
acos(...)
acos(x)

Return the arc cosine (measured in radians) of x.

[...]

DATA
e = 2.718281828459045
pi = 3.141592653589793

FILE
/usr/lib64/python3.5/lib-dynload/math.cpython-35m-x86_64-linux-gnu.so
7
 Module sys
sys.exit()
termine l'exécution avec exit code 0
sys.exit(<code>)
termine l'exécution avec un certain exit code

import sys int main()

{
print('Echec') printf("Echec\n");
sys.exit(1)
return 1;
}
8
 Module sys
sys.argv
Une liste qui contiens les arguments passés au script.
Attention ! sys.argv[0] contiens le nom du programme, donc les
arguments sont sys.argv[1:]

argvtest.py

#!/usr/bin/python3
import sys
print(sys.argv)

$ ./argvtest.py un deux trois arguments

['./argvtest.py', 'un', 'deux', 'trois', 'arguments']

9
 Module sys
Le module définit les descripteurs d'accès à la console :
sys.stdin, sys.stdout, sys.stderr

On peut les rediriger vers des fichiers :

>>> import sys
>>> old_stdout = sys.stdout
>>> sys.stdout = open('output.txt', 'w')
>>> print('Hello world') # dans 'output.txt'
>>> help(complex) # dans 'output.txt'
>>> sys.stdout.close()
>>> sys.stdout = old_stdout
>>> print('Hello world')
Hello world 10
 Module os
Fonctions portables pour travailler avec le système d'exploitation.
Notamment :

●
Opérations sur fichiers et répertoires :
os.listdir() Lister les fichiers du dossier courant
os.chdir(path) Changer le dossier courant
os.mkdir(path) Créer un dossier
os.rmdir(path) Supprimer un dossier
os.rename(source, dest) Renommer un fichier
os.remove(path) Supprimer un fichier
os.stat(path) Obtenir des informations sur le fichier
os.chmod(path) Changer les droits d'un fichier
... 11
 Module os

●
Exécution des commandes dans un shell de système :
os.system(s) - exécute la commande contenue
dans la chaîne s.
>>> os.system('ls -l /')

12
 Module os
os.stat(path)
Renvoie un objet (de type os.stat_result) qui contient des
informations sur le fichier passé en argument.
Les informations sont accessible dans les attributs de l'objet :
.st_mode Droit d'accès
.st_uid ID du propriétaire
.st_gid ID du groupe
.st_size Taille en octets
.st_mtime Date de dernière modification
Exemple :
result = os.stat('livre.txt')
print('Proprietaire : {}'.format(result.st_uid)
13
 Module random
Fonctions pour générer nombres au hasard, etc.

random.random()
génère un float entre [0, 1)
random.randint(a, b)
génère un entier entre [a, b], extrêmes inclus
random.choice(seq)
choisit un élément de la séquence seq.
random.shuffle(liste)
mélange aléatoirement une liste
14
 Module turtle
Créer des dessins selon le principe de la « tortue graphique ».

forward(d)
Avancer d’une distance d
backward(d)
Reculer d’une distance d
left(angle)
Tourner à gauche d’un angle donné (exprimé en degrés)
right(angle)
Tourner à droite
15
 Module turtle
reset()
Tout effacer
up()
Relever le crayon (pour pouvoir avancer sans dessiner)
down()
Abaisser le crayon (pour recommencer à dessiner)
width(épaisseur)
Changer l’épaisseur du tracé
goto(x, y)
Placer la tortue au point de coordonnées x, y

16
Création de modules

17
Pour créer un module nommé « squaring » : créez un fichier
squaring.py

squaring.py
"""Un module pour afficher le carré des nombres."""
def affiche_carre(x):
"""Affiche le carré de x."""
print(x**2)

>>> import squaring

>>> squaring.affiche_carre(5)
25

18
Attention ! import ne se limite pas à importer le fonctions.
Tout le code contenu dans le module est exécuté lors de l'importation.

bavard.py
print('hello')

Dans l'interpréteur :
>>> import bavard
hello
>>>

19
squaring.py

"""Un module pour afficher

le carré des nombres"""

def affiche_carre(x):
"Affiche le carré de x."
print(x**2)

20
 Description
du module
squaring.py

"""Un module pour afficher

le carré des nombres"""

def affiche_carre(x):
"Affiche le carré de x."
print(x**2)

21
 Description
du module
squaring.py

"""Un module pour afficher

le carré des nombres"""

def affiche_carre(x):
"Affiche le carré de x."
print(x**2)

Description de
la fonction 22
 Description
du module
squaring.py

"""Un module pour afficher

le carré des nombres"""

def affiche_carre(x):
"Affiche le carré de x."
print(x**2)

Ces descriptions s'appellent docstrings. On les

retrouve dans l'attribut __doc__ de l'objet. Les Description de
docstrings sont utilisées par la fonction help() la fonction 23
 puissance.py
"""Affichage de diverses puissance des nombres.

Le module exporte des fonctions qui permettent d'afficher

les principales puissances des nombres : 2 et 1/2.
"""

import math

def affiche_carre(x):
"Affiche le carré de x."
print(x**2)

def affiche_racine(x):
"Affiche la racine carrée de x."
print(math.sqrt(x))
24
 puissance.py Première ligne :
description synthetique

suivie par une ligne

"""Affichage de diverses puissance des nombres. blanche

Le module exporte des fonctions qui permettent d'afficher

les principales puissances des nombres : 2 et 1/2.
"""

import math

def affiche_carre(x):
"Affiche le carré de x."
print(x**2)

def affiche_racine(x):
"Affiche la racine carrée de x."
print(math.sqrt(x))
25
 puissance.py
"""Affichage de diverses puissance des nombres.

Le module exporte des fonctions qui permettent d'afficher

les principales puissances des nombres : 2 et 1/2.
"""

import math Ligne suivantes :

description détaillée
def affiche_carre(x):
"Affiche le carré de x."
print(x**2)

def affiche_racine(x):
"Affiche la racine carrée de x."
print(math.sqrt(x))
26
 Modules précompilés
La première fois qu'un module est importé, CPython crée un autre
fichier avec extension .pyc qui contiens le code du module
compilé, pour optimiser les importations suivantes.

Python 3
Un fichier dans le sous-répertoire __pycache__, qui spécifie la
version de CPython utilisée :
mymodule.py -> __pycache__/mymodule.cpython-34.pyc

Python 2
Un fichier avec le même nom dans le répertoire courant :
mymodule.py -> mymodule.pyc
27
 Modules vs exécutables
Souvent, on veut créer un script qui peut jouer deux
« rôles » différents :
●
module/bibliothèque importable
exporter des fonctions etc., sans autres effets
●
programme exécutable
faire quelque chose avec les objet définis dans le fichier
Deux comportements :
● import monmodule
● $ python3 monmodule.py
28
 puissance.py
import math

def affiche_carre(x):
print(x**2)

def affiche_racine(x):
print(math.sqrt(x))

x = int(input('Saisir un nombre : '))

affiche_carre(x)
affiche_racine(x)

29
 puissance.py
import math

def affiche_carre(x):
print(x**2)

def affiche_racine(x):
print(math.sqrt(x)) import n'exécute pas ce bloc

if __name__ == '__main__':
x = int(input('Saisir un nombre : '))
affiche_carre(x)
affiche_racine(x)

30
Paquets

31
 PyPI
Paquet = archive téléchargeable et installable qui offre
des nouvelles fonctionnalités sous forme de modules.
1 paquet = 1 ou plusieurs modules structurés.

Python Package Index : collection de paquets

disponible à l’adresse :
http://pypi.python.org

32
 Installation de paquets
Exemple :
Paquet « Pillow » = une bibliothèque de manipulation d’images.
Le module principale s’appelle PIL.

Pour l’installation, on utilise l’outil pip3 (ou pip pour Python 2) :

$ pip3 install Pillow

Une fois installé, nous pouvons l’importer et l’utiliser :

>>> from PIL import Image
>>> im = Image('chat.jpeg')

33
 Environnements virtuels
Par défaut, pip et pip3 installent les paquets dans une location
de système (Linux : /usr ou /usr/local).

Mais parfois il est souhaitable utiliser une location séparée, dans le

dossier personnel :
●
pas besoin des droits d’administrateur
●
encapsulation de différents projets

Les environnements virtuels nous permettent précisément ce

genre de séparation.
34
 Environnements virtuels
Les environnements virtuels sont créés avec le module venv.
Chaque env. virt. est placé dans un dossier indépendant.
Example : création d’un env. « test »
$ python3 -m venv test
$ source test/bin/activate
(test) $

Il est désormai possible installer des paquets dans notre nouvel env.
virt. Sans toucher au système :
(test) $ pip3 install Pillow

35