Discussion :

[Zavonen]

SpiceGuid:

Par contre pour une opération arithmétique le seul moyen de préserver la structure de monoide c'est l'élément neutre de cette opération.

Mezigues:

Et il y a une logique derrière.
Il faut bien que Op(L1)OpOp(L2) donne Op(L1+L2) si la loi est associative, ce qui oblige Op(Nul)= neutre

C'est bien le message que j'ai essayé de faire passer auparavant avec un formalisme (peut-être) plus soft. Mais SpiceGuid va au fond des choses, les listes avec la concaténation forment un monoïde (loi associative, avec neutre [], mais pas de réciproques sauf pour le neutre).

[eyquem]

Tout cela est de la belle mathématique, mais que pensez vous de reduce(mul,L) et autres solutions comme réponses à la recherche de yoshik ?

[SpiceGuid]

Et il y a une logique derrière.
Il faut bien que Op(L1)OpOp(L2) donne Op(L1+L2) si la loi est associative, ce qui oblige Op(Nul)= neutre

En effet, l'argument intuitif utilisé c'est que:

• le produit d'une concaténation doit être le produit des listes concaténées, par exemple le produit de append [1;2] [3;4] est 2 × 12
• toute liste est aussi sa concaténation avec la liste vide, par exemple [1;2;3;4] c'est aussi append [] [1;2;3;4]
• si le produit de la liste vide est 0 alors le produit de append [] [1;2;3;4] est 0 × 24 = 0
• si le produit de la liste vide est 1 alors le produit de append [] [1;2;3;4] est 1 × 24 = 24
• comme append [] [1;2;3;4] est égal à [1;2;3;4] on sait que son produit doit être égal à 24

(c'est le même argument que celui fourni par Zavonen, mais plus développé et sans le formalisme hard de mon message précédent)

[Zavonen]

Tout cela est de la belle mathématique, mais que pensez vous de reduce(mul,L) et autres solutions comme réponses à la recherche de yoshik ?

Et bien, Eyquem, tu as pensé pour nous.
Après tes posts je ne vois pas bien ce qu'on pourrait ajouter.

[tyrtamos]

Pour eyquem:

Voilà mon code d'essai:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
from operator import mul
import time
import random
 
def prod1(L):
    x=1
    for e in L:
        x*=e
    return x
 
prod2 = lambda z : reduce(lambda x,y:x*y,z,1)
 
prod3 = lambda z : reduce(mul,z,1)
 
 
 
L = [random.random() for i in xrange(1,10001)]
 
t = time.clock()
a = prod1(L)
ta = time.clock()-t
 
t = time.clock()
b = prod2(L)
tb = time.clock()-t
 
t = time.clock()
c = prod3(L)
tc = time.clock()-t
 
print tc/tb, tc/ta

Ce qui affiche quelque chose comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
0.43192224206 1.06641384758

Le 1er nombre indique que la solution "mul" est meilleure (ici d'env. -57%) que la solution lambda.

Le 2ème nombre indique que la solution "mul" est moins bonne (ici de 6%) que la solution itérative. En fait de 1 à 10%.

Pour avoir des chiffres plus stables, il faudrait recommencer 1000 fois et faire la moyenne.


Par contre, j'ai voulu une solution comparable à sum(L) en tant que structure d'appel. l'appel prod(L) convient, mais pas reduce(mul,L,1). D'où mon lambda supplémentaire.


Avec une liste d'entiers obtenus de la même façon:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
L = [random.randint(1000,9999) for i in xrange(1,10001)]

Le même code produit des résultats très différents:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
0.990703574104 1.0045047644

Il n'y a alors pratiquement plus de différence entre les 3 méthodes. D'où mon choix du code le plus lisible "dans tous les cas".

Tyrtamos

[eyquem]

Je ne suis pas d’accord avec vous.

Je conteste la validité de votre raisonnement se fondant implicitement(Zavonen) ou explicitement (SpiceGuid) sur la notion de monoïde.




Comme les maths sont loin pour moi, j’ai regardé la définition de monoïde sur Wikipedia. Rien de compliqué:

un ensemble E muni d’un opérateur binaire OP est un monoïde (E,OP,e) s’il vérifie trois conditions:
- l’opérateur est interne: x OP y appartient à E
- l’opérateur est associatif: x OP (y OP Z) = (x OP y) OP z
- il existe un élément neutre tel que x OP e = x et e OP x = x

(je n’écris pas e OP x = x OP e car en toute rigueur ce n’est vrai que si l’opérateur est commutatif. Donc e OP x est égal a x OP e parce que les deux sont égaux à x , mais pas pour raison intrinsèque à l’opérateur)



Quand l’opérateur est défini partout dans E, c’est à dire que l’opération x OP y a un sens quels que soient les éléments x et y choisis, l’opérateur est appelé loi de composition interne.
La divison est un opérateur binaire interne mais pas une loi de composition interne parce qu’on ne peut pas diviser par 0.

Quand par dessus le marché tout élément de E a un inverse par rapport à cette loi, E connait une promotion : il est qualifié de Groupe.







Bon, pour en venir au raisonnement:

- la multiplication * forme bien un monoïde sur les entiers.
J’ajoute: sur les réels aussi.

- on vérifie que la concaténation de liste forme aussi un monoïde sur les listes Python:
— L1 + L2 est bien une liste : la concaténation est un opérateur interne
— L1+(L2+L3) = L1+(L2+L3) : la concaténation est associative
— [ ] est l’élément neutre de la concaténation

On peut même dire que la concaténation est une loi de composition interne sur les listes.

Jusqu’ici, c’est OK.

Mais pourquoi parler de monoïde ?
Les listes n’ayant pas d’inverses, on ne peut pas parler de Groupe pour l’ensemble des listes Python. Le monoïde est la seule nature algébrique qui reste pour qualifier les listes Python, avec un nombre de conditions minimal, dont l’une concerne l’existence d’un élément neutre, la liste vide [ ] qui pose justement problème pour savoir quelle valeur doit sortir reduce(mul,[ ]).

Je suis encore d’accord sur ces constats.

Mais là où je ne le suis plus, c’est qu’à mon avis, faire valoir que, les listes avec la concaténation, et les nombres équipés de la multiplication * , ont la même nature de monoïde, c’est parce que la notion de monoïde est la seule notion mathématique sur laquelle prétendre prendre appui pour résoudre le problème logiquement et parce qu’il y a la conviction plus ou moins consciente qu’on va pouvoir trouver dans les mathématiques le moyen de répondre à la question “faire le produit d'une liste vide ne doit-il pas être 0 ? “ . Moi je me dis: qu’est ce que les mathématiques ont à voir là dedans ?

Donc on commence par avancer subrepticement une idée qui a toute l’apparence d’un bon principe, mais sans justification:

-Il est souhaitable que la fonction reduce préserve une certaine structure, dans le cas des opérations arithmétiques on veut préserver la structure de monoide.

Pourquoi est-ce souhaitable ?

Et au fait qu’est ce que ça veut dire

“PRÉSERVER la structure de monoïde“

puisque de toutes façons l'ensemble des nombres et l'ensemble des listes sont déjà des monoides indépendamment de l’intervention de reduce() ???

En réalité, sous l’idée qu’il y a une réponse objective trouvable rationnellement, il y une volonté subjective de trouver une réponse, comme si on ne supportait pas que la question soit sans réponse.

Concrètement

“PRÉSERVER la structure de monoïde“

se traduit par :

«le produit d'une concaténation DOIT être le produit des listes concaténées»

: on est passé d’une suggestion à un postulat non justifié, sinon par le but.

Mais cet énoncé n’a pas beaucoup de sens:
- il est déjà vrai pour des listes non vides. Ce n’est pas la valeur du produit d’une liste vide qui va y changer quelque chose.
- cet énoncé n’a aucune utilité pratique pour un programme compilé.
Un programme ne cherche pas à faire reduce(mul,L1) * reduce(mul,L2) quand il rencontre reduce(mul, L1+L2).
Ce que je veux dire, c’est qu’un programme ne fait pas de maths, il fait tourner le CPU, l’énoncé

«le produit d'une concaténation DOIT être le produit des listes concaténées»

l’indiffère, il n’a de sens qu’intellectuel et il est vrai sans avoir eu à se préoccuper de monoïde.

Cet énoncé est pour moi une fausse justification. Je me contente fort bien de l’idée que la valeur de reduce(mul,[ ]) est celle que voudra bien lui donner l’auteur d’un code relativement au type de problème qui l’occupera.
La question est aussi à mon avis une fausse question.






Je trouve aussi l’expression Op(L1)OpOp(L2) = Op(L1+ L2) de Zavonen bien contestable.


Si on prend M(L) = multiplication de tous les éléments de la liste L, alors on est obligé d’écrire

M(L1)*M(L2) = M(L1+L2) et non pas M(L1)MM(L2) = M(L1+L2)
Ce qui veut dire que la fonction M qui prend UNE liste en argument n’est pas la même chose que l’opérateur * qui multiplie DEUX arguments.

Donc il y a écriture abusive dans la formule.



D’autre part, ce n’est pas “ si la loi est associative’ qu’il faudrait écrire mais “si les lois sont associatives“. Car cette formule n’a rien d’une expression de l’associativité.



Dans

Il faut bien que Op(L1)OpOp(L2) donne Op(L1+L2) si la loi est associative

, je vois à nouveau une façon de présenter comme une justification mathématique ce qui n’est qu’un fait constaté, parce qu’il faut bien trouver quelque chose pour arriver à sortir une réponse précise.


Enfin bon, tout ceci n'est pas bien grave mais mon sens de la rigueur était un peu chiffoné

[Zavonen]

@Eyquem
Quand je lis tes posts ma première réaction est de penser qu'il s'agit d'enc... de mouches (ou de discussions byzantines pour être moins vulgaire).
A y regarder de plus près tu écris des choses censées et tu y passes beaucoup de temps. Honnêtement je ne peux pas consacrer tout ce temps à ce forum. Néammoins je vais essayer de répondre à tes dernières préoccupations.
Il existe en mathématiques un principe dont tu sembles ignorer l'existence et le sens, c'est le PRINCIPE DU PROLONGEMENT DES IDENTITES ALGEBRIQUES.
T'es tu déjà demandé pourquoi le produit de deux entiers relatifs négatifs est un nombre positif ?
Si tu t'intéresses à l'histoire des sciences tu verras que les nombres négatifs ont suscité des débats passionnés, avec des partisans et des détracteurs (même chez les professionnels). Petit retour sur le passé donc. Il est difficile de nier l'utilité des nombres négatifs, par exemple pour le calcul de soldes financiers, etc... Leur addition a un sens que je ne rappellerai pas. Passons maintenant au produit, pour les nombres positifs ce produit a un sens (mesure de surface), qu'en est-il du produit de nombres négatifs, a priori il n'en a pas, alors pourquoi introduire la règle fameuse règle des signes -*+=-, -*-=+ etc...
Un Eyquem/Candide des siècles passés aurait pu pondre une grande tartine sur le sujet et contester ce choix au nom d'un hypothétique 'principe d'égalité', certains l'ont fait.
La réponse est simple.
Dans les entiers naturels (monoïde additif) le produit est distributif par rapport à la somme. Si tu veux définir un produit sur les relatifs qui conserve (prolonge) cette propriété, tu n'as pas le choix tu DOIS définir le produit par la règle des signes. Faut-il pour autant se plier à cette nécessité ? La réponse à cette question dépend de ton sens pratique, soit tu cherches les emm... soit tu cherches à te simplifier la vie. Je crois que la plupart des gens (mais pas tous), dont je fais partie appartiennent à la seconde catégorie. Les règles de calcul des anneaux incluant la distributivité ne sont pas là simplement pour faire joli, elle assurent la plupart des identités algébriques (identités remarquables) et la validité d'un grand nombre de calculs effectués avec des objets qui ne sont pas forcément des nombres. Tu serais étonné de voir le nombre d'identités usuelles qui tombent à l'eau dès qu'on 'désactive' un de ces axiomes. Donc si on veut travailler dans un espace de nombres où (a+b)²=a²+2ab+b² et bien il FAUT que la règle des signes soit respectée.
Si l'on veut travailler dans un espace où a^(m+n)=a^n*b^n et bien il FAUT que a^0=1.
Note au passage que a^0=1 et 0!=1 est du même tonneau qu'un produit vide est égal à l'unité. Tu pourrais à bon droit t'insurger contre la dictature des maths qui t'imposent de telles égalités contre nature, mais tu n'en fais rien, habitué que tu es à manipuler ces écritures commodes.
Recadrons le débat.
L'ensemble des listes, considérées comme objets mathématiques est un monoïde, tu nous le concèdes. Encore une fois, on peut considérer qu'il s'agit d'une simple question de vocabulaire pédant, ou bien d'une réalité mathématique. De fait il s'agit bien des deux, l'utilisation d'un vocabulaire adapté évitant les circonvolutions et les redondances mais pouvant dérouter les non-spécialistes. Ce point étant acquis pour tout opérateur T associatif sur un ensemble E et pour toute liste d'éléments de E comportant au moins DEUX éléments on peut (récursivement) donner un sens à l'expression T(L).
Si L=[a,b] T(L)=aTb si L= [a]+L' T(L)=aT(T(L')).
Cela dit on constate que pour ces listes ayant une longueur au moins égale à 2.
T(L1+L2)=(T(L1))T(T(L2)).
La question se pose maintenant de définir T(L) pour des listes ayant 1 élément ou 0 élément.
Et bien si tu veux PROLONGER l'identité algébrique ci-dessus, tu n'a pas le choix.
Tu DOIS définir T(L)=a si L=[a] et T(L)= e (neutre de E) si L=[].
Ce faisant L ---> T(L) est un homomorphisme de (L,+) dans (E,T).
Si, appartenant au GRFDM (Groupe de Résistance Farouche à la Dictature des Mathématiques- assoc. loi 1901), tu refuses de faire ces choix, et bien tu te prépares une vie pleine d'exceptions et de règles spéciales.
Ce qui est d'ailleurs curieux, c'est que la plupart des gens qui refusent qu'un produit vide soit égal à 1 ne s'étonnent pas qu'un produit d'une famille d'un unique élément soit égal à cet élément alors que c'est le même arbitraire qui dicte sa loi (pour faire un produit il faut bien deux éléments au minimum, non ?). Enfin ces mêmes personnes quand elles ont à calculer un produit itératif initialisent instinctivement l'accumulateur à 1 en début de boucle, comme ils le feraient avec 0 pour une somme. Une initialisation à 0 entrainerait que tout produit itératif est nul, ce n'est donc pas nécessaire de le calculer.
Il y a quelque chose que je ne veux pas laisser passer:
"Un programme ne cherche pas à faire reduce(mul,L1) * reduce(mul,L2) quand il rencontre reduce(mul, L1+L2).
"Ce que je veux dire, c’est qu’un programme ne fait pas de maths, il fait tourner le CPU"
Il s'agit-là d'une vérité 'racoleuse'. Tu vas te faire des copains parmi tous les GF (gentils forumeux) qui ont eu (et qui ont peut être encore) des relations difficiles avec les maths. C'est sympa, ça sonne bien, mais c'est une absurdité.
Peut-on inventer des objets informatiques n'ayant aucun réalité scientifique (ne modélisant aucune entité 'réelle') et des programmes manipulant ces objets juste pour le plaisir ? Certes on le peut, c'est ce que j'appelle l'informatique de l'absurde, et on doit pouvoir écrire des pièces de théâtre sur ce thème. Pour ma part, je peste quand, comme tout le monde, je dois travailler avec des 'floats' ou des 'doubles', censés représenter des réels sans respecter la règle (1/3)*3=1. Il faut pourtant vivre avec, la technologie nous l'impose.
Je demande donc que chacun accepte qu'un produit vide soit égal à 1 AU NOM DU SIMPLE BON SENS.

