Université de Batna 2 département d’Informatique

Master I : Intelligence Artificiel et Multimédia (IAM) 2017/2018

Python
 Python ?
• Python est un langage de programmation de haut niveau,
interprété, orienté objet et interactive.
– Interpreté: il n’est pas nécessaire de compiler son programme
avant de l’éxécuter.
– Interactive: l’utilisateur pourra utiliser le Python prompt(>>>)
et interacte directement avec l’interpréteur du code.
– Orienté-Objet : Python supports la programmation Oreinté-
Objet.
• Python est doté de plusieurs caractéristiques, il englobe une
grande bibliothèque portable et compatible (UNIX,
Windows, et Macintosh).
 Type de variables
• La déclaration des variables n’est pas explicite.
• La déclaration se produit automatiquement lorsque vous
affecter une valeur à une variable. Le signe (=) est utilisé
pour affecter une valeur à une variable.
– Exemple :
name = "Ahmed" # string
age= 80 # integer
taille = 1.80 # float

• Remarque : avec python il est possible de faire plusieurs

affectation en même temps.
– Exemple:
a = b = c =1
name , age, taille = "Ahmed" , 80, 1.80
 Opération basique
• Opération arithmétique :
a , b = 9, 2
Opérateur Description Exemple Résultat Opérateur de Exemple
+ Addition a+b 11 comparaison

- Soustraction a-b 7 == a==b

* Multiplication a*b 18 != a!=b

/ Division a/b 4.5 < a<b

% Modulo a%b 1 > a>b

** Puissance a**b 81 <= a<=b

// Division entier a//b 4 >= a>=b

 Opération basique(2)
• Opérateur d’assignement :
a , b = 9, 2

Opérateur d’assignement Exemple Résultat de a

= a=b 2
+= a+=b 11
-= a-=b 7
*= a*=b 18
/= a/=b 4.5
%= a%=b 1
**= a**=b 81
//= a//=b 4
 Opération binaire
a , b = 01011101, 0011 1100

Opérateur Exemple Résultat de a

& a&b 00011100 # 28
| a|b 11111101 #125
^ a^b 01100001 #97
~ ~a 10100010 # -94
<< a<<2 10110100 #372
>> a>>2 00010111 #23
 Type de données
• Python a cinq types de données standard:
– Numbers (Valeurs numérique)
– String (Chaines de caractères)
– List
– Tuple
– Dictionary
 Valeurs numérique
• Python supports quatre types numériques différents: :
• int (signed integers)
• long (long integers)
• float
• complex (complex numbers)

int long float Complex

12 12548L 12.25 3+4j
-15 -213215L 0.01 -4j
1200 oxQBC47FL -15.0214 3-4j
 string
str = 'Hello World!'
print(str) # affichage de la chaine
print(str[0]) # affichage du premier caractère de la chaine
print(str[1:5]) # affichage des caractères de 2 à 5
print(str[2:]) # affichage de la chaine du 3ème caractère
print(str * 2) # double affichage de la chaine
print(str[:6] + "python") # affichage de la chaine avec
concatination
 Les listes
• Les listes c’est comme les tableaux en C, seulement les
éléments de la liste peuvent être de différents types :
ma_list = [0, ’12’, 5, ’chaine’]
Accès et modification des éléments :
• l’accè aux éléments et par indice, le premier élément a
l’indice 0.
ma_liste[1]
• L’indice peut être négatif, python ajoute à cette valeur le
nombre total d’élément pour trouver la case concernée.
ma_liste[-2]
– Modification :
ma_liste[0]=10
 Ajout d’un élément à une liste
• avec l’opérateur + :
L’opérateur + permet de concaténer deux listes, pour ajouter un
élément il faut le mettre entre deux crochets. L’ajout peut ce faire au
début ou à la fin.
Exemple Résultat
ma_list = [0, ’12’, 5, ’chaine’]+[1] ma_list : [0, ’12’, 5, ’chaine’ ,1]
ma_list =[exp] +ma_list ma_list : [exp ,0, ’12’, 5, ’chaine’ ,1]

