Fiches et activités

en Python
pour se remettre à niveau
et s’entraîner efficacement

Vuibert 2021
1 Bases
Le langage python est un langage orienté objet, c’est à dire que tout élément est un objet. Tous
les types d’objets sont regroupé dans des classes où sont définies les attributs de l’objet. Les entiers les
flottants, les complexes, le type booléen sont des objets avec pour chacun des caractéristiques différentes.

„ Exemple 1. Opérations, affectations : interpréteur et éditeur

Il y a deux façon d’utiliser le langage python :
• L’interpréteur : feuille où s’exécute les calculs. On peut écrire des instruction mais l’exécution est
immédiate. L’utilisation est un peu la même que celle d’une calculatrice, une fois validé, non modi-
fiable :

In [ 1 ] : 2+3∗5
>>> 2+3∗5
Out [ 1 ] : 17
17 ou
>>> . . .
In [ 2 ] : . . .

• L’éditeur : feuille de rédaction de programme composé d’instructions, de fonctions, … L’exécution se

fait dans un second temps comme dans la rédaction d’un programme dans une calculatrice.

# somme des e n t i e r s de 1 à 1999

s = 0 In [ 1 ] : 719400
f o r i i n range ( 1 2 0 0 ) :
s = s+i In [ 2 ] :
print ( s )

„ Exemple 2. Évaluation d’une durée d’exécution

Voici une fonction permettant de calculer le temps de création des diviseurs d’un entier n . On remarquera
le format d’affichage de 4 décimales (précision millième de seconde)

from time import time In [ 1 ] : t i m e _ d i v i s e u r s ( 1 2 0 0 )

Out [ 1 ] : ’ 0 . 0 0 0 0 ’
def time_diviseurs (n) :
debut=time ( ) In [ 2 ] : t i m e _ d i v i s e u r s ( 1 2 0 0 0 )
L=[ ] # l i s t e v i d e Out [ 2 ] : ’ 0 . 0 0 2 0 ’
f o r k i n range ( 1 , n+1) :
PYTHON

if n % k = = 0 :
# a j o u t de k dans L
L . append ( k )
duree = time ( ) − debutp
r e t u r n ”%.4 f ”% duree
In [ 3 ] : t i m e _ d i v i s e u r s ( 1 2 0 0 0 0 )
Out [ 3 ] : ’ 0 . 0 0 7 0 ’
In [ 4 ] : t i m e _ d i v i s e u r s (12 0 0 000 )
Out [ 4 ] : ’ 0 . 0 7 7 0 ’

2
Vuibert 2021
 Types de base

int 783 0 −192 Identificateurs

float 9.23 0.0 –1.7 e − 6 Pour les noms de variables, de fonctions, …
complex 2.7+3.1j 1j a , z A, z _max, f , fct_1
bool True False • accents possibles mais à éviter
• mots clés du langage interdits
Conversions • distinction de la casse a et A
int(–15.62) −→ –15 (troncature) Affectation
round(-15.32) −→ –16 (arrondi)
L’affectation de se fait de gauche à droite :
float(15) −→ 15.0
Affectation simple :
float(–2e– 3) −→ –0.002
• x = 1.2 + 8 : valeur ou expression
complex(2,–3) −→ 2 – 3j
• x + = 3 : incrémente x de 3.
Commentaire • x − = 2 : décrémente x de 2.

# : Après ce symbole commentaire. Affectation multiple :

Non pris en compte par python. • x , y , z = 9.2 , −7.6 , ”lettre”
| {z } | {z }
noms de conteneur de plusieurs
• Mettre de commentaires régulièrement. variables valeurs
• Décrire ce que fait un bloc d’instructions. • x , y = y , x : échange de valeur
• Pouvoir facilement reprendre un programme. • x = y = z = 0 : affectation à la même valeur
• Permettre à une personne extérieure d’amé-
liorer un programme.

Python
Bases

Mathématique de base

