Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > fr.comp.lang.python > #3315

Re: vitesse manipulation liste (generateur ?)

Show all headers | View raw

Le 28-03-2020, Nicolas <nicolasp@aaton.com> a écrit :
>  Le 27/03/2020 à 15:29, Lulu a écrit :
>> Le 27-03-2020, Nicolas <nicolasp@aaton.com> a écrit :
>>>   Le 27/03/2020 à 00:50, Lulu a écrit :
>>   
>>>> J'ai besoin de manipuler des listes rapidement pour manipuler une image.
>>>> D'une liste ((r,v,b),(a,b,c),(x,y,z),.....), je veux passer à trois
>>>> listes :
>>>> ((r,0,0),(a,0,0),(x,0,0),....)
>>>> ((0,v,0),(0,b,0),(0,y,0),....)
>>>> ((0,0,b),(0,0,c),(0,0,z),....)
>>>>
>>>> Et je veux faire ça le plus rapidement possible.
>>>> J'imagine que ça pourrait passer par un générateur, mais je ne sais pas
>>>> comment en "fabriquer" et les exemples que je trouve sur le web ne
>>>> m'aident pas vraiment. (plus essais infructueux).
>> 
>> J'avais aussi essayé la "compréhension de liste" (par exemple ici :
>> https://openclassrooms.com/fr/courses/1206331-utilisation-avancee-des-listes-en-python
>> ), mais je n'ai rien compris...
>> 
>  La compréhension de liste, c'est pas compliqué.
> 
>  ----------------------
>  Soit le code suivant :
> 
>  l_in = [1, 45, 89, 56, 4]
> 
>  l_out = []
>  for e in l_in :
>       l_out.append(e)
> 
>  C'est exactement la même chose que :
>  l_out = [e for e in l_in]
> 
>  --------------------------
>  On peut compléter un peu :
> 
>  l_out = []
>  for e in l_in :
>       l_out.append(traitement(e))
> 
>  est équivalent à :
>  l_out = [traitement(e) for e in l_in]
> 
>  ------------------
>  Version complète :
>  l_out = []
>  for e in l_in :
>       if is_ok(e) :
>           l_out.append(traitement(e))
> 
>  est équivalent à :
>  l_out = [traitement(e) for e in l_in if is_ok(e)]

où j'imagine que traitement() et ok() sont deux fonctions ? 

>  Les 4 lignes sont "mises à plat" en une seule ligne.
> 
>  Ca serait plus facile à expliquer avec des couleurs ou un dessin mais, 
>  sur la mailing list, c'est pas possible.

Donc pour mon exemple de liste de tuples.

>>>> D'une liste ((r,v,b),(a,b,c),(x,y,z),.....), je veux passer à trois
>>>> listes :
>>>> ((r,0,0),(a,0,0),(x,0,0),....)
>>>> ((0,v,0),(0,b,0),(0,y,0),....)
>>>> ((0,0,b),(0,0,c),(0,0,z),....)

j'obtiens mes 3 listes avec l1 = [ (e[0], 0, 0) for e in l_in ]
l2 = [ (0, e[1], 0) for e in l_in ] et l3 = [ (0, 0, e[2]) for e in l_in ]

(Bizarrement, c'est aussi l'exemple de zip(list) et zip(*list)) donné
par Pierre qui m'a aussi permis de comprendre ;-)

Donc mille mercis encore à vous deux.