[eyquem]

Merci pour ta réponse tyrtamos.


1/ Observations sur mon ordinateur

J’ai copié-collé ton code tel quel et l’ai fait tourner plusieurs fois.
Résultat pour une liste de réels entre 0 et 1:

rapports reduce mul/reduce lambda et reduce mul/itérative
0.330353811463 0.655845410628
0.376985125186 0.710246121765
0.405137359913 0.721773956064
0.400691611988 0.659842887597
0.36454651507 0.658272024147
0.402875298738 0.662745337072
0.355356489308 0.637685691946
0.401636804404 0.686790923825

Premier rapport semblable sur mon ordinateur
Deuxième rapport notablement plus bas sur mon ordinateur !!!!!


Avec ta liste d’entier L = [random.randint(1000,9999) for i in xrange(1,10001)] , ces deux rapports sont:

1.04171945411 1.15035143183
0.972733100742 0.986723557547
1.23550717674 1.29358686505
1.11705405311 1.10351429795
0.98632783372 0.897484433095
1.00231697378 0.78768324533
0.821470976244 0.986263894726
0.90176665026 1.11704215597
0.989542539215 0.991909854463
0.928976108448 0.880422362284
1.16352689961 1.222284105
0.999406194737 0.958398459271
0.964177674511 0.836621920586
1.12533216491 1.09019312636
0.951691496344 0.894698261979
1.0908240739 0.924432453716
0.944652298079 0.967167499743
0.958037927693 0.789090750793
1.27544206417 1.30586552761

Cette fois, ces valeurs sur mon ordi sont plus semblables à celles sur ton ordinateur.
J’en donne une plus longue liste pour mettre en évidence la grande variabilité de ces valeurs.
Pour moi c’est un problème de voir une telle variabilité: le plus haut est 142 % le plus bas pour le premier rapport, et 166 % pour le second rapport !! À quoi cela peut-il bien ëtre dû ?



2/ Les listes testées

Après un moment passé à échafauder des élucubrations à partir de ces résultats, j’ai pris du recul et j’ai eu la curiosité de regarder non seulement les temps absolus mais les valeurs des produits calculés.
Et là ça ne va pas, tes listes ne sont pas adaptées aux mesures que nous faisons.


D’abord les réels.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
L = [random.random() for i in xrange(1,10001)]
 
def prod1(li):
    x=1
    i = 1
    krit = 1
    ecart = 50
    for e in li:
        prec = x
        x*=e
        if i%ecart==0:
            print i,'  ',x
        if x==0 and krit==1:
            print 'Pour i =',i,':\nprec =',prec,' , e =',e,' et x = prec*e egal a 0'
            ecart = 1000
            krit = 0
        i+=1
 
prod1(L)

50 9.91888315831e-022
100 2.84394700549e-045
150 2.112986293e-062
200 1.38876913112e-082
250 1.69370554035e-100
300 1.94424601527e-115
350 6.38320357371e-133
400 1.10946545673e-156
450 5.31457594536e-178
500 7.14056232705e-206
550 6.00678518324e-231
600 1.27323710724e-251
650 1.48479876011e-271
700 5.68200700711e-293
750 1.3418648712e-310
Pour i = 786 :
prec = 4.94065645841e-324 , e = 0.437687884638 et x = prec*e egal a 0
1000 0.0
2000 0.0
3000 0.0
4000 0.0
5000 0.0
6000 0.0
7000 0.0
8000 0.0
9000 0.0
10000 0.0

Le produit est nul au bout de 760 tours environ.




Pour les entiers:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
L = [random.randint(1000,9999) for i in xrange(1,501)]
 
def prod1(li):
    x=1
    i = 1
    for e in li:
        x*=e
        if i<30:
            print i,'  ',x
        if i==100:
            print '\n\n'
            print x
        i+=1
    print '\n\n'
    return x
 
print prod1(L)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
1    9102
2    31310880
3    242909807040
4    883220058397440
5    2934057033996295680
6    26541479929530490721280
7    100565667452991029342929920
8    311954700439178173021768611840
9    2816638990265339724213548796303360
10    25259618464699566646747105605248532480
11    147591950689239567916943338051467175280640
12    1169666209212223575741775954057877364099072000
13    9496519952594043211447478970995906319120365568000
14    32981413795359112073357094466268782646305029617664000
15    286839355778238197701986650573139602674914842584823808000
16    2488044572020438126867032207071412913602211344580761710592000
17    5242309913247063133308836860299467008959859303031664924217344000
18    33419725696950027474843834984409102182119103056826863891885568000000
19    158843956237603480587932747680896462671612096829098084078132104704000000
20    575491653448837410170080344847887884259250626811822358615072615342592000000
21    3892625543927936242390423452551113649129571239755166433672351170177292288000000
22    27680460242871554619638301171090969158960381085898988509844089171130725459968000000
23    152380933637007908181108847946855785220076897877873931746691710887074643657123840000000
24    182552358497135474000968399840333230693652123657692970232536669642715423101234360320000000
25    1010427304281644848595360093116244431889364504445330590237090466472429866865332184371200000000
26    5107710023143714709649545270702615603200737569971146133648492308018132977004254191996416000000000
27    22356446771300039284136059649865348495209628343763706626979450832195368040347620598368312832000000000
28    214040621388426576106318635087810846493136981763193727246701262267438453618288119608778227053568000000000
29    1604234457306257187916858169983142294466061678315136985714025960694451209869069456467792811766492160000000000
 
 
 
produit des 100 premiers
163727433807606641292868089543745787539092867069331507801594276876671741539700228764787771455551135297572203493593204627518329051979351762374350609943415327154053969944788517540354267692297041331475371010414226381656669879200333551117960316034069252372498931534342163063800891990922002177623668497223961989167674350756296034300638103812964352000000000000000000000000000
 
 
 
produit final
72729888745400920210290042267236996315565275480695246328644243746935201045343572808328532272440444890880296388728027226255274745568776878659092115122886161887814509655179860407766707924984171759412948035480179890257390705181997034143943717962703517512745170282372038429867336856308812464820800414275258268797910733741094503059824795806494791537448433582545707845966473813490276637366700062257643852278004194663878242743177248983843947583301407515434876053142514058791535067332461121106397141492445930468785229047464103693637413285019407702388502598226667877192448554863756303065874656372856887660945160628155930724172819438509578217762818598651004417817686221293918336704688638643362725051704828113325670636895295387492006818209055041081470951654476507244207782722022118755100645228318941120276766312231331360269872716660271626711623952416019699999319764553516157144077296588578730210281142357201294392009347308073845026807036466506709202025654121367327050298207562301698823020270485193187325091244186075502212302759257031928938139883375930271803394170487850038688432921595498655623465238812246200815549287085169939080114930271642295645219130542818584728916568826939198223761181751988492744561863821646312859102654994951300089060608674693339453286641565109994080554943616181616481339864694402402536076511229063093701924333124311689005827216591295498642358041826241026554875109753549315478902410436634271941389934287725011783716488503760130280684000396505594452613342224767643345691924009200871911731604738732085429797583263847070005077471192577252971426073586540804582931130157256062475184358168350213022747792098873995801404978552548119397668454237943309517816824248058661594895287435271289757904561766400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
il faut aller voir au bout comme c'est long -------->
 
nombre de chiffre du produit final  : 1839
nombre de 0 a la fin du produit final : 135

J’ai été obligé de réduire à 501 la borne max du range, sinon les produits obtenus sont trop énormes.
Avec une borne de 10001, le produit final a typiquement 36000 chiffres (oui 36 mille) et 2500 zéros à la fin !!!!
Par dessus le marché tu sélectionnes des nombres entre 1000 et 10000




3/ Timer avec tes listes

J’ai aussi voulu vérifier quelle est l’influence de la manière de faire les mesures de temps.
En plus de tes mesures avec clock(), j’ai refait des mesures avec Timer, bien que j’en avais déjà faites.

Je me suis aperçu à cette occasion qu’il y a une erreur dans mon code donné dans le message #17: les fonctions d’affichage sont mal écrites et donnent la valeur du minimum comme valeur moyenne. Ce n’est pas très grave mais ça explique sans doute la variabilité agaçante que j’avais signalée.



Auparavant j’ai comparé les vitesses mesurées de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
def prod2(z):
    return reduce(lambda x,y:x*y,z,1)

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

prod2 = lambda z : reduce(lambda x,y:x*y,z,1)

ainsi que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
def prod3(z):
    return reduce(mul,z,1)

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

prod3 = lambda z : reduce(mul,z,1)

Mais il n’y a pas de différence significative. J’ai utilisé la première forme dans les codes, par homogénéité avec la définition de def iterative()




Comme tu le préconisais , j’ai fait une itération de mesures (iterat = nombre de tours fixé)
avec clock() et avec Timer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
from operator import mul
import time
import random
from timeit import Timer
 
clo = time.clock
 
def prod1(L):
    x=1
    for e in L:
        x*=e
    return x
 
def prod2(z):
    return reduce(lambda x,y:x*y,z,1)
 
def prod3(z):
    return reduce(mul,z,1)
 
iterat = 100
 
print '-----------------------------------------------------------------------------------'
L = [random.random() for i in xrange(1,10001)]
print "Liste de reels L = [random.random() for i in xrange(1,10001)]\n"
 
print 'Avec clock()'
sta,stb,stc = 0,0,0
for i in xrange(iterat):
    t = time.clock()
    a = prod1(L)
    sta += time.clock()-t
 
    t = time.clock()
    b = prod2(L)
    stb += time.clock()-t
 
    t = time.clock()
    c = prod3(L)
    stc += time.clock()-t
print sta,'    iterative                            ',iterat,'tours'
print stb,'    reduce lambda'
print stc,'    reduce mul'
print 'reduce_mul/reduce_lambda',stc/stb,' reduce_mul/iterative',stc/sta
print
 
print 'Avec Timer'
t1 = Timer('prod1(L)','from __main__ import prod1,L').timeit(iterat)
t2 = Timer('prod2(L)','from __main__ import prod2,L').timeit(iterat)
t3 = Timer('prod3(L)','from __main__ import prod3,L').timeit(iterat)
print t1,'    iterative                             '+str(iterat)+' tours'
print t2,'    reduce lambda'
print t3,'    reduce mul'
print 'reduce_mul/reduce_lambda',t3/t2,' reduce_mul/iterative',t3/t1
 
 
print '-----------------------------------------------------------------------------------'
L = L = [random.randint(1000,9999) for i in xrange(1,501)]
print "Liste d'entiers L = L = [random.randint(1000,9999) for i in xrange(1,501)]\n"
 
