ENSET Mohammedia Année universitaire : 2022/2021

Initiation en Python

Plan :
 Introduction
 Les variables et principaux types de données
 Contrôle du flux d'exécution
 Instructions répétitives
 Fonctions prédéfinies
 Fonctions originales
 Utilisation de fenêtres et de graphismes
 Manipuler des fichiers
 Les structures de données

Professeur : A.Mansouri 1
ENSET Mohammedia Année universitaire : 2022/2021
I- Introduction:

Python est un langage de programmation créé par Guido Van Rossum en 1991.
Ce langage de programmation est relativement simple, et présente de nombreuses
caractéristiques intéressantes :
 Multiplateforme, Langage Open Source,
 Disponibilité de bibliothèques
 Langage de haut niveau, interprété.
 Orienté objet et très utilisé en analyse de données.

 langages de différents niveaux

Chaque processeur possède un langage propre, directement exécutable :
Le langage machine : formé de 0 et de 1 et n’est pas portable.
Le langage d’assemblage : codage alphanumérique du langage machine, pas portable.
On le traduit en langage machine par un assembleur ;
Les langages de haut niveau : Souvent normalisés, ils permettent le portage d’une
machine à l’autre. Ils sont traduits en langage machine par un compilateur ou un
interpréteur.
II- Les variables et principaux types de données :

1-Définition:
Une variable est une chaîne de caractères (un mot) qui doit commencer par une lettre,
sans espaces, en évitant les accents et caractères spéciaux.
En Python il n’est pas nécessaire de déclarer les variables ni leurs types avant de pouvoir
leur affecter une valeur (typage dynamique). Pour connaître le type d’une donnée ou le
type de la valeur d’une variable, il suffit d’utiliser la fonction type().
Le type int (entier): utilisé pour stocker un entier.
Le type float (flottant): utilisé pour stocker des nombres à virgule flottante.
Le type str (chaîne de caractères): nous pouvons créer simplement en joignant
caractères entre guillemets ou apostrophes.

Professeur : A.Mansouri 2
ENSET Mohammedia Année universitaire : 2022/2021
Le type complex : la partie imaginaire est indiquée grâce à la lettre « j » ou « J ».
Le type bool (booléen) : prendre les valeurs True ou False.
Le type list (liste) : on peut définir une liste comme une collection d’éléments séparés par
des virgules, l’ensemble étant enfermé dans des crochets.
2-Exemple:

Console lors de l’appel des variables

Entier Flottant String Complexe Booléen Liste

3-Remarques:
- Majuscules et minuscules sont différentes dans python.
- Il ne faut surtout pas utiliser de nom de fonctions python comme noms de variables.
Les mots réservés de Python

and del from None True as elif global else

try if not while in class pass yield raise
import break except or with is def for lambda
False continue finally return assert nonlocal
- Affectations multiples: Sous Python, on peut assigner une valeur à plusieurs variables
simultanément.

 Quelques opérateurs :
Opérateur Description Opérateur Description
+ Concatenation - Addition == Vérifie si égale
- Soustraction != Vérifie si différent
* Repetition - Multiplication > Supérieur
/ Division < Inférieur
% Modulo >= Supérieur ou égale
** Exposent <= Inférieur ou égale
// Division entière += c += a → c=c+a
= affectation -= c -= a → c=c-a
== Vérifie si égale *= c *= a → c=c*a
!= Vérifie si différent /= c /= a → c=c/a
and Conjonction %= c %= a → c=c%a
or Disjonction **= c **= a → c = c ** a
not Négation //= c //= a → c = c // a

Professeur : A.Mansouri 3
ENSET Mohammedia Année universitaire : 2022/2021

 Quelques règles:
