- Introduction
- Le mode interactif
- Variables et affectations
- Programmation et fonctions
- Structure conditionnelle
- Boucles non bornées
- Les listes
- Boucles bornées
- Lire et écrire dans un fichier
- Application en SNT (en seconde)
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 :
- Pour n'utiliser que les fonctions dont on a besoin :
from random import shuffle, randrange alea = randrange(1,7) - Pour pouvoir tout utiliser :
from random import * alea = randrange(1,7) - Dans ce dernier cas, si on importe plusieurs modules, il y a un risque pour qu'ils définissent deux choses différentes sous le même nom. On préfère alors préfixer ce qui est issu d'un module par le nom du module :
import random alea = random.randrange(1,7) - Dans ce cas, on peut re-définir localement le nom d'un module pour raccourcir les écritures :
import random as rnd alea = rnd.randrange(1,7)
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.
forwardetbackwardd'un paramètred: avancer / reculer de d pixelsleftetrightd'un paramètrea: tourner à gauche / à droite de a degrésdone: 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...

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

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.
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 :
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.

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 :
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).

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 :

- 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.


- 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