Calcul Numérique en Mécanique
Python
R. Mozul & L. Daridon
Université de Montpellier - CNRS
2021
1/ 15
Sommaire
Introduction
Affectation, type et opérations
Structure conditionnelle
Structure répétitive
Fonctions et portées des variables
Séquences
Notions d’objets
Importation de Modules
Fichiers
2/ 15
Introduction
Créé par Guido Von Rossum en 1991
Multi-plateforme, libre et gratuit
Géré par la Python Software Foundation
Nombreuses contributions de la communauté
3/ 15
Affectation et type
Syntaxe variable = valeur
Le membre de droite est évalué avant celui de gauche
4/ 15
Affectation et type
Syntaxe variable = valeur
Le membre de droite est évalué avant celui de gauche
variable peut contenir lettres, chiffres et
4/ 15
Affectation et type
Syntaxe variable = valeur
Le membre de droite est évalué avant celui de gauche
variable peut contenir lettres, chiffres et
variable ne peut pas commencer par un chiffre
4/ 15
Affectation et type
Syntaxe variable = valeur
Le membre de droite est évalué avant celui de gauche
variable peut contenir lettres, chiffres et
variable ne peut pas commencer par un chiffre
variable n’est pas typée
4/ 15
Affectation et type
Syntaxe variable = valeur
Le membre de droite est évalué avant celui de gauche
variable peut contenir lettres, chiffres et
variable ne peut pas commencer par un chiffre
variable n’est pas typée
valeur est typée
4/ 15
Affectation et type
>>> a = 12
>>> a 1 2 b = a
>>> a = 12
>>> 12A = 1 2 .
>>> 12 a = 12
F i l e ”<s t d i n >” , l i n e 1
12 a = 12
ˆ
SyntaxError : i n v a l i d syntax
>>> a = ’ t o t o r ’
>>> a = 12
>>> b = 1 2 .
>>> t y p e ( a )
<c l a s s ’ i n t ’>
>>> t y p e ( b )
<c l a s s ’ f l o a t ’>
>>> i s i n s t a n c e ( a , i n t )
True
>>> i s i n s t a n c e ( b , i n t )
False
>>> a == b
True
>>> a i s b
False
5/ 15
Type et opérateur
Types numériques : int float complex
Opérations classiques + - * / **
6/ 15
Type et opérateur
Types numériques : int float complex
Opérations classiques + - * / **
Opérations courante // %
6/ 15
Type et opérateur
Types numériques : int float complex
Opérations classiques + - * / **
Opérations courante // %
Opérations booléennes not or and in
6/ 15
Type et opérateur
Types numériques : int float complex
Opérations classiques + - * / **
Opérations courante // %
Opérations booléennes not or and in
Comparaisons == ! = < > <= >=
6/ 15
Type et opérateur
Types numériques : int float complex
Opérations classiques + - * / **
Opérations courante // %
Opérations booléennes not or and in
Comparaisons == ! = < > <= >=
Utilisation des parenthèses pour contrôler les priorités
6/ 15
Type et opérateur
Types numériques : int float complex
Opérations classiques + - * / **
Opérations courante // %
Opérations booléennes not or and in
Comparaisons == ! = < > <= >=
Utilisation des parenthèses pour contrôler les priorités
L’expression est évaluée de gauche à droite
6/ 15
Type et opérateur
>>> c = 2∗a∗∗2 + 3
>>> c // a
24
>>> c%a
3
>>> d = ( c +5) ∗ b
>>> d < a
False
>>> ( d < a ) and ( a == b )
False
7/ 15
Structure conditionnelle
Exécute des instructions en fonction de la valeur d’un test
Syntaxe avec le mot clef if test :
Le bloc d’instructions suivant doit commencer par des espaces
En général 4 espaces
Le nombre d’espaces doit être constant pour toute les lignes
du bloc
>>> i f c%5 == 0 :
... p r i n t ( c , ” e s t d i v i s i b l e par 5” )
. . . e l i f c%5 == 1 :
... p r i n t ( c , ”−1 e s t d i v i s i b l e p a r 5 . . . ” )
. . . else :
... p r i n t ( c , ” nous f a i t s u e r ! ” )
Exercice : se donner deux variables a et b et échanger leur contenu
si a > b
8/ 15
Structure répétitive
Pour répéter un bloc d’instructions il faut faire des ”boucles”
while, tant qu’une condition est vérifiée
for, un certain nombre de fois
La boucle for va de paire avec les séquences (en fait avec les
itérateurs).
break permet de quitter la boucle en cours
continue permet de passer à l’itération suivante
range(n) permet de générer la séquence des n premiers entiers
naturels
n = 12
f o r i i n range ( n ) :
print ( i )
s = range ( n //2)
for k in s :
i f k%2 == 0 :
p r i n t ( f ”{k} e s t p a i r ” )
Exercice : Trouver si un nombre n est premier 9/ 15
Fonctions et portées des variables
Réutiliser des blocs d’instructions de manière paramétrées
Attention à la portée des variables
def func ( args ) :
c = a r g s+a r g s
return c
val = func ( ’ bla ’ )
def f2 ( args ) :
r e t u r n a r g s+v a l
val = f2 ( ’ blu ’ )
Exercice : Faire une fonction qui test si un nombre est premier et
la tester pour plusieurs valeurs
Exercice : Essayer de faire une fonction qui échange deux valeurs
10/ 15
Séquences
Séquence indexées par des entiers naturels:
les chaı̂nes de caractères du type str
les listes du type list
les objets de la classe tuple (∼ liste figée)
s1 = ” t o t o r ”
s2 = ’ S u p e r c a l i f r a g i l i s t i c e x p i a l i d o c i o u s ’
f o r c i n s2 :
print (c)
f o r i i n range ( l e n ( s1 ) ) :
p r i n t ( i , s1 [ i ] )
l1 = [1 , 3 , 5]
l2 = [ ]
l 2 . append ( 1 3 )
l2 . extend ( l1 )
l2 [ 2 ] = 3.14
print ( l2 )
Remarque : les listes et tuples peuvent contenir des données
hétérogènes
Exercice : Ecrire une fonction qui trie une liste d’entiers 11/ 15
Séquences
Les dictionnaires sont
des listes
non ordonnées
indéxées par autre chose qu’une liste d’entiers consécutifs
a n n u a i r e = { 1 2 3 4 : ’ Remy ’ ,
6222: ’ Loic ’ ,
}
annuaire [ 2 ] = ’ Loic ’
for i in annuaire :
print ( i )
for n in annuaire . values ( ) :
print (n)
annuaire [1234] = 3.14
12/ 15
Notions d’objets
Les objets/instances sont :
d’un type complexe appelé une classe
souvent composés d’autres objets appelés attributs
fournit des fonctions appelées méthodes qui travaillent sur ses
attributs
l’opérateur de résolution est .
>>> l = [ i f o r i i n r a n g e ( 1 2 ) ]
>>> t y p e ( l )
<c l a s s ’ l i s t ’>
>>> l . r e v e r s e ( )
>>> p r i n t ( l )
>>> l . s o r t ( )
>>> p r i n t ( l )
13/ 15
Importation de Modules
Un module renferme la définition:
de classe
de variables
de fonctions
que l’on souhaite utiliser dans l’espace de nommage courant.
i m p o r t math
p r i n t ( math . p i )
p r i n t ( math . s i n ( math . p i / 4 . ) )
i m p o r t numpy a s np
a = np . a r r a y ( [ 1 , 2 , 3 , 4 ] )
from m a t p l o t l i b i m p o r t p y p l o t a s p l t
help ( p l t )
Exercice :
Mettre les fonctions dans tri de liste et test de primalité dans
un fichier
Utiliser ce fichier comme un module dans un script principal
qui:
Génère une liste d’entier aléatoire
Extrait les nombres premiers de cette liste 14/ 15
Fichiers
Il faut ’ouvrir’ un fichier pour le récupérer comme un objet.
Le mode d’ouverture peut être:
en lecture : ’r’
en écriture : ’w’ (en écrasant le contenu précédent)
en ajout : ’a’ (en ajoutant à la fin du fichier)
w i t h open ( ’ l o o p . py ’ , ’ r ’ ) a s f :
for l in f . readlines ():
p r i n t ( l , end= ’ ’ ) :
15/ 15