Les variables globales:
- Définies avant d'appeler une fonction, sont lisibles lors de l'exécution de la fonction.
- Elles ne peuvent être modifiées qu'en agissant sur l'objet par un mot-clé ou par une
méthode.
Les variables locales :
- Définies dans une fonction, sont supprimées après l'exécution de la fonction.
On peut transformer des variables locales en variables globales (à l'aide de global) pour les
modifier lors de l'exécution d'une fonction (cf. exemples sur les fonctions).
III- Entrée-Sortie:

Pour afficher un message, il suffit d’utiliser la fonction .

Il est possible de combiner plusieurs message, soit en créant une variable concaténée
(+), ou en utilisant des virgules entre chaque type de caractère :
1-Exemples :

Pour inviter l'utilisateur à entrer des caractères en utilise la fonction input ().

IV- Contrôle du flux d'exécution :

L'exécution en python se fait par défaut de manière séquentielle. Cependant on peut agir
sur ce déroulement pour réaliser des alternatives ou des répétitions.
Le principe est de réaliser une ou plusieurs opérations si une condition est vraie, et
éventuellement d’autres opérations si la condition est fausse, voire même différente.

Professeur : A.Mansouri 4
ENSET Mohammedia Année universitaire : 2022/2021
1-L’indentation :
Les fonctions Python n’ont pas de begin ou end explicites, ni d’accolades qui pourraient
marquer là où commence et où se termine le code de la fonction. Le seul délimiteur est les
deux points ( : ) et l’indentation du code lui-même.

La syntaxe:
if Condition_1 :
opérations à effectuer si Condition_1 vaut True
opérations à effectuer si Condition_1 vaut True
elif Condition_2 : # Optionnel
opérations à effectuer si Condition_2 vaut True
opérations à effectuer si Condition_2 vaut True
else : # Optionnel
opérations à effectuer si ni Condition_1, ni Condition_2 ne sont
vérifiées
opérations à effectuer si ni Condition_1, ni Condition_2 ne sont
vérifiées
# Suite du programme
2-Remarques
- Ceci n’est pas une boucle, elle est exécutée puis le programme continue.
- Dès qu’une condition est vérifiée, les opérations associées sont exécutées et on sort du
bloc.

3-Exemples :

4-Applications :
1- Écrivez un programme pour trouver un maximum entre trois nombres.
2- Écrivez un programme pour vérifier si un nombre est pair ou impair.
3- Ecrire un programme qui demande la saisit de la température d’une eau, puis affiche
son état.
Soit T, la température d’une eau, Alors son état est :
• Si T ≤ 0 : C’est de la glace
• Si 0 < T ≤ 25 : C’est confortable
• Si 25 < T ≤ 100 : C’est chaud

Professeur : A.Mansouri 5
ENSET Mohammedia Année universitaire : 2022/2021
• Sinon (t > 100) : C’est de la vapeur
4- Saisissez un flottant. S’il est positif ou nul, affichez sa racine, sinon affichez un message
d’erreur.
V- Instructions répétitives :
1-Boucles for:
Le principe est de réaliser une ou plusieurs opérations pour une variable allant d’une
valeur à une autre, le nombre d’itérations est connu d’avance.
La syntaxe :
for i in range(n):
opérations à effectuer
opérations à effectuer i varie du 0 à n-1
opérations à effectuer Il y a n étapes
opérations à effectuer
opérations à effectuer

1-1 Exemples :

for i in range(0,n) : # parcourt tous les entiers de 0 à n-1 inclus

for i in range(n,0,-1) : # parcourt tous les entiers de n à 1 inclus
for i in range(2,200,4) : # parcourt tous les entiers de 2 à 200 avec un pas de 4
for e in li : # parcourt tous les éléments de la liste li

1-2 Remarques :
Les valeurs de i sont imposées par le for et augmentent toutes seules. Inutile donc de
l’initialiser avant la boucle, elle sera remplacée :

Il est inutile de l’augmenter :

On peut stopper une boucle for avec la commande « break » :

1-3 Applications :
1-Réaliser un programme qui affiche la table de multiplication de 1 à 12.
2- proposer un programme qui calcule le factoriel du nombre saisi par l’utilisateur. -
3- La suite de Fibonacci est une suite de nombres entiers de 0, 1, 1, 2, 3, 5, 8 ….
Les deux premiers termes sont 0 et 1. Tous les autres termes sont obtenus en ajoutant les
deux termes précédents.
Proposer un programme qui donne les termes selon la valeur introduite par
l’utilisateur.

Professeur : A.Mansouri 6
ENSET Mohammedia Année universitaire : 2022/2021
4- Que font les programmes ci-dessous :

2- Boucle while :
En général, si on connaît avant de démarrer la boucle le nombre d’itérations à exécuter, on
choisit une boucle for. Le while est utilisé lorsque l’on ne connait pas à priori le nombre
d’itérations à effectuer (simulation numérique jusqu’à une valeur d’un paramètre, recherche
dans une liste jusqu’à obtenir l’élément voulu etc).
La syntaxe :
Initialisation de la condition
while Condition :
opérations à effectuer
opérations à effectuer
opérations à effectuer
opérations à effectuer
opérations à effectuer
Modification de la condition
# Suite du programme
2-1 Remarques :
• La variable évaluée dans la condition doit exister au préalable.
• Si la condition est fausse au départ, le corps de la boucle n’est jamais exécuté.
• Si la condition reste toujours vraie, alors le corps de la boucle est répète indéfiniment.
2-2 Exemples :
1- Quel est le résultat attendu après l'exécution de chaque programme:
1 2 3
i=1 i = -2 n = int(input())
while i <= 10: while i <= 10: length = 0
print(i ** 2) print(i) while n != 0:
i += 1 i += 1 length += 1
else: n //= 10
print('Fin de la boucle, i =', i) print('Length is', length)

2-3 Applications :
1- Ecrire un programme qui permet de calculer la moyenne de notes fournies au clavier
(Le nombre des notes n’est pas connu):
VI- Les fonctions:
1. Les fonctions prédéfinies :

Les fonctions prédéfinies proviennent de deux sources différentes :

 soit des fonctions faisant partie intégrante du langage Python comme print, input,
type, len et str…;

Professeur : A.Mansouri 7
ENSET Mohammedia Année universitaire : 2022/2021
Liste des fonctions prédéfinies Python 3.7
abs() delattr() hash() memoryview( set() round() locals()
all() dict() help() min()
) setattr() max() getattr()
any() dir() hex() next() slice() hasattr() classmethod()
ascii() divmod() id() object() sorted() complex() repr()
bin() enumerat input() oct() staticmethod( import() vars()
bool() eval()
e() int() open() str()
) reversed() range()
breakpoint() exec() isinstance() ord() sum() map() list()
bytearray() filter() issubclass() pow() super() globals() frozenset()
bytes() float() iter() print() tuple() compile() chr()
callable() format() len() property() type() zip()
Pour avoir plus de détails sur une fonction il suffit de taper help (fonction) exemple :

 soit des fonctions ayant été écrites par d'autres programmeurs et mises à disposition
en important le module qui les contient, comme la fonction sqrt du module math, par
exemple.
Pour importer un module de fonctions :
Importer le contenu d’un Importer une partie d’un Importer tout un module
module module

import math from math import sqrt from math import *

a=900 a=900 a=900
b = math.sqrt(a) b = sqrt(a) b = sqrt(a)
print(b) print(b) print(b)
L’appel des fonctions diffère en fonction de la façon dont on les importe:

 import module : les fonctions du module devront être appelées

par module.fonction()
 import module as alias : les fonctions du module devront être appelées
par alias.fonction()
 Dans les autres cas, on n'a pas besoin d'utiliser le préfixe du module et l'on peut
directement utiliser le nom de la fonction ou de l'alias.
Exemple de syntaxe :

Professeur : A.Mansouri 8
ENSET Mohammedia Année universitaire : 2022/2021
Module mathématique : math et cmath

Le module math contient les fonctions mathématiques permettant d'effectuer les calculs
scientifiques de base, et le module cmath reprend la plupart des fonctions du module math
pour les nombres complexes:
pi, e, log, log10, exp, sqrt, cos(), sin(), tan(), acos(), asin(), atan(), cosh(), sinh(), tanh(),
acosh(), asinh(), atanh().

2. Les fonctions originales :

Une fonction est un ensemble d’instructions regroupées sous un nom et s’exécutant à la

demande, Elle peut exécuter une ou plusieurs opérations en prenant ou non des arguments
en entrée, et en renvoyant ou non des variables en sortie.
Pour définir une fonction, on écrit la première ligne suivante :
def Nom_Fonction(Argument_1, Argument_2,…,Argument_n):
Les variables définies dans une fonction sont des variables locales, on utilise l’instruction
global() pour la rendre globale.
2.1 Exemples :

Fonction simple sans paramètres :

def bonjour():
print('Bonjour tout le monde')
bonjour()
Fonction avec paramètre :
from math import sqrt
def carre(x):
return x**2
def cube(x):
return x ** 3
def racine(x):
return sqrt(x)
print('Veuillez introduire un nombre positif')
x=int(input())
print('Le carre de x est',carre(x))
print('Le cube de x est',cube(x))
print('La racine de x est',racine(x))
Fonction avec plusieurs paramètres :
def tableMulti(base, debut, fin) :
print ('Fragment de la table de multiplication par', base, ':')
n = debut
while n <= fin :
print (n, 'x', base, '=', n * base)
n = n +1
tableMulti(8, 7, 15)

Professeur : A.Mansouri 9
ENSET Mohammedia Année universitaire : 2022/2021
2.2 Applications :
1- Proposer une fonction qui retourne les éléments de la suite de Fibonacci.
2- Proposer une fonction qui calcule et retourne le volume d’une sphère.
3- Proposer une fonction qui nous donne les solutions d’une équation 2nd ordre.
VII- Utilisation de fenêtres et de graphismes :

Pour tracer des courbes sous Python on a besoin d’avoir deux listes, l’une pour les
abscisses, l’autre pour les ordonnées.
Pour tracer des courbes, il est nécessaire d’importer la librairie associée en écrivant :
import matplotlib.pyplot as plt
1. Exemples :

1er méthode :
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0.0, 8.0,200)
y1 = 1-np.cos(2 * np.pi * x) * np.exp(-x)
y2 = 1-np.exp(-x)
y3=y1-y2
plt.subplot(2,1,1)
plt.plot(x, y1, 'r',x,y2)
plt.ylabel('system 1er ordre et 2nd ordre')
plt.title('Exemple pour subplots')
plt.subplot(2,1,2)
plt.plot(x, y3, '--y')
plt.xlabel('time (s)')
plt.ylabel('Error')
plt.show()
2nd méthode orienté objet :
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0.0, 8.0,200)
y1 = 1-np.cos(2 * np.pi * x) * np.exp(-x)
y2 = 1-np.exp(-x)
y3=y1-y2
fig, (ax1, ax2) = plt.subplots(2, 1)
fig.suptitle('Exemple pour subplots')
ax1.plot(x, y1, 'r',x,y2)
ax1.set_ylabel('system 1er ordre et 2nd ordre')
ax2.plot(x, y3, '--y')
ax2.set_xlabel('time (s)')
ax2.set_ylabel('Error')
plt.show()