print 'Avec clock()'
sta,stb,stc = 0,0,0
for i in xrange(iterat):
    t = time.clock()
    a = prod1(L)
    sta += time.clock()-t
 
    t = time.clock()
    b = prod2(L)
    stb += time.clock()-t
 
    t = time.clock()
    c = prod3(L)
    stc += time.clock()-t
print sta,'    iterative                            ',iterat,'tours'
print stb,'    reduce lambda'
print stc,'    reduce mul'
print 'reduce_mul/reduce_lambda',stc/stb,' reduce_mul/iterative',stc/sta
print
 
print 'Avec Timer'
t1 = Timer('prod1(L)','from __main__ import prod1,L').timeit(iterat)
t2 = Timer('prod2(L)','from __main__ import prod2,L').timeit(iterat)
t3 = Timer('prod3(L)','from __main__ import prod3,L').timeit(iterat)
print t1,'    iterative                             '+str(iterat)+' tours'
print t2,'    reduce lambda'
print t3,'    reduce mul'
print 'reduce_mul/reduce_lambda',t3/t2,' reduce_mul/iterative',t3/t1
 
print '-----------------------------------------------------------------------------------'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
-----------------------------------------------------------------------------------
Liste de reels L = [random.random() for i in xrange(1,10001)]
 
Avec clock()
0.917957170534     iterative                             100 tours
1.7309602198     reduce lambda
0.709156051956     reduce mul
reduce_mul/reduce_lambda 0.409689398891  reduce_mul/iterative 0.772537188792
 
Avec Timer
0.949471511044     iterative                             100 tours
1.60133843827     reduce lambda
0.782893077193     reduce mul
reduce_mul/reduce_lambda 0.488899197374  reduce_mul/iterative 0.824556680307
-----------------------------------------------------------------------------------
Liste d'entiers L = L = [random.randint(1000,9999) for i in xrange(1,501)]
 
Avec clock()
0.359964464757     iterative                             100 tours
0.360485760062     reduce lambda
0.33935430341     reduce mul
reduce_mul/reduce_lambda 0.941380606413  reduce_mul/iterative 0.94274390012
 
Avec Timer
0.308979493204     iterative                             100 tours
0.368784859528     reduce lambda
0.298325904549     reduce mul
reduce_mul/reduce_lambda 0.808942929303  reduce_mul/iterative 0.965520078553
-----------------------------------------------------------------------------------
>>>

Rien de différent entre les deux méthodes:

J’en viens a me demander quel intérêt a vraiment Timer.
-

[eyquem]

4/ Mesures avec mes listes

Pour éliminer le parasitage que représente l’utilisation d’une liste de réels dont le produit converge rapidement vers 0 , ou d’une liste d’entiers dont le produit croît au point d’atteindre des nombres devant lesquels les distances astronomiques sont des têtes d’épingle, j’en suis revenu à ma liste de réels autour de 1 dont le produit reste proche de 1 et à une liste d’entiers raisonnable.

J’ai utilisé le code suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
from operator import mul
from time import clock
from random import random,randint
from timeit import Timer
 
 
def prod1(L):
    x=1
    for e in L:
        x*=e
    return x
 
def prod2(z):
    return reduce(lambda x,y:x*y,z,1)
 
def prod3(z):
    return reduce(mul,z,1)
 
 
 
 
print '\n==================================================================================='
for taille in [10,50,100,200,400,700,800,1000]:
    L = [randint(9807,10200)/10000. for i in xrange(taille)]
 
    print '\nListe de reels L = [randint(9807,10200)/10000. for i in xrange('+str(taille)+')]'
    print '---------------------------------------------------------------'+len(str(taille))*'*'+'--\n'
 
    print 'Avec clock()'
    iterat = 10
    sta,stb,stc = 0,0,0
    for i in xrange(iterat):
        t = time.clock()
        a = prod1(L)
        sta += time.clock()-t
 
        t = time.clock()
        b = prod2(L)
        stb += time.clock()-t
 
        t = time.clock()
        c = prod3(L)
        stc += time.clock()-t
    print sta,'    iterative                            ',iterat,'tours'
    print stb,'    reduce lambda'
    print stc,'    reduce mul'
    print 'reduce_mul/reduce_lambda',stc/stb,' reduce_mul/iterative',stc/sta
    print 'Resultat :',a
    print
 
    print 'Avec Timer'
    for u in xrange(6):
        t1 = Timer('prod1(L)','from __main__ import prod1,L').timeit(iterat)
        t2 = Timer('prod2(L)','from __main__ import prod2,L').timeit(iterat)
        t3 = Timer('prod3(L)','from __main__ import prod3,L').timeit(iterat)
        print t1,'    iterative                             '+str(iterat)+' tours'
        print t2,'    reduce lambda'
        print t3,'    reduce mul'
        print 'reduce_mul/reduce_lambda',t3/t2,' reduce_mul/iterative',t3/t1
 
 
 
 
 
 
 
print '\n==================================================================================='
for taille in [100,500,1000,2000,3000,4000,5000,6000,7000,8000,9000,10000,20000,50000]:
    L = [randint(1,101) for i in xrange(taille)]
    print "\n\nListe d'entiers L = [randint(1,12) for i in xrange("+str(taille)+')]'
    print '---------------------------------------------------'+len(str(taille))*'*'+'--'
 
    iterat = 10
    sta,stb,stc = 0,0,0
    for i in xrange(iterat):
        t = time.clock()
        a = prod1(L)
        sta += time.clock()-t
 
        t = time.clock()
        b = prod2(L)
        stb += time.clock()-t
 
        t = time.clock()
        c = prod3(L)
        stc += time.clock()-t
    print sta,'    iterative                            ',iterat,'tours'
    print stb,'    reduce lambda'
    print stc,'    reduce mul'
    print 'reduce_mul/reduce_lambda',stc/stb,' reduce_mul/iterative',stc/sta
    print '\nlongueur du produit :',len(str(a))
    print
 
 
    t1 = Timer('prod1(L)','from __main__ import prod1,L').timeit(iterat)
    t2 = Timer('prod2(L)','from __main__ import prod2,L').timeit(iterat)
    t3 = Timer('prod3(L)','from __main__ import prod3,L').timeit(iterat)
    print t1,'    iterative                             '+str(iterat)+' tours'
    print t2,'    reduce lambda'
    print t3,'    reduce mul'
    print 'reduce_mul/reduce_lambda',t3/t2,' reduce_mul/iterative',t3/t1
 
print '-----------------------------------------------------------------------------------'

Tyrtamos, peux tu faire tourner ce code ci-dessus, STP. Normalement il est prêt à l’emploi.
On pourra comparer les nouveaux résultats et éclaircir ce qui reste à éclaircir.

Resultat que j'obtiens:

===================================================================================

Liste de reels L = [randint(9807,10200)/10000. for i in xrange(10)]
---------------------------------------------------------------**--

Avec clock()
0.000175720655534 iterative 10 tours
0.000286349242742 reduce lambda
0.000155885734785 reduce mul
reduce_mul/reduce_lambda 0.544390246301 reduce_mul/iterative 0.887122429124
Resultat : 1.04057635665

Avec Timer
0.000126273032947 iterative 10 tours
0.000216228598219 reduce lambda
0.000112025410999 reduce mul
reduce_mul/reduce_lambda 0.518087856656 reduce_mul/iterative 0.88716813388
0.000126552396978 iterative 10 tours
0.000223492092118 reduce lambda
0.000111466681119 reduce mul
reduce_mul/reduce_lambda 0.498750000783 reduce_mul/iterative 0.880794704652
0.000127111126858 iterative 10 tours
0.000219580981138 reduce lambda
0.00011174604515 reduce mul
reduce_mul/reduce_lambda 0.50890584681 reduce_mul/iterative 0.879120875661
0.000126831762827 iterative 10 tours
0.000217066695768 reduce lambda
0.000114260332339 reduce mul
reduce_mul/reduce_lambda 0.526383524356 reduce_mul/iterative 0.900881055279
0.000129346048197 iterative 10 tours
0.000220139711018 reduce lambda
0.000112025410999 reduce mul
reduce_mul/reduce_lambda 0.508883247284 reduce_mul/iterative 0.866090712166
0.000126831762827 iterative 10 tours
0.000217904789679 reduce lambda
0.000110907951239 reduce mul
reduce_mul/reduce_lambda 0.508974361703 reduce_mul/iterative 0.874449339555

Liste de reels L = [randint(9807,10200)/10000. for i in xrange(50)]
---------------------------------------------------------------**--

Avec clock()
0.000472965140943 iterative 10 tours
0.000881955667865 reduce lambda
0.000363454017133 reduce mul
reduce_mul/reduce_lambda 0.412100097971 reduce_mul/iterative 0.768458361241
Resultat : 1.08642849677

Avec Timer
0.000722996916011 iterative 10 tours
0.000806247720902 reduce lambda
0.000335796868967 reduce mul
reduce_mul/reduce_lambda 0.416493417918 reduce_mul/iterative 0.464451315809
0.000486374665343 iterative 10 tours
0.00214747963764 reduce lambda
0.000335796868967 reduce mul
reduce_mul/reduce_lambda 0.156367894289 reduce_mul/iterative 0.690407812937
0.000442234977527 iterative 10 tours
0.000801498514193 reduce lambda
0.000332444486048 reduce mul
reduce_mul/reduce_lambda 0.414778667909 reduce_mul/iterative 0.751737205201
0.000440838151917 iterative 10 tours
0.00141051446553 reduce lambda
0.000336355598847 reduce mul
reduce_mul/reduce_lambda 0.238463062284 reduce_mul/iterative 0.762991128115
0.000442234977527 iterative 10 tours
0.000802057244073 reduce lambda
0.000337752422638 reduce mul
reduce_mul/reduce_lambda 0.421107626836 reduce_mul/iterative 0.76373973069
0.000442514341557 iterative 10 tours
0.000804292165412 reduce lambda
0.000336914328727 reduce mul
reduce_mul/reduce_lambda 0.418895450206 reduce_mul/iterative 0.761363637485

Liste de reels L = [randint(9807,10200)/10000. for i in xrange(100)]
---------------------------------------------------------------***--

Avec clock()
0.000907657256903 iterative 10 tours
0.00222737806507 reduce lambda
0.000707352470272 reduce mul
reduce_mul/reduce_lambda 0.317571803981 reduce_mul/iterative 0.779316713321
Resultat : 1.02496361338

Avec Timer
0.000839492169689 iterative 10 tours
0.00153567003508 reduce lambda
0.000614603251961 reduce mul
reduce_mul/reduce_lambda 0.400218300755 reduce_mul/iterative 0.732113144294
0.00083781597823 iterative 10 tours
0.00153399384544 reduce lambda
0.000617396903181 reduce mul
reduce_mul/reduce_lambda 0.402476779822 reduce_mul/iterative 0.7369123044
0.000838654073959 iterative 10 tours
0.00153455257532 reduce lambda
0.00118255253074 reduce mul
reduce_mul/reduce_lambda 0.770617149098 reduce_mul/iterative 1.4100599609
0.000837815980049 iterative 10 tours
0.00187677484246 reduce lambda
0.00061879372879 reduce mul
reduce_mul/reduce_lambda 0.3297112231 reduce_mul/iterative 0.738579525249
0.00083977153372 iterative 10 tours
0.00162674306375 reduce lambda
0.00061572071354 reduce mul
reduce_mul/reduce_lambda 0.378499055727 reduce_mul/iterative 0.73320026795
0.00083837470811 iterative 10 tours
0.00159489544058 reduce lambda
0.000622704841589 reduce mul
reduce_mul/reduce_lambda 0.390436153836 reduce_mul/iterative 0.742752417941

Liste de reels L = [randint(9807,10200)/10000. for i in xrange(200)]
---------------------------------------------------------------***--

Avec clock()
0.00184297166197 iterative 10 tours
0.00316464802017 reduce lambda
0.00114930808013 reduce mul
reduce_mul/reduce_lambda 0.363170903305 reduce_mul/iterative 0.623616794466
Resultat : 0.992152039092

Avec Timer
0.00181168276868 iterative 10 tours
0.00326158771531 reduce lambda
0.00123786682343 reduce mul
reduce_mul/reduce_lambda 0.379528907844 reduce_mul/iterative 0.683269082664
0.00175636847598 iterative 10 tours
0.00332863534277 reduce lambda
0.00117836205391 reduce mul
reduce_mul/reduce_lambda 0.354007553416 reduce_mul/iterative 0.670908223429
0.00162758115948 iterative 10 tours
0.00328365755922 reduce lambda
0.0012515557155 reduce mul
reduce_mul/reduce_lambda 0.381146844007 reduce_mul/iterative 0.768966701419
0.00191951770466 iterative 10 tours
0.00346273059949 reduce lambda
0.00117696523012 reduce mul
reduce_mul/reduce_lambda 0.33989511927 reduce_mul/iterative 0.613156746226
0.00175720657171 iterative 10 tours
0.0029933972055 reduce lambda
0.00125714301612 reduce mul
reduce_mul/reduce_lambda 0.419972001647 reduce_mul/iterative 0.715421303538
0.00162674306193 iterative 10 tours
0.00337500995192 reduce lambda
0.00139151763688 reduce mul
reduce_mul/reduce_lambda 0.41230030628 reduce_mul/iterative 0.855400996898

