Introduction au langage python

I- Rappels de syntaxe

Télécharger la fiche d'introduction : Cliquer ici

Vous avez eu l'occasion lors de l'année de seconde de découvrir le langage python de façon superficielle.
Cette introduction vous permettra de vous les résumer rapidement

Affiche les rappels

Cacher les rappels

1- Variables

Une variable est une "boîte" dans laquelle on va stocker une donnée afin que le programme puisse y accéder au besoin.
Cela peut être le résultat d'un calcul, un numéro de téléphone, du texte, et même des images, de la musique...

Pour affecter la valeur 1789, à la variable revolution, il suffit décrire ceci:

revolution = 1789

2- Types

On l'a vu dans le chapitre précédent, il existe plusieurs façon d'écrire un nombre, selon qu'il soit entier ou décimal.
Ainsi un nombre entier aura le type int tandis qu'un nombre décimal aura le type float. Il est bien entendu possible d'attribuer le type float à un nombre entier, mais l'inverse aboutira à la troncature du nombre décimal :

float(10)
Out[1]: 10.0

int(2.35)
Out[2]: 2

On remarque que le passage d'un type int vers un type float se traduit par l'écriture d'un .0 à la fin du nombre.
C'est ainsi que a=10 affectera automatiquement le type int à a mais que a=10.0 affectera le type float.

Il y a d'autres types, notamment string pour les chaînes de caractère

3- Conditions

Les tests logiques vus au précédent chapitre peuvent être utilisés pour adapter le comportement d'un problème aux données qu'il reçoit.
Cela va se traiter avec la structure conditionnelle

if (condition) :
	...(instructions)
elif (condition) :
	...(instructions)
else :
	...(instructions)

Attention ! Le test d'égalité s'écrit a==b car le simple = est un opérateur d'attribution (il stockera la valeur de droite dans la variable de gauche).

4- Boucles

Lorsque l'on doit executer un certain nombre de fois un travail similaire, on peut utiliser une boucle. Il y a 2 types différents : while (condition): ("tant que") et for i in ... : ("pour").
Généralement, on utilise la boucle while lorsque l'on ne connaît pas à l'avance le nombre d'itérations, et la boucle for pour balayer un ensemble prédéterminé.
Dans les 2 cas, il n'est pas nécessaire que la condition porte sur des nombres.

Exemple :afficher tous les nombres entre 1 et 100

avec while	avec for
i=1 while i>101: print(i) i+=1	for i in range(1,101): print(i)

II- Les tuples, les listes et dictionnaires

Cliquer pour voir les activités de présentation :

Affiche tuples et listes

Cacher tuples et listes

1- Tuples et listes

a. Présentation

Ces 2 objets ont un fonctionnement proche : on accède à un élément en utilisant la syntaxe liste[n] et on détermine le nombre d'élément qui le composent avec len(liste).
En revanche un tuple s'écrira mon_tuple=(1,2,3) tandis qu'une liste s'écrira ma_liste=[1,2,3].
Enfin, un tuple est non mutable ce qui signifie que vous ne pourrez pas modifier ses éléments :

mon_tuple=(1,2,3)

mon_tuple[1]=0
Traceback (most recent call last):

  File "", line 1, in 
    mon_tuple[1]=0

TypeError: 'tuple' object does not support item assignment

b. Construire une liste

En dehors de l'attribution, il est possible de construire une liste par concaténation :

a=[1,2,3]+[4,5,6]

a
Out[6]: [1, 2, 3, 4, 5, 6]

Il est également possible d'utiliser .append():

a.append(7)

a
Out[8]: [1, 2, 3, 4, 5, 6, 7]

Il est possible de coupler ces méthodes avec une boucle :

Créer une liste contenant les 100 premiers multiples de 7
concaténation	avec .append()	en compréhension
multiples=[] for i in range(100): multiples+=[7*i]	multiples=[] for i in range(100): multiples.append(7*i)	multiples=[7*i for i in range(100)]

La dernière méthode est plus courte, mais tout à fait équivalente aux 2 autres.