• Opérations : + , – , ∗ , / Affichage
∗∗ (puissance entière) 2 ∗ ∗10 = 1024
On peut afficher des valeurs littérales, des
// quotient de la division euclidienne. variables ou des expressions :
% reste de la division euclidienne.
Pour afficher du texte mettre : ”texte” ou ’texte’.
• Fonctions intrinsèques
print(”v =” , 3, ”cm” : , x , ”,” , y + 4)
abs( x ) valeur absolue ou module
round( x ,n ) arrondi du float x à n chiffres time
après la virgule
Évaluation d’une durée d’exécution d’un pro-
z .real partie entière de z
gramme en secondes.
z .imag partie imaginaire de z
from time import time
z .conjugate() conjugré de z
debut = time()
• Opération booléenne : ..
. Instructions
a and b : a et b en même temps
duree = time() – debut
a or b : a ou b ou les deux
not a : non a

3
Vuibert 2021
2 Instructions
Le décalage de 4 espaces après une instruction conditionnelle ou une boucle permet d’éviter l’ins-
truction de fin de condition ou de boucle.

„ Exemple 3. Instructions conditionnelles

Test sans alternative Test avec une alternative

In [ 1 ] : a = 10 # d r o i t e : ax + by + c = 0
In [ 2 ] : i f a > 5 : # dé t e r m i n e r l ’ é quat ion r é d u i t e
... : a = a + 1 if b = = 0 :
... : p r i n t ( ”x␣=” , − c /a )
In [ 3 ] : a else :
Out [ 3 ] : 11 m = −a/b # pente
# S i a = 3 a l o r s a r e s t e inchang é p = − c /b # ordonn é e à l ’ o r i g i n e
p r i n t ( ”y␣=” , m , ”x␣+” , p )

Test avec alternatives multiples # é q uat ion ax²+bx+c=0

Lorsqu’il y a plus d’une alternative, on utilise elif.
On met autant de elif que nécessaire et l’on termine
par un else.
# nombre de s o l u t i o n s dans R
d e l t a = b∗∗2 − 4∗a∗ c
i f delta ! = 0 :
p r i n t ( ” deux␣ s o l u t i o n s ” )
e l i f delta = = 0 :
p r i n t ( ” une␣ s o l u t i o n ␣ double ” )
else :
p r i n t ( ” pas ␣de ␣ s o l u t i o n ” )

„ Exemple 4. Boucle itérative

L = [ ]
Ce programme affiche dans la liste L, les carrés f o r i i n range ( 0 , 1 0 0 , 4 ) :
des multiples de 4 jusqu’à 99. L . append ( i ∗∗2)
p r i n t (L)

„ Exemple 5. Boucle conditionnelle

PYTHON

s , k = 0, 0
while s < 2019 :
Ce programme affiche l’entier k pour lequel la
k + = 1 # i n c r é mentation de k
somme des entier de 1 à k est inférieure à 2019. s + = k # on a j o u t e k à s
print (k)

4
Vuibert 2021
 Instruction conditionnelle
Blocs instructions Bloc d’instructions exécuté uniquement si la
condition est vraie.
Instruction parente :
i f condition :
bloc d’instruction 1 …
instructions
…
e l i f condition : #s i n é c e s s a i r e
−→ instruction parente : instruction
bloc d’instruction 2 …
−→ else : #s i n é c e s s a i r e
… instructions

instruction suivante après le bloc 1

Conditions
−→ Indexation : régler l’éditeur pour insérer 4 if a == b : si a est égal à b
espaces à la place d’une tabulation d’indentation if a ! = b : si a est différent de b
if 2 < a <= 5 : si a est dans ]2,5]

Python
Instructions

Boucle itérative

bloc d’instruction exécuté pour chaque élément Boucle conditionnelle

d’un conteneur ou d’un itérateur.
Bloc d’instruction exécuté tant que la condition
est vraie
f o r v a r i a b l e i n s é quence :
bloc instructions
while condition :
Le plus souvent la séquence sera une génération bloc instructions
d’entier : range :
par non par
défaut 0 compris défaut 1 Attention aux boucles sans fin !
range ( [début] , fin , [pas] ) Contrôle de boucle :
range(5) −−−−−→ 0 1 2 3 4 • break sortie immédiate
range(3,8) −−−−→ 3 4 5 6 7 • continue itération suivante
range(2,12,3) −−→ 2 5 8 11

5
Vuibert 2021
 Listes