• append :
La méthode append permet d’ajouter un élément à la fin de la liste.
Exemple Résultat
ma_list = [0, ’12’, 5, ’chaine’]
ma_list.append(20) ma_list : [exp ,0, ’12’, 5, ’chaine’ ,20]
 Ajout d’un élément à une liste(2)
• insert :
– La méthode insert permet d’insérer un élément à la position
spécifié, list.insert(position,element)
– Si la position d’insertion dépasse la taille de la liste, l’élément sera
inséré à la fin.
Exemple Résultat
ma_list = [0, ’12’, 5, ’chaine’]
ma_list.insert(1,20) ma_list : [0, 20, ’12’, 5, ’chaine’ ]
• extend :
– Cette méthode permet d’étendre une liste par une autre, comme
l’opérateur +:
Exemple Résultat
ma_list .extend([1]) ma_list : [0, ’12’, 5, ’chaine’ ,1]
list =[‘a’ , ‘b’] ma_list : [0, ’12’, 5, ’chaine’ , ‘a’ , ‘b’]
ma_list .extend(list)
 Suppression d’éléments d’une liste
• remove :
– La méthode remove permet de supprimer la première occurrence
d’un élément d’une liste lorsqu’il existe.
Exemple Résultat
ma_list = [0, 5 , ’12’, 5, ’chaine’]
ma_list .remove(5) ma_list : [0, ’12’, 5, ’chaine’ ]

• del :
– La fonction del supprime l’élément dont l’indice est fourni :
Exemple Résultat
ma_list = [0, 5 , ’12’, 5, ’chaine’]
del ma_list[2] ma_list : [0, 5, 5, ’chaine’ ]
 Suppression d’éléments d’une liste (2)
• Utilisation d’une liste vide:
– pour la suppression d’un ou de plusieurs éléments, on affecte à
notre liste à la position définie une liste vide.
Exemple Résultat
ma_list = [0, 5 , ’12’, 5, ’chaine’]
ma_list[1:3]=[] ma_list : [0, 5, ’chaine’ ]
• La fonction range :
– La fonction range permet de générer un intervalle. sa syntaxe est
range (a,b,c) avec a la borne inférieure incluse et b est la borne
supérieure exclue de la liste et c est le pas s’il est mentionné, sinon
c’est 1 par défaut.
• La fonction len :
– La fonction len permet de retourner le nombre d’éléments
existant dans une liste.
• L’instruction in :
– L’instruction in permet de déterminer l’appartenance d’un
élément à une structure.
• Python offre la possibilité de définir une liste par extension
comme suit :
nomliste=[ k for k in range (a,b,c) if condition_vrai ]
• Par exemple :
H=[2 *i for i in range (0,11) ] # liste des nombres paires inférieurs à 20
et supérieurs à 0.
K=[i for i in range (21) if i%2==0] # les mêmes éléments que ceux de
H.
M=[n for n in range (0,21,2)] # les mêmes éléments que pour les listes
H et K.
N=[x for x in M if x%3!=0] # liste des nombres pairs inférieurs à 20,
non multiples de 3.
L=[ i for i in range(0,21,5)]
P=[y for y in N if y not in L] # liste des nombres pairs inférieurs à 20,
non multiples de 3 et 5.
 Les tuples
• Un tuple c’est une séquence comme les listes ensemble de valeurs
séparés pas des virgules, mais de valeurs non modifiable (immutable).
• Création de tuple :
– Un tuple se définit comme une liste, sauf qu'on utilise comme
délimiteur des parenthèses au lieu des crochets.
– tuple1 =() # tuple vide
– tuple2 = (‘un’,) # tuple contient un seul élément n’oublier pas la ,
– tuple3 = (1, 45, 85 , ‘idx’ , ‘val’, 2) #tuple de données hétérogènes
• Accès aux élément : pour accéder aux valeurs d’un tuple, vous devez
utiliser les crochets [].
print(tuple3[2:5]) (85, 'idx', 'val')
print(tuple3[1]) 45

