Python

Oral
MP, PC, PSI, TSI
Calcul matriciel

On travaille avec les modules numpy et [Link].

import numpy as np
import [Link] as alg

Création de matrices
Pour définir une matrice, on utilise la fonction array du module numpy.

>>> A = [Link]([[1, 2, 3], [4, 5, 6]])

>>> A
array([[1, 2, 3],
[4, 5, 6]])

L’attribut shape donne la taille d’une matrice : nombre de lignes, nombre de colonnes. On peut redimensionner
une matrice, sans modifier ses termes, à l’aide de la méthode reshape.

>>> [Link]
(2, 3)
>>> A = [Link]((3, 2))
>>> A
array([[1, 2],
[3, 4],
[5, 6]])

L’accès à un terme de la matrice A se fait à l’aide de l’opération d’indexage A[i, j] où i désigne la ligne
et j la colonne. Attention, les indices commencent à zéro ! À l’aide d’intervalles, on peut également
récupérer une partie d’une matrice : ligne, colonne, sous-matrice. Rappel, a :b désigne l’intervalle ouvert à
droite ⟦𝑎, 𝑏⟦, : désigne l’intervalle contenant tous les indices de la dimension considérée. Notez la différence entre
l’indexation par un entier et par un intervalle réduit à un entier.

>>> A[1, 0] # terme de la deuxième ligne, première colonne

3
>>> A[0, :] # première ligne sous forme de tableau à 1 dimension
array([1, 2])
>>> A[0, :].shape
(2,)
>>> A[0 :1, :] # première ligne sous forme de matrice ligne
array([[1, 2]])
>>> A[0 :1, :].shape
(1, 2)
>>> A[ :, 1] # deuxième colonne sous forme de tableau à 1 dimension
>>> array([2, 4, 6])
A[ :, 1 :2] # deuxième colonne sous forme de matrice colonne
array([[2],
[4],
[6]])
>>> A[1 :3, 0 :2] # sous-matrice lignes 2 et 3, colonnes 1 et 2
array([[3, 4],
[5, 6]])

15 mai 2017 08:56 Python-matrices-1

Les fonctions zeros et ones permettent de créer des matrices remplies de 0 ou de 1. La fonction eye permet de
créer une matrice du type 𝐼𝑛 où 𝑛 est un entier. La fonction diag permet de créer une matrice diagonale.

>>> [Link]((2,3))
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
>>> [Link]((3,2))
array([[ 1., 1.],
[ 1., 1.],
[ 1., 1.]])
>>> [Link](4)
array([[ 1., 0., 0., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 0., 0., 1.]])
>>> [Link]([1,2,3])
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])

Enfin la fonction concatenate permet de créer des matrices par blocs en superposant (axis=0) ou en plaçant
côte à côte (axis=1) plusieurs matrices.

>>> A = [Link]((2,3))
>>> B = [Link]((2,3))
>>> [Link]((A,B), axis=0)
array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 0., 0., 0.],
[ 0., 0., 0.]])
>>> [Link]((A,B), axis=1)
array([[ 1., 1., 1., 0., 0., 0.],
[ 1., 1., 1., 0., 0., 0.]])

Quelques méthodes ou fonctions utiles avec les tableaux Numpy

Pour copier un tableau, il est recommandé d’utiliser la méthode copy.

>>> A = [Link]([[1,-2,3], [-4,5,-6]])

>>> B = [Link]()
>>> B[1, 0] = 8
>>> A
array([[ 1, -2, 3],
[-4, 5, -6]])
>>> B
array([[ 1, -2, 3],
[ 8, 5, -6]])

Les fonctions amax,amin et mean du module numpy permettent respectivement de calculer le maximum, le
minimum et la moyenne des éléments d’un tableau.

>>> [Link](A)
5
>>> [Link](A)
-6
>>> [Link](A)
-0.5

