P
'
t
i
t
e
C
h
a
t
t
e
 
spacer~ DON'T BLAME ME, IT'S A SOFTWARE PROBLEM Articles | Connexion
 
~Listes et modules en Python

Précédent  
  Python  
  Suivant
 Présentation

Le langage de scripting Python repose énormément sur l'emploi de listes et de modules. Si les modules semblent familiers aux adeptes de la programmation objet, les listes montrent une véritable originalité.
 Sommaire


 Modules

En Python, un module peut correspondre, de manière simplifiée, à un répertoire ou à un fichier Python portant l'extension traditionelle .py. Le contenu d'un module, soit des classes, des attributs, des méthodes ou encore des modules, doit être importé dans votre code si vous souhaitez l'utiliser. L'import d'un module peut se faire de deux manières. La première consiste à déclarer le nom complet du module.

En ce cas, vous pourrez utiliser le contenu de ce module utilisant le préfixe "module.". Dans l'exemple qui suit, nous allons tenter de déterminer les paramètres donnés à l'application grâce à l'attribut "argv" du module "sys":

import sys
if __name__ == '__main__':
  for parameter in sys.argv:
    print parameter
       
      
JextCopier dans Jext | Jext | Plugin Codegeek
La structure "for" emploie les spécifités des listes sur lesquelles nous allons bientôt revenir. Nous pouvons remarquer deux choses: l'import du module sys par le biais du mot-clé "import" et l'utilisation de l'attribut "argv" de ce même module par l'instruction "sys.argv".

Lorsqu'un module est importé de la sorte, son nom fait alors partie de l'espace de nommage local au programme. Contrairement à Java ou une telle instruction permettrait de faire appel directement à "argv", Python nécessite la référence complète du nom de module. Il est cependant possible d'importer directement "argv" dans l'espace de nommage:

from sys import argv
       
      
JextCopier dans Jext
Cette seconde instruction d'importation sert à placer dans l'espace de nommage une entité incluse dans le module concerné par le mot-clé "from". Nous pouvons dès lors écrire:

for parameter in argv:
       
      
JextCopier dans Jext
L'import d'un script Python place dans un sous-répertoire se verra effectué en employant la syntaxe "import repertoire.repertoire.script". Néanmoins, un répertoire ne représente pas nécessairement un module. Pour ce faire, il doit posséder un ficihier nommé "__init__.py", vide ou non. Ce fichier sert à définir les attributs du répertoire.

Conventionnellement, le programmeur place la documentation du module, son numéro de version, et ainsi de suite, sous forme de variables dans ce fichier. Si ce fichier manque à l'appel, l'import ne pourra être effectué.

Python permet d'importer plusieurs entités à la fois. Par exemple:

import string, sys
from com.loginmag import *
       
      
JextCopier dans Jext
La première ligne provoque l'addition des noms "string" et "sys" dans l'espace de nommage. La seconde ajoute chaque nom d'entité contenue dans le répertoire "com/loginmag" dans l'espace de nommage. Imaginons que le répertoire "com/loginmag" possède un script nommé "printModule.py". Ce dernier contient la méthode "printArguments(argv)". Voici deux manières de procéder à son utilisation:

import sys
from com.loginmag import printModule
printModule.printArguments(sys.argv)

from com.loginmag.printModule import printArguments
printArguments(sys.argv)
       
      
JextCopier dans Jext
Cet exemple illustre parfaitement le fait que pour Python les différents types de modules se fondent complètement. Lors de l'import d'un répertoire, une entité importé correspondra à un script. Dans le cas de l'import d'un script, une entité correspondra à une classe, un attribut...


 Les listes

Jusqu'à présent, le sujet des structures de contrôle a été soigneusement évité. La raison en est simple: les structures de contrôles utilisent abondamment les listes. Prenons le cas de la boucle itérative "for". En Python, cette dernière agit à l'instar d'une énumération.



La puissance des listes

Ainsi, le parcours d'un tableau consistera en l'énumération de chaque élément, un par un. Ceci explique pourquoi la traditionelle boucle C n'existe pas. Prenons le code C suivant:

for (int i = 0; i < 10; i++)
{
  printf("hello");
}
       
      
JextCopier dans Jext | Jext | Plugin Codegeek
Voici maintenant sa traduction en Python:

