Notions pratiques de Python

0. Généralités
Pas de caractère de fin de ligne.
En général, une seule instruction par ligne. Si plusieurs, le séparateur est le point virgule ;
Python est sensible à la casse (T et t désignent des variables différentes).
Pour insérer du commentaire : # commentaire (signe croisillon)
ou triple guillemets : ‘‘‘ commentaire ‘‘‘ OU ‘’ ‘’ ‘’ commentaire ‘’ ‘’ ‘’

1. Type des variables

Catégorie Type des variables
Python
int entier i = 2 # variable i interprétée comme étant de type entier
float nombre à virgule flottante a = 2.0 # variable i interprétée comme étant de type réel
str chaîne de caractères line = ‘bonjour‘ # var. line est une chaîne de caractères
bool variable logique (booléenne) pos = y > 0 # pos est du type logique (True ou False)
list Liste suite = [“a”, “b”, “c”] # suite est une liste
complex complexe z = 0. + 1j # la variable z est un imaginaire pur

1
 Notions pratiques de Python

2. Instructions
b = 1.0
c = 2.0 # Affectation de valeur aux variables b et c

a = b + c # On met dans la variable a le résultat de b + c

Attention : il s’agit d’une affectation, pas d’une égalité !

i = i + 1 # la nouvelle valeur de i est égale à l’ancienne plus 1

a + b = 3*x + c # Attention, ceci n’a aucun sens

Important : Attention à l’ordre des instructions !

a = b b = c
Exemple : b = c et a = b ne donneront pas les mêmes résultats.
print(a,b,c) print(a,b,c)

Sur l’écran : 1. 0 2.0 2. 0 2.0 2.0 2.0

print(a,b,c) # Écrit les valeurs de a, b, c

2
 Notions pratiques de Python

3. Listes
Une liste est une séquence de valeurs qui peuvent être de n’importe quel type (entier, réel, caractère, …)

ma_liste = [1,2.0,“toto”] # création de la liste

On peut faire une liste de listes (liste imbriquée).

On accède à un élément de la liste en utilisant l’opérateur [ ].
valeur_choisie = ma_liste[2]

print(valeur_choisie) # à l’écran on aura : ‘toto’

Attention : le premier élément est numéroté avec l’entier 0.

Sous-listes : on peut sélectionner plusieurs éléments en utilisant l’opérateur [m:n] où m et n sont des
entiers ou des expressions. Attention : m est inclu, n est exclu.
ma_sous_liste = ma_liste[0:2]

print(ma_sous_liste) # à l’écran on aura : [1,2.0]

on peut décider de sauter des éléments en écrivant [m:n:step]

print(ma_liste[0:3:2]) # à l’écran on aura : [1,‘toto’]

3
 Notions pratiques de Python

4. Fonctions natives, méthodes et modules

Il existe des fonctions natives prêtes à l’emploi telles que print(), type(), int(), min(), max(), …
print(len(ma_liste)) # on aura à l’écran : 3

Pour une liste de ces fonctions et leur définition : https://docs.python.org/fr/3.8/library/functions.html

Les méthodes sont des fonctions particulières permettant d’extraire une information d’un objet donné.
Utilisation d’une fonction : sortie1,…,sortieN = nom_fonction(entrée1, … , entréeP)
Utilisation d’une méthode : sortie1,…,sortieN = objet.nom_methode(entrée1, … , entréeP)

ma_liste.append(5) # ajout d’un élément (valeur 5 en dernière position)

print(ma_liste) # on aura à l’écran : [1,2.0,’toto’,5]
print(len(ma_liste)) # on aura à l’écran : 4

Les modules sont des bibliothèques de fonctions.

import math # pour pouvoir utiliser le module math
print(math.pi) # à l’écran : 3,141592653589793
math.sin(3 * math.pi /4) # à l’écran : 0,7071067811865476

ou de façon équivalente mais plus synthétique :

from math import * # pour importer toutes les fonctions du module math
sin(3*pi/4) # à l’écran : 0,7071067811865476

4
 Notions pratiques de Python

5. Faire un tableau à l’aide du module NumPy

Le plus simple pour créer un tableau est de convertir une liste en tableau : on peut utiliser la fonction
array() du module NumPy.

import numpy as np # on importe numpy et on le renomme

ma_liste = [2.0, 1.6, 3.4, 56.2, 4.8] # création de la liste
mon_tableau = np.array(ma_liste) # création du tableau
print(mon_tableau) # à l’écran : [ 2. 1.6 3.4 56.2 4.8]
print(type(mon_tableau)) # à l’écran : < class ‘numpy.ndarray’ >

On a un nouveau type d’objet (ou classe), numpy.ndarray, avec des fonctions (méthodes) et opérateurs
associés. Un objet a des attributs :
print(mon_tableau.ndim) # à l’écran : 1
print(mon_tableau.size) # à l’écran : 5
print(mon_tableau.shape) # à l’écran : (5,)
print(mon_tableau.dtype) # à l’écran : float64