Enfin la commande array_equal permet de tester l’égalité terme à terme de deux tableaux de même taille.

>>> np.array_equal(A, B)
False

15 mai 2017 08:56 Python-matrices-2

Calcul matriciel
Les opérations d’ajout et de multiplication par un scalaire se font avec les opérateurs + et *.

>>> A = [Link]([[1,2], [3,4]])

>>> B = [Link](2)
>>> A + 3*B
array([[ 4., 2.],
[ 3., 7.]])

Pour effectuer un produit matriciel (lorsque que cela est possible), il faut employer la fonction dot.

>>> A = [Link]([[1,2], [3,4]])

>>> B = [Link]([[1,1,1], [2,2,2]])
>>> [Link](A, B)
array([[ 5, 5, 5],
[11, 11, 11]])

On peut également utiliser la méthode dot qui est plus pratique pour calculer un produit de plusieurs matrices.
Enfin la fonction matrix_power du module [Link] permet de calculer des puissances de matrices.

>>> [Link](B)
array([[ 5, 5, 5],
[11, 11, 11]])
>>> [Link](B).dot([Link]((3,2)))
array([[ 15., 15.],
[ 33., 33.]])
>>> alg.matrix_power(A,3)
array([[ 37, 54],
[ 81, 118]])

La transposée s’obtient avec la fonction transpose. L’expression A.T renvoie aussi la transposée de A.

>>> [Link](B)
array([[1, 2],
[1, 2],
[1, 2]])
>>> B.T
array([[1, 2],
[1, 2],
[1, 2]])

Le déterminant, le rang et la trace d’une matrice s’obtiennent par les fonctions det, matrix_rank du module
[Link] et trace du module numpy. Enfin la fonction inv du module [Link] renvoie l’inverse de
la matrice s’il existe.

>>> [Link](A)
-2.0000000000000004
>>> alg.matrix_rank(A)
2
>>> [Link](A)
5
>>> [Link](A)
matrix([[-2. , 1. ],
[ 1.5, -0.5]])

Pour résoudre le système linéaire 𝐴𝑥 = 𝑏 lorsque la matrice 𝐴 est inversible, on peut employer la fonction solve
du module [Link].

>>> b = [Link]([1,5])
>>> [Link](A, b)
array([ 3., -1.])

15 mai 2017 08:56 Python-matrices-3

Éléments propres d’une matrice
La fonction poly du module numpy appliquée à une matrice carrée renvoie la liste des coefficients du polynôme
caractéristique par degré décroissant.

>>> A = [Link]([[2,-4],[1,-3]])
>>> [Link](A)
array([ 1., 1., -2.])

La fonction eigvals du module [Link] renvoie les valeurs propres de la matrice.

>>> [Link](A)
array([ 1., -2.])

Pour obtenir en plus les vecteurs propres associés, il faut employer la fonction eig. Cette fonction renvoie un
tuple constitué de la liste des valeurs propres et d’une matrice carrée. La 𝑖ième colonne de cette matrice est un
vecteur propre associé à la 𝑖ième valeur de la liste des valeurs propres. Dans l’exemple ci dessous, on peut conclure
1
que ( ) est un vecteur propre de 𝐴 associé à la valeur propre -2. On vérifie aussi que 𝐴 est diagonalisable.
1

>>> L = [Link](A)
>>> L
(array([ 1., -2.]), array([[ 0.9701425, 0.70710678],
[ 0.24253563, 0.70710678]]))
>>> L[1][ :,1]
array([ 0.70710678, 0.70710678])
>>> L[1].dot([Link](L[0])).dot([Link](L[1]))
array([[ 2., -4.],
[ 1., -3.]])

Produit scalaire et produit vectoriel

La fonction vdot permet de calculer le produit scalaire de deux vecteurs de ℝ𝑛 .

>>> u = [Link]([1,2])
>>> v = [Link]([3,4])
>>> [Link](u, v)
11

