manipulation d'image

Le
Lulu
Bonjour,

Je veux faire quelque chose qui me paraît simple, mais je m'arrache les
cheveux depuis plusieurs heures parce que des fonctions python sont
indisponibles ou causent des erreurs.

Je veux ouvrir une image PNG en RGB, créer une nouvelle image de la même
taille, lire la valeur RGB de l'image originale (getpixel), modifier la
valeur du pixel (niveaux de gris, noir et blanc, négatif, etc.) et
écrire le nouveau pixel (putpixel) dans l'image créée en mémoire avant
de l'afficher.

Évidemment, comme j'apprends "sur le tas" (PDF imprimé, exemples péchés
sur le web), je dois commettre des erreurs grossières : merci de
m'indiquer lesquelles.

Voilà mon code:
8<--8<8<-8<-8<-8<-8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-

#import sys
from PIL.Image import *
#from PIL import Image
#from PIL import *
#import PIL
#import PIL.Image

Fichier_Image="Les_Horribles_Cernettes.png"
#Fichier_Image="avengers-endseries-comics-png-475.png"

#try:
the_image=open(Fichier_Image).convert("RGB")
#except:
#print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?"
#sys.exit(1)

Image.show(the_image)

# l = largeur en pixel de l'image
# h = hauteur en pixel de l'image
(l, h) = the_image.size
print("taille de l'image :",l,"px *",h,"px")

nb_pixels=l*h
print("nombre de pixels :",nb_pixels)

#creation de l'image en niveau de gris
the_image_ndg=Image.new("RGB",(l,h))

# pour y variant de 0 à h-1
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
#print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")

gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5

rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
8<--8<8<-8<-8<-8<-8<

Tel quel, mon code affiche bien l'image des horribles Cernettes, mais j'ai
une erreur:
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 31, in <module>
the_image_ndg=Image.new("RGB",(l,h))
AttributeError: type object 'Image' has no attribute 'new'

Je comprends que la fonction 'new' n'est pas présente dans le module
'PIL.Image'

Qu'à cela ne tienne, je trouve sur cette page : https://www.education-du-numerique.fr/module-pil.html
un exemple qui commence par :
from PIL.Image import *
from PIL import Image
(au passage, si on peut m'expliquer la différence entre ces deux lignes)

je décommente donc la ligne '#from PIL import Image' et relance mon
script :

Traceback (most recent call last):
File "img_niveau_de_gris.py", line 20, in <module>
Image.show(the_image)
AttributeError: module 'PIL.Image' has no attribute 'show'

(J'ai essayé toutes les combinaisons possibles 'PIL.Image.show',
'Image.PIL.show', 'PIL.show' avec toujours des erreurs)

J'en conclue (faussement, j'en suis sûr), que je peux soit afficher une
image, soit en créer une, mais pas les deux en même temps !!



Petite bizarrerie au passage: bien que mon fichier soit en RGB (vérifié
grâce à ImageMagick), je suis contraint d'ouvrir le fichier en ajoutant
'.convert("RGB"), sinon getpixel ne me retourne qu'une valeur entière au
lieu d'une liste de trois valeurs.