Je viens de tester dans mon script et la manipulation de liste par
compréhension est la plus rapide des 4 manipulations que je tente :
-=-=-=-
Image :  ws_SBK-07_0834.jpg
taille de l'image : 1024 px × 768 px
nombre de pixels : 786432
-=-=-=-
1: Traitement par une boucle sur les 786432 pixels.
durée = 9.874 seconde(s)
-=-=-=-
2: Traitement par boucle avec list.append().
durée = 2.402 seconde(s)
4 fois plus rapide.
-=-=-=-
3: Traitement par compréhension de liste.
durée = 1.495 seconde(s)
6 fois plus rapide.
-=-=-=-
4: Traitement par split avec zip(*liste) et merge par zip(liste).
durée = 2.786 seconde(s)
3 fois plus rapide.
-=-=-=-
5: Traitement par split de liste et fausse compréhension
durée = 2.688 seconde(s)
3 fois plus rapide.
-=-=-=-
6: Traitement par Image.split().
durée = 0.002264 seconde(s)
4361 fois plus rapide.

Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys
from datetime import datetime
from PIL import Image, ImageFilter

# Fichier_Image = "Les_Horribles_Cernettes.png"
# Fichier_Image = "avengers-endseries-comics.png"
# Fichier_Image = "Anna_et_Lulu.jpg"
Fichier_Image = "ws_SBK-07_0834.jpg"
# Fichier_Image = "Sauzon.jpg"

print("-=-=-=-\nImage : ", Fichier_Image)
try:
    ze_image = Image.open( Fichier_Image ).convert("RGB")
except:
    print('\n' * 2)
    print("    Erreur : le fichier \n",Fichier_Image,"\" existe-t-il ?")
    print('\n' * 2)
    sys.exit(1)

# j'appelle la méthode 'show' de la classe PIL.Image.Image (liste des méthodes help(Image))
ze_image.show()

(l, h) = ze_image.size
print("taille de l'image :", l, "px ×", h, "px")
nb_pixels = l*h
print("nombre de pixels :",nb_pixels)


#    1er procédé


# création en mémoire des 3 images à calculer
ze_image_rouge_p1 = Image.new("RGB",(l,h))
ze_image_verte_p1 = Image.new("RGB",(l,h))
ze_image_bleue_p1 = Image.new("RGB",(l,h))

# mesure du temps de traitement :
timestamp_debut = datetime.timestamp(datetime.now())
# traitement pixel par pixel :
print("-=-=-=-\n1: Traitement par une boucle sur les", nb_pixels,"pixels.")
for y in range(h):                  # pour y variant de 0 à h-1
    for x in range(l):              # pour x variant de 0 à l-1
        (rouge, vert, bleu) = ze_image.getpixel((x,y))

        ze_image_rouge_p1.putpixel((x,y), ( rouge, 0, 0))
        ze_image_verte_p1.putpixel((x,y), ( 0, vert, 0))
        ze_image_bleue_p1.putpixel((x,y), ( 0, 0, bleu))

# mesure du temps de traitement :
timestamp_fin = datetime.timestamp(datetime.now())
duree_1 = timestamp_fin - timestamp_debut
print('durée =',"{:0.3f}".format(duree_1),"seconde(s)")


#    2ème procédé


# création en mémoire des 3 images à calculer
ze_image_rouge_p2 = Image.new("RGB",(l,h))
ze_image_verte_p2 = Image.new("RGB",(l,h))
ze_image_bleue_p2 = Image.new("RGB",(l,h))

liste_pixels = []
liste_pixels_rouges = []
liste_pixels_verts =[]
liste_pixels_bleus = []

print("-=-=-=-\n2: Traitement par boucle avec list.append().")
timestamp_debut = datetime.timestamp(datetime.now())

liste_pixels = list(ze_image.getdata())

for i in range(len(liste_pixels)):
    liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
    liste_pixels_verts.append((0, liste_pixels[i][1], 0))
    liste_pixels_bleus.append((0, 0, liste_pixels[i][2]))

ze_image_rouge_p2.putdata(liste_pixels_rouges)
ze_image_verte_p2.putdata(liste_pixels_verts)
ze_image_bleue_p2.putdata(liste_pixels_bleus)

timestamp_fin = datetime.timestamp(datetime.now())
duree_2 = timestamp_fin - timestamp_debut
print('durée =',"{:0.3f}".format(duree_2),"seconde(s)")
print(int(duree_1/duree_2), "fois plus rapide.")


