4 - Boucle Pour

⏪

⏬

⏩

1 - Cours

2 - Exercices

3 - turtle

4 - Application à la photographie numérique

5 - Py-rates

6 - FAQ

Voyons maintenant comment réaliser des actions similaires sans avoir à faire trop de copier-coller.

Comment ?

En utilisant des boucles bien entendu.

Les boucles bornées avec Scratch

Nous allons voir comment faire comprendre cela à l'interpréteur Python.

Vous auriez vraiment envie de faire cela en donnant vous même les coordonnées de chacun de ces segments ?

IDE Python proposé : Thonny

Documents de cours : pdf ou odt.

MODE COURS (cacher les questions)

1 - Découverte du cours, pas à pas

⇩ ⇧ ⤊

✔ Intro A (Mise en place)° Réaliser les actions suivantes :

Ouvrir Thonny. Réduire la fenêtre de Thonny et de votre navigateur Web pour que chaque fenêtre occupe la moitié de l'écran.
Ouvrir votre dossier/répertoire personnel. Créer dans le dossier SNT un nouveau sous-dossier qu'on nommera python04.
Sur Windows : vérifier via le menu affichage de votre explorateur de dossiers que vous avez bien coché la case "Afficher les extensions".

✔ Intro B° Placer ce programme dans la zone de programmation. Sauverger sous le nom boucle.py. Lancer. Il permet d'afficher 5 fois la même séquence de message.

texte = "J'aime bien les copier coller !"
texte2 = "Oui, oui."
 
print(texte)
print(texte2)
print(texte)
print(texte2)
print(texte)
print(texte2)
print(texte)
print(texte2)
print(texte)
print(texte2)

J'aime bien les copier coller !
Oui, oui.
J'aime bien les copier coller !
Oui, oui.
J'aime bien les copier coller !
Oui, oui.
J'aime bien les copier coller !
Oui, oui.
J'aime bien les copier coller !
Oui, oui.

Cela fonctionne bien. Mais si on veut le faire un million de fois, avez-vous envie de faire autant de copier-coller que cela ?

✔ Intro C° Utilisez ce nouveau programme en utilisant la flèche verte dans Thonny.

texte = "J'aime bien les copier coller !"
texte2 = "Oui, oui."
 
print("C'EST PARTI !")
 
for _ in range(5):
    print(texte)
    print(texte2)
 
print("FINI !")

>>> %Run prog_boucle.py
  C'EST PARTI !
  J'aime bien les copier coller !
  Oui, oui.
  J'aime bien les copier coller !
  Oui, oui.
  J'aime bien les copier coller !
  Oui, oui.
  J'aime bien les copier coller !
  Oui, oui.
  J'aime bien les copier coller !
  Oui, oui.
  FINI !

Questions-réponses

Où signale-t-on à Python qu'on veut agir 5 fois en boucle ? En ligne 6.

`6`	`for _ in range(5):`

Que trouve-t-on à la fin de la ligne de déclaration du for , la ligne 6 ? Python attend TOUJOURS le caractère :.
Qu'est-ce qui semble indiquer à Python que les instructions des lignes 7-8 sont à réaliser en boucle ? Les deux lignes 7-8 sont décalées de 4 espaces EXACTEMENT. Ce décalage se nomme la TABULATION.

7
8

␣␣␣␣print(texte)
␣␣␣␣print(texte2)

✔ Intro D° Observer bien la ligne 5 : print("Fini !").

texte = "J'aime bien les copier coller !"
texte2 = "Oui, oui."
 
print("C'EST PARTI !")
 
for _ in range(5):
    print(texte)
    print(texte2)
 
print("FINI !")

QCM : comment Python a-t-il compris que cette ligne n'appartenait pas à la boucle ?

C'est un coup de chance !
C'est parce qu'on n'utilise plus le décalage de 4 espaces.
C'est parce qu'on ne peut faire que deux instructions en boucle
C'est à cause de la ligne 9 qui est vide.

La réponse est bien entendu la réponse B : C'est parce qu'on est revenu sur la même colonne que le for, elle n'est pas décalé de 4 espaces.

✔ Intro E° Poursuivre dans votre tête la séquence de lignes proposées si dessous : il s'agit des lignes suivies par l'interpréteur lorsqu'il tombe sur ce programme, plus court :

texte = "J'aime bien les copier coller !"
print("C'est parti !")
 
for _ in range(3):
    print(texte)
 
print("Fini !")

L01 - L02

L04(1^er tour)-L05 - ...