• Important : les tuples une fois créés, ne peuvent pas être modifiés
(insertion ou suppression non autorisées).
 Les dictionnaires
• Un dictionnaire est une autre structure de données qui
permet de stocker plusieurs valeurs, il nous permet de
stocker des valeurs en utilisant nos propres indices.
• Création de dictionnaire : un dictionnaire est une séquence
de paires « clé : valeur » séparées par virgules et mises entre
accolades.

dico1 = {} # dictionnaire vide

dico2 = {‘inf01’ : ’ahmed’ , ‘inf02’ : ’amine’ , ‘inf03’ : ’khaled’ }
dico3 = {‘a’ : 2.5 , ‘B’ : 21 , ‘C’ : 4 }
dico4 = dict(A=65 , a = 97)
dico5={}
dico5 ['math']=15
dico5 ['phy']=18
 Ajout et suppression d’élément
• Il est possible de mettre à jour un dictionnaire par insertion,
modification ou suppression des valeurs.
• Insertion :
dico2 = {‘inf01’ : ’ahmed’ , ‘inf02’ : ’amine’ , ‘inf03’ : ’khaled’ }
dico2[‘inf04’] = ‘bilal’
La clé "inf04" n’existe pas dans dico2, elle sera ajoutée avec la valeur "bilal"

• Modification :
dico2[‘inf03’] = ‘ibrahim’
La valeur de la clé "inf03" sera modifiée en "ibrahim"

• Suppression :
del dico2[‘inf03’] # supprimer la paire de clé "inf03"
dico2.clear() # vider le dictionnaire
del dico2 # supprimer tout le dictionnaire
 Parcours d’un dictionnaire
• Récupérer les clés :
fruits = {"pommes":21, "raisin":3, "poires":31}
for cle in fruits.keys():
print(cle)

• Récupérer les valeurs :

fruits = {"pommes":21, "raisin":3, "poires":31}

for valeur in fruits.values():
print(valeur)

• Récupérer les clés et les valeurs par une boucle

fruits = {"pommes":21, "raisin":3, "poires":31}

for cle , valeur in fruits.items():
print(cle , valeur)
 Méthodes de manipulation des dictionnaires

fruits.keys() Retourner la liste des clés du dictionnaire fruits

fruits.update( dico1) Mettre à jour le dictionnaire fruits par le dictionnaire dico1
fruits.items() Retourner la liste de paires (clé, valeur)
fruits.values() Retourner la liste des valeurs du dictionnaire fruits
fruits.clear() Vider le dictionnaire fruits
fruits.copy() Retourner une copie du dictionnaire fruits
fruits.fromkeys(keys , Créer un dictionnaire à partir de la liste keys et la valeur value.
value)
fruits.get(key, Retourne la valeur de la clé "key" si elle existe sinon retourne la
default) valuer default
 Input & output
• input :
Avec Python il est très facile pour un utilisateur d’interagir avec
son programme par la saisie des données.
– La fonction input() fournit en retour une chaîne de
caractères correspondant à ce que l’utilisateur a saisi.
• print :
– La fonction print() permet d’afficher n’importe quel
nombre de valeurs ou chaines de caractères fournies en
arguments
age = input('votre age : ')

print(age*2)
print(int(age)*2)
 Les conditions
• Condition if/else : exécute le bloc d’instruction si la condition est
vrai, sinon exécute le deuxième bloc.
• Exemple :
If condition : x=int(input())
bloc1 if x%2:
else : print(x, ' : est impaire')
bloc2 else:
print(x, ' : est paire')

• Multiple conditions elif (else if):

• Exemple : If condition : x = int(input())
bloc1 if x <= 15:
elif condition: y = x + 15
bloc2 elif x <= 30:
else : y = x + 30
bloc3 else:
y=x
print(' y =', y)
 Boucles
• L'instruction while permet d’exécuter une boucle tant que la
condition de test est vérifiée.
• Exemple : while condition : x=1
bloc1 while x<=10:
print(x ,'* 7 = ', x*7)
x+=1

