Extraire des éléments d'une liste

Bonjour,

j'ai une liste de 300 éléments

Code:

ListeA = [ float(a) for a in diamAFile ]

, de ces 300 éléments, je voudrais extraire l'élément 2,4,6.. soit un élément sur deux de la liste... et j'aimerai que ce petit programme puisse par une simple question style "tous les combien d'éléments voulez-vous extraire" reponse :2 ou 3 ou 15 ou... faire automatiquement l'extraction nécessaire.

est-ce possible de faire cela ? je pense qu'il y a une bidouille avec liste.index(x) ... mais je ne trouve pas :(

je vous remercie par avance pour votre aide

Patricia

quelques exemple

Code:

1
2
3
4
liste=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
liste[::2]     ==>  [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
liste[::5]     ==>  [0, 5, 10, 15]
liste[:4:16:2] ==>  [4, 6, 8, 10, 12, 14]

merci beaucoup

mais si ma liste est la suivante :
3.0433
3.0433
3.043
3.0423
3.0427
3.0425
3.0428
3.043
3.0431
3.0429
3.0426
3.0428
3.0423
3.0431
3.0427
3.0428
3.0425
3.0424
3.0429
3.0422
3.042
3.0432
3.042
3.0418
3.0414
... (en tout 300 éléments), et que je veux le deuxième élément, le quatrième... ou bien le 50ème, le 100ème...

ça marche aussi ???

liste[debut:fin:pas]

liste[::17] signifie : extraire du debut de la liste jusqu'à la fin tout les 17 elements
liste|5:71:3] signifie : extraire à partir du 5eme element de la liste jusqu'au 71eme tout les 3 elements

essayes ^^

Code:

print [ float(a) for a in diamAFile ][::int(raw_input("pas : "))]

merci

:ccool:

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 from random import random from time import clock diamAFile = [ str(random())[0:5] for i in xrange(200000) ] print 'Taille de diamAFile: ',len(diamAFile),'\n20 premiers elements de diamAFile :\n',diamAFile[0:20] for pas in (1,2,4,8,16,32,64): te = clock() x = [ float(a) for a in diamAFile ][::pas] tf = clock() print '\n[ float(a) for a in diamAFile ][::pas] ....',tf-te t1 = clock() x = [ float(a) for a in diamAFile[::pas] ] t2 = clock() print '[ float(a) for a in diamAFile[::pas] ] ....',t2-t1,'....',(t2-t1)/(tf-te),'.. pas =',pas
Citation:

Taille de diamAFile: 200000
20 premiers elements de diamAFile :
['0.383', '0.881', '0.177', '0.683', '0.906', '0.029', '0.229', '0.580', '0.839', '0.135', '0.181', '0.546', '0.214', '0.224', '0.012', '0.841', '0.411', '0.567', '0.505', '0.412']

[ float(a) for a in diamAFile ][::pas] .... 1.74050528768
[ float(a) for a in diamAFile[::pas] ] .... 1.77853246712 .... 1.02184835617 .. pas = 1

[ float(a) for a in diamAFile ][::pas] .... 1.64371756746
[ float(a) for a in diamAFile[::pas] ] .... 0.802475454283 .... 0.48820762774 .. pas = 2

[ float(a) for a in diamAFile ][::pas] .... 1.69334929439
[ float(a) for a in diamAFile[::pas] ] .... 0.393598907124 .... 0.232438108562 .. pas = 4

[ float(a) for a in diamAFile ][::pas] .... 1.54080085597
[ float(a) for a in diamAFile[::pas] ] .... 0.219652497734 .... 0.142557357028 .. pas = 8

[ float(a) for a in diamAFile ][::pas] .... 1.77953594661
[ float(a) for a in diamAFile[::pas] ] .... 0.0984608378999 .... 0.0553295021028 .. pas = 16

[ float(a) for a in diamAFile ][::pas] .... 1.54865157443
[ float(a) for a in diamAFile[::pas] ] .... 0.0532355369191 .... 0.034375412648 .. pas = 32

[ float(a) for a in diamAFile ][::pas] .... 1.73652405543
[ float(a) for a in diamAFile[::pas] ] .... 0.0281982765964 .... 0.0162383449329 .. pas = 64

Pour pas==1, la deuxième méthode semble être toujours un tout petit peu moins rapide.
J’ai écrit un code pour le vérifier plus rigoureusement, en compareant les moyennes de temps des deux méthodes,
en éliminant les valeurs trop éloignées du minimum (celles supérieures de 15% au temps minimum) pour atoires a priori sans rapport avec le code mais plutôt avec l'activité erratique de l’ordinateur.