Vérifiez votre solution en cliquant sur la solution ci-dessous.

Correction ?

...CORRECTION...

texte = "J'aime bien les copier coller !"
print("C'est parti !")
 
for _ in range(3):
    print(texte)
 
print("Fini !")

L01 - L02

L04(1^er tour)-L05

L04(2^e tour)-L05

L04(3^e tour)-L05

L07 - fin

Mais, on peut faire bien mieux que faire exactement la même chose à chaque tour de boucle : on peut faire presque la même chose à chaque tour de boucle.

✔ Intro F° Nous allons maintenant donner un vrai nom à la variable de boucle située entre le for et le in. Ici, nous utiliserons k par exemple. Lancer ce nouveau programme.

print("C'est parti !")
 
for k in range(10):
    print(k)
 
print("Fini !")

>>> %Run prog_boucle.py
  C'est parti !
  0
  1
  2
  3
  4
  5
  6
  7
  8
  9
  Fini !

Questions-réponses

Combien de boucles ont été réalisées ? 10.
Quelle est la première valeur prise par la variable de boucle v ? 0.
Quelle est la dernière valeur prise par la variable de boucle v ? 9.

Attention donc : nous retrouvons l'histoire du décalage à cause du fait qu'on commence 0. Si vous notez range(4), vous allez bien faire 4 tours de boucle mais la variable de boucle prendra les valeurs 0,12,3.

✔ Intro G° Compléter dans votre tête la séquence des lignes suivies par l'interpréteur. Vérifiez ensuite avec la correction.

print("C'est parti !")
 
for v in range(4):
    print(v * 100)
 
print("Fini !")

L01

L03(v=0)-L04(affiche 0) - ...

Correction ?

...CORRECTION...

print("C'est parti !")
 
for v in range(4):
    print(v * 100)
 
print("Fini !")

L01

L03(v=0)-L04(affiche 0)

L03(v=1)-L04(affiche 100)

L03(v=2)-L04(affiche 200)

L03(v=3)-L04(affiche 300)

L06 - fin

Si vous êtes en TP, passez directement à la partie 2 suivante, sans lire les deux bilans ci-dessous : ils seront analysés oralement à la fin du TP.

1.1 Boucle POUR : réaliser plusieurs fois EXACTEMENT la même action

Voir

A - Principe

Pour réaliser plusieurs fois exactement la même série d'actions, il suffit d'utiliser une boucle bornée POUR, qu'on déclare à l'aide du mot-clé for en Python.

B - Exemple

print("Avant boucle")       # Pas tabulée : avant la boucle
 
for _ in range(3):          # Déclaration de la boucle
    print("A")              # Tabulée : dans la boucle
    print("-- B")           # Tabulée : dans la boucle
 
print("Après boucle")       # Pas tabulée : avant la boucle

Déroulé du programme

L1
L3 - L4 - L5
L3 - L4 - L5
L3 - L4 - L5
L7

Résultat du programme


Avant boucle
A
-- B
A
-- B
A
-- B
Après boucle

C - Sémantique

`3`	`for _ in range(3):`

Traduction en français : "Réalise 3 fois le bloc d'instructions indentées"

1.2 Boucle POUR : réaliser plusieurs fois PRESQUE la même action

Voir

A - Valeurs successives de la variable de boucle

On réalise des actions un peu différentes car utilisant une variable de boucle dont le nom se situe derrière le mot clé for.

for k in range(5):

Sur cet exemple, k est la variable de boucle :

k commence à 0
k est incrémentée de 1 à chaque tour de boucle.
Ainsi, k va prendre les valeurs 0 puis 1 puis 2 puis 3 puis 4.

Attention

k n'ira pas jusqu'à 5, c'est une borne exclue.
5 correspond néanmoins bien au nombre de tours de boucle effectuées : 0-1-2-3-4.
La valeur finale de k est 4, obtenue en calculant (5 - 1).

B - Déroulé d'une boucle avec variable de boucle

print("Avant boucle")
 
for k in range(3):          # Pour k variant de 0 à 2
    print("A")              # Affiche le string "A"
    print(k)                # Affiche le contenu de k
 
print("Après boucle")

Déroulé du programme

L1
L3(k=0) - L4 - L5
L3(k=1) - L4 - L5
L3(k=2) - L4 - L5
L7

Résultat du programme


Avant boucle
A
0
A
1
A
2
Après

C - Sémantique

`3`	`for k in range(3):`