Liste de reels L = [randint(9807,10200)/10000. for i in xrange(400)]
---------------------------------------------------------------***--

Avec clock()
0.00841699154444 iterative 10 tours
0.0062703500007 reduce lambda
0.00219832408766 reduce mul
reduce_mul/reduce_lambda 0.350590331865 reduce_mul/iterative 0.261176939059
Resultat : 1.59957359058

Avec Timer
0.00887515033355 iterative 10 tours
0.00644188018305 reduce lambda
0.0023799114133 reduce mul
reduce_mul/reduce_lambda 0.369443601196 reduce_mul/iterative 0.268154490218
0.004906489512 iterative 10 tours
0.00618151189701 reduce lambda
0.00233605108951 reduce mul
reduce_mul/reduce_lambda 0.377909341345 reduce_mul/iterative 0.476114558852
0.0032875686702 iterative 10 tours
0.0069997723167 reduce lambda
0.00229945425963 reduce mul
reduce_mul/reduce_lambda 0.328504150648 reduce_mul/iterative 0.69943915711
0.00466288313146 iterative 10 tours
0.00607060394395 reduce lambda
0.00237180982549 reduce mul
reduce_mul/reduce_lambda 0.3907040959 reduce_mul/iterative 0.508657360398
0.00389015922519 iterative 10 tours
0.00664497862272 reduce lambda
0.00274224796703 reduce mul
reduce_mul/reduce_lambda 0.412679727465 reduce_mul/iterative 0.704919209804
0.00363873062088 iterative 10 tours
0.00664358179711 reduce lambda
0.00234443204317 reduce mul
reduce_mul/reduce_lambda 0.352886758193 reduce_mul/iterative 0.644299424014

Liste de reels L = [randint(9807,10200)/10000. for i in xrange(700)]
---------------------------------------------------------------***--

Avec clock()
0.00532805146941 iterative 10 tours
0.0264259843098 reduce lambda
0.00666257862213 reduce mul
reduce_mul/reduce_lambda 0.252122249981 reduce_mul/iterative 1.25047189585
Resultat : 0.946247713609

Avec Timer
0.00619855316836 iterative 10 tours
0.0240139459074 reduce lambda
0.00456342915095 reduce mul
reduce_mul/reduce_lambda 0.190032457329 reduce_mul/iterative 0.736208761464
0.00597841345734 iterative 10 tours
0.0107572331126 reduce lambda
0.0208713677293 reduce mul
reduce_mul/reduce_lambda 1.94021710889 reduce_mul/iterative 3.4911214954
0.00574905469875 iterative 10 tours
0.0200355073048 reduce lambda
0.003974248124 reduce mul
reduce_mul/reduce_lambda 0.198360244317 reduce_mul/iterative 0.691287234553
0.00587113725305 iterative 10 tours
0.0106211823022 reduce lambda
0.00400078781058 reduce mul
reduce_mul/reduce_lambda 0.376680081063 reduce_mul/iterative 0.68143319397
0.00562278166581 iterative 10 tours
0.0108334997894 reduce lambda
0.00426758149297 reduce mul
reduce_mul/reduce_lambda 0.39392454663 reduce_mul/iterative 0.758980473832
0.00639969605072 iterative 10 tours
0.0115930935353 reduce lambda
0.00397480685388 reduce mul
reduce_mul/reduce_lambda 0.342859896865 reduce_mul/iterative 0.621093067917

Liste de reels L = [randint(9807,10200)/10000. for i in xrange(800)]
---------------------------------------------------------------***--

Avec clock()
0.00615161982569 iterative 10 tours
0.0123518491891 reduce lambda
0.00437178468565 reduce mul
reduce_mul/reduce_lambda 0.353937667041 reduce_mul/iterative 0.710672117186
Resultat : 1.01826592521

Avec Timer
0.00697071834657 iterative 10 tours
0.0120342110513 reduce lambda
0.00471735932842 reduce mul
reduce_mul/reduce_lambda 0.391995728538 reduce_mul/iterative 0.676739339318
0.00804012800472 iterative 10 tours
0.0119202300848 reduce lambda
0.00458773391438 reduce mul
reduce_mul/reduce_lambda 0.384869577327 reduce_mul/iterative 0.570604586355
0.00674946117397 iterative 10 tours
0.0119867189824 reduce lambda
0.012121931697 reduce mul
reduce_mul/reduce_lambda 1.01128021061 reduce_mul/iterative 1.79598509934
0.00705648343501 iterative 10 tours
0.0124594047575 reduce lambda
0.00525848955658 reduce mul
reduce_mul/reduce_lambda 0.422049821716 reduce_mul/iterative 0.745199730859
0.00970709964531 iterative 10 tours
0.0142012462493 reduce lambda
0.00555852769139 reduce mul
reduce_mul/reduce_lambda 0.391411260239 reduce_mul/iterative 0.572624974966
0.00788368354006 iterative 10 tours
0.0141160398871 reduce lambda
0.00461008312413 reduce mul
reduce_mul/reduce_lambda 0.326584733467 reduce_mul/iterative 0.584762579663

Liste de reels L = [randint(9807,10200)/10000. for i in xrange(1000)]
---------------------------------------------------------------****--

Avec clock()
0.00771410891502 iterative 10 tours
0.0189571579649 reduce lambda
0.0165445608345 reduce mul
reduce_mul/reduce_lambda 0.872734239233 reduce_mul/iterative 2.14471444684
Resultat : 0.968364912394

Avec Timer
0.00864299792192 iterative 10 tours
0.0177600784464 reduce lambda
0.00643210240378 reduce mul
reduce_mul/reduce_lambda 0.362166328443 reduce_mul/iterative 0.744198073618
0.00814628674925 iterative 10 tours
0.0188750246198 reduce lambda
0.00651479447879 reduce mul
reduce_mul/reduce_lambda 0.345154224168 reduce_mul/iterative 0.799725651615
0.00801358831814 iterative 10 tours
0.0160051067942 reduce lambda
0.00606194362626 reduce mul
reduce_mul/reduce_lambda 0.37875058906 reduce_mul/iterative 0.756458079154
0.012580090488 iterative 10 tours
0.0165431640053 reduce lambda
0.00591443884696 reduce mul
reduce_mul/reduce_lambda 0.357515578342 reduce_mul/iterative 0.470142790516
0.00927967101961 iterative 10 tours
0.0151949479605 reduce lambda
0.00613765157323 reduce mul
reduce_mul/reduce_lambda 0.403927120329 reduce_mul/iterative 0.661408315042
0.00836279471332 iterative 10 tours
0.0159428083734 reduce lambda
0.00576637533595 reduce mul
reduce_mul/reduce_lambda 0.361691315663 reduce_mul/iterative 0.689527309186

Liste d'entiers L = [randint(1,12) for i in xrange(100)]
---------------------------------------------------***--
0.00236706062242 iterative 10 tours
0.00260563842312 reduce lambda
0.00164490179304 reduce mul
reduce_mul/reduce_lambda 0.631285514693 reduce_mul/iterative 0.694913251255

longueur du produit : 164

0.00183403198025 iterative 10 tours
0.00273191145789 reduce lambda
0.00157226686679 reduce mul
reduce_mul/reduce_lambda 0.575518969419 reduce_mul/iterative 0.857273419285


Liste d'entiers L = [randint(1,12) for i in xrange(500)]
---------------------------------------------------***--
0.028903114784 iterative 10 tours
0.0216633678247 reduce lambda
0.0154826940307 reduce mul
reduce_mul/reduce_lambda 0.71469469364 reduce_mul/iterative 0.535675623418

longueur du produit : 795

0.0174675831713 iterative 10 tours
0.0212398503154 reduce lambda
0.0156181861094 reduce mul
reduce_mul/reduce_lambda 0.735324678726 reduce_mul/iterative 0.894124044304


Liste d'entiers L = [randint(1,12) for i in xrange(1000)]
---------------------------------------------------****--
0.0528444257525 iterative 10 tours
0.0622830555258 reduce lambda
0.0492101649816 reduce mul
reduce_mul/reduce_lambda 0.790105182961 reduce_mul/iterative 0.931227168823

longueur du produit : 1596

0.082308226325 iterative 10 tours
0.0697800977487 reduce lambda
0.079388860875 reduce mul
reduce_mul/reduce_lambda 1.13770062577 reduce_mul/iterative 0.964531304095


Liste d'entiers L = [randint(1,12) for i in xrange(2000)]
---------------------------------------------------****--
0.252605009855 iterative 10 tours
0.204646400589 reduce lambda
0.169862370778 reduce mul
reduce_mul/reduce_lambda 0.830028626397 reduce_mul/iterative 0.672442604664

longueur du produit : 3173

0.181213813488 iterative 10 tours
0.198873879222 reduce lambda
0.175406650846 reduce mul
reduce_mul/reduce_lambda 0.881999443725 reduce_mul/iterative 0.967954084013


Liste d'entiers L = [randint(1,12) for i in xrange(3000)]
---------------------------------------------------****--
0.365565176578 iterative 10 tours
0.399227555456 reduce lambda
0.362657823829 reduce mul
reduce_mul/reduce_lambda 0.908398778775 reduce_mul/iterative 0.992046964712

longueur du produit : 4750

0.421717844027 iterative 10 tours
0.520620916905 reduce lambda
0.34958381582 reduce mul
reduce_mul/reduce_lambda 0.671474780341 reduce_mul/iterative 0.828951918377


Liste d'entiers L = [randint(1,12) for i in xrange(4000)]
---------------------------------------------------****--
0.631450086534 iterative 10 tours
0.693882881758 reduce lambda
0.619213894504 reduce mul
reduce_mul/reduce_lambda 0.892389639207 reduce_mul/iterative 0.980622075616

longueur du produit : 6306

0.623872307793 iterative 10 tours
0.665371157507 reduce lambda
0.607859937507 reduce mul
reduce_mul/reduce_lambda 0.913565204395 reduce_mul/iterative 0.974333898001


Liste d'entiers L = [randint(1,12) for i in xrange(5000)]
---------------------------------------------------****--
0.968402688051 iterative 10 tours
1.08119020714 reduce lambda
0.924927330148 reduce mul
reduce_mul/reduce_lambda 0.855471427732 reduce_mul/iterative 0.955106116041

longueur du produit : 7880

0.986166398243 iterative 10 tours
1.105710642 reduce lambda
0.910377156873 reduce mul
reduce_mul/reduce_lambda 0.823341227168 reduce_mul/iterative 0.923147613319


Liste d'entiers L = [randint(1,12) for i in xrange(6000)]
---------------------------------------------------****--
1.30245380348 iterative 10 tours
1.41033483306 reduce lambda
1.35582930233 reduce mul
reduce_mul/reduce_lambda 0.961352772792 reduce_mul/iterative 1.04098072323

longueur du produit : 9469

1.28894258907 iterative 10 tours
1.4003114921 reduce lambda
1.5822323787 reduce mul
reduce_mul/reduce_lambda 1.12991458516 reduce_mul/iterative 1.22754294265


Liste d'entiers L = [randint(1,12) for i in xrange(7000)]
---------------------------------------------------****--
1.83377496302 iterative 10 tours
1.90734520728 reduce lambda
1.74773441876 reduce mul
reduce_mul/reduce_lambda 0.916317828615 reduce_mul/iterative 0.953080096524

longueur du produit : 11080

3.08283399147 iterative 10 tours
2.02521968574 reduce lambda
1.69384488811 reduce mul
reduce_mul/reduce_lambda 0.83637587568 reduce_mul/iterative 0.549444080607


Liste d'entiers L = [randint(1,12) for i in xrange(8000)]
---------------------------------------------------****--
3.31769903717 iterative 10 tours
3.81199174755 reduce lambda
3.26713339265 reduce mul
reduce_mul/reduce_lambda 0.857067278476 reduce_mul/iterative 0.984758821113

longueur du produit : 12655

2.54558833595 iterative 10 tours
4.37108990109 reduce lambda
5.46921605958 reduce mul
reduce_mul/reduce_lambda 1.25122479367 reduce_mul/iterative 2.14850766809


Liste d'entiers L = [randint(1,12) for i in xrange(9000)]
---------------------------------------------------****--
3.61621435127 iterative 10 tours
3.68822936993 reduce lambda
3.23529498861 reduce mul
reduce_mul/reduce_lambda 0.877194627587 reduce_mul/iterative 0.894663500099

longueur du produit : 14251

3.66088092202 iterative 10 tours
3.28151538813 reduce lambda
3.54909799988 reduce mul
reduce_mul/reduce_lambda 1.08154239128 reduce_mul/iterative 0.969465567301


