Utilisation de Python

Python est un langage de haut niveau doté qui peut être augmenté de nombreuses fonctions de calcul scientifique et de traitement d’images. Dans ces TP, vous utiliserez des notebooks qui permettent de faire de la « programmation lettrée », mélangeant ainsi du code (Python) et des éléments de texte.

Vous pouvez utiliser VSCode ou Jupyter Lab Pour créer un notebook Python. Pour exécuter Jupyter Lab, tapez dans un terminal : jupyter lab ou jupyter-lab.

Écrire un notebook

Un notebook est un fichier contenant du code, mais aussi des commentaires pour expliquer ce code ou les résultats qu’il a produit. Un notebook est divisé en cellules, qui sont de deux types :

• les cellules de type « Code » ne contiennent que du code (Python par exemple) ;

• les cellules de type « Markdown » contiennent du texte mis en forme. En appuyant sur Ctrl+Entrée sur une cellule, le code de cette cellule (et uniquement celle-ci !) est exécuté.

Warning

Il est parfois nécessaire d’exécuter toutes les cellules du notebook, par exemple pour exécuter entièrement votre programme après plusieurs modifications ou si le notebook a été renommé ou déplacé dans un autre dossier.

Pour exécuter tous les notebooks et réinitialiser la mémoire, cliquez sur le menu Restart kernel and run all cells (Jupyter Lab) ou Run All (VSCode).

Cellules « Code »

Par défaut, les cellules sont sensées contenir du code. Elles sont divisées en une entrée (les instructions Python) et une sortie (le résultat).

Par exemple, l’entrée suivante :

a = 21
b = 42
c = a + b
print("La valeur est " + str(c))

Renvoie cette sortie :

La valeur est 63

Cellules « Markdown »

Vous pouvez changer le type d’une cellule en choisissant Markdown dans la liste déroulante de la barre d’outils (Jupyter Lab) ou en cliquant sur Python dans l’angle en bas à droite de la cellule (VSCode). Markdown est un langage très simple pour formater du texte (par exemple, écrire des titres, des listes ou des équations).

Par exemple :

La _convolution_ entre **deux** images $f$ et $g$ est définie comme suit :

$$
(f*g)(m,n) = \sum_u \sum_v f(u,v) g(u-m,v-n)
$$

Donne :

La convolution entre deux images \(f\) et \(g\) est définie comme suit :

\[ (f*g)(m,n) = \sum_u \sum_v f(u,v) g(u-m,v-n) \]

Veuillez consulter cette aide pour apprendre la syntaxe Markdown.

Écrire du code

Pour faire du calcul scientifique avec Python, il faut importer des modules. En général, nous utiliserons les trois modules suivants :

• numpy, qui fournit des fonctions pour le calcul scientifique général ;

• scikit-image qui est un ensemble d’algorithmes pour le traitement d’images ;

• matplotlib, qui permet d’afficher des images.

Les modules Python sont importés dans votre code à l’aide de l’instruction import.

Par exemple, le code suivant ouvre une image, la convertit en niveaux de gris et affiche les deux versions :

# Ceci est un commentaire et n'est donc pas exécuté
# Les commentaires commencent avec un #

# Importe le sous-module 'io' du module 'skimage' (scikit-image),
# et le renomme 'io' (pour éviter de taper 'skimage.io'
# à chaque fois qu'on en a besoin)
import skimage.io as io

# Importe le sous-module 'color' du module 'skimage' et le renomme 'clr'
import skimage.color as clr

# Importe le sous-module 'pyplot' du module 'matplotlib' et le renomme 'plt'
import matplotlib.pyplot as plt

# La fonction 'imread' qui est dans 'skimage.io' charge une image
# à partir de son nom de fichier
f = io.imread("_static/peppers.png")

# Convertit l'image couleur f en image à niveau de gris g
g = clr.rgb2gray(f)

# Crée une figure et la divise en 1 ligne et 2 colonnes :
# chaque division ainsi constituée est un axe où seront affichées les images
fig, axs = plt.subplots(1,2)

# Affiche l'image couleur f avec la fonction 'imshow' (de 'matplotlib.pyplot')
# dans le premier axe (indice 0)
axs[0].imshow(f)

# Affiche l'image à niveaux de gris g dans le deuxième axe (indice 1)
axs[1].imshow(g, cmap="gray")

# Affiche l'image g
plt.show()

Pour les utilisateurs de Matlab

Python, grâce au module Numpy, est très similaire à Matlab. Ces deux langages fonctionnent avec des scripts et leurs fonctions sont très similaires. Il existe cependant des différences majeures, listées ci-après.

Modules

Python est conçu pour être un langage de programmation généraliste. Contrairement à Matlab, il ne contient que très peu de fonctions scientifiques de base. Il faut donc le compléter avec des modules comme Matplotlib ou Numpy. Par exemple, Numpy est chargé avec :

import numpy as np

Les fonctions dans Numpy sont ensuite accessibles avec np.nom_de_la_fonction.

Vecteurs et matrices

Alors que Matlab utilise des parenthèses pour les vecteurs et les matrices, Python utilise des crochets. De plus, le premier élément dans Matlab est à l’indice 1, tandis qu’en Python, il est à l’indice 0.

Matlab	Python
a(1)	a[0]
B(3,5)	B[2,4]

Point-virgule

En Python, il n’y a pas de point-virgule (;) à la fin des instructions.

Pour aller plus loin…

Pour aller plus loin, vous pouvez consulter cet aide-mémoire ou cet article sur Numpy.