Programmation Python
Madame Jinen Daghrir
Email: jinen.daghrir@gmail.com
Eléments du contenu
Modules
Fonctions
Dictionnaires, tuples et sets
Quelques modules d’intérêt: numpy, pandas, matplotlib
Modules
Les modules sont des programmes Python qui contiennent des fonctions que l’on est
amené à réutiliser souvent (on les appelle aussi bibliothèques ou libraries).
Ce sont des « boîtes à outils » qui vont vous être très utiles.
Importation de modules:
>>> import random
>>> random . randint (0, 10)
4
Ligne 1, l’instruction import donne accès à toutes les fonctions du module random 2.
Ensuite, ligne 2, nous utilisons la fonction randint(0, 10) du module random. Cette
fonction renvoie un nombre entier tiré aléatoirement entre 0 inclus et 10 inclus.
Modules
L’utilisation de la syntaxe import module permet d’importer tout une série de
fonctions organisées par «thèmes ». Par exemple, les fonctions gérant les nombres
aléatoires avec random et les fonctions mathématiques avec math.
Python possède de nombreux autres modules internes
>>> import math
>>> math . cos ( math .pi / 2)
6.123233995736766 e -17
>>> math . sin ( math .pi / 2)
1.0
Il existe un autre moyen d’importer une ou plusieurs fonctions d’un module :
>>> from random import randint
>>> randint (0 ,10)
7
Modules
On peut également importer toutes les fonctions d’un module :
>>> from random import *
>>> x = [1, 2, 3, 4]
>>> shuffle (x)
>>> x
[2, 3, 1, 4]
>>> shuffle (x)
>>> x
[4, 2, 1, 3]
L’instruction from random import * importe toutes les fonctions du module random.
On peut ainsi utiliser toutes ses fonctions directement.
Dans la pratique, plutôt que de charger toutes les fonctions d’un module en une seule
fois : from random import *, il est conseillé de charger le module seul de la
manière suivante : import random puis d’appeler explicitement les fonctions
voulues, par exemple : random . randint (0 ,2)
Modules
Il est également possible de définir un alias (une abréviation ) pour un module.
>>> import random as rand
>>> rand . randint (1, 10)
6
>>> rand . uniform (1, 3)
2.643472616544236
Pour vider de la mémoire un module déjà chargé, on peut utiliser l’instruction del :
>>> import random
>>> random . randint (0 ,10)
2
>>> del random
>>> random . randint (0 ,10)
Traceback ( most recent call last ):
File "<stdin >", line 1, in ?
NameError : name 'random ' is not defined
Modules
Obtenir de l’aide sur les modules importés: Pour obtenir de l’aide sur un module
rien de plus simple, il suffit d’utiliser la commande help() :
>>> import random
>>> help ( random )
[...]
Help on module random :
NAME
random - Random variable generators .
MODULE REFERENCE
https :// docs . python .org /3.7/ library / random
The following documentation is automatically generated from the Python
source files . It may be incomplete , incorrect or include features that are
considered implementation detail and may vary between Python
implementations . When in doubt , consult the module reference at the location
listed above
Modules
Vous pouvez également obtenir de l’aide sur une fonction particulière d’un module de
la manière suivante : help(random.randint)
Pour connaître d’un seul coup d’oeil toutes les méthodes ou variables associées à un
objet, utilisez la fonction dir() :
>>> import random
>>> dir ( random )
['BPF ', 'LOG4 ', 'NV_MAGICCONST ', 'RECIP_BPF ', 'Random ',
'SG_MAGICCONST ', 'SystemRandom ', 'TWOPI ', 'WichmannHill ',
'_BuiltinMethodType ', '_MethodType ', '__all__ ', '__builtins__ ', '__doc__ ',
'__file__ ', '__name__ ', '_acos ', '_ceil ', '_cos ', '_e ', '_exp ', '_hexlify ', '_inst ',
'_log ', '_pi ','_random ', '_sin ', '_sqrt ', '_test ', '_test_generator ', '_urandom ', '_wa
rn ', 'betavariate ', 'choice ', 'expovariate ', 'gammavariate ', 'gauss ', 'getrandbits ',
'getstate ', 'jumpahead ', 'lognormvariate ', 'normalvariate ', 'paretovariate ', 'randint ',’
random ', 'randrange ', 'sample ', 'seed ', 'setstate ', 'shuffle ', 'uniform ',
'vonmisesvariate ', 'weibullvariate ']
Modules
Quelques modules courants: Il existe une série de modules que vous serez
probablement amenés à utiliser si vous programmez en Python:
math : fonctions et constantes mathématiques de base (sin, cos, exp, pi. . . ).
os : dialogue avec le système d’exploitation (cf. plus bas).
random : génération de nombres aléatoires.
time : accès à l’heure de l’ordinateur et aux fonctions gérant le temps.
urllib : récupération de données sur internet depuis Python.
Tkinter : interface python avec Tk. Création d’objets graphiques .
re : gestion des expressions régulières.
NumPy: manipulations de vecteur ,matrices, algèbre linéaire).
Matplotlib: représentations graphiques : courbes, nuages de points, diagrammes en
bâtons.
Pandas: analyse et manipulation de données, lire des données à partir des fichies
Excel.
Fonctions
Les fonctions sont très utiles pour réaliser plusieurs fois la même opération au sein d’un
programme.
Elles rendent également le code plus lisible et plus clair en le fractionnant en blocs
logiques.
Par exemple math.cos(angle) du module math renvoie le cosinus de la variable angle
exprimé en radian. Vous connaissez aussi des fonctions internes à Python comme range()
ou len(). Une fonction est une sorte de « boîte noire » :
1. À laquelle vous passez aucune, une ou plusieurs variable(s) entre parenthèses. Ces variables sont
appelées arguments. Il peut s’agir de n’importe quel type d’objet Python.
2. Qui effectue une action.
3. Et qui renvoie un objet Python ou rien du tout.
Par exemple, si vous appelez la fonction len() de la manière suivante :
>>> len ([0 , 1, 2])
3
1) vous appelez len() en lui passant une liste en argument (ici la liste [0, 1, 2]) ; 2) la fonction calcule la longueur de
cette liste ; 3) elle vous renvoie un entier égal à cette longueur.
Fonctions
Définition: Pour définir une fonction, Python utilise le mot-clé def. Si on souhaite que
la fonction renvoie quelque chose, il faut utiliser le mot-clé return.
Exemple:
>>> def carre (x):
... return x **2
...
>>> print ( carre (2))
4
Notez que la syntaxe de def utilise les deux-points comme les boucles for et while
ainsi que les tests if, un bloc d’instructions est donc attendu. De même que pour les
boucles et les tests, l’indentation de ce bloc d’instructions (qu’on appelle le corps
de la fonction) est obligatoire.
Dans l’exemple précédent, nous avons passé un argument à la fonction carre() qui
nous a renvoyé (ou retourné) une valeur que nous avons immédiatement affichée à
l’écran avec l’instruction print().
Fonctions
Notez qu’une fonction ne prend pas forcément un argument et ne renvoie pas
forcément une valeur, par exemple :
>>> def hello ():
... print (" bonjour ")
...
>>> hello ()
bonjour
Dans ce cas la fonction, hello() se contente d’afficher la chaîne de caractères
"bonjour" à l’écran. Elle ne prend aucun argument et ne renvoie rien.
Passage d’arguments: Le nombre d’arguments que l’on peut passer à une fonction est
variable( peut être 0 ou 1 argument).
Le nombre d’argument est donc laissé libre à l’initiative du programmeur qui
développe une nouvelle fonction.
Fonctions
Une particularité des fonctions en Python est que vous n’êtes pas obligé de préciser le
type des arguments.
Python est en effet connu comme étant un langage au « typage dynamique », c’est-à-
dire qu’il reconnaît pour vous le type des variables au moment de l’exécution.
>>> def fois (x, y):
... return x*y
3 ...
>>> fois (2, 3)
6
>>> fois (3.1415 , 5.23)
16.430045000000003
>>> fois ('to ', 2)
'toto '
>>> fois ([1 ,3] , 2)
[1, 3, 1, 3]
L’opérateur * reconnaît plusieurs types (entiers, floats, chaînes de caractères, listes).
Notre fonction fois() est donc capable d’effectuer des tâches différentes.
Fonctions
Renvoi de résultats: les fonctions en Python sont capables de renvoyer plusieurs objets
à la fois, comme dans cet example :
>>> def carre_cube (x):
... return x**2 , x **3
...
>>> carre_cube (2)
(4, 8) # tuple
En réalité Python ne renvoie qu’un seul objet, mais celui-ci peut être séquentiel,
c’est-à-dire contenir lui même d’autre objets.
La fonction pourrait tout autant renvoyer une liste :
>>> def carre_cube2 (x):
... return [x**2 , x **3]
...
>>> carre_cube2 (3)
[9, 27]
Fonctions
Renvoyer un tuple ou une liste de deux éléments (ou plus) est très pratique en
conjonction avec l’affectation multiple, par exemple :
>>> z1 , z2 = carre_cube2 (3)
>>> z1
9
>>> z2
27
Arguments positionnels et arguments par mot-clé:
>>> def fois (x, y):
... return x*y
...
>>> fois (2, 3)
6
>>> fois (2)
erreur
Fonctions
Arguments positionnels et arguments par mot-clé: Lorsqu’on définit une fonction
def fct(x, y) : les arguments x et y sont appelés arguments positionnels (en anglais
positional arguments). Il est strictement obligatoire de les préciser lors de l’appel de
la fonction. De plus, il est nécessaire de respecter le même ordre lors de l’appel que
dans la définition de la fonction.
Mais il est aussi possible de passer un ou plusieurs argument(s) de manière facultative
et de leur attribuer une valeur par défaut :
>>> def fct (x =1):
... return x
...
>>> fct ()
1
>>> fct (10)
10
Fonctions
Un argument défini avec une syntaxe def fct(arg=val): est appelé argument par
mot-clé (en anglais keyword argument). Le passage d’un tel argument lors de l’appel
de la fonction est facultatif. Ce type d’argument ne doit pas être confondu avec les
arguments positionnels présentés ci-dessus, dont la syntaxe est def fct(arg):.
def fct (x=0, y=0, z =0):
... return y, x, z
...
>>> fct ()
(0, 0, 0)
>>> fct (10)
(0,10,0)
>>> fct (10 , 8)
(8,10,0)
Fonctions
On observe que pour l’instant, les arguments par mot-clé sont pris dans l’ordre dans
lesquels on les passe lors de l’appel.
L’argument est précisé par mot-clé z et les valeurs de x et y sont gardé par défaut
Simplement en précisant le nom de l’argument lors de l’appel :
>>> fct (z =10)
(0, 0, 10)
Python permet même de rentrer les arguments par mot-clé dans un ordre arbitraire :
>>> fct (z=10 , x=3, y =80)
(80,3, 10)
>>> fct (z=10 , y =80)
(80,0, 10)
>>> fct(10,3,80)
Dictionnaires, tuples et sets
Dictionnaires: Les dictionnaires se révèlent très pratiques lorsque vous devez
manipuler des structures complexes à décrire et que les listes présentent leurs limites.
Les dictionnaires sont des collections non ordonnées d’objets, c’est-à-dire qu’il n’y a
pas de notion d’ordre (i.e. pas d’indice). On accède aux valeurs d’un dictionnaire par
des clés. Exemple:
>>> ani1 = {}
>>> ani1 [" nom "] = " girafe "
>>> ani1 [" taille "] = 5.0
>>> ani1 [" poids "] = 1100
>>> ani1
{'nom ': 'girafe ', 'taille ': 5.0 , 'poids ': 1100}
Dictionnaires, tuples et sets
Dictionnaires: Les dictionnaires se révèlent très pratiques lorsque vous devez
manipuler des structures complexes à décrire et que les listes présentent leurs limites.
Les dictionnaires sont des collections non ordonnées d’objets, c’est-à-dire qu’il n’y a
pas de notion d’ordre (i.e. pas d’indice). On accède aux valeurs d’un dictionnaire par
des clés. Exemple:
>>> ani1 = {}
>>> ani1 [" nom "] = " girafe "
>>> ani1 [" taille "] = 5.0
>>> ani1 [" poids "] = 1100
>>> ani1
{'nom ': 'girafe ', 'taille ': 5.0 , 'poids ': 1100}