Professeur : A.Mansouri 10
ENSET Mohammedia Année universitaire : 2022/2021
2. Les options :
Il existe une multitude d’options permettant de changer les couleurs, styles de traits,
épaisseurs, titres des graphiques, titres des axes etc… Voyons ici les plus importants.
Lors de la création du plot, on peut préciser :
plt.plot(X, Y, linewidth=2.0) règle l’épaisseur du trait
plt.plot(X, Y, 'ro') Crée un nuage de points
plt.plot(X, Y, '--') trait en pointillés
couleur associée à la courbe
plt.plot(X,Y,'r') b: blue - g: green - r: red - c: cyan - m: magenta - y: yellow - k: black -
w: white
plt.plot(X,Y,label="Texte") Ajout d’une légende
plt.legend()
plt.plot(X, Y, '--r') Pointillés rouges
plt.xlim(,) intervalle des abscisses
plt.ylim(,) intervalle des ordonnées
plt.axis([, , , ]) Définit l’intervalle de la figure
plt.grid(True) Affiche la grille
plt.title('Texte') Définit un titre
plt.xlabel('Texte') nom des données en abscisses
plt.ylabel('Texte') nom des données en ordonnée
plt.show() Affiche le graphique
plt.close() Ferme la figure
plt.close('all') Ferme toutes les figures
Vide la dernière figure créée/appelée/ouverte sans la fermer
plt.clf() (lors d’une simulation, il est beaucoup plus rapide de vider que de
fermer/ouvrir)
plt.pause(n) Permet d’attendre par exemple n secondes avant de continuer
Enregistrement dans le répertoire courant des figures au format
plt.savefig('Nom')
standard

