Tables de matières
La fonction, en mathématiques, est une loi qui définit une relation entre une variable et une autre. Les fonctions sont omniprésentes en mathématiques et sont importantes pour visualiser les relations physiques en science.
La visualisation d'une fonction f (x) se fait en dessinant la courbe y = f (x) dans un repère xy. Lorsque nous utilisons un ordinateur pour effectuer cette tâche, nous mentionnons à la machine que nous dessinons la courbe. En d'autres termes, nous dessinons une courbe en traçant des lignes droites entre n points sur la courbe. Plus nous utilisons de points, plus la courbe apparaît lisse.
Dans ce tutoriel, tout en utilisant numpy et matplotlib vous apprendrez les sujets suivants:
Numpy est le package indispensable pour le calcul scientifique en Python. C’est une bibliothèque Python qui nous donne un objet de tableau multidimensionnel, divers objets dérivés (tels que des tableaux et des matrices cachées), et un assortiment de routines pour des opérations rapides sur des tableaux, y compris des opérations mathématiques et logiques, façonner, trier, sélectionner, E / S, transformées de Fourier discrètes, algèbre linéaire de base, opérations statistiques de base, simulation aléatoire… Pour plus d’informations sur cette bibliothèque, consultez le tutoriel suivant : Tutoriel Python : La librairie Numpy.
Matplotlib.pyplot est un package python qui contient des fonctions de style de commande qui rendent matplotlib efficace. Chaque fonction pyplot modifie une figure, par exemple : créer une figure, créer une zone de tracé dans une figure, dessiner des lignes dans une zone de tracé, décorer le tracé avec des étiquettes, ajouter des titres et des couleurs, etc.
Nous commençons par tracer l'équation quadratique la plus simple y=x².
Fonction quadratique
Les fonctions quadratiques sont des équations polynomiales du second ordre de type ax²+ bx + c = 0. Vous trouverez ci-dessous le code Matplotlib pour tracer la fonction y = x² :
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-2, 2, 70)
y = x ** 2
fig = plt.figure(figsize = (10, 5))
plt.plot(x, y)
plt.show()
Résultat d’exécution :
Il existe de nombreuses fonctions pyplot disponibles pour la personnalisation des tracés, ainsi que des styles de lignes et des styles de marqueurs pour styliser le tracé. Le tableau ci-dessous regroupe les fonctions les plus importantes :
|
Fonction |
Description |
|
plt.xlim() |
définit les limites de l'axe X |
|
plt.ylim() |
définit les limites de l'axe Y |
|
plt.grid() |
ajoute des lignes de quadrillage dans le tracé |
|
plt.title() |
ajoute un titre |
|
plt.xlabel() |
ajoute une étiquette à l'axe horizontal |
|
plt.ylabel() |
ajoute une étiquette à l'axe vertical |
|
plt.axis() |
définit les propriétés de l'axe (égal, désactivé, mis à l'échelle, etc.) |
|
plt.xticks() |
définit les emplacements des graduations sur l'axe horizontal |
|
plt.yticks() |
définit les emplacements des graduations sur l'axe vertical |
|
plt.legend() |
utilisé pour afficher les légendes de plusieurs lignes dans la même figure |
|
plt.savefig() |
enregistre la figure (au format .png, .pdf, etc.) dans le répertoire de travail |
|
plt.figure() |
utilisé pour définir de nouvelles propriétés de figure |
Styles de ligne
|
Caractère |
Style de ligne |
|
– |
style de ligne continue |
|
— |
style de ligne en pointillé |
|
-. |
style de ligne pointillé |
|
: |
style de ligne pointillée |
Marqueurs
|
Caractère |
Marqueur |
|
. |
point |
|
o |
cercle |
|
v |
triangle |
|
^ |
triangle |
|
s |
Carré |
|
p |
pentagone |
|
* |
Etoile |
|
+ |
plus |
|
x |
croix |
|
D |
diamant |
Exemple :
Nous allons utiliser la même fonction de l'exemple précédent et lui appliquer quelques modifications en utilisant les tableaux ci-dessus :
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-2, 2, 70)
y = x ** 2
fig = plt.figure(figsize = (14, 8))
plt.plot(x, y, alpha = 0.5, label ='f(x) = X²',
color ='red', linestyle ='dashed',
linewidth = 2 )
plt.title('Courbe de fonction f(x)=x²')
plt.xlabel('x ')
plt.ylabel('f(x)')
fig.text(0.9, 0.15, 'cours-gratuit.com',
fontsize = 12, color ='green',
ha ='right', va ='bottom',
alpha = 0.7)
plt.grid(alpha =.6, linestyle =':')
plt.legend()
plt.show()
Résultat d’exécution :
En mathématiques, une fonction cubique est une fonction de la forme où a est différent de zéro; ou en d'autres termes, une fonction définie par un polynôme de degré trois.
Puisque l'exposant en y = x3, la puissance est liée à des valeurs négatives pour les valeurs négatives de x, nous devons déplacer l'axe des x vers le centre du graphe
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-5,5,100)
y = x**3
# mettre les axes au centre
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.spines['left'].set_position('center')
ax.spines['bottom'].set_position('center')
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
plt.title('Courbe du fonction cubique')
#Ajouter un filigrane
fig.text(0.9, 0.15, 'cours-gratuit.com',
fontsize = 12, color ='green',
ha ='right', va ='bottom',
alpha = 0.7)
plt.grid(alpha =.6, linestyle =':')
plt.plot(x,y)
plt.show()
Résultat d’exécution:
Les fonctions trigonométriques sont des fonctions élémentaires dont l'argument est un angle. Les fonctions trigonométriques décrivent la relation entre les côtés et les angles d'un triangle rectangle. Les applications des fonctions trigonométriques sont extrêmement diverses. Ces fonctions apparaissent souvent dans la solution d'équations différentielles et d'équations fonctionnelles. Les fonctions trigonométriques comprennent les fonction suivantes : sinus, cosinus, tangente, cotangente. Pour chacune de ces fonctions, il existe une fonction trigonométrique inverse.
On trace ici la fonction trigonométrique y = sin (x), pour les valeurs de x entre ?? et ?. Nous allons utiliser la méthode linespace
Syntaxe:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-np.pi,np.pi,100)
fig = plt.figure(figsize = (16, 7))
y = np.sin(x)
plt.plot(x, y, 'b', label ='sin(x)')
#Ajouter des spécifications a notre figure
plt.legend()
plt.grid(True, linestyle =':')
plt.xlim([-6, 6])
plt.ylim([-4, 4])
plt.title('Courbe de foncion sin(x)')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.show()
Résultat d’exécution :
Remarque: nous pouvons utiliser la même syntaxe pour tracer la courbe de cos (x)
Une fonction exponentielle est une fonction mathématique de la forme suivante: f (x) = ax. Où x est une variable et a est une constante appelée la base de la fonction. La base de fonction exponentielle la plus fréquemment rencontrée est le nombre transcendantal e, qui est égal à environ 2,71828. Ainsi, l'expression de cette function devient: f (x) = e x
La fonction exponentielle y = ex n'aurait jamais de valeurs négatives pour une valeur de x en mettant ax.spines ['bottom'] à zéro et on le trace sur l'intervalle ?2 ? à 2 :
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-2,2,100)
y = np.exp(x)
plt.title('Courbe d\' une fonction exponentielle')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.plot(x, y, alpha = 0.4,
color ='yellow', linestyle ='dashed',
linewidth = 2)
plt.grid(alpha =.6, linestyle ='-')
plt.plot(x,y, 'y', label='f(x)=e^x')
#Placer la lagénde
plt.legend(loc='upper left')
plt.show()
Résultat d’exécution :
Les fonctions polynomiales sont parmi les fonctions mathématiques les plus simples, les plus importantes et les plus couramment utilisées. Ces fonctions consistent en un ou plusieurs termes de variables avec des exposants entiers.
Une fonction polynomiale est une fonction telle qu'une quadratique, une cubique, une quartique, etc., n'impliquant que des puissances entières non négatives de x. On peut donner une définition générale d'un polynôme, et définir son degré
Exemple : f (x) = 4x³ - 3x² + 2
Cette fonction appelée polynôme cubique car polynôme de degré 3, car 3 est la puissance la plus élevée de la formule x. Traçons alors cette simple fonction polynomiale en utilisant python : f (x) = x ² - 2x + 7
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-10,10,100)
fx = []
for i in range (len(x)):
fx.append(x[i]**2-2*x[i]+7)
plt.title('Courbe d\' une fonction polynomiales')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.plot(fx,x, label='f (x) = x ² - 2x + 7')
plt.legend(loc='upper left')
plt.grid()
plt.axvline()
plt.axhline()
Résultat d’exécution :
Voyons une autre fonction polynomiale plus complexe :
f(x) = x ³— 3x³ — 45x²-69x + 80
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-10,10,100)
fx = []
for i in range (len(x)):
fx.append(x[i]**3-3*x[i]**2-45*x[i]**2-69*x[i]+80)
plt.title('Courbe d\' une fonction polynomiale')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.plot(fx,x, label='f(x) = x ³— 3x³ — 45x²-69x + 80 ')
plt.legend(loc='upper right')
plt.grid()
plt.axvline()
plt.axhline()
Résultat d’exécution:
Une tâche de tracé courante consiste à comparer deux courbes ou plus, ce qui nécessite que plusieurs courbes soient dessinées dans le même tracé. Supposons que nous voulons tracer les deux fonctions f1 (x) = x2exp (?x2) et f2(x) = x4exp (?x2). Nous pouvons alors simplement émettre deux commandes de tracé, une pour chaque fonction. Pour que la syntaxe ressemble à MATLAB, nous appelons hold ('on') après la première commande de tracé pour indiquer que les commandes de tracé suivantes doivent dessiner les courbes dans le premier tracé :
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
def f1(x):
return x**2*np.exp(-x**2)
def f2(x):
return x**2*f1(x)
x= np.linspace(0, 3, 51)
y1 = f1(x)
y2 = f2(x)
plt.plot(x, y1, 'r-')
plt.plot(x, y2, 'bo')
plt.xlabel('x')
plt.ylabel('y')
plt.legend(['x^2*exp(-x^2)', 'x^4*exp(-x^2)'])
plt.title('Tracer deux courbes dans le même tracé')
plt.show()
Résultat d’exécution :
Dans ces commandes de tracé, nous avons également spécifié le type de ligne: r- signifie ligne rouge (r) (-), tandis que bo signifie un cercle bleu (b) (o) à chaque point de données. Les légendes de chaque courbe sont spécifiées dans une liste où la séquence de chaînes correspond à la séquence de commandes de tracé.
Considérons la fonction suivante f (x) = x² + 7
En utilisant matplotlib et numpy, essayez de tracer une courbe avec les spécifications suivantes:
Considérons la fonction suivante f (x) = 4x³ - 3x² + 2
En utilisant matplotlib et numpy, essayez de tracer une courbe avec les spécifications suivantes:
Considérons les deux fonctions suivantes :
f 1(x) = cos (x) et f 2(x) = sin (x)
Tracez les deux courbes de fonctions dans la même figure avec ces spécifications:
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-10, 10)
y = x ** 2 + 7
fig = plt.figure(figsize = (12, 7))
plt.plot(x, y, alpha = 0.4, label ='f(x) = X² +7',
color ='red',
linewidth = 2, marker ='D',
markersize = 5, markerfacecolor ='blue',
markeredgecolor ='blue')
plt.title('Ma première courbe d\' une fonction à l\'aide python')
plt.xlabel('x ')
plt.ylabel('f(x)')
fig.text(0.9, 0.15, 'nom de votre université',
fontsize = 12, color ='red',
ha ='right', va ='bottom',
alpha = 0.7)
plt.grid(alpha =0.9)
plt.legend()
plt.show()
Résultat d’exécution :
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-10,10)
fx = []
for i in range (len(x)):
fx.append(4*x[i]**3-3*x[i]**+2)
fig = plt.figure(figsize = (12, 7))
plt.plot(x, y, alpha = 0.4, label ='f(x) = X² +7',
color ='red',)
plt.title('Ma première courbe d'une fonction utilisant python')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.plot(fx,x, label='f (x) = 4x³ - 3x² + 2 ')
plt.legend(loc='upper right')
plt.grid()
plt.axvline()
plt.axhline()
Résultat d’exécution :
Syntaxe :
import matplotlib.pyplot as plt
import numpy as np
def f1(x):
return np.cos(x)
def f2(x):
return np.sin(x)
x = np.linspace(-np.pi,np.pi)
y1 = f1(x)
y2 = f2(x)
plt.plot(x, y1, color ='red')
plt.plot(x, y2, color = 'blue')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend(['f1(x)=Cos(x)', ' f2(x)=sin(x)'])
plt.title('deux courbes dans la même figure')
plt.show()
Résultat d’exécution :
Dans ce tutoriel, nous avons appris à tracer des courbes de fonctions à l'aide de la bibliothèque de tracé Python 2D matplotlib qui produit des chiffres de qualité de publication dans une variété de formats papier et d'environnements interactifs. Matplotlib essaie de rendre les choses faciles plus faciles et les choses difficiles possibles. Vous pouvez générer des courbes de tout type de fonctions avec seulement quelques lignes de code.
