Python : l’essentiel en CPGE 1 - Généralités •

(1)

In fo rm at iq ue C P G E T SI - É ta bl is se m en t Sa in t Jo se ph - L aS al le

Python : l’essentiel en CPGE

1 - Généralités

• Déclaration de variable : var=1 sera un entier, var=1.0 (sera un réel), var="1" (sera une chaine de caractère), var=[var1,var2,var3] (sera une liste), var=(var1,var2,var3) sera un tuple.

• Transtypage : var=int("1") (sera un entier),float(pour réel), str(pour chaine de caractères).

• Variable saisie au clavier :

var=input("texte s'affichant à l'écran et demandant de saisir une variable")

Le contenu de la variable saisie au clavier est par défaut une chaîne de caractères qu’il faudra transtyper si on veut des nombres.

• Opérateurs : + - * / % (Reste de la division euclidienne) // (Quotient de la division euclidienne) **(puissance) =(affectation)

• 1e15:Écriture scientifique de 10¹⁵.

• round(x,n):arronditxànchiffres après la virgule

• range(min,max,pas): entiers compris entremin inclus etmax exclus par pas depas

• Opérateurs logiques:not (ou !) and(ou &) or(ou|) True(ou 1) False(ou 0)

• Affichage: print("var1={0} et var2={1}".format(var1, var2))

2 - Conditions et boucles

• Tests et booléens:

➔ Test d’égalité (différence):==(!=)

➔ Inférieur (ou égal):<(ou<=)

➔ Supérieur (ou égal):>(ou>=)

➔ ET:and(ou&)

➔ OU:or(ou|)

➔ NON:not(ou∼)

• Condition si (if) :

if (condition1):

instruction1 elif (condition2):

instruction2 else:

instruction finale

• Boucle pour (for):

for i in range(1,10,1):

instruction à répéter pour i allant de 1 à 9 par pas de 1.

• Boucle tant que (while): while (condition):

instruction tant que condition est vraie

(2)

In fo rm at iq ue C P G E T SI - - É ta bl is se m en t Sa in t Jo se ph - L aS al le

3 - Chaînes

Une chaîne de caractères est non modifiable.

• s.upper():Met la chaînesen majuscule

• s.lower() :Met la chaînesen minuscule

• s.title():Met la première lettre de chaque mot desen majuscule, le reste en minuscule

• s.swapcase():Met les minuscules en majuscule et les majuscules en minuscule

• s.islower(): Indique si la chaînesest en minuscule (True/False)

• s.isupper(): Indique si la chaînesest en majuscule (True/False)

• s.isalpha(): Indique si la chaînescontient uniquement des caractères alphabétique (True/False)

• s.isdigit(): Indique si la chaînescontient uniquement des caractères numériques (True/False)

• isalnum():Indique si la chaînescontient uniquement des caractères alphanumérique (True/False)

• s.replace(old, new):Remplace dans la chaînesles élémentsoldparnew

• "el".join(L):Concatène une listeLavec l’élémentelentre chaque item

• s.split("el"):Découper la chaînesen listes en fonction du séparateurel.

4 - Listes

Une liste est modifiable.

• L = [el1 ,el2 , el3]:crée une listeL.

• list(range(10)):crée une liste de 0 à 9 par pas de 1

• list(range (2, 20, 3)):liste de 2 à 20 (exclu) par pas de 3

• Concaténation:L1 + L2

• Sélection de liste (slicing)

➔ L[1:6:3]:sélectionne du 2^èmeau 7^ème(exclu) élément par pas de 3.

➔ L[-2] sélectionne les deux derniers éléments deL.

➔ L[2:]:sélectionne les éléments du 2ème jusqu’à la fin deL.

➔ L[::-1]:sélection deLmais inversée.

➔ L[0][-1]:sélectionne du premier élément deLet en prend le dernier élément de celui ci

• L.reverse(): inverse l’ordre des items d’une liste [L].

• var=L.count(el):compte le nombre d’occurrences de l’élémentel dans une listeL

• L.append(el) :ajoute l’élémentel à la fin d’une listeL.

