PYTHON > la gestion des modules

LISTE DES MODULES INSTALLES

pip list

CHEMIN DES MODULES

python sys_path_show.py

INSTALLER UN MODULE

sudo pip install nomModule

 

Si on a des version différentes de python installés

Pour chaque version, faire :

 

sudo apt install pythonX-pip
sudo apt install python3-pip

 

puis, pour installer un module dans la version de Python désirée :

 

pythonX -m pip install nomModule
python3 -m pip install nomModule

 

ou bien :

 

pip3 install nomModule

IMPORTER UN MODULE

import monModule as toto

 

Les fonctions seront accessibles par  lemodule.leglobal

 

si a defines a.b and a.c…

 

import a
a.b()
a.c()

à préférer

 

vs.

 

from a import b
b()
c() # fails because c isn't imported

 

vs.

 

from a import *
b()
c()

à éviter !!! Les fonctions sont mises en global, et peuvent donc interférer avec d’autres.

TELECHARGER UN MODULE

https://pypi.org

 

tkinter et python3

sudo apt-get install python3-tk

 

PYTHON VERSION PORTABLE

Savoir où est le dossier Lib :

 

import sys; print(sys.path)

 

—

Il est tout à fait possible de se créer des bibliothèques de fonctions pour éviter de dupliquer un travail déjà fait dans le cadre d’un projet, ou bien pour pouvoir réutiliser des fonctions ou des définitions de classes (voir ci-après) dans des projets différents.

Pour cela, il faut simplement écrire la liste des fonctions dans un fichier .py (par exemple mes_fonctions.py) puis importer ce fichier avant toute autre opération dans le code, avec les mots-clefs from... import (dans ce cas, from mes_fonctions import *). Cette syntaxe comporte plusieurs variantes :

• from mes_fonctions import * importe telles quelles toutes les fonctions définies dans le fichier
• from mes_fonctions import fonction1, fonction2 importe uniquement les fonctions fonction1 et fonction2

2. Importation avec nommage

Afin d’éviter d’éventuels conflits de noms, d’une manière similaire aux espaces de noms XML, on peut expliciter un préfixe pour le module importé :

• import mes_fonctions. Dans ce cas, les noms des fonctions importées doivent être préfixés par mes_fonctions : mes_fonctions.fonction1, mes_fonctions.fonction2…
• import mes_fonctions as mesFonc. Dans ce cas, les noms des fonctions importées doivent être préfixés par l’alias mesFonc, qui peut être défini indépendamment du nom du fichier : mesFonc.fonction1, mesFonc.fonction2…

II. Classes et objets

1. Classe et objet simple

a. Définition d’une classe minimale

La définition d’une classe est tout à fait simulaire à celle d’une fonction. Par convention, on a l’habitude de mettre une majuscule à la première lettre du nom d’une classe.

class ExempleClasse:
"""Documentation de la classe"""  #Définition de la classe

p = ExempleClasse()

Les """ après le nom de la classe servent à la documentationp est une instanciation de la classe. Attention à cette étape à la duplication d’objets :

p1=ExempleClasse()
p2=ExempleClasse()
p3=p1
print(p1)
<__main__.ExempleClasse object at 0x7ff404091ba8>
print(p3)
<__main__.ExempleClasse object at 0x7ff404091b70>
print(p3)
<__main__.ExempleClasse object at 0x7ff404091ba8>

On remarque dans le code précédent que les variables p1 et p3 renvoient bien au même objet, à l’adresse mémoire 0x7ff404091ba8.

b. Ajout de propriétés

On peut ensuite ajouter des propriétés à l’objet ainsi créé :

p1.x="valeur de x"

c. Ajout de de méthodes

La définition de méthodes se fait dans celle de la classe :

class ExempleClasse:
def methode1(self, x,z):
self.x=2*x
self.y=2*x*z

Le mot-clef self est obligatoire et doit apparaître comme premier argument.

On peut tout à fait définir des valeurs par défaut, de la même manière que pour les fonctions :

class exempleClasse:
def methode1(self, x=3,z=8):
self.x=2*x
self.y=2*x*z

2. Constructeur

Le constructeur est une méthode portant un nom prédéfini et préservé, __init__ (commençant et finissant par deux « underscores »). Comme toute méthode, le constructeur peut accepter des paramètres, avec ou sans valeur par défaut…

class Test:
def__init__ (self, t=4, z=5):
self.x="varx"
self.y="vary"
self.t=t
self.z=z

3. Encapsulation

L’encapsulation consiste en le masquage de certaines propriétés afin qu’elles ne soient plus directement accessibles depuis l’extérieur de l’objet. Pour définir une propriété privée, on préfixe son nom, encore une fois, par deux « underscores » dans le constructeur :

class ClasseTest :

#Constructeur
def __init__ (self):
self.a=1
self.b=2
self.__c=3
self.__d=4

#getters
def get_a(self):
return self.a
def get_b(self):
return self.b
def get_c(self):
return self.__c
def get_d(self):
return self.__d

#setters
def set_a(self, x):
self.a=x
def set_b(self, x):
self.b=x
def set_c(self, x):
self.__c=x
def set_d(self, x):
self.__d=x

test=ClasseTest()

Dans l’exemple précédent, les propriétés test.a et test.b sont de plus accessibles directement.

4. Héritage

On peut facilement construire une hiérarchie de classes avec l’héritage. Par exemple:

class Parente :
"""Classe parente"""

def __init__(self):
self.__prop1=1
self.__prop2=2

def get_prop1(self):
return self.__prop1
def get_prop2(self):
return self.__prop2

def set_prop1(self, x):
self.__prop1=x
def set_prop2(self, x):
self.__prop2=x

class Enfant(Parente) :
"""Classe enfant"""

def __init__(self):
Parente.__init__(self)
self.__prop3=3

def get_prop3(self):
return self.__prop3
def set_prop3(self, x):
self.__prop3=x

Exercice 1. Classes

Énoncé

Correction