Cours Informatique Tag

CHAPITRE
ÉLÉMENTS D’ALGORITHMIQUE
3.1 Définitions
Un algorithme est une série d’instructions qui doit être exécutée par un programme in-
formatique. A partir des données d’entrée un algorithme doit donner un résultat. Le mot
"algorithme" vient du nom du mathématicien Al Khwarizmi, qui, au 9 ème siècle écrivit le
premier ouvrage systématique sur la solution des équations linéaires et quadratiques.
algorithme parallèle : les opérations s’exécutent sur plusieurs processeurs en parallèle.
algorithme distribué : les tâches s’exécutent sur un réseau de processeurs.
algorithme distribué : il contient un appel à lui-même.
Un algorithme glouton est un algorithme qui suit le principe de faire, étape par étape, un
choix optimum local, dans l’espoir d’obtenir un résultat optimum global.

Un programme informatique est la traduction d’un algorithme dans un langage de pro-
grammation
3.2 Structure d’un algorithme

Un algorithme est constitué des éléments suivants :
Un début et une fin
un nom
Des données d’entrée
Des données de sortie qui sont le résultat du calcul effectué par l’algorithme
une ensemble d’instructions exécutés par l’algorithme.
Les problèmes qui se posent dans la conception d’un algorithme sont :
S.Tagmouti Page 25 Agreg.1

Exemples d’algorithmes
La preuve : prouver que l’algorithme résout la classe de problèmes pour laquelle il a été
écrit.
L’arrêt : prouver que quelles que soient les données fournies en entrée l’algorithme s’arrête
toujours.
Le choix des structures des données : la façon d’organiser les données manipulées
influence l’écriture et la performance de l’algorithme.
Son efficacité. Il est très important d’avoir une idée du comportement d’un algorithme
lorsque la taille des données qui lui sont transmises en entrée augmente.
L’algorithmique intervient dans des domaines divers et variés :
Numériques.
Tri, recherche de mots, plus généralement recherche d’information (gé- nomes, internet, . .
. ).
Algorithmes géométriques, images de synthèse.
Reconnaissance de formes.
Compression des données.
Cryptographie.
...
3.3 Exemples d’algorithmes

Nous donnons ci-dessous quelques exemples d’algorithmes pour comprendre son squelette.
3.3.1 Division euclidienne

Cet algorithme effectue la division euclidienne de deux nombres entiers a et b en calculant le
quotient q et le reste r. Les opérations utilisées sont la soustraction, la multiplication par 2 et la
division par 2.
Entrées : Deux nombres entiers naturels a et b, avec b 6= 0.
Sorties : Le couple (q, r) où q et r désignent respectivement le quotient et le reste de la division
euclidienne de a par b.
q ←− 0
w ←− b
r ←− a
tant que w ≤ r faire
w ←− 2 × w
tant que w = b faire
q ←− 2 × q
w ←− w div 2
si w ≤ r alors
r ←− r − w
q ←− q + 1
résultat(q, r)
Ci-dessous le code python

def f(a,b):
q=0
w=b
r=a
while w<= r:
w=2*w
while w!=b:
q=2*q
w=w/2
if w<=r:
r=r-w
q=q+1
return (q,r)
3.3.2 Recherche d’une racine par dichotomie