Traduction en français : "Pour chaque valeur de k dans [0, 1, 2], réalise le bloc d'instructions indentées"

2 - Exercices

⇩ ⇧ ⤊

Premiers exercices

⚙ 01° Réaliser ces deux actions :

Créer un programme qui affiche 1000 fois "Trop facile en programmant".
Fournir la séquence des lignes suivies pour écrire les 3 premiers textes.


Trop facile en programmant
Trop facile en programmant
Trop facile en programmant
...

Correction ?

...CORRECTION...

1
2
3

texte = "Trop facile en programmant"
for _ in range(1000):
    print(texte)

1 - 2-3 - 2-3 - 2-3...

⚙ 02° Créer un string qui contient 40 symboles étoiles *. Le plus facile est encore de le créer à l'aide d'une répétition. Finaliser le programme pour qu'il affiche 10 lignes qui contiennent chacune 40 étoiles *.


****************************************
****************************************
****************************************
****************************************
****************************************
****************************************
****************************************
****************************************
****************************************
****************************************

Correction ?

...CORRECTION...

1
2
3

texte = "*" * 40
for _ in range(10):
    print(texte)

⚙ 03° Réaliser ces deux actions :

Compléter les ... dans le programme pour qu'il affiche les nombres 0, 10, 20, 30, 40, 50... jusqu'à 100.
Fournir la succession de lignes de code suivies par l'interpréteur.

print("C'est parti !")
 
for k in range(11):
    ...
 
print("Fini !")

Correction ?

...CORRECTION...

print("C'est parti !")
 
for k in range(11):
    print(k * 10)
 
print("Fini !")

>>> %Run prog_boucle.py
  C'est parti !
  0
  10
  20
  30
  40
  50
  60
  70
  80
  90
  100
  Fini !

Les séquences suivies sont :

L3(k=0)-L4

L3(k=1)-L4

L3(k=2)-L4

L3(k=3)-L4

L3(k=4)-L4

L3(k=5)-L4

L3(k=6)-L4

L3(k=7)-L4

L3(k=8)-L4

L3(k=9)-L4

L3(k=10)-L4

⚙ 04° Créer un programme qui affiche (à l'aide d'une boucle) 0 étoile, puis 1 étoile, puis 2 étoiles... jusqu'à 10 étoiles.

Attention, je veux 10 étoiles, pas 9 !



    *
    **
    ***
    ****
    *****
    ******
    *******
    ********
    *********
    **********

Correction ?

...CORRECTION...

1
2

for v in range(11):
    print("*" * v)

>>> %Run prog_boucle.py

    *
    **
    ***
    ****
    *****
    ******
    *******
    ********
    *********
    **********

Somme des entiers

⚙ 05-A° Voici un premier programme permettant de calculer progressivement 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10.

somme = 0
 
somme = somme + 0
somme = somme + 1
somme = somme + 2
somme = somme + 3
somme = somme + 4
somme = somme + 5
somme = somme + 6
somme = somme + 7
somme = somme + 8
somme = somme + 9
somme = somme + 10
 
...

Questions

Comment se nomme la variable qui va stocker progressivement les valeurs qu'on ajoute ?
Compléter la ligne 15 pour afficher le résultat final.

Correction ?

...CORRECTION...

La variable est bien entendu somme.

Il suffit de noter ceci en ligne 15 : print(somme)

✎ 05-B° Nous voudrions maintenant faire la somme des entiers de 0 à 100 et nous n'avons pas trop envie de faire 100 incrémentations. Compléter les ... ci-dessous pour permettre au programme de faire son travail. Pour cela, quelques questions qui devraient vous aider :

L03 : comment se nomme la variable de boucle qui aura 0 comme valeur lors du premier tour, puis 1, puis 2, ect... ?
L03 : que faut-il mettre dans les parenthèses de la fonction range() pour aller jusqu'à 100 ?
L04 : pour obtenir l'équivalent des lignes 3 à 13 de la question 05-A, que faut-il rajouter à somme à chaque tour de boucle ? 0, 1, 2, v, somme ou 10

somme = 0
 
for v in range(...):
    somme = somme + ...
 
print(somme)

✔ 05-C° Utiliser le programme pour qu'il calcule la somme des entiers de 0 à 5345.

Si vous ne trouvez pas 14287185, appelez : c'est que quelque chose ne va pas dans votre programme.

✎ 05-D (difficile)° Recopier sur votre feuille les deux tours de boucles suivants, les lignes en gras (en complétant les ???) :

