tableaux

Bonjour,

On peut aussi utiliser la fonction reduce() :

reduce(lambda x,y:x+y,([f(x),g(x)] for x in t))

La syntaxe la plus naturelle serait

sum([f(x),g(x)] for x in t)

mais pour une raison qui m'échappe, sum() ne fonctionne qu'avec des
nombres et pas avec tous les types qui acceptent l'opérateur
d'addition

Pierre

t=[1, 2, 8, 12, 74]
[[i]*2 for i in t]

Ca ne donne pas le même résultat.

[[1, 1], [2, 2], [8, 8], [12, 12], [74, 74]]
au lieu de
[1, 1, 2, 2, 8, 8, 12, 12, 74, 74]

Argh !!!

Effectivement, une faute de frappe dans mes tests faisaient que j'affichais 2 fois la formule de Michel.
Le résultat obtenu est tout à fait logique.

Désolé :(

Nicolas

JBB wrote:

t = [ 1,2,8,12,74]
[i for i in t for j in [1]*2]
Effectivement ça marche mais j'ai du mal à comprendre !

En tout cas trop fort.

On peut imbriquer autant de for que l'on veut dans une liste en
compréhension, cela permet par exemple de générer des listes d'indices a n
dimensions :

d = dict.fromkeys( (i, j, k) for i in range(3) for j in range(3) for k
in range(3) )

print d[0, 0, 0]
None

print d[2, 2, 2]
None

Dans votre exemple cela signifie que l'on itère sur chaque valeur de j, pour
chaque valeur de i. Étant donné que l'on jette j, cela n'a pas un grand
intérêt. D'ailleurs générer une liste dont chaque valeur est doublé
n'apporte aucune information et ne fait que gaspiller de la mémoire ! Si
c'est pour modifier l'élément pair par la suite, alors c'est très peu
efficace puisque il faudra à nouveau parcourir la liste intégralement.

La solution que j'avais donnée est meilleure, puisqu'il n'y a aucune
duplication inutile de la mémoire et une génération de la liste en une
seule itération.

from itertools import chain
def f(e) : return e**e
...

list(i for i in chain(*((e, f(e)) for e in xrange(5))))
[0, 1, 1, 1, 2, 4, 3, 27, 4, 256]

--
_____________

Maric Michaud
_____________

Re !

a=t+t
a.sort()
print a





--
@-salutations

Michel Claveau

Re-re !

(presque) le même :

t = [ 1,2,8,12,74]
t.extend(t)
t.sort()
print t




@+

Michel Claveau

Salut !


Une autre, que je trouve plus jolie :

b=[None]*len(t)*2
b[::2]=t
b[1::2]=t
print b


Je sais, on affecte deux fois.
Et après ?


Michel Claveau

Re !

a=t+t
a.sort()
print a





Effectivement c'est très joli.

Sauf que mon tableau n'est pas forcement dans l'ordre croissant bien que l'exemple le laisse penser.

Re !

Sauf que mon tableau n'est pas forcement dans l'ordre

J'ai eu beau relire le cahier des charges, je n'ai pas trouvé mention
de cette spécificité.
Du coup, il faut réaliser un avenant d'évolution des spécifs.

Bref, en postant le message, je m'étais effectivement posé la question
de la nécessité du maintien de l'ordre.

Dans l'absolu, t+t devrais suffire... Sinon, regarde mon msg de
9h.58





--
@-salutations

Michel Claveau

Sous une forme plus rigolote :

t = [1,2,8,12,74]

b=[None]*len(t)*2
b[1::2]=b[::2]=t
print b





--
@-salutations

Michel Claveau

Re !

Sauf que mon tableau n'est pas forcement dans l'ordre

J'ai eu beau relire le cahier des charges, je n'ai pas trouvé mention de
cette spécificité.
Du coup, il faut réaliser un avenant d'évolution des spécifs.

Bref, en postant le message, je m'étais effectivement posé la question
de la nécessité du maintien de l'ordre.

Dans l'absolu, t+t devrais suffire... Sinon, regarde mon msg de 9h.58





Voila des spec un peu plus detaillés.

soit t une liste t = [t1,t2,...tn]
soit g et f deux fonctions
le but est d'obtenir la liste [ f(t1),g(t1),f(t2),g(t2),...f(tn),g(tn)]

le cas cité dans l'exemple correspondait au cas très (très) particulier ou :
- tn est un entier
- t est trié dans l'ordre croissant
- f = g = lambda(x):x