Informatique en PCSI et MPSI

Champollion 2014-2015

A. HASSAN

2 décembre 2014

A. Hassan@Champollion PCSI-MPSI – 1
 Programmation en
Python (suite)
Les Fonctions
Pourquoi les
fonctions?
Fonctions
intégrées( built in
functions)
Fonctions
importées

Programmation en Python (suite) Exemple

pratique:
Fonctions

Les Fonctions mathématiques

usuelles, le module
math et numpy
Quelques Fonctions
du module math
Liste des modules
importants
Définir ses propres
fonctions : def
Les fonctions à la
volée: l’opérateur
lambda
Définir ses propres
fonctions :
Exemples
Fonction versus
Procédure
Variable globales
Vs Variables locales
Fonctions
(. . . suite)
Fonctions
A. Hassan@Champollion PCSI-MPSI
récursives (à – 2
détailler en 2e
 Pourquoi les fonctions ?

Programmation en
• Éviter la redondance et la répétition Python (suite)
Les Fonctions
• Décomposer et segmenter un problème complexe en sous Pourquoi les
fonctions?
problèmes moins complexes Fonctions
intégrées( built in
• Faciliter l’analyse et améliorer la clarté du code functions)
Fonctions
• Re-utilisation du code dans d’autres programmes. importées
Exemple
• En fin cacher des informations : on n’exhibe que le titre de la pratique:
Fonctions
fonction et non son code (qui peut être considérer comme mathématiques
usuelles, le module
une propriété intellectuelle). math et numpy
Quelques Fonctions
Certaines fonctions sont disponibles au démarrage de Pyhton ( du module math
Liste des modules

built-in functions ), d’autres sont à chercher dans des modules importants

Définir ses propres

spécialisés, sinon il faut les créer. . . fonctions : def

Les fonctions à la
volée: l’opérateur
lambda
Définir ses propres
fonctions :
Exemples
Fonction versus
Procédure
Variable globales
Vs Variables locales
Fonctions
(. . . suite)
Fonctions
A. Hassan@Champollion PCSI-MPSI
récursives (à – 3
détailler en 2e
 Fonctions intégrées( built in functions)

Fonctions immédiatement disponibles au démarrage de Python. Liste non

exhaustive :
Syntaxe Emploi
abs(a) valeur absolue : |a|
round(a) et round(a,[n]) arrondi de a, ou à n décimales
bin(a), hex(a), oct(a) conversion en binaire, hexadécimale, octale
chr(a) exemple : chr(97) renvoie ’a’
ord(a) la réciproque de chr()
complexe (a,b) renvoie le complexe a + ib
len(a) longueur (chaine, tuple, liste, ensemble. . . )
divmod (a,b) quotient et reste de la division a ÷ b
min(a), max(a) max et min d’une séquence
pow(x,y,[z] xy ou xy mod z lorsque z présent
int(a),float(a), list(a)
conversion entre types
str(a), tuple(a), ens(a)


sorted(a) trier une liste : sorted([2,1,1,3,2])

Obtenir de l’aide : help(nom_fonction)

A. Hassan@Champollion PCSI-MPSI – 4
 Fonctions importées
Certains fonctions sont rangées dans des packages, modules, que l’on importe.
Exemple : Si MyModule.py contient des fonctions :f1 et f2 (parmi d’autres). On veut utiliser
f1
1. Tout importer (toutes les commandes de MyModule) :
import MyModule
# u t i l i s a t i o n de f 1 ( mais avec l e p r e f i x : MyModule)
MyModule . f1 (x ,y ) # f2 est disponible

2. Importer uniquement les fonctions qui nous intéressent, ici f1 :

from MyModule import f1
# u t i l i s a t i o n de f 1 ( mais sans l e p r e f i x : MyModule)
f1 (x , y) # f 2 n ’ e s t pas d i s p o n i b l e

3. Importer en créant un alias, ainsi on évite les conflits des noms :

import MyModule as MyMo # a l i a s MyMo
# u t i l i s a t i o n de f 1 ( mais avec l e p r e f i x MyMo)
MyMo . f1 (x ,y )

4. Tout importer et sans préfixe :

from MyModule import *
# u t i l i s a t i o n de f 1 ( mais sans l e p r e f i x MyMo)
f1 (x , y)

A. Hassan@Champollion PCSI-MPSI – 5
 Exemple pratique : Fonctions mathématiques usuelles,
le module math et numpy
On charge le module math avec la commande import.
1. Directement(avec préfixe) :
import math
x = math . pi # x←π
y = math . cos ( x) # y r e c o i t cos(π) = −1

2. Utiliser un alias(meilleure façon) :

import math as m # remplacer p r e f i x e numpy par m
x = m . pi # x←π
y = m . cos (x ) # y ← cos(π)

3. Charger des fonctions spécifiques :

from math import cos , exp , sin , pi # uniquement : π, cos , sin e t exp
x = pi # x←π
y = exp ( - x) - cos ( x) # y ← e−π − cos(π)

4. Tout charger :
from math import *
x = pi # x←π
y = exp ( - x) - cos ( x) # y ← e−π − cos(π)

5. Pour connaître le contenu d’un module, avoir de l’aide :

import math
dir ( math ) # a f f i c h e l e s f o n c t i o n s contenues dans math
help ( math . gamma ) # une f i c h e d ’ aide sur l a f o n c t i o n gamma

A. Hassan@Champollion PCSI-MPSI – 6
 Quelques Fonctions du module math

syntaxe fonctions
exp; log; log10; log2 exponentielle et logarithmes
cos; sin; tan Fonctions trigonométriques
acos; asin; atan; atan2 Fonctions trigonométriques réciproques
cosh; sinh; tanh Fonctions hyperboliques
acosh; asinh; atanh Fonctions hyperboliques réciproques
trunc; floor; ceil
sqrt;pow √ et puissance

1 import math as mm
2 mm . log10 (0.0001) # :
3 mm . log2 (32) # :
4 mm . cosh (0) # :
5 mm . log2 ( mm . pow (2 ,5))# :
6 mm . floor ( -5.6) # :
7 mm . trunc ( -5.6) # :
8 mm . ceil ( -5.6) # :

A. Hassan@Champollion PCSI-MPSI – 7
 Liste des modules importants

1. numpy pour l’analyse numérique et calcul matriciel.

2. scipy une surcouche de numpy , calcul intégral et diffrentiel, optimisation
3. matplotlib pour les graphiques.
4. random pour le calcul des probabilités.
5. time pour l’utilisation de l’horloge de l’ordinateur.
6. os pour la gestion des fichiers et utiliser les fonctions du système
d’exploitation.

A. Hassan@Champollion PCSI-MPSI – 8
 Définir ses propres fonctions : def

Syntaxe générale :

1 # l e nom que j e donne e s t MyFunction

2 def MyFunction ( v1 , v2 ,... , df1 =a , df2 =b , * g ): # l e s : marque l e debut
3 " "" Entre ces trois guillemets on ecrit a quoi sert cette fonction , surtout
4 Entrees : ses arguments v1 , v2 , ... , df1 ,.. , *g ,
5 Sorties : ce qu ’ elle renvoie
6 " ""
7 global x1 , x2 ,... # parametres globaux s ’ i l y en a
8 instruction1
9 instruction2
10 i f i >1:
11 op1
12 op2
13 ............
14 return s1 , s2 ,... # v a l e u r s renvoyees par l a f o n c t i o n s i j e veux
15 # FIN DE L ’INDENTATION du Block MyFunction
16 def MyFunction2 (): # I l y a d ’ a u t r es f o n c t i o n s dans l a v i e
17 instr .. # i n s t r u c t i o n hors l a f o n c t i o n nomFunction

Pour utiliser cette fonction, il suffit de taper :

1 MyFunction (x ,y ,z ,...) # Avec l e nombre qu ’ i l f a u t d ’ arguments
2 a = MyFunction (x ,y ,z ,...) # Stocker l e s v a l e u r s r et r o u r nees pour l e s t r a i t e r apres

A. Hassan@Champollion PCSI-MPSI – 9
 Les fonctions à la volée : l’opérateur lambda

On peut Définir des fonctions simples à la volée : Programmation en

Python (suite)
Les Fonctions

1 # pour d e f i n i r f : x 7→ 2x2 − 5 Pourquoi les

fonctions?
Fonctions
2 f =lambda x : x **2 -5 # et c ’ est f a i t intégrées( built in
p functions)
3 # pour d e f i n i r (x; y) 7→ g(x; y) = x2 + y2 Fonctions
importées
4 g =lambda x ,y : (x **2+ y **2)**(0.5) Exemple
pratique:
5 # A koi S e r je ? : Fonctions
mathématiques
6 mystery =lambda l: len ( set ( l )) usuelles, le module
et
# Alors ?
math numpy
7 mystery ([1 ,2 ,4 , -1 ,2 ,1])
Quelques Fonctions
8 mystery (" coucou c ’ est moi " ) # Re−Alors ? du module math
Liste des modules
importants
Définir ses propres
fonctions : def
Les fonctions à la
volée: l’opérateur
lambda
Définir ses propres
fonctions :
Exemples
Fonction versus
Procédure
Variable globales
Vs Variables locales
Fonctions
(. . . suite)
Fonctions
A. Hassan@Champollion PCSI-MPSI
récursives (à – 10
détailler en 2e
 Définir ses propres fonctions : Exemples

Exemple élémentaire : Écrire une fonction qui donne le reste et le quotient de

deux entiers positifs
1 def DivEtReste (x ,y ):
2 " "" Donne le quotient et reste de l ’ entier x par l ’ entier y ( non nul )
3 Entrees : x et y
4 Sorties : d le quotient et r le reste " " "
5 # On e x p l i q u e a quoi s e r t l a f o n c t i o n
6 x = int (x ); y = int ( y ); # on s ’ assure que x e t y e n t i e r s
7 i f x <0 or y <=0:
8 return " x et y doivent etre >0 " #
9 i f x < y: # cas ou x < y
10 d =0; r = x ;
11 return (d , r )
12 else : # cas ou x ≥ y
13 d =0;
14 while x >= y :
15 x=x - y
16 d= d +1
17 r =x
18 return (d , r )
19 # f i n du s c r i p t de DivEtReste

Exemple d’utilisation : >>> DivEtReste(10,3)

(3,1)
A. Hassan@Champollion PCSI-MPSI – 11
 Fonction versus Procédure

1. Procédure
1 def MySum (x , y ):
2 z =x + y
3 print(z )
4 # Utilisation :
5 MySum (5 ,6)
6 # Par contre
7 11* MySum (5 ,6)

2. Fonction (Valeur renvoyée) avec return v1,v2, ...

1 def MySum (x , y ):
2 z =x + y
3 return(z )
4 # Utilisation :
5 print( MySum (5 ,6))
6 # Maintenant :
7 11* MySum (5 ,6)

A Éviter return print("mon resultat est:",res) où res est la valeur que

calcule funct
Plutôt : s=funct(x,y,..) puis print(s)

A. Hassan@Champollion PCSI-MPSI – 12
 Variable globales Vs Variables locales

2 Variable(s) globale(s)
1. Variable(s) locale(s)
1 v =3.14159
1 def MySum (x , y ): 2 def MySum (x , y ):
2 z= x + y 3 global p ,v
3 p= x * y 4 z =x + y
4 return( z ) 5 p =x * y
5 # Utilisation : 6 v =10* z
6 >>> MySum (5 ,6) 7 return( z )
7 # 8 # Utilisation :
8 >>> 11* MySum (5 ,6) 9 >>> print( MySum (5 ,6))
9 # et l e produit : 10 # Maintenant :
# Mais i l e s t ou? >>> print(p ) # : 30


10 >>> print(p ) 11
11 # 12 >>> print(v ) # : 110
12 Traceback ( most recent call last ):


13 File " < console > " , in < module >
14 NameError : name ’p ’ i s not defined
Les variable p et v sont glo-
bales.
La variable p est locale elle Elles sont accessible et modi-
est crée à l’intérieur de la fonc- fiables par la fonction
tion et détruite de suite après son
usage.

A. Hassan@Champollion PCSI-MPSI – 13
 Fonctions (. . . suite)

1. Fonction sans arguments :

1
2
def Bonjour (): # Ne pas o u b l i e r l e s :
return " Bonjour " # Mais . . .
A
3 # f i n du b l o c de l a f o n c t i o n

2. Fonctions avec arguments dont certains ont des valeurs par défaut :
1 def Carre_Et_n_Bonjour (x , n =1): # c a l c u l e x2 e t e c r i r e Bonjour ! n f o i s
2 return( x*x , n* " Bonjour ! " ) # par d ef a u t n vaut 1
3 # f i n du b l o c Bonjour
4 # U t i l i s e r l a f o n c t i o n Carre_Et_n_Bonjour
5 a = Carre_Et_n_Bonjour (4) # : (16 , Bonjour ! )
6 b = Carre_Et_n_Bonjour (4 ,3) # : (16 , Bonjour ! Bonjour ! Bonjour ! )
7 c , bn = Carre_Et_n_Bonjour (4 ,3) # : c=16 e t bn= Bonjour ! Bonjour ! Bonjour !
8 print(a ); print( b [1])

3. Fonctions avec un nombre indéterminé d’arguments :

def CompteVoyelles (* phrase ):# l e nombre de l e t t r e s de phrase inconnu a l ’ avance
1
2 voy =[ ’a ’ , ’A ’ , ’e ’ ,’E ’ ,’i ’ ,’I ’ ,’o ’ ,’O ’ ,’u ’, ’U ’]# l e s v o y e l l e s
3 s =0 # compteur de v o y e l l e s i n i t i a l i s e a 0
4 for c in phrase : # c parcourt l e s c a r a c t e r e s de phrase
5 i f c in voy :
6 s +=1
7 return s
8 # Utilisation :
9 print( CompteVoyelles ( ’o ’ ,’h ’ ,’l ’ ,’a ’ ,’l ’ ,’a ’))# : 3
10 ph = ’ ceci est une phrase contenant 16 voyelles , on parie ? ’#
11 CompteVoyelles (* ph ) # : 17 perdu
A. Hassan@Champollion PCSI-MPSI – 14
 Fonctions récursives (à détailler en 2e année)

Une fonction est dite récursive, ssi elle contient un appel à elle même.

Elle doit vérifer les conditions sui- Exemples :

vantes : 1 # exemple 1 :
2 # la fonction f a c t o r i e l l
1. Elle contient un (ou plusieurs) 3 def fact (n ):
4 i f n ==0:
cas de base (ou de démarrage) 5 return 1
2. Elle doit toujours modifier sont 67 else :
return fact (n -1)
état pour se ramener aux cas de 8 # exemple 2 :
9 # f o n c t i o n qu i somme l e s c h i f f r e s
base 10 # d ’ un e n t i e r en base b
3. Elle fait appel à elle même 11 def sumc (n , b =10):
12 i f 0 <=n <=9:
13 return n
14 else :
15 return n% b + sumc (n // b)

A. Hassan@Champollion PCSI-MPSI – 15
 Appliquer une fonction aux éléments d’une
liste(Exemple)
EvenDigits compte le nombre de chiffres décimaux pairs d’un entier :
1 ##
2 def EvenDigits (n ,b =10):
3 " ""
4 Entree ( s ): n entier (b =10 par defaut )
5 Sortie ( s ): s le nombre de chiffres pairs " " "
6 s =0; # b=10 par d ef a u t
7 while n >0:
8 r =n % b;
9 i f r %2==0:
10 s +=1
11 n =n // b ;
12 return s
13 # U t i l i s a t i o n de EvenDigits
14 a =2**13+51; # a = 213 + 51
15 test = EvenDigits ( a)
16 print(" nombre de chiffres pairs dans a = " ,a , " est : " , test )
17 x = range (22 ,56)
18 for k in x:
19 print(" k= " ,k , " on a " , EvenDigits ( k ) ," chiffres pairs " )
20 #
21 lp =[ EvenDigits ( k ) for k in x ]
22 print( lp )
23 #
24 lp2 = list ( map ( EvenDigits , x )) # x d o i t e t r e un i t e r a b l e
25 print( lp2 ) # transformer l e r e s u l t a t en l i s t avant l ’ a f f i c h a g e
26 ##

A. Hassan@Champollion PCSI-MPSI – 16
 Exercice

Programmation en
n
Écrire une fonction puiss(x,n) qui renvoie x , où x est un Python (suite)
Les Fonctions
flottant et n est un entier relatif (i.e. n ∈ Z). Pourquoi les
fonctions?
Fonctions
1 def puiss (x , n ): intégrées( built in
2 nn = n functions)
3 s =1 Fonctions
4 i f nn <0: # cas des puissances n e g a t i v e s importées
5 nn = - nn Exemple
pratique:
6 for k in range ( nn ): Fonctions
7 s =s * x mathématiques
8 i f n <0: usuelles, le module
9 return 1/ s math et numpy
10 else : Quelques Fonctions
11 return s du module math
Liste des modules
importants
C’est une très mauvaise méthode surtout lorsque n est très Définir ses propres
fonctions : def
grand. Les fonctions à la
volée: l’opérateur

On verra comment employer un algorithme d’exponentiation lambda

Définir ses propres
rapide . . . à suivre fonctions :
Exemples
Fonction versus
Procédure
Variable globales
Vs Variables locales
Fonctions
(. . . suite)
Fonctions
A. Hassan@Champollion PCSI-MPSI
récursives (à – 17
détailler en 2e
 Exemple Fondamental : Évaluation polynômiale
k=n
P
Soit : P(x) = a0 + a1 x + a2 x + · · · + an−1 x
2 n−1 n
+ an x = ak xk , (an 6= 0).
k=0
Évaluer P en un point x. P est donnée sous forme de liste de coefficients (selon
l’ordre décroissant ou croissant de degré).
Méthode naïve :
1 def naivePolynom (A ,x , reverse =0):
Entrées : A liste des coeffs et x 2 "" "
point d’évaluation 3 Evaluation naive d ’ un polynome
4 Entrees : A liste des Coeffs
Sorties : s valeur de P(x) 5 x valeur d ’ evaluation
s←0 6 Sorties : P ( x)
7 "" "
pour k = 0 à longueur(A)-1 faire 8 A= list ( A )
s ← s + A[k].xk 9 n= len ( A ) # n − 1 = deg(P)
s =0 # Attention : pour moi 00 = 1
renvoyer s 10
11 for k in range ( n ):
Oups : Il faut penser à programmer 12 s += A [k ]* x **( k ) # s ← s + ak xk
k 13 return s
x 7→ x

A. Hassan@Champollion PCSI-MPSI – 18
 Algorithme d’Horner

On ré-ecrit

P(x) = (((an )x + an−1 )x + an−2 )x + an−3 )x + · · · + a0

Aucun calcul de puissance, que des multiplications et additions :

1 def Horner (A ,x , c =1):

Entrées : A liste des coeffs et x 2 "" "
point d’évaluation classés 3 Evaluation polynomiale selon Horner
4 Entrees : A liste des Coeffs
dans le sens croissant des 5 ( sens croissant des degres );
6 x valeur d ’ evaluation
degrés 7 Sorties : P ( x)
Sorties : s valeur de P(x) 8 "" "
9 # On met l e s c o e f f s dans l e sens voulu
s←0 10 i f c !=1:
pour k = len(A) à 0 (pas=-1) 11
12
A= A [:: -1]
s , n =0 , len ( A )
faire 13 for i in range ( n ):
14 s= s * x+ A [n -1 - i ]
s ← s.x + A[k] 15 return s
renvoyer s

A. Hassan@Champollion PCSI-MPSI – 19
 Comparaison des résultats

1 test =50000*[1] # polynome de degre 49999

2 t1 = tm . time ()
3 pn = naivePolynom ( test ,0.0)
4 tn = tm . time () - t1
5 #
6 t1 = tm . time ()
7 ph = Horner ( test ,0.0)
8 th = tm . time () - t1
9 #
10 print( ’ Comparaison des algorithmes ’)
11 print(" -------------- - -- -- -- -- -- -- " )
12 print(" Algorithme naif : " ,tn ," valeur p (x )= " , pn )
13 print(" Algo d ’ Horner : " ,th , " valeur p ( x )= " , ph )
14 ##−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
15 >>> ( executing cell " Resultats du Test " ( line 54 of " Horner . py " ))
16 Comparaison des algorithmes
17 ------------ -- -- -- -- - -- -- --
18 Algorithme naif : 250.46875 valeur p ( x )= 1.0
19 Algo d ’ Horner : 0.03125 valeur p( x )= 1.0
20 # rapport de vitesse avec une puissance tres naive
21 >>> tn / th
22 8015.0

Python ne calcule pas xk naïvement

A. Hassan@Champollion PCSI-MPSI – 20
 Utilisation de la fonction puissance de Python a**b , ou pow(a,b , (qui n’est
pas naïve).
1 ## R e s u l t a t s du Test
2 test =50000*[1] # polynome de degre 49999
3 t1 = tm . time ()
4 pn = naivePolynom ( test ,0.0)
5 tn = tm . time () - t1
6 #
7 t1 = tm . time ()
8 pnl = lessNaivePolynom ( test ,0.0)
9 tln = tm . time () - t1
10 #
11 t1 = tm . time ()
12 ph = Horner ( test ,0.0)
13 th = tm . time () - t1
14 #
15 print( ’ Comparaison des algorithmes ’)
16 print(" -------------- - -- -- -- -- -- -- " )
17 print(" Algorithme naif : " ,tn ," valeur p (x )= " , pn )
18 print(" Algorithme moins naif : " ,tln ," valeur p ( x )= " , pnl )
19 print(" Algo d ’ Horner : " ,th , " valeur p ( x )= " , ph )
20 #−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
21 Comparaison des algorithmes
22 ------------ -- -- -- -- - -- -- --
23 Algorithme naif : 0.140625 valeur p( x )= 1.0
24 Algo d ’ Horner : 0.03125 valeur p( x )= 1.0
25 >>> tn / th
26 4.5
27 >>> # Horner est 4 fois plus rapide
A. Hassan@Champollion PCSI-MPSI – 21
 Programmation en
Python (suite)
Les Fonctions
Graphique avec
Python
Tracé de courbe
Résultat
Tracé de
courbe. . . Nuage de
points
Nuage de points

Graphique avec Python Nuage de points

Tracé de plusieurs
fenêtres graphiques
Sous figures:
Résultats
Sous figures:
Exemples
Le SHOW
Tracé de nappes en
3D
Visualisation en 3D

A. Hassan@Champollion PCSI-MPSI – 22
 Tracé de courbe

Pour tracer des courbes on a besoin du package matplotlib

Exemple I : Traçons les courbes des sinus et cosinus :
1 ##
2 from numpy import * # charger l e module numpy
3 from matplotlib . pyplot import * # charger l e package m a t p l o t l i b . p y p l o t
4 from os import chdir , getcwd
5 chdir (" G :\\ Azzam \\ MyPython \\ DropAzzam \\ Python1stYear " )
6 ##
7 x = linspace ( -5 ,5 ,100) # engendrer 100 p o i n t s ent r e −5 ( i n c l u s ) e t 5
8 plot (x , cos ( x ) , ’ -r ’ ,x , sin (x ) , ’ bo ’, linewidth =4)
9 # ou bien
10 #p1=p l o t ( x , s i n ( x ) , ’ r −’) # ou marker=’s ’
11 #p2=p l o t ( x , cos ( x ) , ’ bo ’ ) # ou marker=’v ’
12 axis =[ -5 ,5 , -1.5 ,1.5] # [ xmin , xmax , ymin , ymax ]
13 title ( ’ Fonctions $x \ mapsto \ cos ( x )$ et $x \ mapsto \ sin ( x ) $ ’) # t i t r e de l a f i g u r e
14 ylabel ( ’ les ordonnees ’) # l a b e l des ordonnÃľes
15 xlabel ( ’ les x ’) # l a b e l des a b s c i s s e s
16 legend ([ " sin " ," cos " ]) # une l egend e
17 #annotate ( ’ t e x t e ’ , 1 , 1 ) # e c r i r e du t e x t e
18 grid ( True )
19 savefig ( " figure_1 . eps " ) # ou save (" f i g 1 . png ") pour autre format de l ’ image
20 show () # Montrer l e graphique

A. Hassan@Champollion PCSI-MPSI – 23
 Résultat

2.0
Fonctions x ↦ x et x
cos( ) ↦ x
sin( )

sin
1.5 cos
Max local
locmax
1.0

0.5
les ordonnees

0.0

−0.5

−1.0

−1.5

−2.0
−6 −4 −2 0 2 4 6
les x

A. Hassan@Champollion PCSI-MPSI – 24
 Tracé de courbe. . . Nuage de points

Exemple II :
1 hold ( ’ off ’)
2 ##
3 # graphique d ’ une f o n c t i o n cont non d e r i v a b l e
4 x = linspace (0 ,3.14 ,1000)
5 y1 =[]
6 y2 =[]
7 y3 =[]
8 y4 =[]
9 y5 =[]
10 for t in x:
11 y1 . append ( arccos ( cos (2* t ))/2.)
12 y2 . append ( arccos ( cos (4* t ))/4.)
13 y3 . append ( arccos ( cos (8* t ))/8.)
14 y4 . append ( arccos ( cos (16* t ))/16.)
15 y5 . append ( arccos ( cos (32* t ))/32.)
16 clf ()
17 plot (x , y1 ,x , y2 ,x ,y3 ,x , y4 )
18 show ()
19 Y = array ( y1 )+ array ( y2 )+ array ( y3 )+ array ( y4 )+ array ( y5 )
20 title ( ’ fonction continue mais derivable nulle part ’)
21 plot (x , Y )
22 savefig ( ’ figure_5 . eps ’)

A. Hassan@Champollion PCSI-MPSI – 25
 Nuage de points

fonction continue mais derivable nulle part

2.5

2.0

1.5

1.0

0.5

0.0
0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5

A. Hassan@Champollion PCSI-MPSI – 26
 Nuage de points

0.40
Figure en Nuage de points x ↦x 2
e−x
2

0.35

0.30

0.25

0.20

0.15

0.10

0.05

0.00
−6 −4 −2 0 2 4 6

A. Hassan@Champollion PCSI-MPSI – 27
 Tracé de plusieurs fenêtres graphiques

Exemple III :
1 clf ()
2 t = linspace ( -5 ,5 ,100)
3 xt = sin ( t )
4 yt = cos ( t ) # on a u r a i t pu xt , y t=s i n ( t ) , cos ( t )
5 plot (t , xt , ’r - ’ ,t ,yt , ’y - ’ , linewidth =5)
6 #axes ( ’ equ a l ’ )
7 #p l o t ( xt , y t )
8 show ()
9 ##
10 def f (x , y ): return (1 - x /2+ x **5+ y **3)* np . exp ( -x **2 - y **2)
11 #
12 n = 256
13 x = linspace ( -3 ,3 , n )
14 y = linspace ( -3 ,3 , n )
15 X ,Y = meshgrid (x ,y )
16 #
17 axes ([0.025 ,0.025 ,0.95 ,0.95])
18 subplot (211)
19 Z =f (X ,Y )
20 plot_surface (X , Y , Z )
21 show ()
22 subplot (212)
23 contourf (X , Y , f (X , Y ) , 8 , alpha =.75 , cmap = cm . hot )
24 C = contour (X , Y , f (X , Y ) , 8 , colors = ’ black ’ , linewidth =.5)

A. Hassan@Champollion PCSI-MPSI – 28
 Sous figures : Résultats

1.0
Histoire de 2 sous_figures(subplots)
0.8
Oscillation amortie
0.6
0.4
0.2
0.0
−0.2
−0.4
−0.6
−0.80 1 2 3 4 5
1.0
Normal(non amorti)

0.5

0.0

−0.5

−1.00.0 0.5 1.0 1.5 2.0

temps (s)

A. Hassan@Champollion PCSI-MPSI – 29
 Sous figures : Exemples

Tracer (t, x(t)), (t, y(t)) puis le portrait de phase (x(t), y(t)) [courbe
paramétrée].
x(t) = t.e−t cos(t) et y(t) = 2te−t .sin(t)
1 # exemple de r em p l i s s a ge
2 fill (x , y , ’r ’)
3 grid ( True )
4 show ()
5 ##
6 # courbes parametrees
7 clf ()
8 t = linspace (0 ,6.28 ,500) # engendrer 100 p o i n t s ent r e 0 ( i n c l u s ) e t 2π
9 xt = cos ( t )+.5* cos (7* t )+ sin (17* t )/3.
10 yt = sin ( t )+.5* sin (7* t )+ cos (17* t )/3.
11 plot ( xt , yt , ’ -r ’ , linewidth =4)
12 # ou bien
13 #p1=p l o t ( x , s i n ( x ) , ’ r −’) # ou marker=’s ’
14 #p2=p l o t ( x , cos ( x ) , ’ bo ’ ) # ou marker=’v ’
15 axis =[ -1.5 ,1.5 , -1.5 ,1.5] # [ xmin , xmax , ymin , ymax ]
16 title ( ’ Courbes parametrees ’)
17 # t i t r e de l a f i g u r e
18 #y l a b e l ( ’ l e s ordonnees ’ ) # l a b e l des ordonnÃľes
19 #x l a b e l ( ’ l e s x ’ ) # l a b e l des a b s c i s s e s
20 #legend ( [ " s i n " ," cos " ] ) # une l egend e
21 grid ( True )

A. Hassan@Champollion PCSI-MPSI – 30
 Le SHOW

0.3
t ↦ x(t)
0.8
t ↦ ()
y t

0.6
0.2
0.4
0.1 0.2
0.0 0.0
−0.2
−0.1
−0.4
−0.2 −0.6
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
0.8
t ↦ x(t),y(t)
7
inversion d'axes
0.6 6
0.4 5
0.2 4
0.0 3
−0.2 2
−0.4 1
−0.6 0
−0.2 −0.1 0.0 0.1 0.2 0.3 −0.6−0.4−0.2 0.0 0.2 0.4 0.6 0.8

A. Hassan@Champollion PCSI-MPSI – 31
 Tracé de nappes en 3D

Exemple : Tracé de la nappe z = sin(x2 + y2 )

1 from mpl_toolkits . mplot3d import Axes3D
2 from matplotlib import cm
3 from matplotlib . ticker import LinearLocator , FormatStrFormatter
4 import matplotlib . pyplot as plt
5 import numpy as np
6
7 fig = plt . figure () # d e f i n i r une f i g u r e
8 ax = fig . gca ( projection = ’3 d ’)
9 X = np . arange ( -5 , 5 , 0.25) # i n t e r v a l l e des x
10 Y = np . arange ( -5 , 5 , 0.25) # i n t e r v a l l e des y
11 X , Y = np . meshgrid (X , Y ) # cr eer l a g r i l l e
12 R = np . sqrt ( X **2 + Y **2)
13 Z = np . sin ( R ) # s u r f a c e Z = sin(x2 + y2 )
14 surf = ax . plot_surface (X , Y , Z , rstride =1 , cstride =1 , cmap = cm . coolwarm ,
15 linewidth =0 , antialiased = False )
16 ax . set_zlim ( -1.01 , 1.01) # f e n e t r e des z
17 plt . title (" nappe z = sin(x2 + y2 )" )
18 ax . zaxis . set_major_locator ( LinearLocator (5)) # graduation axe z
19 ax . zaxis . set_major_formatter ( FormatStrFormatter ( ’ %.02 f ’))# format des nombres
20 fig . colorbar ( surf , shrink =0.5 , aspect =5)
21 plt . savefig ( "G :\\ Azzam \\ MyPython \\ DropAzzam \\ Python1stYear \\ fig3d . eps " )
22 plt . show ()

A. Hassan@Champollion PCSI-MPSI – 32
 Visualisation en 3D

nappe z = sin(x 2
+ y
2
)

1.01

0.8
0.51
0.6
0.4
0.00 0.2
0.0
-0.51 −0.2
−0.4
-1.01 −0.6
−0.8
6
4
2
−6 0
−4
−2 −2
0
2 −4
4
6 −6

A. Hassan@Champollion PCSI-MPSI – 33