Python-Physique 06 : Graphiques, module math et vecteurs

1 - pyplot

2 - math

3 - changement base

4 - vecteurs

Cette courte activité apporte quelques précisions sur les graphiques et fournit une courte description du module math qui permet d'utiliser les fonctions mathématiques.

On y aborde notamment la méthode quiver qui permet de tracer des vecteurs.

1 - Précisions sur le module pyplot de matplotlib

Nous avons vu que le module pyplot permet de tracer des choses. Pour ne pas à avoir à noter pyplot. à chaque fois que nous allons utiliser l'une des méthodes et fonctions du module, nous allons utiliser un alias lors de l'importation. L'alias courant est plt.

01° Utiliser le code basique suivant pour tracer un graphique.

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

x = [ 0,1,2,3,4,5,6,7,8,9,10 ]

y = [ i*i for i in x ]

print(x)

print(y)

plt.plot(x,y)

plt.show()

Rappel : un ensemble de données séparées par des virgules et entourées par des crochets [ ] est une liste.

Vous devriez obtenir quelque chose proche de ceci :

Quelques explications :

#!/usr/bin/env python : On précise que le fichier est un fichier Python.
# -*- coding: utf-8 -*- : On déclare que l'encodage du fichier .py est l'UTF-8. Pensez à le faire réellement si vous enregistrez le fichier avec Notepad++.
from matplotlib import pyplot as plt : On importe pyplot sous l'alias plt
x = [ 0,1,2,3,4,5,6,7,8,9,10 ] : On crée une liste nommée x qui contient les valeurs des points sur l'axe x.
y = [i*i for i in x] : C'est nouveau : on crée une liste à partir d'une autre : pour chaque valeur i contenue dans la liste x, on place i² dans la liste y.
print(x) : purement pédagogique : on affiche la liste x.
print(y) : purement pédagogoqie : on affiche la liste y.
plt.plot(x,y) : on crée un graphique où le premier argument (x) est l'abscisse et le deuxième argument (y) est l'ordonnée.
plt.show() : on affiche le graphique qu'on a crée juste au dessus.

La documentation officielle de pyplot se trouve ici http://matplotlib.org/api/pyplot_summary.html.

La documentation sur plot se trouve facilement dans la liste : http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot.

02° Utiliser la documentation pour afficher une courbe rouge composée de pointillés.

...CORRECTION...

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

x = [ 0,1,2,3,4,5,6,7,8,9,10 ]

y = [ i*i for i in x ]

print(x)

print(y)

plt.plot(x,y, 'r--')

plt.show()

Jusqu'à présent, on crée des graphiques en fournissant une liste pour les x et les y. Mais on peut également simplement fournir une seule liste. Regardons ce que cela donne.

03° Utiliser successivement les deux codes suivants où on ne donne que y. Pourquoi est-ce que ça marche pour le premier mais pas pour le second ?

Premier cas :

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

x = [0,1,2,3,4,5,6,7,8,9,10]

y = [ i*i for i in x ]

plt.plot(y, 'k+')

plt.show()

Donne :

Deuxième cas :

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

x = [10,11,12,13,14,15,16,17,18,19,20]

y = [ i*i for i in x ]

plt.plot(y, 'k+')

plt.show()

Donne :

Si vous n'avez pas vu l'information dans la documentation, le fait de n'envoyer qu'une seule liste crée un graphique où l'abscisse correspond juste au numéro de l'élément de la liste.

Ainsi, le premier élement porte l'élément 0, le suivant 1... Dans le premier cas, x est également une liste variant de 0 à 10, ça ne pose pas de problème.

Par contre, pour le deuxième cas, les valeurs réelles de x varient de 10 à 20. Mais, comme on ne donne que y, Python place la première valeur de y à une abscisse de 0, la seconde à 2 ... Pour avoir les bonnes valeurs en abscisse, il faut envoyer x également à votre fonction plot>.

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

x = [10,11,12,13,14,15,16,17,18,19,20]

y = [ i*i for i in x ]

plt.plot(x,y, 'k+')

plt.show()

Voyons maintenant les deux types de diagrammes à barres.

Les diagrammes à barres à l'aide de hist. Cela permet de créer des historigrammes : on range les données dans un nombre précis de catégories et on affiche le total de chaque catégorie.

