Introduction au langage Python

Utilisation de modules

Un module est un fichier qui contient des collections de variables et de fonctions prêtes à l'emploi

Par exemple, le module random contient (entre autres) les fonctions randrange et shuffle.

On peut utiliser un module de plusieurs façons différentes :

Exercice En utilisant la fonction cos et la variable pi du module math, faire afficher une valeur approchée de $\cos(\frac{\pi}{7})$.

Par exemple :

from math import cos, pi
print(cos(pi/7))
Documentation : docs.python.org/3/library/math.html

Exercice En utilisant la fonction Fraction du module fractions (pour pouvoir écrire Fraction(1,3) la fraction $\frac{1}{3}$), faire afficher le résultat exact de la somme $\frac{1}{3}+\frac{1}{6}$.

Par exemple :

from fractions import Fraction # Attention au 's' et à la majuscule
print(Fraction(1,3)+Fraction(1,6))
Documentation : docs.python.org/fr/3/library/fractions.html

Exercice Le module turtle définit (entre autres) les fonctions suivantes.

  • forward et backward d'un paramètre d : avancer / reculer de d pixels
  • left et right d'un paramètre a : tourner à gauche / à droite de a degrés
  • done : terminer la figure.

Proposer un programme pour dessiner un carré en utilisant ce module.

Par exemple :

from turtle import *
for i in range(4):
    forward(100)
    left(90)
done()
Documentation : docs.python.org/fr/3/library/turtle.html

Il existe des modules pour tout faire en python, mais il faut les installer...

installer un module avec edupython
Ou en ligne de commande :
python -m pip install sympy
Puis :

>>> from sympy import *
>>> x=symbols('x')
>>> y=symbols('y')
>>> expand((x+y)**2)
x**2 + 2*x*y + y**2
>>> factor(x**2-5*x+4)
(x - 4)*(x - 1)
Documentation : docs.sympy.org/latest/tutorials/intro-tutorial/index.html

Traitement de l'image

Le module pillow

logo pillow

Un module a été développé pour le traitement des images : Python Imaging Library (ou PIL). Il permettait d'ouvrir, de manipuler, et de sauvegarder différents formats de fichiers graphiques.

Plus maintenue depuis 2009, une version dérivée, a pris le relais sous le nom Pillow

Pour installer ce module, on écrit logiquement :

python -m pip install pillow

Mais son utilisation, dérivée de PIL, se fait ainsi :

from PIL import Image

Documentation : https://pillow.readthedocs.io/en/stable/index.html

Prise en main : image matricielle

Une image matricielle est composée d'une juxtaposition de pixels, repérés selon leurs numéros de colonne et de ligne dans l'image, c'est-à-dire, selon un repère orthonormé, d'origine le pixel en haut à gauche, avec un axe des abscisses vers la droite et un axe des ordonnées vers le bas.

pixel dans une image matricielle

Pour la suite, on choisit de travailler sur une image noire (par défaut), carrée, de 256 pixels de côté (mode RGB expliqué plus bas) :

from PIL import Image

# Création de l'image :
image = Image.new(mode='RGB', size=(256,256))

# Dessin du pixel de coordonnées (2;3) en blanc :
image.putpixel( (2,3), (255,255,255))

# Affichage de l'image par le logiciel par défaut :
image.show()

Exercice Produire les dessins suivants :

image noire avec une ligne horizontale image noire avec une ligne verticale image noire avec une ligne diagonale descendante image noire avec une ligne diagonale montante

Pour l'horizontale :

from PIL import Image

# Création de l'image :
image = Image.new(mode='RGB', size=(256,256))

for x in range(256):
    image.putpixel( (x,128), (255,255,255) )

# Affichage de l'image par le logiciel par défaut :
image.show()

Le mode RGB

Il s'agit d'un codage possible des couleurs. On donne en synthèse additive l'intensité des primaires Rouge (Red), Verte (Green) et Bleue (Blue).

Chaque primaire étant encodée sur 8 bits (un octet), elles sont graduées de 0 à 255.

cube de couleurs RVB (creux) cube de couleurs RVB (plein)

Les couleurs primaires : (255,0,0) (0,255,0) (0,0,255)

Les nuances de gris : (0,0,0) ... (128,128,128) ... (255,255,255)

Dégradé de rouge : (0,0,0) (255,0,0) (255,255,255)

Exercice Produire les dessins suivants :

image avec un dégradé horizontale image avec un dégradé verticale image avec un dégradé selon la première diagonale image avec un dégradé selon la seconde diagonale

Pour le premier dégradé :

from PIL import Image

# Création de l'image :
image = Image.new(mode='RGB', size=(256,256))

for x in range(256):
    for y in range(256):
        image.putpixel( (x,y), (x,0,0) )

# Affichage de l'image par le logiciel par défaut :
image.show()

Avec une vraie image

Pour la suite, on a besoin d'une image à manipuler. Enregistrez l'image ci-dessous dans votre dossier de travail (celui contenant votre fichier python).

une photo de myosotis

Pour vérifier que tout fonctionne, le code suivant, devrait afficher des informations sur l'image (taille, mode des couleurs et couleur d'un pixel) :

from PIL import Image

with Image.open('myosotis.png') as image:
    print(image.size)
    print(image.mode)
    print(image.getpixel( (50,150) ))

Pour les exercices suivants, on pourra partir du code suivant, qui isole le canal rouge d'une image.

from PIL import Image

def couleur_modif(image_src):
    """ Modifie les couleurs de l'image, pixel par pixel """
    dimx, dimy = image_src.size
    image = Image.new(image_src.mode, image_src.size)
    for x in range(dimx):
        for y in range(dimy):
            r, v, b = image_src.getpixel((x, y))
            modif_r = r
            modif_v = 0
            modif_b = 0
            image.putpixel((x, y), (modif_r, modif_v, modif_b))
    return image

with Image.open('myosotis.png') as image:
    image_modif = couleur_modif(image)
image_modif.show()

Exercice Produire les images suivantes :

  • En nuances de gris :
L'image en nuances de gris
  • En négatif :
L'image en négatif
  • Contrasté en modifiant chaque composante couleur C (= R, V ou B) par suit :
    • Pour $C < 30$, on ramène $C$ à $0$.
    • Pour $30\leqslant C \leqslant 225$, $C$ devient $\frac{255}{195}(C-30)$.
    • Pour $C>225$, on passe $C$ a 255.
courbe de contraste
L'image contrastée
  • En nuances de gris :

Il suffit de mettre la même valeur pour chaque canal. On peut imaginer mettre la moyenne des trois :

            modif_r = (r+v+b)//3
            modif_v = (r+v+b)//3
            modif_b = (r+v+b)//3

Mais c'est plus "joli" avec la formule :

            modif_r = int(0.2126*r+0.7152*v+0.0722*b)
            modif_v = int(0.2126*r+0.7152*v+0.0722*b)
            modif_b = int(0.2126*r+0.7152*v+0.0722*b)
  • En négatif :
            modif_r = 255-r
            modif_v = 255-v
            modif_b = 255-b
  • Contrasté en modifiant chaque composante couleur C (= R, V ou B) par les formules :
            modif_r = contraste(r)
            modif_v = contraste(v)
            modif_b = contraste(b)

en ajoutant la fonction de contraste :

def contraste(c) :
    if c < 30 :
        modif_c = 0
    elif c <= 225 :
        modif_c = int((c-30)*255/195)
    else :
        modif_c = 255
    return modif_c

Navigation