La différence est très faible.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 from random import random from time import clock diamAFile = [ str(random())[0:5] for i in xrange(20000) ] print 'Taille de diamAFile: ',len(diamAFile),'\n20 premiers elements de diamAFile :\n',diamAFile[0:20] print '\n' li = [] lu = [] n = 50 for k in xrange(n): te = clock() x = [ float(a) for a in diamAFile ][::1] tf = clock() print tf-te, li.append(tf-te) t1 = clock() x = [ float(a) for a in diamAFile[::1] ] t2 = clock() print t2-t1 lu.append(t2-t1) print mini = min(li) minu = min(lu) print 'mini =',mini,' minu =',minu limaigr = [ x for x in li if x<=1.15*mini] lumaigr = [ x for x in lu if x<=1.15*minu] print '\n[ float(a) for a in diamAFile ][::pas] .... moyenne =',sum(limaigr)/len(limaigr),' ... sur ',len(limaigr),' valeurs' print '[ float(a) for a in diamAFile[::pas] ] .... moyenne =',sum(lumaigr)/len(lumaigr),' ... sur ',len(lumaigr),' valeurs'
Citation:

Taille de diamAFile: 20000
20 premiers elements de diamAFile :
['0.650', '0.384', '0.772', '0.593', '0.657', '0.137', '0.630', '0.643', '0.631', '0.909', '0.032', '0.336', '0.143', '0.951', '0.402', '0.448', '0.256', '0.709', '0.060', '0.155']

0.152646495574 0.155657772147
0.158133505794 0.158921315418
0.158027067686 0.158959867805
0.155820083279 0.160124540968
0.188157433417 0.217762313367
0.21838948805 0.158231842315
0.156418483355 0.15662521354
0.155613632459 0.156393899225
0.162716211139 0.157797150197
0.156548667498 0.158030699432
0.158107245474 0.157209924725
0.156037429338 0.157360781887
0.157578966042 0.158667093164
0.154982267299 0.157772566066
0.156726623076 0.160547779117
0.161524439558 0.157690153358
0.157446826342 0.155566419754
0.155847181695 0.186357763347
0.217933284817 0.188611681094
0.187493103173 0.157041467561
0.158746432857 0.158045785148
0.158491931237 0.162015284066
0.156421835736 0.155665315005
0.157491804126 0.161278598257
0.165211220979 0.161907169766
0.155771194384 0.162108592014
0.176184962055 0.162548312705
0.16212256027 0.162363931729
0.161717760218 0.161644007828
0.164680427261 0.160013633018
0.162395779352 0.157780667655
0.195301358133 0.220779456607
0.188732087458 0.218947938914
0.156793950069 0.157766699399
0.156693378628 0.155800248356
0.157798547022 0.156701200851
0.161602382425 0.161437557008
0.156247791269 0.157594331123
0.158270394701 0.159377798016
0.157652997797 0.162806725436
0.161094496647 0.164095436711
0.15713756916 0.15702666121
0.219958402534 0.189087439884
0.188776506511 0.188365839792
0.157959181963 0.157299600927
0.156618229412 0.157507169207
0.15819384866 0.156933911991
0.160620134682 0.158738331269
0.157439842214 0.157455486661
0.155729010251 0.157184223135

mini = 0.152646495574 minu = 0.155566419754

[ float(a) for a in diamAFile ][::pas] .... moyenne = 0.158221410413 ... sur 41 valeurs
[ float(a) for a in diamAFile[::pas] ] .... moyenne = 0.158737096864 ... sur 43 valeurs

En fait, même en moyennant sur 50 essais, la moyenne de la deuxième méthode est parfois inférieure à celle de la première.

J'ai donc fait une comparaison basée sur 1000 essais. Elle donne:

Citation:

mini = 0.156810432611 minu = 0.156058102357

[ float(a) for a in diamAFile ][::pas] .... moyenne = 0.165416888466 ... sur 704 valeurs
[ float(a) for a in diamAFile[::pas] ] .... moyenne = 0.163475192135 ... sur 724 valeurs

Même pour pas==1, la deuxième méthode se révèle en fait au moins aussi rapide que la première !

Pour des pas>1 en tous cas, il peut être intéressant d’utiliser la deuxième méthode si des itérations de construction avec des pas>1 sont effectuées.