Nous allons créer un programme qui crée une liste z au hasard.

Rappel : Une courte description du module random se trouve dans l'activité Python-Canvas de ce site. Ici la fonction choice renvoie simplement l'un des éléments de la liste au hasard. Ainsi avec le code suivant valeur contiendra (au hasard) un nombre de 1 à 6 :

valeurs = [1,2,3,4,5,6]

valeur = random.choice(valeurs)

04° Analyser le code suivant pour comprendre ce qu'il faut. L'Utiliser puis augmenter le nombre de tirage du dé 6 pour montrer que la répartition entre les différentes possibilités s'uniformise avec un très grand nombre de lancés. Vous pouvez modifier le nombre de catégories en agissant sur bins.

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import random

valeurs = [1,2,3,4,5,6]

z = [random.choice(valeurs) for i in range(10)]

plt.hist(z, bins=6, range = (1,6))

plt.show()

On tire 10 dés à 6 faces (10d6)

Si on lance un million de D6 :

Les diagrammes à barres à l'aide de bar().

Cette fonction permet de tracer des diagrammes à barres à l'aide de deux listes ou tableaux x et y. Le premier contient les valeurs des abscisses x[i] et le second la hauteur y[i] de la barre correspondante.

On peut régler la largeur des barres à l'aide de width.

05° Utiliser le code suivant qui génére une liste x commençant à 10, et une liste y comprenant des valeurs entières tirées au hasard entre 0 et 100.

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import random

x = [i for i in range(10,30,2)]

y = [random.randint(0,100) for i in x]

print(x)

print(y)

plt.bar(x,y,width=1)

plt.show()

Exemple 1 dont on donne les valeurs contenues dans les listes x et y :

Exemple 2 dont on donne les valeurs contenues dans les listes x et y :

06° Regardons ce qui se passe si on lance deux fois plot à la suite l'un de l'autre.

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

x = [0,1,2,3,4,5,6,7,8,9,10]

y = [i*i for i in x]

y2 = [i**3 for i in x]

print(x)

print(y)

print(y2)

plt.plot(x,y)

plt.plot(x,y2)

plt.show()

Il nous reste à voir ou revoir quelques dernières fonctions permettant de modifier les axes et de rajouter des informations sur les axes par exemple.

Pour rajouter un TITRE	plt.title("Mon titre")
Pour rajouter un LABEL sur l'axe x	plt.xlabel("Label sur cet axe") On notera que x n'est pas le nom de la série mais bien le nom de la fonction. Comme il s'agit de l'abscisse, le créateur de la fonction a utilisé x.
Pour rajouter un LABEL sur l'axe y	plt.ylabel("Label sur cet axe") On notera que y n'est pas le nom de la série mais bien le nom de la fonction. Comme il s'agit de l'ordonnée, le créateur de la fonction a utilisé y.
Pour définir la largeur et la couleur de l'axe des abscisses	plt.axhline(linewidth=1,color="r") Ici, on crée un axe Ox rouge de largeur 1.
Pour définir la largeur et la couleur de l'axe des ordonnées	plt.axvline(linewidth=2,color="g") Ici, on crée un axe Oy vert de largeur 2.
Pour gérer les valeurs minimales et maximales des axes x et y	plt.axis([ xmin, xmax, ymin, ymax ]) Il faut donc faire attention à l'ordre des arguments transmis.
Pour imposer un repère orthonormé	plt.axis('equal')
Pour choisir les graduations sur l'axe des abscisses	plt.xticks([0,1,2,3,4,5])
Pour choisir les graduations sur l'axe des ordonnés	plt.yticks([0,1,2,3,4,5])
Pour fermer le graphique	plt.close()

07° Utilisez les indications ci-dessus pour tracer la fonction f(x)= 4x² - 10 x + 2 sur l'intervalle [-10;+10].

Une proposition de correction :

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

def ma_fonction(x):

return 4*(x**2)-10*x+2

x = [i/10 for i in range(-100,101,1)]

y = [ma_fonction(i) for i in x]

plt.plot(x,y)

plt.title("Représentation de f(x)")

plt.xlabel("Abscisse x")