3
Il existe plusieurs sortes de conteneurs (objet ayant vocation à en contenir d’autres) dont les listes ont
une part prépondérantes. On distingue les conteneurs ordonnés ou non et modifiable (après création)
ou non. Les principaux sont les :
• listes : ordonnée et modifiable : [1,2,3].
• tuples : ordonné et non modifiable : n upplet (1,2,3)
• strings : ordonné et non modifiable : ’texte’
• dictionnaires : non ordonné et modifiable : {’lundi’ : 1, ’mardi’ : 2}
• sets : non ordonné et modifiable : set([2,4,6])

„ Exemple 6. Définition, opérations et parcours d’une liste

In [ 1 ] : l s t = [ 1 , 2 ] + [ 3 , 4 ] # concat é n a t i o n
In [ 2 ] : lst
Out [ 2 ] : [1 , 2 , 3 , 4]
In [ 3 ] : 2∗ l s t
Out [ 3 ] : [1 , 2 , 3 , 4 , 1 , 2 , 3 , 4]

In [ 4 ] : L=[ i ∗∗2 f o r i i n range ( 0 , 2 2 ) i f i % 3 = = 0 ]

In [ 5 ] : L
Out [ 5 ] : [ 0 , 9 , 36 , 81 , 144 , 225 , 324 , 4 4 1 ]

In [ 6 ] : L[3] # indice i n i t i a l 0
Out [ 6 ] : 81
In [ 7 ] : L[ − 1 ] # d e r n i e r é l ément de l a l i s t e
Out [ 7 ] : 441
In [ 8 ] : L [ 1 : 4 ] # p r i n c i p e du s l i c i n g
Out [ 8 ] : [ 9 , 36 , 8 1 ]
In [ 9 ] : L[ : : − 1]
Out [ 9 ] : [ 4 4 1 , 324 , 225 , 144 , 81 , 36 , 9 , 0 ]

In [ 1 0 ] : L . remove ( 4 4 1 ) # on r e t i r e 441 de l a l i s t e
In [ 1 1 ] : L
Out [ 1 1 ] : [ 0 , 9 , 36 , 81 , 144 , 225 , 3 2 4 ]
In [ 1 2 ] : L . extend ( [ 4 4 1 , 5 7 6 ] ) # on a j o u t e deux é l é ments
In [ 1 3 ] : L
Out [ 1 3 ] : [ 0 , 9 , 36 , 81 , 144 , 225 , 324 , 441 , 5 7 6 ]

„ Exemple 7. Définition par compréhension et opérations : Ératosthène

La fonction eratosthene crée une liste de nombres
premiers inférieurs ou égaux à n . def eratosthene (n) :
• On crée une liste de 2 à n . L = [ i f o r i i n range ( 2 , n+1) ]
• On prend 2 et l’on enlève tous les multiples de 2 nbre = 2
supérieur à 2 w h i l e nbre∗∗2<=n :
idx_nbre = L . index ( nbre )
• Le suivant est 3, on prend 3 et l’on enlève tous
f o r i i n L [ idx_nbre+1 :] :
PYTHON

les multiples de 3 supérieur à 3 i f i % nbre == 0 :

• Et ainsi de suite jusqu’au nombre
p
premier immé- L . remove ( i )
diatement inférieur ou égal à n nbre = L [ idx_nbre +1]
• Il reste dans la liste L que les nombres premiers r e t u r n l e n (L) , L
inférieurs ou égaux à n .
Pour eratosthene(200), on trouve : 46 nombres premiers

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199]

6
Vuibert 2021
 Définitions

Une liste se définit entre crochet. Opérations spécifiques (méthodes)

L = [10,20,30,40,50,60,70] Modification de la liste original

Une liste vide se définit par deux crochet vide : L.append(item) ajout d’un élément à la fin
L=[] L.extend(seq) ajout d’une séquence à la fin

Une liste peut se définir par compréhension : insertion d’un élément sur
L.insert(idx,val)
une position
L = [ 10*i for i in range(1,8) ]
suppression d’un élément à
L.remove(val)
Opérations génériques partir de sa valeur
L.reverse() inversion des éléments
len(L) nombre d’éléments dans L
L.sort() tri croissant
min(L), max(L) minimum ou maximum de L
L.sort(reverse=True) tri décroissant
sum(L) somme des éléments de L
L.clear() vide la liste
L.count(a) nombre d’occurrences a
L.index(a) position du 1er élément a