3.Applications :
1-Représenter sur 6 graphes dans une figure subdivisée en 6, les fonctions cosx, sinx,
sincx, coscx, exp(x), ln(x), pour chaque figure ajouter les informations utiles.
2- Pour les mêmes fonctions et sur la même figure cette fois ci, proposer une méthode pour
la représentation.
4. le package Numpy :
Numpy est la librairie qui offre la pièce fondamentale pour faire du calcul scientifique avec
Python.
Elle étend les capacités de Python pour travailler sur des tableaux et matrices
à n dimensions de façon bien plus optimisée et offre des fonctions mathématiques de haut
niveau sur ces objets.
Pour importer ce package il suffit de taper le code suivant :
import numpy as np
Les tableaux peuvent être créés avec numpy.array(). On utilise des crochets pour délimiter
les listes d’éléments dans les tableaux.

Professeur : A.Mansouri 11
ENSET Mohammedia Année universitaire : 2022/2021
4.1 Quelques constructeurs Numpy :

np.zeros(shape)

np.ones(shape)

La fonction numpy.arange()

La fonction numpy.linspace() :

np.random.rand(d0, d1, ..., dn)

Retourne un ndarray avec la géométrie définie par les

arguments contenant des valeurs aléatoires de

distribution uniforme [0, 1) (0 <= x < 1).