for i in range(10):
  print "hello"
       
      
JextCopier dans Jext
La fonction "range()" crée une liste de 10 éléments, numérotés de 0 à 9. La boucle "for" va ensuite énumérer son contenu jusqu'à ce que la fin soit atteinte pour sortir de la boucle. Le mot-clé "in" qui apparaît ici peut également servir dans une structure conditionelle. Cet opérateur binaire renvoie la valeur vraie (qui en Python correspond à toute valeur hormi 0 ou None) si l'opérande de gauche existe dans la liste en opérande de droite.

liste = ['Lord', 'Gfx', 'Rico', 'Bgw' ]
if "Rico" in liste:
  print "trouvé"
       
      
JextCopier dans Jext
Constatez que toute structure de contrôle est terminée par le caractère "deux-points". Voici quelques exemples:

while 'Rico' in liste:
  enlever(liste, 'Rico')
if 'Lord' in liste:
  print "trouvé"
elif 'Gfx' in liste:
  print "trouvé aussi"
else:
  print "rien trouvé"
       
      
JextCopier dans Jext
Mais revenons à nos listes. Il existe deux manières de créer une liste. A savoir comme en mathématiques, par extension ou par définition. La déclaration en extension correspond à celle que nous venons de voir:

liste = [1, "chaine", objet, 2]
       
      
JextCopier dans Jext
La déclaration par définition fait appel à une boucle "for". Essayons de créer la liste des nombres pairs compris entre 0 et 200:

liste = [x for x in range(200) if x % 2 == 0]
       
      
JextCopier dans Jext
En français, cette instruction consiste à placer dans la liste chaque x élément de l'intervalle [0..200] si le modulo 2 de cet élément égal 0.



Définition des listes

L'instruction conditionelle "if" n'est pas obligatoire. Une telle construction est extrêment puissante et facilite grandement le travaile du programmeur. Imaginons une autre déclaration par extension permettant de mettre la première lettre de chaque mot de la liste en majuscule:

noms = ['lord', 'gfx', 'rico', 'bgw']
liste = [nom[0].upper() + nom[1:] for nom in noms]
       
      
JextCopier dans Jext
Cet exemple montre que Python considère les chaînes de caractères comme des listes dont chaque élément correspond à un caractère.

Pour atteindre un élément d'une liste, il suffit de taper "liste[index]". Python permet également d'utiliser des "tranches" de listes (ou "slices" en anglais). Il s'agit typiquement de définir un intervalle dans lequel prendre des éléments. L'utilisation d'une "tranche" renvoie une liste:

print noms[1:3] # ['gfx', 'rico']
print noms[2:] # ['rico', 'bgw']
print noms[:2] # ['lord', 'gfx']
print noms[1:-1] # ['gfx, 'rico']
       
      
JextCopier dans Jext
Un "slice" est défini par l'utilisation du caractère "deux-points". Les bornes supérieure et inférieure sont précisées. Si l'une des bornes est omise, Python utilise alors la borne minimale (0) ou maximale (longueur de la liste) suivant le cas. Finalement, "noms[2:]" équivaut à "prendre tous les noms de la liste compris entre l'index 2 et la fin". L'utilisation de nombres négatifs provoque l'indexation des éléments depuis la fin de la liste, ainsi "noms[-1]" retourne "bgw". Les "tranches" deviennent très utiles lors de la manipulation de chaînes de caractères ou lors de la séparation d'une pile en deux.



Correspondance entre chaîne et liste

La longueur d'une liste, c'est à dire le nombre d'éléments qu'elle contient, correspond à la valeur renvoyée par la fonction "len(liste)". Puisque les chaînes de caractères sont également des listes, cette fonction s'applique aux chaînes également. Les listes ne nous ont pas encore dévoilé tous leurs secrets. Sachez que l'on peut s'en servir comme des tables à clés (par le biais de l'utilisation de "tuples", qui permettent également de retourner plusieurs valeurs depuis une fonction) ou comme des piles.


 Téléchargement

L'archive cours3.zip recèle des exemples relatifs aux listes et aux modules.



par Romain Guy
romain.guy@jext.org
http://www.jext.org
Dernière mise à jour : 14/10/2006


Précédent  
  Python  
  Suivant

 
#ProgX©2005 Mathieu GINOD - Romain GUY - Erik LOUISE