Python
Listes

Parcours des listes

L[ : : 2 ] Index à partir de 0.
Accès à chaque élément par L[index]
L[ 1 :–1 ]
L[0] −→ 10 le premier
L[ : ]
L[1] −→ 20 le second
L[ 2 : 5 ] L[–1] −→ 70 le dernier
L[–2] −→ 60 l’avant dernier
L[–4 : ]

L[ : 4] Accès à une partie de la liste par :

L[début inclus : fin exclus : pas]
L[0] L[1] L[2] L[3] L[4] L[5] L[6]
L[ 2 : 5 ] −→ [30,40,50] indice 2,3,4
L 10 20 30 40 50 60 70
L[ : 4 ] −→ [10,20,30,40] les 4 premiers
L[–7] L[–6] L[–5] L[–4] L[–3] L[–2] L[–1] L[–4 : ] −→ [40,50,60,70] les 4 derniers
L[–2 : 2 :–1 ] L[ : : 2 ] −→ [10,30,50,70] de 2 en 2
L[ : ] −→ copie du conteneur
L[–3 : 0 :–1 ]
L[ : :–1 ] −→ tous de droite à gauche
L[ : :–1 ] L[–2 : :–3 ] −→ [60,30] de –3 en –3 en
partant de l’avant dernier
L[–2 : :–3 ]

7
Vuibert 2021
 Modules

4 „ Exemple 8. Module random

Une partie consiste à lancer 10 fois un dé à jouer. On gagne si l’on obtient au moins 3 six. Programmer
une simulation sur N parties puis estimer la probabilité de gagner une partie. Vérifier à l’aide de la loi
binomiale B (10 , 1/6).

On programme la fonction partie puis la fonction import random

simulation sur les N parties.
def partie () :
Noter la transformation de la variable k en float pour x = 0
éviter d’avoir un quotient entier. f o r i i n range ( 1 0 ) :
de = random . r a n d i n t ( 1 , 6 )
On obtient simulation(10000) = 0.2299 i f de = = 6 :
x = x+1
Le calcul avec la loi binomiale :
return x
p (X ¾ 3) = 1 − p (X ¶ 2) = 1 − binomFRép(10 , 1/6 , 2)
≈ 0, 2248 d e f s i m u l a t i o n (N) :
k = 0
f o r i i n range (N) :
i f p a r t i e ( ) >= 3 :
k = k+1
r e t u r n f l o a t ( k ) /N

„ Exemple 9. Autres modules : turtle (quelques instructions)

import turtle as tu
tu.fd(n), tu.bk(n) avance, recule de n
tu.rt(n), tu.lt(n) tourne à droite, à gauche de n degrés
tu.reset() efface l’écran, remet la tortue au centre
speed(n) la valeur spéciale 0 est la plus rapide.
Le flocon de Von Koch (1870 - 1934)
floc(l,n) est récursive. A chaque étape, on divise le import t u r t l e as tu
segment en 3 puis on crée 4 segments d’orientation tu . r e s e t ( )
0°, 60°, -120°, 30°. tu . speed ( 0 )
flocon(l,n) fait appel 3 fois à la fonction floc(l,n) avec
def f l o c ( l , n) :
3 rotations de 120°. Avec flocon(300,3) :
if n = = 0 :
tu . f d ( l )
else :
f l o c ( l /3 , n − 1)
tu . l t ( 6 0 )
f l o c ( l /3 , n − 1)
PYTHON

tu . r t ( 1 2 0 )
f l o c ( l /3 , n − 1)
tu . l t ( 6 0 )
f l o c ( l /3 , n − 1)

def flocon ( l , n) :
f o r i i n range ( 3 ) :
f l o c ( l , n)
tu . r t ( 1 2 0 )

8
Vuibert 2021