Liste d'entiers L = [randint(1,12) for i in xrange(10000)]
---------------------------------------------------*****--
6.34206861487 iterative 10 tours
6.97328766645 reduce lambda
6.97084852963 reduce mul
reduce_mul/reduce_lambda 0.999650217095 reduce_mul/iterative 1.09914429391

longueur du produit : 15819

5.49298695784 iterative 10 tours
5.57531557782 reduce lambda
5.1004957334 reduce mul
reduce_mul/reduce_lambda 0.914835342001 reduce_mul/iterative 0.928546849382


Liste d'entiers L = [randint(1,12) for i in xrange(20000)]
---------------------------------------------------*****--
24.4621377857 iterative 10 tours
24.1903834146 reduce lambda
24.0782538004 reduce mul
reduce_mul/reduce_lambda 0.995364702894 reduce_mul/iterative 0.984307014022

longueur du produit : 31665

23.3216699329 iterative 10 tours
19.1733144855 reduce lambda
23.4833617122 reduce mul
reduce_mul/reduce_lambda 1.22479406103 reduce_mul/iterative 1.00693311327


Liste d'entiers L = [randint(1,12) for i in xrange(50000)]
---------------------------------------------------*****--
96.3010125589 iterative 10 tours
92.7271658828 reduce lambda
94.8293252355 reduce mul
reduce_mul/reduce_lambda 1.02267037208 reduce_mul/iterative 0.984717841648

longueur du produit : 79140

93.7457855677 iterative 10 tours
95.1697129104 reduce lambda
93.7195456406 reduce mul
reduce_mul/reduce_lambda 0.98476230278 reduce_mul/iterative 0.999720094861
-----------------------------------------------------------------------------------

>>>



Pour les entiers en effet,
avec ce code c’est clair:
- en prenant une liste d’entiers relativement courte, les mesures donnent un rapport reduce_mul/reduce_lambda autour de 0,60 comme je l’avais écrit.
- pour un grand nombre d’entiers dans la liste par contre, c’est à dire un produit très très long, le rapport monte vers la valeur 0,90. C’est ce que tu as observé. C’est simplement parce qu’alors on fait travailler Python sur des nombres gigantesquississimes.

avec ton code, en réalité avec ta liste d’entiers (puisque que nos codes n’ont rien de fondamentalement différent) j’ai obtenu un résultat similaire au tien.
Je pense donc qu’avec mon code dans lequel la liste d’entiers est de longueur variable, tu obtiendras la même variation du rapport reduce mul/reduce lambda, ce qui établira l’explication de la différence que nous avions:
simplement due aux listes d’entiers différentes que nous utilisions.


Pour une liste de réels,
avec ta liste je n’ai pas obtenu le même résultat que toi.
Je ne vois pas d’explication claire pour le moment.

Explication possible: mon code ci-dessus met en évidence une grande variabilité des résultats :
je vois des valeurs de reduce_mul/reduce_lambda de 0.198360244317 et 1.94021710889 l’une au dessus de l’autre ! , et pour reduce_mul/iterative cela varie entre 0.26 et 3.49 !!!!
Peut être les quelques valeurs que tu as observées (mesures uniques et non pas sur plusieurs répétitions) sont elles sorties justement au dessus de 1 alors qu’un peu plus tard elle seraient à <1 ????? Supputation dont je doute moi même.

En tous cas j’aimerais bien trouver une explication et savoir à quoi m’en tenir sur mul()

[eyquem]

Ton message comporte plusieurs niveaux. Je pourrais donc répondre bien des choses. Mais j’hésite à le faire car ma réponse ne pourrait pas être totalement onctueuse. Par ailleurs, cela me demanderait trop de temps.

Je me contenterai donc de lancer un challenge:

que quelqu’un propose le code d’un programme qui mette en évidence que l’expression
prod(L1+L2) = prod(L1) *prod(L2)
est causalement nécessaire pour pouvoir traiter les listes, et non pas seulement une égalité vérifiable après coup.

Je veux dire: écrire un code qui manifeste que l’information de cette expression détermine des propriétés inrinsèques des listes dans le langage Python.

Si quelqu’un peut me demontrer la même chose sans code, je suis preneur aussi. Mais il paraît qu’il est si évident que cette expression est causalement déterminante qu’il devrait être plus facile de montrer cela avec un petit code.

Dit autrement:
je pense que cette expression est un CONSTAT et non pas une LOI DE FONCTIONNEMENT du langage Python et qu'elle n'oblige à rien du tout.
Et je demande si quelqu’un peut me présenter la preuve que j'ai tort.

[SpiceGuid]

Il y a la règle du moindre étonnement, il y a des "best practices", c'est dans ce sens qu'allait mon argumentation, essayer d'expliquer le pourquoi du choix "classique".

Python ne t'oblige à rien du tout, quel est le meilleur style, quelle est la bonne valeur, c'est de la responsabilité du programmeur.

[tyrtamos]

Pour eyquem:

J'ai fait tourner ton code (avec "import time"):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
 
===================================================================================
 
Liste de reels L = [randint(9807,10200)/10000. for i in xrange(10)]
---------------------------------------------------------------**--
 
Avec clock()
2.51750084229e-005     iterative                             10 tours
4.53711675963e-005     reduce lambda
2.32545951409e-005     reduce mul
reduce_mul/reduce_lambda 0.512541254125  reduce_mul/iterative 0.923717472119
Resultat : 1.09129923294
 
Avec Timer
2.05517912627e-005     iterative                             10 tours
3.34743383371e-005     reduce lambda
1.82345674391e-005     reduce mul
reduce_mul/reduce_lambda 0.544732721986  reduce_mul/iterative 0.887249544627
1.98255531015e-005     iterative                             10 tours
3.54209560888e-005     reduce lambda
1.85040991278e-005     reduce mul
reduce_mul/reduce_lambda 0.522405411118  reduce_mul/iterative 0.93334592145
2.76307415865e-005     iterative                             10 tours
3.66974881144e-005     reduce lambda
1.89271141392e-005     reduce mul
reduce_mul/reduce_lambda 0.515760481485  reduce_mul/iterative 0.685002032244
1.94848949949e-005     iterative                             10 tours
3.56118743683e-005     reduce lambda
1.898701007e-005     reduce mul
reduce_mul/reduce_lambda 0.533165142436  reduce_mul/iterative 0.974447646494
1.96084303523e-005     iterative                             10 tours
3.73750608318e-005     reduce lambda
1.8870961704e-005     reduce mul
reduce_mul/reduce_lambda 0.504907852564  reduce_mul/iterative 0.962390225276
2.06116871935e-005     iterative                             10 tours
3.54658780369e-005     reduce lambda
1.8096058099e-005     reduce mul
reduce_mul/reduce_lambda 0.510238547604  reduce_mul/iterative 0.877951325826
 
Liste de reels L = [randint(9807,10200)/10000. for i in xrange(50)]
---------------------------------------------------------------**--
 
Avec clock()
5.9967057238e-005     iterative                             10 tours
0.000136278216599     reduce lambda
6.03488937971e-005     reduce mul
reduce_mul/reduce_lambda 0.442835952094  reduce_mul/iterative 1.00636743867
Resultat : 1.0717699196
 
Avec Timer
5.78519821809e-005     iterative                             10 tours
0.000123894732902     reduce lambda
5.66390895818e-005     reduce mul
reduce_mul/reduce_lambda 0.457154943196  reduce_mul/iterative 0.979034554161
5.81626923221e-005     iterative                             10 tours
0.000123580279265     reduce lambda
5.65455021899e-005     reduce mul
reduce_mul/reduce_lambda 0.45756088695  reduce_mul/iterative 0.972195404517
5.94654288175e-005     iterative                             10 tours
0.000119368846629     reduce lambda
5.63807883802e-005     reduce mul
reduce_mul/reduce_lambda 0.472324144635  reduce_mul/iterative 0.94812716399
5.9169692659e-005     iterative                             10 tours
0.000128944708569     reduce lambda
5.63995058586e-005     reduce mul
reduce_mul/reduce_lambda 0.437392945275  reduce_mul/iterative 0.953182335822
5.96526036012e-005     iterative                             10 tours
0.000125680380339     reduce lambda
5.66353460862e-005     reduce mul
reduce_mul/reduce_lambda 0.450629970512  reduce_mul/iterative 0.949419516787
5.70621045933e-005     iterative                             10 tours
0.000118549021076     reduce lambda
5.6672781043e-005     reduce mul
reduce_mul/reduce_lambda 0.47805355564  reduce_mul/iterative 0.993177196091
 
Liste de reels L = [randint(9807,10200)/10000. for i in xrange(100)]
---------------------------------------------------------------***--
 
Avec clock()
0.000128656459402     iterative                             10 tours
0.00025483098117     reduce lambda
0.000104282559054     reduce mul
reduce_mul/reduce_lambda 0.409222452368  reduce_mul/iterative 0.810550512105
Resultat : 1.18963147355
 
Avec Timer
0.000110287126118     iterative                             10 tours
0.000250245198967     reduce lambda
0.000108067233182     reduce mul
reduce_mul/reduce_lambda 0.431845380565  reduce_mul/iterative 0.979871694783
0.000115591659492     iterative                             10 tours
0.000255321379104     reduce lambda
0.000107632987684     reduce mul
reduce_mul/reduce_lambda 0.421558852853  reduce_mul/iterative 0.93114839044
0.000122277542769     iterative                             10 tours
0.000260790626287     reduce lambda
0.000107700370606     reduce mul
reduce_mul/reduce_lambda 0.412976386995  reduce_mul/iterative 0.880786186627
0.000113817242541     iterative                             10 tours
0.00024981844046     reduce lambda
0.000107468273874     reduce mul
reduce_mul/reduce_lambda 0.430185512632  reduce_mul/iterative 0.94421786607
0.00010985288062     iterative                             10 tours
0.000252289147606     reduce lambda
0.000107479504361     reduce mul
reduce_mul/reduce_lambda 0.426017152862  reduce_mul/iterative 0.978394956551
0.0001094373526     iterative                             10 tours
0.00025090031071     reduce lambda
0.000105910979673     reduce mul
reduce_mul/reduce_lambda 0.422123748564  reduce_mul/iterative 0.967777245673
 
Liste de reels L = [randint(9807,10200)/10000. for i in xrange(200)]
---------------------------------------------------------------***--
 
Avec clock()
0.000223696327631     iterative                             10 tours
0.000460625912477     reduce lambda
0.000183637180399     reduce mul
reduce_mul/reduce_lambda 0.398668801353  reduce_mul/iterative 0.820921748444
Resultat : 1.29277853733
 
Avec Timer
0.000201729495002     iterative                             10 tours
0.000440699284992     reduce lambda
0.000196709467301     reduce mul
reduce_mul/reduce_lambda 0.446357582141  reduce_mul/iterative 0.975115053444
0.000239692284655     iterative                             10 tours
0.000458480889455     reduce lambda
0.000198555010669     reduce mul
reduce_mul/reduce_lambda 0.433071509055  reduce_mul/iterative 0.82837464274
0.000215018904653     iterative                             10 tours
0.000433665256617     reduce lambda
0.000212304870288     reduce mul
reduce_mul/reduce_lambda 0.48955932496  reduce_mul/iterative 0.98737769421
0.00020478793097     iterative                             10 tours
0.000469842398832     reduce lambda
0.000199621906937     reduce mul
reduce_mul/reduce_lambda 0.424869929646  reduce_mul/iterative 0.974773786674
0.000203608729832     iterative                             10 tours
0.000437494852694     reduce lambda
0.000196672032344     reduce mul
reduce_mul/reduce_lambda 0.449541362905  reduce_mul/iterative 0.96593123736
0.000203810878598     iterative                             10 tours
0.000434054580167     reduce lambda
0.000191210272152     reduce mul
reduce_mul/reduce_lambda 0.440521263659  reduce_mul/iterative 0.93817500551
 
Liste de reels L = [randint(9807,10200)/10000. for i in xrange(400)]
---------------------------------------------------------------***--
 
Avec clock()
0.000392872384232     iterative                             10 tours
0.000926264365665     reduce lambda
0.000382364391869     reduce mul
reduce_mul/reduce_lambda 0.412802657689  reduce_mul/iterative 0.973253420742
Resultat : 1.22299028295
 
Avec Timer
0.000416422715532     iterative                             10 tours
0.000894059072362     reduce lambda
0.000396795567701     reduce mul
reduce_mul/reduce_lambda 0.443813591257  reduce_mul/iterative 0.952867249795
0.000449511473814     iterative                             10 tours
0.000890749822184     reduce lambda
0.000382974581664     reduce mul
reduce_mul/reduce_lambda 0.429946290335  reduce_mul/iterative 0.851979546628
0.000417923857298     iterative                             10 tours
0.000869509227717     reduce lambda
0.00038948077715     reduce mul
reduce_mul/reduce_lambda 0.447931735207  reduce_mul/iterative 0.931941956288
0.000416175644817     iterative                             10 tours
0.000909377456669     reduce lambda
0.000387781230113     reduce mul
reduce_mul/reduce_lambda 0.426424942986  reduce_mul/iterative 0.931773002438
0.000416108261895     iterative                             10 tours
0.000907816418972     reduce lambda
0.000390038558005     reduce mul
reduce_mul/reduce_lambda 0.429644749593  reduce_mul/iterative 0.937348747245
0.000417029161831     iterative                             10 tours
0.000914674503051     reduce lambda
0.000391079249803     reduce mul
reduce_mul/reduce_lambda 0.427561114362  reduce_mul/iterative 0.937774346729
 