L2(v=0) - L3(somme=somme+v=0+0=0)

L2(v=1) - L3(somme=somme+v=0+1=1)

L2(v=2) - L3(somme=somme+v=1+2=3)

L2(v=???) - L3(somme=somme+v=???+???=???)

Si vous ne trouvez pas une somme de 10 lors du dernier calcul, appelez : c'est que votre compréhension du programme n'est pas la bonne.

3 - Les boucles dans turtle

⇩ ⇧ ⤊

Un peu de graphisme maintenant. Commençons par voir (ou revoir pour certains d'entre vous) comment parvenir à demander à la tortue d'avancer tout droit ou de tourner de quelques degrés.

(Rappel ?) 3.1 - Turtle : déplacement relatif avec forward(), left(), right()

Voir

Orientation de la tortue

Si vous regardez l'écran de turtle, vous pourrez constater qu'on y voit une sorte de flèche : elle indique la direction vers laquelle pointe la tortue.

Initialement, la tortue pointe vers la droite (angle 0°).

Avancer avec forward()

Cette fonction permet de faire avancer la tortue dans la direction qu'elle regarde en partant de sa position actuelle.

On doit lui transmettre la distance en pixels.

from turtle import *
 
dot(15) 
forward(50)      # veut dire d’avancer de 50 pixels.
dot(15)
forward(100)     # veut dire d’avancer de 100 pixels.

Tourner avec left()

Cette fonction permet de faire tourner la tortue sur place en fournissant un angle en degrés. Elle tourne sur elle-même vers la gauche, en sens anti-horaire donc.

from turtle import *
 
dot(15) 
forward(50)     # veut dire d’avancer de 50 pixels.
dot(15)
left(90)        # rotation à angle droit
forward(100)    # veut dire d’avancer de 100 pixels.

Tourner avec right()

Cette fonction permet de faire tourner la tortue sur place en fournissant un angle en degrés. Elle tourne sur elle-même vers la droite, en sens horaire donc.

from turtle import *
 
dot(15) 
forward(50)     # veut dire d’avancer de 50 pixels.
dot(15)
right(90)       # rotation à angle droit
forward(100)    # veut dire d’avancer de 100 pixels.

✔ 06-A° Voici un programme qui trace un triangle en réalisant trois fois EXACTEMENT la même action : avance et tourne de 120°.

On notera que 120° * 3 donne 360°.

from turtle import *
 
couleur_choisie = "#33AAFF"
taille = 50
x = 0
y = 0
 
# Choix du feutre
color(couleur_choisie)
pensize(5)
 
# Déplacement du crayon
penup()
goto(x, y)
pendown()
 
# Dessin d'un carré
for _ in range(3):
    forward(taille)
    left(120)

Actions à réaliser

Lancer le programme.
Modifiez les contenus des variables des lignes 3-4-5-6 pour constater que cela a bien un impact sur le dessin.

✎ 06-B° Ecrire la succession de lignes que va emprunter l'interpréteur Python lorsqu'il va exécuter le programme précédent.

Attention, certaines doivent apparaître plusieurs fois puisqu'il y a une boucle.

⚙ 06-C° Modifier les lignes 18 et 20 du programme précédent pour qu'il trace plutôt un carré en réalisant quatre fois EXACTEMENT la même action : avance et tourne de 90°. On notera que 90° * 4 donne 360°.

Correction ?

...CORRECTION...

from turtle import *
 
couleur_choisie = "#33AAFF"
taille = 50
x = 0
y = 0
 
# Choix du feutre
color(couleur_choisie)
pensize(5)
 
# Déplacement du crayon
penup()
goto(x, y)
pendown()
 
# Dessin d'un carré
for _ in range(4):
    forward(taille)
    left(90)

⚙ 07-A° Traçons maintenant des côtés de plus en plus grands : on réalise donc presque la même action. Nous allons donc utiliser la valeur de la variable de boucle notée k ici, différente à chaque tour :

Utiliser ce programme pour visualiser le résultat, puis répondre aux questions.

from turtle import *
 
couleur_choisie = "#33AAFF"
taille = 25
x = 0
y = 0
 
# Choix du feutre
color(couleur_choisie)
pensize(5)
 
# Déplacement du crayon
penup()
goto(x, y)
pendown()
 
# Dessin d'un carré
for k in range(16):
    forward( taille * (k + 1) )
    left(90)

Questions

Lors du premier tour :

(L18) Que vaut la variable de boucle k ?
(L19) De combien de pixels avance-t-on lors du premier tour ?

Lors du deuxième tour :

(L18) Que vaut la variable de boucle k ?
(L19) De combien de pixels avance-t-on lors du premier tour ?

Lors du troisième tour :

(L18) Que vaut la variable de boucle k ?
(L19) De combien de pixels avance-t-on lors du premier tour ?

Correction ?

...CORRECTION...

k vaut 0 puis k vaut 1 puis k vaut 2 puis k vaut 3.

On calcule alors les longueurs en utilisant la ligne 19 : taille * (k + 1)

Lorsque k vaut 0, la longueur vaut 25*(0+1) = 25

Lorsque k vaut 1, la longueur vaut 25*(1+1) = 50

Lorsque k vaut 2, la longueur vaut 25*(2+1) = 75

⚙ 07-B° Modifiez l'angle de rotation de la ligne 20 :

Placez 120 et lancez.
Placez 240 et lancez.
Placez 210 et lancez.

Question : la dernière forme est-elle réellement plus complexe à décrire que les autres ou s'agit-il uniquement d'une illusion de complexité si on utilise le mauvais langage de description ?

Correction ?

...CORRECTION...

Le langage humain donnerait effectivement à la dernière forme l'illusion d'une forme complexe car nous serions bien ennuyés pour la décrire précisément.

En réalité, en utilisant le bon langage de description, on se rend compte que ces formes sont toutes équivalentes puisque dans le code permettant de les dessiner seule la valeur change.

Le dessin de l'introduction.

⚙ 08° En conclusion, voici le code permettant de créer l'image de l'introduction.

Lancer le code et modifier quelques couleurs ou valeurs pour observer les changements.

Vous auriez vraiment envie de faire cela sans boucle ?

from turtle import *
couleurs = ["gold", "white", "blue" ]
speed(0)
bgcolor('black')
 
for x in range(800):
    pencolor(couleurs[x % 3])
    pensize(x//100 + 1)
    forward(x)
    left(59)

Voici des valeurs qu'on pourrait prendre par exemple. Comment se fait-il qu'on ait parfois l'impression de voir du jaune au centre de la forme lors de la réalisation du dessin ?

from turtle import *
couleurs = ["black", "red", "green" ]
speed(0)
bgcolor('black')
 
for x in range(800):
    pencolor(couleurs[x % 3])
    pensize(x//100 + 1)
    forward(x)
    left(195)

4 - Application à la photographie numérique

⇩ ⇧ ⤊

Vous savez qu'une image est une succession de petits carrés nommés pixels.

Vous savez que chaque couleur de pixel est définie par sa décomposition RGB : Red Green Blue.

Nous allons voir qu'on peut accéder à chaque pixel et modifier les valeurs RGB.

✔ 09-A° L'utilisation de boucles imbriquées va nous permettre d'atteindre chaque pixel d'une image.

from turtle import *
 
for ligne in range(15):
    for colonne in range(15):
        goto(colonne*20, ligne*20)  # partons au bon endroit
        dot(18)                     # plaçons un pixel unique

Le code ci-dessus veut dire ceci : "Pour chaque ligne, parcours chaque colonne de cette ligne pour y placer un point".

Lancer le code et visualiser que la phrase en gras correspond bien à ce qu'on visualise.

⚙ 09-B° Modifier le programme pour lui demander plutôt ceci : "Pour chaque COLONNE, parcours chaque LIGNE de cette colonne pour y placer un point".

Correction ?

...CORRECTION...

from turtle import *
 
for colonne in range(50):
    for ligne in range(50):
        goto(colonne*20, ligne*20)  # partons au bon endroit
        dot(1)                # plaçons un pixel unique

✔ 10° Réaliser ces deux actions :

Vérifier que vous avez bien activé la visualisation des extensions si vous êtes sur Windows (explorateur de fichiers, menu affichage).
Télécharger l'image suivante en la plaçant dans votre dossier python04. Vous nommerez l'image mm.jpg, comme Marilyn Monroe, dont le portrait fut utilisé par le célèbre artiste Andy Warhol.

✔ 11° Réaliser ces actions :

Aller sur python.infoforall.fr.
Cliquer sur l'icône représentant un dossier, à côté de l'icône EXECUTER.

Sélectionner votre image mm.jpg.
Placer ce script dans la zone de programmation puis cliquer sur EXECUTER.

from PIL import Image  # Pour charger le module PIL gérant les images
 
image = Image.open("mm.jpg")  # Pour gérer cette image via la variable Python nommée image
image.show()                  # Pour afficher cette image
image.close()                 # Pour fermer proprement le fichier

Une fois le programme terminé, un bouton devrait clignoter en jaune : il vous suffit de cliquer dessous et vous devriez voir apparaître votre image.

✔ 12° Dans ce nouveau script, nous allons demander à Python :

Pour chaque colonne de cette image (Ligne 5)
Pour chaque ligne de cette image (Ligne 6)
Récupère les valeurs rgb du pixel actuel (Ligne 7)
Modifie ce pixel en inversant les intensités du rouge et bleue (Ligne 8)

Placer ce nouveau script dans la zone de programmation puis cliquer sur EXECUTER.

from PIL import Image
 
image = Image.open("mm.jpg")
 
for colonne in range( image.width ):
    for ligne in range( image.height ):
        r, g, b = image.getpixel( (colonne, ligne))
        image.putpixel( (colonne, ligne), (b, g, r))
 
image.show()
image.close()

Une fois le programme terminé, un bouton devrait clignoter en jaune : il vous suffit de cliquer dessous et vous devriez voir apparaître votre image.

⚙ 13° Quelques questions liées à ce programme :

Localiser l'expression qui permet de récupérer la largeur de l'image (en pixels).
Localiser l'expression qui permet de récupérer la hauteur de l'image (en pixels).
Localiser la fonction qui permet de récupérer les trois valeurs RGB d'un pixel en particulier.
Localiser la fonction qui permet de modifier les trois valeurs RGB d'un pixel en particulier.

from PIL import Image
 
image = Image.open("mm.jpg")
 
for colonne in range( image.width ):
    for ligne in range( image.height ):
        r, g, b = image.getpixel( (colonne, ligne))
        image.putpixel( (colonne, ligne), (b, g, r))
 
image.show()
image.close()

Correction ?

...CORRECTION...

Localiser l'expression qui permet de récupérer la largeur de l'image (en pixels).

`5`	`for colonne in range( image.width ):`

Localiser l'expression qui permet de récupérer la hauteur de l'image (en pixels).

`6`	`for ligne in range( image.height ):`

Localiser la fonction qui permet de récupérer les trois valeurs RGB d'un pixel en particulier.

`7`	`r, g, b = image.getpixel( (colonne, ligne))`

Localiser la fonction qui permet de modifier les trois valeurs RGB d'un pixel en particulier.

`8`	`image.putpixel( (colonne, ligne), (b, g, r))`

✌ 14° Voyons comment réaliser un filtre rouge : on ne laisse passer que la composante rouge :

from PIL import Image
 
image = Image.open("mm.jpg")
 
for colonne in range( image.width ):
    for ligne in range( image.height ):
        r, g, b = image.getpixel( (colonne, ligne))
        image.putpixel( (colonne, ligne), (r, 0, 0))
 
image.show()
image.close()

A faire

Réaliser un filtre bleu qui ne laisse passer que le bleu.

⚙ 15° Compléter les ... de ce dernier programme : nous voulons obtenir une image grisée : pour cela, on va devoir calculer la moyenne des trois composantes rouge, vert, bleu et placer cette valeur sur les trois composantes RGB. Puisqu'elles auront la même valeur, nous allons percevoir des nuances de gris.

from PIL import Image
 
image = Image.open("mm.jpg")
 
for colonne in range( image.width ):
    for ligne in range( image.height ):
        r, g, b = image.getpixel( (colonne, ligne))
        m = ...      
        image.putpixel( (colonne, ligne), (..., ..., ...))
 
image.show()
image.close()

Correction ?

...CORRECTION...

from PIL import Image
 
image = Image.open("mm.jpg")
 
for colonne in range( image.width ):
    for ligne in range( image.height ):
        r, g, b = image.getpixel( (colonne, ligne))
        m = (r + g + b) // 3      
        image.putpixel( (colonne, ligne), (m, m, m))
 
image.show()
image.close()

5 - Py-rates

⇩ ⇧ ⤊

✎ 16° Connectez-vous sur le site py-rates.fr ou py-rates.org. Choisissez votre langue en haut à droite, puis votre personnage, et notez bien le numéro qui vous permettra de continuer de chez vous.

Il vous reste à fournir les codes permettant de passer les niveaux 1, 2 et 3.

6 - FAQ

⇩ ⇧ ⤊

Pas de question pour le moment

Activité publiée le 08 12 2022
Dernière modification : 28 11 2024
Auteur : ows. h.

⏪

⏫

⏩