d0, d1, …, dn : les dimensions pour chaque

axe.

np.random.randn(d0, d1, ..., dn)

Retourne un ndarray avec la géométrie

définie par les arguments contenant des
valeurs aléatoires de distribution gaussienne
(moyenne de 0 et variance de 1).

np.random.randint(low, high=None,
size=None, dtype='l')

Retourne un ndarray avec la géométrie définie par

size contenant des valeurs entières aléatoires de
distribution discrete uniforme.

a) Indexing et Slicing:

Il est possible d’accéder à un élément ou un ensemble d’éléments à l’intérieur d’un ndarray

avec l’indexing et le slicing. Cela se fait en donnant le/les index entre [].

Professeur : A.Mansouri 12
ENSET Mohammedia Année universitaire : 2022/2021
Lorsque la valeur est positive, on indexe depuis le début du ndarray, lorsqu’elle est
négative, depuis la fin.
Pour un ndarray à multiple dimensions, on sépare chaque index (ou slice) avec une ,
Pour faire du slicing, on va donner 2 ou 3 valeurs, séparées d’un :. Cela sera [start:end] ou
[start:end:step]
start : position de départ (commence par 0 depuis la gauche, et par -1 depuis la droite)
end : position de fin (non-inclue)
step : pas sur l’index (peut être négatif pour aller de droite à gauche)
Cas particulier, on peut demander la totalité avec le simple caractère :
Applications :

1- Générer puis afficher une matrice 6*6 d’éléments aléatoires de 1 à 30 :

- Afficher tous les éléments de la 1er ligne.
- Afficher tous les éléments de la 1er colonne.
- Les deux dernières lignes.
- Les deux dernières colonnes.
- Affecter la valeur 100 à toutes les valeurs supérieures à 25
- Effectuer différentes calcules matricielle sur votre matrice.
- Réaliser les transformations suivantes :

4. le
5. Le package control :

La librairie contrôle de Python (python-control) est un package Python qui implémente des
opérations de base pour l'analyse et la conception et le contrôle des systèmes
automatique.

Pour importer ce package il suffit de taper le code suivant :

from control.matlab import *
System creation

ss(*args) Create a state space system.

tf(*args) Create a transfer function system.

Professeur : A.Mansouri 13
ENSET Mohammedia Année universitaire : 2022/2021
Frequency domain plotting

bode(syslist[, omega, dB, Hz, deg, Plot]) Bode plot for a system

bode_plot(syslist[, omega, dB, Hz, deg, Plot]) Bode plot for a system