Liste de reels L = [randint(9807,10200)/10000. for i in xrange(700)]
---------------------------------------------------------------***--
 
Avec clock()
0.000675727174035     iterative                             10 tours
0.00156893647288     reduce lambda
0.000638868715607     reduce mul
reduce_mul/reduce_lambda 0.407198587483  reduce_mul/iterative 0.945453638917
Resultat : 0.948379069863
 
Avec Timer
0.000793205555348     iterative                             10 tours
0.00156554860929     reduce lambda
0.000674821248082     reduce mul
reduce_mul/reduce_lambda 0.431044583398  reduce_mul/iterative 0.850752044703
0.000788440085352     iterative                             10 tours
0.00154940665594     reduce lambda
0.00065513420432     reduce mul
reduce_mul/reduce_lambda 0.422829088678  reduce_mul/iterative 0.830924526152
0.000824572305619     iterative                             10 tours
0.00157661812601     reduce lambda
0.000644921948115     reduce mul
reduce_mul/reduce_lambda 0.409053998224  reduce_mul/iterative 0.782129042803
0.00077987871074     iterative                             10 tours
0.00154769213492     reduce lambda
0.000712005390634     reduce mul
reduce_mul/reduce_lambda 0.460043295802  reduce_mul/iterative 0.912969389763
0.000793564930933     iterative                             10 tours
0.0015941975817     reduce lambda
0.000664661400816     reduce mul
reduce_mul/reduce_lambda 0.416925360097  reduce_mul/iterative 0.837563978583
0.000785872047318     iterative                             10 tours
0.00162620821323     reduce lambda
0.000660464942163     reduce mul
reduce_mul/reduce_lambda 0.406137994379  reduce_mul/iterative 0.840422998142
 
Liste de reels L = [randint(9807,10200)/10000. for i in xrange(800)]
---------------------------------------------------------------***--
 
Avec clock()
0.000734694717928     iterative                             10 tours
0.001835933815     reduce lambda
0.000801778160446     reduce mul
reduce_mul/reduce_lambda 0.436714087347  reduce_mul/iterative 1.09130791454
Resultat : 0.809039991635
 
Avec Timer
0.000884719050649     iterative                             10 tours
0.00182894096507     reduce lambda
0.000781952607345     reduce mul
reduce_mul/reduce_lambda 0.427543929672  reduce_mul/iterative 0.883842850192
0.000863396099277     iterative                             10 tours
0.00180182308239     reduce lambda
0.000774300902182     reduce mul
reduce_mul/reduce_lambda 0.429731925264  reduce_mul/iterative 0.896808432225
0.00082120315951     iterative                             10 tours
0.00182382360648     reduce lambda
0.000780178190394     reduce mul
reduce_mul/reduce_lambda 0.427770639453  reduce_mul/iterative 0.95004285037
0.000821450230225     iterative                             10 tours
0.00176544753491     reduce lambda
0.000771040317449     reduce mul
reduce_mul/reduce_lambda 0.436739298225  reduce_mul/iterative 0.93863302861
0.000828551641523     iterative                             10 tours
0.00173903342942     reduce lambda
0.000764410586606     reduce mul
reduce_mul/reduce_lambda 0.439560605147  reduce_mul/iterative 0.922586533292
0.000821682326957     iterative                             10 tours
0.00183355295175     reduce lambda
0.000791139145734     reduce mul
reduce_mul/reduce_lambda 0.431478755484  reduce_mul/iterative 0.96282847979
 
Liste de reels L = [randint(9807,10200)/10000. for i in xrange(1000)]
---------------------------------------------------------------****--
 
Avec clock()
0.000956436940815     iterative                             10 tours
0.0022386141579     reduce lambda
0.000892842436267     reduce mul
reduce_mul/reduce_lambda 0.398837125691  reduce_mul/iterative 0.933508941537
Resultat : 3.34662522811
 
Avec Timer
0.000970201774417     iterative                             10 tours
0.00248308688653     reduce lambda
0.000961853779059     reduce mul
reduce_mul/reduce_lambda 0.38736211136  reduce_mul/iterative 0.991395609059
0.000958769138622     iterative                             10 tours
0.00231782652641     reduce lambda
0.000975682252087     reduce mul
reduce_mul/reduce_lambda 0.420947055774  reduce_mul/iterative 1.01764044417
0.000980447722083     iterative                             10 tours
0.00245486841613     reduce lambda
0.00097365327743     reduce mul
reduce_mul/reduce_lambda 0.396621371245  reduce_mul/iterative 0.99307005922
0.000962445251376     iterative                             10 tours
0.00234569685172     reduce lambda
0.00100795867181     reduce mul
reduce_mul/reduce_lambda 0.42970542893  reduce_mul/iterative 1.04728936048
0.000962336690001     iterative                             10 tours
0.00220927638229     reduce lambda
0.000958406019541     reduce mul
reduce_mul/reduce_lambda 0.433809924021  reduce_mul/iterative 0.995915493506
0.000968831654999     iterative                             10 tours
0.00245717440946     reduce lambda
0.00097400890952     reduce mul
reduce_mul/reduce_lambda 0.396393884687  reduce_mul/iterative 1.00534381231

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
===================================================================================
 
Liste d'entiers L = [randint(1,12) for i in xrange(100)]
---------------------------------------------------***--
0.000308306816905     iterative                             10 tours
0.000408265638453     reduce lambda
0.00027890914536     reduce mul
reduce_mul/reduce_lambda 0.683156060884  reduce_mul/iterative 0.904648000195
 
longueur du produit : 163
 
0.000290386703103     iterative                             10 tours
0.000461161232359     reduce lambda
0.0002696103021     reduce mul
reduce_mul/reduce_lambda 0.584633492979  reduce_mul/iterative 0.928452643385
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(500)]
---------------------------------------------------***--
0.00250595215813     iterative                             10 tours
0.00318981020477     reduce lambda
0.00248855613372     reduce mul
reduce_mul/reduce_lambda 0.780158057679  reduce_mul/iterative 0.993058117909
 
longueur du produit : 797
 
0.0025301276532     iterative                             10 tours
0.00323889492008     reduce lambda
0.00252607344739     reduce mul
reduce_mul/reduce_lambda 0.779918308472  reduce_mul/iterative 0.998397627957
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(1000)]
---------------------------------------------------****--
0.00776876801557     iterative                             10 tours
0.00911648261146     reduce lambda
0.00775043986074     reduce mul
reduce_mul/reduce_lambda 0.850156819363  reduce_mul/iterative 0.997640790046
 
longueur du produit : 1601
 
0.00769857372815     iterative                             10 tours
0.00937768502227     reduce lambda
0.00778576722944     reduce mul
reduce_mul/reduce_lambda 0.830244053937  reduce_mul/iterative 1.01132592924
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(2000)]
---------------------------------------------------****--
0.0250699284992     iterative                             10 tours
0.0280277580204     reduce lambda
0.0253526709842     reduce mul
reduce_mul/reduce_lambda 0.904555796638  reduce_mul/iterative 1.01127815283
 
longueur du produit : 3197
 
0.0247997566728     iterative                             10 tours
0.0286639725976     reduce lambda
0.0252297944821     reduce mul
reduce_mul/reduce_lambda 0.880191829523  reduce_mul/iterative 1.01734040438
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(3000)]
---------------------------------------------------****--
0.0505974843709     iterative                             10 tours
0.0549408377943     reduce lambda
0.0508296934077     reduce mul
reduce_mul/reduce_lambda 0.92517142891  reduce_mul/iterative 1.00458933956
 
longueur du produit : 4749
 
0.0506884251114     iterative                             10 tours
0.0560533523004     reduce lambda
0.0512704862801     reduce mul
reduce_mul/reduce_lambda 0.914672970946  reduce_mul/iterative 1.01148311804
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(4000)]
---------------------------------------------------****--
0.086019462434     iterative                             10 tours
0.091987032531     reduce lambda
0.0867116422716     reduce mul
reduce_mul/reduce_lambda 0.942650718104  reduce_mul/iterative 1.00804678172
 
longueur du produit : 6381
 
0.0852405046232     iterative                             10 tours
0.0932250477296     reduce lambda
0.0860553550706     reduce mul
reduce_mul/reduce_lambda 0.923092636222  reduce_mul/iterative 1.00955942777
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(5000)]
---------------------------------------------------****--
0.127553704189     iterative                             10 tours
0.134796511062     reduce lambda
0.129071373489     reduce mul
reduce_mul/reduce_lambda 0.95752755373  reduce_mul/iterative 1.01189827696
 
longueur du produit : 7902
 
0.126902317224     iterative                             10 tours
0.136904020514     reduce lambda
0.128424853068     reduce mul
reduce_mul/reduce_lambda 0.938064876293  reduce_mul/iterative 1.01199769931
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(6000)]
---------------------------------------------------****--
0.178534485082     iterative                             10 tours
0.186432171602     reduce lambda
0.181747991615     reduce mul
reduce_mul/reduce_lambda 0.97487461554  reduce_mul/iterative 1.01799936035
 
longueur du produit : 9488
 
0.177990925766     iterative                             10 tours
0.188776509565     reduce lambda
0.178892018867     reduce mul
reduce_mul/reduce_lambda 0.947639191337  reduce_mul/iterative 1.00506257888
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(7000)]
---------------------------------------------------****--
0.237310710141     iterative                             10 tours
0.247874124958     reduce lambda
0.23857431962     reduce mul
reduce_mul/reduce_lambda 0.962481742135  reduce_mul/iterative 1.0053247048
 
longueur du produit : 11093
 
0.240483180474     iterative                             10 tours
0.250598057126     reduce lambda
0.238669707633     reduce mul
reduce_mul/reduce_lambda 0.952400470979  reduce_mul/iterative 0.992459045005
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(8000)]
---------------------------------------------------****--
0.304762404073     iterative                             10 tours
0.31840669337     reduce lambda
0.305528806199     reduce mul
reduce_mul/reduce_lambda 0.959555224689  reduce_mul/iterative 1.00251475286
 
longueur du produit : 12619
 
0.304452247969     iterative                             10 tours
0.31840607195     reduce lambda
0.306397334631     reduce mul
reduce_mul/reduce_lambda 0.962284835696  reduce_mul/iterative 1.00638880703
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(9000)]
---------------------------------------------------****--
0.382064051211     iterative                             10 tours
0.397618485382     reduce lambda
0.384729300341     reduce mul
reduce_mul/reduce_lambda 0.967584039689  reduce_mul/iterative 1.00697592229
 
longueur du produit : 14269
 
0.381926417849     iterative                             10 tours
0.399081900198     reduce lambda
0.386345842848     reduce mul
reduce_mul/reduce_lambda 0.968086607426  reduce_mul/iterative 1.01157140431
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(10000)]
---------------------------------------------------*****--
0.467707194999     iterative                             10 tours
0.480710332048     reduce lambda
0.467417635608     reduce mul
reduce_mul/reduce_lambda 0.972347803753  reduce_mul/iterative 0.99938089601
 
longueur du produit : 15874
 
0.466132055553     iterative                             10 tours
0.485621738479     reduce lambda
0.469757604911     reduce mul
reduce_mul/reduce_lambda 0.967332324089  reduce_mul/iterative 1.00777794472
 
 
Liste d'entiers L = [randint(1,12) for i in xrange(20000)]
---------------------------------------------------*****--
1.78798047393     iterative                             10 tours
1.81786571332     reduce lambda
1.78267388912     reduce mul
reduce_mul/reduce_lambda 0.980641130999  reduce_mul/iterative 0.997032078993
 
longueur du produit : 31674
 
1.78678783364     iterative                             10 tours
1.82996253884     reduce lambda
1.78395643694     reduce mul
reduce_mul/reduce_lambda 0.974859538968  reduce_mul/iterative 0.998415370507

Effectivement, mes listes d'essais n'étaient pas adaptées.
De plus, pour tester la validité des fonctions, il n'était pas nécessaire de calculer des listes aussi longues.
Enfin, pour assurer une plus grande stabilité des résultats, mon code modifié fait une moyenne sur 1000 calculs, et plus (10000, 100000, ...) si le temps reste "raisonnable".

De ce fait, les différences entre les résultats de nos essais diminuent fortement.

En ce qui concerne mon code de test pour les flottants, voilà le mien:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
ta = tb = tc = 0
for i in xrange(0,10000):
 
    L = [random.uniform(0.5,1.5) for i in xrange(1,501)]
 
    t = time.clock()
    a = prod1(L)
    ta += time.clock()-t
 
    t = time.clock()
    b = prod2(L)
    tb += time.clock()-t
 
    t = time.clock()
    c = prod3(L)
    tc += time.clock()-t
 
