créer liste avec valeurs max d'autres listes

Version imprimable

26/05/2021, 16h53
rg71800

créer liste avec valeurs max d'autres listes

bonjour tout le monde

voila ma question

j'ai plusieurs listes par exemples

liste1 = [1, 2, 9, 7, 2, 6]
liste2 = [4, 7, 2, 8, 1, 5]

et je voudrais créer une liste3 qui serait composée de la valeur max des 1er items puis de la valeur max des seconds items et ainsi de suite pour arriver a :

liste3 = [4, 7, 9, 8, 2, 6]

si quelqu'un pouvait m'éclaire sur la méthode je serais ravi
merci d'avance
26/05/2021, 18h03
marco056

A la main, tu ferais comment ?
Pour i allant de 0 à len(liste1), tu compares liste1[i] et tu l'ajoutes à une liste vide créé auparavant ?
Montre-nous un peu ce que tu as ébauché, on pourra t'aiguiller plus facilement...
26/05/2021, 18h03
wiztricks

Salut,

Citation:

Envoyé par rg71800

si quelqu'un pouvait m'éclaire sur la méthode je serais ravi

De façon basique, s'il n'y a qu'une liste au départ, à chaque itération on ajoute l'élément correspondant à la liste à fabriquer.
S'il y a plusieurs listes au départ, à chaque itération, il va falloir trouver le max à la position correspondante des différentes listes pour l'ajouter à la liste à fabriquer.

Qu'est ce qui vous bloque?

Après avec Python, on peut aussi faire çà en une ligne: [ max(z) for z in zip(liste1, liste2) ] mais c'est mieux de savoir se dépatouiller avec les boucles basiques avant...

- W
27/05/2021, 21h11
Invité
Salut !

Citation:

Envoyé par wiztricks

[ max(z) for z in zip(liste1, liste2) ]

Je viens de faire la même chose avant de lire ton message : 8-)
Code:

1 2 >>> [max(x) for x in zip(l1,l2)] [4, 7, 9, 8, 2, 6]
Sinon j'ai pensé à ça :
Code:

1 2 >>> [x if x>liste2[i] else liste2[i] for i,x in enumerate(liste1)] [4, 7, 9, 8, 2, 6]
(Pas compris pourquoi on peut pas mettre le else derrière la boucle alors que le if seul oui...)

Pour plus d'info, un tuto assez complet (imbrication et compagnie) : https://code.tutsplus.com/fr/tutoria...hon--cms-26836

merci pour vos réponses

je crois que je m'étais un peu perdu dans mes réflexions :? et vos réponses m'ont remis sur la bonne voie

du coup j'ai écris plusieurs versions

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
liste1 = [1, 2, 3, 8, 4]
liste2 = [3, 4, 5, 2, 3]
liste3 = [9, 1, 4, 7, 9]
 
liste_max = []
for i, j, k in zip(liste1, liste2, liste3):
	liste_max.append(max(i,j, k))
print(liste_max)
 
 
liste_max1 = [max(i) for i in zip(liste1, liste2, liste3)]
print(liste_max1)
 
 
liste_max2 = []
for i in range(0, len(liste1)) :
	if liste1[i] > liste2[i] and liste1[i] > liste3[i]:
		liste_max2.append(liste1[i])
 
	elif liste2[i] > liste1[i] and liste2[i] > liste3[i]:
		liste_max2.append(liste2[i])
 
	else:
		liste_max2.append(liste3[i])
print(liste_max2)

maintenant il y a peut être mieux a faire

Bonjour

Citation:

Envoyé par LeNarvalo

(Pas compris pourquoi on peut pas mettre le else derrière la boucle alors que le if seul oui...)

Parce que ce n'est pas la même chose
Dans un cas, v1 if expr else v2 se lit "si expression vraie alors v1 sinon v2", équivalent au ternaire du C expr ?v1 :v2. On peut trouver parfois une autre formulation expr and v1 or v2 mais elle est moins "safe" car si v1 est considéré faux, alors on aura v2, chose qui ne se produit pas avec la première écriture. Exemple var=0 if True else 123 => résultat var=0, alors que var=True and 0 or 123 => resultat var=123.