• L.insert(i,el):insère l’élémenteldans la listeLavant l’élément à la positioni(le reste est décalé)

• L.pop(i):extrait l’élémentel de positionidans la listeL(le reste est décalé)

• L.remove(el):enlève l’élément el de la listeL

• var = len(L):donne la longueur d’une liste L

• list(T):convertit un tupleTen liste.

5 - Tuples

Un tuple est non modifiable.

• T = (el1 ,el2 , el3):définit un tuple.

• Permuter des données:var1, var2 = var2, var1

• Affichage: print ("x=%d y=%d"%(l)) print("x={0[0]} y={0[1]}".format(l))

• tuple(L):convertit la listeLen un tuple

Page 2/17

(3)

In fo rm at iq ue C P G E T SI - É ta bl is se m en t Sa in t Jo se ph - L aS al le

6 - Dictionnaires

• D = {"clé1": valeur1, "clé2": valeur2, "clé3": valeur3}:Définit un dictionnaireD.

• print(D["cle1"] ) :Affichevaleur1

• D["cle"] = valeur:Ajoute un élément ou modifie la valeur decle

• D.keys():retourne une liste contenant les clés deD

• D.values():retourne une liste contenant les valeurs du dictionnaireD

• D.has_key(clé):retourne le booléenTruesi le dictionnaire contient la clé ou la valeurFalsesinon.

• D.get(clé, valsinon):retourne la valeur d’une clé ouvalsinonsi la clé n’existe pas.

• len(D):retourne la taille du dictionnaireD(nombre de clés)

• D.items():retourne une liste de tuples, chaque tuple contenant clé puis valeur

• del D[clé]: supprime un élément du dictionnaireD(clé et valeur)

7 - Modules ou bibliothèques

• importer un module:

➔ import ..., par exemple import math : il faudra mettremath. avant d’utiliser un fonction du module , par exemple math.sin(math.pi/2).

➔ import ... as ..., par exemple import numpy as np : np sera alors un raccourci du module numpy np.exp(10).

➔ from ... import ..., par exemple from math import sqrt, sin, pi : on importe seulement la fonctionssqrt,sinet pi du modulemath

➔ from ... import *, par exemple from math import * : on importe toutes les fonctions du module. Cette solution est peu pertinente en raison du risque de conflits avec d’autres modules

• modules courants:math,random, time,numpy,matplotlib,os,re,scipy,sympy,tkinter, . . . Avecfromil ne faut pas mettre le nom du module, seulement le nom de la fonction, par exemple exp(10)

et nonmath.exp(10) .

8 - Fonctions

• def(arguments):

def nomDeLaFonction (arg1 , arg2= 5 (valeur par défaut)... ):

""" description de la fonction, Docstring """

Actions

return resultat1, resultat2

Les variables sont locales SAUF pour les listes qui sont définitivement modifiées !

• Exemple:

def factorielle (n):

""" Fonction factorielle """

fact=1

for i in range(1,n+1):

fact*=i return fact

9 - Manipilation de fichiers

• fichier = open("monfichier.txt", "r"): pour ouvrir un fichier en lecture Les options sont : rlecture seule,w écriture,apour ajouter du texte bbinaire

• contents = fichier.read():pour la lecture du fichier.

• lines = fichier.readlines():pour lire une seule ligne.

• fichier.close():pour fermer le fichier.

• fichier.write("Ceci est un texte"):pour écrire le texte. Si le fichier n’existe pas, il sera créé.

• fichier.writeline(line):Pour écrire une ligne supplémentaire

(4)

In fo rm at iq ue C P G E T SI - - É ta bl is se m en t Sa in t Jo se ph - L aS al le

10 - Numpy

• rint(x):Nombre entier le plus proche dex.

• floor(x),ceil(x):Partie entière supérieure et inférieure dex.

• rand(n,p):Générateur aléatoire de matrice de dimensionn×psur [0; 1]. (numpy.random)

• pi:Valeur approchée deπ≈3.1415.

• exp(1):Valeur approchée dee≈2.7183.

• Vecteur

➔ array([1, 2, 3]):Représente le vecteur horizontal 1 2 3 .