plt.ylabel("Ordonnée y")

plt.yticks([0,100,200,500])

plt.show()

Voyons maintenant comment calculer des choses moins triviales.

2 - Module math

Comme nous traçons des graphiques, autant parler des fonctions mathématiques qui vous permettront de demander à Python d'utiliser quelques fonctions mathématiques.

Il faut pour cela importer le module math à l'aide par exemple de import math.

Vous trouverez ci-dessous quelques unes des fonctions (informatiques) permettant de trouver la valeur des fonctions mathématiques.

08° Utiliser pyplot pour afficher les deux premières fonctions ci-dessous.

La racine carrée de x : math.sqrt(x).

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import math

def ma_fonction(x) :

return math.sqrt(x)

x = [i/100 for i in range(0,1001,1)]

y = [ma_fonction(i) for i in x]

plt.plot(x,y)

plt.title("Racine carrée de x")

plt.xlabel("Abscisse x")

plt.ylabel("Ordonnée y")

plt.show()

La partie entière de x : math.floor(x).

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import math

def ma_fonction(x) :

return math.floor(x)

x = [i/100 for i in range(-1000,1001,1)]

y = [ma_fonction(i) for i in x]

plt.plot(x,y)

plt.title("Partie entière de x")

plt.xlabel("Abscisse x")

plt.ylabel("Ordonnée y")

plt.show()

La valeur absolue |x| de x : math.fabs(x).

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import math

def ma_fonction(x) :

return math.fabs(x)

x = [i/100 for i in range(-1000,1001,1)]

y = [ma_fonction(i) for i in x]

plt.plot(x,y)

plt.title("Valeur absolue de x")

plt.xlabel("Abscisse x")

plt.ylabel("Ordonnée y")

plt.show()

Le factoriel x! de x : math.factorial(x).

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import math

def ma_fonction(x) :

return math.factorial(x)

x = [i/100 for i in range(100,500,1)]

y = [ma_fonction(math.floor(i)) for i in x]

plt.plot(x,y)

plt.title("Factorielle de x")

plt.xlabel("Abscisse x")

plt.ylabel("Ordonnée y")

plt.xticks([1,2,3,4,5])

plt.show()

L'exponentielle e^x de x : math.exp(x).

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import math

def ma_fonction(x) :

return math.exp(x)

x = [i/100 for i in range(-1000,1001,1)]

y = [ma_fonction(i) for i in x]

plt.plot(x,y)

plt.title("Exponentielle de x")

plt.xlabel("Abscisse x")

plt.ylabel("Ordonnée y")

plt.show()

Le logarithme népérien ln(x) de x : math.log(x).

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import math

def ma_fonction(x) :

return math.log(x)

x = [i/100 for i in range(1,1001,1)]

y = [ma_fonction(i) for i in x]

plt.plot(x,y)

plt.title("Logarithme (népérien) de x")

plt.xlabel("Abscisse x")

plt.ylabel("Ordonnée y")

plt.show()

Le logarithmebase 10 s'obtient très facilement aussi, de deux façons :

La première :

>>> import math

>>> math.log(100,10)

2.0

>>> math.log(1000,10)

3.0

>>> math.log(10000,10)

4.0

On peut même faire plus simple :

>>> import math

>>> math.log10(100)

2.0

>>> math.log10(1000)

3.0

>>> math.log10(10000)

4.0

Les fonctions trigonométriques portent un nom assez explicite pour ne pas rentrer dans les détails :

math.cos(x) et math.acos(x).
math.sin(x) et math.asin(x).
math.tan(x) et math.atan(x).

Par contre, attention : x est l'angle défini en radians. Pour convertir des degrés en radians, il faut utiliser math.radians(angle_en_degre).

De la même façon, transformer un angle en radians en degrés nécessite math.degrees(angle_en_radians).

Si vous cherchez pi, il faut utiliser math.pi.Au passage, la constante de Neper e = exp(1) se note math.e.

On remarquera que le calcul étant numérique, Python gère mal les discontinuités.

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import math

def ma_fonction1(x) :

return math.sin(x)

def ma_fonction2(x) :

return math.cos(x)

def ma_fonction3(x) :

return math.tan(x)

x = [i/100 for i in range(0,36100,1)]