On peut effectuer des opérations sur les tableaux. Exemple : print(mon_tableau/2)

# création de 2 tableaux
A = np.array([0, 5, 3]) ; B = np.array([2, 5, 1])
# somme terme à terme
print(A + B) # à l’écran : [ 2 10 4]

5
 Notions pratiques de Python

Quelques fonction utiles de NumPy pour créer un tableau dans un intervalle donné :
arange(début, fin, pas) : valeurs régulièrement espacées pour un pas donné
dans l’intervalle [début, fin[
A = np.arange(0, 5, 0.5) ; print(A)
# à l’écran : [0 , 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
linspace(début, fin, nombre d’éléments) : valeurs régulièrement espacées
pour un nombre d’éléments donné dans l’intervalle [début, fin]
B = np.linspace(0, 1, 6) ; print(B)
# à l’écran : [0. , 0.2, 0.4, 0.6, 0.8, 1.0]

Une routine pour créer un tableau d’éléments entre 2 bornes connues avec un pas fixe :
start = 0. # borne inférieure
end = 5.0 # borne supérieure
step = 0.5 # pas
interval = end – start # intervalle
num_points = int(interval / step) + 1 # nombre d'éléments
g = np.linspace(start, end, num_points) # tableau
# à l’écran : [0 , 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]

logspace(début, fin, nombre d’éléments) : valeurs régulièrement espacées

sur une échelle logarithmique
C = np.logspace(-2, 2, 5) ; print(C)
# à l’écran : [1.e-02 1.e-01 1.e+00 1.e+01 1.e+02]
6
 Notions pratiques de Python

6. Représentation graphique à l’aide du module matplotlib

On utilisera la fonction plot() du module matplotlib.pyplot
Pour représenter graphiquement une fonction, il est nécessaire de la discrétiser sur un ensemble de
points. Exemple pour la fonction sinus :
import numpy as np
import matplotlib.pyplot as plt
x_min = 0. # bornes de
x_max = 5 * np.pi # l’intervalle de représentation
pas = 0.1 # pas de discrétisation
intervalle = x_max – x_min
num_pts = int(intervalle / pas) + 1 # nombre de points
x = np.linspace(x_min, x_max, num_pts) # tableau contenant les abscisses
# création du tableau contenant l’image du tableau x par la fonction sinus
y = np.sin(x)
# création du graphique
plt.plot(x,y,’.’)
# options de mise en forme
plt.grid()
plt.title(‘fonction sin(x)’)
plt.xlabel(‘x (en radian)’)
plt.ylabel(‘sin(x)’)
plt.yticks([-1,-0.5,0.,0.5,1.0])
# visualisation
plt.show()
7
 Notions pratiques de Python

7. Conditions
if condition1 : # Passage à la ligne après les :
bloc d’instructions1 # On indente les instructions à exécuter si condition1 est remplie
elif condition2 :
bloc d’instructions2 # On indente les instructions à exécuter si condition2 est remplie
... # On peut faire autant de ’elif’ que désiré
else : # Dernier cas possible (pas besoin de ’if (condition)’)
dernier bloc d’instructions # On indente les instructions correspondantes
Instructions (suite du programme) # sortie du bloc conditionnel : instructions ne sont plus indentées

Exemple :
if y >= 0.0 :
z = sqrt(y) # Racine carrée de y (si y est positif ou nul)
print(‘racine carree ’, z)
else :
print(’y est negatif’)
print(‘Bye ...’)

Cas particulier : Lorqu’il n’y a qu’une seule instruction à exécuter pour une condition donnée,
on peut l’écrire sur une seule ligne :
if y >= 0.0 : print(‘racine carree ’, sqrt(y))

8
 Notions pratiques de Python

8. Opérateurs de comparaison et opérateurs logiques

opérateur description
x == y x est égal à y
x != y x n’est pas égal à y
x>y x est strictement supérieur à y
x<y x est strictement inférieur à y
x >= y x est supérieur ou égal à y
x <= y x est inférieur ou égal à y
and et
or ou
not contraire d’une expression logique

Remarque: l’expression y >= 0.0 est du type logique ; elle ne peut prendre que 2 valeurs :
True si y ≥ 0 et False si y < 0. On pourrait donc aussi écrire :
ok = (y >= 0.)
if ok :
z = sqrt(y)
else :
print(’y est negatif’)

9
 Notions pratiques de Python

9. Boucles
9.1 L’instruction while
while condition : # passage à la ligne après les deux points
bloc d’instructions # bloc à répéter tant que condition est vérifiée
# N. B. : on indente les instructions à répéter
n = 3
while n > 0 : 3
print(n) donne à l’écran : 2
n = n - 1 1
print(‘partez !’) partez !

Rq 1 : Attention, il existe un risque de boucle infinie (si la condition d’entrée est toujours vraie)
Rq 2 : Il existe une instruction break pour sortir d’une boucle while (à éviter)

9.2 L’instruction for

range(début, fin, pas) : crée une séquence de nombres entiers (immuables)
avec un pas donné dans l’intervalle [début, fin[
(valeurs par défaut : début vaut 0, pas vaut 1)

for i in range(début, fin, pas) : # passage à la ligne après les deux points
bloc d’instructions # on indente le bloc d’instructions à répéter

for i in range(3,0,-1) : n = 3 3
ou for i in range(n) : à l’écran : 2
print(i)
print(n-i) 1
print(‘partez !’)
print(‘partez !’) partez ! 10
 Notions pratiques de Python

Rq : Lorsque l’on connaît l’intervalle de variation de la quantité que l’on cherche à faire
varier, il est préférable d’utiliser une boucle finie (for plutôt que while).
Rq 2 : les indices de boucle (début, fin, pas) sont nécessairement de type entier. Donc
pour itérer sur des valeurs réelles, il faut créer des variables supplémentaires.
Exemple : on veut calculer x3 pour x variant entre -10 et 10 par pas de 0.1
x = -10.0
for i in range(1, 202, 1) : for i in range(-100, 101, 1) :
y = x**3 ou x = 0.1*i
x = x + 0.1 y = x**3

Les boucles peuvent être imbriquées les unes dans les autres :
for i in range(imax) :
...
for j in range(jmax) :
print(‘boucle 1 iteration ’,i, ‘boucle 2 iteration ’, j)
...
On peut boucler sur les indices d’une liste ou d’un tableau :
liste = [ [1,3,4,2], [1,4,6,2], [2,7,9,1] ]
for i in liste :
sum = 0.
for j in i :
sum = sum + j
print(‘la somme des éléments de ’,i, ‘ vaut ’, sum)

la somme des éléments de [1, 3, 4, 2] vaut 10.0

à l’écran : la somme des éléments de [1, 4, 6, 2] vaut 13.0
la somme des éléments de [2, 7, 9, 1] vaut 19.0 11
 Notions pratiques de Python

10. Fonctions
Créer une nouvelle fonction :
def nom_fonction(par1, par2, par3=“valeur_defaut”) :
””” docstring : description de la function ”””
... bloc d’instructions indentées
... return valeur1, valeur2

Appel de la fonction :
nom_fonction(para1, para2, para3)

Ex. : construction d’une fonction bsom(z) qui calcule le barycentre (1D) d’un ensemble z de réels
def bsom(z) :
s = 0.0
for i in range(1, size(z)+1) :
s = s + i*z[i-1]
res = s/sum(z)
return res
# appel de la fonction
b = bsom(z)
print(b)

Autre forme possible : Lambda (si la fonction est très simple) :

nom_fonction = lambda para : expression
carre = lambda x : x**2
# appel de la fonction
print(carre(5)) # à l’écran : 25
12
 Notions pratiques de Python

11. Entrées-sorties
Ouvrir, lire et fermer un fichier (ici le fichier s’appelle res.dat) :
file = open(’res.dat’, mode = ‘r’, encoding = ‘utf-8’)
print(file.read()) # On lit tout le fichier avec la méthode .read() sur la variable file
...
file.close() # fermeture du fichier (pour libérer la mémoire)

ou lecture ligne à ligne (ici, on affiche la ligne 13 du fichier) :

...
for i in range(12)
file.readline() # On ‘saute’ les 12 premières lignes
print(file.readline()) # on affiche la 13e ligne
...

Ecriture : file.write(‘hello world’)

Lire au clavier :
h = input(’entrer la hauteur \n’) # attention : variable h est une chaine de caractères
h = float(h) # conversion en réel
print(h)

Les formats :
x = 45,9876 ; n = 6
print(‘x = %5.3f, n = %d’ % (x, n) ) # réel avec 3 chiffres après la virgule, entier
print(‘x = %5.3e, n = %5d’ % (x, n) ) # réel en notation exponentielle, entier sur 5 caractères
x = 45,988, n = 6
à l’écran : X = 4,599e+01, n = 6

Plus d’info : https://pyformat.info/ 13

 Notions pratiques de Python

Pour importer les données d’un fichier texte dans un tableau Numpy, on peut utiliser la fonction
loadtxt(). Chaque ligne du fichier doit avoir le même nombre de valeurs. Les lignes commençant par
# ne sont pas lues.
import numpy as np
data = np.loadtxt(’res.dat’) # ici on importe dans une variable data

Si le fichier comportait 100 lignes et 2 colonnes, alors data sera un tableau Numpy (100, 2). Plutôt
que de créer un tableau 2D, il est possible de créer 2 tableaux 1D de 100 éléments contenant les
valeurs de chaque colonne avec l’argument unpack :
a, b = np.loadtxt(’res.dat’, unpack = True) # ici on importe dans 2 variables a et b

On peut sauvegarder les données d’un tableau Numpy dans un fichier en utilisant la fonction savetxt() :
np.savetxt('out.dat', np.c_[a, b], fmt = '%10.3e')

(ici on a utilisé la commande Numpy c_[] pour concaténer en colonnes les tableaux 1D)

14