Accueil

Modules

Objectifs du TD : apprendre à créer des modules

Un module Python peut être vu comme une boîte à outils pour travailler sur des données, comme par exemple le module math qui vous donne accès aux fonctions trigonométriques, ou le module turtle qui vous donne accès à toutes les fonctionnalités de la tortue.

EXERCICES DE COURS

Définition d'un module

Vous pouvez définir vos propres modules très simplement : c'est un fichier d'extension .py qui contient constantes et fonctions sur des données d'un même type. Quand ce fichier est utilisé par un autre programme Python3 avec l'instruction import, alors un fichier d'extension .pyc est généré par l'interprète et placé dans le répertoire . Ce fichier est chargé dans l'interprète quand on l'importe; il contient un codage du module (bytecode).

Importation d'un module

Les modules sont importés gràce au mot clé import, cela donne accès aux outils du module. Il y a plusieurs façons d'importer un module, illustrées à travers l'importation du module turtle :
  1. from turtle import *
    Tous les outils du module turtle sont directement accessibles dans le programme. Cela signifie qu'ils sont chargés dans l'interprète et qu'ils sont dans le même espace de nommage que celui du programme qui fait l'import. On écrira donc par exemple 
    forward(100)
  2. from turtle import forward,color
    Seules les fonctions forward et color sont directement accessibles dans le programme. On écrira donc par exemple 
    forward(100)
color("red")
    mais 
    left(90)
    génèrera une erreur d'exécution.
  3. import turtle
    Ici, tous les outils de turtle sont accessibles mais ils ne sont pas dans le même espace de nommage que le programme principal. Il faut donc préciser que l'on veut accéder à une fonction de cet espace de nommage. Par exemple, on écrira 
    turtle.forward(100)
Il est recommandé d'utiliser la méthode 1 dans un programme où l'on va utiliser la plupart des outils du module (cela est souvent vrai avec turtle). Les méthodes 2 et 3 seront préférées dans tous les autres cas (par exemple, pour tirer un nombre aléatoire, nous avons écrit import random et random.randint car cette fonction était très peu utilisée).

Nota: en utilisant les méthodes 1 ou 2, il peut y avoir des conflits de nommage si une des fonctions du module importé a le même nom qu'une fonction du programme principal. Il peut aussi y avoir des conflits si deux modules utilisent le même nom de fonction (comme radians du module math et radians du module turtle). On pourra alors changer le nom gràce au mot clé as. Voici un exemple avec les fonctions radians(a) du module math qui traduit un angle en radians et radians() du module turtle qui indique que tous les angles seront pris en radian.
Version avec un conflit de nommage : 
from math import *   ## charge radians(x) de math
from turtle import * ## charge radians() de turtle et écrase radians(x)
Version sans conflit : 
from math import *   ## charge radians(x)
from math import radians as anglesEnRadians   ## charge radians() et le renomme anglesEnRadians(). on a donc accès à radians(x) des math et anglesEnRadians() de turtle
Des détails sur les modules se trouvent dans le tutorial

Exercices

  1. Créer un fichier myString.py qui contient uniquement les définitions des fonctions palindrome et reverse écrites dans le TD sur les chaines de caractères. Créez un fichier testString.py qui importe myString.py, lit un mot, et utilise les fonctions palindrome et reverse. Vérifiez qu'un répertoire _pycache_ a bien été créé. Tester les 3 méthodes d'importation décrites ci-dessus.

  2. Ajouter au module myString.py la fonction permute (voir problème 2 du TD sur les listes). Ecrire un programme testPermute.py qui importe le module myString et le module lireListe et qui lit une liste de mots (avec lireListeMot du module lireListe) et affiche ces mots après permutation. Lisez le complément ci-dessous pour pouvoir importer des modules situés dans différents répertoires.

    3. Complément sur les modules : modules dans plusieurs répertoires
    Les modules que vous pouvez importer sont connus de l'interprète gràce à la variable d'environnement sys.path (équivalent de la variable PATH de linux). Cette variable contient les chemins vers tous les répertoires susceptibles de contenir un module, prédéfini ou non. Le code : 
     import sys
sys.path
    affiche le path courant de l'interprète c'est à dire les chemins vers les répertoires qui contiennent les modules prédéfinis de Python, ainsi que le chemin vers le répertoire depuis lequel vous avez lancé idle3. En effet, par défaut, tout ce que vous avez écrit dans le répertoire de lancement de idle3 est accessible. Pour que vous puissiez accéder au module lireListe qui est dans le répertoire ....../algoProgCIP1/td6 il faut ajouter cette chaine dans sys.path. Pour cela, il suffit tout simplement d'utiliser la fonction append des listes, en indiquant le chemin vers votre répertoire td5. Voici un exemple à adapter : 
     sys.path.append("/home/collavi/algoProgCIP1/td6")
sys.path
    Maintenant que le répertoire td6 est connu, vous pouvez importer votre module lireListe en faisant from lireListe import * et l'utiliser pour lire des listes.

    Modules et Idle3
    Selon votre installation de idle3, il est possible que les modifications faites dans myString ne soient pas prises en compte par l'interprète. En effet, le "Python shell" utilise le myString.pyc qui a été créé la première fois, mais ne le recharge pas si vous modifiez le code du module myString.py. En principe, si vous faites F5 dans le fichier module myString.py, cela le recharge dans l'interprète.
    Si cela ne fonctionne pas, une autre solution consiste à recharger explictement le module. Pour cela vous devez faire dans l'interprète les actions suivantes: Ces actions doivent être faites une seule fois. Ensuite, à chaque fois que vous modifiez myString.py vous devez le recharger avant de lancer le programme testString.py. Pour cela : La nouvelle version du module sera alors utilisée dans l'interprète.
    En dernier recours, quitter complètement l'interprète et le relancer.

  3. Ajouter au module myString une fonction indexOf(t,c,i) qui renvoie l'indice dans le texte t du caractère c à partir de la position i. Par exemple, si t = "il fait beau", indexOf(t," ",0) renvoie 2 (le premier espace dans t est à l'indice 2) et indexOf(t," ",4) renvoie 7 (le premier espace dans t à partir de l'indice 4 est à l'indice 7). Si le caractère cherché n'apparait pas dans t, alors la fonction doit renvoyer -1. Modifiez le fichier testString.py pour tester cette nouvelle fonction.

  4. Ajouter au module myString une fonction replace(t,old,new) qui prend un texte t et remplace dans t toutes les occurences du mot old par new. Modifiez le fichier testString.py pour tester cette nouvelle fonction. Exemple : 
    une phrase : le mot dans le mot à remplacer un le
le mot à remplacer : le
le nouveau mot : un
nouvelle phrase : un mot dans un mot à remplacer un un
    Aide : Pour identifier les mots, il est recommandé d'utiliser la fonction indexOf(t,c,i) en cherchant le caractère " ". Il est aussi recommandé d'utiliser la notation [i:j] pour récupérer la chaine comprise entre les indices i et j. Par exemple, si t vaut "il se fait tard", t[6:10] vaut "fait".

    5. Collavizza Hélène