c. Parcourir une liste/un tuple

Pour ne prendre en compte qu'une partie d'une liste, il suffit de le préciser dans les crochets :

a=[1,2,3,4,5,6,7,8,9]

a[2:7]
Out[12]: [3, 4, 5, 6, 7]

a[:8]
Out[13]: [1, 2, 3, 4, 5, 6, 7, 8]

a[5:]
Out[14]: [6, 7, 8, 9]

a[-3:-1]
Out[15]: [7, 8]

a[::-1]
Out[16]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

La première position correspond au point de départ et la seconde à la position suivant le dernier item. La troisième information indique le sens de lecture de liste, en indiquant [x:y:-1] on indique qu'on lit la liste à l'envers !
Ces commandes fonctionnent également avec les chaînes de caractères "! euqitarp sèrt tse'c te"

d. Effacer un terme

Pour effacer un(des) terme(s) d'une liste (ou la liste entière), on utilise la commande del.

a=[1,2,3,4,5,6,7,8,9]

del a[3]

a
Out[22]: [1, 2, 3, 5, 6, 7, 8, 9]

del a[3:5]

a
Out[24]: [1, 2, 3, 7, 8, 9]

del a[:]

a
Out[26]: []

del a

a
Traceback (most recent call last):

  File "", line 1, in 
    a

NameError: name 'a' is not defined

2- Les dictionnaires

Affiche les dictionnaires

Cacher les dictionnaires

a. Créer un dictionnaire

Comme vous l'avez découvert dans l'activité d'introduction, un dictionnaire a une structure différente de celle des listes. Les valeurs ne sont plus rangées en fonction d'un indice (valeur numérique entière) mais à l'aide de clés (chaîne de caractère).
Pour créer un dictionnaire, on peut soit le définir directement :

mon_dictionnaire={"age":36,"nom":"Duplant","prénom":"Christophe"}

mon_dictionnaire
Out[30]: {'age': 36, 'nom': 'Duplant', 'prénom': 'Christophe'}

soit ajouter des informations de façon plus classique :

mon_dictionnaire["telephone"]="0601020304"

mon_dictionnaire
Out[32]: 
{'age': 36,
 'nom': 'Duplant',
 'prénom': 'Christophe',
 'telephone': '0601020304'}

b. Parcourir un dictionnaire

Pour accéder à la valeur associée à une clé d'un dictionnaire :

mon_dictionnaire["nom"]
Out[33]: 'Duplant'

Pour avoir la liste de toutes les clés présentes dans un dictionnaire :

mon_dictionnaire.keys()
Out[34]: dict_keys(['age', 'nom', 'prénom', 'telephone'])

Pour afficher toutes les valeurs associées à chaque clé du dictionnaire :

for i in mon_dictionnaire.keys():
    print(i,mon_dictionnaire[i])
    
age 36
nom Duplant
prénom Christophe
telephone 0601020304

Pour savoir si une clé est présente dans le dictionnaire :

"prénom" in mon_dictionnaire.keys()
Out[36]: True

"voiture" in mon_dictionnaire.keys()
Out[37]: False

Faire la fiche 07 : cliquer ici

chaine1="0001111000001000010001000000101001001001100000000110100001011001001001010011001000100001000001111000"
chaine2="0011110001000010101001011000000110100101100110010100001000111100"

def assigne(image,largeur):
    hauteur=len(image)//largeur
    dummy=[]
    for ligne in range(hauteur):
        dummy.append([])
        for case in range(largeur) :
            
            dummy[ligne].append(int(chaine[case+ligne*(largeur)]))    
    return dummy

def affiche(tableau):
    for ligne in tableau:
        for case in ligne:
            if case:
                print ("░░",end="")
            else:
                print("██",end="")
        print("")

sortie=assigne(chaine1,8)
affiche(sortie)

III- Les modules

1- Présentation

