Bonjour,
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Merci de vos avis
Bonjour,
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Merci de vos avis
Bonjour,
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Merci de vos avis
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Pour créer les listes :
(l, h) = ze_image.size
l1 = [[0,0,0]] * (l*h)
l2 = [[0,0,0]] * (l*h)
l3 = [[0,0,0]] * (l*h)
Reste à remplir avec les données.
GetPixel() est très lent. A n'utiliser que ponctuellement.
Il est préférable de passer par tostring().
Un truc du genre : pix_data = ze_image.convert("RGB").tostring("raw", "RGB")
Si les images sont déjà en RVB, pas forcément besoin d'appeler convert().
pix_data est une liste d'octets R,V,B,R,V,B,R...
Attention, avec les images dont les couleurs sont codées sur plus que
8bits.
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Pour créer les listes :
(l, h) = ze_image.size
l1 = [[0,0,0]] * (l*h)
l2 = [[0,0,0]] * (l*h)
l3 = [[0,0,0]] * (l*h)
Reste à remplir avec les données.
GetPixel() est très lent. A n'utiliser que ponctuellement.
Il est préférable de passer par tostring().
Un truc du genre : pix_data = ze_image.convert("RGB").tostring("raw", "RGB")
Si les images sont déjà en RVB, pas forcément besoin d'appeler convert().
pix_data est une liste d'octets R,V,B,R,V,B,R...
Attention, avec les images dont les couleurs sont codées sur plus que
8bits.
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Pour créer les listes :
(l, h) = ze_image.size
l1 = [[0,0,0]] * (l*h)
l2 = [[0,0,0]] * (l*h)
l3 = [[0,0,0]] * (l*h)
Reste à remplir avec les données.
GetPixel() est très lent. A n'utiliser que ponctuellement.
Il est préférable de passer par tostring().
Un truc du genre : pix_data = ze_image.convert("RGB").tostring("raw", "RGB")
Si les images sont déjà en RVB, pas forcément besoin d'appeler convert().
pix_data est une liste d'octets R,V,B,R,V,B,R...
Attention, avec les images dont les couleurs sont codées sur plus que
8bits.
Bonjour,
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Merci de vos avis
Bonjour,
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Merci de vos avis
Bonjour,
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Merci de vos avis
Fondamentalement une réponse est dans zip(*zipped).
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs = [(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu) = list(zip(*RVBs))
im_rouge = [(x, 0, 0) for x in _rouge]
im_vert = [(0, x, 0) for x in _vert]
im_bleu = [(0, 0, x) for x in _bleu]
print(im_rouge)
print(im_vert)
print(im_bleu)
Remarques:
Avez-vous vraiment besoin d'une image "RVB" pour chaque channel ? Normalement
un channel se représente dans une image "L".
Peut-être y a-t-il moyen de tout faire à partir de PIL (Image.split(),
Image.getchannel(channel), et des fonctions de convertion ).
Fondamentalement une réponse est dans zip(*zipped).
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs = [(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu) = list(zip(*RVBs))
im_rouge = [(x, 0, 0) for x in _rouge]
im_vert = [(0, x, 0) for x in _vert]
im_bleu = [(0, 0, x) for x in _bleu]
print(im_rouge)
print(im_vert)
print(im_bleu)
Remarques:
Avez-vous vraiment besoin d'une image "RVB" pour chaque channel ? Normalement
un channel se représente dans une image "L".
Peut-être y a-t-il moyen de tout faire à partir de PIL (Image.split(),
Image.getchannel(channel), et des fonctions de convertion ).
Fondamentalement une réponse est dans zip(*zipped).
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs = [(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu) = list(zip(*RVBs))
im_rouge = [(x, 0, 0) for x in _rouge]
im_vert = [(0, x, 0) for x in _vert]
im_bleu = [(0, 0, x) for x in _bleu]
print(im_rouge)
print(im_vert)
print(im_bleu)
Remarques:
Avez-vous vraiment besoin d'une image "RVB" pour chaque channel ? Normalement
un channel se représente dans une image "L".
Peut-être y a-t-il moyen de tout faire à partir de PIL (Image.split(),
Image.getchannel(channel), et des fonctions de convertion ).
Lulu :Bonjour,
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Merci de vos avis
Fondamentalement une réponse est dans zip(*zipped).
zipped = list(zip([1,2,3],[4,5,6])
zipped
[(1,4),(2,5),(3,6)]
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs =
[(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu) = list(zip(*RVBs))
(x,y) = list(zip(*zipped))
x
im_rouge = [(x, 0, 0) for x in _rouge]
im_vert = [(0, x, 0) for x in _vert]
im_bleu = [(0, 0, x) for x in _bleu]
print(im_rouge)
print(im_vert)
print(im_bleu)
Remarques:
Avez-vous vraiment besoin d'une image "RVB" pour chaque channel ?
Normalement un channel se représente dans une image "L".
Peut-être y a-t-il moyen de tout faire à partir de PIL (Image.split(),
Image.getchannel(channel), et des fonctions de convertion ).
Lulu :
Bonjour,
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Merci de vos avis
Fondamentalement une réponse est dans zip(*zipped).
zipped = list(zip([1,2,3],[4,5,6])
zipped
[(1,4),(2,5),(3,6)]
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs =
[(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu) = list(zip(*RVBs))
(x,y) = list(zip(*zipped))
x
im_rouge = [(x, 0, 0) for x in _rouge]
im_vert = [(0, x, 0) for x in _vert]
im_bleu = [(0, 0, x) for x in _bleu]
print(im_rouge)
print(im_vert)
print(im_bleu)
Remarques:
Avez-vous vraiment besoin d'une image "RVB" pour chaque channel ?
Normalement un channel se représente dans une image "L".
Peut-être y a-t-il moyen de tout faire à partir de PIL (Image.split(),
Image.getchannel(channel), et des fonctions de convertion ).
Lulu :Bonjour,
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).
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Merci de vos avis
Fondamentalement une réponse est dans zip(*zipped).
zipped = list(zip([1,2,3],[4,5,6])
zipped
[(1,4),(2,5),(3,6)]
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs =
[(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu) = list(zip(*RVBs))
(x,y) = list(zip(*zipped))
x
im_rouge = [(x, 0, 0) for x in _rouge]
im_vert = [(0, x, 0) for x in _vert]
im_bleu = [(0, 0, x) for x in _bleu]
print(im_rouge)
print(im_vert)
print(im_bleu)
Remarques:
Avez-vous vraiment besoin d'une image "RVB" pour chaque channel ?
Normalement un channel se représente dans une image "L".
Peut-être y a-t-il moyen de tout faire à partir de PIL (Image.split(),
Image.getchannel(channel), et des fonctions de convertion ).
Pierre Maurette :
[...]Fondamentalement une réponse est dans zip(*zipped).
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs = [(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu) = list(zip(*RVBs))
im_rouge = [(x, 0, 0) for x in _rouge]
im_vert = [(0, x, 0) for x in _vert]
im_bleu = [(0, 0, x) for x in _bleu]
print(im_rouge)
print(im_vert)
print(im_bleu)
Pour info, en utilisant zip et une liste de "0" (zob):
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs =
[(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu, zob) = list(zip(*RVBs)) + [([0,] * len(RVBs)),]
(im_rouge, im_vert, im_bleu) = (list(zip(_rouge, zob, zob)),
list(zip(zob, _vert, zob)), list(zip(zob, zob, _bleu)))
print(im_rouge)
print(im_vert)
print(im_bleu)
Pierre Maurette :
[...]
Fondamentalement une réponse est dans zip(*zipped).
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs = [(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu) = list(zip(*RVBs))
im_rouge = [(x, 0, 0) for x in _rouge]
im_vert = [(0, x, 0) for x in _vert]
im_bleu = [(0, 0, x) for x in _bleu]
print(im_rouge)
print(im_vert)
print(im_bleu)
Pour info, en utilisant zip et une liste de "0" (zob):
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs =
[(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu, zob) = list(zip(*RVBs)) + [([0,] * len(RVBs)),]
(im_rouge, im_vert, im_bleu) = (list(zip(_rouge, zob, zob)),
list(zip(zob, _vert, zob)), list(zip(zob, zob, _bleu)))
print(im_rouge)
print(im_vert)
print(im_bleu)
Pierre Maurette :
[...]Fondamentalement une réponse est dans zip(*zipped).
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs = [(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu) = list(zip(*RVBs))
im_rouge = [(x, 0, 0) for x in _rouge]
im_vert = [(0, x, 0) for x in _vert]
im_bleu = [(0, 0, x) for x in _bleu]
print(im_rouge)
print(im_vert)
print(im_bleu)
Pour info, en utilisant zip et une liste de "0" (zob):
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
RVBs =
[(1,2,3),(11,12,13),(21,22,23),(31,32,33),(411,412,413),(521,522,523)]
print(RVBs)
(_rouge, _vert, _bleu, zob) = list(zip(*RVBs)) + [([0,] * len(RVBs)),]
(im_rouge, im_vert, im_bleu) = (list(zip(_rouge, zob, zob)),
list(zip(zob, _vert, zob)), list(zip(zob, zob, _bleu)))
print(im_rouge)
print(im_vert)
print(im_bleu)
Je n'ai effectivement pas besoin d'une image RVB pour chaque channel,
mais mes élèves, oui !
C'est à but pédagogique, ils ont besoin que la composante rouge d'une
image soit... rouge.
Je n'ai effectivement pas besoin d'une image RVB pour chaque channel,
mais mes élèves, oui !
C'est à but pédagogique, ils ont besoin que la composante rouge d'une
image soit... rouge.
Je n'ai effectivement pas besoin d'une image RVB pour chaque channel,
mais mes élèves, oui !
C'est à but pédagogique, ils ont besoin que la composante rouge d'une
image soit... rouge.
Le 27-03-2020, Nicolas 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...
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Pour créer les listes :
(l, h) = ze_image.size
l1 = [[0,0,0]] * (l*h)
l2 = [[0,0,0]] * (l*h)
l3 = [[0,0,0]] * (l*h)
Merci, je ne savais pas qu'on pouvait faire cette opération sur une
liste.Reste à remplir avec les données.
Mais je ne vois pas comment faire...GetPixel() est très lent. A n'utiliser que ponctuellement.
Oui, j'ai vu.Il est préférable de passer par tostring().
Un truc du genre : pix_data = ze_image.convert("RGB").tostring("raw", "RGB")
Si les images sont déjà en RVB, pas forcément besoin d'appeler convert().
pix_data est une liste d'octets R,V,B,R,V,B,R...
Je ne vois pas du tout comment remplir les listes l1, l2 et l3 avec ton
exemple de « ze_image.convert("RGB").tostring("raw", "RGB") ».
J'ai cherché ce que pouvait faire cette fonction, mais les exemples que
j'ai trouvés me semblent sans aucun rapport avec mon problème.
Attention, avec les images dont les couleurs sont codées sur plus que
8bits.
Oui, je n'avais pas pensé à ce problème.
Merci pour ton aide.
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...
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Pour créer les listes :
(l, h) = ze_image.size
l1 = [[0,0,0]] * (l*h)
l2 = [[0,0,0]] * (l*h)
l3 = [[0,0,0]] * (l*h)
Merci, je ne savais pas qu'on pouvait faire cette opération sur une
liste.
Reste à remplir avec les données.
Mais je ne vois pas comment faire...
GetPixel() est très lent. A n'utiliser que ponctuellement.
Oui, j'ai vu.
Il est préférable de passer par tostring().
Un truc du genre : pix_data = ze_image.convert("RGB").tostring("raw", "RGB")
Si les images sont déjà en RVB, pas forcément besoin d'appeler convert().
pix_data est une liste d'octets R,V,B,R,V,B,R...
Je ne vois pas du tout comment remplir les listes l1, l2 et l3 avec ton
exemple de « ze_image.convert("RGB").tostring("raw", "RGB") ».
J'ai cherché ce que pouvait faire cette fonction, mais les exemples que
j'ai trouvés me semblent sans aucun rapport avec mon problème.
Attention, avec les images dont les couleurs sont codées sur plus que
8bits.
Oui, je n'avais pas pensé à ce problème.
Merci pour ton aide.
Le 27-03-2020, Nicolas 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...
Mon code :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PIL import Image
Fichier_Image = "Anna_et_Lulu.jpg"
ze_image = Image.open( Fichier_Image ).convert("RGB")
ze_image.show()
(l, h) = ze_image.size
# création de l'image rouge
ze_image_rouge = Image.new("RGB",(l,h))
# traitement pixel par pixel :
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.putpixel((x,y), ( rouge, 0, 0))
# création en mémoire de l'image rouge
ze_image_rouge_fast = Image.new("RGB",(l,h))
liste_pixels = list(ze_image.getdata())
liste_pixels_rouges=[]
for i in range(len(liste_pixels)):
liste_pixels_rouges.append((liste_pixels[i][0], 0, 0))
ze_image_rouge_fast.putdata(liste_pixels_rouges)
ze_image_rouge.show()
ze_image_rouge_fast.show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Sur une image de 1.600.000 pixels, la première double boucle avec deux
for imbriqués bricole pendant 7 secondes (pas très étonnant), mais la
deuxième boucle qui remplit trois listes n'est que 4 fois plus rapide.
Je crois que c'est en jouant sur ma manière de créer ces trois listes et
de les remplir que je peux gagner le plus.
Pour créer les listes :
(l, h) = ze_image.size
l1 = [[0,0,0]] * (l*h)
l2 = [[0,0,0]] * (l*h)
l3 = [[0,0,0]] * (l*h)
Merci, je ne savais pas qu'on pouvait faire cette opération sur une
liste.Reste à remplir avec les données.
Mais je ne vois pas comment faire...GetPixel() est très lent. A n'utiliser que ponctuellement.
Oui, j'ai vu.Il est préférable de passer par tostring().
Un truc du genre : pix_data = ze_image.convert("RGB").tostring("raw", "RGB")
Si les images sont déjà en RVB, pas forcément besoin d'appeler convert().
pix_data est une liste d'octets R,V,B,R,V,B,R...
Je ne vois pas du tout comment remplir les listes l1, l2 et l3 avec ton
exemple de « ze_image.convert("RGB").tostring("raw", "RGB") ».
J'ai cherché ce que pouvait faire cette fonction, mais les exemples que
j'ai trouvés me semblent sans aucun rapport avec mon problème.
Attention, avec les images dont les couleurs sont codées sur plus que
8bits.
Oui, je n'avais pas pensé à ce problème.
Merci pour ton aide.
Le 27/03/2020 à 15:29, Lulu a écrit :Le 27-03-2020, Nicolas 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)]
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.
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),....)
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)]
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.
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),....)
Le 27/03/2020 à 15:29, Lulu a écrit :Le 27-03-2020, Nicolas 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)]
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.
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),....)
Je n'ai effectivement pas besoin d'une image RVB pour chaque channel,
mais mes élèves, oui !
C'est à but pédagogique, ils ont besoin que la composante rouge d'une
image soit... rouge.
Pour des élèves de seconde, je n'irai pas dans la voie "zip()".
Mon fils a pris la spécialisation NSI (il est en seconde).
Le programme est très chargé, voire même absurde. Apprendre à coder des
nombres à virgule fixe et des nombres à virgule flottante alors qu'ils
n'ont même pas intégré la logique de base... Mais je m'égare.
Donc, le programme est très chargé et les élèves ont (beaucoup) de mal a
digérer tout ce qu'ils doivent ingurgiter. Leur faire manipuler des
listes, c'est fondamental en Python. Mais, à mon avis, il faut rester le
plus simple possible.
Qu'elle est la différence entre
l = [1, 3, 5, 9]
for e in l :
print(e)
et
l = [1, 3, 5, 9]
for i in range(len(l)) :
print(l[i])
Dans quel cas faut-il utiliser la 1ere forme ? La deuxième forme ?
Ce sont des exemples simples mais ils en sont encore, pour beaucoup, à
mélanger les deux formes d'écriture.
"zip()" est très utile mais le risque de les embrouiller est là.
Il vaut mieux leur apprendre à parfaitement maitriser les bases.
Mais ce n'est que mon avis ;)
Je n'ai effectivement pas besoin d'une image RVB pour chaque channel,
mais mes élèves, oui !
C'est à but pédagogique, ils ont besoin que la composante rouge d'une
image soit... rouge.
Pour des élèves de seconde, je n'irai pas dans la voie "zip()".
Mon fils a pris la spécialisation NSI (il est en seconde).
Le programme est très chargé, voire même absurde. Apprendre à coder des
nombres à virgule fixe et des nombres à virgule flottante alors qu'ils
n'ont même pas intégré la logique de base... Mais je m'égare.
Donc, le programme est très chargé et les élèves ont (beaucoup) de mal a
digérer tout ce qu'ils doivent ingurgiter. Leur faire manipuler des
listes, c'est fondamental en Python. Mais, à mon avis, il faut rester le
plus simple possible.
Qu'elle est la différence entre
l = [1, 3, 5, 9]
for e in l :
print(e)
et
l = [1, 3, 5, 9]
for i in range(len(l)) :
print(l[i])
Dans quel cas faut-il utiliser la 1ere forme ? La deuxième forme ?
Ce sont des exemples simples mais ils en sont encore, pour beaucoup, à
mélanger les deux formes d'écriture.
"zip()" est très utile mais le risque de les embrouiller est là.
Il vaut mieux leur apprendre à parfaitement maitriser les bases.
Mais ce n'est que mon avis ;)
Je n'ai effectivement pas besoin d'une image RVB pour chaque channel,
mais mes élèves, oui !
C'est à but pédagogique, ils ont besoin que la composante rouge d'une
image soit... rouge.
Pour des élèves de seconde, je n'irai pas dans la voie "zip()".
Mon fils a pris la spécialisation NSI (il est en seconde).
Le programme est très chargé, voire même absurde. Apprendre à coder des
nombres à virgule fixe et des nombres à virgule flottante alors qu'ils
n'ont même pas intégré la logique de base... Mais je m'égare.
Donc, le programme est très chargé et les élèves ont (beaucoup) de mal a
digérer tout ce qu'ils doivent ingurgiter. Leur faire manipuler des
listes, c'est fondamental en Python. Mais, à mon avis, il faut rester le
plus simple possible.
Qu'elle est la différence entre
l = [1, 3, 5, 9]
for e in l :
print(e)
et
l = [1, 3, 5, 9]
for i in range(len(l)) :
print(l[i])
Dans quel cas faut-il utiliser la 1ere forme ? La deuxième forme ?
Ce sont des exemples simples mais ils en sont encore, pour beaucoup, à
mélanger les deux formes d'écriture.
"zip()" est très utile mais le risque de les embrouiller est là.
Il vaut mieux leur apprendre à parfaitement maitriser les bases.
Mais ce n'est que mon avis ;)