➔ array([[1], [2], [3]]):Représente le vecteur vertical



 1 2 3



.

➔ x.size:Renvoie la longueur du vecteur x.

➔ arange(a,b,i):Construit le tableau a a+i a+ 2i . . . b.

• Matrice

➔ array([[1,2], [3,4]]]):Représente la matrice 1 2

3 4

.

➔ m[i,j]:Représente l’élémentaij de la matrice m

➔ m.shape:Renvoie la taille de la matrice m sous forme d’une liste.

➔ m[i,:]:Extrait la i^eligne de la matrice m.

➔ m[:,i]:Extrait la i^ecolonne de la matrice m.

➔ zeros([n,p]):Représente la matrice nulle de taille n×p.

➔ eye(n,p):Représente la matrice identité de taillen×p.

➔ ones([n,p]):Représente la matrice de coefficients 1 de taille n×p.

➔ asarray(m): Transforme une matrice en tableau.

➔ asmatrix(m):Transforme un tableau en matrice.

➔ norm(m):Norme de la matrice m. (numpy.linalg)

➔ transpose(m):Transposée de la matrice m.

➔ det(m):Déterminant de la matrice m. (numpy.linalg)

• Polynômes

➔ poly1d([1, 2, 3, 5, 8]) :Représente le polynômex⁴+ 2x³+ 3x²+ 5x+ 8.

➔ poly1d([1,2, 3, 5, 8],True):Représente le polynôme (x−1)(x−2)(x−3)(x−5)(x−8).

➔ p.order:Degrés du polynôme p.

➔ p.roots:ou«roots(p)»Racines du polynôme p.

➔ p.coeffs:Coefficients du polynôme p.

➔ p(3):ou«polyval(p,3)»Évalue le polynôme p en 3 (selon le schéma de Hörner)

11 - matplotlib.pyplot

• plot(x,y,c?):Affiche les points définis par les vecteurs et , (Option : permet de définir le format et la couleur du tracé)

• imshow(m,c?):Affiche la matrice en deux dimensions

• show():Affiche la figure courante

• savefig(name):Sauvegarde la figure courante dans le fichier name.

• clf():Efface la figure courante

• legend(array,loc?) : Dessine une légende contenant les lignes apparaissant dans array (Option : pour définir l’emplacement)

• xlabel(str) ylabel(str):Imprime une légende pour décrire les axes horizontaux et verticaux

• axis([xl,xr,yb,yt]):Cadre la figure sur le rectangle décrit par les 4 coordonnées

Page 4/17

(5)

In fo rm at iq ue C P G E T SI - É ta bl is se m en t Sa in t Jo se ph - L aS al le

Python : les documents disponibles à l’oral de Centrale

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 modulenumpyet du modulematplotlib.pyplot. De plus pour effectuer des tracés en dimension 3, il convient d’importer la fonctionAxes3ddu modulempl_toolkits.mplot3d. Les instructions nécessaires aux exemples qui suivent sont listés ci-dessous.

3 import math

4 import matplotlib.pyplot as plt

5 import numpy as np

6 from mpl_toolkits.mplot3d import Axes3D

1 - 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 fonctionaxispermet de définir la fenêtre dans laquelle est contenue le graphique.

L’optionequalpermet d’obtenir les mêmes échelles sur les deux axes. Les tracés relatifs à divers emplois de la fonctionplotse superposent. La fonctionplt.clf()efface les tracés contenus dans la fenêtre graphique.

8 x1 = [1., 2.5, 4.]

9 y1 = [3., 1., 5.]

10 plt.axis('equal')

11 plt.plot(x1, y1)

12 plt.axis([-1., 5., -1., 6.])

13 plt.grid()

14 plt.savefig("plot-cent-1.eps",dpi=200)

15 plt.show()

−2 0 2 4 6

−1 0 1 2 3 4 5 6

La fonctionplotadmet de nombreuses options de présentation. Le paramètrecolorpermet de choisir la couleur(’g’ : vert, ’r’ : rouge, ’b’ : bleu). Pour définir le style de la ligne, on utiliselinestyle (’-’ :)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).