Les modules permettent de réaliser certaines opération par défaut impossible ou d'éviter d'avoir à coder de nouveau certaines fonctions utiles.
On utilise par exemple régulièrement les modules math ou random.
Chaque module contient plusieurs fonctions que l'on pourra utiliser une fois le module importé.

import math

math.sin(math.pi/4)
Out[2]: 0.7071067811865476

Ici, seul le module est importé et il faut alors préciser que l'on appelle la fonction sin() du module math.

from math import sin,pi

sin(pi/4)
Out[4]: 0.7071067811865476

Dans ce cas, seules les fonctions indiquées sont importées, sans avoir à préciser le préfixe math..

Affiche les modules sur la calculatrice

Cacher les modules sur la calculatrice

2- Les modules sur calculatrice Numworks

Afin de pouvoir travailler avec des images, la calculatrice Numworks intègre le module kandinsky (cliquez pour accéder au manuel).
Ce module, très simple, permet de dessiner des points, du texte et des rectangles.

En utilisant votre calculatrice ou l'émulateur officiel, saisir le code suivant et l’exécuter :

from kandinsky import *
for i in range(256):
	for j in range(256):
		set_pixel(i,j,(i,j,511-(i+j)))

En vous basant sur ce script, ainsi que la documentation représenter les drapeaux français, italien et allemand

from kandinsky import *
def france():
  for i in range(320):
    for j in range(220):
      if i<(320/3):
        set_pixel(i,j,(0,0,255))
      elif i<(2*320/3):
        set_pixel(i,j,(255,255,255))
      else :
        set_pixel(i,j,(255,0,0))

def italie():
  for i in range(320):
    for j in range(220):
        if i<(320/3):
            set_pixel(i,j,(0,255,0))
        elif i<(2*320/3):
            set_pixel(i,j,(255,255,255))
        else :
            set_pixel(i,j,(255,0,0))
    
def allemagne():
  for i in range(320):
    for j in range(220):
        if j<(220/3):
            set_pixel(i,j,(0,0,0))
        elif j<(2*220/3):
            set_pixel(i,j,(255,255,0))
        else :
            set_pixel(i,j,(255,0,0))

Utiliser la fonction fill_rect(x,y,largeur,hauteur,(r,v,b)) pour faire la même chose, mais sans avoir à faire de boucle. Que remarquez-vous ?

