TP1

March 14, 2022

Initiation à Python
March 14, 2022

1 1 TP1: Exercices d’initiation à Python

il y a différents types de modules :
• ceux qui sont inclus dans la version de Python comme random ou math,
• ceux que l’on peut rajouter comme numpy ou matplotlib,
• et ceux que l’on peut faire soi-même (il s’agit dans les cas simples d’un fichier Python con-
tenant un ensemble de fonctions).

il y a deux façons pour importer un module. Voyons cela en prenant comme exemple
le module math.

la première façon
[7]: from math import cos
cos(0)

[7]: 1.0

[8]: sin(0)

---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-8-afbcc558f753> in <module>
----> 1 sin(0)

NameError: name 'sin' is not defined

Le message d’erreur signifie simplement que l’on n’a pas importé la fonction sin. Donc si on
recommence

[10]: from math import cos, sin

[11]: sin(0)

1
[11]: 0.0

Et si on veut que toutes les fonctions du module soient importées, on peut procéder comme on l’a
fait plus haut en utilisant l’étoile *.

[14]: from math import *

sqrt(4)

[14]: 2.0

la deuxième façon
[15]: import math
math.sqrt(4)

[15]: 2.0

Bien que cette deuxième méthode paraisse plus lourde à écrire, elle peut avoir certains avantages

1.1 1.1 Exercice1 (Vecteurs et Courbes)

a) Définir la variable x = π4 , et calculer y1 = sin(x) et y2 = cos(x), puis z = tan(x) à
partir de y1 et y2 .
[5]: import math # C’est un module qui permet d’avoir accès aux fonctions␣
,→mathématiques

x=math.pi/4
y1=math.sin(x)
print("y1=",y1)
y2=math.cos(x)
print("y2=",y2)
z=y1/y2
print("z =",z)

y1= 0.7071067811865476
y2= 0.7071067811865476
z = 1.0

b) Définir la variable x = [ π6 , π4 , π3 ], et calculer y1 = sin(x) et y2 = cos(x).

Calculer alors z = tan(x) en utilisant exclusivement les vecteurs y1 et y2 précédents.

[16]: import numpy as np

[42]: x=[np.pi/6, np.pi/4, np.pi/3] # liste

x=np.array(x) # convertit la liste x en tableau np.array

print("x =",x)
y1=np.sin(x) # Calcule chaque y pour chaque valeur dans x.
print("y1=",y1)
y2=np.cos(x)

2
 print("y2=",y2)
z=y1/y2
print("z =",z)

x = [0.52359878 0.78539816 1.04719755]

y1= [0.5 0.70710678 0.8660254 ]
y2= [0.8660254 0.70710678 0.5 ]
z = [0.57735027 1. 1.73205081]

c) Définir la variable x = [0 : 0.1 : 2]. Combien y a t-il de valeurs dans ce vecteur?

Affcher la courbe du sinus.
[68]: #np.arange(m,n) # [m, m+1, m+2, ..., n-1]
np.arange(2,7)

[68]: array([2, 3, 4, 5, 6])

[47]: x=np.arange(0,2*np.pi,0.1) # [0, 0.1, 0.2, ..., 2*pi]

x

[47]: array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1, 1.2,
1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. , 2.1, 2.2, 2.3, 2.4, 2.5,
2.6, 2.7, 2.8, 2.9, 3. , 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8,
3.9, 4. , 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5. , 5.1,
5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6. , 6.1, 6.2])

[48]: len(x)

[48]: 63

[49]: import matplotlib.pyplot as plt # La bibliothèque matplotlib.pyplot permet de␣

,→produire des graphes.

[52]: y = np.sin(x) # Calcule chaque y pour chaque vqleur dans x.

plt.figure() # Ouverture d'une nouvelle fenêtre graphique
plt.plot(x, y) # Construction du graphe en mémoire
plt.title("Graphe de la fonction sin") # Titre du graphe
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.show() # Affichage du graphe

3
[53]: x1=np.arange(0, 2*np.pi, 0.7)
y1=np.sin(x1)
plt.figure()
plt.plot(x1,y1)