y = [ma_fonction1(math.radians(i)) for i in x]

y2 = [ma_fonction2(math.radians(i)) for i in x]

y3 = [ma_fonction3(math.radians(i)) for i in x]

plt.plot(x,y,'b')

plt.plot(x,y2,'g')

plt.plot(x,y3,'r')

plt.title("sin(x) en bleu, cos(x) en vert et tan(x) en rouge")

plt.xlabel("Abscisse x")

plt.ylabel("Ordonnée y")

plt.axis([0,360,-3,3])

plt.show()

Le cosinus hyperbolique de x : math.cosh(x).

Le sinus hyperbolique de x : math.sinh(x).

La tangente hyperbolique de x : math.tanh(x).

#!/usr/bin/env python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import math

def ma_fonction1(x) :

return math.sinh(x)

def ma_fonction2(x) :

return math.cosh(x)

def ma_fonction3(x) :

return math.tanh(x)

x = [i/100 for i in range(-1000,1001,1)]

y = [ma_fonction1(i) for i in x]

y2 = [ma_fonction2(i) for i in x]

y3 = [ma_fonction3(i) for i in x]

plt.plot(x,y,'b')

plt.plot(x,y2,'g')

plt.plot(x,y3,'r')

plt.title("sinh(x) en bleu, cosh(x) en vert et tanh(x) en rouge")

plt.xlabel("Abscisse x")

plt.ylabel("Ordonnée y")

plt.axis([-10,10,-10,10])

plt.show()

Il va encore rester quelques cas à illustrer. Par exemple :

Mettre en valeur l'aire sur un graphique
Créer un curseur sur un graphique
Rajouter des barres d'erreur
...

3 - Changement de base

Cette partie pourrait vous servir surtout si vous voulez mettre au point des TP traitant des conversions analogique numérique par exemple.

Convertir en base 10, le décimal

09° Utiliser les codes ci-dessous pour tenter de voir à quel nombre décimal correspond le nombre binaire 0110 1111 .

>>> 0b001

>>> 0b010

>>> 0b011

Remarque :

Comme vous pouvez le voir, Python précéde un nombre exprimé en binaire par les codes 0b .

La notation mathématique habituelle donnerait ainsi (01101111)₂ = (111)₁₀ .

En Python, on obtient alors plutôt 0b01101111 = 111 .

10° Utiliser les codes ci-dessous pour tenter de voir à quel nombre décimal correspond le nombre hexadécimal F4 .

>>> 0xF1

241

>>> 0xF2

242

>>> 0xF3

243

Remarque :

Comme vous pouvez le voir, Python précéde un nombre exprimé en hexadécimal par les codes 0x .

La notation mathématique habituelle donnerait ainsi (F4)₁₆ = (244)₁₀ .

En Python, on obtient alors plutôt 0xF4 = 244 .

Il existe encore d'autres façons de convertir en base 10. L'une d'entre elles consiste à utiliser la fonction native int. Cette fonction va tenter de lire le contenu que vous lui fournissez en tant que nombre exprimé en base 10.

Deux exemples en fournissant directement des nombres binaires ou hexadécimaux :

>>> int(0b0101)

>>> int(0b11111111)

255

>>> int(0xF1)

241

>>> int(0xFF)

255

Pour l'instant, on ne voit pas trop l'intérêt. En réalité, on peut fournir un second argument : la base dans laquelle on est censé décoder le premier argument qui peut alors être un string :

>>> int('0101',2)

>>> int('0b0101',2)

>>> int('0xF1',16)

241

>>> int('FF',16)

255

Convertir en base 2, le binaire

11° Utiliser les codes ci-dessous pour tenter de voir à quel nombre binaire correspond le nombre décimal 15 .

>>> bin(10)

'0b1010'

>>> bin(11)

'0b1011'

Remarque :

La réponse correspond bien au code binaire précédé du préfixe 0b .

Par contre, la réponse n'est pas réellement un nombre mais un string comme l'indique la présence des guillemets simples.

Si vous voulez supprimer les deux premiers caractères, voici le truc :

>>> a = bin(10)

>>> a

'0b1010'

>>> a = a[2::]

>>> a

'1010'

