bonjour
J’ai une liste par exemple
u=range(15)
Je souhaite compter le nombre d’éléments de u tel que 2<=u[i]<=10
existe il un moyen d’avoir directement le résultat sans faire une boucle et passer en revu tout les éléments de la liste.
J’ai bien trouvé pour compter le nombre d’éléments égale à 2 mais pas supérieur à 2.
merci
Sinon je viens de trouver ca
u=range(15)
[i for i in u if i>=2 and i<=10] # pour obtenir la liste réalisant la condition
len([i for i in u if i>=2 and i<=10]) # pour avoir le nombre d'éléments
avec R je fais sum(u>=2 & u<=10) et je trouve ceci plus logique.
Si vous avez une autre méthode je suis preneur
Heureusement que j’aime bien les monthy python ca motive.
Je ne connais pas mieux personnellement. Seul perl et langages fonctionnel sont plus agréable je trouve (avec des filtres). Pour sum(u>=2 & u<=10) c’est vraiment une question de goût (c’est plus court oui, mais plus logique je dirais pas).
il y a aussi la fonction filter :
>>> u= range(15)
>>> def plage(x):return x>=2 and x<=10
>>> print filter(plage,u)
[2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> len(filter(plage,u))
9edit
on peut aussi faire ça avec un lambda en plus pour eviter la fonction au début :
>>> len(filter(lambda x: x>=2 and x<=10,u))
9
print filter(lambda x: x>=2 and x<=10,u)
[2, 3, 4, 5, 6, 7, 8, 9, 10]
Merci
Je pense cependant garder la syntaxe [f(x) for x in liste if x>=2 and x<=10]
edit: tu m’as fait cependant découvrir la fonction plage et après lecture la fonction map (j’en avais besoin)
def f(x):return x**2
map(f,u)
edit2 c’est quoi le mieux (ou le plus rapide)
[f(x) for x in u ] ou map(f,u)
edit3:[quote=“MisterFreez”] (c’est plus court oui, mais plus logique je dirais pas).[/quote]
ce qui est plus logique est le résultat de u>2 & u<10
[quote=“limax”]edit2 c’est quoi le mieux (ou le plus rapide)
[f(x) for x in u ] ou map(f,u)[/quote]
j’en sais rien je ne suis qu’un débutant en Programmation.
il faudrait faire un test en lançant un timer sur une très grosse liste pour comparer les deux syntaxes.
j’ai fais des tests de vitesse avec le module timeit
script pour map
[code]#!/usr/bin/env python
import timeit
def f(x):return x**2
test1 = timeit.Timer(“map(f,u)”, “from main import f;u = range(100000)”)
print(test1.timeit(10))[/code]
[quote=“Python_2.6.6_WinVista (au boulot)”]>>>
1.71375950016[/quote]
script pour for :
[code]#!/usr/bin/env python
import timeit
def f(x):return x**2
test1 = timeit.Timer("[f(x) for x in u ]", “from main import f;u = range(100000)”)
print(test1.timeit(10))[/code]
[quote=“Python_2.6.6_WinVista (au boulot)”]>>>
1.72096153282[/quote]
les résultat sont les mêmes, perso je préfère la fonction map, qui est plus lisible, ensuite ce n’est qu’une question de gout.
Les comprehension list me semblent plus gourmandes (je crois qu’elles consomment plus de mémoire aussi).
On peut faire aussi:
>>> u = range(15)
>>> u
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> len(u[2:11])
9
>>> non ca ne fonctionne pas comme ça !
le but était de compter les éléments de la liste compris entre 2 et 10
Non mais là il n’y a que l’idée, il faut développer.
par exemple:
>>> u = sample(xrange(50), 20)
>>> u
[25, 0, 9, 26, 13, 2, 14, 43, 45, 24, 3, 36, 5, 1, 37, 42, 48, 44, 15, 30]
>>> u.append(2)
>>> u.append(11)
>>> u.sort()
>>> u
[0, 1, 2, 2, 3, 5, 9, 11, 13, 14, 15, 24, 25, 26, 30, 36, 37, 42, 43, 44, 45, 48]
>>> start = u.index(2)
>>> end = u.index(11)
>>> len(u[start:end])-1
4
>>> il y a bien 4 chiffres entre 2 et 10 (2<=u[i]<=10) dans la liste u première.
solution à la question:
“existe t-il un moyen d’avoir directement le résultat sans faire une boucle…”
bonjour
Perso je trouve ca tordu
[f(x) for x in liste if x>=2 and x<=10] est quand même plus simple et plus logique.
@Dixippe > Ta solution n’est pas parfaite car elle pose deux hypothèses fortes :
[ul]
[li]on utilise une liste d’entiers trié[/li]
[li]la condition est simple[/li][/ul]
Si tu veux dans une liste de nombre à virgule flotante trouver tout les nombres qui sont des entiers ta solutions ne pourrait être utilisée. Si l’ordre dans la liste est importante, ta solution n’est pas acceptable non plus. L’utilisation de map ou des lists comprehensions est extrèmement générique.
@MisterFreez> bien évidemment, c’est une solution pour le jeu.
Qui voudrait se priver des listes compréhensions par ce que allergique au ‘for’? 
La ‘list comprehension’ est un des super aspects de python.
A noter que la ‘list comprehension’ remplace map et filter “vouées à disparaître et qui ne doivent plus être utilisées”*.
ok, j’adopterai donc de préférence les listes comprehensions.
limax, j’ai eu une idée ! Tu peux utiliser numpy. Avec tu peux faire les opération dont tu parle et dont tu es famillier avec R. Ca n’est pas bien compliqué à utiliser non plus 
scipy.org/Tentative_NumPy_Tu … 97586a4fc5
oui merci je regarde plus attentivement la doc.
Sinon je me suis bien fait aux listes comprehension