print a, a==b, a==c   # pour verification
print tc/tb, tc/ta

Je retiens pour ma part les conclusions suivantes:

Pour des listes d'entiers:

• petites listes: la solution mul est meilleure que lambda (-40%), et équivalente à la solution fonction

• grandes listes: les 3 solutions convergent vers la même durée. Il est probable que le temps de calcul des nombres très longs "gomme" alors les différences de code.

Pour des listes de flottants:

• la solution mul est meilleure que lambda (env. -60%), et très légèrement meilleure que la solution fonction (-2%).

A la louche, les solutions avec mul() et avec la définition de fonction sont équivalentes, et on peut choisir l'une ou l'autre selon le contexte, la lisibilité du code ou sa sensibilité...

Et bravo pour avoir trouvé la solution avec mul()!

Tyrtamos

[eyquem]

Pour des listes d'entiers:

petites listes: la solution mul est meilleure que lambda (-40%), et équivalente à la solution fonction (1)
grandes listes: les 3 solutions convergent vers la même durée. Il est probable que le temps de calcul des nombres très longs "gomme" alors les différences de code.

Pour des listes de flottants:

la solution mul est meilleure que lambda (env. -60%), et très légèrement meilleure que la solution fonction (-2%). (2)

(1) équivalente à la solution fonction
Pour tailles 100 et 500 (les plus petites dans mon code) d’entiers,
reduce-mul est meilleure que itérative sur mon ordi,
équivalente sur le tien:

a gauche mes resultats , a droite les tiens

Liste d'entiers L = [randint(1,12) for i in xrange(100)]

clock: reduce_mul/iterative 0.694913251255 reduce_mul/iterative 0.904648000195
Timer: reduce_mul/iterative 0.857273419285 reduce_mul/iterative 0.928452643385

Liste d'entiers L = [randint(1,12) for i in xrange(500)]

clock: reduce_mul/iterative 0.535675623418 reduce_mul/iterative 0.993058117909
Timer: reduce_mul/iterative 0.894124044304 reduce_mul/iterative 0.998397627957

J’ai refait tourner mon code pour très petites tailles de liste d’entiers (2 fois):

Liste d'entiers L = [randint(1,12) for i in xrange(2)]
---------------------------------------------------*--
0.000140520652707 iterative 10 tours
0.000151415892191 reduce lambda
0.000104761918095 reduce mul
reduce_mul/reduce_lambda 0.691881919259 reduce_mul/iterative 0.745526839487

longueur du produit : 4

5.69904834151e-005 iterative 10 tours
8.93968367564e-005 reduce lambda
5.75492136647e-005 reduce mul
reduce_mul/reduce_lambda 0.643750000032 reduce_mul/iterative 1.00980392192
3


Liste d'entiers L = [randint(1,12) for i in xrange(3)]
---------------------------------------------------*--
0.000109231759865 iterative 10 tours
0.00016091430615 reduce lambda
0.000110069855253 reduce mul
reduce_mul/reduce_lambda 0.684027777808 reduce_mul/iterative 1.00767263468

longueur du produit : 5

6.42539764044e-005 iterative 10 tours
0.000108114299451 reduce lambda
6.53714368752e-005 reduce mul
reduce_mul/reduce_lambda 0.604651162772 reduce_mul/iterative 1.01739130453
4


Liste d'entiers L = [randint(1,12) for i in xrange(4)]
---------------------------------------------------*--
0.000123200015565 iterative 10 tours
0.000176279387375 reduce lambda
0.000120685729598 reduce mul
reduce_mul/reduce_lambda 0.684627575551 reduce_mul/iterative 0.979591837262

longueur du produit : 7

7.48698507778e-005 iterative 10 tours
0.000135212715605 reduce lambda
7.15174693937e-005 reduce mul
reduce_mul/reduce_lambda 0.528925619706 reduce_mul/iterative 0.955223880518
5


Liste d'entiers L = [randint(1,12) for i in xrange(5)]
---------------------------------------------------*--
0.000473803234769 iterative 10 tours
0.000206171454806 reduce lambda
0.000131580969111 reduce mul
reduce_mul/reduce_lambda 0.638211382048 reduce_mul/iterative 0.277712264195

longueur du produit : 9

8.32508042379e-005 iterative 10 tours
0.000140800017874 reduce lambda
7.7104771691e-005 reduce mul
reduce_mul/reduce_lambda 0.547619047605 reduce_mul/iterative 0.926174496413
6


Liste d'entiers L = [randint(1,12) for i in xrange(6)]
---------------------------------------------------*--
0.000168177799139 iterative 10 tours
0.000238019077841 reduce lambda
0.000462907995228 reduce mul
reduce_mul/reduce_lambda 1.94483568051 reduce_mul/iterative 2.75249169389

longueur du produit : 10

0.000109511125004 iterative 10 tours
0.000178514308374 reduce lambda
0.000599517536472 reduce mul
reduce_mul/reduce_lambda 3.35837245728 reduce_mul/iterative 5.47448979682
7


Liste d'entiers L = [randint(1,12) for i in xrange(7)]
---------------------------------------------------*--
0.000579961978445 iterative 10 tours
0.000269028605601 reduce lambda
0.000174603196797 reduce mul
reduce_mul/reduce_lambda 0.649013499538 reduce_mul/iterative 0.301059730269

longueur du produit : 12

0.000130463508611 iterative 10 tours
0.000202260343144 reduce lambda
0.000121244459848 reduce mul
reduce_mul/reduce_lambda 0.599447513849 reduce_mul/iterative 0.929336188628
8


Liste d'entiers L = [randint(1,12) for i in xrange(8)]
---------------------------------------------------*--
0.000199746057149 iterative 10 tours
0.000284114321857 reduce lambda
0.00018270478509 reduce mul
reduce_mul/reduce_lambda 0.643067846404 reduce_mul/iterative 0.914685314431

longueur du produit : 12

0.000139123827182 iterative 10 tours
0.000221257170949 reduce lambda
0.000125993666813 reduce mul
reduce_mul/reduce_lambda 0.569444444548 reduce_mul/iterative 0.905622490161
9


Liste d'entiers L = [randint(1,12) for i in xrange(9)]
---------------------------------------------------*--
0.000227682568664 iterative 10 tours
0.00031121273787 reduce lambda
0.000200863517506 reduce mul
reduce_mul/reduce_lambda 0.645421902975 reduce_mul/iterative 0.882208588409

longueur du produit : 17

0.000163428592174 iterative 10 tours
0.000333282582005 reduce lambda
0.000158958750347 reduce mul
reduce_mul/reduce_lambda 0.476948868408 reduce_mul/iterative 0.972649572716
10


Liste d'entiers L = [randint(1,12) for i in xrange(10)]
---------------------------------------------------**--
0.000241092094086 iterative 10 tours
0.000339707979663 reduce lambda
0.000226006377886 reduce mul
reduce_mul/reduce_lambda 0.665296052541 reduce_mul/iterative 0.937427578217

longueur du produit : 18

0.000185219071142 iterative 10 tours
0.000285511147354 reduce lambda
0.000169295259582 reduce mul
reduce_mul/reduce_lambda 0.592954990202 reduce_mul/iterative 0.914027149246
12


Liste d'entiers L = [randint(1,12) for i in xrange(12)]
---------------------------------------------------**--
0.000266793684602 iterative 10 tours
0.000383288937599 reduce lambda
0.000242488919667 reduce mul
reduce_mul/reduce_lambda 0.632653061126 reduce_mul/iterative 0.908900523747

longueur du produit : 19

0.000207009550081 iterative 10 tours
0.000323504802992 reduce lambda
0.000186895261834 reduce mul
reduce_mul/reduce_lambda 0.577720207259 reduce_mul/iterative 0.902834008192
14


Liste d'entiers L = [randint(1,12) for i in xrange(14)]
---------------------------------------------------**--
0.000285511147382 iterative 10 tours
0.000416812751297 reduce lambda
0.000259250826531 reduce mul
reduce_mul/reduce_lambda 0.621983914178 reduce_mul/iterative 0.908023483174

longueur du produit : 22

0.000310933372816 iterative 10 tours
0.0137109604712 reduce lambda
0.000288304798516 reduce mul
reduce_mul/reduce_lambda 0.0210273232952 reduce_mul/iterative 0.927223719684
16


Liste d'entiers L = [randint(1,12) for i in xrange(16)]
---------------------------------------------------**--
0.000332723851784 iterative 10 tours
0.000471009583634 reduce lambda
0.000547555625047 reduce mul
reduce_mul/reduce_lambda 1.16251482788 reduce_mul/iterative 1.64567590244

longueur du produit : 26

0.000264558763774 iterative 10 tours
0.00040675560723 reduce lambda
0.000233828601125 reduce mul
reduce_mul/reduce_lambda 0.57486263734 reduce_mul/iterative 0.883843716947
18


Liste d'entiers L = [randint(1,12) for i in xrange(18)]
---------------------------------------------------**--
0.00035339687031 iterative 10 tours
0.000510679429908 reduce lambda
0.000317358770474 reduce mul
reduce_mul/reduce_lambda 0.621444201367 reduce_mul/iterative 0.898023715365

longueur du produit : 27

0.000301714324024 iterative 10 tours
0.000452292120912 reduce lambda
0.000270146066043 reduce mul
reduce_mul/reduce_lambda 0.597282273011 reduce_mul/iterative 0.895370370356
20


Liste d'entiers L = [randint(1,12) for i in xrange(20)]
---------------------------------------------------**--
0.000384406398013 iterative 10 tours
0.000551466736653 reduce lambda
0.000341942900519 reduce mul
reduce_mul/reduce_lambda 0.620060790239 reduce_mul/iterative 0.889534883621

longueur du produit : 30

0.000322107977411 iterative 10 tours
0.000493358792795 reduce lambda
0.000279923845085 reduce mul
reduce_mul/reduce_lambda 0.567383918505 reduce_mul/iterative 0.869037294062
25


Liste d'entiers L = [randint(1,12) for i in xrange(25)]
---------------------------------------------------**--
0.000484977839392 iterative 10 tours
0.000731657235747 reduce lambda
0.000438603230293 reduce mul
reduce_mul/reduce_lambda 0.599465444834 reduce_mul/iterative 0.904377880118

longueur du produit : 40

0.000425473069896 iterative 10 tours
0.000889219160513 reduce lambda
0.000370717507394 reduce mul
reduce_mul/reduce_lambda 0.416902293446 reduce_mul/iterative 0.871306631662
30


Liste d'entiers L = [randint(1,12) for i in xrange(30)]
---------------------------------------------------**--
0.0005942095992 iterative 10 tours
0.000869384237404 reduce lambda
0.000494755618433 reduce mul
reduce_mul/reduce_lambda 0.569087403644 reduce_mul/iterative 0.832628114894

longueur du produit : 46

0.000499225460231 iterative 10 tours
0.000745066761283 reduce lambda
0.000487771490526 reduce mul
reduce_mul/reduce_lambda 0.654668166496 reduce_mul/iterative 0.977056519313
40


Liste d'entiers L = [randint(1,12) for i in xrange(40)]
---------------------------------------------------**--
0.000724393742814 iterative 10 tours
0.00107052712013 reduce lambda
0.0006436572246 reduce mul
reduce_mul/reduce_lambda 0.601252609574 reduce_mul/iterative 0.888546085585

longueur du produit : 66

0.000700647708015 iterative 10 tours
0.00121635571 reduce lambda
0.000603428648049 reduce mul
reduce_mul/reduce_lambda 0.496095544328 reduce_mul/iterative 0.861244019134
50


Liste d'entiers L = [randint(1,12) for i in xrange(50)]
---------------------------------------------------**--
0.000905422337183 iterative 10 tours
0.0013269842955 reduce lambda
0.00102722552728 reduce mul
reduce_mul/reduce_lambda 0.774105263161 reduce_mul/iterative 1.13452638078

longueur du produit : 83

0.00216647646559 iterative 10 tours
0.00124485095171 reduce lambda
0.000787250893609 reduce mul
reduce_mul/reduce_lambda 0.632405745065 reduce_mul/iterative 0.3633784655
-----------------------------------------------------------------------------------
>>>

===================================================================================

===================================================================================
2


Liste d'entiers L = [randint(1,12) for i in xrange(2)]
---------------------------------------------------*--
0.000105320648117 iterative 10 tours
0.0001550476386 reduce lambda
0.000108673029899 reduce mul
reduce_mul/reduce_lambda 0.700900902978 reduce_mul/iterative 1.03183024262

longueur du produit : 4

5.64317533644e-005 iterative 10 tours
9.19111228086e-005 reduce lambda
6.03428647992e-005 reduce mul
reduce_mul/reduce_lambda 0.656534954152 reduce_mul/iterative 1.06930692742
3


Liste d'entiers L = [randint(1,12) for i in xrange(3)]
---------------------------------------------------*--
0.000110628585162 iterative 10 tours
0.000163707956972 reduce lambda
0.000226844473218 reduce mul
reduce_mul/reduce_lambda 1.38566553156 reduce_mul/iterative 2.05050505605