La fonction cross permet de calculer le produit vectoriel de deux vecteurs de ℝ3 .

>>> u = [Link]([1,0,0])
>>> v = [Link]([0,1,0])
>>> [Link](u, v)
array([0, 0, 1])

15 mai 2017 08:56 Python-matrices-4

 Python
Oral
MP, PC, PSI, TSI
Analyse numérique

La plupart des fonctions présentées dans cette section nécessitent l’import du module numpy et de sous-modules
du module scipy. Les instructions nécessaires aux exemples suivants sont listés ci-dessous.

import numpy as np
import [Link] as resol
import [Link] as integr
import [Link] as plt

Nombres complexes
Python calcule avec les nombres complexes. Le nombre imaginaire pur 𝑖 se note 1j. Les attributs real et imag
permettent d’obtenir la partie réelle et la partie imaginaire. La fonction abs calcule le module d’un complexe.

>>> a = 2 + 3j
>>> b = 5 - 3j
>>> a*b
(19+9j)
>>> [Link]
2.0
>>> [Link]
3.0
>>> abs(a)
3.6055512754639896

Fonctions mathématiques
La constante 𝜋 s’obtient grâce à la commande pi.

Le module numpy connaît les fonctions mathématiques usuelles. La fonction partie entière s’obtient par la
commande floor. Attention la fonction logarithme népérien a pour nom de commande log.

>>> [Link](1)
2.7182818284590451
>>> [Link]([Link])
-1.0
>>> [Link]([Link](1))
1.0
>>> [Link](3.4)
3
>>> [Link](-3.7)
-4

15 mai 2017 08:37 Python-AN-1

Résolution approchée d’équations
Pour résoudre une équation du type 𝑓(𝑥) = 0 où 𝑓 est une fonction d’une variable réelle, on peut utiliser la
fonction fsolve du module [Link]. Il faut préciser la valeur initiale 𝑥0 de l’algorithme employé par
la fonction fsolve. Le résultat peut dépendre de cette condition initiale.

def f(x) :
return x**2 - 2

>>> [Link](f, -2.)

array([-1.41421356])

>>> [Link](f, 2.)

array([ 1.41421356])

Dans le cas d’une fonction 𝑓 à valeurs vectorielles, on utilise la fonction root. Par exemple, pour résoudre le
système non linéaire