Dans l'autre cas, (v for x in iterable if expr) se lit "pour chaque x pris dans l'itérable on aura v à condition que expr (sous-entendu "pour le x en cours") soit vrai". Dans ce cas, pas de "else" car de toute façon si expr est faux le "sinon rien" est implicite. Et si tu veux faire "v1 ou v2 selon l'expression vrai/faux" alors tu inclus la première écriture style (v1 if expr else v2 for x in iterable).

Citation:

Envoyé par rg71800

maintenant il y a peut être mieux a faire

En cas de doute, se référer à la philosophie Python "simple is better than complex". Déjà il est clair que ta 3° solution à base de tests dans tous les sens est à chier face aux autres possibilités bien plus simples.

Maintenant, pourquoi tes listes sont distinctes? 3 listes (ou 3 nombres ou 3 strings) c'est déjà un tableau (de strings, de nombres, de listes !!!)...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #!/usr/bin/env python3 # coding: utf-8 tab=[ [1, 2, 3, 8, 4], [3, 4, 5, 2, 3], [9, 1, 4, 7, 9], ] liste_max = [] for elem in zip(*tab): liste_max.append(max(*elem)) print(liste_max) liste_max1 = tuple(max(i) for i in zip(*tab)) print(liste_max1)
Et là, tu peux rajouter 50 autres listes dans le tableau, t'as rien d'autre à changer le code fonctionne tout pareil.

Sinon append() étant une opération (relativement) lourde, je préfère la dernière méthode qui crée le résultat en un shot. D'autant plus que dans ce cas là cela permet de le mettre en tuple encore moins coûteux qu'une liste.

28/05/2021, 11h48
fred1599
Hello,

@Sve@r

À mon sens, tes deux solutions se valent question performance... le fait de transformer en tuple le résultat calculer en RAM prendra autant de temps que le premier code.

Il est préférable de faire

Code:

return [e for e in tab]

que

Code:

return tuple((e for e in tab))

même question performance, car l'objectif ici est bien d'ajouter des éléments, et que la liste est faîte pour ça, le tuple non.

Dans ton exemple, on y gagnerait (mais pas beaucoup faut avouer) à créer une fonction intermédiaire
Code:

1 2 3 def get_max(tab): for elem in zip(*tab): yield max(*elem)
et d'y appliquer return [e for e in get_max(tab)]------------------------------------

L'avantage du tuple, on est bien d'accord, est dans la possibilité d'itérer plus rapidement, mais liste ou tuple, pour accéder à une valeur c'est kif kif.

C'est encore une preuve que plus long ou moins long, n'a pas de réelle importance à part le fait d'écrire peut-être moins mais en faisant toujours attention que les performances sont au moins identiques au code plus long.

Après c'est un détail, l'essentiel ici c'est que la solution zip est de loin préférable.

EDIT

Autre solution avec numpy

np.max(np.array(tab), axis=0)

Citation:

Envoyé par fred1599

À mon sens, tes deux solutions se valent question performance... le fait de transformer en tuple le résultat calculer en RAM prendra autant de temps que le premier code.

Il est préférable de faire

Code:

return [e for e in tab]

que

Code:

return tuple((e for e in tab))

Et si nous regardions ensemble... (je viens d'apprendre le timeit et je suis comme un fou avec ça :D). J'y mets aussi ta 3° solution avec fonction intermédiaire ;)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 #!/usr/bin/env python3 # coding: utf-8 import random import timeit from functools import partial def tpl(t): return tuple(max(x) for x in zip(*t)) def lst(t): res=[] for x in zip(*t): res.append(max(x)) return res def get_max(t): for elem in zip(*t): yield max(*elem) def with_other_fct(t): return [x for x in get_max(t)] # Le tableau témoin temoin=[ [1, 2, 3, 8, 4], [3, 4, 5, 2, 3], [9, 1, 4, 7, 9], ]*10 # Les fonctions à chronométrer fct={ "comprehension" : tpl, "append" : lst, "with_other_fct" : with_other_fct, } # Le benchmark for (k, v) in random.sample(fct.items(), len(fct)): t=timeit.Timer(partial(v, temoin)).repeat(repeat=10) print("%s: min=%f, max=%f, avg=%f" % (k, min(t), max(t), sum(t)/len(t))) # for
Et le résultat
Code:

