Introduction au Python

From Deimos.fr / Bloc Notes Informatique
Jump to: navigation, search

Contents

Python

Software version 2.7 / 3.2
Operating System
Website Python Website
Last Update 06/06/2012
Others

1 Introduction

Python est un langage de programmation interprété multi-paradigme. Il favorise la programmation impérative structurée, et orientée objet. Il est doté d'un typage dynamique fort, d'une gestion automatique de la mémoire par ramasse-miettes et d'un système de gestion d'exceptions ; il est ainsi similaire à Perl, Ruby, Scheme, Smalltalk et Tcl.

Le langage Python est placé sous une licence libre proche de la licence BSD et fonctionne sur la plupart des plates-formes informatiques, des supercalculateurs aux ordinateurs centraux, de Windows à Unix en passant par Linux et MacOS, avec Java ou encore .NET. Il est conçu pour optimiser la productivité des programmeurs en offrant des outils de haut niveau et une syntaxe simple à utiliser. Il est également apprécié par les pédagogues qui y trouvent un langage où la syntaxe, clairement séparée des mécanismes de bas niveau, permet une initiation plus aisée aux concepts de base de la programmation.

Parmi tous les langages de programmation disponibles à l'heure actuelle, Python est un des plus faciles à apprendre. Python a été créé à la fin des années 80 et a énormément mûri depuis. Il est pré-installé dans la plupart des distributions Linux et est souvent un des plus négligés quand on choisit un langage à apprendre. Nous allons nous confronter à la programmation en ligne de commande, jouerons avec la programmation GUI (Graphical User Interface). Sautons à l'eau en créant une application simple.

Dans cette documentation, nous verrons comment écrire en python et utiliserons l'interpréteur (via la commande python). Les lignes ci dessous correspondant à l'interpréteur seront visible via les éléments de ce type : '>>>' ou '...'