nyquist(syslist[, omega, Plot, color, labelFreq]) Nyquist plot for a system

nyquist_plot(syslist[, omega, Plot, color, ...]) Nyquist plot for a system

nichols(syslist[, omega, grid]) Nichols plot for a system

nichols_plot(syslist[, omega, grid]) Nichols plot for a system

Time domain simulation

impulse_response(sys[, T, X0, input, ...]) Impulse response of a linear system

step_response(sys[, T, X0, input, output, ...]) Step response of a linear system

Block diagram algebra

series(sys1, sys2) Return the series connection sys2 * sys1 for –> sys1 –> sys2 –>.

parallel(sys1, sys2) Return the parallel connection sys1 + sys2.

feedback(sys1[, sys2, sign]) Feedback interconnection between two I/O systems.

Control system analysis

dcgain(*args) Compute the gain of the system in steady state.

freqresp(sys, omega) Frequency response of an LTI system at multiple angular frequencies.

margin(*args) Calculate gain and phase margins and associated crossover frequencies

pole(sys) Compute system poles.

zero(sys) Compute system zeros.

pzmap(sys[, Plot, title]) Plot a pole/zero map for a linear system.

Exemple:

import numpy as np
import matplotlib.pyplot as plt
import control
G = control.tf([1,2],[3,5,1])
print(G)
mag,phase,omega = control.bode(G)

Professeur : A.Mansouri 14
ENSET Mohammedia Année universitaire : 2022/2021
6. Le package scipy :

Scipy est une librairie de calcul scientifique appliquer en (statistiques, optimisation,

intégration numérique, algèbre linéaire, transformée de Fourier, traitement du signal,
traitement d'images, intégration d'équations différentielles, fonctions spéciales), elle
s’appuie sur les structures de données de NumPy .

1. Exemple échantillonnage :
import numpy as np
import matplotlib.pyplot as plt
f=1
globals()
def signal(t):
return np.sin(2 * np.pi * f*t )
D = 3/f
fe = 8*f
N = int(D * fe) + 1
te = np.linspace(0, (N-1)/fe, N)
t = np.linspace(0, D, 1000)
plt.plot(t, signal(t), 'b', label = "Signal reel")
plt.plot(te, signal(te), 'or--', label = "Signal echantillonne")
plt.grid()
plt.xlabel("Temps")
plt.ylabel("Amplitude x(t)")
plt.legend()
plt.show()

Repliement de spectre

Autre méthode :

from scipy import signal

import numpy as np
from matplotlib import pyplot as plt
f=1
l=1000
N=200
t = np.linspace(0, 5, l)
te=np.linspace(0, 5,N)
x = np.sin(2*np.pi*f*t)
Professeur : A.Mansouri 15
ENSET Mohammedia Année universitaire : 2022/2021
x_resampled = signal.resample(x, N)
plt.plot(t, x, 'b--', label='Original signal')
plt.plot(te, x_resampled, 'or', label='Resampled signal')
plt.show()
2. Transformée de Fourier :

from scipy.fftpack import fft