[53]: [<matplotlib.lines.Line2D at 0x274a79fa610>]

4
 1.2 1.2 Exercice 2 (Manipulation de matrices)
a) Définir le vecteur V = [0, 1, 2, ..., 49, 50]. Quelle est la taille de ce vecteur?

Définir le vecteur W contenant le cinq premiers éléments de de V , et le vecteur X

contenant

les cinq premiers et les cinq derniers éléments.

Définir ensuite le vecteur Z = [0, 2, 4, ..., 48, 50] à partir de V .

[64]: V=np.arange(0,50+1)
V

[64]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,

17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50])

[65]: len(V) # la taille de ce vecteur

[65]: 51

[55]: W=V[0:5]
W

[55]: array([0, 1, 2, 3, 4])

5
[57]: X=np.append(W, V[-5:])
X

[57]: array([ 0, 1, 2, 3, 4, 46, 47, 48, 49, 50])

[62]: Z=V[1:-1:2]

[63]: Z

[63]: array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33,
35, 37, 39, 41, 43, 45, 47, 49])

b) Définir la matrice
 
1 2 3 4 5 6 7 8 9 10
M =  11 12 13 14 15 16 17 18 19 20 
21 22 23 24 25 26 27 28 29 30

Extraire de cette matrice la matrice

 
1 2
N =  11 12 
21 22

et la matrice  
8 9 10
P =  18 19 20 
28 29 30
puis la matrice ( )
3 7
Q=
23 27
Extraite de la matrice M la matrice R obtenue en prenant dans la matrice M une colonne sur 2 .

[74]: M=np.arange(1,31)
M

[74]: array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])

[75]: M=M.reshape(3,10)
M

[75]: array([[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],

[11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
[21, 22, 23, 24, 25, 26, 27, 28, 29, 30]])

[77]: N=M[:3,:2]
N

6
 [77]: array([[ 1, 2],
[11, 12],
[21, 22]])

[79]: P=M[:,-3:]
P

[79]: array([[ 8, 9, 10],

[18, 19, 20],
[28, 29, 30]])

[95]: rows = np.array([[0, 0],

[2, 2]])
cols = np.array([[2, 6],
[2, 6]])
Q=M[rows,cols]
Q

[95]: array([[ 3, 7],

[23, 27]])

[96]: R=M[:,:-1:2]
R

[96]: array([[ 1, 3, 5, 7, 9],

[11, 13, 15, 17, 19],
[21, 23, 25, 27, 29]])

c) Définir la matrice M = [2, ..., 100] et $ N = [-1, -3, -5 . . ., -99]$, puis le vecteur
P = [−1, 2, −3, 4, −5, 8, ..., −99, 100].
[118]: M=np.arange(2,101,2)
M=M.reshape(-1,1)
M

[118]: array([[ 2],

[ 4],
[ 6],
[ 8],
[ 10],
[ 12],
[ 14],
[ 16],
[ 18],
[ 20],
[ 22],
[ 24],
[ 26],

7
 [ 28],
[ 30],
[ 32],
[ 34],
[ 36],
[ 38],
[ 40],
[ 42],
[ 44],
[ 46],
[ 48],
[ 50],
[ 52],
[ 54],
[ 56],
[ 58],
[ 60],
[ 62],
[ 64],
[ 66],
[ 68],
[ 70],
[ 72],
[ 74],
[ 76],
[ 78],
[ 80],
[ 82],
[ 84],
[ 86],
[ 88],
[ 90],
[ 92],
[ 94],
[ 96],
[ 98],
[100]])

[117]: N=np.arange(-1,-100,-2)
N=N.reshape(-1,1)
N

[117]: array([[ -1],

[ -3],
[ -5],
[ -7],
[ -9],

8
[-11],
[-13],
[-15],
[-17],
[-19],
[-21],
[-23],
[-25],
[-27],
[-29],
[-31],
[-33],
[-35],
[-37],
[-39],
[-41],
[-43],
[-45],
[-47],
[-49],
[-51],
[-53],
[-55],
[-57],
[-59],
[-61],
[-63],
[-65],
[-67],
[-69],
[-71],
[-73],
[-75],
[-77],
[-79],
[-81],
[-83],
[-85],
[-87],
[-89],
[-91],
[-93],
[-95],
[-97],
[-99]])