• Python support l’utilisation de l’instruction else avec while.

• Exemple :
while condition : x=1
bloc1 while x<=10:
else : print(x ,'* 7 = ', x*7)
bloc2 x+=1
else:
print(‘fin de calcul’)
 Les boucles (2)
• L’instruction for permet d’exécuter des boucles, dans
lesquelles l’itération traite successivement tous les éléments
d’une séquence donnée, comme des listes ou chaine de
caractères.
for iterateur in sequence: liste=(5, 10, 15, 23, 13, 29)
bloc1 for nombre in liste:
print(’Le nombre est’,nombre)

for val in range (start, stop, step): for nombre in range(2, 11, 2):
bloc1 print ('la table de multiplication de ',nombre)
for nombre2 in range( 11):
print(nombre, '*', nombre2, '=', nombre*nombre2)
 Les boucles avec break et continue
• break permet de sortir immédiatement de la boucle for ou
while en cours.
for x in range(1, 11): Le résultat obtenu :
if x == 5:
break 1234
print(x) Boucle interrompue pour x = 5
print ("Boucle interrompue pour x =", x)

• continue permet de passer immédiatement à l’itération

suivante de la boucle for ou while en cours; reprend à la
ligne de l’en-tête de la boucle.
for x in range(1, 11): Le résultat obtenu :
if x == 5:
continue 1 2 3 4 6 7 8 9 10
print(x, end=" ") # la boucle a sauté la valeur 5
 Les fonctions
• La syntaxe Python pour la définition d’une fonction est la suivante :
def nomDeLaFonction(liste de paramètres): def min(a, b):
bloc d'instructions if a<b:
return a
else:
return b
• appel d’une fonction :
def min(a, b):
if a < b:
return a
else:
return b

x=int(input())
y=int(input())
print("le min entre",x, " et ", y , "est :",min(x,y))
 Paramètres des fonctions
• En python tous les paramètres des fonctions sont passés
par références
def init_List( mylist2 ): Le résultat obtenu :

mylist2+=[0,0,0,0] Values outside the function:

print("Values inside the function : ", mylist2) [10, 20, 30]
Values inside the function :
[0, 0, 0, 0]
mylist = [10,20,30]

print("Values outside the function: ", mylist)

init_List( mylist )

• Remarque : En Python vous ne pouvez définir deux

fonctions du même nom (la nouvelle définition écrasé
l'ancienne).
 Argument par défaut
• Un argument par défaut est affecté par défaut à la variable
si lord du l’appel de la fonction aucune valeur n’est assigné
à l’argument.
• Eexemple :

def printinfo( name, age = 35 ): Résultat :

print( "Name: ", name)
print("Age ", age) Name: miki
return Age 50
Name: miki
printinfo("miki", 50 ) Age 35
printinfo( "miki" )
 Lecture dans un fichier
• Pour ouvrir un fichier on utilise la fonction open().
• Elle prend deux paramètres :
– le chemin (absolu ou relatif) du fichier à ouvrir ;
– le mode d'ouverture. (r, w, a)

fileIn=open('test.txt','r')
contenu = fileIn.read()
print(contenu)

fileIn=open('test.txt','r')
#affichage du contenu de fichier ligne par ligne
for line in fileIn:
print('line:',line.rstrip())
 Lecture dans un fichier (2)
• Méthode readlines() : retourne une liste contenant toutes les lignes
du fichier.
fileIn=open('test.txt','r')
#affichage du contenu de fichier ligne par ligne
lignes = fileIn.readlines()
for line in lignes:
print('line:',line)

• La fonction split() découpe la ligne en mots, en utilisant comme

séparateur espace, tabulation ou un symbole spécifique entre "".
file=open('h:\\liensfirfox.txt','r')
#affichage du contenu de fichier mot par mot

for line in file:

words = line.split()
for word in words:
print('word :',word)
 Écriture dans un fichier
• Pour l’écriture il existe deux mode d’ouverture d’un fichier :
– " w" écrase le contenu éventuel du fichier.
– "a" ajoute ce que l'on écrit à la fin du fichier.
• la méthode write() permet l’écriture dans un fichier.

langages = ['c++\n', 'java\n', 'python\n', 'scala']

#ouverture du fichier en mode écriture
filout = open('h:\\file.txt', 'w')
for langage in langages:
#écriture dans le fichier
filout.write(langage)

filout.close() #fermer le fichier

 Numpy
• Numpy est une bibliothèque de fonctions spécialisées dans
la manipulation des vecteurs et des matrices (objet array)
sous python.
• Les objets de type array correspondent à des tableaux à une
ou plusieurs dimensions.
• Numpy englobe une grande variété de fonctions pour
l’accès rapide aux données, divers manipulations et calculs
sur les objets array.
– Unr bonne référence (Travis E. Oliphant. Guide to NumPy ), livre gratuit.
 CRÉATION D’UNE MATRICE
• Premier point importer le module « numpy »
– import numpy as np
• Création manuelle à partir
import numpy as np

mat = np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]])
print(mat) # affichage de la matrice