Deuxième bizarrerie : je veux interrompre mon script s'il ne trouve pas
l'image, donc j'importe 'sys' (tiré d'un exemple trouvé sur le web) et
j'ai cette erreur :
File "img_niveau_de_gris.py", line 18
sys.exit(1)
^
SyntaxError: invalid syntax


Je tourne avec python3 version 3.6.8 sur une Linux Mint à jour.


Merci de m'éclairer sur l'erreur que je commets (et de m'excuser pour la
trivialité de celle-ci, parce qu'elle doit vous paraître énorme).


PS : Je ne veux pas de solution à base de numpy ou autre matplot car je
dois rester leplus simple possible sans aucun impératif de performance
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Pierre Maurette
Le #26523391
Lulu :
Bonjour,
Je veux faire quelque chose qui me paraît simple, mais je m'arrache les
cheveux depuis plusieurs heures parce que des fonctions python sont
indisponibles ou causent des erreurs.
Je veux ouvrir une image PNG en RGB, créer une nouvelle image de la même
taille, lire la valeur RGB de l'image originale (getpixel), modifier la
valeur du pixel (niveaux de gris, noir et blanc, négatif, etc.) et
écrire le nouveau pixel (putpixel) dans l'image créée en mémoire avant
de l'afficher.
Évidemment, comme j'apprends "sur le tas" (PDF imprimé, exemples péchés
sur le web), je dois commettre des erreurs grossières : merci de
m'indiquer lesquelles.
Voilà mon code:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#import sys
from PIL.Image import *
#from PIL import Image
#from PIL import *
#import PIL
#import PIL.Image
Fichier_Image="Les_Horribles_Cernettes.png"
#Fichier_Image="avengers-endseries-comics-png-475.png"
#try:
the_image=open(Fichier_Image).convert("RGB")
#except:
#print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?"
#sys.exit(1)
Image.show(the_image)
# l = largeur en pixel de l'image
# h = hauteur en pixel de l'image
(l, h) = the_image.size
print("taille de l'image :",l,"px *",h,"px")
nb_pixels=l*h
print("nombre de pixels :",nb_pixels)
#creation de l'image en niveau de gris
the_image_ndg=Image.new("RGB",(l,h))
# pour y variant de 0 à h-1
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
#print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Tel quel, mon code affiche bien l'image des horribles Cernettes, mais j'ai
une erreur:
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 31, in <module>
the_image_ndg=Image.new("RGB",(l,h))
AttributeError: type object 'Image' has no attribute 'new'
Je comprends que la fonction 'new' n'est pas présente dans le module
'PIL.Image'
Qu'à cela ne tienne, je trouve sur cette page :
https://www.education-du-numerique.fr/module-pil.html un exemple qui commence
par : from PIL.Image import *
from PIL import Image
(au passage, si on peut m'expliquer la différence entre ces deux lignes...)
je décommente donc la ligne '#from PIL import Image' et relance mon
script :
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 20, in <module>
Image.show(the_image)
AttributeError: module 'PIL.Image' has no attribute 'show'
(J'ai essayé toutes les combinaisons possibles 'PIL.Image.show',
'Image.PIL.show', 'PIL.show' avec toujours des erreurs)
J'en conclue (faussement, j'en suis sûr), que je peux soit afficher une
image, soit en créer une, mais pas les deux en même temps !!

Petite bizarrerie au passage: bien que mon fichier soit en RGB (vérifié
grâce à ImageMagick), je suis contraint d'ouvrir le fichier en ajoutant
'.convert("RGB"), sinon getpixel ne me retourne qu'une valeur entière au
lieu d'une liste de trois valeurs.
Deuxième bizarrerie : je veux interrompre mon script s'il ne trouve pas
l'image, donc j'importe 'sys' (tiré d'un exemple trouvé sur le web) et
j'ai cette erreur :
File "img_niveau_de_gris.py", line 18
sys.exit(1)
^
SyntaxError: invalid syntax

Là vous avez simplement oublié une parenthèse dans le print() dans
l'except'.
Je tourne avec python3 version 3.6.8 sur une Linux Mint à jour.
Merci de m'éclairer sur l'erreur que je commets (et de m'excuser pour la
trivialité de celle-ci, parce qu'elle doit vous paraître énorme).
PS : Je ne veux pas de solution à base de numpy ou autre matplot car je
dois rester leplus simple possible sans aucun impératif de performance

Vous avez juste un problème avec la structure de PIL et PIL.Image en
particulier. new, show et open sont des fonctions de PIL.Image. Il n'y
a aucune raison de simplifier par des imports, des imports * /a
fortiori/ , c'est même néfaste, en particulier aviez-vous vous-même
bien vu que le open était un PIL.Image.open par la magie des imports ?
Donc juste un
import sys
from PIL import Image
puis:
try:
the_image=Image.open(Fichier_Image).convert("RGB")
except:
print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?")
sys.exit(1)
...
the_image.show()
( ou Image._show(the_image) )
...
the_image_ndg=Image.new("RGB", (l, h), "white")
( ou the_image_ndg=Image.new("RGB", (l, h)) )
--
Pierre Maurette
Lulu
Le #26523396
Le 14-08-2019, Pierre Maurette
Lulu :
Bonjour,
Je veux faire quelque chose qui me paraît simple, mais je m'arrache les
cheveux depuis plusieurs heures parce que des fonctions python sont
indisponibles ou causent des erreurs.
Je veux ouvrir une image PNG en RGB, créer une nouvelle image de la même
taille, lire la valeur RGB de l'image originale (getpixel), modifier la
valeur du pixel (niveaux de gris, noir et blanc, négatif, etc.) et
écrire le nouveau pixel (putpixel) dans l'image créée en mémoire avant
de l'afficher.
Évidemment, comme j'apprends "sur le tas" (PDF imprimé, exemples péchés
sur le web), je dois commettre des erreurs grossières : merci de
m'indiquer lesquelles.
Voilà mon code:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#import sys
from PIL.Image import *
#from PIL import Image
#from PIL import *
#import PIL
#import PIL.Image
Fichier_Image="Les_Horribles_Cernettes.png"
#Fichier_Image="avengers-endseries-comics-png-475.png"
#try:
the_image=open(Fichier_Image).convert("RGB")
#except:
#print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?"
#sys.exit(1)
Image.show(the_image)
# l = largeur en pixel de l'image
# h = hauteur en pixel de l'image
(l, h) = the_image.size
print("taille de l'image :",l,"px *",h,"px")
nb_pixels=l*h
print("nombre de pixels :",nb_pixels)
#creation de l'image en niveau de gris
the_image_ndg=Image.new("RGB",(l,h))
# pour y variant de 0 à h-1
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
#print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Tel quel, mon code affiche bien l'image des horribles Cernettes, mais j'ai
une erreur:
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 31, in <module>
the_image_ndg=Image.new("RGB",(l,h))
AttributeError: type object 'Image' has no attribute 'new'
Je comprends que la fonction 'new' n'est pas présente dans le module
'PIL.Image'
Qu'à cela ne tienne, je trouve sur cette page :
https://www.education-du-numerique.fr/module-pil.html un exemple qui commence
par : from PIL.Image import *
from PIL import Image
(au passage, si on peut m'expliquer la différence entre ces deux lignes...)
je décommente donc la ligne '#from PIL import Image' et relance mon
script :
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 20, in <module>
Image.show(the_image)
AttributeError: module 'PIL.Image' has no attribute 'show'
(J'ai essayé toutes les combinaisons possibles 'PIL.Image.show',
'Image.PIL.show', 'PIL.show' avec toujours des erreurs)
J'en conclue (faussement, j'en suis sûr), que je peux soit afficher une
image, soit en créer une, mais pas les deux en même temps !!

Petite bizarrerie au passage: bien que mon fichier soit en RGB (vérifié
grâce à ImageMagick), je suis contraint d'ouvrir le fichier en ajoutant
'.convert("RGB"), sinon getpixel ne me retourne qu'une valeur entière au
lieu d'une liste de trois valeurs.
Deuxième bizarrerie : je veux interrompre mon script s'il ne trouve pas
l'image, donc j'importe 'sys' (tiré d'un exemple trouvé sur le web) et
j'ai cette erreur :
File "img_niveau_de_gris.py", line 18
sys.exit(1)
^
SyntaxError: invalid syntax

Là vous avez simplement oublié une parenthèse dans le print() dans
l'except'.

Rhô 'tain !!!
Je tourne avec python3 version 3.6.8 sur une Linux Mint à jour.
Merci de m'éclairer sur l'erreur que je commets (et de m'excuser pour la
trivialité de celle-ci, parce qu'elle doit vous paraître énorme).
PS : Je ne veux pas de solution à base de numpy ou autre matplot car je
dois rester leplus simple possible sans aucun impératif de performance

Vous avez juste un problème avec la structure de PIL et PIL.Image en
particulier. new, show et open sont des fonctions de PIL.Image.

Comment puis-je obtenir la liste des fonctions d'une bibliothèque ?
Une commande 'print dir(machin)' que j'ai tapée dans l'interpréteur m'a
renvoyé une erreur (oubliée... j'en ai eu tellement)
Il n'y a aucune raison de simplifier par des imports, des imports *
/a fortiori/ , c'est même néfaste,

Pourquoi donc ?
Pouvez-vous développer un peu ?
en particulier aviez-vous vous-même bien vu que le open était un
PIL.Image.open par la magie des imports ?

Euh... je crois bien que oui.
Donc juste un
import sys
from PIL import Image

Je ne comprends pas, vous disiez « Il n'y a aucune raison de simplifier
par des imports » et là vous faîtes bien deux imports...
puis:
try:
the_image=Image.open(Fichier_Image).convert("RGB")

Avez-vous une explication à la nécessité d'ajouter '.convert("RGB")' à
l'ouverture du fichier pour avoir trois valeurs (dans une liste) plutôt
qu'une seule lors de l'appel à getepixel ?
except:
print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?")
sys.exit(1)
...
the_image.show()
( ou Image._show(the_image) )

Je préfère la seconde "écriture".
Mais pourquoi "._show" plutôt que ".show" ? Le ".open" ci-dessus
fonctionne sans underscore "_"... (et ne fonctionne pas avec).
Dit autrement : comment deviner qu'une fonction doit être appelée avec
ou sans underscore ?
...
the_image_ndg=Image.new("RGB", (l, h), "white")
( ou the_image_ndg=Image.new("RGB", (l, h)) )

0K
Un grand merci pour votre aide.
J'ai donc un script qui ouvre une image, qui l'affiche, qui lit la valeur
(R,G,B) de chacun des pixels et qui créé trois images dans lesquelles
écrire (du moins pas d'erreur à l'exécution de
'the_image_ndg=Image.new("RGB",(l,h))'
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
J'ai ça dans ma boucle :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
Image.putpixel(the_image_ndg, (x,y), gris)
Image._show(the_image_ndg)
Lulu
Le #26523398
Le 14-08-2019, Lulu
Le 14-08-2019, Pierre Maurette
Lulu :

0K
Un grand merci pour votre aide.
J'ai donc un script qui ouvre une image, qui l'affiche, qui lit la valeur
(R,G,B) de chacun des pixels et qui créé trois images dans lesquelles
écrire (du moins pas d'erreur à l'exécution de
'the_image_ndg=Image.new("RGB",(l,h))'
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
J'ai ça dans ma boucle :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
Image.putpixel(the_image_ndg, (x,y), gris)
Image._show(the_image_ndg)

Corrigé en 'Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))'
mais toujours la même erreur :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
gris = 155 ///
noir_ou_blanc = 255 ///
couleur RGB sombre ( 79 , 78 , 69 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 66, in <module>
Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
Lulu
Le #26523401
Le 14-08-2019, Lulu
Le 14-08-2019, Lulu
Le 14-08-2019, Pierre Maurette
Lulu :

0K
Un grand merci pour votre aide.
[...]
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
[...]

Corrigé en 'Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))'
mais toujours la même erreur :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
gris = 155 ///
noir_ou_blanc = 255 ///
couleur RGB sombre ( 79 , 78 , 69 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 66, in <module>
Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))
AttributeError: module 'PIL.Image' has no attribute 'putpixel'

Rhô Pu$%@n !!!
la ligne (tirée de vos exemples mon cher Pierre) marche :
the_image_ndg.putpixel((x,y), (gris,gris,gris))
et mon image en niveau de gris est bien affichée.
Et ma question devient :
pourquoi 'Image.putpixel(the_image_ndg,....' plante quand '
the_image_ndg.putpixel(...' marche alors que vous me présentiez les deux
écritures comme équivalentes ?
(/me se demande s'il ne va pas suggérer à not' grand chef que les
vertues du PHP sont à considérer pour ce qui concerne l'apprentissage de
la programmation de nos chères têtes blondes ;-)
Lulu
Le #26523400
Le 14-08-2019, Lulu
Le 14-08-2019, Lulu
Le 14-08-2019, Pierre Maurette
Lulu :

0K
Un grand merci pour votre aide.
[...]
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
[...]

Corrigé en 'Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))'
mais toujours la même erreur :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
gris = 155 ///
noir_ou_blanc = 255 ///
couleur RGB sombre ( 79 , 78 , 69 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 66, in <module>
Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))
AttributeError: module 'PIL.Image' has no attribute 'putpixel'

Rhô Pu$%@n !!!
la ligne (tirée de vos exemples mon cher Pierre) marche :
the_image_ndg.putpixel((x,y), (gris,gris,gris))
et mon image en niveau de gris est bien affichée.
Et ma question devient :
pourquoi 'Image.putpixel(the_image_ndg,....' plante quand
'the_image_ndg.putpixel(...' marche alors que vous me présentiez les deux
écritures comme équivalentes ?
(/me se demande s'il ne va pas suggérer à not' grand chef que les
vertues du PHP sont à considérer pour ce qui concerne l'apprentissage de
la programmation de nos chères têtes blondes ;-)
Pierre Maurette
Le #26523407
Lulu :
[...]
Quelques indications qui devraient vous permettre de répondre vous-même
à vos questions.
Pour la doc, vous devriez partir de la doc officielle:
https://pillow.readthedocs.io/en/latest/
Vous voyez que Pillow est la distribution actuelle de l'historique
bibliothèque PIL (Pillow est un nom "commercial", c'est bien sous le
nom de PIL qu'elle sera importée, Pillow n'existe pas dans le code).
Dans cette bibliothèque, une foule de modules, dont un nous intéresse
particulièrement (et pour un temps exclusivement): Image :
https://pillow.readthedocs.io/en/latest/reference/Image.html
Dans ce module, des fonctions et une classe (un objet): Image. Dans la
même page:
https://pillow.readthedocs.io/en/latest/reference/Image.html#the-image-class
C'est peut être confusant, mais en définitive logique.
Un module: PIL.Image
Une classe: PIL.Image.Image
Parmi les fonctions du module (PIL.Image): open, new, etc.
Parmi les fonctions (méthodes) de la classe (PIL.Image.Image): convert,
putpixel, getpixel, etc.
Donc, si je fais juste:
from PIL import Image
je n'ai importé que le module PIL.Image, en faisant simplement
l'économie d'avoir à saisir PIL.Image au profit de Image. La classe
PIL.Image.Image deviendra Image.Image, c'est tout.
Je vais donc avoir:
theimage1 = Image.open(blah)
theimage2 = Image.new(blahblah)
theimage1.putpixel(blah)
theimage2.show()
Mais je peux également faire:
Image.Image.putpixel(theimage1, blah)
Image.Image.show(theimage2)
Cas particulier:
Image._show(theimage2)
fonctionne. C'est un peu un hasard (ne fonctionne pas pour _convert,
qui n'existe pas), même si la pratique est habituelle. _show(unobjet)
est une fonction utile au module PIL.Image, l'underscore indique
qu'elle est vaguement "à usage interne" (peut-être héritée par
PIL.Image.Image, peu importe en fait), elle ne sera pas importée avec
*, ne sera pas documentée, etc. Mais reste parfaitement accessible.
Un code qui utilise des écritures exotiques (les "mais je peux
également...") masque un problème, et doit être corrigé.
Pourquoi (par exemple)
from PIL.Image import *
est *réellement* bad ?
PIL.Image.open() devient open(). Hors open() est une fonction native
largement utilisée, elle sera masquée. Il ne sera pas rare d'avoir à
l'utiliser dans un code incluant PIL.Image.open(). On peut bien sûr
faire
import builtins puis builtins.open(), il est clair que c'est débile, ça
casse les habitudes, les templates, le copier-coller de code, ça fait
chier le lecteur du code, et sans doute bien d'autres choses.
--
Pierre Maurette
Lulu
Le #26523481
Le 15-08-2019, Pierre Maurette
Lulu :

Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
[...]
Quelques indications qui devraient vous permettre de répondre vous-même
à vos questions.
Pour la doc, vous devriez partir de la doc officielle:
https://pillow.readthedocs.io/en/latest/
Vous voyez que Pillow est la distribution actuelle de l'historique
bibliothèque PIL (Pillow est un nom "commercial", c'est bien sous le
nom de PIL qu'elle sera importée, Pillow n'existe pas dans le code).

0K. J'avais un peu peur de cette histoire de fork...
Voullez-vous dire que lorsque je "cause" avec PIL, j'ai aussi accès aux
fonctions/modules/classes de Pillow ? (Est-ce newbie friendly ?)
Je lis dans les premières lignes du votre lien : « Pillow is the
_friendly_ PIL fork by... », donc a priori, « oui » à ma question.
Dans cette bibliothèque, une foule de modules, dont un nous intéresse
particulièrement (et pour un temps exclusivement): Image :
https://pillow.readthedocs.io/en/latest/reference/Image.html

Je note la distinction que je dois faire entre "bibliothèque" et
"module"...
Dans ce module, des fonctions et une classe (un objet): Image. Dans
la même page:
https://pillow.readthedocs.io/en/latest/reference/Image.html#the-image-class
C'est peut être confusant, mais en définitive logique.
Un module: PIL.Image
Une classe: PIL.Image.Image

0K.
(J'essaye de suivre)
Image est un module de la bibliothèque PIL
mais Image est aussi une "classe" du module Image de PIL.
Parmi les fonctions du module (PIL.Image): open, new, etc.

Liste de fonctions que l'on obtient en tapant dans un shell bash :
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
from PIL import Image
dir(Image)



['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
'CONTAINER', 'CUBIC', 'DECODERS', 'DEFAULT_STRATEGY',
'DecompressionBombError', 'DecompressionBombWarning', 'ENCODERS',
'EXTENSION', 'EXTENT', 'FASTOCTREE', 'FILTERED', 'FIXED',
'FLIP_LEFT_RIGHT', 'FLIP_TOP_BOTTOM', 'FLOYDSTEINBERG', 'HAMMING',
'HAS_CFFI', 'HAS_PATHLIB', 'HUFFMAN_ONLY', 'ID', 'Image', 'ImageMode',
'ImagePointHandler', 'ImageTransformHandler', 'LANCZOS',
'LIBIMAGEQUANT', 'LINEAR', 'MAXCOVERAGE', 'MAX_IMAGE_PIXELS',
'MEDIANCUT', 'MESH', 'MIME', 'MODES', 'NEAREST', 'NONE', 'NORMAL',
'OPEN', 'ORDERED', 'PERSPECTIVE', 'PILLOW_VERSION', 'Path', 'QUAD',
'RASTERIZE', 'RLE', 'ROTATE_180', 'ROTATE_270', 'ROTATE_90', 'SAVE',
'SAVE_ALL', 'SEQUENCE', 'TRANSPOSE', 'TRANSVERSE', 'USE_CFFI_ACCESS',
'VERSION', 'WEB', '_E', '_ENDIAN', '_MAPMODES', '_MODEINFO',
'_MODE_CONV', '__builtins__', '__cached__', '__doc__', '__file__',
'__loader__', '__name__', '__package__', '__spec__',
'_apply_env_variables', '_check_size', '_conv_type_shape',
'_decompression_bomb_check', '_fromarray_typemap', '_getdecoder',
'_getencoder', '_getscaleoffset', '_imaging_not_installed',
'_initialized', '_plugins', '_show', '_showxv', '_wedge',
'alpha_composite', 'atexit', 'blend', 'builtins', 'coerce_e',
'collections', 'composite', 'core', 'deferred_error',
'effect_mandelbrot', 'effect_noise', 'eval', 'fromarray', 'frombuffer',
'frombytes', 'fromqimage', 'fromqpixmap', 'fromstring',
'getmodebandnames', 'getmodebands', 'getmodebase', 'getmodetype', 'i8',
'init', 'io', 'isImageType', 'isPath', 'isStringType',
'linear_gradient', 'logger', 'logging', 'math', 'merge', 'new',
'numbers', 'open', 'os', 'preinit', 'radial_gradient',
'register_decoder', 'register_encoder', 'register_extension',
'register_extensions', 'register_mime', 'register_open',
'register_save', 'register_save_all', 'registered_extensions', 'struct',
'sys', 'warnings']
Ce qui me permet de connaître les fonctions que je peux appeler depuis
le code que j'écris.
Parmi les fonctions (méthodes) de la classe (PIL.Image.Image): convert,
putpixel, getpixel, etc.

Justement.
Je suis étonné de ne trouver dans la liste ci-dessus, ni convert, ni
putpixel, ni getpixel.
J'ai avancé...
Avant mon code ne marchait pas et je ne savais pourquoi.
Maintenant, mon code marche, mais je ne sais toujours pas pourquoi
puisque je ne vois, dans PIL.Image aucune fonction convert, putpixel ou
getpixel.
Donc, si je fais juste:
from PIL import Image
je n'ai importé que le module PIL.Image, en faisant simplement
l'économie d'avoir à saisir PIL.Image au profit de Image. La classe
PIL.Image.Image deviendra Image.Image, c'est tout.

Soit.
Je vais donc avoir:
theimage1 = Image.open(blah)
theimage2 = Image.new(blahblah)

OK.
'open' et 'new' font bien partie des fonctions du module Image de PIL.
theimage1.putpixel(blah)
theimage2.show()

Par contre ni 'putpixel' ni 'show' ne sont listées par 'dir(Image)'.
Comment pourrais-je (autrement que par des exemples tirés du web)
savoir que ces fonctions sont disponibles ?
Mais je peux également faire:
Image.Image.putpixel(theimage1, blah)
Image.Image.show(theimage2)

Même remarque.
Cas particulier:
Image._show(theimage2)
fonctionne. C'est un peu un hasard (ne fonctionne pas pour _convert,
qui n'existe pas), même si la pratique est habituelle. _show(unobjet)
est une fonction utile au module PIL.Image, l'underscore indique
qu'elle est vaguement "à usage interne" (peut-être héritée par
PIL.Image.Image, peu importe en fait), elle ne sera pas importée avec
*, ne sera pas documentée, etc. Mais reste parfaitement accessible.

0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
Un code qui utilise des écritures exotiques (les "mais je peux
également...") masque un problème, et doit être corrigé.

Pas compris
Pourquoi (par exemple)
from PIL.Image import *
est *réellement* bad ?
PIL.Image.open() devient open(). Hors open() est une fonction native
largement utilisée, elle sera masquée. Il ne sera pas rare d'avoir à
l'utiliser dans un code incluant PIL.Image.open(). On peut bien sûr
faire import builtins puis builtins.open(), il est clair que c'est
débile, ça casse les habitudes, les templates, le copier-coller de
code, ça fait chier le lecteur du code, et sans doute bien d'autres
choses.

0K.
Bien compris.
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gré
Pierre Maurette
Le #26523487
Lulu :
Le 15-08-2019, Pierre Maurette
Lulu :

Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
[...]
Quelques indications qui devraient vous permettre de répondre vous-même
à vos questions.
Pour la doc, vous devriez partir de la doc officielle:
https://pillow.readthedocs.io/en/latest/
Vous voyez que Pillow est la distribution actuelle de l'historique
bibliothèque PIL (Pillow est un nom "commercial", c'est bien sous le
nom de PIL qu'elle sera importée, Pillow n'existe pas dans le code).

0K. J'avais un peu peur de cette histoire de fork...
Voullez-vous dire que lorsque je "cause" avec PIL, j'ai aussi accès aux
fonctions/modules/classes de Pillow ? (Est-ce newbie friendly ?)
Je lis dans les premières lignes du votre lien : « Pillow is the
_friendly_ PIL fork by... », donc a priori, « oui » à ma question.
Dans cette bibliothèque, une foule de modules, dont un nous intéresse
particulièrement (et pour un temps exclusivement): Image :
https://pillow.readthedocs.io/en/latest/reference/Image.html

Je note la distinction que je dois faire entre "bibliothèque" et
"module"...
Dans ce module, des fonctions et une classe (un objet): Image. Dans
la même page:
https://pillow.readthedocs.io/en/latest/reference/Image.html#the-image-class

C'est peut être confusant, mais en définitive logique.
Un module: PIL.Image
Une classe: PIL.Image.Image

0K.
(J'essaye de suivre)
Image est un module de la bibliothèque PIL
mais Image est aussi une "classe" du module Image de PIL.
Parmi les fonctions du module (PIL.Image): open, new, etc.

Liste de fonctions que l'on obtient en tapant dans un shell bash :
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
from PIL import Image
dir(Image)



['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
'CONTAINER', 'CUBIC', 'DECODERS', 'DEFAULT_STRATEGY',
'DecompressionBombError', 'DecompressionBombWarning', 'ENCODERS',
'EXTENSION', 'EXTENT', 'FASTOCTREE', 'FILTERED', 'FIXED',
'FLIP_LEFT_RIGHT', 'FLIP_TOP_BOTTOM', 'FLOYDSTEINBERG', 'HAMMING',
'HAS_CFFI', 'HAS_PATHLIB', 'HUFFMAN_ONLY', 'ID', 'Image', 'ImageMode',
'ImagePointHandler', 'ImageTransformHandler', 'LANCZOS',
'LIBIMAGEQUANT', 'LINEAR', 'MAXCOVERAGE', 'MAX_IMAGE_PIXELS',
'MEDIANCUT', 'MESH', 'MIME', 'MODES', 'NEAREST', 'NONE', 'NORMAL',
'OPEN', 'ORDERED', 'PERSPECTIVE', 'PILLOW_VERSION', 'Path', 'QUAD',
'RASTERIZE', 'RLE', 'ROTATE_180', 'ROTATE_270', 'ROTATE_90', 'SAVE',
'SAVE_ALL', 'SEQUENCE', 'TRANSPOSE', 'TRANSVERSE', 'USE_CFFI_ACCESS',
'VERSION', 'WEB', '_E', '_ENDIAN', '_MAPMODES', '_MODEINFO',
'_MODE_CONV', '__builtins__', '__cached__', '__doc__', '__file__',
'__loader__', '__name__', '__package__', '__spec__',
'_apply_env_variables', '_check_size', '_conv_type_shape',
'_decompression_bomb_check', '_fromarray_typemap', '_getdecoder',
'_getencoder', '_getscaleoffset', '_imaging_not_installed',
'_initialized', '_plugins', '_show', '_showxv', '_wedge',
'alpha_composite', 'atexit', 'blend', 'builtins', 'coerce_e',
'collections', 'composite', 'core', 'deferred_error',
'effect_mandelbrot', 'effect_noise', 'eval', 'fromarray', 'frombuffer',
'frombytes', 'fromqimage', 'fromqpixmap', 'fromstring',
'getmodebandnames', 'getmodebands', 'getmodebase', 'getmodetype', 'i8',
'init', 'io', 'isImageType', 'isPath', 'isStringType',
'linear_gradient', 'logger', 'logging', 'math', 'merge', 'new',
'numbers', 'open', 'os', 'preinit', 'radial_gradient',
'register_decoder', 'register_encoder', 'register_extension',
'register_extensions', 'register_mime', 'register_open',
'register_save', 'register_save_all', 'registered_extensions', 'struct',
'sys', 'warnings']
Ce qui me permet de connaître les fonctions que je peux appeler depuis
le code que j'écris.
Parmi les fonctions (méthodes) de la classe (PIL.Image.Image): convert,
putpixel, getpixel, etc.

Justement.
Je suis étonné de ne trouver dans la liste ci-dessus, ni convert, ni
putpixel, ni getpixel.
J'ai avancé...
Avant mon code ne marchait pas et je ne savais pourquoi.
Maintenant, mon code marche, mais je ne sais toujours pas pourquoi
puisque je ne vois, dans PIL.Image aucune fonction convert, putpixel ou
getpixel.
Donc, si je fais juste:
from PIL import Image
je n'ai importé que le module PIL.Image, en faisant simplement
l'économie d'avoir à saisir PIL.Image au profit de Image. La classe
PIL.Image.Image deviendra Image.Image, c'est tout.

Soit.
Je vais donc avoir:
theimage1 = Image.open(blah)
theimage2 = Image.new(blahblah)

OK.
'open' et 'new' font bien partie des fonctions du module Image de PIL.
theimage1.putpixel(blah)
theimage2.show()

Par contre ni 'putpixel' ni 'show' ne sont listées par 'dir(Image)'.
Comment pourrais-je (autrement que par des exemples tirés du web)
savoir que ces fonctions sont disponibles ?
Mais je peux également faire:
Image.Image.putpixel(theimage1, blah)
Image.Image.show(theimage2)

Même remarque.
Cas particulier:
Image._show(theimage2)
fonctionne. C'est un peu un hasard (ne fonctionne pas pour _convert,
qui n'existe pas), même si la pratique est habituelle. _show(unobjet)
est une fonction utile au module PIL.Image, l'underscore indique
qu'elle est vaguement "à usage interne" (peut-être héritée par
PIL.Image.Image, peu importe en fait), elle ne sera pas importée avec
*, ne sera pas documentée, etc. Mais reste parfaitement accessible.

0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
Un code qui utilise des écritures exotiques (les "mais je peux
également...") masque un problème, et doit être corrigé.

Pas compris
Pourquoi (par exemple)
from PIL.Image import *
est *réellement* bad ?
PIL.Image.open() devient open(). Hors open() est une fonction native
largement utilisée, elle sera masquée. Il ne sera pas rare d'avoir à
l'utiliser dans un code incluant PIL.Image.open(). On peut bien sûr
faire import builtins puis builtins.open(), il est clair que c'est
débile, ça casse les habitudes, les templates, le copier-coller de
code, ça fait chier le lecteur du code, et sans doute bien d'autres
choses.

0K.
Bien compris.
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gré
from PIL import Image
dir(PIL.Image)



['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
'CONTAINER', 'CUBIC', 'Callable', 'DECODERS', 'DEFAULT_STRATEGY',
'DecompressionBombError', 'DecompressionBombWarning', 'ENCODERS',
'EXTENSION', 'EXTENT', 'Exif', 'FASTOCTREE', 'FILTERED', 'FIXED',
'FLIP_LEFT_RIGHT', 'FLIP_TOP_BOTTOM', 'FLOYDSTEINBERG', 'HAMMING',
'HAS_PATHLIB', 'HUFFMAN_ONLY', 'ID', 'Image', 'ImageMode',
'ImagePointHandler', 'ImageTransformHandler', 'LANCZOS',
'LIBIMAGEQUANT', 'LINEAR', 'MAXCOVERAGE', 'MAX_IMAGE_PIXELS',
'MEDIANCUT', 'MESH', 'MIME', 'MODES', 'MutableMapping', 'NEAREST',
'NONE', 'NORMAL', 'OPEN', 'ORDERED', 'PERSPECTIVE', 'PILLOW_VERSION',
'Path', 'QUAD', 'RASTERIZE', 'RLE', 'ROTATE_180', 'ROTATE_270',
'ROTATE_90', 'SAVE', 'SAVE_ALL', 'SEQUENCE', 'TRANSPOSE', 'TRANSVERSE',
'TiffTags', 'USE_CFFI_ACCESS', 'WEB', '_E', '_ENDIAN', '_MAPMODES',
'_MODEINFO', '_MODE_CONV', '__builtins__', '__cached__', '__doc__',
'__file__', '__loader__', '__name__', '__package__', '__spec__',
'__version__', '_apply_env_variables', '_check_size',
'_conv_type_shape', '_decompression_bomb_check', '_fromarray_typemap',
'_getdecoder', '_getencoder', '_getscaleoffset',
'_imaging_not_installed', '_initialized', '_plugins', '_show',
'_showxv', '_wedge', 'alpha_composite', 'atexit', 'blend', 'builtins',
'cffi', 'coerce_e', 'composite', 'core', 'deferred_error',
'effect_mandelbrot', 'effect_noise', 'eval', 'fromarray', 'frombuffer',
'frombytes', 'fromqimage', 'fromqpixmap', 'fromstring',
'getmodebandnames', 'getmodebands', 'getmodebase', 'getmodetype',
'i32le', 'i8', 'init', 'io', 'isImageType', 'isPath', 'isStringType',
'linear_gradient', 'logger', 'logging', 'math', 'merge', 'new',
'numbers', 'open', 'os', 'preinit', 'py3', 'radial_gradient',
'register_decoder', 'register_encoder', 'register_extension',
'register_extensions', 'register_mime', 'register_open',
'register_save', 'register_save_all', 'registered_extensions',
'struct', 'sys', 'warnings']
dir(PIL.Image.Image)



['_Image__transformer', '__array_interface__', '__class__', '__copy__',
'__del__', '__delattr__', '__dict__', '__dir__', '__doc__',
'__enter__', '__eq__', '__exit__', '__format__', '__ge__',
'__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
'__setstate__', '__sizeof__', '__str__', '__subclasshook__',
'__weakref__', '_close_exclusive_fp_after_loading', '_copy', '_crop',
'_dump', '_ensure_mutable', '_expand', '_new', '_repr_png_',
'alpha_composite', 'close', 'convert', 'copy', 'crop', 'draft',
'effect_spread', 'filter', 'format', 'format_description', 'frombytes',
'fromstring', 'getbands', 'getbbox', 'getchannel', 'getcolors',
'getdata', 'getexif', 'getextrema', 'getim', 'getpalette', 'getpixel',
'getprojection', 'height', 'histogram', 'load', 'offset', 'paste',
'point', 'putalpha', 'putdata', 'putpalette', 'putpixel', 'quantize',
'remap_palette', 'resize', 'rotate', 'save', 'seek', 'show', 'size',
'split', 'tell', 'thumbnail', 'tobitmap', 'tobytes', 'toqimage',
'toqpixmap', 'tostring', 'transform', 'transpose', 'verify', 'width']




Voilà ;-)
--
Pierre Maurette
Lulu
Le #26523494
Le 17-08-2019, Pierre Maurette
Lulu :
Le 15-08-2019, Pierre Maurette
Lulu :

Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
from PIL import Image
dir(Image)



['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gré

from PIL import Image
dir(PIL.Image)



['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
dir(PIL.Image.Image)



['_Image__transformer', '__array_interface__', '__class__', '__copy__',
[...]
Voilà ;-)

Encore une fois, mille mercis !
En fait, pendant que vous me répondiez, je bossais avec mon beau-frère
qui est prof de Maths et qui a donc plus d'expérience que moi en
python...
Il m'a dit qu'il importait toujours un module avec la syntaxe 'from PIL
import Image' et jamais autrement.
Nous avons compris que :
dir(Image) affiche la liste des _FONCTIONS_ du _MODULE_ PIL.Image



ce qui permet, par exemple d'appeler la _FONCTION_ 'Image._show()' pour
afficher une image grâce au code 'Image._show(the_image)'
help(Image) (équivalente à votre 'dir(PIL.Image.Image)' affiche



les _MÉTHODES_ de la _CLASSE_ PIL.Image.Image, ce qui permet d'appliquer la
_MÉTHODE_ 'show()' à mon objet 'the_image' grâce au code 'the_image.show()'
Pour un newbie comme moi, c'est (c'était !) plutôt confusant.
Merci encore pour votre aide
Lulu
Le #26523493
Le 17-08-2019, Pierre Maurette
Lulu :
Le 15-08-2019, Pierre Maurette
Lulu :

Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
from PIL import Image
dir(Image)



['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gré

from PIL import Image
dir(PIL.Image)



['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
dir(PIL.Image.Image)



['_Image__transformer', '__array_interface__', '__class__', '__copy__',
[...]
Voilà ;-)

Encore une fois, mille mercis !
En fait, pendant que vous me répondiez, je bossais avec mon beau-frère
qui est prof de Maths et qui a donc plus d'expérience que moi en
python...
Il m'a dit qu'il importait toujours un module avec la syntaxe 'from PIL
import Image' et jamais autrement.
Nous avons compris que :
dir(Image) affiche la liste des _FONCTIONS_ du _MODULE_ PIL.Image ce qui
permet, par exemple d'appeler la _FONCTION_ 'Image._show()' pour
afficher une image grâce au code 'Image._show(the_image)'
help(Image) (équivalente à votre 'dir(PIL.Image.Image)' affiche les
_MÉTHODES_ de la _CLASSE_ PIL.Image.Image, ce qui permet d'appliquer la
_MÉTHODE_ 'show()' à mon objet 'the_image' grâce au code 'the_image.show()'
Pour un newbie comme moi, c'est (c'était !) plutôt confusant.
Merci encore pour votre aide
Publicité
Poster une réponse
Anonyme