#    3ème procédé


# création en mémoire des 3 images à calculer
ze_image_rouge_p3 = Image.new("RGB",(l,h))
ze_image_verte_p3 = Image.new("RGB",(l,h))
ze_image_bleue_p3 = Image.new("RGB",(l,h))

liste_pixels = []
# liste_pixels_rouges = []
liste_pixels_verts =[]
liste_pixels_bleus = []

print("-=-=-=-\n3: Traitement par compréhension de liste.")
timestamp_debut = datetime.timestamp(datetime.now())

liste_pixels = list(ze_image.getdata())
#print("liste_pixels[:30] = ", liste_pixels[:30])

liste_pixels_rouges = [ (e[0], 0, 0) for e in liste_pixels ]
liste_pixels_verts =  [ (0, e[1], 0) for e in liste_pixels ]
liste_pixels_bleus =  [ (0, 0, e[2]) for e in liste_pixels ]

ze_image_rouge_p3.putdata(liste_pixels_rouges)
ze_image_verte_p3.putdata(liste_pixels_verts)
ze_image_bleue_p3.putdata(liste_pixels_bleus)

timestamp_fin = datetime.timestamp(datetime.now())
duree_3 = timestamp_fin - timestamp_debut
print('durée =',"{:0.3f}".format(duree_3),"seconde(s)")
print(int(duree_1/duree_3), "fois plus rapide.")


#    4ème procédé


# création en mémoire des 3 images à calculer
ze_image_rouge_p4 = Image.new("RGB",(l,h))
ze_image_verte_p4 = Image.new("RGB",(l,h))
ze_image_bleue_p4 = Image.new("RGB",(l,h))

liste_pixels = []
liste_pixels_rouges = []
liste_pixels_verts =[]
liste_pixels_bleus = []
liste_pixels_zero = []

print("-=-=-=-\n4: Traitement par split avec zip(*liste) et merge par zip(liste).")
timestamp_debut = datetime.timestamp(datetime.now())

liste_pixels = list(ze_image.getdata())

liste_pixels_rouges, liste_pixels_verts, liste_pixels_bleus = list(zip(*liste_pixels))
liste_pixels_zero = [0] * nb_pixels

ze_image_rouge_p4.putdata(list(zip(liste_pixels_rouges, liste_pixels_zero, liste_pixels_zero)))
ze_image_verte_p4.putdata(list(zip(liste_pixels_zero, liste_pixels_verts, liste_pixels_zero)))
ze_image_bleue_p4.putdata(list(zip(liste_pixels_zero, liste_pixels_zero, liste_pixels_bleus)))

timestamp_fin = datetime.timestamp(datetime.now())
duree_4 = timestamp_fin - timestamp_debut
print('durée =',"{:0.3f}".format(duree_4),"seconde(s)")
print(int(duree_1/duree_4), "fois plus rapide.")


#    5ème procédé


liste_pixels = []
liste_pixels_rouges = []
liste_pixels_verts =[]
liste_pixels_bleus = []
liste_pixels_zero = []

ze_image_rouge_p5 = Image.new("RGB",(l,h))
ze_image_verte_p5 = Image.new("RGB",(l,h))
ze_image_bleue_p5 = Image.new("RGB",(l,h))
print("-=-=-=-\n5: Traitement par split de liste et fausse compréhension")
timestamp_debut = datetime.timestamp(datetime.now())

liste_pixels = list(ze_image.getdata())
liste_pixels_rouges, liste_pixels_verts, liste_pixels_bleus = list(zip(*liste_pixels))

liste_pixels_rouges = [(x, 0, 0) for x in liste_pixels_rouges ]
liste_pixels_verts = [(0, x, 0) for x in liste_pixels_verts ]
liste_pixels_bleus = [(0, 0, x) for x in liste_pixels_bleus ]