Print(mat.dtype) # type des données float64

#nombre de dimensions
Print(mat.ndim) #2 (car c’est une matrice)

#nombre de lignes et col, shape renvoie un tuple

print(mat.shape) #(3,2) 3 lignes et 2 colonnes

#nombre totale de valeurs

print(mat.size) #6, nb.lignes x nb.colonnes
 Création d’une matrice à partir d’un ensemble de valeurs
mat = np.array([[1,2],[4,7]]) #création et typage implicite
mat = np.array([[1,2],[4,7]],dtype=float) #création et typage explicite

#création à partir d'une séquence

#arange() génère une séquence de valeurs, 0 à 9.
#reshape() se charge de les réorganiser en matrice
mat = np.arange(0,10).reshape(2,5) [[0 1 2 3 4]
print(mat) [5 6 7 8 9]]

#matrices de valeurs identiques

mat = np.zeros(shape=(2,4)) [[ 0. 0. 0. 0.]
print(mat) [ 0. 0. 0. 0.]]

#plus généralement
mat = np.full(shape=(2,4),fill_value=0.1) [[ 0.1 0.1 0.1 0.1]
print(mat) [ 0.1 0.1 0.1 0.1]]
#concaténation de ligne ou de matrices
a = np.array([[2, 5, 3][1, 7, 4]]) [[2 5 3]
[1 7 4]]
b = np.array([[5, 6, 3]]) [[2 5 3]
c = np.append(a,b,axis=0) [1 7 4]
print(a) [5 6 3]]
print(c)
#ajouter une colonne [[2 5 3 9]
d = np.array([[9],[3.2],[5.4]]) [1 7 4 3]
[5 6 3 5]]
print(np.append(c,d,axis=1))
print(c)
[[2 5 3]
#insertion [5 6 3]
print(np.insert(a,1,b,axis=0)) [1 7 4]]

#suppression [[2 5 3]
[1 7 4]]
print(np.delete(a,1,axis=0))
 Accéder aux valeurs
mat = np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]])
print(mat[0,0]) #accès indicé - première valeur 1.2

print(mat[mat.shape[0]-1,mat.shape[1]-1]) #dernière valeur 4.3

print(mat[0:2,:]) #plage d'indices contigus : lignes 0 à 1 (2 non inclus),

toutes les colonnes

print(mat[1:,:]) #de la ligne 1 à la fin, toutes les colonnes

print(mat[-1,:]) #dernière ligne et toutes les colonnes

print(mat[-2:,:]) #les deux dernières lignes et toutes les colonnes

 CALCULS SUR LES MATRICES
#moyenne des lignes pour chaque colonne
print(np.mean(mat,axis=0)) [ 2.66666667 6. 3.33333333]

#moyenne des colonnes pour chaque ligne

print(np.mean(mat,axis=1)) [ 3.33333333 4. 4.66666667]

#somme cumulée des valeurs en ligne pour chaque colonne