longueur du produit : 6

6.59301670112e-005 iterative 10 tours
0.000105600013512 reduce lambda
6.53714369037e-005 reduce mul
reduce_mul/reduce_lambda 0.61904761874 reduce_mul/iterative 0.99152542557
4


Liste d'entiers L = [randint(1,12) for i in xrange(4)]
---------------------------------------------------*--
0.000132698429752 iterative 10 tours
0.000186057166275 reduce lambda
0.000123200015423 reduce mul
reduce_mul/reduce_lambda 0.662162161716 reduce_mul/iterative 0.928421049544

longueur du produit : 6

7.34730251679e-005 iterative 10 tours
0.000123479380591 reduce lambda
7.20761995581e-005 reduce mul
reduce_mul/reduce_lambda 0.583710407465 reduce_mul/iterative 0.980988592662
5


Liste d'entiers L = [randint(1,12) for i in xrange(5)]
---------------------------------------------------*--
0.000134653985469 iterative 10 tours
0.000195276215663 reduce lambda
0.00012878731809 reduce mul
reduce_mul/reduce_lambda 0.659513590288 reduce_mul/iterative 0.956431535546

longueur du produit : 8

8.38095345443e-005 iterative 10 tours
0.000141638113291 reduce lambda
7.68254067225e-005 reduce mul
reduce_mul/reduce_lambda 0.542406312378 reduce_mul/iterative 0.916666667345
6


Liste d'entiers L = [randint(1,12) for i in xrange(6)]
---------------------------------------------------*--
0.00018689526155 iterative 10 tours
0.000241092094484 reduce lambda
0.000156165099042 reduce mul
reduce_mul/reduce_lambda 0.647740438676 reduce_mul/iterative 0.835575486225

longueur du produit : 10

0.000109790490114 iterative 10 tours
0.000179631768788 reduce lambda
0.000102247631958 reduce mul
reduce_mul/reduce_lambda 0.569206842686 reduce_mul/iterative 0.931297709402
7


Liste d'entiers L = [randint(1,12) for i in xrange(7)]
---------------------------------------------------*--
0.000183822246299 iterative 10 tours
0.000262323842435 reduce lambda
0.00017627938746 reduce mul
reduce_mul/reduce_lambda 0.671991481309 reduce_mul/iterative 0.958966561498

longueur du produit : 12

0.00012906668303 iterative 10 tours
0.000205612724585 reduce lambda
0.000120406364431 reduce mul
reduce_mul/reduce_lambda 0.585597825591 reduce_mul/iterative 0.932900432584
8


Liste d'entiers L = [randint(1,12) for i in xrange(8)]
---------------------------------------------------*--
0.000204495263688 iterative 10 tours
0.000888101700411 reduce lambda
0.000194717484646 reduce mul
reduce_mul/reduce_lambda 0.219251336369 reduce_mul/iterative 0.952185792154

longueur du produit : 12

0.000144990494618 iterative 10 tours
0.00023215241049 reduce lambda
0.000139403192406 reduce mul
reduce_mul/reduce_lambda 0.60048134806 reduce_mul/iterative 0.961464355117
9


Liste d'entiers L = [randint(1,12) for i in xrange(9)]
---------------------------------------------------*--
0.000207009550422 iterative 10 tours
0.000406476242006 reduce lambda
0.000194438120388 reduce mul
reduce_mul/reduce_lambda 0.478350516697 reduce_mul/iterative 0.939271255803

longueur du produit : 13

0.00015197462244 iterative 10 tours
0.000241092094257 reduce lambda
0.000141358748124 reduce mul
reduce_mul/reduce_lambda 0.586326766789 reduce_mul/iterative 0.930147059121
10


Liste d'entiers L = [randint(1,12) for i in xrange(10)]
---------------------------------------------------**--
0.000228520663768 iterative 10 tours
0.000335517503345 reduce lambda
0.000203098437623 reduce mul
reduce_mul/reduce_lambda 0.605328889249 reduce_mul/iterative 0.888753053114

longueur du produit : 16

0.000402565130571 iterative 10 tours
0.000272660352039 reduce lambda
0.000158120654987 reduce mul
reduce_mul/reduce_lambda 0.579918032838 reduce_mul/iterative 0.392782789615
12


Liste d'entiers L = [randint(1,12) for i in xrange(12)]
---------------------------------------------------**--
0.000270425431154 iterative 10 tours
0.000438882595745 reduce lambda
0.000243327015369 reduce mul
reduce_mul/reduce_lambda 0.554423934164 reduce_mul/iterative 0.899793389736

longueur du produit : 21

0.00020812701041 iterative 10 tours
0.000322666707689 reduce lambda
0.000188850817494 reduce mul
reduce_mul/reduce_lambda 0.585281384767 reduce_mul/iterative 0.907382550311
14


Liste d'entiers L = [randint(1,12) for i in xrange(14)]
---------------------------------------------------**--
0.000293333370337 iterative 10 tours
0.000484139743776 reduce lambda
0.000269307971166 reduce mul
reduce_mul/reduce_lambda 0.556260820617 reduce_mul/iterative 0.918095240432

longueur du produit : 23

0.00023634288732 iterative 10 tours
0.000426311165029 reduce lambda
0.000514869906738 reduce mul
reduce_mul/reduce_lambda 1.20773263516 reduce_mul/iterative 2.17848699649
16


Liste d'entiers L = [randint(1,12) for i in xrange(16)]
---------------------------------------------------**--
0.000529117527549 iterative 10 tours
0.000484139744003 reduce lambda
0.000371834968291 reduce mul
reduce_mul/reduce_lambda 0.768032314837 reduce_mul/iterative 0.702745512918

longueur du produit : 27

0.000272101621931 iterative 10 tours
0.000412622274553 reduce lambda
0.000239974633814 reduce mul
reduce_mul/reduce_lambda 0.581584292982 reduce_mul/iterative 0.881930185168
18


Liste d'entiers L = [randint(1,12) for i in xrange(18)]
---------------------------------------------------**--
0.000352279409753 iterative 10 tours
0.000519619113675 reduce lambda
0.000325460358454 reduce mul
reduce_mul/reduce_lambda 0.62634408529 reduce_mul/iterative 0.923869943695

longueur du produit : 29

0.000303669879941 iterative 10 tours
0.000450057199942 reduce lambda
0.000272101621931 reduce mul
reduce_mul/reduce_lambda 0.604593420495 reduce_mul/iterative 0.896044158164
20


Liste d'entiers L = [randint(1,12) for i in xrange(20)]
---------------------------------------------------**--
0.000390831795357 iterative 10 tours
0.000569625469552 reduce lambda
0.000534146099881 reduce mul
reduce_mul/reduce_lambda 0.937714565854 reduce_mul/iterative 1.36669049506

longueur du produit : 30

0.000330209565846 iterative 10 tours
0.00056459689722 reduce lambda
0.000293892100899 reduce mul
reduce_mul/reduce_lambda 0.520534388952 reduce_mul/iterative 0.890016920456
25


Liste d'entiers L = [randint(1,12) for i in xrange(25)]
---------------------------------------------------**--
0.000467098471972 iterative 10 tours
0.000681371514929 reduce lambda
0.000493638157877 reduce mul
reduce_mul/reduce_lambda 0.724477244882 reduce_mul/iterative 1.05681818181

longueur du produit : 39

0.000419327037207 iterative 10 tours
0.000609295315599 reduce lambda
0.000422120688427 reduce mul
reduce_mul/reduce_lambda 0.692801466908 reduce_mul/iterative 1.00666222536
30


Liste d'entiers L = [randint(1,12) for i in xrange(30)]
---------------------------------------------------**--
0.000562641341503 iterative 10 tours
0.000870781063213 reduce lambda
0.000719644536048 reduce mul
reduce_mul/reduce_lambda 0.826435675338 reduce_mul/iterative 1.27904667319

longueur du produit : 48

0.000504533397589 iterative 10 tours
0.000741155649848 reduce lambda
0.000436088944298 reduce mul
reduce_mul/reduce_lambda 0.588390501222 reduce_mul/iterative 0.864341085015
40


Liste d'entiers L = [randint(1,12) for i in xrange(40)]
---------------------------------------------------**--
0.00077440009818 iterative 10 tours
0.00103867949701 reduce lambda
0.000635276271169 reduce mul
reduce_mul/reduce_lambda 0.611619150079 reduce_mul/iterative 0.820346320541

longueur du produit : 64

0.000672711196557 iterative 10 tours
0.00102666679709 reduce lambda
0.000668520719955 reduce mul
reduce_mul/reduce_lambda 0.651156462692 reduce_mul/iterative 0.993770764299
50


Liste d'entiers L = [randint(1,12) for i in xrange(50)]
---------------------------------------------------**--
0.000896482653161 iterative 10 tours
0.00139459065304 reduce lambda
0.00106298426181 reduce mul
reduce_mul/reduce_lambda 0.762219551303 reduce_mul/iterative 1.18572764131

longueur du produit : 82

0.000859606458562 iterative 10 tours
0.00123032396573 reduce lambda
0.000991187427417 reduce mul
reduce_mul/reduce_lambda 0.805631244312 reduce_mul/iterative 1.15307117291
-----------------------------------------------------------------------------------

Ces résultats montrent que le rapport reduce_mul/iterative tourne en effet autour de 1. Mais il a par rapport à 1 le même comportement qu’une comète par rapport à la Terre: tantôt loin du soleil, tantôt dans les parages de la Terre, et tantôt proche du soleil. On remarque:

reduce_mul/iterative 0.745526839487 pout clock et N=2
reduce_mul/iterative 1.00980392192 pour Timer et N=2


reduce_mul/iterative 0.277712264195 pour clock et N=5 !!


reduce_mul/iterative 2.75249169389 pour clock et N=6 !!
reduce_mul/iterative 5.47448979682 pour Timer et N=6 !!!!!


reduce_mul/iterative 0.301059730269 pour Timer et N=7

reduce_mul/iterative 1.64567590244 pour clock et N=16

reduce_mul/iterative 0.3633784655 pour Timer et N=50

reduce_mul/iterative 2.05050505605 pour clock et N=3

reduce_mul/iterative 0.392782789615 pour Timer et N=10

reduce_mul/iterative 2.17848699649 pour Timer et N=14

reduce_mul/iterative 0.702745512918 pour clock et N=16

reduce_mul/iterative 1.36669049506 pour clock et N=20

C'est un peu n’importe quoi ces résultats, je ne vois pas comment on peut en tirer une conclusion ferme. Ça me donne l’impression que ce rapport est plutôt vers -10% (c’est à dire 0,9) mais je note des valeurs aberrantes qui ne sont pas rares et une grande variabilité qui empêchent d’être sûr.




(2) très légèrement meilleure que la solution
Chez moi non, le rapport reduce_mul/iterative tourne autour de 0,70 (valeurs erratiques à 1 et 0.26 !): cf résultats dans message #29





3/ Conclusion

valable seulement sur mon ordinateur:

- pour reduce(mul,L) par rapport à reduce(lambda,L) , conclusion identique à la tienne : -60% pour les réels, -40% pour les entiers, sauf avec listes d’entiers hyper balèzes qui ne sont de toutes façons jamais rencontrées dans les besoins pratiques même les plus marginaux

- reduce(mul,L) équivalente à l’itérative pour les entiers, on ne peut pas les départager

- reduce(mul,L) à -30% de l’itérative pour les flottants


Pour ce qui me concerne, reduce(mul,L) est toujours au moins équivalente aux autres solutions, et elle remporte en fait la palme de la vitesse et de la concision (1 seule ligne de code).

Mais je concède que question clarté, l’itérative est immédiatement compréhensible tandis que reduce(mul,L) ne le sera pas par quelqu’un qui ne connaît pas reduce et mul.


Pour moi, il reste à comprendre :
-pourquoi une telle variabilité de reduce_mul/iterative pour des listes d’entiers
- pourquoi reduce_mul est plus rapide sur mon ordinateur que sur le tien pour les flottants.
Il faudrait étudier les valeurs absolues des temps d’exécution de ces deux fonctions.

Merci pour tes réponses , Tyrtamos

[yoshik]

Salut les gars,

Je ne pensais pas lever un tel lièvre avec une question aussi "anodine"...
Mais je lis tout avec intérêt.

Pour moi, il reste à comprendre :
-pourquoi une telle variabilité de reduce_mul/iterative pour des listes d’entiers
- pourquoi reduce_mul est plus rapide sur mon ordinateur que sur le tien pour les flottants.

Si je puis permettre, je vois deux pistes matérielles :
- comparer les quantités de RAM des deux bécanes et leurs "vitesses"
- comparer les deux processeurs.
Je pencherais plus pour la deuxième solution à cause de ces différences possibles :
- simple coeur, double, triple...
- marque du processeur
- finesse de la gravure.

Euh, Eyquem, désolé, je n'ai pas tout compris. Ca veut dire quoi :

...cette expression est causalement déterminante

?
Je ne sais pas ce que ça veut dire, mais on peut démontrer un truc pareil ???

@+