1 2 3 append: min=3.450610, max=3.471353, avg=3.458312 comprehension: min=3.632678, max=3.720236, avg=3.647079 with_other_fct: min=3.539974, max=3.689205, avg=3.588079
Ok, mon expression préférée a perdu (tu vois je suis d'une honnêteté sans appel). Mais je préfère quand-même l'écriture à base de tuple (goûts et couleurs). A ce propos tu as mis des parenthèses de trop dans ton exemple. Ici ça n'a pas d'effet mais dans d'autres situations cela peut poser souci.

Citation:

Envoyé par fred1599

même question performance, car l'objectif ici est bien d'ajouter des éléments, et que la liste est faîte pour ça, le tuple non.

Ah non, là je ne peux qu'opposer un véto absolu. Le PO veut le max de ce qui existe, mais nulle part il n'a dit qu'il devrait ensuite faire évoluer ce max.

Citation:

Envoyé par fred1599

Autre solution avec numpy

np.max(np.array(tab), axis=0)

numpy... faut vraiment que j'apprenne à l'utiliser :salive:

@Sve@r

Code:

1
2
3
4
line 38
    for (k, v) in random.sample(fct.items(), len(fct)):
DeprecationWarning: Sampling from a set deprecated
since Python 3.9 and will be removed in a subsequent version.

Sinon j'ai rigolé, moi qui me suis mis à mettre des tuples partout, j'ai modifié ton code pour voir :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#!/usr/bin/env python3
# coding: utf-8
 
import random
import timeit
from functools import partial
 
def tpl(t):
	return tuple(max(x) for x in zip(*t))
 
 
def lst2(t):
	return [max(x) for x in zip(*t)]
 
def lst(t):
	res=[]
	for x in zip(*t):
		res.append(max(x))
	return res
 
def get_max(t):
	for elem in zip(*t):
		yield max(*elem)
 
def with_other_fct(t):
	return [x for x in get_max(t)]
 
# Le tableau témoin
temoin=[
	[1, 2, 3, 8, 4],
	[3, 4, 5, 2, 3],
	[9, 1, 4, 7, 9],
]*10
 
# Les fonctions à chronométrer
fct={
	"comprehension-list" : lst2,
        "comprehension-tpl" : tpl,
	"append" : lst,
	"with_other_fct" : with_other_fct,
}
 
# Le benchmark
for (k, v) in random.sample(fct.items(), len(fct)):
	t=timeit.Timer(partial(v, temoin)).repeat(repeat=10)
	print("%s: min=%f, max=%f, avg=%f" % (k, min(t), max(t), sum(t)/len(t)))
# for

Résultat :

Code:

1
2
3
4
comprehension-tpl: min=3.049974, max=3.154585, avg=3.097106
comprehension-list: min=2.859648, max=2.884421, avg=2.870266
with_other_fct: min=3.047150, max=3.089693, avg=3.065008
append: min=2.877710, max=3.027638, avg=2.916940

:P
C'est quand même fou que la technique append soit plus performante que celle par comprehension-tpl...
J'ai pas regardé du côté du détail des opérations.

28/05/2021, 13h21
Sve@r
Citation:
Envoyé par LeNarvalo

@Sve@r

Code:

1 2 3 4 line 38 for (k, v) in random.sample(fct.items(), len(fct)): DeprecationWarning: Sampling from a set deprecated since Python 3.9 and will be removed in a subsequent version.
C'est noté (suis sur Debian Buster en Python 3.7.3). Cette instruction n'est toutefois pas primordiale, elle permet juste de sortir les fonctions dans un ordre aléatoire.
28/05/2021, 13h25
fred1599
Citation:

Ah non, là je ne peux qu'opposer un véto absolu. Le PO veut le max de ce qui existe, mais nulle part il n'a dit qu'il devrait ensuite faire évoluer ce max.

Je ne parle pas de l'évolution de ton résultat, mais de la manière dont tu vas ajouter les éléments de ton générateur dans ton tuple, en faisant tuple((elem for elem in elements))

(elem for elem in elements) est un générateur, quand tu fais tuple((elem for elem in elements)), tu crées un tuple de l'ensemble généré par ton générateur en mémoire. Donc comment créé ce tuple sans ajouter ce qui est en mémoire élément par élément dans ce même tuple ?

En gros je peux me tromper, mais ajouter élément par élément dans ce tuple, c'est ajouter ce qui est en mémoire de cette manière,
Code:

1 2 3 4 5 6 7 8 9 elements = [2, 3, 5, 7, 2] gen = (elem for elem in elements) t = tuple() while True: try: t += (next(gen), ) except StopIteration: break print(t)
qui n'a rien à voir avec [elem for elem in elements]
28/05/2021, 20h55
lg_53

Citation:

Envoyé par LeNarvalo

C'est quand même fou que la technique append soit plus performante que celle par comprehension-tpl...

C'est parce que la liste est petite. Teste avec qqch qui fait 1 million de valeur, tu vas voir le classement ne sera pas pareil.

Et numpy va tout exploser, surtout si on time vraiment que l'opération de faire le max, et pas la transformation du tab en array (que de toute facon on aurait déjà en array si on fait un code complètement basé sur numpy)
28/05/2021, 21h02
Invité

Citation:

Envoyé par lg_53

C'est parce que la liste est petite. Teste avec qqch qui fait 1 million de valeur, tu vas voir le classement ne sera pas pareil.

Et c'est parti !
Réservez-moi une centrale nucléaire svp !
28/05/2021, 21h35
lg_53

C'est pas si gros que ca 1 million de valeur. Ca tient aisément dans ta RAM, et c'est qqch que tu peux vite atteindre (tout dépend de l'application après). C'est sûr qu'avec moins tu devrais voir aussi l'avantage numpy mais je ne saurais trop dire où (i.e à partir de quelle taille de tableau) cet avantage commence vraiment. Faudrait faire des mesures de performances, de calcul d'un max sur une liste de taille L. Puis prendre différente valeur de L, et tracer la courbe temps de calcul du max en fonction de la longueur L de la liste. Et faire ca pour chacun des algos de calculs de max. On obtient donc une courbe par algo, et on voit l'évolution des performances de chaque algo selon la taille de l'input.

On peut même discrétiser L en échelle log, car à priori ils va se passer plus de chose dans les petites valeurs de L que dans les grandes (pour L grand, le classement des algos est fait, et ne bougera plus).

Egalement, pour L grand, on pourra réaliser moins de run pour mesurer le temps de calcul, car sinon celui ci va vite explosé. On peut se fixer une règle du style Nrun * L ~ L_max .

Ça dépend pour quoi, je suppose, j'ai arrêté le script de Sve@r et même avec 1000 valeurs j'obtiens pas un seul résultat au bout de 15 minutes.
C'est re-reparti pour 100 !
Pfiou, ce fut long !
Code:

1 2 3 4 comprehension-tpl: min=46.067351, max=47.856105, avg=47.553030 comprehension-list: min=44.854978, max=46.016382, avg=45.679012 with_other_fct: min=47.907314, max=48.444543, avg=48.292164 append: min=47.842930, max=48.784372, avg=48.275939
Peut-être pas très fiable, j'ai surfé sur internet en même temps...

Citation:

Envoyé par lg_53

C'est parce que la liste est petite. Teste avec qqch qui fait 1 million de valeur, tu vas voir le classement ne sera pas pareil.

Regardons ensembles...:D
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 #!/usr/bin/env python3 # coding: utf-8 import random import timeit from functools import partial def tpl(t): return tuple(max(x) for x in zip(*t)) def comprehension(t): return [max(x) for x in zip(*t)] def apd(t): res=[] for x in zip(*t): res.append(max(x)) return res # Le tableau témoin m=1_000_000 temoin=[ [1, 2, 3, 8, 4] * m, [3, 4, 5, 2, 3] * m, [9, 1, 4, 7, 9] * m, ] # Les fonctions à chronométrer fct={ "tuple" : tpl, "comprehension" : comprehension, "append" : apd, } # Le benchmark for (k, v) in random.sample(fct.items(), len(fct)): t=timeit.Timer(partial(v, temoin)).repeat(repeat=10, number=10) print("%s: min=%f, max=%f, avg=%f" % (k, min(t), max(t), sum(t)/len(t))) # for
Résultat:
Code:

1 2 3 tuple: min=8.500264, max=8.703820, avg=8.590410 comprehension: min=7.946462, max=8.103481, avg=8.003285 append: min=8.973071, max=9.147698, avg=9.068189
Le append arrive bon dernier. Accessoirement, pour fred1599, tu as raison. Tous les tests que j'ai faits (et j'en ai fait un paquet dans tous les sens) montrent que l'écriture [expression en comprehension] est plus rapide que l'écriture tuple(expression en comprehension). Pas beaucoup plus rapide mais plus rapide quand-même :triste:

Citation:

Envoyé par LeNarvalo

Ça dépend pour quoi, je suppose, j'ai arrêté le script de Sve@r et même avec 1000 valeurs j'obtiens pas un seul résultat au bout de 15 minutes.

Il faut savoir paramétrer le repeat (voir mon code ci-dessus) !!! Il y a le number, qui est le nombre de fois où la fonction est appelée par chrono, et le repeat (là je parle du paramètre, pas de la fonction) qui est le nombre de chronos. Le repeat c'est par défaut 5 mais le number lui c'est 1M. Bien évidemment l'ensemble total des appels du bench c'est l'un multiplié par l'autre. Si en plus toi tu fais là dessus des tests où chaque appel est à priori un peu long...

29/05/2021, 10h09
fred1599

Citation:

Le append arrive bon dernier. Accessoirement, pour fred1599, tu as raison. Tous les tests que j'ai faits (et j'en ai fait un paquet dans tous les sens) montrent que l'écriture [expression en comprehension] est plus rapide que l'écriture tuple(expression en comprehension). Pas beaucoup plus rapide mais plus rapide quand-même