print(np.cumsum(mat,axis=0)) [[ 2 5 3]
[ 3 12 7]
[ 8 18 10]]
#matrice de corrélation
#rowvar = 0 pour indiquer que les variables
#sont organisés en colonnes
[[ 1. -0.24019223 -0.69337525]
m = np.corrcoef(mat,rowvar=0)
[-0.24019223 1. 0.8660254 ]
print(m) [-0.69337525 0.8660254 1. ]]
 Tri sur les valeurs
mat = np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]])

#recherche valeur max des lignes (axis = 0) pour chaque colonne

print(np.max(mat,axis=0)) # [ 3.2 4.3 ] -- décryptage : 3.2 est la max des lignes
pour la colonne 0, 4.3 est la max des lignes pour la colonne 1

#recherche valeur max des colonnes (axis = 1) pour chaque ligne

print(np.max(mat,axis=1)) # [ 2.5 3.2 4.3]

#recherche indice de valeur max des lignes (axis = 0)pour chaque colonne
print(np.argmax(mat,axis=0)) # [ 1 2 ]

#tri des lignes (axis = 0) pour chaque colonne

#la relation entre les valeurs d'une même ligne est perdue !!!
print(np.sort(mat,axis=0))

#récupération des indices triés

print(np.argsort(mat,axis=0))
 Fonctions matricielles
a = np.arange(0, 12).reshape(3,4)
b = np.arange(10, 22).reshape(4,3)
[[ 0 4 8]
[1 5 9]
[2 6 10]
print(np.transpose(a))
[3 7 11]]
c= np.dot(a,b)
[[102 108 114]
print(c)
[334 356 378]
print(np.trace(c)) [566 604 642]]
1100
m = np.arange(2,6).reshape(2,2)
[[2 3]
print(m) [4 5]]
n= np.linalg.inv(m) [[ 1. 0.]
[ 0. 1.]]
print(np.dot(m,n))
(array([[-0.48992502, -0.87176457],
print(np.linalg.svd(m)) [-0.87176457, 0.48992502]]), array([ 7.34342046,
0.27235265]), array([[-0.60828716, -0.79371704],
[ 0.79371704, -0.60828716]]))
 Traitement d’image
from numpy import *
from PIL import Image
from pylab import *
imRGB = Image.open('peppers.bmp') #chargement d’image
#chargement en mode NDG et conversion en matrice NUMPY
imNDG = array(Image.open('peppers.bmp').convert('L'))
imshow(imNDG)

Image.fromarray(imNDG).show()

imshow(imRGB)
show()
print(imNDG.shape) #affichage des dimensions de la matrice

im2=255- imNDG
imshow(im2)
show()
Image.fromarray(im2).save('im2out.jpg')
import numpy as np
from PIL import Image
from pylab import *
imRGB = Image.new("RGB", (512, 512),"white")
im = Image.new("L", (512, 512))

img = array(Image.open("H:\\peppers.bmp"))
print(img.shape," ",img.dtype)
img[:,:,0]=0
img[:,:,1]=0

Image.fromarray(img).show()
Image.fromarray(img).save('H:\\out2.jpg')
imshow(img)
show()
from numpy import *
from scipy.misc.pilutil import Image
from pylab import *

def filtrage(imageIn, sizeM):

# imgFiltre = array(zeros(shape=(img.shape[0],img.shape[1])))

imgFiltre = array(Image.new("L", (imageIn.shape[0], imageIn.shape[1])))

k = ones((sizeM, sizeM))
step = k.shape[0] // 2
for i in range(step,(imageIn.shape[0] - step)):
for j in range(step,(imageIn.shape[0] - step)):
somme = 0
for u in range(k.shape[0]):
for v in range (k.shape[0]):
somme += k[u, v] * imageIn[i + u - step, j + v - step]

imgFiltre[i, j] = somme// (sizeM**2)

return imgFiltre

img = array(Image.open('imgfiltre.bmp').convert('L'))
imgOut = filtrage(img, 5)
Image.fromarray(imgOut).save('imgfiltre.bmp')
Image.fromarray(imgOut).show()