Le code [2::] veut dire de ne sélectionner qu'à partir de l'index 2. On ne prendra donc pas les caractères placés aux index 0 et 1.

'0b1010' devient donc '1010'.

12° Utiliser l'astuce ci-dessus pour tenter d'afficher les codes binaires des nombres compris entre 0 et 255 en décimal.

...CORRECTION...

for nombre in range(256) :

print( bin(nombre)[2::] )

On obtient alors cela par exemple :

Pour finir cette partie, on peut aussi convertir de l'hexadécimal en binaire de façon simple :

>>> bin(0xFF)

'0b11111111'

>>> bin(int('0xFF',16))

'0b11111111'

>>> bin(int('FF',16))

'0b11111111'

>>> bin(0xFF)[2::]

'11111111'

Convertir en base 16, l'hexadécimal

13° Utiliser les codes ci-dessous pour tenter de voir à quel nombre hexadécimal correspond le nombre décimal 15 .

>>> hex(10)

'0xa'

>>> hex(11)

'0xb'

Remarque :

La réponse correspond bien au code hexadécimal précédé du préfixe 0x .

Par contre, la réponse n'est pas réellement un nombre mais un string comme l'indique la présence des guillemets simples.

Si vous voulez supprimer les deux premiers caractères, voici le truc :

>>> a = hex(20)

>>> a

'0x14'

>>> a = a[2::]

>>> a

'14'

Le code [2::] veut dire de ne sélectionner qu'à partir de l'index 2. On ne prendra donc pas les caractères placés aux index 0 et 1.

'0x14' devient donc '14'.

14° Utiliser l'astuce ci-dessus pour tenter d'afficher les codes hexadécimaux des nombres compris entre 0 et 255 en décimal.

...CORRECTION...

for nombre in range(256) :

print( hex(nombre)[2::] )

On obtient alors cela par exemple :

0
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
10
11
12
13
14
15
16
17
18
19
1a
1b
1c
1d
1e
1f
20
21
22
23
24
25
26
27
28
29
2a
2b
2c
2d
2e
2f
30
31
32
33
34
35
36
37
38
39
3a
3b
3c
3d
3e
3f
40
41
42
43
44
45
46
47
48
49
4a
4b
4c
4d
4e
4f
50
51
52
53
54
55
56
57
58
59
5a
5b
5c
5d
5e
5f
60
61
62
63
64
65
66
67
68
69
6a
6b
6c
6d
6e
6f
70
71
72
73
74
75
76
77
78
79
7a
7b
7c
7d
7e
7f
80
81
82
83
84
85
86
87
88
89
8a
8b
8c
8d
8e
8f
90
91
92
93
94
95
96
97
98
99
9a
9b
9c
9d
9e
9f
a0
a1
a2
a3
a4
a5
a6
a7
a8
a9
aa
ab
ac
ad
ae
af
b0
b1
b2
b3
b4
b5
b6
b7
b8
b9
ba
bb
bc
bd
be
bf
c0
c1
c2
c3
c4
c5
c6
c7
c8
c9
ca
cb
cc
cd
ce
cf
d0
d1
d2
d3
d4
d5
d6
d7
d8
d9
da
db
dc
dd
de
df
e0
e1
e2
e3
e4
e5
e6
e7
e8
e9
ea
eb
ec
ed
ee
ef
f0
f1
f2
f3
f4
f5
f6
f7
f8
f9
fa
fb
fc
fd
fe
ff

Pour finir cette partie, on peut aussi convertir du binaire en hexadécimal de façon simple :

>>> hex(0b1111)

'0xf'

>>> hex(int('0b1111',2))

'0xf'

>>> hex(int('1111',2))

'0xf'

>>> hex(0b1111)[2::]

'f'

4 - Les vecteurs

Considérons un vecteur A dont le point d'application M possède les coordonnées (x;y) et dont on peut représenter les coordonnées de cette façon :

Tracer des vecteurs est très facile dans matplotlib : il suffit d'utiliser la méthode quiver. Cette méthode se présente de cette façon :

repVecteurs = ax.quiver(X, Y, U, V)

C'est une méthode puisqu'on agit sur la référence ax du graphique.

Mais il existe aussi une fonction qui porte le même nom : quiver. Fonction qui est dans le module plt :