𝑥2 − 𝑦2 = 1
{
𝑥 + 2𝑦 − 3 = 0

def f(v) :
return v[0]**2 - v[1]**2 - 1, v[0] + 2*v[1] - 3

>>> sol = [Link](f, [0,0])

>>> [Link]
True
>>> sol.x
array([ 1.30940108, 0.84529946])

>>> sol=[Link](f, [-5,5])

>>> [Link]
True
>>> sol.x
array([-3.30940108, 3.15470054])

Calcul approché d’intégrales

La fonction quad du module [Link] permet de calculer des valeurs approchées d’intégrales. Elle
renvoie une valeur approchée de l’intégrale ainsi qu’un majorant de l’erreur commise. Cette fonction peut aussi
s’employer avec des bornes d’intégration égales à +∞ ou −∞.

def f(x) :
return [Link](-x)

>>> [Link](f, 0, 1)
(0.6321205588285578, 7.017947987503856e-15)

>>> [Link](f, 0, [Link])

(1.0000000000000002, 5.842607038578007e-11)

Cette fonction peut être employée pour la définition d’intégrales à paramètres. Ainsi si on veut obtenir des
+∞

valeurs approchées de Γ(𝑥) = ∫ 𝑒−𝑡 𝑡𝑥−1 d𝑡 pour 𝑥 réel strictement positif on pourra procéder ainsi :
0

def g(x) :
def f(t) :
return [Link](-t)*t**(x-1)
return [Link](f,0,[Link])[0]

>>> g(2)
0.9999999999999998

15 mai 2017 08:37 Python-AN-2

Résolution approchées d’équations différentielles
Pour résoudre une équation différentielle 𝑥′ = 𝑓(𝑥, 𝑡), on peut utiliser la fonction odeint du module [Link]-
tegrate. Cette fonction nécessite une liste de valeurs de 𝑡, commençant en 𝑡0 , et une condition initiale 𝑥0 . La
fonction renvoie des valeurs approchées (aux points contenus dans la liste des valeurs de 𝑡) de la solution 𝑥
de l’équation différentielle qui vérifie 𝑥(𝑡0 ) = 𝑥0 . Pour trouver des valeurs approchées sur [0, 1] de la solution
𝑥′(𝑡) = 𝑡𝑥(𝑡) qui vérifie 𝑥(0) = 1, on peut employer le code suivant.

def f(x, t) :
return t*x

>>> T = [Link](0, 1.01, 0.01)

>>> X = [Link](f, 1, T)
>>> X[0]
array([ 1.])
>>> X[-1]
array([ 1.64872143])
>>> [Link](T,X)
>>> [Link]()

Si on veut résoudre, sur [0, 1], le système différentiel

𝑥′(𝑡) = −𝑥(𝑡) − 𝑦(𝑡)

{
𝑦′(𝑡) = 𝑥(𝑡) − 𝑦(𝑡)

avec la condition initiale 𝑥(0) = 2, 𝑦(0) = 1 le code devient le suivant.

def f(x, t) :
return [Link]([-x[0]-x[1], x[0]-x[1]])

>>> T = [Link](0, 5.01, 0.01)

>>> X = [Link](f, [Link]([2.,1.]), T)
>>> X[0]
array([ 2., 1.])
>>> [Link](X[ :,0], X[ :,1])
>>> [Link]()

15 mai 2017 08:37 Python-AN-3

Pour résoudre une équation différentielle scalaire d’ordre 2 de solution 𝑥, on demandera la résolution du système
𝑥(𝑡)
différentiel d’ordre 1 satisfait par 𝑋(𝑡) = ( ).
𝑥′(𝑡)

Ainsi, si on considère la fonction 𝑥 qui vérifie l’équation différentielle 𝑥″(𝑡) + 2𝑥′(𝑡) + 3𝑥(𝑡) = sin(𝑡) avec les
𝑥′(𝑡)
conditions initiales 𝑥(0) = 0, 𝑥′(0) = 1 et , le vecteur 𝑋 vérifiera 𝑋′(𝑡) = ( ). Pour
−2𝑥′(𝑡) − 3𝑥(𝑡) − sin(𝑡)
obtenir la représentation graphique de 𝑥 sur l’intervalle [0, 3𝜋], on pourra utiliser le code suivant :

def f(x,t) :
return [Link]([x[1], -2*x[1] - 3*x[0] + [Link](t)])

T = [Link](0, 3*[Link] + 0.01, 0.01)

X = [Link](f, [Link]([0,1]), T)
[Link](T, X[ :,0])
[Link]()

15 mai 2017 08:37 Python-AN-4

 Python
Oral
MP, PC, PSI, TSI
Polynômes

La classe Polynomial du module [Link] permet de travailler avec des polynômes.

from [Link] import Polynomial

Pur créer un polynôme, il faut lister ses coefficients par ordre de degré croissant. Par exemple, pour le polynôme
𝑋 3 + 2𝑋 − 3,

p = Polynomial([-3, 2, 0, 1])

On peut alors utiliser cette variable comme une fonction pour calculer, en un point quelconque, la valeur de la
fonction polynôme associée. Cette fonction peut agir également sur un tableau de valeurs, elle calcule alors la
valeur de la fonction polynôme en chacun des points indiqués.

>>> p(0)
-3.0
>>> p([1, 2, 3])
array([ 0., 9., 30.])

L’attribut coef donne accès aux coefficients ordonnés par degré croissant ; ainsi [Link][i] correspond au
coefficient du terme de degré i. La méthode degree renvoie le degré du polynôme alors que roots calcule ses
racines.

>>> [Link]
array([-3., 2., 0., 1.])
>>> [Link][1]
2.0
>>> [Link]()
3
>>> [Link]()
array([-0.5-1.6583124j, -0.5+1.6583124j, 1.0+0.j ])

La méthode deriv renvoie un nouveau polynôme, dérivé du polynôme initial. Cette méthode prend en argument
facultatif un entier positif indiquant le nombre de dérivations à effectuer. De la même manière la méthode integ
intègre le polynôme, elle prend un paramètre optionnel supplémentaire donnant la constante d’intégration
à utiliser, ce paramètres peut être une liste en cas d’intégration multiple ; les constantes d’intégration non
précisées sont prises égales à zéro.

>>> [Link]().coef
array([ 2., 0., 3.])
>>> [Link](2).coef
array([ 0., 6.])
>>> [Link](5).coef
array([-0.])
>>> [Link]().coef
array([ 0. , -3. , 1. , 0. , 0.25])
>>> [Link](1, 2).coef # intégrer une fois avec la constante 2
array([ 2. , -3. , 1. , 0. , 0.25])
>>> [Link](2, [1, 2]).coef # intégrer deux fois
array([ 2. , 1. , -1.5 , 0.33333333, 0. ,
0.05 ])

15 mai 2017 09:35 Python-polynomes-1

Les opérateurs +, -, * permettent d’additionner, soustraire et multiplier des polynômes. Ils fonctionnent égale-
ment entre un polynôme et un scalaire. L’opérateur ** permet d’élever un polynôme à une puissance entière
positive. Enfin, on peut composer deux polynômes (p(q) remplace l’indéterminée 𝑋 par le polynôme q dans le
polynôme p)

>>> a = Polynomial([1, 2, 1])

>>> b = Polynomial([5, 3])
>>> p = 2*a * b + Polynomial([-7, 2])
>>> [Link]
array([ 3., 28., 22., 6.])
>>> (p**2).coef
array([ 9., 168., 916., 1268., 820., 264., 36.])
>>> a(b).coef
array([ 36., 36., 9.])

L’opérateur / permet de diviser un polynôme par un scalaire. Pour diviser deux polynômes il faut utiliser
l’opérateur // qui renvoie le quotient ; l’opérateur % calcule le reste.

>>> (p / 2).coef
array([ 1.5, 14. , 11. , 3. ])
>>> q = p // a
>>> r = p % a
>>> [Link]
array([ 10., 6.])
>>> [Link]
array([-7., 2.])
>>> (q * a + r).coef
array([ 3., 28., 22., 6.])

15 mai 2017 09:35 Python-polynomes-2

 Python
Oral
MP, PC, PSI, TSI
Probabilités

Les fonctions d’échantillonnage et de génération de valeurs pseudo-aléatoires sont regroupées dans la bibliothèque
[Link].

import [Link] as rd

L’expression randint(a, b) permet de choisir un entier au hasard dans l’intervalle ⟦𝑎, 𝑏⟦. La fonction randint
prend un troisième paramètre optionnel permettant d’effectuer plusieurs tirages et de renvoyer les résultat sous
forme de tableau ou de matrice.

>>> [Link](1, 7) # un lancer de dé

2
>>> [Link](1, 7, 20) # 20 lancers de dé
array([5, 2, 2, 3, 1, 5, 5, 3, 6, 4, 2, 6, 6, 4, 3, 2, 4, 5, 1, 3])
>>> [Link](1, 7, (4, 5)) # 20 lancers de dé sous forme d'une matrice 4x5
array([[3, 6, 1, 6, 3],
[5, 1, 6, 2, 2],
[3, 1, 2, 2, 5],
[5, 2, 6, 1, 4]])

La fonction random renvoie un réel compris dans l’intervalle [0, 1[. Si 𝑋 désigne la variable aléatoire correspondant
au résultat de la fonction random, alors pour tout 𝑎 et 𝑏 dans [0, 1] avec 𝑎 ⩽ 𝑏, on a 𝑃 (𝑎 ⩽ 𝑋 < 𝑏) = 𝑏 − 𝑎.
Cette fonction accepte un paramètres optionnel permettant de réaliser plusieurs tirages et de les renvoyer sous
forme de tableau ou de matrice.

>>> [Link]()
0.9168092013708049
>>> [Link](4)
array([ 0.98748897, 0.86589972, 0.53683001, 0.50687386])
>>> [Link]((2,4))
array([[ 0.78230688, 0.83803526, 0.62077457, 0.27432819],
[ 0.66522387, 0.71258365, 0.25813448, 0.28833084]])

La fonction binomial permet de simuler une variable aléatoire suivant une loi binomiale de paramètres n et p.
Elle permet donc également de simuler une variable aléatoire suivant une loi de Bernoulli de paramètres p en
prenant simplement 𝑛 = 1. Cette fonction prend un troisième paramètre optionnel qui correspond, comme pour
les fonctions précédentes, au nombre de valeurs à obtenir.

>>> [Link](10, 0.3, 7)

array([2, 2, 2, 2, 2, 4, 3])
>>> [Link](1, 0.6, 20)
array([0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1])

Les fonctions geometric et poisson fonctionnement de la même manière pour les lois géométrique ou de Poisson.

>>> [Link](0.5, 8)
array([1, 1, 3, 1, 3, 2, 5, 1])
>>> [Link](4, 15)
array([5, 2, 3, 4, 6, 0, 5, 3, 1, 5, 1, 5, 9, 4, 6])

15 mai 2017 09:41 Python-random

 Python
Oral
MP, PC, PSI, TSI
Réalisation de tracés
Les fonctions présentées dans ce document permettent la réalisation de tracés. Elles nécessitent l’import du
module numpy et du module [Link]. De plus pour effectuer des tracés en dimension 3, il convient
d’importer la fonction Axes3d du module mpl_toolkits.mplot3d. Les instructions nécessaires aux exemples
qui suivent sont listés ci-dessous.

import math
import [Link] as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D

Tracés de lignes brisées et options de tracés

On donne la liste des abscisses et la liste des ordonnées puis on effectue le tracé. La fonction axis permet de
définir la fenêtre dans laquelle est contenue le graphique. L’option equal permet d’obtenir les mêmes échelles
sur les deux axes. Les tracés relatifs à divers emplois de la fonction plot se superposent. La fonction [Link]()
efface les tracés contenus dans la fenêtre graphique.

x = [1., 2.5, 4.]

y = [3., 1., 5.]
[Link]('equal')
[Link](x, y)
[Link]([-1., 5., -1., 6.])
[Link]()
[Link]()

La fonction plot admet de nombreuses options de présentation. Le paramètre color permet de choisir la couleur
('g' : vert, 'r' : rouge, 'b' : bleu). Pour définir le style de la ligne, on utilise linestyle ('-' : ligne continue,
'- -' : ligne discontinue, ' :' : ligne pointillée). Si on veut marquer les points des listes, on utilise le paramètre
marker ('+', '.', 'o', 'v' donnent différents symboles).

x = [1., 2.5, 4.]

y = [3., 1., 5.]
[Link]([-1., 5., -1., 6.])
[Link](x, y, color='r', linestyle=' :',
marker='o')
[Link]()

15 mai 2017 09:43 Python-plot-1

Tracés de fonction
On définit une liste d’abscisses puis on construit la liste des ordonnées correspondantes. L’exemple ci-dessous
trace 𝑥 ↦ sin 𝑥 sur [0, 3𝜋].

def f(x) :
return [Link](x)

X = [Link](0, 3*[Link], 0.01)

Y = [ f(x) for x in X ]
[Link](X, Y)
[Link]()

Il est généralement plus intéressant d’utiliser les fonctions du module numpy, plutôt que celles du module math,
car elles permettent de travailler aussi bien avec des scalaires qu’avec des tableaux (on les appelle fonctions
vectorisées et universal function ou ufunc dans la documentation officielle de Python).

def f(x) :
return [Link](x)

X = [Link](0, 3*[Link], 0.01)

Y = f(X)
[Link](X, Y)
[Link]()

Une autre solution consiste à utiliser la fonction vectorize du module numpy qui permet de transformer une
fonction scalaire en une fonction capable de travailler avec des tableaux. Il est cependant beaucoup plus efficace
d’utiliser directement des fonctions vectorisées.

def f(x) :
return [Link](x)

f = [Link](f)

Il est à noter que les opérateurs python (+, -, *, etc.) peuvent s’appliquer à des tableaux, ils agissent alors terme
à terme. Ainsi la fonction f définie ci-dessous est une fonction vectorisée, elle peut travailler aussi bien avec
deux scalaires qu’avec deux tableaux et même avec un scalaire et un tableau.

def f(x, y) :
return [Link](x**2 + y**2)

>>> f(3, 4)
5.0
>>> f([Link]([1, 2, 3]), [Link]([4, 5, 6]))
array([ 4.12310563, 5.38516481, 6.70820393])
>>> f([Link]([1, 2, 3]), 4)
array([ 4.12310563, 4.47213595, 5. ])

15 mai 2017 09:43 Python-plot-2

Tracés d’arcs paramétrés
Dans le cas d’un arc paramétré plan, on définit d’abord la liste des valeurs données au paramètre puis on
construit la liste des abscisses et des ordonnées correspondantes. On effectue ensuite le tracé.

def x(t) :
return [Link](2*t)

def y(t) :
return [Link](3*t)

T = [Link](0, 2*[Link], 0.01)

X = x(T)
Y = y(T)
[Link]('equal')
[Link](X, Y)
[Link]()

Voici un exemple de tracé d’un arc paramétré de l’espace.

ax = Axes3D([Link]())
T = [Link](0, 2*[Link], 0.01)
X = [Link](T)
Y = [Link](T)
Z = T
[Link](X, Y, T)
[Link]()

Tracé de surfaces
Pour tracer une surface d’équation 𝑧 = 𝑓(𝑥, 𝑦), on réalise d’abord une grille en (𝑥, 𝑦) puis on calcule les valeurs
de 𝑧 correspondant aux points de cette grille. On fait ensuite le tracé avec la fonction plot_surface.

ax = Axes3D([Link]())

def f(x,y) :
return x**2 - y**2

f=[Link](f)
X = [Link](-1, 1, 0.02)
Y = [Link](-1, 1, 0.02)
X, Y = [Link](X, Y)
Z = f(X, Y)
ax.plot_surface(X, Y, Z)
[Link]()

15 mai 2017 09:43 Python-plot-3

Tracé de lignes de niveau
Pour tracer des courbes d’équation 𝑓(𝑥, 𝑦) = 𝑘, on fait une grille en 𝑥 et en 𝑦 sur laquelle on calcule les valeurs
de 𝑓. On emploie ensuite la fonction contour en mettant dans une liste les valeurs de 𝑘 pour lesquelles on veut
tracer la courbe d’équation 𝑓(𝑥, 𝑦) = 𝑘.

def f(x,y) :
return x**2 + y**2 + x*y

f=[Link](f)
X = [Link](-1, 1, 0.01)
Y = [Link](-1, 1, 0.01)
X, Y = [Link](X, Y)
Z = f(X, Y)
[Link]('equal')
[Link](X, Y, Z, [0.1,0.4,0.5])
[Link]()

15 mai 2017 09:43 Python-plot-4