(6)

In fo rm at iq ue CP GE TS I - - Ét ab li ss em en t Sa in t Jo se ph - La Sa ll e

17 x2 = [1., 2.5, 4.]

18 y2 = [3., 1., 5.]

19 plt.axis([-1., 5., -1., 6.])

20 plt.plot(x2, y2, color='r', linestyle=

':',marker='o')

22 plt.show()

−1 0 1 2 3 4 5

−1 0 1 2 3 4 5 6

2 - Tracés de fonction

On définit une liste d’abscisses puis on construit la liste des ordonnées correspondantes. L’exemple ci-dessous tracex→sinxsur [0,3π].

24 def f(x):

25 return math.sin(x)

26 x3 = np.arange(0, 3*np.pi, 0.01)

27 y3 = [ f(x) for x in x3 ]

28 plt.plot(x3, y3)

30 plt.show()

0 2 4 6 8 10

−1.0

−0.5 0.0 0.5 1.0

Il est généralement plus intéressant d’utiliser les fonctions du modulenumpy, 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 universelles).

32 def f(x):

33 return np.sin(x)

34 x4 = np.arange(0, 3*np.pi, 0.01)

35 y4 = f(x4)

36 plt.plot(x4, y4)

38 plt.show()

0 2 4 6 8 10

−1.0

−0.5 0.0 0.5 1.0

Une autre solution consiste à utiliser la fonctionvectorizedu modulenumpyqui 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 universelles.

Page 6/17

(7)

In fo rm at iq ue C P G E T SI - É ta bl is se m en t Sa in t Jo se ph - L aS al le

40 def f(x):

41 return math.sin(x)

42 f = np.vectorize(f)

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

44 def f(x, y):

45 return np.sqrt(x**2 + y**2)

46 print(f(3,4))

47 # 5.0

48 print(f(np.array([1,2,3]),np.array([4,5,6])))

49 # [ 4.12310563 5.38516481 6.70820393]

50 print(f(np.array([1,2,3]),4))

51 # [ 4.12310563 4.47213595 5. ]

3 - 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é.

53 def x(t):

54 return np.sin(2*t)

55 def y(t):

56 return np.sin(3*t)

57 t5 = np.arange(0,2*np.pi,0.01)

58 x5 = x(t5)

59 y5 = y(t5)

61 plt.plot(x5,y5)

63 plt.show()

−1.5 −1.0 −0.5 0.0 0.5 1.0 1.5

−1.0

−0.5 0.0 0.5 1.0

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

65 ax = Axes3D(plt.figure())

66 t6 = np.arange(0, 2*np.pi, 0.01)

67 x6 = np.cos(t6)

68 y6 = np.sin(t6)

69 z6 = t6

70 ax.plot(x6,y6,t6)

72 plt.show()

−1.0 −0.5

0.0 0.5

1.0 −1.0

−0.5 0.0

0.5 1.0

0 1 2 3 4 5 6 7

(8)

In fo rm at iq ue CP GE TS I - - Ét ab li ss em en t Sa in t Jo se ph - La Sa ll e

4 - Tracé de surfaces

Pour tracer une surface d’équationz=f(x, y), on réalise d’abord une grille en (x, y) puis on calcule les valeurs dez correspondant aux points de cette grille. On fait ensuite le tracé avec la fonction

plot_surface.

74 ax = Axes3D(plt.figure())

75 def f(x,y):

76 return x**2 - y**2

77 x7 = np.arange(-1,1,0.02)

78 y7 = np.arange(-1,1,0.02)

79 x70,y70 = np.meshgrid(x7,y7)

80 z70 = f(x70,y70)

81 ax.plot_surface(x70,y70,z70)

83 plt.show() _−1.0

−0.5 0.0

0.5 1.0 −1.0

−0.5 0.0

0.5 1.0

−1.0

−0.5 0.0 0.5 1.0

5 - Tracé de lignes de niveau

Pour tracer des courbes d’équationf(x, y), on fait une grille enxet eny sur laquelle on calcule les valeurs def. On emploie ensuite la fonctioncontouren mettant dans une liste les valeurs dekpour lesquelles on veut tracer la courbe d’équationf(x, y) =k.