9
[125]: P=np.concatenate((N,M),axis=1) # ou np.hstack
P

[125]: array([[ -1, 2],

[ -3, 4],
[ -5, 6],
[ -7, 8],
[ -9, 10],
[-11, 12],
[-13, 14],
[-15, 16],
[-17, 18],
[-19, 20],
[-21, 22],
[-23, 24],
[-25, 26],
[-27, 28],
[-29, 30],
[-31, 32],
[-33, 34],
[-35, 36],
[-37, 38],
[-39, 40],
[-41, 42],
[-43, 44],
[-45, 46],
[-47, 48],
[-49, 50],
[-51, 52],
[-53, 54],
[-55, 56],
[-57, 58],
[-59, 60],
[-61, 62],
[-63, 64],
[-65, 66],
[-67, 68],
[-69, 70],
[-71, 72],
[-73, 74],
[-75, 76],
[-77, 78],
[-79, 80],
[-81, 82],
[-83, 84],
[-85, 86],
[-87, 88],

10
 [-89, 90],
[-91, 92],
[-93, 94],
[-95, 96],
[-97, 98],
[-99, 100]])

[126]: P.reshape(1,-1)

[126]: array([[ -1, 2, -3, 4, -5, 6, -7, 8, -9, 10, -11, 12, -13,
14, -15, 16, -17, 18, -19, 20, -21, 22, -23, 24, -25, 26,
-27, 28, -29, 30, -31, 32, -33, 34, -35, 36, -37, 38, -39,
40, -41, 42, -43, 44, -45, 46, -47, 48, -49, 50, -51, 52,
-53, 54, -55, 56, -57, 58, -59, 60, -61, 62, -63, 64, -65,
66, -67, 68, -69, 70, -71, 72, -73, 74, -75, 76, -77, 78,
-79, 80, -81, 82, -83, 84, -85, 86, -87, 88, -89, 90, -91,
92, -93, 94, -95, 96, -97, 98, -99, 100]])

d) Définir une matrice M aléatoire à 3 lignes et 7 colonnes. Combien de nombres dans

cette matrice sont plus grands que 0.5? que 0.8? où sont-ils situés?

Construire alors la matrice P obtenue à partir de la matrice M en remplaçant tous

les nombres de M inférieurs à 0.4 par 0, et ceux supérieurs à 0.4 par 1. Construire de
même la matrice Q obtenue à partir de la matrice M en remplaçant tous les nombres
de M inférieurs à 0.5 par -3 et tous les nombres supérieurs à 0.5 par 14.
[148]: M=np.random.rand(3,7)
M

[148]: array([[0.85760989, 0.35312851, 0.5182001 , 0.81181858, 0.40200124,

0.81220015, 0.3590656 ],
[0.3830702 , 0.47633881, 0.16761232, 0.30072278, 0.58410557,
0.82327631, 0.80662026],
[0.48032694, 0.89422069, 0.59782556, 0.99506199, 0.68644816,
0.0630271 , 0.21237061]])

[149]: len(np.where(M>=0.5)[0])

[149]: 11

[150]: len(np.where(M>=0.8)[0])

[150]: 7

[151]: rows,cols=np.where(M>=0.5)
rows

[151]: array([0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2], dtype=int64)

11
[152]: cols

[152]: array([0, 2, 3, 5, 4, 5, 6, 1, 2, 3, 4], dtype=int64)

[153]: rows,cols=np.where(M>=0.8)

[154]: P=M;
rows,cols=np.where(M>=0.4);
P[rows,cols]=1

rows,cols=np.where(M<0.4);
P[rows,cols]=0
P

[154]: array([[1., 0., 1., 1., 1., 1., 0.],

[0., 1., 0., 0., 1., 1., 1.],
[1., 1., 1., 1., 1., 0., 0.]])

[ ]:

[ ]:

12