repVecteurs = plt.quiver(X, Y, U, V)

Les listes X et Y doivent contenir les coordonnées des points d'application des différents vecteurs à tracer, respectivement sur en x et en y.

Les listes U et V doivent contenir les coordonnées des différents vecteurs sur x et y .

Comment savoir tout cela ? En allant voir la documentation : VERS LA DOC QUIVER SUR MATPLOTLIB.

Voyons cela avec quelques exemples simples :

Traçons un vecteur uniquement en x=1 et y=3.

import matplotlib.pyplot as plt

X = [ 1 ]

Y = [ 3 ]

U = [ 2 ]

V = [ -4 ]

fig, ax = plt.subplots()

ax.axis([ -5, 5, -5, 5 ])

ax.set_xticks([ k for k in range (-5,6) ])

ax.set_yticks([ k for k in range (-5,6) ])

traceVec = ax.quiver(X, Y, U, V)

fig.show()

15° Tester le programme précédent pour vérifier que vous parvenez bien à obtenir quelque chose de similaire à la capture d'écran ci-dessous. Dans le programme, comment parvient-on à régler les valeurs sur les axes ?

On remarque donc bien que le pont d'application est en x = 1 et y = 3. Le vecteur est bien orienté vers la droite et vers le bas mais l'échelle semble étrange. C'est normal : par défaut, matplotlib choisit de représenter les vecteurs avec une échelle qui lui semble adapté.

On remarquera également qu'on ne règle pas les valeurs affichées sur l'axe avec les fonctions xticks et yticks du module plt.

On parvient à agir directement sur la référence ax de notre graphique avec les méthodes set_xticks et set_yticks. Comme à chaque fois qu'on utilise une méhode sur un objet, on place un point entre l'objet et sa méthode :

ax.axis([ -5, 5, -5, 5 ])

ax.set_xticks([ k for k in range (-5,6) ])

ax.set_yticks([ k for k in range (-5,6) ])

En allant voir la documentation, on trouve que pour imposer une échelle, il faut rajouter quelques paramètres dont scale, un float permettant de donner l'échelle de représentation du vecteur.

traceVec = ax.quiver(X, Y, U, V, angles='xy', scale_units='xy', scale=1)

Ce réglage vous permettra d'avoir des vecteurs dont les coordonnées (u,v) correspondent bien à l'échelle du plan Oxy.

16° Utiliser cette modification pour tracer votre vecteur. Vous devriez obtenir ceci :

On observe donc bien un vecteur entre

un point initial (x=1, y=3) et
un point d'arrivée (x=3, y=-1) car (x=1+u, y=3+v) donne (x=1+2, y=3-4)

17° Placez maintenant votre échelle à 0.5 :

Comme vous pouvez le constater, on a cette fois un vecteur plus grand car nous venons de définir que l'échelle de xy est deux fois plus petit que l'échelle de uv :

On observe donc bien un vecteur entre

un point initial (x=1, y=3) et
un point d'arrivée (x=5, y=-5) car (x=1+u, y=3+v) donne (x=1+2*2=5,y=3-4*2=-5)

Si vous avez plusieurs vecteurs à tracer, il suffit donc de définir les 4 listes avec autant d'éléments que vous le voulez.

18° Compléter le programme suivant pour afficher quelque chose de similaire à l'image :

import matplotlib.pyplot as plt

X = [ 0,2 ]

Y = [ 0,0 ]

U = [ 2,0 ]

V = [ 0,2 ]

fig, ax = plt.subplots()

ax.axis([ -5, 5, -5, 5 ])

ax.set_xticks([ k for k in range (-5,6) ])

ax.set_yticks([ k for k in range (-5,6) ])

traceVec = ax.quiver(X, Y, U, V, angles='xy', scale_units='xy', scale=1)

fig.show()

...CORRECTION...

import matplotlib.pyplot as plt

X = [ 0,2,0 ]

Y = [ 0,0,0 ]

U = [ 2,0,2 ]

V = [ 0,2,2 ]

fig, ax = plt.subplots()

ax.axis([ -5, 5, -5, 5 ])

ax.set_xticks([ k for k in range (-5,6) ])