import numpy as np
import matplotlib.pyplot as plt
Fs=1000
t = np.arange(0,0.5,1/Fs)
f=10
y = np.sin(2*np.pi*f*t) +
2*np.sin(10*np.pi*f*t)+4*np.sin(6*np.pi*f*t)
yf = fft(y)
n=np.size(t)
fr=(Fs/2)*np.linspace(0,1,n//2)
plt.subplot(2,1,1)
plt.plot(t,y)
plt.subplot(2,1,2)
plt.plot(fr,2/Fs*abs(yf[0:np.size(fr)]))
plt.grid()
plt.show()

Signal plus bruit

from scipy.fftpack import fft

import numpy as np
import matplotlib.pyplot as plt
Fs=1000
t = np.arange(0,1,1/Fs)
f=10
y = np.sin(2*np.pi*f*t)
x= 2*np.random.normal(0, 0.1,y.shape)
yx=x+y
xx=yx+0.2*np.sin(2*49*np.pi*f*t)
plt.subplot(2,1,1)
plt.plot(xx)
plt.subplot(2,1,2)
yf = fft(xx)
n=np.size(t)
fr=(Fs/2)*np.linspace(0,1,n//2)
plt.plot(fr,2/Fs*abs(yf[0:np.size(fr)]))
plt.grid()
plt.show()

Professeur : A.Mansouri 16
ENSET Mohammedia Année universitaire : 2022/2021
Filtrage par application de la méthode booléen indexing;

from scipy.fftpack import fft,fftfreq

import numpy as np
import matplotlib.pyplot as plt
Fs=1000
t = np.arange(0,1,1/Fs)
f=10
y = np.sin(2*np.pi*f*t)
x=0.2*np.sin(2*49*np.pi*f*t)
bb= 2*np.random.normal(0, 0.1,y.shape)
sig=x+y+bb
fourier=fft(sig)
fourier_1=2/Fs*np.abs(fourier)
freq=Fs*fftfreq(sig.size)
plt.subplot(2,1,1)
plt.plot(freq,fourier_1)
plt.subplot(2,1,2)
fourier_1[fourier_1<0.3]=0
plt.plot(freq,fourier_1)
plt.show()

Filtrage par synthèse de filtre (voir TP)

7. Le package opencv :

OpenCV est une bibliothèque de fonctions de programmation principalement destinées à la

vision par ordinateur en temps réel. Nous pouvons faire du traitement d'images, de
l'apprentissage automatique, etc.

Lire une image :

cv2.imread(/path/to/image, flag)
 cv2.IMREAD_COLOR image en couleurs RGB .
 cv2.IMREAD_GRAYSCALE grey image.
 cv2.IMREAD_UNCHANGED image d‘origine

Lire et montrer une image :

import cv2
import matplotlib.pyplot as plt

img = cv2.imread('D:/image.jpg')
img1 = cv2.imread('D:/image.jpg',
cv2.IMREAD_GRAYSCALE)

print('color Image Dimensions :', img.shape)

print('gray Image Dimensions :', img1.shape)

cv2.imshow('image en couleur',img)
cv2.waitKey(0)

Professeur : A.Mansouri 17
ENSET Mohammedia Année universitaire : 2022/2021
cv2.destroyAllWindows()

cv2.imshow('image en nuance de gris',img1)

cv2.waitKey(0)
cv2.destroyAllWindows()

color Image Dimensions : (404, 647, 3)

gray Image Dimensions : (404, 647)
VIII. Manipuler des fichiers :

1 Lecture d’un fichier

1.1 Ouverture
Pour « ouvrir » un fichier texte sous python, on peut écrire :
fichier = open(Nom_Fichier, "r")

- L’option r veut dire « read ».

2 Lecture des lignes
2.1 Lecture ligne par ligne
On peut alors parcourir chacune des lignes du fichier à l’aide d’une boucle for ainsi :
for Ligne in fichier:

2.2 Lecture complète

Il est possible de récupérer directement une liste des lignes d’un fichier en écrivant :
Liste_Lignes = fichier.readlines()
3 Fermeture
Après avoir lu un fichier texte, il faut le refermer sous Python avec la fonction « .close »:
fichier.close()
IX. Les structures de données
Les structures de données les plus utilisées en python :
1. Tuple -> tuple
 Séquence immuable hétérogène
 Une fois créée, ne peut pas être mis à jour
 Entouré de parenthèses plutôt que de crochets
a = (5, 6.54, "enset")
print(type(a))
<class 'tuple'>

2. String (chaîne de caractères) -> str (voir section II )

3. Intervalle -> range (voir section II )
4. Liste -> list (voir section II )
5. Dictionnaire -> dict
Le dictionnaire se crée sous Python à l’aide d’accolades : dico = { }

Professeur : A.Mansouri 18
ENSET Mohammedia Année universitaire : 2022/2021
On peut initialiser le dictionnaire en le créant :
num = {'Lina':'065895','Said':'0783','Mourad':'02154'}
print(num)
print(type(num))
{'Lina': '065895', 'Said': '0783', 'Mourad': '02154'}
<class 'dict'>
Les clés du dictionnaire sont des chaines de caractères (prénoms) et les valeurs
correspondant aux numéros.
print(num['Lina'])
065895

Professeur : A.Mansouri 19