Pour cela que je disais que c'est un détail, et que l'essentiel est de trouver la solution zip.

Après le tuple est avantageux quand on aura pas à modifier, et si on doit faire beaucoup d'itérations, et la liste quand à elle est plus flexible si on a l'idée d'en modifier le contenu.

Pour les performances, pour moi les valeurs que tu trouves prouvent que c'est équivalent et que l'un comme l'autre sont à choix à adapter selon ses besoins dans le code à terme.

Comme je vous le disais, résultat sans appel avec numpy :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import random
import timeit
from functools import partial
 
import numpy as np
 
def tpl(t):
	return tuple(max(x) for x in zip(*t))
 
def comprehension(t):
	return [max(x) for x in zip(*t)]
 
def apd(t):
	res=[]
	for x in zip(*t):
		res.append(max(x))
	return res
 
def np_max(t):
	return np.amax(np.array(t), axis=0)  
 
# Le tableau témoin
m=1_000_000
temoin=[
	[1, 2, 3, 8, 4] * m,
	[3, 4, 5, 2, 3] * m,
	[9, 1, 4, 7, 9] * m,
]
 
 
# Les fonctions à chronométrer
fct={
	"tuple" : tpl,
	"comprehension" : comprehension,
	"append" : apd,
    "np_max" : np_max
}
 