Importation des modules
import random
Un module est un fichier python qui regroupe
des fonctions et des définitions de constantes.
Il y a plusieurs façons d’appeler un module :
• Avec l’utilisation du nom du module :
import mod : importe le module mod.
Utilisation avec le préfixe mod : mod.fct
import mod as md : importe le module mod.
Utilisation avec le préfixe md : md.fct
• Sans l’utilisation du nom du module :
from mod import * : importe le module mod.
Utilisation sans préfixe du module : fct
from mod import f , g : importe les fonctions
f et g module mod.
module random
• random.random() : Valeur flottante dans [0,1[
• random.uniforme(a,b) : Valeur flottante sur [a,b[.
• random.randint(a,b) : Valeur entière entre a inclus
et b inclus (équiprobabilité)
• random.choice(L) : Un élément de la liste L.
• random.shuffle(L) : Mélange la liste L « en place »
(ne renvoie rien)
Autres modules
• Le module numpy : pour les vecteurs et les matrices.
• Le module matplotlib : pour les graphiques.
• Le module turtle : pour les dessins géométriques.
• Le module sympy : pour le calcul formel.

Python
Modules

Module math

import math
Fonctions mathématiques
• math.floor(-7.6) : partie entière, donne ici -8.0.
• math.ceil(-7.6) entier immédiatement supérieur, donne ici -7.
• math.exp(2) : exponentielle.
• math.log(2) : logarithme néperien.
• math.log10(2) : logarithme en base 10.
• math.log(8, 2) : log de 8 en base 2.
• math.sqrt(2) : racine carrée.
• math.pow(4, 5) : 4 puissance 5 (puissance en flottant possible).
• math.fmod(4.7, 1.5) : modulo, ici 0.2. Préférer cette fonction à % pour les flottants.
• math.factorial(4) : factorielle 4, donc 24 (uniquement pour les entiers positifs).
• math.fsum(L) : fait la somme des éléments d’une liste L, à préférer à sum (moins d’erreurs d’arrondis)
Fonctions trigonométriques
• fonctions trigonométriques : math.sin, math.cos, math.tan (l’argument est en radians)
• fonctions trigonométriques inverses : math.asin, math.acos, math.atan.
• fonctions hyperboliques : math.sinh, math.cosh, math.tanh.
• fonctions hyperboliques inverses : math.asinh, math.acosh, math.tanh.
• math.degrees(x) : convertit de radians en degrés.
• math.radians(x) convertit de degrés en radians).
• math.pi, math.e : les constantes π et e.

9
Vuibert 2021
5 Vecteurs et matrices
In [ 1 ] : import numpy as np
In [ 2 1 ] : M1 = np . a r r a y ( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
In [ 2 ] : M = np . a r r a y ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
In [ 2 2 ] : M2 = np . a r r a y ( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
In [ 3 ] : M
In [ 2 3 ] : M1 + M2
Out [ 3 ] : a r r a y ( [ [ 1 , 2 , 3 ] ,
Out [ 2 3 ] : a r r a y ( [ [ 6 , 8 ] ,
[4 , 5 , 6]])
[10 , 12]])
In [ 4 ] : M. shape
In [ 2 4 ] : M1∗M2
Out [ 4 ] : ( 2 , 3)
Out [ 2 4 ] : a r r a y ( [ [ 5 , 1 2 ] ,
[21 , 32]])
In [ 5 ] : M. s i z e
Out [ 5 ] : 6
In [ 2 5 ] : M1∗∗2
Out [ 2 5 ] : a r r a y ( [ [ 1 , 4 ] ,
In [ 6 ] : M. ndim
[ 9, 16]])
Out [ 6 ] : 2 # t a b l e a u double e n t r é e s
In [ 2 6 ] : M1 + 3
In [ 7 ] : M. t o l i s t ( )
Out [ 2 6 ] : a r r a y ( [ [ 4 , 5 ] ,
Out [ 7 ] : [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ]
[6 , 7]])
In [ 8 ] : M. sum ( )
In [ 2 7 ] : np . dot (M1,M2)
Out [ 8 ] : 21
Out [ 2 7 ] : a r r a y ( [ [ 1 9 , 2 2 ] ,
[43 , 50]])
In [ 9 ] : M. sum ( 1 )
Out [ 9 ] : a r r a y ( [ 6 , 1 5 ] )
In [ 2 8 ] : np . s q r t (M1)
Out [ 2 8 ] : a r r a y ( [ [ 1 . , 1.414] ,
In [ 1 0 ] : M. min ( )
[ 1.732 , 2. ]])
Out [ 1 0 ] : 1
In [ 2 9 ] : import numpy . l i n a l g as a l g
In [ 1 1 ] : M. max ( 0 )
Out [ 1 1 ] : a r r a y ( [ 4 , 5 , 6 ] )
In [ 3 0 ] : a l g . det (M1)
Out [ 3 0 ] : − 2.0000000000000004
In [ 1 2 ] : I = np . eye ( 2 )
In [ 3 1 ] : a l g . i nv (M1)
In [ 1 3 ] : I
Out [ 3 1 ] : a r r a y ( [ [ − 2 . , 1 . ] ,
Out [ 1 3 ] : a r r a y ( [ [ 1 . , 0.] ,
[ 1.5 , −0.5]])
[ 0. , 1.]])
In [ 3 2 ] : a l g . e i g v a l s (M1)
In [ 1 4 ] : U = np . l i n s p a c e ( 0 , 1 , 5 )
Out [ 3 2 ] : a r r a y ( [ − 0 . 3 7 2 , 5 . 3 7 2 ] )
In [ 1 5 ] : U
In [ 3 3 ] : a l g . matrix_power (M1, 4 )
Out [ 1 5 ] : a r r a y ( [ 0 . , 0 . 2 5 , 0 . 5 , 0 . 7 5 , 1 . ] )
Out [ 3 3 ] : a r r a y ( [ [ 1 9 9 , 2 9 0 ] ,
PYTHON

[435 , 634]])
In [ 1 6 ] : V = np . arange ( 0 , 1 , 0 . 2 )
In [ 3 4 ] : A = np . a r r a y ( [ [ 2 , − 3 ] , [ − 2 , 1 ] ] )
In [ 1 7 ] : V
Out [ 1 7 ] : a r r a y ( [ 0 . , 0 . 2 , 0 . 4 , 0 . 6 , 0 . 8 ] )
In [ 3 5 ] : B = np . a r r a y ( [ [ 7 ] , [ − 5 ] ] )
In [ 1 8 ] : L = V. t o l i s t ( )
In [ 3 6 ] : a l g . s o l v e (A,B)
Out [ 3 6 ] : a r r a y ( [ [ 2 . ] ,
In [ 1 9 ] : L
[ −1.]])
Out [ 2 0 ] : [ 0 . 0 , 0 . 2 , 0 . 4 , 0 . 6 , 0 . 8 ]

10
Vuibert 2021
 Opérations spécifiques (méthode)

Import numpy as np
Tableaux : création de vecteurs et matrices M.shape : dimension de M
Import numpy as np M.size : nombre de coefficients de M
np.array([1,2,3]) : vecteurs (1,2,3) M.ndim : le nombre de dimensions du
 ‹ tableau M
1 2
np.array([ [1,2],[3,4] ]) : matrice M.sum() : somme des coefficients de M
3 4
M.min(), M.max() : plus petit plus grand , coef-
np.zeros(n) : vecteur de n composantes nul- ficient de M
les M.sum(0), M.sum(1) : somme de chaque colonne,
np.zeros((n,m)) : matrice n × m de coefficients de chaque ligne
nuls
M.min(0),M.min(1) : minimum de chaque colon-
np.eye(n) : matrice identité d’ordre n
ne, de chaque ligne
np.linspace(a,b,n) : vecteur de n valeurs régulières
dans [a , b ] Conversion
np.arange(a,b,p) : vecteur de valeurs régulières
V = np.array(L) : transforme une liste L en un
dans [a , b [ avec un pas p
vecteur V
L = V.tolist() : transforme un vecteur V en
une liste L

Python
Vecteurs et matrices
module numpy

Algèbre linéaire
Extraction d’une matrice
Import numpy.linalg as alg
Import numpy as np alg.det(M) : déterminant d’une matrice
M[ i ] , M[ i , : ] : ligne de M d’indice i carrée M
M[ : , j] : colonne de M d’indice i alg.inv(M) : inverse de M
alg.eigvals(M) : valeurs propres de M
Opérations alg.matrix_rank(M) : rang de M
M1+M2, M1∗M2, : opérations ”termes à termes” alg.matrix_power(M,n): Mn (n entier)
M∗∗2 (même dimension) alg.solve(A,B) : renvoie X dans AX = B
c*M, M+c : multiplication, somme de M
Fonctions mathématiques
par le scalaire c
np.dot(V1,V2) : produit scalaire de 2 vecteurs Import numpy as np
np.dot(M1,M2) : produit de 2 matrices np.exp, np.sin, np.cos, np.sqrt etc.
np.transpose(M) : transposée de M (mêmes fonctions que dans le module math)
np.trace(M) : trace de M Fonctions qui s’appliquent non seulement aux réels et
aux complexes mais aussi aux vecteurs et aux matrices
en s’appliquant à chaque termes).

11
Vuibert 2021
6 Fonctions et graphiques
„ Exemple 10. Fonctions itératives ou récursives
Soit la suite (u n ) définie sur N par : u 0 = 2 et u n +1 = 3u n − 2.
Déterminer la valeur d’un terme u N , N étant donné.
Si l’on calcule le terme u N , en calculant u 1 , puis u 2 jusqu’à u N , le prgramme est dit ”itératif.
Une fonction qui calcule les termes de la suite de façon itérative, c’est à dire qu’elle calcule u 1 puis u 2
jusqu’à u N est dite ”itérative”.
Une fonction faisant appel à elle-même à l’ordre inférieur, c’est à dire qu’elle part du terme u N puis
descend la récurrence en direction du terme initial u 0 est dite ”récursive”.

def u(n) :
def u(n) :
u=2
i f n==0 :
f o r i i n range ( 1 , n+1) :
return 2
u=3∗u−2
r e t u r n 3∗u ( n − 1) −2
return u
Fonction récursive
Fonction itérative

Soit maintenant la suite de Fibonacci définie sur N par : v0 = 0, v1 = 1 et vn +2 = vn +1 + vn

Le nombre d’appels récursifs nécessaires pour cal-

culer v (7) est assez important : >>> d e f v ( n ) :
v(7) ... i f n==0 :
... return 0
... e l i f n==1 :
v (6) v (5) ... return 1
... r e t u r n v ( n − 1)+v ( n − 2)
...
v (5) v (4) v (4) v (3)
>>> v ( 7 )
13
v (4) v (3) >>> v ( 4 2 )
267914296
Calculer v(42) prend alors beaucoup de temps !!

Vaut-il mieux travailler de façon récursive ou itérative ?

• Approche naturelle pour résoudre certains problèmes.
PYTHON

• Souvent plus coûteux en occupation mémoire.

• Attention au dépassement de la capacité.
• Principe de dérécursification : traduction d’un algorithme récursif en algorithme itératif.

12
Vuibert 2021
 Fonction
Appel de fonction
Une fonction est la traduction d’un algorithme qui :
• prend en entrée un ou plusieurs arguments ; Récupération du résultat renvoyé par une fonction
• effectue une suite d’instructions ;
• retourne un résultat. r = nomfct (3 , i + 2)
| {z }
ici 2 arguments
d e f nomfct ( x , y , . . . ) :
bloc instructions
return r é s u l t a t Intégrales, équations différentielles

import scipy.integrate as spi

• les arguments x, y et toutes les variables du bloc
d’instruction n’existent que dans le bloc et pen- spi.quad( f , a , b )[ 0 ] : renvoie une
Z évaluation de
b
dant l’appel à la fonction (variables locales)
l’intégrale f (t ) dt
• si la fonction de calcule pas de résultat à retour- a
ner écrire : return None

Python
Fonctions et graphiques

Graphique

import matplotlib.pyplot as plt

plt.figure(figsize = (W,H)) : pour fixer la taille de la figure W x H (en pouces).
plt.plot(X,Y,options) :
trace le graphique défini par les listes X et Y ;
une première option est une chaîne de caractères qui peut contenir par exemple (”o–r”)
• une couleur : ”b” (blue, par défaut), ”r” (red), ”g” (green), ”c” (cyan), ”y” (yellow=, ”m” (magenta),
”k” (black),
• une marque : ”o” rond, ”s” carré, ”*” étoile,…)
• un type de ligne : ”-” plain (par défaut), ”–” dashed, ” :” dotted, ”-.” trait mixte, ”” pas de ligne ;
et les options courantes : label=…, linewidth=…, markersize=…,
plt.scatter((X,Y,options) : même chose que plot mais plus adapté à un nuage de points.
plt.axis(”equal”) : repère orthonormé.
plt.grid(option) : quadrillage avec les options : linestyle=”…”, color=”…” linewidth=…
plt.xlim(xmin,xmax), plt.ylim(ymin,ymax) : fixe les bornes des axes x et y
plt.xlabel(axe_x,size= s,color=(r,g,b)), plt.ylabel(axe_y,…)
plt.savefig(fichier,dpi=…) : sauve le tracé dans un fichier dans les formats jpg, png, …
plt.show() : affichage de la fenêtre.

Vuibert 2021
„ Exemple 11. Graphique : méthode Monte-Carlo de la fiche 41
Z 1
Soit la fonction f (x ) = x (1 − x ) sin2 [100x (1 − x )]. On cherche à approcher l’intégrale I = f (x ) d x .
0

On choisit 1000 points au hasard dans un rectangle de dimension 1 × 0, 25.

import m a t p l o t l i b . p y p l o t as p l t
import numpy as np
import random as rd

N=10000 # Nombre de p o i n t s a l é a t o i r e s

def f (x) :
r e t u r n x∗(1 − x ) ∗( np . s i n (100∗ x∗(1 − x ) ) ) ∗∗2

d e f monte_carlo ( ) :
n = 0
f o r i i n range (N) :
i f y2 [ i ] <= f ( x2 [ i ] ) :
n = n + 1
r e t u r n 0 . 2 5 ∗ n/N

p l t . f i g u r e ( f i g s i z e =(5 ,5) ) # T a i l l e du graphique

x1 = np . l i n s p a c e ( 0 , 1 , 1 0 0 0 )
y1 = f ( x1 ) # 1000 p o i n t s images de f dans [ 0 , 1 ]

x2 = [ rd . random ( ) f o r i i n range (N) ]

y2 = [ 0 . 2 5 ∗ rd . random ( ) f o r i i n range (N) ] # N p o i n t s a l é a t o i r e dans l e r e c t a n g l e

c o l o r =[ ’ c ’ i f y2 [ i ]< f ( x2 [ i ] ) e l s e ’ l i g h t g r a y ’ f o r i i n range (N) ] # Couleur des p t s

p l t . g r i d ( l i n e s t y l e= ’ − ’ )

p l t . xlim ( 0 , 1 )
p l t . ylim ( 0 , 0 . 2 5 )

p l t . p l o t ( x1 , y1 , ’ r ’ , l i n e w i d t h =1.5 , l a b e l= ’ f ( x ) ’ ) # Courbe de l a f o n c t i o n f
p l t . s c a t t e r ( x2 , y2 , c=c o l o r , s =5, e d g e c o l o r = ’ none ’ , l a b e l=monte_carlo ( ) )

plt . legend () # Lé gende

p l t . s a v e f i g ( ’ monte_carlo . png ’ , dpi =200) # f i c h i e r de l ’ image

p l t . show ( ) # V i s u a l i s a t i o n du graphique

14
Vuibert 2021
Activités en Python pour s’entraîner à coder et comprendre les rouages de Python

Activité 1. Instructions répétitives

https://lienmini.fr/MATHSMPSI_python-1

Activité 2. Instructions continues

https://lienmini.fr/MATHSMPSI_python-2

Activité 3. Calcul d’un volume

https://lienmini.fr/MATHSMPSI_python-3

Activité 4. Fonction cube

https://lienmini.fr/MATHSMPSI_python-4

Activité 5. Dessiner un cercle

https://lienmini.fr/MATHSMPSI_python-5

Activité 6. Dessiner une étoile

https://lienmini.fr/MATHSMPSI_python-6

Activité 7. Lancer de dés

https://lienmini.fr/MATHSMPSI_python-7

Activité 8. Mouvement d’une planète

https://lienmini.fr/PHYSIQUEPCSI_python-3

Activité 9. Etude d’un pendule

https://lienmini.fr/PHYSIQUEPCSI_python-4

Vuibert 2021