4.3. Système

Ce chapitre est fortement lié au précédent, et c’est pour cette raison qu’il sera très court : nous nous contenterons d’aborder les dernières fonctions utiles du module os ainsi que celle du module sys.

4.3.1. Informations sur Python

Le module sys permet d’obtenir des informations sur certaines propriétés de la version Python qui est utilisée, ainsi que sur son comportement.

sys.path

Liste des dossiers dans lesquels Python cherche les modules à importer (voir Modules).

sys.modules

Liste des modules importés par le programme (voir Modules).

sys.version

Donne des informations sur la version de Python qui est utilisée.

sys.version_info

Donne, sous forme d’un tuple, des informations sur la version de Python. Cette forme peut être plus pratique à utilisée lorsqu’il s’agit de tester si la version utilisée correspond à certains critères.

>>> if sys.version_info[0] < 3:
...     print('La version de Python que vous utilisez est trop ancienne.')
sys.float_info

Donne, sous forme d’un objet, des informations sur les nombres à virgule du système (précision, taille maximale…).

sys.getfilesystemencoding()

Renvoie le nom de l’encodage utilisé par le système.

Voici quelques exemples :

>>> sys.version 
'3.1.1 (default, Feb  5 2010, 20:43:13) \n[GCC 4.4.2 20091222 (Red Hat 4.4.2-20)]'
>>> sys.version_info 
sys.version_info(major=3, minor=1, micro=1, releaselevel='final', serial=0)

4.3.2. Informations sur le système

Le module os permet d’accéder à de nombreuses informations sur le système.

os.name

Indique le nom du système. Les principales possibilités sont : “posix” (Linux, Mac), “nt” (Windows).

os.getcwd()

Indique le répertoire de travail, c’est à dire, en quelque sorte, l’endroit où sont exécutés les scripts : tout chemin relatif partira de ce dernier. Il est possible de le changer avec chdir().

os.uname()

Renvoie un 5-tuple contenant : le nom du système, le nom de la machine, la version du système et le type d’architecture.

Voici quelques exemples :

>>> os.name
'posix'
>>> os.getcwd()
'/mnt/data/Documents/Projets/Enseignements/Python'
>>> os.uname() 
('Linux', 'harold-laptop', '2.6.32.9-70.fc12.i686.PAE', '#1 SMP Wed Mar 3 04:57:21 UTC 2010', 'i686')

4.3.3. Arguments en ligne de commande

Lorsque l’on crée un programme, il peut être très utile de lui donner des informations supplémentaires dès le lancement afin de modifier son comportement ou pour éviter d’utiliser input(). Ceci peut être réalisé en utilisant des arguments de ligne de commandes : il s’agit simplement de texte (qui peut représenter un nom de fichier, un nombre, une chaine…) qui se place après le nom du fichier, c’est à dire, dans un terminal, on écrira :

$ python file.py arg1 arg2 arg3 ...

Il est ensuite possible de récupérer les arguments grâce à l’attribut sys.argv [1] : il s’agit d’une liste qui contient tous les arguments (le premier élément étant le nom du fichier).

Warning

Les éléments de sys.argv sont toujours des chaines de caractères.

On peut imaginer, par exemple, vérifier si l’argument -v est présent pour activer le mode verbeux et aussi donner la possibilité de donner un nom de fichier pour sauvegarder dans ce dernier le résultat du script.

'''
Le code suivant affiche la somme des cinq premiers entiers. Si le mode
verbeux est activé, alors il affiche les résultats intermédiaires. Si un
nom de fichier est donné, il écrira le résultat dans ce fichier, sinon
il l'affichera à l'écran.
'''

from sys import argv

if '-v' in argv:
    VERBOSE = True
else:
    VERBOSE = False

if '-f' in argv:
    # on récupère l'index de l'élément qui suit "-f".
    index = argv.index('-f') + 1
    FILE = argv[index]
else:
    FILE = None

s = 0

for i in range(6):
    s += i
    if VERBOSE is True:
        print(s)

if FILE is None:
    print('Le résultat est :', s)
else:
    result_file = open(FILE, 'w')
    result_file.write(str(s))
    result_file.close()
    print('Le résultat a été sauvegardé dans :', FILE)

Testons notre code :

$ python3.1 commandline.py
Le résultat est : 15
$ python3.1 commandline.py -v
0
1
3
6
10
15
Le résultat est : 15
$ python3.1 commandline.py -f fichier.txt
Le résultat a été sauvegardé dans : fichier.txt

Le module optparse permet une gestion beaucoup plus poussée des arguments passé en ligne de commande.

Footnotes

[1]sys.argc permet d’obtenir le nombre d’arguments. Cela revient au même que len(sys.argv).

4.3.4. Exercices

  1. Corriger le programme donner en exemple dans la dernier section afin d’ajouter une gestion des exceptions : par exemple prendre en compte le cas où -f n’est pas suivi d’un nom de fichier. On pourra aussi vérifier si le dossier où l’on veut sauvegarder le fichier existe.
  2. Corriger le script précédent afin de permettre à l’utilisateur d’entre le nombre n d’entiers qu’il veut sommer.

Table des matières

Sujet précédent

4.2. Gestion des fichiers et dossiers

Sujet suivant

4.4. Classes étendues

Cette page