# Le benchmark
for (k, v) in random.sample(fct.items(), len(fct)):
	t=timeit.Timer(partial(v, temoin)).repeat(repeat=2, number=2)
	print("%s: min=%f, max=%f, avg=%f" % (k, min(t), max(t), sum(t)/len(t)))
# for

donne

Code:

1
2
3
4
tuple: min=2.150203, max=2.261651, avg=2.205927
np_max: min=1.294393, max=1.301560, avg=1.297977
append: min=2.314363, max=2.382438, avg=2.348401
comprehension: min=2.002060, max=2.030427, avg=2.016244

31/05/2021, 17h15
Invité

Ah oui quand même !!!
31/05/2021, 19h47
Sve@r

Citation:

Envoyé par LeNarvalo

Ah oui quand même !!!

Ben... avec le recul ça se comprend. Dans tous les autres tests, c'est Python qui fait tout. Il associe via zip() les tableaux puis fait l'itération et à chaque item, cherche le max. Ok derrière Python il y a du C mais toutes ces itérations se traduisent par autant d'aller/retour vers le C qui grèvent le calcul.
Avec numpy on lui passe les tableaux en vrac et c'est numpy (probablement lui aussi écrit en C) qui se charge de tout. Tous ces frais généraux qu'on avait dans les autres méthodes n'existent plus...