ax.set_yticks([ k for k in range (-5,6) ])

traceVec = ax.quiver(X, Y, U, V, angles='xy', scale_units='xy', scale=1)

fig.show()

Regardons maintenant comment nous pourrions afficher les vecteurs-accélération lors du déplacement d'un objet dont on connait l'équation horaire. Nous prendrons le cas simple d'un objet qui n'est soumis qu'à son poids et dont on connait la position et la vitesse initiale.

import matplotlib.pyplot as plt

# - - - - - -

# Initialisation

# - - - - - -

xo = 0 # m

yo = 0 # m

vox = 10 # m.s-1

voy = 20 # m.s-1

g = 9.81 # N.kg-1

m = 1 # kg

duree = 15 # s

t_cal = [ k/10 for k in range(0,duree*10) ] # liste des temps à calculer

# - - - - - -

# Déclaration des fonctions-équations horaires

# - - - - - -

def x(t) :

return vox*t + xo

def y(t) :

return -g*t**2 + voy*t + yo

def ax(t) :

return 0

def ay(t) :

return -g

# - - - - - -

# Corps du programme

# - - - - - -

X = [ x(t) for t in t_cal ] # X et Y sont les listes des coordonnées de l'objet

Y = [ y(t) for t in t_cal ]

Ax = [ ax(t) for t in t_cal ] # Ax et Ay sont les listes contenant les différentes valeurs de ax et ay

Ay = [ ay(t) for t in t_cal ]

fig, ax = plt.subplots()

trajectoire = ax.plot(X,Y, label="trajectoire", color="blue")

vecAcc = ax.quiver(X, Y, Ax, Ay, angles='xy', scale_units='xy', scale=2, label="vect.Acc.", color="red")

vecVit = ax.quiver([xo], [yo], [vox], [voy], angles='xy', scale_units='xy', scale=2, label="Vit.Init.", color="purple")

ax.axis([ -1, 20, -5, 15 ])

ax.set_xticks([ k for k in range (-1,21) ])

ax.set_yticks([ k for k in range (-5,16) ])

ax.set_xlabel("Coordonnée x(m)")

ax.set_ylabel("Coordonnée y(m)")

ax.legend(loc='upper center')

fig.show()

19° Tester le programme puis répondre aux questions suivantes :

Comment parvient-on à définir les temps où on désire faire un calcul ? Que devrait-on taper si on voulait 100 calculs sur la durée d'étude ?
Comment calcule-t-on les valeurs de la position et de l'accélération subie par l'objet ?
Comment calcule-t-on à modifier le texte visible sur les axes ?

...CORRECTION...

On place les valeurs des temps voulus dans la liste t_cal. Si on veut 100 calculs :

t_cal = [ k/100 for k in range(0,duree*100) ] # liste des temps à calculer

On calcule les valeurs en utilisant des fonctions. C'est plus pratique car on centralise les équations et on verra plus tard qu'on peut plus facilement compliquer les choses. De cettte façon, on peut assez facilement gérer le sol par exemple : on peut empêcher le projectile d'atteindre des valeurs y négatives.

On modifie les labels sur les axex à l'aide de la méthode set_xlabel plutôt qu'avec la fonction xlabel.

Dernière chose décrite ici : la largeur des vecteurs. Comme vous avez pu le constater, les vecteurs sont assez épais. On peut choisir facilement cette largeur par rapport à la taille de votre vue.

Pour définir une largeur, utilisez le paramètre nommé width. Un exemple avec un vecteur dont la largeur correspond à 0.2% de la taille de votre vue.

vecAcc = ax.quiver(X, Y, Ax, Ay, angles='xy', scale_units='xy', scale=2, label="vect.Acc.", color="red", width=0.002)

La larguer par défaut est de 0.5%, donc équivalent à width=0.005.

20° Tracer les vecteurs accélérations avec une épaisseur de 0.6% et le vecteur vitesse initiale avec une épaisseur de 0.3% :

On peut encore faire beaucoup de réglages. Il suffit d'aller voir la documentation.

Avec cela, nous sommes déjà capable de gérer la partie mécanique. Mais il manque encore quelques outils et connaissances pour faire les choses proprement. C'est ce que nous allons voir dans les activités suivantes.