Lorsque vous écrivez un fichier qui devra comprendre le Python, il devra contenir ceci tout au début (le Shebang et l'encodage) :

#!/usr/bin/env python
# -*- coding:utf-8 -*-

La ligne d'encodage est optionnelle mais nécessaire si vous utilisez des accents.

2 La Syntaxe

En python, on doit indenter nos lignes pour que ce soit lisible et surtout pour que cela fonctionne. Il faut indenter à l'aide de tabulations ou d'espaces. Attention à ne pas mélanger les deux, Python n'aime pas ça du tout : votre code ne fonctionnera pas et vous n'obtiendrez pas de message d'erreur explicite.

Vous pouvez utiliser des commentaires à la fin des lignes si vous le souhaitez. Voici un exemple :

bloc1
   blabla # comment1
Suite du bloc1
   blibli # comment2

La fin d'un bloc se fait automatiquement avec un saut de ligne.

3 help

Sachez qu'à tout moment vous avez la possibilité de demander de l'aide grâce à la commande help. Par exemple pour l'aide de la méthode input :

>>> help(input)
Help on built-in function input in module __builtin__:
 
input(...)
    input([prompt]) -> value
 
    Equivalent to eval(raw_input(prompt)).

Vous pouvez également avoir accès à cette aide depuis le shell en utilisant la commande pydoc :

Command pydoc
pydoc input

4 Afficher du texte

Nous allons voir la première commande la plus basique, afficher du texte :

>>> print 'Deimos Fr'
Deimos Fr

Puis voici comment concaténer 2 éléments :

>>> print 'Deimos ' + 'Fr'
Deimos Fr
>>> print 'Deimos', 'Fr'
Deimos Fr

Dans le cas de l'utilisation de la virgule, les chaînes sont automatiquement séparées par un caractère espace alors qu'en utilisant la concaténation il faut gérer manuellement ce soucis.
Si vous concaténez des variables non chaînées, il vous faudra les convertir avant de pouvoir les afficher :

>>> c = 3
>>> print 'Valeur : ' + c Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
>>> print 'Valeur : ' + str(c)
Valeur : 3
>>> print 'Valeur :', c
Valeur : 3

Si vous ne souhaitez pas avoir un retour à la ligne automatique (l'équivalent du "\n"), il faut simplement mettre une virgule à la fin de votre ligne :

>>> print 'Pas de \n',

En Python 3.2, voici comment faire du print :

>>> print('Deimos', 'Fr')
Deimos Fr

4.1 sep

En Python 3.2, avec sep nous pouvons séparer des chaines par des caractères :

>>> print('Deimos', 'Fr', sep='--')
Deimos--Fr
>>> print('a', 'b', 'c', 'd', sep=',')
a,b,c,d

4.2 end

En Python 3.2, avec end nous pouvons ajouter à la fin d'une chaine, un caractère :

>>> print('Deimos', 'Fr', sep='--', end='!')
Deimos--Fr!

5 Les données

Il existe plusieurs types de données en Python :

  • Les entiers : permettent de représenter les entiers sur 32 bits (de - 2 147 483 648 à 2 147 483 647).
>>> type(2)
<type 'int'>
>>> type(2147483647)
<type 'int'>
  • Les entiers long : tout entier ne pouvant être représenté sur 32 bits. On peut forcer un entier en entier long en le faisant suivre de la lettre L ou l.
>>> type(2147483648)
<type 'long'>
>>> type(2L)
<type 'long'>
  • Les Flottants : Le symbole utilisé pour déterminer la partie décimale est le point. On peut également utiliser la lettre E ou e pour signaler un exposant en base 10.
>>> type(6.15)
<class 'float'>
>>> 3e1
30.0
>>> type(3e1)
<class 'float'>

6 Les calculs

Pour faire des divisions, il faut faire attention, les résultats dépendent du contexte ! Voyez par vous même :

>>> 7/6
1
>>> 7.0/6.0
1.1666666666666667
>>> 7//6
1

Attention aux opérations ! Voici un exemple :

>>> ((0.7+0.1)*10)
7.999999999999999

Vous le voyez, il y a un problème d'arrondis !

il est possible d'effectuer une opération en utilisant l'ancienne valeur d'une variable à l'aide de +=, -=, *= et /= (variable += valeuréquivautà variable = variable + valeur). Par exemple :

>>> a = 1
>>> a
1
>>> a += 2
>>> a
3

Et vous pouvez également effectuer des affectations multiples de variables ayant des valeurs différentes en séparant les noms de variables et les valeurs par des virgules :

>>> a, b = 1, 2
>>> a
1
>>> b
2

Pour élever un nombre à une puissance quelconque il faut utiliser l'opérateur ** :

>>> 2*3
8

7 Les chaines de caractères

La concaténation (assemblage de plusieurs chaînes pour n'en produire qu'une seule) se fait à l'aide de l'opérateur +. L'opérateur * permet de répéter une chaîne. Exemples :

>>> a = "Hello"
>>> b = 'World !'
>>> a+b
'Hello World !'
>>> 3*a
'Hello Hello Hello '

L'accès à un caractère particulier de la chaîne se fait en indiquant sa position entre crochets (le premier caractère est à la position 0) :

>>> a[0]
'H'

8 Les booléens

Les valeurs booléennes sont notées True ou False. Dans le cadre d'un test, les valeurs 0, (chaîne vide) et None sont considérées comme False. Voici les opérateurs de comparaison :

  • == : pour l'égalité
  •  != : pour la différence
  • < : inférieur
  • > : supérieur
  • <= : inférieur ou égale
  • >= : supérieur ou égale
>>> 1 == 2
False
>>> 1 <= 2
True

Pour combiner les tests, on utilise les opérateurs booléens :

  • and
  • or
  • not
>>> 0 and True
0
>>> 1 and True
True
>>> not (0 or True)
False

9 Les Structures

9.1 if

Voici comment se construit un if :

if condition:
# Traitement bloc 1 # ...
else:
# Traitement bloc 2 # ...

9.2 for

Voici une boucle for avec une liste :

>>> for e in ['tata', 'toto', 'titi']:
... print e
...
tata
toto
titi

Nous allons utiliser ici une liste avec 2 nouveaux paramètres qui sont continue et break :

>>> range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for i in range(0,10):
...   if i==2:
...      continue
...   if i==4:
...      break
...   print i
...
0
2
3
  • continue : permet de passer à l'élément suivant
  • break : arrête la boucle dans laquelle il est

9.3 While

Voici l'exemple d'une boucle while

>>> i = 0
>>> while i<5:
...   i += 1
...   if i==2:
...      continue
...   if i==4:
...      break
...   print i
1
3
  • continue : permet de passer à l'élément suivant
  • break : arrête la boucle dans laquelle il est

10 Les listes

10.1 Chaines de caractères

Comme pour une liste, on peut accéder à ses éléments (les caractères) en spécifiant un indice :

>>> chaine = 'Pierre Mavro'
>>> chaine[0]
'P'

Par contre, il est impossible de modifier une chaîne de caractères ! On dit alors qu'il s'agit d'une liste non modifiable :

>>> chaine[1] = 'a'
Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

En fait, ici, nous réalisons une nouvelle affectation : la variable chaine est écrasée (effacée puis remplacée) par la valeur chaine + '!'. Il ne s'agit pas d'une modification au sens propre du terme.

En Python 2.7 on utilisera les expressions de formatage issues du C :

  •  %d : pour un entier
  •  %f : pour un flottant
  •  %s : pour une chaîne de caractères
  •  %.3f : pour forcer l'affichage de 3 chiffres après la virgule
  •  %02d : pour forcer l'affichage d'un entier sur deux caractères
>>> c = 1
>>> d = 2
>>> '%d * %d = %d' % (c, d, c*d)
'1 * 2 = 2'

En Python 3.2 :

>>> '{} * {} = {}'.format(c, d, c*d)
'2 * 3 = 6'
>>> chaine = 'Un entier sur deux chiffres : {:02d}'
>>> chaine.format(6)
'Un entier sur deux chiffres : 06'

10.2 Les Tuples

Les tuples sont également des listes non modifiables (les chaînes de caractères sont donc en fait des tuples particuliers) :

>>> t = (1, 2, 3)
>>> t[0]
1
>>> l = [1, 2, 3]
>>> t = tuple(l)
>>> t
(1, 2, 3)
>>> l
[1, 2, 3]
>>> t = tuple('1234')
>>> t
('1', '2', '3', '4')

Pour rappel, un tuple ne contenant qu'un seul élément est noté entre parenthèses, mais avec une virgule précédant la dernière parenthèse :

>>> t = (1,)
>>> t
(1,)

10.3 Utiliser les listes

10.3.1 Modifier les listes

Pour modifier les listes :

>>> l = [ 1, 2, 3, 4]
>>> l
[1, 2, 3, 4]
>>> l[0] = 0
>>> l
[0, 2, 3, 4]

10.3.2 Ajouter un élément à la fin de liste

La méthode append() ajoute un élément en fin de liste :

>>> l = [ 1, 2, 3, 4]
>>> l.append(5)
>>> l
[0, 2, 3, 4, 5]

10.3.3 Ajouter un élément à un endroit définit d'une liste

La méthode insert() permet de spécifier l'indice où insérer un élément :

>>> l = [ 0, 2, 3, 4]
>>> l.insert(1, 1)
>>> l
[0, 1, 2, 3, 4, 5]

10.3.4 Supprimer un élément à un endroit définit d'une liste

Pour supprimer un élément, on peut utiliser la méthode remove()/del() qui supprime la première occurrence de la valeur passée en paramètre :

>>> l = [ 1, 2, 3, 1 ]
>>> l.remove(1)
>>> l
[2, 3, 1]
>>> l.remove(1)
>>> l
[2, 3]
>>> l.remove(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module> ValueError: list.remove(x): x not in list
>>> l = [ 1, 2, 3, 1 ]

10.3.5 Concaténer 2 listes

La méthode extend() permet de réaliser la concaténation de deux listes sans réaffectation. Cette opération est réalisable avec réaffectation en utilisant l'opérateur + :

>>> l1 = [ 1, 2, 3 ]
>>> l2 = [ 4, 5, 6 ]
>>> l1.extend(l2)
>>> l1
[1, 2, 3, 4, 5, 6]
>>> l1 = [ 1, 2, 3 ]
>>> l1 = l1 + l2
>>> l1
[1, 2, 3, 4, 5, 6]

10.3.6 Vérifier si un élément appartient à une liste

Si l'élément testé est dans la liste, la valeur retournée sera True et sinon ce sera False :

>>> guys = [ 'tata', 'toto', 'titi' ]
>>> 'tata' in guys
True
>>> 'tutu' in guys
False

10.3.7 Récupérer la taille d'une liste

Si l'on veut connaitre le nombre d'éléments présents dans une liste :

>>> l = [ 1, 2, 3 ]
>>> len(l)
3

10.3.8 Compréhension de listes

Python implémente un mécanisme appelé "compréhension de listes", permettant d'utiliser une fonction qui sera appliquée sur chacun des éléments d'une liste :

>>> l = [ 0, 1, 2, 3, 4, 5 ]
>>> carre = [ x**2 for x in l ]>>> carre
[0, 1, 4, 9, 16, 25]

Grâce à l'instruction for x in l, on récupère chacun des éléments contenus dans la liste l et on les place dans la variable x. On calcule ensuite ensuite toutes les valeurs au carré (x**2) dans la liste, ce qui produit une nouvelle liste. Ce mécanisme peut produire des résultats plus complexes. Il peut également être utilisé avec les dictionnaires.

10.4 Le Slicing

Le slicing est une méthode applicable à tous les objets de type liste (sauf les dictionnaires). C'est un "découpage en tranches" des éléments d'une liste pour récupérer certains objets. Cela se traduit sous cette forme :

d[début:fin:pas]

Voici un exemple :

>>> c = 'Deimos Fr'
>>> c[0:6]
'Deimos'
>>> c[7:8]
'Fr'
  • Aucune indication de pas n'a été donnée, c'est la valeur par défaut qui est alors utilisée, c'est-à-dire 1.
  • Si la valeur de début absente, la valeur par défaut utilisée sera 0
  • Si la valeur de fin est omise, la valeur par défaut utilisée sera la taille de la chaîne + 1

10.4.1 Lire une chaine

Pour récupérer la chaine entière :

>>> c[:]
'Deimos Fr'

Pour inverser le sens :

>>> c[::-1]
'rF somieD'

10.4.2 Accéder au dernier élément de la liste

Pour accéder au dernier élément de la liste :

>>> c[-2:]
'Fr'

Si vous donnez comme intervalle [-2:-1], vous n'aurez pas la dernière lettre, et si vous donnez [-2:0] vous n'obtiendrez rien puisqu'il est impossible d'aller de -2 à 0 avec un pas de 1 (la dernière lettre étant -1).

10.4.3 Sur les Tuples

Appliqué aux listes et aux tuples, le slicing réagit de la même manière. La différence est que l'on ne manipule plus uniquement des caractères mais n'importe quel type de données :

>>> guys = [ 'toto', 'tata', 'titi', 'tutu' ]
>>> guys[1:3]
['tata', 'titi']
>>> guys[-1::-2]
['tata', 'tata']
>>> t_guys = ('toto', 'tata', 'titi', 'tutu')
>>> t_guys[::-1]
('tutu', 'titi', 'tata', 'toto')

10.4.4 Supprimer des éléments d'une liste

Voici du slicing sur une liste pour supprimer des éléments :

>>> guys = [ 'toto', 'tata', 'titi', 'tutu' ]
>>> guys[1:3] = []
('tutu', 'toto')

10.4.5 Copie de listes

Regardez ceci si vous souhaitez faire des copies de liste :

>>> liste_a = [ 1, 2, 3 ]
>>> liste_b = liste_a
>>> liste_a
[1, 2, 3]
>>> liste_b
[1, 2, 3]
>>> liste_b[0] = 0
>>> liste_b
[0, 2, 3]
>>> liste_a
[0, 2, 3]

Vous remarquez qu'en fait les 2 listes sont touchées car en fait, cela agit comme un alias ! Pour faire une copie, il y a donc 2 solution ! Voici la première, il faut utiliser [:] :

>>> liste_a = [ 1, 2, 3 ]
>>> liste_b = liste_a[:]
>>> liste_a
[1, 2, 3]
>>> liste_b
[1, 2, 3]
>>> liste_b[0] = 0
>>> liste_b
[0, 2, 3]
>>> liste_a
[1, 2, 3]

11 Les dictionnaires

11.1 Suppression de clés

Les dictionnaires sont des listes de type clé => valeurs. Comme pour les listes, la commande del permet de supprimer un élément et le mot key in permet de vérifier l'existence d'une clé :

>>> d = { 'key_1' : 1, 'key_2' : 2, 'key_3' : 3 }
>>> del d['key_2']
>>> d
{'key_3': 3, 'key_1': 1}
>>> 'key_1' in d True
>>> 'key_2' in d False

Si les listes ne sont pas dans l'ordre souhaité, c'est tout simplement parce que les dictionnaires ne sont pas ordonnés !

11.2 Récupérer les clés et valeurs

Sur python 2.7, pour lire les clés et valeurs d'une liste :

>>> guys = { 'tata' : 1, 'toto' : 2, 'titi' : 3 }
>>> guys.keys()
['toto', 'titi', 'tata']
>>> guys.values()
[2, 3, 1]
>>> guys.items()
[('toto', 2), ('titi', 3), ('tata', 1)]

Sur Python 3.2, c'est un petit peu différent :

>>> guys = { 'tata' : 1, 'toto' : 2, 'titi' : 3 }
>>> guys.keys()
dict_keys(['toto', 'titi', 'tata'])
>>> guys.values()
dict_values([2, 3, 1])
>>> guys.items()
dict_items([('toto', 2), ('titi', 3), ('tata', 1)])

Les dictionnaires ne consomment pas autant de mémoire que pour stocker une liste, on ne stocke qu'un pointeur vers l'élément courant.

11.3 Ajouter une erreur si un élément n'est pas trouvé

Il existe une solution pour retournée une valeur de substitution si aucune valeur n'est trouvée lors d'une recherche dans une liste grâce à la méthode get() :

>>> guys = { 'tata' : 1, 'toto' : 2, 'titi' : 3 }
>>> guys.get('toto', 'not found')
2
>>> guys.get('salades', 'not found')
'not found'

11.4 Concaténer des dictionnaires

On peut, tout comme les liste faire des concaténations de dictionnaire avec la méthode update():

>>> guys = { 'tata' : 1, 'toto' : 2 }
>>> guys_2 = { 'titi' : 3, 'tutu' : 4 }
>>> guys.update(guys_2)
>>> guys
{'tata': 1, 'toto': 2, 'titi': 3, 'tutu': 4}

11.5 Copier un dictionnaire

Pour copier un dictionnaire déjà existant, il faut utiliser la méthode copy() :

>>> dico_a = {'key_1' : 1, 'key_2' : 2, 'key_3' : 3 }
>>> dico_b = dico_a.copy()
>>> dico_a
{'key_2': 2, 'key_3': 3, 'key_1': 1}
>>> dico_b
{'key_2': 2, 'key_3': 3, 'key_1': 1}
>>> dico_b['key_1'] = 0
>>> dico_b
{'key_2': 2, 'key_3': 3, 'key_1': 0}
>>> dico_a
{'key_2': 2, 'key_3': 3, 'key_1': 1}

12 Dictionnaires et Listes complexes

12.1 pickle

Il existe une solution pour sauvegarder et restituer simplement des structures complexes (listes.dictionnaires multidimensionnelles par exemple) grâce à la sérialisation, qui s'appelle Pickle. L'utilisation de pickle reste très dangereuse : n'utilisez que des fichiers pour lesquels les données peuvent être vérifiées, car le chargement d'un fichier corrompu peut conduire à l'exécution d'un code malicieux !

>>> try:
...    import cPickle as pickle
... except:
...    import pickle
...

12.1.1 dump

Pour écrire les données, on va ouvrir un fichier en mode binaire (wb). On utilisera alors la fonction dump() pour écrire une variable en précisant en paramètre l'objet-fichier :

>>> file = open('data', 'wb')
>>> pickle.dump(data, file)
>>> file.close()

Pour lire les données depuis un fichier (rb), on utilisera la fonction load() en lui passant en paramètre l'objet-fichier :

>>> file = open('data', 'rb')
>>> var = pickle.load(file)
>>> var
{'tata': 1, 'toto': 2, 'titi': 3, 'tutu': 4, 'tete': [a, b, c, d]}
file.close()

12.1.2 dumps

Si vous voulez voir la sérialisation d'une variable, vous pourrez utiliser la fonction dumps(), qui effectue la même tâche que dump(), mais dans une chaîne de caractères et non un fichier :

>>> pickle.dumps(data)
"(dp1\nS'tata'\np2..."

12.2 ConfigParser

Cette fonction permet de gérer les fichiers de type ini. C'est donc très pratique pour la gestion de fichiers de configuration. Pour ceux qui ne voient pas à quoi ça ressemble :

[section1]
   option_1 = value_1
   option_2 = value_2
[section2]
   option_3 = value_3
   option_4 = value_4

Nous pouvons accéder à la valeur d'une option dans une section particulière :

>>> from ConfigParser import SafeConfigParser
>>> parser = SafeConfigParser()
>>> parser.read('file.ini')
['file.ini']
>>> print parser.get('section1', 'option_1')
value_1

Pour tout récupérer d'une section :

>>> from ConfigParser import SafeConfigParser
>>> parser = SafeConfigParser()
>>> parser.read('file.ini')
['file.ini']
for name in parser.options('section1'):
... print 'Option : ' + name
... print ' ' + parser.get('section1', name)
...
Option : option_1
value_1
Option : option_2
value_2

13 Stdin

Le STDIN permet d'afficher un message à l'écran et pour qu'un utilisateur puisse saisir des caractères au clavier et qu'il appuie sur la touche entrée pour valider. En Python 2.7 il existe 2 solutions :

  • input() : récupère un entier ou un flottant
  • raw_input() : récupère une chaîne de caractères

13.1 input

Avec la fonction input(), la saisie d'une chaîne de caractères entraînera la tentative d'interprétation de celle-ci en tant que variable et donc provoquera une erreur :

>>> c = input('Give an integer : ')
Give an integer : 1
>>> c
1
>>> c = input('Give an integer : ')
Give an integer : hello
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module> NameError: name 'hello' is not defined
>>> a = 1
>>> c = input('Give an integer : ') Give an integer : a
>>> c
1

En Python 3.2, il n'y a plus qu'une seule fonction input().

Les principales fonctions de conversion sont :

  • int() pour convertir en entier
  • float() pour convertir en flottant
  • complex() pour convertir en complexe
  • str() pour convertir en chaîne de caractères (inutile dans le cadre d'une utilisation avec input()).

13.2 raw_input

raw_input() est plus simple puisque toute saisie sera considérée comme chaîne de caractères :

>>> c = raw_input('Give a string :')
Give a string :
hello
>>> c
'hello'
>>> c = raw_input('Give a string :')
Give a string :
2
>>> c
'2'

14 Handles

14.1 Se déplacer dans un dossier

Il est possible de se déplacer dans un dossier via la fonction chdir() :

from os import chdir
chdir('/etc')

14.2 Lecture de fichier

Il est possible d'ouvrir des fichiers en lecture(r), écriture(w) et ajout(a) :

file = open('file.txt', 'mode')
file.close()

Ici par exemple, nous allons ouvrir un fichier nommé fichier.txt et il faut saisir le mode (r/w/a).

14.2.1 Read

On peut lire la totalité d'un fichier pour travailler sur son contenu par la suite (attention la taille du fichier sera contenue en mémoire) :

>>> file_content = file.read()
>>> file_content
'1st line\n2nd line \n3rd Line\n'

Vous noterez que les retours à la ligne ne sont pas interprétés ! Pour les interpréter, il va falloir utiliser print :

>>> print file_content
1st line
2nd line
3rd Line

Il est possible de lire x caractères depuis l'emplacement de lecture (le début par défaut ou à partir d'un autre endroit si avez déjà commencé à lire le fichier) :

>>> file = open('file.txt', 'r')
>>> file_content = file.read(8)>>> print file_content
1st line
>>> file_content = file.read(8)>>> print file_content file_content
2nd line

On lit les 8 premiers caractères, puis les 8 autres.

14.2.2 Readline

readlines() est identique à la fonction read(), à l'exception que les données seront envoyées dans une liste dont chaque élément contiendra une ligne (avec un \n à chaque fin de ligne) :

>>> file_content = file.readlines()
>>> file_content
['1st line\n', '2nd line\n', '3rd Line\n']

14.3 Écriture dans un fichier

Pour écrire dans un fichier, c'est très simple, nous allons faire appel à la fonction write :

file = open('file.txt', 'w')
file.write('Write this text')
file.close()

14.4 Strip

Vous connaissez peut être chomp en Perl, la fonction strip() permet de faire la même chose, c'est à dire de supprimer les caractères non visibles (espaces, tabulations, retours à la ligne) du début et de la fin d'une chaîne de caractères. Cette fonction fait partie du module string et comporte deux variantes :

  • lstrip() : ne supprime les caractères qu'au début de la chaîne ('l' pour left - gauche)
  • rstrip() : ne supprime les caractères qu'à la fin de la chaîne ('r' pour right - droite)
>>> from string import strip, lstrip, rstrip
>>> line = ' Deimos Fr\n '
>>> strip(line)
'Deimos Fr'
>>> lstrip(line)
'Deimos Fr\n '
>>> rstrip(line)
' Deimos Fr'

15 Les fonctions

Voici comment nous définissons une fonction (def) et nous l'appelons avec son nom et des parenthèses à la fin :

>>> def fonction:
...   print "Hello World"
>>> fonction()

15.1 Documentation des fonctions

La documentation relative à une fonction s'écrit à l'aide de triples guillemets :

>>> def fonction(x):
...   """ Ici j'écris ma documentation...   sur la fonction ici présente....   Et je termine comme ceci"""...   return x**2
...
>>> help(fonction)
>>> Help on function fonction in module __main__:
fonction()
Ici j'écris ma documentation
sur la fonction ici présente.
Et je termine comme ceci

Vous avez vu ensuite, nous pouvons demander l'aide d'une fonction directement depuis Python.

15.2 Les paramètres de fonction

En Python, tous les paramètres passés font appels à leur adresse mémoire ! Par contre, comme certains types ne sont pas modifiables, on aura alors l'impression qu'ils sont passés par valeur. Les types non modifiables sont les types simples (entiers, flottants, complexes, etc.), les chaînes de caractères et les tuples :

>>> def plusone(a):
...    a = a + 1
...
>>> value = 3
>>> value
3
>>> plusone(value)
>>> value
3

Avec un paramètre modifiable, tel qu'une liste, les modifications seront visibles en sortie de la fonction.

Ici nous lui demandons de prendre l'argument de la fonction (x) et de l'élever à la puissance. La fonction retournera le résultat grâce au return. Si une fonction n'a pas de return de renseigné, la valeur de retour sera None.

>>> def fonction(x):
...    return x**2
...
>>> fonction(3)
9

Si des paramètres ne sont pas spécifiés lors de l'appel à la fonction, ce seront les valeurs par défaut qui seront utilisées. La seule obligation est que les paramètres ayant une valeur par défaut doivent être renseignés à la fin de la liste des paramètres. Voici un exemple avec ses appels :

>>> def fonction(a, b, c=0, d=1):
...    print a, b, c, d
... 
>>> fonction(1, 2)
1 2 0 1
>>> fonction(1, 2, 3)
1 2 3 1

Vous l'avez compris, on peut donc déclarer des valeurs par défaut et les écraser à la demande en les passants en argument. L'ordre des paramètres d'une fonction n'est pas fixé si on les nommes :

>>> def fonction_ordre(a, b):
...    return a
...
>>> fonction_ordre(b=1, a=2)
2

15.3 Le nombre d'arguments d'une fonction

En Python, on est pas obligé de définir au préalable le nombre d'arguments qui vont être utilisés. On utilise pour cela les *args et les **kwargs :

  • *args : tuple contenant la liste des paramètres passés par l'utilisateur
  • **kwargs : dictionnaire des paramètres

La différence entre les deux syntaxes (* ou **) est le type de la variable de retour :

>>> def exemple_args(*args):
...    print args
>>> exemple_args(1, 2, "hello")
(1, 2, 'hello')
>>> def exemple_kwargs(**kwargs):
...   print kwargs
>>> exemple_kwargs(a=1, b=2, text="hello")
{'a': 1, 'text': 'hello', 'b': 2}

16 Les modules

Les modules sont très utiles, puisqu'ils correspondent à des fonctions déjà toute faite, permettant de gagner beaucoup de temps lorsqu'on les utilisent. Les imports peuvent être placés n'importe où dans le code et peuvent être intégrés à des boucles conditionnelles. Mais il est beaucoup plus simple de les retrouver en tête de fichier.

Pour charger un module avec toutes ses fonctions :

from module_name1 import *
import module_name2

Ici on demande à Python de charger en mémoire toutes les fonctions (*) du module module_name1.
Si nous ne mettons pas (*), il faudra préfixer le nom du module avant de faire appel à sa fonction :

module_name2.function1()

Si l'on souhaites importer seulement quelques fonctions d'un module (prends moins de place en mémoire et permet de n'utiliser que ce que nous souhaitons) :

from module_name import function1, function2

Note : En cas de noms de fonctions identiques, c'est le dernier import qui prime sur ceux d'avant !

Si vous manipulez des modules ayant un nom très long, vous pourrez définir un alias grâce au mot-clé 'as'. Par exemple un module nommé ModuleAuNomTresLong et contenant la fonction func(). À chaque appel à func() vous n'allez quand même pas écrire : ModuleAuNomTresLong.func()... Donc il faut utiliser as :

import ModuleAuNomTresLong as myModule
myModule.func()

Si lors d'un import de module, il contient des instructions à exécution immédiate (qui ne sont pas dans des fonctions), ces dernières seront exécutées au moment de l'import. Pour différencier le comportement de l'interpréteur lors d'une exécution directe d'un module ou lors du chargement de celui-ci, il existe un test spécifique à ajouter qui permet de déterminer une sorte de programme principal dans le module :

>>> def function():
... print 'Deimos Fr'
...
>>> if __name__ == '__main__':
...    print 'Test function function()'
>>> function()

Pour définir le corps du programme principale, insérez cette ligne :

if __name__ == '__main__':

16.1 Les Paths des modules

Par défaut, Python commence par rechercher :

  1. Dans le répertoire courant
  2. Dans le ou les répertoire(s) spécifié(s) par la variable d'environnement PYTHONPATH (si définie)
  3. Dans le répertoire des bibliothèques de Python : /usr/lib/python<version>

Faites donc très attention en nommant vos fichiers : s'ils portent le nom d'un module Python existant, il seront importés à la place du dernier puisque l'import recherche d'abord les modules dans le répertoire courant.

Voici un exemple du PYTHONPATH (variables d'environnement) :

export PYTHONPATH=$PYTHONPATH:~/.python_libs

Pour indiquer que A est un "répertoire module", nous créerons un fichier supplémentaire dans le dossier contenant le module : '_ _init_ _.py'. Ce fichier peut ne rien contenir ou contenir des fonctions. Les modules sont également appelés paquetage.

17 String

string est installé par défaut avec Python. Il fournit de nombreuses méthodes permettant de rechercher du texte et de remplacer des chaînes de caractères. Il permet d'éviter l'utilisation des regex qui peuvent dans certains cas s'avérer très couteuses en CPU si elles sont mal écrites.

17.1 split

La fonction split() permet de découper une chaîne de caractères qui lui est passée en paramètre suivant un ou des caractères de séparation et renvoie une liste des chaînes découpées. Si rien n'est spécifier, c'est le caractère espace qui sera utilisé :

>>> import string
>>> s = 'deimos:x:1000:1000::/home/deimos:/usr/bin/zsh'
>>> string.split(s, ':')
['deimos', 'x', '1000', '1000', '', '/home/deimos', '/usr/bin/zsh']
>>> p = 'Bloc Notes Info'
>>> string.split(p)
['Bloc', 'Notes', 'Info']

17.2 Join

Join est l'inverse de split et permet de joindre plusieurs éléments entre eux via un ou des caractères de séparation :

>>> l = [ 'a', 'b', 'c', 'd' ]
>>> ' => '.join(l)
'a => b => c => d'

17.3 Lower

Lower permet de convertir une chaine de caractères en minuscules :

>>> s = 'Bloc Notes Info'
>>> s.lower()
'bloc notes info'
>>> s
'Bloc Notes Info'

Attention : Nous parlons de conversion mais ces méthodes ne modifient pas la chaîne de départ mais renvoient une nouvelle chaîne !!!

17.4 Upper

Upper permet de convertir une chaine de caractères en majuscules :

>>> s = 'Bloc Notes Info'
>>> s.upper()
'BLOC NOTES INFO'
>>> s
'Bloc Notes Info'

Attention : Nous parlons de conversion mais ces méthodes ne modifient pas la chaîne de départ mais renvoient une nouvelle chaîne !!!

17.5 Capitalize

Ce fonction permet de ne mettre en majuscule que la première lettre d'une chaîne :

>>> s = 'bloc Notes Info'
>>> string.capitalize(s)
'Bloc notes info'

17.6 Capwords

Capwords permet de mettre une majuscule à chaque début de mot :

>>> s = 'bloc Notes Info'
>>> string.capwords(s)
'Bloc Notes Info'

17.7 Count

La fonction count() permet de compter le nombre d'occurrences d'une sous-chaîne dans une chaîne de caractères. Le premier paramètre est la chaîne dans laquelle effectuer la recherche et le second paramètre est la sous-chaîne :

>>> p = 'one guy, two guys, three guys'
>>> string.count(p, 'guy')
3
>>> string.count(p, 'guys')
2

17.8 Find

La fonction find() permet de trouver l'indice de la première occurrence d'une sous-chaîne. Les paramètres sont les mêmes que pour la fonction count() :

>>> s = 'one guy, two guys, three guys'
>>> string.find(s, 'guy')
3
>>> string.find(s, 'four')
-1

En cas d'échec, find() renvoie la valeur -1 (0 correspond à l'indice du premier caractère).

17.9 Replace

La fonction replace() permet, comme son nom l'indique, de remplacer une sous-chaîne par une autre à l'intérieur d'une chaîne de caractères. Les paramètres sont, dans l'ordre :

  1. La chaîne de caractères à modifier
  2. La sous-chaîne à remplacer
  3. La sous-chaîne de remplacement
  4. Le nombre maximum d'occurrences à remplacer (si non spécifié, toutes les occurrences seront remplacées), ceci est optionnel
>>> s = 'one guy, two guys, three guys'
>>> string.replace(s, 'guy', 'girl')
'one girl, two girls, three girls'
>>> string.replace(s, 'guy', 'girl', 1)
'one girl, two guys, three guys'

17.10 Maketrans

maketrans() crée la table de traduction et grâce à la fonction translate(), lui applique les traductions sur une chaîne de caractères :

>>> hack = string.maketrans('aei', '43!')
>>> s = 'Ecriture de Hacker'
>>> s.translate(hack)
'3cr!tur3 d3 h4ck3r'

Lors de la création de la table avec maketrans(), chaque caractère de première position est transformé avec les caractères dans la deuxième position. Donc les e sont remplacés par des 3, a par 4 et i par !.

17.11 Substitute et Safe_substitute

Il existe plus simple que maketrans(). Nous pouvons écrire ceci d'une façon plus lisible et plus souple :

>>> s = string.Template("""
... Show one var : $var
... In another one : $var2
... In a text : ${var}iable
... Vars names : $$var et $$var2
... """)
>>> values = { 'var' : 'variable', 'var2' : '123456' }
>>> s.substitute(values)
'\nShow one var : variable\nIn another one : 123456\nIn a text : variableiable\nVars names : $var et $var2\n'
  • $$ permet d'afficher le caractère $
  • ${var_name} permet d'isoler une variable comprise dans un mot

Vous devez utiliser la fonction safe_substitute() si vous ne souhaitez pas que Python provoque une erreur en cas de non substitution (car absent du dictionnaire) :

[...]
>>> s.safe_substitute(values)
[...]

18 Regex

Une regex permet par exemple de trouver des éléments au sein d'une ligne/phrase qui pourraient correspondre à certains élément mais dont nous n'avons pas toujours de certitude.

18.1 Search

Nous utiliserons alors le module re qui propose la fonction search() :

>>> pattern = '\d{4}'
>>> date = 'Year : 1982'
>>> match = re.search(pattern, date)
>>> print 'Pattern', match.re.pattern, 'is located :', match.start(), '-', match.end()
Pattern \d{4} is located : 8 - 11

Si le motif n'est pas trouvé, la fonction search() renvoie la valeur None.

Si vous utilisez fréquemment le même motif de recherche, il est préférable de le compiler de manière à avoir un code plus efficace :

>>> pattern = re.compile('\d{4}')
>>> match = pattern.search(pattern)

Lorsque vous utilisez des motifs complexes, il est recommandé de les commenter et d'écrire donc une expression régulière "verbeuse". Dans ce mode, il faut ignorer les espaces multiples et les commentaires :

>>> pattern="""
... ^                       # Debut de ligne
... Deimos\s                # Prenom
... Fr                      # Nom
... $                       # Fin de ligne
... """
>>> match = re.search(pattern, 'Deimos Fr', re.VERBOSE)

Attention : la fonction search() ne permet de retrouver que la première sous-chaîne correspondant au motif recherché !

18.2 Liste des regex

Voici les regex les plus connues :

Opérateur Description Exemple
^ Début de ligne ^Deimos pour 'Deimos Fr !!!'
$ Fin de ligne !$ pour 'Deimos Fr !!!'
. N'importe quel caractère d.im.s pour 'Deimos Fr !!!'
* Répétition du caractère précédent de 0 à x fois !* pour 'Deimos Fr !!!'
+ Répétition du caractère précédent de 1 à x fois !+ pour 'Deimos Fr !!!'
? Répétition du caractère précédent de 0 à 1 fois F? pour 'Deimos Fr !!!'
\ Caractère d’échappement \. pour 'Deimos Fr\.'
a,b,...z Caractère précis Deimos pour 'Deimos Fr'
\w Caractère alphanumérique (a...z,A...Z,0...9) \weimos pour 'Deimos Fr'
\W Tout sauf un caractère alphanumérique I\Wll pour 'I'll be back'
\d Un chiffre \d pour 1
\D Tout sauf un chiffre \Deimos pour Deimos
\s Un caractère d'espacement tel que : espace, tabulation, retour chariot ou saut de ligne (\f,\t,\r,\n) 'Deimos\sFr' pour 'Deimos Fr'
\S Tout sauf un caractère d'espacement 'Deimos\SFr' pour 'Deimos Fr'
{x} Répète le caractère précédent exactement x fois !{3} dans 'Deimos Fr !!!'
{x,} Répète le caractère précédent au moins x fois !{2} dans 'Deimos Fr !!!'
{, x} Répète entre 0 et x fois le caractère précédent !{3} dans 'Deimos Fr !!!'
{x, y} Répète entre x et y fois le caractère précédent !{1, 3} dans 'Deimos Fr !!!'
[] Permet de mettre un range (de a à z[a-z], de 0 à 9[0-9]...) [A-D][0-5] dans 'A4'
[^] Permet de spécifier des caractères non désirés [^0-9]eimos dans 'Deimos'
() Permet d'enregistrer le contenu des parenthèses pour une utilisation ultérieure (Deimos) dans 'Deimos Fr'
| Permet de faire un ou exclusif (Org|Fr|Com) dans 'Deimos Fr'

Il existe un site permettant de visualiser une regex : Regexper (sources : https://github.com/javallone/regexper)

18.3 Recherche tous motifs

Si vous souhaitez retrouver toutes les occurrences d'une chaîne, il faut utiliser findall(). Ça fonctionne de la même manière que search() mais renvoie une liste de chaînes de caractères correspondant au motif recherché :

>>> pattern = "\d{4}"
>>> years = "Years : 1981, 1982, 1983"
>>> for m in re.findall(pattern, years):
...    print "Year :", m
...
Year : 1981
Year : 1982
Year : 1983

Si vous souhaitez obtenir un élément vous fournissant les mêmes informations que search(), c'est la fonction finditer() qu'il faudra utiliser :

>>> pattern = "\d{4}"
>>> years = "Years : 1981, 1982, 1983"
>>> for m in re.finditer(pattern, years):
...    print 'Pattern', m.re.pattern, 'found on position :', m.start(), ',', m.end()
...
Pattern \d{4} found on position : 8 , 12
Pattern \d{4} found on position : 14 , 18
Pattern \d{4} found on position : 20 , 24

18.4 Mémoriser et utiliser les motifs trouvés

Les expressions régulières permettent de faire référence à un élément noté entre parenthèses. On peut ensuite les appeler en se référent (de gauche à droite) à la parenthèse numéro n (précédée d'un antislash). Pour résumer, à la première parenthèse rencontré, vous utilisez 1, à la deuxième 2, etc... :

>>> pattern = r'^Nom : ([A-Z][a-z]+) Prenom : ([A-Z][a-z]+) Mail : \2\1@deimos.fr$'
>>> match = re.search(pattern, 'Nom : Deimos Prenom : Fr Mail : [email protected]')

Nous avons précédé le pattern r'...'. Ceci permet de déterminer une chaîne brute (raw string) qui interprétera différemment les anti-slashes (ils ne protègent aucun caractère et doivent donc être considérés en tant que caractères à part entière).

Pour une meilleure lisibilité, il est possible de nommer les éléments capturés :

(?P<nom>motif)

Et les utiliser :

(?P=nom)

Exemple :

>>> pattern = r'^Nom : (?P<name>[A-Z][a-z]+) Prenom : (?P<firstname>[A-Z][a-z]+) Mail : (?P=firstname)(?P=name)@deimos.fr$'
>>> match = re.search(pattern, 'Nom : Deimos Prenom : Fr Mail : [email protected]')

18.4.1 Groups

On peut également récupérer la valeur capturée après un appel à une fonction de type search(). Les éléments sont récupérés dans une liste grâce à la fonction groups() et peuvent être obtenus en utilisant la fonction group() qui prend en paramètre le numéro de l'élément (commence à 1, et pour l'indice 0 la fonction renvoie toute la chaîne).

>>> pattern = '^Nom : ([A-Z][a-z]+) Prenom : ([A-Z][a-z]+)'
>>> import re
>>> match = re.search(pattern, 'Nom : Fr Prenom : Deimos$')
>>> match.groups()
('Fr', 'Deimos')
>>> match.group(0)
'Nom : Fr Prenom : Deimos'
>>> match.group(1)
'Fr'
>>> match.group(2)
'Deimos'

On peut également les obtenir dans un dictionnaire à l'aide de la fonction groupdict() (si vous avez nommé les éléments capturés, c'est cette méthode qu'il faudra choisir). Voyons tout d'abord un exemple d'application avec les fonctions groups() et group() :

>> pattern = '^Nom : (?P<name>[A-Z][a-z]+) Prenom : (?P<firstname>[A-Z][a-z]+)$'
>>> import re
>>> match = re.search(pattern, 'Nom : Fr Prenom : Deimos')
>>> match.groupdict()
{'name': 'Fr', 'firstname': 'Deimos'}
>>> m = match.groupdict()
>>> m['name']
'Fr'
>>> m['firstname']
'Deimos'

18.5 Paramètres de recherche

Il est possible dans une recherche d'indiquer certains paramètres, nous allons les voir ici :

Option Description
IGNORECASE Effectue une recherche non sensible à la casse
MULTILINE La recherche peut contenir plusieurs lignes séparées par un retour à la ligne (caractère \n)
DOTALL La recherche peut contenir plusieurs lignes séparées par un point (caractère .)
UNICODE Permet d'utiliser l'encodage Unicode pour la recherche (utile avec les caractères accentués). Vos chaînes devront être données au format Unicode en les préfixant par u (Inutile en Python 3.2):
u'chaîne Unicode'

Vous pouvez également spécifier plusieurs options avec un pipe :

>>> pattern = '^deimos$'
>>> match = re.search(pattern, 'deimos\nfr', re.MULTILINE | re.IGNORECASE)
>>> match.start()
0

18.6 Paramètres dans les patterns

Les paramètres précédents peuvent être indiqués directement dans les patterns (?option) :

Option de pattern Correspondance
i IGNORECASE
m MULTILINE
s DOTALL
u UNICODE
x VERBOSE

Voici un exemple :

>>> pattern = '(?i)(?m)^deimos$'
>>> match = re.search(pattern, 'deimos\nfr')
>>> match.start()
0

18.7 Substitution

La substitution se fait à l'aide de la méthode sub() et retourne la chaîne de caractères modifiée :

>>> pattern = '(org|com)$'
>>> re.sub(pattern, 'fr', 'deimos com')
'deimos fr'

Pour des éléments capturés nommés, nous utiliserons \g<nom> :

>>> pattern = '(?P<name>org|com)$'
>>> re.sub(pattern, r'\g<name>', 'deimos fr')
'deimos fr'

sub() effectue les substitutions pour toutes les occurrences du motif rencontrées !

Pour limiter les substitutions aux n premières chaînes correspondant au motif, il faudra utiliser la fonction subn() :

>>> pattern = '(org|com)$'
>>> re.subn(pattern, r'\g<name>', 'deimos fr deimos fr deimos fr', count=2)
('deimos fr deimos fr deimos org', 2)

18.7.1 Split

Pour finir, signalons l'existence d'une fonction split() où les caractères de séparation sont déterminés par un motif :

>>> pattern = '-\*-|--|\*'
>>> re.split(pattern, '1-*-2--3--4*5*6-*-7')
['1', '2', '3', '4', '5', '6', '7']

19 argv

En Python, la façon la plus simple de travailler en prenant en compte la saisie d'arguments sur la ligne de commandes est d'utiliser le module sys.

import sys
print 'Nombre d\'arguments :', str(len(sys.argv)1)
print 'Nom du script :', sys.argv[0]
print 'Paramètres :'
 
for i in range(1, len(sys.argv)):
   print 'sys.argv[' + str(i) + '] = ' + sys.argv[i]

Vous remarquerez qu'il faut faire -1 pour connaitre le nombre d'arguments !

Au lancement du script :

Command example.py
> python example.py 1 2 'Deimos Fr'
Nombre d'arguments : 3
Nom du script : example.py
Paramètres :
sys.argv[1] = 1
sys.argv[2] = 2
sys.argv[3] = Deimos Fr

20 argparse

Le module argparse est la nouvelle version du module optparse qui est maintenant deprecated. Nous allons créer un objet ArgumentParser qui va contenir la liste des arguments :

import argparse
parser = argparse.ArgumentParser(description='Description', epilog='Epilog')
  • description : permet d'indiquer par un petit commentaire ce que fait votre script
  • epilog : le texte qui sera affiché à la fin de l'aide. Ces textes seront utilisés lors de l'affichage de l'aide générée automatiquement.

20.1 Ajouter des arguments à argparse

Définissons une option -a qui ne collecte aucune information et indiquera seulement si l'utilisateur l'a utilisée lors de l'appel à la commande (True) ou non (False) :

parser.add_argument('-a', action='store_true', default=False, help='Description de l\'argument a')

N'oubliez pas que ce module gère automatiquement l'aide :-). Par contre nous pouvons déclarer la version de la commande :

parser.add_argument('-v', '--version', action='store_true', help='Version de la commande')

Nous pouvons utiliser ici -v ou --version, sachant que c'est le premier argument contenant -- qui sera celui à utiliser lors de la récupération d'arguments.

  • Si on souhaites rendre un argument obligatoire :
parser.add_argument('-a', action='store', required=True)
  • On peut spécifier le nombre d'arguments nécessaires :
parser.add_argument('-a', action='store', nargs=2)

Ici le nombre d'arguments attendus est de 2 et sera renvoyé dans une liste (args.a). Vous pouvez mettre la présence possible de cette variable avec un ? à nargs.
Tout comme les regex, il est possible également de mettre * à nargs pour spécifier 0 ou plusieurs arguments. Et enfin le + pour 1 à plusieurs arguments.

20.1.1 Actions d'arguments

Il existe plusieurs actions possible pour les arguments :

  • store : C'est l'action par défaut qui sauvegarde la valeur que l'utilisateur aura entrée
  • store_const : Permet de définir une valeur par défaut si l'utilisateur saisit l'argument. Sinon la variable args.v contiendra la valeur 'Non'e :
parser.add_argument('-v', action='store_const', const='Default value', help='Give help')
args = parser.parse_args()
  • store_true/store_false : Si l'argument est spécifié, la valeur sera true, sinon false. En cas d'absence d'argument, la variable args.v prend la valeur booléenne inverse de celle indiquée par l'action store.
  • append : Enregistre la valeur dans une liste. Si plusieurs appels au même argument sont spécifiés, alors elles sont ajoutées à cette même liste :
parser.add_argument('-l', action='append', help='Values list')
args = parser.parse_args()
  • append_const : C'est un mix entre store_const et append. Il permet de sauvegarder des éléments prédéfinit dans une liste :
parser.add_argument('-l', action='append_const', const='Default value', help='Values list')
args = parser.parse_args()
  • verison : Permet d'indiquer la version du soft.
parser.add_argument('-v', action='version', version='%(prog)s v0.1 Licence GPLv2', help='Version')
args = parser.parse_args()

%(prog)s fait référence au nom du script s'exécutant (comme sys.argv[0]).

20.1.2 Choisir ses caractères de préfixe d'arguments

Si nous souhaitons utiliser d'autres caractères que - ou --, il est possible par exemple de rajouter + :

parser = argparse.ArgumentParser(description='Description', prefix_ chars='-+')

On peut par exemple un cas d'utilisation ou on ajoute des options (+option) ou on en supprime (-option).

20.1.3 Forcer les valeurs

Il est possible de forcer les valeurs saisies par l'utilisateur en spécifiant un type (int, float, bool, file...). Ceci permet de faire de la conversion de données à la volée et de vérifier que les valeurs saisies par l'utilisateur sont du type attendues :

parser.add_argument('-i', action='store', type=int, help='Give an integer')
args = parser.parse_args()

On peut également définir une valeur par défaut en toute circonstance :

parser.add_argument('-i', action='store', type=int, default=10, help='Give an integer')
args = parser.parse_args()

Note : Un appel à la commande sans spécifier d'argument -a initialisera tout de même la variable args.i avec la valeur 10.

20.1.4 Gérer les doublons

Si on déclare 2 fois le même argument, il est possible (mais pas propre) de faire régler ça automatiquement par python. La dernière valeur écrasera alors la ou les premières :

parser.add_argument('--other_a', '-a', action='store')
parser.add_argument('-a', action='store')
parser = argparse.ArgumentParser(description='Description', conflict_handler='resolve')

20.1.5 Groupes d'options

  • Pour une meilleure lisibilité, il est possible de grouper certaines options lors de l'affichage de l'aide :
group1 = parser.add_argument_group('login')
group1.add_argument('-u', action='store', metavar='name', help='Login')
group1.add_argument('-p', action='store', metavar='password', help='Password')
 
group2 = parser.add_argument_group('io')
group2.add_argument('-i', action='store', metavar='filename', help='Input file')
group2.add_argument('-o', action='store', metavar='filename', help='Output file')
  • Il est également possible de définir des groupes dont une seule option est sélectionnable sous peine de se faire jetter si on en demande plus d'une :
group = parser.add_mutually_exclusive_group('Filesystems')group.add_argument('-z', action='store', metavar='zfs', help='Choose ZFS')
group.add_argument('-b', action='store', metavar='btrfs', help='Choose BTRFS')

20.2 Utiliser la commande

Le script que nous venons de créer dispose des options -a et -h pour l'aide qui est générée automatiquement :

Command python
> python example.py
usage: example.py [-h] [-a]
 
Description de ma commande
 
optional arguments:
   -h, --help show this help message and exit
   -a Description de l'argument a

20.3 Utiliser les arguments

Pour affichage de la liste des arguments :

print args

Pour afficher la valeur de l'argument -a :

print args.a

20.4 Récupérer les arguments

Pour récupérer les arguments que l'utilisateur aura saisi :

args = parser.parse_args()

21 References

http://inforef.be/swi/python.htm
http://diamond.izibookstore.com/produit/50/9786000048501/Linux%20Pratique%20HS%20n23%20%20La%20programmation%20avec%20Python
http://docs.python.org/library/string.html