from kandinsky import *
def rec_france():
  fill_rect(0,0,320//3,220,(0,0,255))
  fill_rect(320//3,0,2*320//3,220,(255,255,255))
  fill_rect(2*320//3,0,320,220,(255,0,0))

def rec_italie():
  fill_rect(0,0,320//3,220,(0,255,0))
  fill_rect(320//3,0,2*320//3,220,(255,255,255))
  fill_rect(2*320//3,0,320,220,(255,0,0))

def rec_allemagne():
  fill_rect(0,0,320,220//3,(0,0,0))
  fill_rect(0,220//3,320,2*220//3,(255,255,0))
  fill_rect(0,2*220//3,320,220,(255,0,0))

On remarque que l'affichage des drapeaux est quasi instantané cette fois.

A l’aide d’une boucle while( ) du type :
```
while True :
….commandes…
```
Dessiner un rectangle dont la couleur oscille du rouge (255,0,0) au vert (0,255,0).

from kandinsky import *
def oscillation():
	valeur=0
	while True:
		fill_rect(0,0,320,220,(255-valeur,valeur,0))
		valeur=(valeur+1)%256

On réalise une boucle sans fin qui va dessiner un rectangle initialement rouge (255,0,0) puis qui va évoluer vers le vert (254,1,0),(253,2,0),...,(0,255,0).
Pour ne pas dépasser la valeur 255 on utilise le modulo qui repassera valeur à 0 une fois que 256 sera atteint.

a. Écrire une fonction bouge(vitx,vity) qui dessine un rectangle se déplaçant à l’écran avec une vitesse verticale vity et une vitesse horizontale vitx
b. La fonction s’arrête lorsque le rectangle sort de l’écran
c. Le rectangle rebondit lorsqu’il "touche" le bord de l’écran

from kandinsky import *
def bouge1(vitx,vity,posx,posy):
    while True:
        fill_rect(posx,posy,10,10,(255,255,255))
        posx+=vitx
        posy+=vity
        fill_rect(posx,posy,10,10,(255,0,0))

a. La fonction bouge1 utilise comme paramètres d'entrée la vitesse selon x et y (vitx et vity) ainsi que la position initiale de l'objet (posx et posy).
Il execute ensuite une boucle qui ne s'arrête pas, qui commence par "effacer" le rectangle en dessinant un carré blanc à la place, puis incrémente la position en y ajoutant la vitesse et enfin dessine le rectangle à la nouvelle position.
On a alors la sensation que le rectangle s'est déplacé.

def bouge2(vitx,vity,posx,posy):
    while not(posx<0 or posy<0 or posx>(320-10) or posy>(220-10)):
        fill_rect(posx,posy,10,10,(255,255,255))
        posx+=vitx
        posy+=vity
        fill_rect(posx,posy,10,10,(255,0,0))

b. La fonction bouge2 est presque identique à bouge1 si ce n'est que la boucle while vérifie que le rectangle se dessine bien dans l'écran qui a une définition de 320 pixels en largeur et 220 en hauteur.
On arrête la fonction 10 pixels avant d'arriver à droite (320-10) ou en bas (220-10) afin que le rectangle s'arrête dès qu'il "touche" la bordure.

def bouge3(vitx,vity,posx,posy):
    while True:
        if posx<0 or posx>(320-10):
            vitx=-vitx
        if posy<0 or posy>(220-10):
            vity=-vity
        fill_rect(posx,posy,10,10,(255,255,255))
        posx+=vitx
        posy+=vity
        fill_rect(posx,posy,10,10,(255,0,0))

c. Ici la boucle ne s'arrête plus. En revanche 2 conditions sont ajoutées : lorsque le rectangle "touche" les bordures horizontales, il rebondit : on inverse alors vitx. De même avec les bordure verticale où l'on inverse vity.
On remarque que même avec des vitesses faibles (par exemple bouge3(1,1,10,10) où le rectangle ne se déplacera que d'1 pixel par boucle) le rectangle se déplace très vite. Pour le ralentir, il est dès lors nécessaire d'utiliser une temporisation pour le ralentir, d'où la question ci-dessous.

Utiliser les modules time et ion pour faire bouger le rectangle à l’aide du clavier de la calculatrice

from time import sleep
def bouge4(vitesse,vitx,vity,posx,posy):
    while True:
        if posx<0 or posx>(320-10):
            vitx=-vitx
        if posy<0 or posy>(220-10):
            vity=-vity
        fill_rect(posx,posy,10,10,(255,255,255))
        posx+=vitx
        posy+=vity
        fill_rect(posx,posy,10,10,(255,0,0))
        sleep(1/vitesse)

La fonction sleep(x) présente dans le module ion arrête la fonction pendant x seconde.
En ajoutant sleep(1/vitesse) on fait donc en sorte de rendre l'arrêt d'autant plus court que vitesse est grand.

from ion import *
def bouge5():
    posx,posy=160,110
    vitesse=3
    while True:
        if posx<0 or posy<0 or posx>(320-10) or posy>(220-10):
            print("Perdu !")
            return False
        fill_rect(posx,posy,10,10,(255,255,255))
        if keydown(KEY_LEFT):
            posx-=1
        if keydown(KEY_RIGHT):
            posx+=1
        if keydown(KEY_UP):
            posy-=1
        if keydown(KEY_DOWN):
            posy+=1
        if keydown(KEY_PLUS):
            vitesse+=1
        if keydown(KEY_MINUS):
            vitesse-=1
        fill_rect(posx,posy,10,10,(255,0,0))
        sleep(1/vitesse)

Le module ion contient la fonction keydown(touche) qui indique si la touche est en train d'être pressée.
Ici on choisit de ne modifier la position du rectangle que lorsque les touches de direction sont pressées. les touches "+" et "-" sont utilisées pour modifier la valeur de vitesse, comme dans la fonction bouge4().

La totalité des fonctions est présente sur mon espace Numworks : Cliquer ici.
Il vous suffit donc de connecter votre calculatrice à votre ordinateur pour y envoyer toutes les fonctions !

Affiche "Travailler avec des fichiers"

Cacher "Travailler avec des fichiers"

3- Manipuler des fichiers

a. Ouvrir/lire/écrire dans un fichier

On va pouvoir ouvrir un fichier en mode texte à l'aide de la fonction open()
Pour ouvrir le fichier mon_texte.txt se trouvant dans le dossier C:/python :

le_texte=open("C:/python/mon_texte.txt","a",encoding="utf-8")

le_texte
Out[2]: <_io.TextIOWrapper name='C:/python/mon_texte.txt' mode='a' encoding='utf-8'>

A partir de ce moment, le fichier mon_texte.txt est accessible par la variable le_texte.
Cependant on ne peut pas imprimer le texte ainsi. On peut l'afficher ligne par ligne :

le_texte=open("C:/python/mon_texte.txt","r",encoding="utf-8")

for i in le_texte:
    print(i,end="")
le_texte.close()

On termine toujours par la fermeture du fichier. La seonde option "r" signifie que l'on a ouvert le fichier en lecture : on ne pourra pas le modifier. S'il s'agit d'un fichier sensible, cela évite de faire des erreurs !
L'option "a" (append) permet d'ajouter du texte à la suite de ce qui est déjà présent dans le document. Enfin, l'option "w" efface le fichier et écrit les modifications

Le fichier mon_texte.txt contient la fable Le corbeau et le renard de Jean de La Fontaine. Une fois téléchargé et enregistré dans le répertoire c:\python, on souhaite éditer le texte et écrire toutes les voyelles en majuscule.

le_texte=open("C:/python/mon_texte.txt","r",encoding="utf-8")

texte=""
    for i in le_texte:
        ligne=""
        for lettre in i:
            ligne+=lettre
        texte+=ligne

le_texte.close()
  
for lettre in texte:
	if lettre in "aeiouy":
		texte_modifie+=chr(ord(lettre)-(97-65))
	else:
		texte_modifie+=lettre
            
le_nouveau_texte=open("C:/python/mon_texte_modifie.txt","w",encoding="utf-8")
le_nouveau_texte.write(texte_modifie)
le_nouveau_texte.close()

Si vous avez enregistré le fichier au bon endroit et que les droits en écriture ont été accordés par le système à votre interpréteur python, vous devriez voir apparaître un fichier mon_texte_modifie.txt dans lequel toutes les voyelles non accentuées ont été basculées en majuscules.
Ce que fait ce script :

Il ouvre le fichier mon_texte.txt, puis stocke chaque ligne successivement dans texte, (chaque ligne du fichier texte se termine par un caractère de fin de ligne). Le fichier est ensuite fermé.

On crée ensuite la chaîne texte_modifie qui comme son nom l'indique va accueillir le texte modifié.

on parcourt texte caractère par caractère. Si un caractère appartient à "aeiouy", c'est une voyelle minuscule : on la bascule donc en majuscule en modifiant son code ascii de 97-65, soit la valeur qui sépare le A du a dans la table ascii

on ajoute chaque caractère, modifié le cas échéant, dans texte_modifie

enfin ouvre le nouveau fichier mon_texte_modifie.txt avec l'attribut "w" : si le fichier n'existe as il sera créé, sinon il sera réécrit.

on y écrit la chaîne le_texte_modifie, puis on ferme

4- Se simplifier la vie avec le module tkinter

Il est parfois difficile ou rébarbatif d'écrire le chemin d'accès complet au fichier.
Cette fonction, utilisant le module tkinter pour faire apparaître une fenêtre de sélection vous simplifiera la vie !

from tkinter import filedialog,Tk

def fichier(action):
    popup=Tk()
    if action=="ouvrir":
        chemin_fichier =  filedialog.askopenfilename(initialdir = "./",title = "Select file")
    elif action=="enregistrer":
        chemin_fichier =  filedialog.asksaveasfilename(initialdir = "./",title = "Select file")
    else:
        chemin_fichier=False
    popup.destroy()
    return chemin_fichier

la fonction fichier(action) vous permet donc d'ouvrir ou de choisir où enregistrer votre fichier.
Pour l'exercice précédent (la fable du corbeau et du renard), il suffit donc d'écrire :

from tkinter import filedialog,Tk

def fichier(action):
    popup=Tk()
    if action=="ouvrir":
        chemin_fichier =  filedialog.askopenfilename(initialdir = "./",title = "Select file")
    elif action=="enregistrer":
        chemin_fichier =  filedialog.asksaveasfilename(initialdir = "./",title = "Select file")
    else:
        chemin_fichier=False
    popup.destroy()
    return chemin_fichier

with open(fichier("ouvrir"),"r",encoding="utf-8") as le_texte:
    texte=""
    for i in le_texte:
        ligne=""
        for lettre in i:
            ligne+=lettre
        texte+=ligne

texte_modifie=""
  
for lettre in texte:
    if lettre in "aeiouy":
        texte_modifie+=chr(ord(lettre)-(97-65))
    else:
        texte_modifie+=lettre
            
with open(fichier("enregistrer"),"w",encoding="utf-8") as le_nouveau_texte :
    le_nouveau_texte.write(texte_modifie)

Vous remarquez l'utilisation d'une nouvelle écriture : with ... as :.
Cette méthode permet de s'assurer que le fichier sera correctement fermé en fin de traitement, et il est donc recommandé de l'utiliser.

Affiche "Traiter des images"

Cacher "Traiter des images"

5- Traiter les images avec le module pillow

a. Charger une image

Remarque : Toute la partie sera traitée avec cette image. Enregistrez-là pour avoir les mêmes résultats que moi. (une barre de chocolat à qui en identifie le lieu).

Toute image est stockée numériquement sous forme binaire. Chaque format d'image a une façon particulière de s'écrire. Pour simplifier leur prise en charge, le module pillow va ouvrir l'image et l'interpréter sous la forme d'un tableau (x,y) dans lequel la couleur correspondant à chaque pixel sera présente. Pour l'utiliser avec la fonction fichier(action) écrite précédemment :

from PIL import Image

mon_image=Image.open(fichier("ouvrir"))

mon_image.size
Out[13]: (3968, 2976)

mon_image.getpixel((200,200))
Out[14]: (145, 150, 169)

mon_image.size donne les dimensions (x,y) de l'image, mon_image.getpixel((x,y)) indique le code couleur du pixel indiqué.
Enfin, mon_image.putpixel((x,y),(r,v,b)) coloriera le pixel de coordonnées (x,y) à la couleur (r,v,b).
mon_image.show() affichera l'image et mon_image.save("dossier/image.jpg") permettra de l'enregistrer. C'est l'extension (jpg,bmp,png) qui permettra à PIL de connaître la norme d'encodage dans laquelle il doit l'enregistrer, n'oubliez donc pas que jpg enregistre à perte !

b. Créer une image

PIL permet également de créer une image, en indiquant ses dimensions (largeur,longueur) ainsi que le type de couleur :

"1" pour une image en noir et blanc, chaque pixel prenant la valeur 0 ou 1.
"L" pour une image en niveaux de gris, chaque pixel prenant une valeur entière entre 0 (noir) et 255 (blanc)
"RGB" pour une image en couleur, chaque pixel prenant un tuple (r,v,b) chaque composante étant un nombre entier compris entre 0 et 255.

Pour créer une image en couleur de 1024 pixels de large par 768 pixels de haut, il faut écrire :

nouvelle_image=Image.new("RGB",(1024,768))

b. Modifier une image

Une fois l'image chargée par PIL, il est possible de la modifier en créant les fonctions dont vous avez besoin.

Dans tous les cas suivants, la fonction sera lancée avec fonction(Image.open(fichier("ouvrir")),arguments_supplémentaires).

a. Ecrire une fonction rectangle(image,x,y,largeur,hauteur,couleur) qui dessine un rectangle dont le coin supérieur gauche est aux coordonnées [x,y], des dimensions indiquées et de la couleur sous la forme d'un tuple (r,v,b).

def rectangle1(image,x,y,largeur,hauteur,couleur):
    for i in range(largeur):
        for j in range(hauteur):
            mon_image.putpixel((x+i,y+j),couleur)
    mon_image.show()
    return mon_image

b. Prendre en compte le fait que les dimensions puissent dépasser les dimensions de l'image. Trouver le moyen de ne pas faire planter le programme dans ce cas.

def rectangle2(image,x,y,largeur,hauteur,couleur):
    for i in range(min(largeur,mon_image.size[0])):
        for j in range(min(hauteur,mon_image.size[1])):
            mon_image.putpixel((x+i,y+j),couleur)
    mon_image.show()
    return mon_image

c. Sur le même modèle, écrire une fonction cercle(image,x,y,rayon,couleur)

def distance(xa,ya,xb,yb):
    return ((xa-xb)**2+(ya-yb)**2)**.5

def cercle(image,x,y,rayon,couleur):
    for i in range(max(0,x-rayon),min(x+rayon,mon_image.size[0])):
        for j in range(max(0,y-rayon),min(y+rayon,mon_image.size[1])):
            if distance(i,j,x,y)<=rayon:
                mon_image.putpixel((i,j),couleur)
    mon_image.show()
    return mon_image

Ecrire une fonction niveaux_de_gris(image) qui convertit une image en niveaux de gris

def niveaux_de_gris(image):
    nouvelle_image=Image.new('L',image.size)
    for i in range(image.size[0]):
        for j in range(image.size[1]):
            pixel_couleur=image.getpixel((i,j))
            #En faisant une moyenne naïve des couleurs
            pixel_gris=(pixel_couleur[0]+pixel_couleur[1]+pixel_couleur[2])//3
            #En prenant en compte le fait que l'oeil est plus sensible au vert, puis au rouge et enfin au bleu
            #il convient de donner un coefficient moins important au bleu
            #0,2126 × Rouge + 0,7152 × Vert + 0,0722 × Bleu
            #Cpixel_gris=int(0.2126*pixel_couleur[0]+0.7152*pixel_couleur[1]+0.0722*pixel_couleur[2])
            nouvelle_image.putpixel((i,j),pixel_gris)
    nouvelle_image.show()
    return nouvelle_image

Ecrire une fonction redim(image,facteur) qui redimensionne une image d'un facteur donné.
Ainsi redim(image,4) pour une image ayant une définition de 1024x768 retournerait une image de 1024/4=256px par 768/4=192px.

def somme_liste(liste1,liste2):
    sortie=[]
    for i in range(len(liste1)):
        sortie.append(liste1[i]+liste2[i])
    return sortie

def divise_entier_liste(liste,k):
    sortie=[]
    for i in range(len(liste)):
        sortie.append(int(liste[i]/k))
    return sortie

def redim(image,facteur):
    facteur=int(facteur)
    nouvelles_dimensions=(int(image.size[0]/facteur),int(image.size[1]/facteur))
    nouvelle_image=Image.new('RGB',nouvelles_dimensions)     
    for i in range(nouvelles_dimensions[0]):
        for j in range(nouvelles_dimensions[1]):
            pixel_moyen=[0,0,0]
            nombre=0
            for x in range(facteur):
                for y in range(facteur):
                    pixel_moyen=somme_liste(pixel_moyen,image.getpixel((facteur*i+x,facteur*j+y)))
                    nombre+=1
                    
            pixel_moyen=divise_entier_liste(pixel_moyen,nombre)
            nouvelle_image.putpixel((i,j),tuple(pixel_moyen))
    nouvelle_image.show()
    return nouvelle_image