ze_image_rouge_p5.putdata(liste_pixels_rouges)
ze_image_verte_p5.putdata(liste_pixels_verts)
ze_image_bleue_p5.putdata(liste_pixels_bleus)

timestamp_fin = datetime.timestamp(datetime.now())
duree_5 = timestamp_fin - timestamp_debut
print('durée =',"{:0.3f}".format(duree_5),"seconde(s)")
print(int(duree_1/duree_5), "fois plus rapide.")


#    6ème procédé


print("-=-=-=-\n6: Traitement par Image.split().")
timestamp_debut = datetime.timestamp(datetime.now())

ze_image_splited = Image.Image.split(ze_image)

timestamp_fin = datetime.timestamp(datetime.now())
duree_6 = timestamp_fin - timestamp_debut
print('durée =',"{:0.6f}".format(duree_6),"seconde(s)")
print(int(duree_1/duree_6), "fois plus rapide.")

x = input("Afficher les images [O/n] ? ")
if x == "" or x[0] == "o" or x[0] == "O" :
	ze_image_rouge_p1.show()
	ze_image_verte_p1.show()
	ze_image_bleue_p1.show()

	ze_image_rouge_p2.show()
	ze_image_verte_p2.show()
	ze_image_bleue_p2.show()

	ze_image_rouge_p3.show()
	ze_image_verte_p3.show()
	ze_image_bleue_p3.show()

	ze_image_rouge_p4.show()
	ze_image_verte_p4.show()
	ze_image_bleue_p4.show()

	ze_image_rouge_p5.show()
	ze_image_verte_p5.show()
	ze_image_bleue_p5.show()

	ze_image_splited[0].show()
	ze_image_splited[1].show()
	ze_image_splited[2].show()

Back to fr.comp.lang.python | Previous | Next — Previous in thread | Next in thread | Find similar

Thread

vitesse manipulation liste (generateur ?) Lulu <lulu042@fry.fr.invalid> - 2020-03-27 00:50 +0100
  Re: vitesse manipulation liste (generateur ?) Nicolas <nicolasp@aaton.com> - 2020-03-27 13:12 +0100
    Re: vitesse manipulation liste (generateur ?) Lulu <lulu042@fry.fr.invalid> - 2020-03-27 15:29 +0100
      Re: vitesse manipulation liste (generateur ?) Nicolas <nicolasp@aaton.com> - 2020-03-28 12:27 +0100
        Re: vitesse manipulation liste (generateur ?) Lulu <lulu042@fry.fr.invalid> - 2020-03-28 18:08 +0100
          Re: vitesse manipulation liste (generateur ?) Nicolas <nicolasp@aaton.com> - 2020-03-28 21:38 +0100
  Re: vitesse manipulation liste (generateur ?) Pierre Maurette <maurette.pierre@free.fr> - 2020-03-27 17:36 +0100
    Re: vitesse manipulation liste (generateur ?) Pierre Maurette <maurette.pierre@free.fr> - 2020-03-27 17:38 +0100
      Re: vitesse manipulation liste (generateur ?) Lulu <lulu042@fry.fr.invalid> - 2020-03-28 01:00 +0100
    Re: vitesse manipulation liste (generateur ?) Lulu <lulu042@fry.fr.invalid> - 2020-03-28 00:57 +0100
      Re: vitesse manipulation liste (generateur ?) Nicolas <nicolasp@aaton.com> - 2020-03-28 12:12 +0100
        Re: vitesse manipulation liste (generateur ?) Lulu <lulu042@fry.fr.invalid> - 2020-03-28 19:15 +0100
          Re: vitesse manipulation liste (generateur ?) Nicolas <nicolasp@aaton.com> - 2020-03-28 21:26 +0100
            Re: vitesse manipulation liste (generateur ?) Lulu <lulu042@fry.fr.invalid> - 2020-03-30 16:54 +0200
  Re: vitesse manipulation liste (generateur ?) ast <ast@invalid> - 2020-04-09 13:27 +0200

csiph-web