Entrées : a réel, b réel, f fonction continue sur [a, b] telle que f (a) ≤ 0 et f (b) > 0, un nombre
réel arbitrairement petit.
Sortie : Un nombre réel qui approche une racine de f à ε près.
Invariant : (f (a) ≤ 0 et f (b) > 0
tant que b − a > ε faire

c ←− (a + b)/2
si f (c) ≤ 0 alors
a=c
sinon
b=c
résultat
Ci-dessous le code Python :

def h(f,a,b,epsilon):
g,d=a,b
while (d-g) > epsilon:
m=(g+d)/2
if f(g)*f(m)<0:
d=m
else:
g=m
return (g+d)/2

3.3.3 Résolution d’une équation différentielle linéaire de premier ordre :

méthode d’Euler
On s’intéresse à une équation différentielle d’ordre 1 de la forme :
u′ = f (u, t); u(t0 ) = u0
La méthode d’Euler consiste à déterminer approximativement les valeurs prises par u à différents
instants : t0 , t1 , . . . , tN −1 . Il s’agit de construire ui+1 à partir de ii quelque soit i ∈ [0, N − 1] tel
que :
ui+1 − ui
= f (ui , ti )
ti+1 − ti
Il en résulte que ui+1 est définit par :
ui+1 = ui + (ti+1 − ti ) × f (ui , ti )∀i ∈ [0, N − 2]
L’algorithme d’Euler se résume comme suit :
T ableau(N)
u[0] ←− u0
pour i allant de 0 à N − 2
u[i + 1] ←− u[i] + (t[i + 1] − t[i]) × f (u[i], t[i])
f in pour
Le code python s’écrit sous la forme :

>>> def Euler(f,u0,t):
... N=len(t)
... u=[0]*N
... u[0]=u0
... for i in range(N-1):
... ... u[i+1]=u[i]+(t[i+1]-t[i])*f(u[i],t[i])
return u
3.3.4 Algorithme de tri par insertion

On parcourt la liste du début jusqu’à la fin. Au moment où on considère le ième élément, les
éléments qui le précédent sont déjà triés. On comparer le ième éléments aux autres et on décale

Complexité d’un algorithme
les éléments jusqu’à insérer le ième élément à sa bonne place et ainsi de suite.
Tableau de taille n T (n)

pour i allant de 1 à n-1
f aire
x ←− T [i]
j ←− i
tant que j > 0 et T [j − 1] > x
faire
T [j] ←− T [j − 1]
j ←− j − 1
fin tant que
T [j] ←− x
fin pour
En code python cela se traduit par :

>>> def tri_insertion(T):
T=T[:]
n=len(T)
for i in range(1,n):
x=T[i]
j=i
while j>0 and T[j-1]>x:
T[j]=T[j-1]
j=j-1
T[j]=x
return T
Pour l’exécuter il faut appliquer la fonction tri-insertion à la liste puis afficher la liste.
3.4 Complexité d’un algorithme

Pour comparer la performance des algorithmes relatifs à un même problème on introduit un
critère qui porte sur la notion de complexité. Celle-ci est définie de la manière suivante :
La complexité (temporelle) d’un algorithme est le nombre d’opérations élémentaires (affectations,
comparaisons, opérations arithmétiques) effectuées par un algorithme. Ce nombre s’exprime en
fonction de la taille n des données.
On s’intéresse aussi à l’évolution de la complexité avec la taille n. Pour cela on utilise la notation
"grand O" qui permet d’indiquer le comportement asymptotique de la complexité lorsque n tend
vers l’infini. On dira que la complexité d’un algorithme est O(f (n)) si et seulement si il existe
n0 et une constante c > 0 tel que pour tout n ≥ n0 , la complexité est majorée par cf (n). Nous
distinguons les types suivants :
f (n) = 1 : complexité constante, pas d’augmentation du temps d’exécution quand le para-
mètre croit

Complexité d’un algorithme
f (n) = log(n) : complexité logarithmique, augmentation très faible du temps d’exécution

quand le paramètre croit. Exemple : algorithmes qui décomposent un problème en un
ensemble de problèmes plus petits (dichotomie).
f (n) = n : complexité linéaire, augmentation linéaire du temps d’exécution quand le para-
mètre croit (si le paramètre double, le temps double). Exemple : algorithmes qui parcourent
séquentiellement des structures linéaires.
f (n) = n log(n) : complexité quasi-linéaire, augmentation un peu supérieure à O(n).
Exemple : algorithmes qui décomposent un problème en d’autres plus simples, traités in-
dépendamment et qui combinent les solutions partielles pour calculer la solution générale.
f (n) = n2 : complexité quadratique, quand le paramètre double, le temps d’exécution est
multiplié par 4. Exemple : algorithmes avec deux boucles imbriquées.
f (n) = nm : complexité polynomiale, quand le paramètre double, le temps d’exécution est
multiplié par 2m . Exemple : algorithme utilisant i boucles imbriquées.
f (n) = n! : complexité factorielle, asymptotiquement équivalente à nn .
Un algorithme logarithmique est considérablement plus efficace qu’un algorithme linéaire (lui-
même considérablement plus efficace qu’un algorithme quadratique, ou encore exponentiel) .
Cette différence devient fondamentale si la taille des données est importante.
La complexité pour l’algorithme du tris par insertion s’obtient comme suit :
la boucle sur i tourne (n-1) fois
la boucle sur j tourne (i-1) fois. i est borné par n. Il en résulte que l’algorithme est O(n2 ).
La complexité est obtenue par :
n(n − 1)
1 + 2 +...+ n− 1 =
2

CHAPITRE
NOTIONS DE BASE CONCERNANT LE

LANGAGE DE PROGRAMMATION
PYTHON
D’où vient le mot python ?

Il vient du groupe de comiques Monthy Python (anglais) et non pas du serpent.
Pourquoi utiliser python ?
il est facile à utiliser et à apprendre,
c’est un logiciel libre, licence PSF(python software fondation) : on peut l’utiliser sans
restriction dans des projets commerciaux
il est portable : Mac OS , Linux , Unix , Windows . . .
il définit des structures de données usuelles et utiles (listes, dictionnaires, chaînes de
caractères) comme faisant partie du langage lui-même.
il convient aussi bien à des scripts d’une dizaine de lignes qu’à des projets complexes.
Les programmes Python sont en général très compacts et très lisibles
il gère ses ressources (mémoire, descripteurs de fichiers. . . ) sans intervention du pro-
grammeur, par un mécanisme de comptage de références (proche, mais différent, d’un
garbage collector). Il n’y a pas de pointeurs explicites en Python.
il est orienté-objet. Il supporte l’héritage multiple et la surcharge des opérateurs.
il intègre un système d’exceptions, qui permet d’améliorer considérablement la gestion
des erreurs.
il possède une librairie standard très fournie, proposant une grande variété de services :
chaînes de caractères et expressions régulières, services Unix standard (fichiers, pipes,
signaux, sockets, threads...), protocoles Internet (Web, News, FTP, CGI, HTML...),
persistance et bases de données, interfaces graphiques.

Identificateurs et mots clés
Il évolue rapidement. Il existent deux versions incompatibles entre elles : python 2.x
et python 3.y. Le développement actuel de Python se fait uniquement sur la branche
3.y, qui constitue une remise à plat non-rétrocompatible du langage, et la branche 2.x
ne sera à priori plus supportée au delà de 2020. C’est pour cette raison ce cours porte
sur la version 3.y.
qu’est qu’on peut faire avec python ?
calcul scientifique et l’imagerie,
Les scripts d’administration système ou d’analyse de fichiers textuels, traitements de
fichiers par lot,
Tous les développement liés à l’internet et en particulier au Web : scripts CGI, navi-
gateurs Web, moteurs de recherche, agents intelligents, objets distribués etc.
La réalisation d’interfaces graphiques utilisateurs.
Comment peut-on installer python ?
Python est déjà installé dans Linux. Pour utiliser des librairies orientées vers le calcul
scientifique, on choisit, entre autres, la distribution Anaconda.
On commence par télécharger le bit installer (64bit ou 32 bit) de Anaconda 4.1.x à
partir de la page web :
https://www.continuum.io/downloads#linux
on ouvre un terminal et on se place dans le répertoire de téléchargement ou se trouve
le fichier téléchargé par exemple
Anaconda3-4.1.1-Linux-x86_64.sh
puis et on tape la commande :
>>> bash Anaconda3-4.1.1-Linux-x86_64.sh
Comment peut-on utiliser python ?

en mode interactif : les instructions sont exécutées les unes après les autres après un
retour-chariot. On parle d’exécution en ligne de commande.
en écrivant les instructions dans un fichier, appelé fichier module, ou scripts Python
que l’on exécute après l’avoir sauvegardé. On utilise l’environnement de développement
"Spyder".
4.1 Identificateurs et mots clés

Un identificateur est une suite de caractères, de longueur quelconque, fermé d’un caractère
de début et de 0 ou plusieurs caractères de continuation. Le caractère de début peut être
n’importe quelle lettre y compris le caractère souligné _. Le caractère de continuation peut
être une lettre ou un chiffre.
les identificateurs ne doivent pas être un mot réservé de python 3.y. Ceux-ci sont regroupés
dans le tableau suivant :
and del from none True as elif global nonlocal try assert
else if not while break excep import or with class False
in pass yiel continue finally is raise def for lambda return

Types, variables et affectations
Toute tentative d’utiliser l’un de ces mots réservés comme identificateur se traduit par une
erreur de syntaxe comme le montre la figure suivante.
>>>lambda=3
File "<stdin>", line 1
lambda=3
SyntaxeError : invalid sntax
>>> def=5
def=5
SyntaxeError : invalid sntax
4.2 Types, variables et affectations

4.2.1 Types de données
4.2.1.1 Type ’int’, ’float’ et ’complex’
Le type int caractérise les nombres entiers alors, le type float est relatif aux nombres réels (à
virgule flottante) et le type complex caractérise les nombres complexes.
>>>type(2)
<class 'int'>
>>>type(2.0)
<class 'float'>
>>>type(1+2j)
<class 'float'>
Les principales opérations possibles avec les nombre entiers, réels et complexes sont les suivantes :
a+b : addition
a-b : soustraction
a ∗ b : multiplication
a/b : division
a//b : division entière valable pour les réels et les entiers
a%b : reste de la division entière
a ∗ ∗b : élévation à la puissance ab
>>> 1+2j+(5-4j)
6-2j
>>> (1+3j)**3
-26-18j
>>> 12/7
1.7142857142857142
>>> 12//7
1
>>> 12%7

4.2.1.2 Type bool

Ce type ne peut prendre que deux valeurs : True(vrai) ou False(Faux). C’est le type du résultat
de comparaison de deux valeurs comparables : ==, !=, >=, <=.
>>> 2==8
False
>>> 2>=8
False
>>> 2<=8
True
2!=2
False
2!=8
True
>>> type(2==8)
<class 'bool'>
4.2.1.3 Type str : chaîne de caractère

Le type str est relatif aux chaînes de caractères. Ces chaînes sont des suites finies de caractères
qui peuvent être placées entre apostrophes, entre triples apostrophes, entre guillemets ou entre
triple guillemets.
>>> type(bonjour tout le monde)
type(bonjour tout le monde)
SyntaxError: invalid syntax
>>> type('bonjour tout le monde')
<class 'str'>
>>> type('l'arc en ciel')
type('l'arc en ciel')
>>> type(''l'arc en ciel'')
type(''l'arc en ciel'')
>>> type('''l'arc en ciel''' )
<class 'str'>
De même pour les guillemets

>>> type("l'arc en ciel" )

<class 'str'>
>>> type("""l'arc en ciel""" )
<class 'str'>
La fonction len(), appliquée à une chaîne de caractère retourne le nombre de caractère de

la chaîne
>>> len("aujourd'hui")
11
Les éléments d’une chaîne de caractère sont indexés de 0 à len()-1. On peut accéder à
chaque caractère par l’opérateur crochet :
>>> '''aujourd'hui'''[4]
'u'
On peut adresser les éléments d’une chaîne à partir de la fin, avec des indices négatifs, le
dernier élément porte le numéro -1
>>> "aujourd'hui"[-5]
'd'
On peut sélectionner des tranches d’une chaîne de caractère(slice) :

>>> "aujourd'hui"[2:5]
'jou'
On peut découper la chaîne avec des indices négatifs :

>>> "aujourd'hui"[2:-3]
"jourd'"
On ne peut pas modifier un caractère d’une chaîne :

>>> "aujourd'hui"[2]=B
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'B' is not defined
on peut concaténer deux chaînes de caractère :

>>> "aujourd'hui"+" il fait beau"
"aujourd'hui il fait beau"
4.2.2 Variables et affectations

Une variable est un identificateur associé à une valeur. c’est une zone de la mémoire dans
laquelle une valeur est stockée. Une variable est une référence désignant une adresse mé-
moire, c’est à dire l’emplacement précis de la mémoire vive dans lequel est stockée la valeur
de la variable

Python est sensible à la casse ce qui signifie que les caractères majuscules et minuscules
sont distingués.
On affecte une variable par une valeur en utilisant le signe = (qui n’a rien à voir avec
l’égalité en math !). Dans une affectation, le membre de gauche reçoit le membre de droite
ce qui nécessite d’évaluer la valeur correspondant au membre de droite avant de l’affecter
au membre de gauche.
Les affectations relient les identificateurs aux données : si une donnée en mémoire n’est plus
reliée, le ramasse-miettes (garbage collector) de Python la supprime automatiquement (car
son nombre de références tombe à zéro)
Différentes manières d’affecter une variable :
>>> a="aujourd'hui";b="255"
>>> a
"aujourd'hui"
>>> b
'255'
>>> a,b="aujourd'hui","255"
>>> a+b
"aujourd'hui255"
>>> a-b
TypeError: unsupported operand type(s) for -: 'str' and 'str'
On peut échanger deux variables :

>>> a,b=10,"aujourd'hui"
>>> a,b
(10, "aujourd'hui")
>>> a,b=b,a
>>> a,b
("aujourd'hui", 10)
>>> a,b=b*2,a*2
>>> a,b
(20, "aujourd'huiaujourd'hui")
4.2.3 Conversion de type

Pour effectuer des opérations mathématiques sur des variables, il faut que ces dernières soient
du même type. On doit donc convertir un type en autre type adéquat pour l’opération souhaitée.
conversion réel−→ entier :
>>> a=3.15
>>> b=int(a)

Objets sous python
>>> b
3
conversion chaine de caractère −→ entier ou réel

>>> T, L='125','12.5'
>>> T+L
'12512.5'
>>> a=float(L)
>>> b=int(T)
>>> a+b
137.5
Conversion réel, entier −→ chaîne de caractère

>>> a=152
>>> b=str(a)
>>> b
'152'
>>> c=152.00
>>> d=str(c)
>>> d
'152.0'
4.3 Objets sous python

4.3.1 Les Tuples
c’est une collection ordonnée d’éléments non modifiables séparés par des virgules et délimitée
par des parenthèses. L’accès aux éléments s’effectue en utilisant des indices positives ou négatives.
>>> T1=(12,'bonjour', 12.55, 20,255,"lire et écrire", 0.00001, 1+2j)
>>> len(T1)
8
>>> T1[2]
12.55
>>> T1[-2]
1e-05
>>> T1[2:5]
(12.55, 20, 255)
>>> T1[:4]
(12, 'bonjour', 12.55, 20)
>>> T1[-4:]

Objets sous python
(255, 'lire et écrire', 1e-05, (1+2j))

>>> T1[:-4]
(12, 'bonjour', 12.55, 20)
On ne peut pas modifier un élément du Tuple :

>>> T1[2]=152
TypeError: 'tuple' object does not support item assignment
Par contre on peut concaténer deux Tuples :

>>> T2=(12,15555,177777)
>>> T1+T2
(12, 'bonjour', 12.55, 20, 255, 'lire et écrire', 1e-05, (1+2j), 12, 15555,
177777)
>>> T2*4+T1*2
(12, 15555, 177777, 12, 15555, 177777, 12, 15555, 177777, 12, 15555, 177777
, 12, 'bonjour', 12.55, 20, 255, 'lire et écrire', 1e-05, (1+2j), 12, '
bonjour', 12.55, 20, 255, 'lire et écrire', 1e-05, (1+2j))
On peut avoir un tuple de tuples :

>>> T3=(T1,T2*2)
>>> T3
((12, 'bonjour', 12.55, 20, 255, 'lire et écrire', 1e-05, (1+2j)), (12, 1
5555, 177777, 12, 15555, 177777))
>>> T3[0]
(12, 'bonjour', 12.55, 20, 255, 'lire et écrire', 1e-05, (1+2j))
>>> T3[1]
(12, 15555, 177777, 12, 15555, 177777)
>>> T3[1][2]
177777
4.3.2 Les listes

C’est une collection ordonnée d’éléments(hétérogènes) modifiables séparés par des virgules et
délimitée par des crochets. C’est un tuple de taille dynamique et modifiable. L’accès aux éléments
s’effectue en utilisant des indices positives ou négatives. Différentes manières de créer une liste :
on écrit des objets successivement séparé par des virgules et délimités par des crochets :
>>> L1=[12.5,20,"écrire",2+3j]
>>> type(L1)

Objets sous python
<class 'list'>
>>> L1[2]
'écrire'
en utilisant la commande range listant une suite arithmétique :

>>> L2=list(range(10))
>>> L2
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L3=list(range(2,9,2))
>>> L3
[2, 4, 6, 8]
En utilisant une fonction mathématique :

>>> L3=[x**2+2*x+3 for x in range(10)]
>>> L3
[3, 6, 11, 18, 27, 38, 51, 66, 83, 102]
A partir d’une chaîne de caractère qui est un cas particulier de liste :

>>> CH="python est un langage très évolué"
>>> L4=[y*2 for y in CH]
>>> L4
['pp', 'yy', 'tt', 'hh', 'oo', 'nn', ' ', 'ee', 'ss', 'tt', ' ', 'uu', 'nn'
, ' ', 'll', 'aa', 'nn', 'gg', 'aa', 'gg', 'ee', ' ', 'tt', 'rr', 'èè',
'ss', ' ', 'éé', 'vv', 'oo', 'll', 'uu', 'éé']
Les principales opérations que l’on peut effectuer sur les listes sont données ci-dessous :
Ajout d’éléments :
>>> L3
[3, 6, 11, 18, 27, 38, 51, 66, 83, 102]
>>> L3.append("écrire")
>>> L3
[3, 6, 11, 18, 27, 38, 51, 66, 83, 102, 'écrire']
Insertion à l’indice fixé :

>>> L3
[3, 6, 11, 18, 27, 38, 51, 66, 83, 102, 'écrire']
>>> L3.insert(5,"aujourd'hui")
>>> L3

Objets sous python
[3, 6, 11, 18, 27, "aujourd'hui", 38, 51, 66, 83, 102, 'écrire']
modification d’un élément :

L3
[3, 6, 11, 18, 27, "aujourd'hui", 38, 51, 66, 83, 102, 'écrire']
>>> L3[5]="aujourd'hui il fait beau"
>>> L3
[3, 6, 11, 18, 27, "aujourd'hui il fait beau", 38, 51, 66, 83, 102, 'écrire
']
suppression d’un élément :

>>> L3
[3, 6, 11, 18, 27, "aujourd'hui il fait beau", 38, 51, 66, 83, 102, 'écrire
']
>>> del L3[5]
>>> L3
[3, 6, 11, 18, 27, 38, 51, 66, 83, 102, 'écrire']
>>> del L3[len(L3)-1]
>>> L3
[3, 6, 11, 18, 27, 38, 51, 66, 83, 102]
Inversion
>>> L3
[3, 6, 11, 18, 27, 38, 51, 66, 83, 102]
>>> L3.reverse()
>>> L3
[102, 83, 66, 51, 38, 27, 18, 11, 6, 3]
>>> L3.append("écrire")
>>> L3
[102, 83, 66, 51, 38, 27, 18, 11, 6, 3, 'écrire']
>>> L3.reverse()
>>> L3
['écrire', 3, 6, 11, 18, 27, 38, 51, 66, 83, 102]
Extension :
>>> L3
['écrire', 3, 6, 11, 18, 27, 38, 51, 66, 83, 102]
>>> L3.extend([10,12,[1,2,3]])
>>> L3

Objets sous python
['écrire', 3, 6, 11, 18, 27, 38, 51, 66, 83, 102, 10, 12, [1, 2, 3]]
Trouver l’index d’un élément de la liste

>>> L3
['écrire', 3, 6, 11, 18, 27, 38, 51, 66, 83, 102, 10, 12, [1, 2, 3]]
>>> L3.index(11)
3
>>> L3.index([1,2,3])
13
copie et évacuation d’une liste :

>>> L4=L3.copy()
>>> L4
['écrire', 3, 6, 11, 18, 27, 38, 51, 66, 83, 102, 10, 12, [1, 2, 3]]
>>> L3.clear()
>>> L3
[]
>>> L4
['écrire', 3, 6, 11, 18, 27, 38, 51, 66, 83, 102, 10, 12, [1, 2, 3]]
recherche de l’index du maximum

>>> L4
[3, 6, 11, 18, 27, 38, 51, 66, 83, 102, 10, 12]
>>> max(L4)
102
>>> L4.index(max(L4))
9
4.3.3 Ensemble
C’est une collection non ordonnée (ce n’est donc pas une séquence comme les listes, les
tuples,. . . , on ne peut donc pas accéder à "l’élément d’indice i" comme pour les séquences) d’objets
deux à deux distincts (pas de doublons) "hashable". Un même objet ne peut apparaître qu’une
seule fois. Pour créer un ensemble, on utilise soit :
la commande set :
>>> Ens=set("écrire")
>>> Ens
{'r', 'i', 'c', 'é', 'e'}

Objets sous python
soit on écrit une suite d’objets (éventuellement hétérogènes) séparés par des virgules et
entre accolades :
>>> Ens2={15, "écrire", 1+2j, 155, 12}
>>> type(Ens2)
<class 'set'>
>>> A={1,1,2,3}
>>> A
{1, 2, 3}
Les opérations que l’on peut effectuer sur les ensembles se résument comme suit :
On peut itérer l’ensemble via l’instruction for :
>>> Ens2
{'écrire', 155, 12, 15, (1+2j)}
>>> for x in Ens2:
... print(x)
...
écrire
155
12
15
(1+2j)
réunion :
>>> A={1,2,3,4,5,6,7,8,9,"aa", "éé"}
>>> B={5,6,7,10,"hh", "écrire"}
>>> A|B
{'hh', 'aa', 2, 3, 4, 5, 6, 7, 8, 9, 1, 10, 'écrire', 'éé'}
Intersection :
>>> A={1,2,3,4,5,6,7,8,9,"aa", "éé"}
>>> B={5,6,7,"hh", "écrire"}
>>> A&B
{5, 6, 7}
Différence :
>>> A={1,2,3,4,5,6,7,8,9,"aa", "éé"}
>>> B={5,6,7,"hh", "écrire"}
>>> A-B
{'aa', 2, 3, 4, 1, 8, 9, 'éé'}
>>> B-A
{'hh', 'écrire', 10}

Objets sous python
Différence symétrique (A − B) ∪ (B − A) :
>>> A={1,2,3,4,5,6,7,8,9,"aa", "éé"}
>>> B={5,6,7,"hh", "écrire"}
>>> C=(A-B)|(B-A)
>>> C
{'hh', 'aa', 2, 3, 4, 1, 8, 9, 10, 'écrire', 'éé'}
Ajout d’un élément :

>>> A
{'aa', 2, 3, 4, 5, 6, 7, 8, 9, 1, 'éé'}
>>> A.add(19)
>>> A
{'aa', 2, 3, 4, 5, 6, 7, 8, 9, 1, 19, 'éé'}
suppression d’un élément :

>>> A
{'aa', 2, 3, 4, 5, 6, 7, 8, 9, 1, 19, 'éé'}
>>> A.remove('éé')
>>> A
{'aa', 2, 3, 4, 5, 6, 7, 8, 9, 1, 19}
Copie :
>>> A
{'aa', 2, 3, 4, 5, 6, 7, 8, 9, 1, 19}
>>> C=A.copy()
>>> C
{'aa', 2, 3, 4, 5, 6, 7, 8, 9, 1, 19}
>>> A.remove(19)
>>> A
{'aa', 2, 3, 4, 5, 6, 7, 8, 9, 1}
>>> C
{'aa', 2, 3, 4, 5, 6, 7, 8, 9, 1, 19}
4.3.4 Dictionnaire
C’est une collection de couples (clé : valeur), non ordonnée entourée d’accolades. Les dic-
tionnaires sont modifiables mais non-ordonnés(non indicés). Une clé pourra être alphabétique,
numérique . . . en fait tout type hachable (donc liste et dictionnaire exclus). Les valeurs pourront
être de tout type sans exclusion.On accède à une valeur par sa clé. Différentes manières de créer
un dictionnaire :
En utilisant une formule mathématique :
>>> D1={x:x*2 for x in range(10)}
>>> D1

Objets sous python
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}

>>> D1={str(x):x*2 for x in range(10)}
>>> D1
{'8': 16, '3': 6, '5': 10, '2': 4, '7': 14, '0': 0, '6': 12, '9': 18, '4': 8,
'1': 2}
>>> type(D1)
<class 'dict'>
>>> D1.keys()
dict_keys(['8', '3', '5', '2', '7', '0', '6', '9', '4', '1'])
>>> D1.values()
dict_values([16, 6, 10, 4, 14, 0, 12, 18, 8, 2])
>>> D1.get('7')
14
En ajoutant des paires clé :valeur à un dictionnaire existant :

>>> D1
{'8': 16, '3': 6, '5': 70, '2': 4, '7': 14, '0': 0, '6': 12, '9': 18, '4': 8,
'1': 2}
>>> D1['20']=1000
>>> D1
{'8': 16, '3': 6, '5': 70, '2': 4, '20': 1000, '7': 14, '0': 0, '6': 12, '9':
18, '4': 8, '1': 2}
En délimitant par deux accolades une séquence de paires clé : valeur :

>>> D2={'Hassan':16,'Fatima':14,'Ilyass':13, 'Younes':17,'Chouaib': 11,'abc':
22}
>>> D2
{'Fatima': 14, 'Ilyass': 13, 'Hassan': 16, 'Younes': 17, 'Chouaib': 11, 'abc'
: 22}
Ci-dessous quelques opérations que l’on peut effectuer sur les dictionnaires :
Effacer une paire clé : valeur
>>> D2
{'Fatima': 14, 'Ilyass': 13, 'Hassan': 16, 'Younes': 17, 'Chouaib': 11, '
abc': 22}
>>> del D2['abc']
>>> D2
{'Fatima': 14, 'Ilyass': 13, 'Hassan': 16, 'Younes': 17, 'Chouaib': 11}
copie d’un dictionnaire :

>>> D2

Objets sous python
{'Fatima': 14, 'Ilyass': 13, 'Hassan': 16, 'Younes': 17, 'Chouaib': 11}
>>> D3=D2.copy()
>>> D3
{'Younes': 17, 'Fatima': 14, 'Ilyass': 13, 'Hassan': 16, 'Chouaib': 11}
fusion de deux dictionnaires :

>>> D3
{'Younes': 17, 'Fatima': 14, 'Ilyass': 13, 'Hassan': 16, 'Chouaib': 11}
>>> D1
{'8': 16, '3': 6, '5': 70, '2': 4, '20': 1000, '7': 14, '0': 0, '6': 12, '9
': 18, '4': 8, '1': 2}
>>> D3.update(D1)
>>> D3
{'7': 14, '20': 1000, '9': 18, 'Fatima': 14, '6': 12, '5': 70, '3': 6, '
Ilyass': 13, 'Hassan': 16, 'Chouaib': 11, '8': 16, '4': 8, '0': 0, 'Younes
': 17, '2': 4, '1': 2}
4.3.5 Conversion de type

ensemble ⇄ liste
>>> E1={12,"corigé",0.001,1+2j}
>>> L1=list(E1)
>>> L1
['corigé', 12, 0.001, (1+2j)]
>>> E2=set(L1)
>>> E2
{0.001, 12, 'corigé', (1+2j)}
>>> E2==E1
True
liste ⇄ chaîne de caractère :

>>> C1="il faisait beau ces derniers jours"
>>> L2=list(C1)
>>> L2
['i', 'l', ' ', 'f', 'a', 'i', 's', 'a', 'i', 't', ' ', 'b', 'e', 'a', 'u', '
', 'c', 'e', 's', ' ', 'd', 'e', 'r', 'n', 'i', 'e', 'r', 's', ' ', 'j',
'o', 'u', 'r', 's']
>>> C2=str(L2)
>>> C2
"['i', 'l', ' ', 'f', 'a', 'i', 's', 'a', 'i', 't', ' ', 'b', 'e', 'a', 'u',
' ', 'c', 'e', 's', ' ', 'd', 'e', 'r', 'n', 'i', 'e', 'r', 's', ' ', 'j',
'o', 'u', 'r', 's']"

Syntaxe python
>>> type(L2)
<class 'list'>
>>> type(C2)
<class 'str'>
4.4 Syntaxe python

Quand on analyse un programme python, on repère des instructions composées constituées :
d’une ligne d’entête terminée par deux points ,
d’un bloc d’instructions indenté par rapport à la ligne d’entête (4 espaces par indentation).
Toutes les instructions au même niveau d’indentation appartiennent au même bloc. Nous
nous intéressons ci-dessous aux instructions de tests et de boucles.
4.4.1 L’instruction de choix : if-elif-else

La structure générale est de la forme :
if condition1:
instructions
elif condition2:
instructions
else:
instructions
C’est l’indentation (le décalage par rapport à la marge gauche) qui délimite le bloc d’ins-
tructions.
elif n’est déclenchée que si la condition qui la précède n’est pas vérifiée. Elle est située au
même niveau que if et else.
else est facultative et concerne tous les autres cas.
On peut envisager de faire intervenir plusieurs clauses elif :
if condition1:
instructions
elif condition2:
instructions
elif condition3:
instructions
else:
instructions
Nous prenons comme exemple les appréciations que l’on formule dans un conseil de classe
note=float(input("entrer votre note"))

if note>=16 and note<=20:
print("c’est excellent")

Syntaxe python
elif note<=16 and note>=14:

print("c’est bien")
print("assez bien")
print("passable")
else:
print("encore des efforts tu peux mieux faire")
4.4.2 L’instruction de boucle

4.4.2.1 La boucle tant que . . . faire : while
La boucle Tant que effectue une action tant qu’une condition donnée est vraie. Avant chaque
répétition, on évalue la valeur de la condition. Si elle est vraie, alors on effectue l’action définie
dans la boucle. Sinon, on sort de la boucle. En quelque sortes, il s’agit de répéter une portion
de code tant qu’une expression booléenne est vraie. La forme générale d’une boucle while est la
suivante :
while condition:
instructions
else:
instructions
Nous donnons comme exemple la somme des entiers paires inférieurs à une certaine valeur n.
n=float(input("entrer le nombre n"))
compteur=1
somme=0
while compteur<=n:
if compteur%2==0:
somme=somme+compteur
compteur=compteur+1
print(somme)
4.4.2.2 La boucle pour : for

La boucle Pour effectue une action en commençant par l’initialisation d’un compteur. À la fin
de chaque répétition, on effectue une action sur ce compteur (par exemple, on l’augmente d’une
certaine valeur). La boucle se termine lorsque la condition de bouclage n’est plus vraie. La forme
générale d’une boucle for est comme suit :
for compteur in séquence:
bloc d'instructions
Dans des situations particulières On reprend l’exemple du calcul de la somme des nombres pairs
à l’aide de la boucle for :

Syntaxe python
n=int(input("entrer le nombre n"))

somme=0
for compteur in range(1,n+1):
if compteur%2==0:
somme=somme+compteur
print(somme)
4.4.2.3 Commandes break, continu, pass

Ces instructions sont utilisées comme suit :
break : permet la sortie de boucle toutes affaires cessantes, sans passer dans le else.
continue : renvoie l’exécution en début de boucle, à l’itération suivante.
pass : est l’instruction vide.
else de boucle : est exécuté si et seulement si la boucle se termine sans passer par le
break.
4.4.2.4 Gestion des exceptions

Lorsqu’une erreur se produit sans être interceptée par le mécanisme des exceptions, le pro-
gramme s’arrête et l’erreur est affichée. Gérer une exception permet d’intercepter une erreur pour
éviter un arrêt du programme. Python possède beaucoup d’exceptions prédéfinies. Quelques unes
sont données dans le tableau suivant :
IndexError se produit si on cherche à accéder à un élément d’une liste, en dehors des

limites de celle-ci
NameError se produit quand on évoque une variable (locale ou globale) dont le nom
n’existe pas
SyntaxError se produit quand Python échoue à lire une expression dont la syntaxe est
erronée
TypeError se produit quand une opération est appliquée à un objet qui n’est pas du
type adéquat
ZeroDivisionError se produit quand un calcul arithmétique conduit à une division par 0
Nous illustrons la gestion de la division par 0 sur l’exemple suivant :
>>> for x in range(-4,10):
... a=1/x
... print(a)
...
-0.25
-0.3333333333333333
-0.5
-1.0
ZeroDivisionError: division by zero
La gestion de cette exception s’effectue de la manière suivante :

Fonctions sous python
>>> for x in range(-4,10):

... try:
... a=1/x
... print(a)
... except ZeroDivisionError:
... print("impossible")
...
-0.25
-0.3333333333333333
-0.5
-1.0
impossible
1.0
0.5
0.3333333333333333
0.25
0.2
0.16666666666666666
0.14285714285714285
0.125
0.1111111111111111
4.5 Fonctions sous python

Une fonction est un groupe d’instructions regroupées sous un nom et exécutées à la demande
(lors de l’appel de la fonction). On peut créer une fonction de deux manières : en utilisant la
commande def
def nom_de_la_fonction(arg1,arg2,..,argn):
instructions
return resultat
ou bien en utilisant la fonction lambda :

lambda param1,param2, ... : une_instruction_unique
Exemple : fonction qui calcule le cube d’un nombre

>>> def cube(x):
... return x**3
...
>>> cube(5)
125
>>> f=lambda x:x**3
>>> f(5)
125

Modules
>>> cube(1+2j)
(-11-2j)
>>> f(1+2j)
(-11-2j)
g=lambda x,y:x**2+y**2
Pour rendre la fonction utilisable pour n’importe quel utilisateur, il faut ajouter un commentaire
précisant la nature de cette fonction. Python propose une fonction help qui retourne pour chaque
fonction un commentaire ou mode d’emploi qui indique comment se servir de cette fonction.
>>> def volume_sphere(R):
... """fonction qui calcule le volume d'une sphère de rayon R"""
... 4/3*3.14*R**3
...
>>> help(volume_sphere)
Help on function volume_sphere in module __main__:
volume_sphere(R)
fonction qui calcule le volume d'une sphère de rayon R
4.6 Modules
Un module est un fichier.py sous forme de regroupement de procédures et de fonctions, dont le
but est de les mettre à disposition de plusieurs programmes appelant ces procédures et fonctions.
Exemple le module math. Quand on cherche le help en ligne de commande on obtient ce qui
suit :
Help on module math:
NAME
math
MODULE REFERENCE
http://docs.python.org/3.5/library/math
The following documentation is automatically generated from the Python

source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This module is always available. It provides access to the
mathematical functions defined by the C standard.

Modules
FUNCTIONS
acos(...)
acos(x)
Return the arc cosine (measured in radians) of x.

acosh(...)
acosh(x)
Return the inverse hyperbolic cosine of x.
asin(...)
asin(x)
Return the arc sine (measured in radians) of x.
asinh(...)
asinh(x)
Return the inverse hyperbolic sine of x.
atan(...)
atan(x)
Return the arc tangent (measured in radians) of x.
atan2(...)
atan2(y, x)
Return the arc tangent (measured in radians) of y/x.
Unlike atan(y/x), the signs of both x and y are considered.
atanh(...)
atanh(x)
Return the inverse hyperbolic tangent of x.
ceil(...)
ceil(x)
Return the ceiling of x as an int.

This is the smallest integral value >= x.
copysign(...)

Modules
copysign(x, y)
Return a float with the magnitude (absolute value) of x but the sign
of y. On platforms that support signed zeros, copysign(1.0, -0.0)
returns -1.0.
cos(...)
.....
Pour importer un module différentes façons de procéder :

On import uniquement une fonction bien définie :
>>> from math import sqrt
>>> sqrt(10)
3.1622776601683795
>>> sqrt(pi)
NameError: name 'pi' is not defined
On importe toutes les fonctions :

>>> from math import *
>>> sqrt(10)
3.1622776601683795
>>> sqrt(pi)
1.7724538509055159
on importe le module sans spécifier une fonction

>>> import math
>>> sqrt(10)
NameError: name 'sqrt' is not defined
>>> math.sqrt(10)
3.1622776601683795
>>> import math as mt
>>> mt.sqrt(10)
3.1622776601683795
>>> sqrt(10)
NameError: name 'sqrt' is not defined

Création, lecture et écriture de fichiers
Les principaux modules qui nous intéressent sont :

— numpy qui permet de faire du calcul numérique,
— scipy qui permet de faire du calcul scientifique. C’est une extension de numpy
— matplotlib qui permet de faire des graphiques en tout genre.
— pylab permet d’utiliser de manière aisée les bibliothèques NumPy et matplotlib
— sympy qui permet de faire du calcul formel,
— os contient de nombreuses facilités pour interagir avec les commandes du système d’exploi-
tation.
— Pour importer le module : import os
— pour connaître le répertoire courant : os.getcd()
— afficher le détail du répertoire courant : os.listdir()
— pour changer de répertoire : os.chdir(’/home/flane/dossier1/dossierrecherche’)
4.7 Création, lecture et écriture de fichiers

Lorsqu’un programme termine son exécution, toutes les informations stockées dans des va-
riables sont perdues. Un moyen de les conserver est de les enregistrer dans un fichier sur disque
dur. A l’intérieur de celui-ci, ces informations peuvent apparaître sous un format texte qui est
lisible par n’importe quel éditeur de texte, dans un format compressé, ou sous un autre format
connu par le concepteur du programme. On appelle ce dernier type un format binaire, il est
adéquat lorsque les données à conserver sont très nombreuses ou lorsqu’on désire que celles-ci ne
puissent pas être lues par une autre application que le programme lui-même. En d’autres termes,
le format binaire est illisible excepté pour celui qui l’a conçu.
4.7.1 Écriture
L’écriture s’effectue selon les étapes suivantes :
création ou ouverture du fichier
écriture
fermeture.
>>> f=open('fichier1','w')
>>> f.write("blabla blabla de la première ligne \n")
36
>>> f.write("blabla de la deuxième ligne \n")
29
>>> f.write("blabla de la troisièe ligne")
27
>>> f.close()
4.7.2 Écriture en mode ajout

>>> f=open('fichier1','a')
f.write("blabla de la quatrième ligne")
f.close()

Création, lecture et écriture de fichiers
4.7.3 Lecture
>>> f = open ("fichier1", "r")

>>> l = f.readlines()
>>> print(l)
['blabla blabla de la première ligne \n', 'blabla de la deuxième ligne \n', 'blabla
de la troisièe ligne', 'blabla de la quatrième ligne']
>>> for s in l:
... print(s)
...
blabla blabla de la première ligne
blabla de la deuxième ligne
blabla de la troisièe ligne
blabla de la quatrième ligne
4.7.4 Lecture d’un fichier CSV(Comma-separated values)

#ouverture en lecture
f = open("fichier.csv","r")
#importation du module csv
import csv
#lecture – utilisation du parseur csv
lecteur = csv.reader(f,delimiter=";")
#affichage – itération sur chaque ligne
for ligne in lecteur:
print(ligne)
#fermeture du fichier
f.close()

CHAPITRE
PYTHON SCIENTIFIQUE
Le calcul scientifique fait intervenir les modules numpy, scipy et matplotlib. Nous exposons
ci-dessous leurs syntaxe et leurs utilisation dans la résolution de problèmes en sciences physiques.
5.1 numpy
numpy est une librairie d’algorirhme et de fonctions. Il permet de créer des tableaux multi-
dimensionnels similaires aux listes tels que les éléments du tableau sont de même type(soit des
entiers, soit des flottants,. . . ). On parle aussi de vecteurs et de matrices. numpy est un outil
performant pour la manipulation de tableaux à N dimension. Il dispose de fonctions basiques en
algèbre linéaire et de fonctions basiques pour les transformées de Fourier.
5.1.1 Création d’un vecteur

la création de tableau à une seule ligne ou une seule colonne peut se faire de différentes
manières :
création manuelle :
>>> import numpy as np
>>> A=np.array([1,0,12,3])
>>> type(A)
<class 'numpy.ndarray'>
>>> print(A)
[ 1 0 12 3]
>>> A.ndim
1
>>> A.shape
(4,)

numpy
>>> A.size
4
>>> A=np.array([1,0,12,3],dtype=float)
>>> A
array([ 1., 0., 12., 3.])
Création à partir d’une séquence :

>>> A=np.arange(0,10)
>>> A
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> A=np.arange(0,10,dtype=float)
>>> A
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
>>> A=np.arange(0,10,2)
>>> A
array([0, 2, 4, 6, 8])
>>> A=np.linspace(0,10,6)
>>> A
array([ 0., 2., 4., 6., 8., 10.])
>>> A=np.linspace(0,10,5)
>>> A
array([ 0. , 2.5, 5. , 7.5, 10. ])
>>> A=np.ones(5)
>>> A
array([ 1., 1., 1., 1., 1.])
à partir d’un fichier texte

>>> import os
>>> os.chdir('/home/tagsai/Bureau')
>>> A=np.loadtxt('fich1.txt',dtype=float)
>>> A
array([ 1., 5., 3., 20., 2., 7., 8., 12., 9.,
23., 7., 66., 400.])
à partir d’une liste :

>>> L=[11,55,0.01,3,4]
>>> type(L)
<class 'list'>
>>> A=np.asarray(L,dtype=float)
>>> A
array([ 1.10000000e+01, 5.50000000e+01, 1.00000000e-02,
3.00000000e+00, 4.00000000e+00])
>>> type(A)

numpy
on rajoute une valeur en dernière position à un vecteur qui existe déjà :

>>> A=np.array([1,15,10,2])
>>> A
array([ 1, 15, 10, 2])
>>> A=np.append(A,0.1)
>>> A
array([ 1. , 15. , 10. , 2. , 0.1])
suppression d’une valeur via son indice

>>> A
array([ 1. , 15. , 10. , 2. , 0.1])
>>> B=np.delete(A,2)
>>> B
array([ 1. , 15. , 2. , 0.1])
redimensionnement d’un vecteur :

>>> B
array([ 1. , 15. , 2. , 0.1])
>>> np.resize(B,10)
array([ 1. , 15. , 2. , 0.1, 1. , 15. , 2. , 0.1, 1. , 15.
])
Concaténer deux vecteurs :

>>> B
array([ 1. , 15. , 2. , 0.1])
>>> C=np.array([12,0,0,3])
>>> D=np.append(B,C)
>>> D
array([ 1. , 15. , 2. , 0.1, 12. , 0. , 0. , 3. ])
5.1.2 Extraction des valeurs d’un vecteur
>>> A=[1,2,5,11,12,25,88,32]
>>> #valeur indicée
... A[3]
11
>>> #début jusqu'à l troisième
... A[:3]
[1, 2, 5]
>>> #du deuxième indice jusqu'à la fin
... A[2:]

numpy
[5, 11, 12, 25, 88, 32]

>>> #utilisation d'un indice négatif
... A[-4]
12
>>> #début vers fin avec un pas
... A[1:6:2]
[2, 11, 25]
>>> #un pas négatif
... A[3:0:-1]
[11, 5, 2]
>>> #inverser un vecteur
... A[::-1]
[32, 88, 25, 12, 11, 5, 2, 1]
5.1.3 Opérations sur les vecteurs
>>> A=np.array([1,3,5,7,9,11,13,15])
>>> B=np.array([2,4,6,8,10,12,14,16])
>>> #moyenne
... np.mean(A)
8.0
>>> #mediane
... np.median(A)
8.0
>>> #variance
... np.var(A)
21.0
>>> #pourcent
... np.percentile(A,50)
8.0
>>> #somme
... np.sum(A)
64
>>> #somme cumulée
... np.cumsum(A)
array([ 1, 4, 9, 16, 25, 36, 49, 64])
>>> #somme de deux vecteurs
... A+B
array([ 3, 7, 11, 15, 19, 23, 27, 31])
>>> #multiplication de deux vecteurs
... A*B
array([ 2, 12, 30, 56, 90, 132, 182, 240])
>>> #produit scalaire de deux vecteurs

numpy
... np.vdot(A,B)
744
>>> #norme d'un vecteur
... np.linalg.norm(A)
26.076809620810597
>>> #intersection
... np.intersect1d(A,B)
array([], dtype=int64)
>>> #union
... np.union1d(A,B)
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
5.1.4 Création d’un tableau : matrice

La création de tableaux peut s’effectuer de plusieurs manières :
saisie manuelle :
>>> A=np.array([[1,2,5,11],[12,20,5,2],[55,0.01,12,20]])
>>> type(A)
>>> print(A)
[[1, 2, 5, 11] [12, 20, 5.2] [55, 0.01, 12, 20]]
>>> print(A.ndim)
2
>>> print(A.shape)
(3, 4)
>>> A.size
12
C’est un tableau de 4 colonnes et de trois lignes.

1 2 5 11
 
 12 20 5 2 


55 0.01 12 20
à partir d’une séquence de valeurs :

>>> A=np.arange(0,15).reshape(3,5)
>>> A
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
>>> #arange génère une séquence de 0 à 14 et reshape les distribue en 3
lignes et 5 colonnes
à partir d’un vecteur

numpy
>>> B
array([ 2, 4, 6, 8, 10, 12, 14, 16])
>>> B.shape
(8,)
>>> C=B.reshape(4,2)
>>> C
array([[ 2, 4],
[ 6, 8],
[10, 12],
[14, 16]])
>>> C.shape
(4, 2)
#matrice à 4 lignes et 2 colonnes
matrice contenant un même élément :

>>> A=np.full(shape=(2,4),fill_value=0.01)
>>> A
array([[ 0.01, 0.01, 0.01, 0.01],
[ 0.01, 0.01, 0.01, 0.01]])
à partir d’un fichier :

>>> A=np.genfromtxt('fich1.txt', delimiter=',')
>>> A
array([[ nan, nan, nan],
[ 15., 14., 12.],
[ 10., 9., 7.],
[ 13., 12., 10.],
[ 5., 4., 6.],
[ 3., 2., 4.]])
>>> A=np.delete(A,(0),axis=0)
>>> A
array([[ 15., 14., 12.],
[ 10., 9., 7.],
[ 13., 12., 10.],
[ 5., 4., 6.],
[ 3., 2., 4.]])
à partir d’une liste :

>>> L=[1,2,3,4,5,6,7,8,9,10]
>>> A=np.asarray(L,dtype=float).reshape(2,5)
>>> A
array([[ 1., 2., 3., 4., 5.],
[ 6., 7., 8., 9., 10.]])
créer une matrice à une colonne et une matrice à une ligne à partir d’un vecteur :

numpy
>>> A=np.array([1,2,5,11])
>>> A
array([ 1, 2, 5, 11])
>>> np.shape(A)
(4,)
>>> B=A[:,np.newaxis]
>>> B
array([[ 1],
[ 2],
[ 5],
[11]])
>>> np.shape(B)
(4, 1)
>>> C=A[np.newaxis,:]
>>> C
array([[ 1, 2, 5, 11]])
>>> np.shape(C)
(1, 4)
concaténer deux matrices :

>>> a=np.array([[1,2],[3,4]])
>>> a
array([[1, 2],
[3, 4]])
>>> np.shape(a)
(2, 2)
>>> b=np.array([[5,6]])
>>> np.shape(b)
(1, 2)
>>> np.concatenate((a,b),axis=0)
array([[1, 2],
[3, 4],
[5, 6]])
>>> np.concatenate((a,b.T),axis=1)
array([[1, 2, 5],
[3, 4, 6]])
>>> np.vstack((a,b))
array([[1, 2],
[3, 4],
[5, 6]])
>>> np.hstack((a,b.T))
array([[1, 2, 5],
[3, 4, 6]])

numpy
>>> a=np.array([[1,2],[3,4],[5,6]])
>>> b=n.array([[7,8]])
>>> a
array([[1, 2],
[3, 4],
[5, 6]])
>>> b
array([[7, 8]])
>>> c=np.append(a,b,axis=0)
>>> c
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
>>> d=np.array([[7],[8],[9]])
>>> np.append(a,d,axis=1)
array([[1, 2, 7],
[3, 4, 8],
[5, 6, 9]])
insertion d’un vecteur dans une matrice en tant que nouvelle ligne
>>> a
array([[1, 2],
[3, 4],
[5, 6]])
>>> b
array([[7, 8]])
>>> np.insert(a,1,b,axis=0)
array([[1, 2],
[7, 8],
[3, 4],
[5, 6]])
suppression d’un ligne d’une matrice :

>>> a
array([[1, 2],
[3, 4],
[5, 6]])
>>> np.delete(a,1,axis=0)
array([[1, 2],
[5, 6]])
redimensionnement d’une matrice :

numpy
>>> a
array([[1, 2],
[3, 4],
[5, 6]])
>>> np.shape(a)
(3, 2)
>>> b=np.resize(a,new_shape=(2,3))
>>> b
array([[1, 2, 3],
[4, 5, 6]])
matrices spéciales :
>>> A=np.ones((3,5))
>>> A
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
>>> A=np.ones((3,5),np.int)
>>> A
array([[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1]])
>>> B=np.zeros((2,3))
>>> B
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
>>> C=np.eye(3)
>>> C
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> D=np.diag([1,2,3])
>>> D
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
5.1.5 Extraction des valeurs d’une matrices

>>> A=np.array([[1,2],[3,4],[5,6],[7,8],[9,10]])
>>> #toutes les valeurs de A

numpy
... A[:,:]
array([[ 1, 2],
[ 3, 4],
[ 5, 6],
[ 7, 8],
[ 9, 10]])
>>> #de la première ligne à la dernière
... A[1:,:]
array([[ 3, 4],
[ 5, 6],
[ 7, 8],
[ 9, 10]])
>>> #dernière ligne et toutes les colonnes
... A[-1,:]
array([ 9, 10])
5.1.6 opérations sur les matrices
>>> A
array([[ 1, 2],
[ 3, 4],
[ 5, 6],
[ 7, 8],
[ 9, 10]])
>>> B
array([[5, 3],
[9, 7]])
>>> #transposition
... np.transpose(A)
array([[ 1, 3, 5, 7, 9],
[ 2, 4, 6, 8, 10]])
>>> np.transpose(B)
array([[5, 9],
[3, 7]])
>>> #multiplication
... np.dot(A,B)
array([[ 23, 17],
[ 51, 37],
[ 79, 57],
[107, 77],
[135, 97]])
>>>#déterminant
... np.linalg.det(B)

matplotlib
8.0000000000000018
>>> #inversion
... np.linalg.inv(B)
array([[ 0.875, -0.375],
[-1.125, 0.625]])
5.2 matplotlib
Ce module permet la réalisation des graphes 2 et 3 dimensions avec un support interactif et
sorties de haute qualité. On peut sauvegarder les figures sous différents formats : pdf, ps, png. . .
Pour obtenir des graphes on dispose de deux manières :
Soit on utilise le mode interactif en utilisant pylab. Dans ce cas on n’a pas à importer
matplotlib, pylab se charge de tout
Soit on importe matplotlib.pyplot. Cette manière est préférable pour exécuter les scripts
python
Nous donnons ci-dessous quelques exemples de graphes.
Courbe du sinus cardinal :
import numpy as np
import matplotlib.pyplot as pl
x=np.linspace(-5*np.pi,5*np.pi,200)#tableau contenant 200 points répartis de
manière uniforme entre -5pi et 5pi
y=np.sin(x)/x
pl.plot(x,y,color='blue',linewidth=1.5,linestyle="-",label='fonction sinus
cardinal')
pl.xlim(x.min()*1.1,x.max()*1.1)#domaine de x
pl.xticks(np.linspace(-13,13,5,endpoint=True))#gamme de x et nombre de
graduations
pl.xticks([-5*np.pi, -3*np.pi, 0, 3*np.pi, 5*np.pi],[r'$-5\pi$', r'$-3\pi$',
r'$0$', r'$3\pi$', r'$5\pi$'])
pl.ylim(y.min()*1.1,y.max()*1.1)#domaine de y
pl.yticks([-0.5,0,0.5,1])#nombre de graduations
ax = pl.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))
#ax.set_xticklabels([])
#ax.set_yticklabels([])
pl.legend(loc='upper left')
pl.show()

matplotlib
fonction sinus cardinal 1.0
0.5
0.0
−5π −3π 0 3π 5π
−0.5
courbe sinus cardinal à 3 dimensions :

from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.gca(projection='3d')
X = np.linspace(-5*np.pi, 5*np.pi, 200)
Y = np.linspace(-5*np.pi, 5*np.pi, 200)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)/R
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,
linewidth=0, antialiased=False)
ax.set_zlim(-0.4, 1.01)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()

matplotlib
1.01
0.85
0.90
0.70
0.75
0.54
0.38 0.60
0.23 0.45
0.07
0.30
-0.09
0.15
-0.24
-0.40 0.00
20 −0.15
15
10
5
−20 0
−15
−10 −5
−5
0 −10
5
10 −15
15
20 −20
Tracé du diagrammes de Bode d’un passe-bas de deuxième ordre :

from matplotlib.pyplot import *
from numpy import *
from pylab import *
def H(w,a):
return 1/(1 + a*1j*w - w*w)
puissance_w = arange(-2,2,0.01)
W = 10**puissance_w
phase1 = angle(H(W,0.1),'deg')
module1 = 20*log(absolute(H(W,0.1)))
phase2 = angle(H(W,1),'deg')
module2 = 20*log(absolute(H(W,1)))
phase3 = angle(H(W,4),'deg')
module3 = 20*log(absolute(H(W,4)))
subplot(211)
semilogx(W,module1,color='red')
semilogx(W,module2,color='blue')
semilogx(W,module3,color='magenta')
grid(True)

matplotlib
subplot(212)
semilogx(W,phase1,color='red')
semilogx(W,phase2,color='blue')
semilogx(W,phase3,color='magenta')
grid(True)
show()
50
−50
−100
−150
−200 -2 -1 0 1 2
10 10 10 10 10
0
−20
−40
−60
−80
−100
−120
−140
−160
−180
10 -2
10
-1
10
0
10
1
10
2
graphe avec animation :

from pylab import *
from matplotlib import animation
k = 2*pi
w = 2*pi
dt = 0.01
xmin = 0
xmax = 3
nbx = 100
x = linspace(xmin, xmax, nbx)
fig = figure() # initialise la figure

scipy
line, = plot([],[])
xlim(xmin, xmax)
ylim(-1,1)
# fonction à définir quand blit=True
# crée l'arrière de l'animation qui sera présent sur chaque image
def init():
line.set_data([],[])
return line,
def animate(i):
t = i * dt
y = cos(k*x - w*t)
line.set_data(x, y)
return line,
ani = animation.FuncAnimation(fig, animate, init_func=init, frames=100, blit=
True, interval=20, repeat=True)
show()
5.3 scipy
Scipy est une librairie d’algorithmes et de fonctions mathématiques basées sur les tableaux
ndarray, complétant ou améliorant les fonctionnalités de numpy. Il contient les modules suivants :
Fonctions spéciales : scipy.special((fonctions de Bessel, erf, gamma, etc.))
intégration numérique : scipy.integrate (intégration numérique ou d’équations différen-
tielles)
Méthodes d’optimisation : scipy.optimize (minimisation, moindres-carrés, zéros d’une
fonction, etc.)
Interpolation : scipy.interpolate (interpolation, splines)
Transformées de Fourier : scipy.fftpack
Traitement du signal : scipy.signal (convolution, corrélation, filtrage, ondelettes, etc.)
Algèbre linéaire : scipy.linalg
Statistiques : scipy.stats (fonctions et distributions statistiques)
Traitement d’images multi-dimensionnelles : scipy.ndimage
Entrées/sorties : scipy.io
5.4 Recherche numérique de l’équation f(x)=0

Deux méthodes seront utilisées pour l’évaluation de la solution à l’équation f(x)=0 :
la méthode de dichotomie : méthode qui converge assez rapidement. la fonction f doit être
continue et changer de signe dans l’intervalle considéré.
la méthode de Newton : elle converge plus rapidement que la méthode de dichotomie, mais
qui nécessite des conditions de validités sont parfois difficiles à réaliser.

Recherche numérique de l’équation f(x)=0
5.4.1 Méthode de dichotomie

Soit f une fonction continue et s’annulant une seule fois sur l’intervalle [a,b]. Le principe de
la méthode consiste à diviser l’intervalle par deux. Soit m le milieu du segment [a,b].
Si f (m)f (a) ≥ 0, la solution se trouve dans [m,b]. on remplace a par m.
Si f (m)f (a) < 0, la solution se trouve dans l’intervalle [a,m], on remplace b par .
On répète jusqu’à avoir atteint la précision recherchée. Ci-dessous les commandes python de
l’algorithme de dichotomie.
def dichotomie(f,a,b,epsilon):
assert f(a)*f(b) <= 0 and epsilon > 0
gauche ,droite = a,b
while (droite - gauche) > epsilon :
m = (gauche+droite)/2
fm = f(m)
fgauche = f(gauche)
if fm*fgauche <= 0:
droite = m
else:
gauche = m
return (gauche+droite)/2
5.4.2 Méthode de Newton

Soit f une fonction dérivable dans un intervalle [a,b] telle que sa dérivée f’ ne s’annule pas
dans cet intervalle.
Pour déterminer la solution à l’équation f(x)=0 on procède comme suit :
on considère un réel x0 de l’intervalle [a,b],
on trace la tangente à la courbe de f en x0 . Cette droite coupe l’axe des x en x1 :
f (x0 )
y = f (x0 ) + (x1 − x0 )f ′ (x0 ) = 0 ⇒ x1 = x0 −
f ′ (x0 )
on trace de nouveau la tangente à la courbe en x1 . Celle-ci coupe l’axe en x2 tel que :
f (x1 )
x2 = x1 −
f ′ (x1 )
on itère :
f (xn )
xn+1 = xn −
f ′ (xn )
l’arrêt des itérations est atteint lorsque :
♦ l’écart entre deux termes successifs est suffisamment petit,
♦ ou bien lorsqu’on estime que le nombre d’itérations est suffisant.
Le code python traduisant les lignes de l’algorithme est comme suit :

Intégration numérique
def newton(f,x_0,epsilon,N):
k = 0
x = x_0
fx = f(x)
h = epsilon
dfx = (f(x+h)-fx)/h
while ( (abs(fx)>epsilon) and (k<N) ):
x = x - fx/dfx
fx = f(x)
dfx = (f(x+h)-fx)/h
k+= 1
if k==N:
print("Pas de convergence")
else:
return x
5.4.3 Résolution de f(x)=0 à l’aide de scipy

Les algorithmes de dichotomie et de newton sont implémentés dans scipy. Pour les utiliser il
suffit de charger le sous-module optimize :
méthode de dichotomie
import scipy.optimize
scipy.optimize.bisect(f,a,b)
méthode de newton
import scipy.optimize
scipy.optimize.newton(f,x_0)
5.5 Intégration numérique

Il s’agit de trouver une valeur approchée d’une intégrale d’une fonction entre deux bornes a et
b. Trois méthodes sont à notre dispositions : la méthode des rectangles, la méthode des trapèzes
et la méthode de Simpson. Pour les trois méthodes on découpe l’intervalle d’intégration en petits
morceaux et on approche sur chacun des petits intervalles la courbe représentative de f par une
courbe très simple pour laquelle le calcul d’aire est facile.
5.5.1 Méthodes des rectangles

On approche l’intégrale par l’air des rectangles découpés comme le montre la figure ci-dessous.

f(x)
a b x
Le code python traduisant cet algorithme se présente comme suit :

def rectangles(f,a,b,n) :
h=(b-a)/float(n)
z=0
for i in range(n) :
z=z+f(a+i*h)
return h*z
La méthode des rectangles nécessite de faire n évaluations de la fonction, ainsi que n sommes
(qui peuvent être considérées comme négligeables). C’est donc un algorithme linéaire par rapport
au nombre d’intervalles utilisés pour le découpage. Sa convergence est hélas très lente, ce qui en
fait un algorithme peu utilisé en pratique. En négligeant le facteur constant M(b − a)2 /2 où M
est un majorant de f’ il faudra un ordre de grandeur de 1010 intervalles pour obtenir une valeur
approchée correcte à dix décimales près.
5.5.2 Méthode des trapèzes

De même on découpe l’intervalle d’intégration en plusieurs intervalles. L’air d’un trapèze
s’exprime par :
h
Si = [f (a + ih) − f (a + (i − 1)h)]
2
L’intégrale est approchée par la sommes des aires des différents trapèzes (figure ci-dessous)
n−1
h
S= [f (a) + f (b)] + f (a + ih)
X
2 i=1
et on approche l’aire des trapèzes à l’intégrale comme le montre la figure ci-dessous.

Le code python traduisant les lignes de l’algorithme est le suivant :
def trapezes(f,a,b,n) :
h=(b-a)/float(n)
z=0.5*(f(a)+f(b))
for i in range(1,n) :

z=z+f(a+i*h)
return h*z
f(x)
a b x
5.5.3 Méthode de Simpson

La méthode consiste à faire le même découpage de l’intervalle d’intégration et à approcher la
courbe entre deux points successifs par un polynôme de degré 2. La somme est donnée par :
n−1
f (xi ) + 4f ( xi+x2 i+1 ) + f (xi+1 )
S=h
X
i=0 6
Cette quantitée est approximativement donnée par :
f (a) + f (b) 1 n−1 2 n−1 xi + xi+1

" #
S=h + f (xi ) +
X X
f
6 3 i=1 3 i=0 2
Le code python est donné par :
def Simpson(f,a,b,n) :
h=(b-a)/float(n)
z=(f(a)+f(b))/6
for i in range(1,n) :
z=z+f(a+i*h)/3
for i in range(n) :
z=z+f(a+(2*i+1)*h/2)*2/3
return h*z
5.5.4 Utilisation de scipy.integrate

Les commandes données ci-dessous permettent d’évaluer les intégrales simples, doubles et
triples à l’aide du module scipy.integrate :

Résolution d’un système d’équations linéaires
intégrale simple :
quad(f,a,b)#calcule une valeur approchée de l'intégrale de f entre a et b
sans spécifier la méthode
romberg(f,a,b)#calcule une valeur approchée de l'intégrale à l'aide de la mé
thode de Romberg
Intégrales doubles et triples :

dblquad(f,a,b)#calcul d'intégrale double sans spécifier la méthode
tplquad(f,a,b)#calcul d'intégrale triple sans spécifier la méthode
5.6 Résolution d’un système d’équations linéaires

Le module numpy.linalg.solve() permet de résoudre le système d’équations linéaires. Dans un
premier temps effectuons notre raisonnement sur un exemple simple :
3x + y = 9
(
x + 2y = 8
La solution s’obtient en utilisant l’écriture matricielle aX = b où a et b sont deux matrices :

3 1 9
! !
a= ; b=
1 2 8
import numpy as np
a = np.array([[3,1], [1,2]])
b = np.array([9,8])
np.linalg.solve(a, b)
5.7 Résolution d’un système d’équations non linéaires

On utilise le module scipy.optimize.root de scipy. Nous effectuons notre raisonnement sur
l’exemple suivant :
x − y2 = 1
( 2
x + 2y = 3
on définit la fonction à valeurs vectorielle f puis on utilise root en spécifiant un point de départ :
>>> import scipy.optimize as opt
>>> def f(v):
... return v[0]**2-v[1]**2-1,v[0]+2*v[1]-3
...
>>> sol=opt.root(f,[0,0])
>>> print(sol)
fjac: array([[ 0.93076594, 0.3656156 ],
[-0.3656156 , 0.93076594]])

Résolution des équations différentielles ordinaires
fun: array([ 2.22044605e-16, 0.00000000e+00])

message: 'The solution converged.'
nfev: 11
qtf: array([ 3.64074679e-11, -1.43012733e-11])
r: array([ 2.73511307, -0.97830981, 2.53305931])
status: 1
success: True
x: array([ 1.30940108, 0.84529946])
5.8 Résolution des équations différentielles ordinaires

5.8.1 Équation différentielle de premier ordre : méthode d’Euler
On se propose de déterminer la solution y(t) de l’équation différentielle avec une condition
initiale y(t0) suivante :
dy
= F (y(t), t); y(t0) = y0
dt
La méthode d’Euler consiste à déterminer approximativement les valeurs prises par y aux instants
t0 , . . . , tN −1 :
dy yi+1 − yi
F (yi , ti ) = ≈ ⇒ yi+1 = yi + F (yi , ti ) × (ti+1 − ti )
dt i ti+1 − ti
Le code python traduisant cet algorithme s’exprime par :
def euler(F,y0,t):
N=len(t)
y=[0]*N
y[0]=y0
for i in range(N-1):
y[i+1]=y[i]+(t[i+1]-t[i])*F(y[i],t[i])
return y
import numpy as np
def F(y,t):
return 1-y
t=np.linspace(0,10,1000)
y=euler(F,0,t)
plt.plot(t,y,'b-')
plt.plot(t,1-np.exp(-t),'r--')
plt.show()

Résolution des équations différentielles ordinaires
5.8.2 Résolution à l’aide du sous module odeint

On utilise le sous module odeint de scipy. On le charge à l’aide de la commande "from
scipy.integrate import odeint". Odeint agit sur (F,y0,t) où F est la fonction F(y,t) qui intervient
dans l’équation différentielle, y0 est la valeur initiale et t est le vecteur contenant les valeurs ti .
Le code python se présente sous la forme :
from math import *
from scipy.integrate import odeint
import numpy as np
def F(y,t):
return 1-y
y=odeint(F,0,t)
plt.plot(t,y)
plt.show()
5.8.3 Résolution des équations différentielles d’ordre 2

On se propose de résoudre l’équation implicite suivante :
ẍ = f (x, ẋ, t)
La méthode consiste à se ramener à un système différentiel de la forme :

(
ẋ = y
ẏ = f (x, y, t)
En appliquant par exemple la méthode d’Euler, la discrétisation du système s’obtient comme
suit : (
xi+1 = xi + (ti+1 − ti ) × y
ẏi+1 = ẏi + (ti+1 − ti ) × f (xi , yi , ti )
Nous effectuons notre raisonnement sur l’équation différentielle suivante :
ω0
ẍ + ẋ + ω02x = 0; ẋ(0) = 0, x(0) = 1
Q
" #
x
On définit le vecteur X sous la forme : X = Le système différentiel s’écrit sous la forme :
y


 ẋ = y
ω0
 ẏ
 = −ω02 x − y
Q
La fonction F associée au système s’exprime par :
" #
dX y
= F (x, y, t) = 2 ω0
dt −ω0 x − Q
y
Le code python traduisant les lignes de l’algorithme est comme suit :

Génération des signaux-Transformée de Fourier
from math import *

import numpy as np
omega0=10
Q=10
def F(X,t):
x=X[0]
y=X[1]
return [y,-omega0**2*x-omega0/Q*y]
X=odeint(F,[1,0],t)
plt.clf()
plt.plot(t,X[:,0],'b-',t,X[:,1])
plt.show()
5.9 Génération des signaux-Transformée de Fourier

5.9.1 Génération d’un signal sinusoïdal
Le code python permettant de générer une sinusoïde et son spectre est donné par :
import numpy as np
from scipy import signal
from scipy.fftpack import *
f=1000
T=1/f
dac=0
fac=5*T
Fe=100*f
Te=1/Fe
Tac=(fac-dac)
N=int(Tac*Fe)
t=np.arange(0,N)*Te
X=np.zeros(N)
for k in range(N):
X[k]=np.sin(2*np.pi*f*t[k])+1
tfd1=abs(fft(X))
freq=np.arange(0,N)*1.0/Tac
freqmax=N/2*1.0/Tac

plt.subplot(211)
plt.plot(t,X,color='b')
plt.axis([0,fac,-0.5,2.5])
plt.subplot(212)
plt.plot(freq,tfd1/N,color='r')
plt.axis([0,freqmax,0,1.5])
plt.show()
2.5
2.0
1.5
1.0
0.5
0.0
−0.5
0.000 0.001 0.002 0.003 0.004 0.005
1.2
1.0
0.8
0.6
0.4
0.2
0.0
0 1000 2000 3000 4000 5000 6000
5.9.2 Génération d’un signal carré de rapport cyclique 0.5

La commande scipy.signal.square permet de générer un signal carré à rapport cyclique contrôlé
selon une certaine fonction.
import numpy as np
f=1000
T=1/f
dac=0
fac=5*T
Fe=100*f
Te=1/Fe

Tac=(fac-dac)
N=int(Tac*Fe)
t=np.arange(0,N)*Te
X=np.zeros(N)
for k in range(N):
X[k]=signal.square(2*np.pi*f*t[k],0.5)
tfd1=abs(fft(X))
freqmax=N/2*1.0/Tac
plt.subplot(211)
plt.axis([0,fac,-1.5,1.5])
plt.subplot(212)
plt.show()
1.5
1.0
0.5
0.0
−0.5
−1.0
−1.5
0.000 0.001 0.002 0.003 0.004 0.005
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0
0 10000 20000 30000 40000 50000
5.9.3 Génération d’un signal carré de rapport cyclique 0.2
import numpy as np

f=1000
T=1/f
dac=0
fac=5*T
Fe=100*f
Te=1/Fe
Tac=(fac-dac)
N=int(Tac*Fe)
t=np.arange(0,N)*Te
X=np.zeros(N)
for k in range(N):
X[k]=signal.square(2*np.pi*f*t[k],0.2)
tfd1=abs(fft(X))
freqmax=N/2*1.0/Tac
plt.subplot(211)
plt.axis([0,fac,-1.5,1.5])
plt.subplot(212)
plt.show()
1.5
1.0
0.5
0.0
−0.5
−1.0
−1.5
0.000 0.001 0.002 0.003 0.004 0.005
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0
0 10000 20000 30000 40000 50000

5.9.4 Génération d’un signal triangulaire de rapport cyclique 0.5
import numpy as np
f=1000
T=1/f
dac=0
fac=5*T
Fe=100*f
Te=1/Fe
Tac=(fac-dac)
N=int(Tac*Fe)
t=np.arange(0,N)*Te
X=np.zeros(N)
for k in range(N):
X[k]=signal.sawtooth(2*np.pi*f*t[k],0.5)
tfd1=abs(fft(X))
freqmax=N/2*1.0/Tac
plt.subplot(211)
plt.axis([0,fac,-1.5,1.5])
plt.subplot(212)
plt.show()

1.5
1.0
0.5
0.0
−0.5
−1.0
−1.5
0.000 0.001 0.002 0.003 0.004 0.005
0.5
0.4
0.3
0.2
0.1
0.0
0 2000 4000 6000 8000 10000 12000 14000
5.9.5 Génération d’un signal triangulaire de rapport cyclique 0.2
import numpy as np
f=1000
T=1/f
dac=0
fac=5*T
Fe=100*f
Te=1/Fe
Tac=(fac-dac)
N=int(Tac*Fe)
t=np.arange(0,N)*Te
X=np.zeros(N)
for k in range(N):
X[k]=signal.sawtooth(2*np.pi*f*t[k],0.2)
tfd1=abs(fft(X))
freqmax=N/2*1.0/Tac
plt.subplot(211)
plt.axis([0,fac,-1.5,1.5])

plt.subplot(212)
plt.show()
1.5
1.0
0.5
0.0
−0.5
−1.0
−1.5
0.000 0.001 0.002 0.003 0.004 0.005
0.5
0.4
0.3
0.2
0.1
0.0
0 2000 4000 6000 8000 10000 12000 14000 16000
5.9.6 Génération d’un signal bruité en amplitude
import numpy as np
from numpy import random
f=1000
T=1/f
dac=0
fac=5*T
Fe=100*f
Te=1/Fe
Tac=(fac-dac)
N=int(Tac*Fe)
t=np.arange(0,N)*Te
X=np.zeros(N)
for k in range(N):
X[k]=np.sin(2*np.pi*f*t[k])+0.5*random.random()*np.sin(2*np.pi*5000*t[k])

tfd1=abs(fft(X))
freqmax=N/2*1.0/Tac
plt.subplot(211)
plt.axis([0,fac,-1.5,1.5])
plt.subplot(212)
plt.show()
1.5
1.0
0.5
0.0
−0.5
−1.0
−1.5
0.000 0.001 0.002 0.003 0.004 0.005
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0
0 10000 20000 30000 40000 50000
5.9.7 Génération d’un signal bruité en fréquence
import numpy as np
from numpy import random
f=1000
T=1/f
dac=0
fac=5*T
Fe=100*f
Te=1/Fe

Applications en Physique-Chimie
Tac=(fac-dac)
N=int(Tac*Fe)
t=np.arange(0,N)*Te
X=np.zeros(N)
for k in range(N):
X[k]=np.sin(2*np.pi*f*t[k])+np.sin(2*np.pi*random.random()*1000*t[k])
tfd1=abs(fft(X))
freqmax=N/2*1.0/Tac
plt.subplot(211)
plt.axis([0,fac,-1.5,1.5])
plt.subplot(212)
plt.show()
−1
−2
0.000 0.001 0.002 0.003 0.004 0.005
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0
0 10000 20000 30000 40000 50000
5.10 Applications en Physique-Chimie

5.10.1 Circuit RC attaqué par un signal sinusoïdal
from math import *

import numpy as np


R=1000
C=1e-6
f=1000
def ue(t):
return 10*np.sin(2*pi*f*t)
def F(u,t):
return (ue(t)-u)/(R*C)
t=np.linspace(0,5/f,1000)
plt.plot(t,ue(t),'b-')
plt.plot(t,odeint(F,0,t),'r-')
plt.legend(["ue","u"])
plt.xlabel("t (s)")
plt.ylabel("u (V)")
plt.show()
10
ue
u
5
u (V)
−5
−10
0.000 0.001 0.002 0.003 0.004 0.005
t (s)
5.10.2 Circuit RC attaqué par un échelon "doux"
from math import *

import numpy as np
R=1000
C=1e-6

f=1000
def ue(t):
if (t<=0):
return 0
elif (t<=1e-2):
return 1000*t
else:
return 10
def F(u,t):
return (ue(t)-u)/(R*C)
t=np.linspace(0,0.02,100)
plt.plot(t,[ue(ti) for ti in t],'b-')
plt.plot(t,odeint(F,0,t),'r-')
plt.legend(["ue","u"],loc="lower right")
plt.xlabel("t (s)")
plt.ylabel("u (V)")
plt.axis([-0.002,0.022,-0.2,10.5])
plt.show()
10
6
u (V)
2
ue
u
0
0.000 0.005 0.010 0.015 0.020
t (s)
5.10.3 chute d’une masse ponctuel dans le champ de pesanteur avec

frottement fluide et quadratique
m=3.6e-3
g=9.81

k1=1.8e-3
k2=9.2e-5
tau=m/k1
def F(v,t):
return g-k1/m*v
def G(v,t):
return g-k2/m*v**2
v1=odeint(F,0,t)
v2=odeint(G,0,t)
vlim=v1[-1]
plt.plot(t,v1,'b-')
plt.plot(t,v2,'r-')
plt.axhline(y=vlim*0.95,color='k')
plt.xlabel("t (s)")
plt.ylabel("v (m/s)")
plt.legend([u"Linéaire","Quadratique"],loc="lower right")
plt.show()
20
15
v (m/s)
10
Linéaire
Quadratique
0
0 2 4 6 8 10 12 14 16
t (s)
5.10.4 Cinétique d’une réaction chimique : régression linéaire

On s’intéresse à l’équation bilan suivante :
Fe2+ + Co3+ ⇋ Fe3+ + Co2+

C’est une réaction d’ordre 2. La concentration des ions Fe2+ , notée C est modélisée par la loi :
1
C=
at + b
Les mesures expérimentales sont regroupées dans le tableau suivant :
t(s) 20 40 60 80 100 120
C(10−4 mol.L−1 ) 2.78 1.92 1.47 1.19 1 0.86
from math import *

import numpy as np
from scipy.stats import linregress
t_mes=np.array([20,40,60,80,100,120])
C_mes=np.array([2.78e-4,1.92e-4,1.47e-4,1.19e-4,1.0e-4,0.86e-4])
y=1/C_mes
(a,b,rho,_,_)=linregress(t_mes,y)
print("a=%f, b=%f, rho=%f" % (a,b,rho))
print("C(0)=%e mol/L" % b**(-1))
plt.plot(t,1/(float(a)*t+float(b)),'r-')
plt.plot(t_mes,C_mes,'bo')
plt.xlabel("t (s)")
plt.ylabel("C (mol/L)")
plt.legend([u"Modèle (rho=%f)" % rho,"Mesures"])
plt.show()
a=80.185091, b=1993.617811, rho=0.999996 C(0)=5.016007e-04 mol/L

0.0006
Modèle (rho=0.999996)
Mesures
0.0005
0.0004
C (mol/L)
0.0003
0.0002
0.0001
0.0000
0 20 40 60 80 100 120 140
t (s)
5.10.5 Pendule simple linéarisé (non amorti)

L’équation du pendule simple s’écrit sous la forme :
θ̈ + ω02 θ = 0
import numpy as np
m=float(input('donner la masse du pendule : '))

L=float(input('donner la longueur du pendule : '))
g=9.8
omega0=np.sqrt(g/L)
# Définition du système différentiel linéaire
def Pendule(Theta,t):
theta = Theta[0]
theta_point = Theta[1]
return [theta_point,-omega0**2*theta]
t0=0
T=2*np.pi/omega0
tfin=10*T
t=np.linspace(t0,tfin,200)
theta0=float(input('donner la valeur de theta0 en radian inférieure à pi sur 9 : ')
)

thetapoint0=float(input('donner la valeur de thetapoint0 en radian par seconde : ')

)
X=odeint(Pendule,[theta0,thetapoint0],t)
plt.subplot(211)
plt.plot(t,X[:,0])
#title("Diagramme de phase - pendule simple")
plt.xlabel('t', fontsize = 20)
plt.ylabel('$\\theta$', fontsize = 20)
plt.subplot(212)
plt.plot(X[:,0],X[:,1])
plt.xlabel('$\\theta$', fontsize = 20)
plt.ylabel('$\dot{\\theta}$', fontsize = 20)
plt.show()
0.4
0.3
0.2
0.1
0.0
θ
−0.1
−0.2
−0.3
−0.4
0 5 10 15 20 25
t
1.0
0.5
0.0
θ̇
−0.5
−1.0
−0.4 −0.3 −0.2 −0.1 0.0 0.1 0.2 0.3 0.4
5.10.6 Pendule simple amorti non isochrone
import numpy as np
m=float(input('donner la masse du pendule : '))

L=float(input('donner la longueur du pendule : '))
g=9.8

omega0=np.sqrt(g/L)
Q1=0.1
Q2=0.5
Q3=10
#Q=float(input('donner le facteur de qualité du pendule simple : '))
def Pendule1(Theta,t):
theta = Theta[0]
return [theta_point,-omega0**2*np.sin(theta)-omega0/Q1*theta_point]
theta = Theta[0]
theta = Theta[0]
t0=0
T=2*np.pi/omega0
tfin=10*T
theta0=float(input('donner la valeur de theta0 en radian inférieure à pi sur 9 : ')
)
thetapoint0=float(input('donner la valeur de thetapoint0 en radian par seconde : ')
)
X1=odeint(Pendule1,[theta0,thetapoint0],t)
plt.subplot(211)
plt.plot(t,X1[:,0],color='b')
plt.plot(t,X2[:,0],color='r')
plt.plot(t,X3[:,0],color='m')
plt.ylabel('$\\theta$', fontsize = 20)
plt.subplot(212)
plt.plot(X1[:,0],X1[:,1],color='b')
plt.plot(X2[:,0],X2[:,1],color='r')
plt.plot(X3[:,0],X3[:,1],color='m')


plt.xlabel('$\\theta$', fontsize = 20)
plt.ylabel('$\dot{\\theta}$', fontsize = 20)
plt.tight_layout()
plt.show()
0.4
0.3
0.2
0.1
θ
0.0
−0.1
−0.2
−0.3
0 5 10 15 20 25
t
0.8
0.6
0.4
0.2
0.0
θ̇
−0.2
−0.4
−0.6
−0.8
−1.0
−0.3 −0.2 −0.1 0.0 0.1 0.2 0.3 0.4
5.10.7 Réponse d’un circuit RLC soumis à un signal carré(sortie aux

bornes de C)
La tension de sortie vérifie l’équation différentielle suivante :
ω0
üc + u̇c + ω02uc = ω02ue
Q
import numpy as np
R=float(input('donner la valeur de la résistance en ohms : '))

L=float(input("donner la valeur de l'inductance en Henri : "))
C=float(input("donner la valeur de la capacité en Farad : " ))
omega0=1/np.sqrt(L*C)
Q=L*omega0/R
print('Q= ', Q)#630=0.5,30=10,1000=0.31

f=float(input("donner la valeur de la fréquence du fondamental pour le signal carré

: "))
def ue(t):
return signal.square(2*np.pi*f*t,0.5)

def RLC(Uc,t):
uc = Uc[0]
uc_point = Uc[1]
return [uc_point,omega0**2*(ue(t)-uc)-omega0/Q*uc_point]
t0=0
T=1/f
tfin=5*T
uc0=float(input('donner la valeur de la tension uc initiale : '))
ucpoint0=float(input('donner la valeur de la dérivée de uc initiale : '))
X=odeint(RLC,[uc0,ucpoint0],t)
plt.subplot(211)
plt.plot(t,X[:,0],color='b')
plt.plot(t,ue(t),color='r')
plt.ylabel('uc', fontsize = 20)
plt.axis([0,0.025,-3,3])
plt.subplot(212)
plt.plot(X[:,0],X[:,1])
plt.xlabel('uc', fontsize = 20)
plt.ylabel('$\dot{uc}$', fontsize = 20)
plt.tight_layout()
plt.show()
Pour les paramètre suivants :

#donner la valeur de la résistance en ohms : 30
#donner la valeur de l'inductance en Henri : 0.01
#donner la valeur de la capacité en Farad : 1e-7
#Q=10.5409255339
#donner la valeur de la fréquence du fondamental pour le signal carré : 200
#donner la valeur de la tension uc initiale : 0
#donner la valeur de la dérivée de uc initiale : 0

3
2
1
uc
0
−1
−2
−3
0.000 0.005 0.010 0.015 0.020 0.025
t
80000
60000
40000
20000
0
uc˙
−20000
−40000
−60000
−80000
−3 −2 −1 0 1 2 3
uc
Pour les paramètres ci-dessous :

#Q= 0.501948834947

3
2
1
uc
0
−1
−2
−3
0.000 0.005 0.010 0.015 0.020 0.025
t
30000
20000
10000
0
uc˙
−10000
−20000
−30000
−1.5 −1.0 −0.5 0.0 0.5 1.0 1.5
uc
Pour une valeur faible du facteur de qualité Q ≈ 0.31 :

#Q= 0.316227766017

3
2
1
uc
0
−1
−2
−3
0.000 0.005 0.010 0.015 0.020 0.025
t
20000
15000
10000
5000
0
uc˙
−5000
−10000
−15000
−20000
−1.0 −0.5 0.0 0.5 1.0
uc
En hautes fréquences et en absence de résonance, le circuit réalise la double intégration :

#Q= 0.316227766017

1.0
0.5
0.0
uc
−0.5
−1.0
0.00000 0.00005 0.00010 0.00015 0.00020 0.00025

t
10000
5000
0
uc˙
−5000
−10000
−0.10 −0.05 0.00 0.05 0.10 0.15 0.20
uc
5.10.8 Oscillateur de Van Der Pol

L’équation adimensionnée s’exprime par :
ẍ − (ε − x2 )ẋ + x(t) = 0
Selon les conditions initiales et la valeur du paramètre ε différents comportements sont obtenus :
import numpy as np
epsilon=float(input("donner la valeur de epsilon : "))

def vanderpol(X,t):
x = X[0]
x_point = X[1]
return [x_point,-x+(epsilon-x**2)*x_point]
t0=0
tfin=100
x0=float(input('donner la valeur de la tension x0 : '))
x_point0=float(input('donner la valeur de xpoint0: '))
Y=odeint(vanderpol,[x0,x_point0],t)

plt.subplot(121)
plt.plot(t,Y[:,0],color='b',label="$\\varepsilon=0.2, x_0=0.3, v_0=0$")
#title("epsilon=0.2-x0=0.3-v0=0")
plt.ylabel('x', fontsize = 20)
plt.axis([0,70,-1,1.2])
plt.legend(loc="upper left")
plt.subplot(122)
plt.plot(Y[:,0],Y[:,1],label="ep=0.2, x0=0.3, v0=0")
#title("epsilon=0.2-x0=0.3-v0=0")
plt.xlabel('uc', fontsize = 20)
plt.ylabel('$\dot{uc}$', fontsize = 20)
ax=plt.gca()
#ax.spines['right'].set_color('none')
#ax.spines['top'].set_color('none')
#ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
#ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))
plt.tight_layout()
plt.show()
1.0
ε = 0. 2, x0 = 0. 3, v0 = 0
1.0
0.5
0.5
x
0.0
ẋ
−1.0 −0.5 0.0 0.5 1.0

0.0
x
−0.5
−0.5
−1.0 −1.0
0 10 20 30 40 50 60 70

2.0
ε = 0. 2, x0 = 3. 5, v0 = 2
3
1.5
1.0
2
0.5
x
ẋ
1
0.0
−2 −1 0 1 2 3 4
x
−0.5
0
−1.0
−1
−1.5
0 10 20 30 40 50 60 70
2.5 3
ε = 1, x0 = 0. 3, v0 = 0
2.0
1.5
1.0 1
0.5
x
0
ẋ
−3 −2 −1 0 1 2 3
0.0
x
−0.5 −1
−1.0
−2
−1.5
−2.0 −3
0 10 20 30 40 50 60 70

ε = 1, x0 = 3. 5, v0 = 2
3
2
1
1
x
ẋ
−3 −2 −1 0 1 2 3 4
x
0
−1
−1 −2
−2 −3
0 10 20 30 40 50 60 70
5 15
ε = 4, x0 = 0. 3, v0 = 0
4
10
2 5
1
x
0
ẋ
−4 −2 0 2 4
0
x
−1 −5
−2
−10
−3
−4 −15
0 10 20 30 40 50 60 70

5 15
ε = 4, x0 = 3. 5, v0 = 2
4
10
2 5
1
x
ẋ
−4 −2 0 2 4
0
x
−1 −5
−2
−10
−3
−4 −15
0 10 20 30 40 50 60 70

Cours Informatique Tag

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Informatique Tag

Transféré par

Droits d'auteur :

Formats disponibles

CHAPITRE

3.2 Structure d’un algorithme

S.Tagmouti Page 25 Agreg.1

3.3 Exemples d’algorithmes

3.3.1 Division euclidienne

S.Tagmouti Page 26 Agreg.1

3.3.2 Recherche d’une racine par dichotomie

tant que b − a > ε faire

Ci-dessous le code Python :

S.Tagmouti Page 27 Agreg.1

3.3.3 Résolution d’une équation différentielle linéaire de premier ordre :

u′ = f (u, t); u(t0 ) = u0

ui+1 = ui + (ti+1 − ti ) × f (ui , ti )∀i ∈ [0, N − 2]

L’algorithme d’Euler se résume comme suit :

Le code python s’écrit sous la forme :

3.3.4 Algorithme de tri par insertion

S.Tagmouti Page 28 Agreg.1

Tableau de taille n T (n)

En code python cela se traduit par :

3.4 Complexité d’un algorithme

S.Tagmouti Page 29 Agreg.1

 f (n) = log(n) : complexité logarithmique, augmentation très faible du temps d’exécution

S.Tagmouti Page 30 Agreg.1

NOTIONS DE BASE CONCERNANT LE

 D’où vient le mot python ?

S.Tagmouti Page 31 Agreg.1

 Comment peut-on utiliser python ?

4.1 Identificateurs et mots clés

S.Tagmouti Page 32 Agreg.1

4.2 Types, variables et affectations

S.Tagmouti Page 33 Agreg.1

4.2.1.2 Type bool

4.2.1.3 Type str : chaîne de caractère

De même pour les guillemets

S.Tagmouti Page 34 Agreg.1

>>> type("l'arc en ciel" )

 La fonction len(), appliquée à une chaîne de caractère retourne le nombre de caractère de

 On peut sélectionner des tranches d’une chaîne de caractère(slice) :

 On peut découper la chaîne avec des indices négatifs :

 On ne peut pas modifier un caractère d’une chaîne :

 on peut concaténer deux chaînes de caractère :

4.2.2 Variables et affectations

S.Tagmouti Page 35 Agreg.1

 On peut échanger deux variables :

4.2.3 Conversion de type

S.Tagmouti Page 36 Agreg.1

 conversion chaine de caractère −→ entier ou réel

 Conversion réel, entier −→ chaîne de caractère

4.3 Objets sous python

S.Tagmouti Page 37 Agreg.1

(255, 'lire et écrire', 1e-05, (1+2j))

 On ne peut pas modifier un élément du Tuple :

 Par contre on peut concaténer deux Tuples :

 On peut avoir un tuple de tuples :

4.3.2 Les listes

S.Tagmouti Page 38 Agreg.1

 en utilisant la commande range listant une suite arithmétique :

 En utilisant une fonction mathématique :

 A partir d’une chaîne de caractère qui est un cas particulier de liste :

 Insertion à l’indice fixé :

S.Tagmouti Page 39 Agreg.1

 modification d’un élément :

 suppression d’un élément :

f (n) = log(n) : complexité logarithmique, augmentation très faible du temps d’exécution

D’où vient le mot python ?

Comment peut-on utiliser python ?

La fonction len(), appliquée à une chaîne de caractère retourne le nombre de caractère de

On peut sélectionner des tranches d’une chaîne de caractère(slice) :

On peut découper la chaîne avec des indices négatifs :

On ne peut pas modifier un caractère d’une chaîne :

on peut concaténer deux chaînes de caractère :

On peut échanger deux variables :

conversion chaine de caractère −→ entier ou réel

Conversion réel, entier −→ chaîne de caractère

On ne peut pas modifier un élément du Tuple :

Par contre on peut concaténer deux Tuples :

On peut avoir un tuple de tuples :

en utilisant la commande range listant une suite arithmétique :

En utilisant une fonction mathématique :

A partir d’une chaîne de caractère qui est un cas particulier de liste :

Insertion à l’indice fixé :

modification d’un élément :

suppression d’un élément :

Trouver l’index d’un élément de la liste

copie et évacuation d’une liste :

recherche de l’index du maximum

Ajout d’un élément :

suppression d’un élément :

En ajoutant des paires clé :valeur à un dictionnaire existant :

En délimitant par deux accolades une séquence de paires clé : valeur :

copie d’un dictionnaire :

fusion de deux dictionnaires :

liste ⇄ chaîne de caractère :

Help on function volume_sphere in module main:

On importe toutes les fonctions :

on importe le module sans spécifier une fonction

Création à partir d’une séquence :

à partir d’un fichier texte

à partir d’une liste :

on rajoute une valeur en dernière position à un vecteur qui existe déjà :

suppression d’une valeur via son indice

redimensionnement d’un vecteur :

Concaténer deux vecteurs :