85 def f(x,y):

86 return x**2 + y**2 + x*y

87 x8 = np.arange(-1,1,0.01)

88 y8 = np.arange(-1,1,0.01)

89 x80,y80 = np.meshgrid(x8,y8)

90 z80 = f(x80,y80)

92 plt.contour(x80,y80,z80,[0.1,0.4,0.5])

94 plt.show()

−1.5 −1.0 −0.5 0.0 0.5 1.0

−1.0

−0.5 0.0 0.5

Calcul matriciel

On travaille avec les modulesnumpy etnumpy.linalg.

4 import numpy.linalg as alg

6 - Création de matrices

Pour définir une matrice, on utilise la fonctionarraydu module numpy.

Page 8/17

(9)

In fo rm at iq ue C P G E T SI - É ta bl is se m en t Sa in t Jo se ph - L aS al le

6 A = np.array([[1, 2, 3], [4, 5, 6]])

7 print(A)

8 # [[1 2 3]

9 # [4 5 6]]

10

11 print(A.shape)

12 # (2, 3)

L’attributshapedonne 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éthodereshape.

14 B = A.reshape(3, 2)

15 print(B)

16 # [[1 2]

17 # [3 4]

18 # [5 6]]

L’accès à un terme de la matriceB se fait à l’aide de l’opération d’indexageB[i, j] oùidé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 :bdésigne l’intervalle ouvert à droite [a, b[ : 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.

20 print(B[1,0]) # terme de la deuxième ligne, première colonne

21 # 3

22

23 print(B[0:]) # première ligne sous forme de tableau à 1 dimension

24 # [[1 2]

25 # [3 4]

26 # [5 6]]

27

28 print(B[0,:].shape)

29 # (2,)

30

31 print(B[0 :1, :]) # première ligne sous forme de matrice ligne

32 # [[1 2]]

33

34 print(B[0 :1, :].shape)

35 # (1, 2)

36

37 print(B[ :, 1]) # deuxième colonne sous forme de tableau à 1 dimension

38 # [2 4 6]

39

40 print(B[ :, 1 :2]) # deuxième colonne sous forme de matrice colonne

41 # [[2]

42 # [4]

43 # [6]]

44

45 print(B[1 :3, 0 :2]) # sous-matrice lignes 2 et 3, colonnes 1 et 2

46 # [[3 4]

47 # [5 6]]

(10)

In fo rm at iq ue CP GE TS I - - Ét ab li ss em en t Sa in t Jo se ph - La Sa ll e

Les fonctionszeroset onespermettent de créer des matrices remplies de 0 ou de 1. La fonctioneyes permet de créer une matrice du typeIn oùnest un entier. La fonctiondiagpermet de créer une matrice diagonale.

49 print(np.zeros((2,3)))

50 # [[ 0. 0. 0.]

51 # [ 0. 0. 0.]]

52

53 print(np.ones((3,2)))

54 # [[ 1. 1.]

55 # [ 1. 1.]

56 # [ 1. 1.]]

57

58 print(np.eye(4))

59 # [[ 1. 0. 0. 0.]

60 # [ 0. 1. 0. 0.]

61 # [ 0. 0. 1. 0.]

62 # [ 0. 0. 0. 1.]]

63

64 print(np.diag([1,2,3]))

65 # [[1 0 0]

66 # [0 2 0]

67 # [0 0 3]]

Enfin la fonctionconcatenatepermet de créer des matrices par blocs.

69 C = np.ones((2,3))

70 D = np.zeros((2,3))

71 print(np.concatenate((C,D), axis=0))

72 # [[ 1. 1. 1.]

73 # [ 1. 1. 1.]

74 # [ 0. 0. 0.]

75 # [ 0. 0. 0.]]

76

77 print(np.concatenate((C,D),axis=1))

78 # [[ 1. 1. 1. 0. 0. 0.]

79 # [ 1. 1. 1. 0. 0. 0.]]

7 - Calcul matriciel

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

81 E = np.array([[1,2], [3,4]])

82 F = np.eye(2)

83 print(E+3*F)

84 # [[ 4. 2.]

85 # [ 3. 7.]]

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

Page 10/17

(11)

In fo rm at iq ue C P G E T SI - É ta bl is se m en t Sa in t Jo se ph - L aS al le

87 G = np.array([[1,2], [3,4]])

88 H = np.array([[1,1,1], [2,2,2]])

89 print(np.dot(G, H))

90 # [[ 5 5 5]

91 # [11 11 11]]

On peut également utiliser la méthodedotqui est plus pratique pour calculer un produit de plusieurs matrices.

93 print(G.dot(H))

94 # [[ 5 5 5]

95 # [11 11 11]]

96

97 print(G.dot(H).dot(np.ones((3,2))))

98 # [[ 15. 15.]

99 # [ 33. 33.]]

La fonctionmatrix_powerdu module numpy.linalg permet de calculer des puissances de matrices.

101 print(alg.matrix_power(G,3))

102 # [[ 37 54]

103 # [ 81 118]]

La transposée s’obtient avec la fonctiontranspose. L’expressionH.Trenvoie aussi la transposée deH.

105 print(np.transpose(H))

106 # [[1 2]

107 # [1 2]

108 # [1 2]]

109

110 print(H.T)

111 # [[1 2]

112 # [1 2]

113 # [1 2]]

Le déterminant, le rang et la trace d’une matrice s’obtiennent par les fonctionsdet,matrix_rankdu modulenumpy.linalg ettracedu modulenumpy. Enfin la fonctioninvdu modulenumpy.linalg renvoie l’inverse de la matrice s’il existe.

115 print(alg.det(G))

116 # -2.0

117

118 print(alg.matrix_rank(G))

119 # 2

120

121 print(np.trace(G))

122 # 5

123

124 print(alg.inv(G))

125 # [[-2. 1. ]

126 # [ 1.5 -0.5]]

(12)

In fo rm at iq ue C P G E T SI - - É ta bl is se m en t Sa in t Jo se ph - L aS al le

Pour résoudre le système linéaireG x=b lorsque la matriceGest inversible, on peut employer la fonction solvedu modulenumpy.linalg.

128 b = np.array([1,5])

129 print(alg.solve(G, b))

130 # [ 3. -1.]

La fonctioneigvalsdu module numpy.linalg renvoie les valeurs propres de la matrice. Pour obtenir en plus les vecteurs propres associés, il faut employer la fonctioneig.

132 print(alg.eigvals(G))

133 # [-0.37228132 5.37228132]

134

135 L = alg.eig(G)

136 print(L)

137 # (array([-0.37228132, 5.37228132]), array([[-0.82456484, -0.41597356],

138 # [ 0.56576746, -0.90937671]]))

139

140 print(L[1].dot(np.diag(L[0])).dot(alg.inv(L[1])))

141 # [[ 1. 2.]

142 # [ 3. 4.]]

La fonctionvdotpermet de calculer le produit scalaire de deux vecteurs deRⁿ.

144 u = np.array([1,2])

145 v = np.array([3,4])

146 print(np.vdot(u, v))

147 # 11

La fonctioncrosspermet de calculer le produit vectoriel de deux vecteurs deR³.

149 u = np.array([1,0,0])

150 v = np.array([0,1,0])

151 print(np.cross(u, v))

152 # [0 0 1]

Page 12/17

(13)

In fo rm at iq ue CP GE TS I - Ét ab li ss em en t Sa in t Jo se ph - La Sa ll e

Analyse numérique

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

4 import scipy.optimize as resol

5 import scipy.integrate as integr

6 import matplotlib.pyplot as plt

8 - Résolution approchée d’équations

Pour résoudre une équation du typef(x) = 0 oùf est une fonction d’une variable réelle, on peut utiliser la fonctionfsolvedu modulescipy.optimize. Il faut préciser la valeur initialex0 de l’algorithme employé par la fonctionfsolve. Le résultat peut dépendre de cette condition initiale.

8 def f1(x) :

9 return x**2 - 2

10

11 print(resol.fsolve(f1, -2.))

12 # [-1.41421356]

13

14 print(resol.fsolve(f1, -2.))

15 # [-1.41421356]

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

x²−y² = 1 x+ 2y−3 = 0

17 def f2(v) :

18 return v[0]**2 - v[1]**2 - 1, v[0] + 2*v[1] - 3

19

20 sol = resol.root(f2, [0,0])

21 print(sol.success)

22 # True

23 print(sol.x)

24 # [ 1.30940108, 0.84529946])

25 sol=resol.root(f2, [-5,5])

26 print(sol.success)

27 # True

28 print(sol.x)

29 # [-3.30940108 3.15470054]

9 - Calcul approché d’intégrales

La fonctionquaddu modulescipy.integratepermet 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−∞.

(14)

In fo rm at iq ue C P G E T SI - - É ta bl is se m en t Sa in t Jo se ph - L aS al le

31 def f3(x) :

32 return np.exp(-x)

33

34 print(integr.quad(f3, 0, 1))

35 # (0.6321205588285578, 7.017947987503856e-15)

36 print(integr.quad(f3, 0, np.inf))

37 # (1.0000000000000002, 5.842607038578007e-11)

10 - Résolution approchées d’équations différentielles

Pour résoudre une équation différentiellex^′=f(x, t), on peut utiliser la fonctionodeintdu module scipy.integrate. Cette fonction nécessite une liste de valeurs de t, commençant ent0, et une condition initialex0. La fonction renvoie des valeurs approchées (aux points contenus dans la liste des valeurs det) de la solutionxde l’équation différentielle qui vérifiex(t0) =x0. Pour trouver des valeurs approchées sur [0,1] de la solutionx^′(t) =t x(t) qui vérifiex(0) = 1, on peut employer le code suivant.

39 def f4(x, t) :

40 return t*x

41

42 T1 = np.arange(0, 1.01, 0.01)

43 X1 = integr.odeint(f4, 1, T1)

44 print(X1[0])

45 # [ 1.]

46 print(X1[-1])

47 # [ 1.64872143]

48 plt.plot(T1,X1)

49 plt.savefig("eq-dif1.eps",dpi = 200)

50 plt.show() 0.90.0 0.2 0.4 0.6 0.8 1.0

1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7

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

x^′(t) = −x(t)−y(t) y^′(t) = x(t)−y(t) avec la condition initialex(0) = 2,y(0) = 1, le code devient le suivant.

52 def f5(x, t) :

53 return np.array([-x[0]-x[1], x[0]- x[1]])

54

55 T2 = np.arange(0, 5.01, 0.01)

56 X2 = integr.odeint(f5, np.array([2.,1.

]), T2)

57 print(X2[0])

58 # [ 2., 1.]

59 plt.plot(X2[ :,0], X2[ :,1])

60 plt.savefig("eq-dif2.eps",dpi = 200)

61 plt.show() −0.2−0.5 0.0 0.5 1.0 1.5 2.0

0.0 0.2 0.4 0.6 0.8 1.0 1.2

Pour résoudre une équation différentielle scalaire d’ordre 2 de solutionx, on demandera la résolution du système différentiel d’ordre 1 satisfait parX(t) =

x(t) x^′(t)

Page 14/17

(15)

In fo rm at iq ue C P G E T SI - É ta bl is se m en t Sa in t Jo se ph - L aS al le

11 - Nombres complexes

Python calcule avec les nombres complexes. Le nombre imaginaire purise note 1j. Les attributs realet imagpermettent d’obtenir la partie réelle et la partie imaginaire. La fonctionabscalcule le module d’un complexe.

63 a = 2 + 3j

64 b = 5 - 3j

65 print(a*b)

66 # (19+9j)

67 print(a.real)

68 # 2.0

69 print(a.imag)

70 # 3.0

71 print(abs(a))

72 # 3.6055512754639896

Probabilités

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

3 import numpy.random as rd

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

5 print(rd.randint(1,7)) # un lancé de dé

6 # 2

7

8 print(rd.randint(1,7,20)) # 20 lancés de dé

9 # [4 6 1 2 4 6 1 2 3 1 2 3 1 1 5 5 2 3 1 3]

10

11 print(rd.randint(1, 7, (4, 5)))

12 # [[1 6 1 6 3]

13 # [6 2 6 5 6]

14 # [6 4 6 2 2]

15 # [5 2 6 6 6]]

La fonctionrandomrenvoie un réel compris dans l’intervalle [0,1[. Si X désigne la variable aléatoire correspondant au résultat de la fonctionrandom, alors pour toutaetbdans [0,1[ aveca6b, on a P(a6X6b) =b−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.

17 print(rd.random())

18 # 0.5445036252593398

19

20 print(rd.random(4))

21 # [ 0.96392737 0.04134487 0.66872481 0.47116844]

22

23 print(rd.random((2,4)))

24 # [[ 0.5184534 0.49994281 0.56372439 0.14915296]

25 # [ 0.00874978 0.42713584 0.46918414 0.01110628]]

(16)

In fo rm at iq ue CP GE TS I - - Ét ab li ss em en t Sa in t Jo se ph - La Sa ll e

La fonctionbinomialpermet de simuler une variable aléatoire suivant une loi binomiale de paramètresn etp.

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

27 print(rd.binomial(10, 0.3, 7))

28 # [2 3 3 1 3 3 2]

29

30 print(rd.binomial(10, 0.3, 7))

31 # [4 7 4 2 2 4 3]

Les fonctionsgeometricetpoissonfonctionnement de la même manière pour les lois géométrique ou de Poisson.

33 print(rd.geometric(0.5, 8))

34 # [6 1 1 1 2 3 1 1]

35

36 print(rd.poisson(4, 15))

37 # [3 4 0 8 3 5 8 7 2 1 2 1 3 2 5]

Polynômes

La classe Polynomial du modulenumpy.polynomial.polynomial permet de travailler avec des polynômes.

3 from numpy.polynomial import Polynomial

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

5 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.

7 print(p(0))

8 # -3.0

9

10 print(p([1, 2, 3]))

11 # [ 0. 9. 30.]

L’attributcoefdonne accès aux coefficients ordonnés par degré croissant ; ainsip.coef[i]correspond au cœfficient du terme de degréi. La méthodedegreerenvoie le degré du polynôme alors querootscalcule ses racines.

13 print(p.coef)

14 # [-3. 2. 0. 1.]

15

16 print(p.coef[1])

17 # 2.0

Page 16/17

(17)

In fo rm at iq ue C P G E T SI - É ta bl is se m en t Sa in t Jo se ph - L aS al le

18

19 print(p.degree())

20 # 3

21

22 print(p.roots())

23 # [-0.5-1.6583124j -0.5+1.6583124j 1.0+0.j ]

La méthodederivrenvoie 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éthodeintegintègre le polynôme, elle prend un paramètre optionnel supplémentaire donnant la

constante d’intégration à utiliser, ce paramètre peut être une liste en cas d’intégration multiple ; les constantes d’intégration non précisées sont prises égales à zéro.

25 print(p.deriv().coef)

26 # [ 2. 0. 3.]

27

28 print(p.deriv(2).coef)

29 # [ 0. 6.]

30

31 print(p.deriv(5).coef)

32 # [-0.]

33

34 print(p.integ().coef)

35 # [ 0. -3. 1. 0. 0.25]

36

37 print(p.integ(1,2).coef)

38 # [ 2. -3. 1. 0. 0.25]

39

40 print(p.integ(2, [1, 2]).coef)

41 # [ 2. 1. -1.5 0.33333333 0. 0.05 ]

Les opérateurs+,-,*permettent d’additionner, soustraire et multiplier des polynômes. Ils fonctionnent également entre un polynôme et un scalaire. L’opérateur**permet d’élever un polynôme à une puissance entière positive.

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

44 b = Polynomial([5, 3])

45 p = 2*a * b + Polynomial([-7, 2])

46 print(p.coef)

47 # [ 3. 28. 22. 6.]

48

49 print((p**2).coef)

50 # [ 9. 168. 916. 1268. 820. 264. 36.]

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.

52 print((p / 2).coef)