Vérifier si toutes les valeurs de la liste sont supérieures à un certain nombre

my_list1 = [30,34,56]
my_list2 = [29,500,43]

Comment puis-je vérifier si toutes les valeurs de la liste sont >= 30? my_list1 doit travailler et my_list2 ne devrait pas.

La seule chose que je pouvais penser était:

boolean = 0
def func(ls):
    for k in ls:
        if k >= 30:
            boolean = boolean + 1
        else:
            boolean = 0
    if boolean > 0:
        print 'Continue'
    elif boolean = 0:
        pass

Mise à jour de 2016:

Avec le recul, après avoir fait face à de plus grands ensembles de données où la vitesse qui importe réellement et en utilisant numpy...je voudrais faire cela:

>>> my_list1 = [30,34,56]
>>> my_list2 = [29,500,43]

>>> import numpy as np
>>> A_1 = np.array(my_list1)
>>> A_2 = np.array(my_list2)

>>> A_1 >= 30
array([ True,  True,  True], dtype=bool)
>>> A_2 >= 30
array([False,  True,  True], dtype=bool)

>>> ((A_1 >= 30).sum() == A_1.size).astype(np.int)
1
>>> ((A_2 >= 30).sum() == A_2.size).astype(np.int)
0

Vous pouvez aussi faire quelque chose comme:

len([*filter(lambda x: x >= 30, my_list1)]) > 0

Une des questions générales à savoir: 1) la assignés boolean variable est locale à la fonction (comme il n'est pas approprié global annotation), et 2) boolean = 0 est une mission, pas une comparaison.
Notez que votre my_list1 a une valeur qui n'est pas au-dessus de 30. Il est plutôt égal à 30. Si le 31 au lieu de cela, ou êtes-vous tester pour supérieur ou égal à 30 ici?

InformationsquelleAutor O.rka | 2013-11-26

98

Utiliser le all() function avec un générateur d'expression:
```
>>> my_list1 = [30, 34, 56]
>>> my_list2 = [29, 500, 43]
>>> all(i >= 30 for i in my_list1)
True
>>> all(i >= 30 for i in my_list2)
False
```
Noter que ces tests pour plus de ou égale à 30, sinon my_list1 ne passerait pas le test.

Si vous vouliez faire cela dans une fonction, vous pouvez utiliser:
```
def all_30_or_up(ls):
    for i in ls:
        if i < 30:
            return False
    return True
```
par exemple, dès que vous trouvez une valeur qui prouve qu'il y a un valeur en dessous de 30, vous revenez False, et retour True si vous avez trouvé aucune preuve du contraire.

De même, vous pouvez utiliser le any() function pour tester si au moins 1 valeur correspond à la condition.
- Quel est l'avantage de l'utilisation de all_30_or_up sur all? Ne devrait pas all aussi arrêter de consommer de l'itérateur dès que négatif a été trouvé? Serait tout à fait stupide, autrement, ne serait-il pas?
- les deux s'arrêtent dès qu'un négatif n'a été trouvé. Je voulais donner l'OP d'une manière différente d'envisager le problème, en leur donnant une fonction pour remplacer celui qu'ils ont écrit.
- Mucho <3
InformationsquelleAutor Martijn Pieters
7

...aucune raison pourquoi vous ne pouvez pas utiliser min()?
```
def above(my_list, minimum):
    if min(my_list) >= minimum:
        print "All values are equal or above", minimum
    else:
        print "Not all values are equal or above", minimum
```
Je ne sais pas si c'est exactement ce que vous voulez, mais techniquement, c'est ce que vous avez demandé...
- L'inconvénient de cette solution est que chaque élément de la liste doit être touché.
- J'ai fait un peu de profilage sur cette. all les courts-circuits, il est donc beaucoup plus rapide si la liste ne sont pas admissibles. Mais si la liste est tous les 30+, min peut être plus rapide. J'ai testé avec deux de 1000 élément des listes d'entiers aléatoires, l'un rempli avec random.randint(0, 100) (à défaut) et un rempli avec random.randint(30, 100). À l'aide de min a pris un peu moins de la moitié du temps sur le 30-100 liste. Mais all a pris environ 2% du temps que min fait sur le 0-100 liste, de sorte qu'il remporte probablement à défaut, à moins que les listes sont très rares.
- Vous êtes à la fois du droit! Merci!
- Comme il s'est avéré, le premier élément de mon 0-100 liste a été en dessous de 30, donc mon test était une sorte de dégénérer. En forçant le premier alinéa 30 de l'élément à mi-chemin par le biais de la liste, min sort un peu plus vite - 0,25 s pour 10000 répétitions plutôt que de 0,32 s pour all. Donc, ce qui est plus rapide dépend de la nature des données, comme vous le souhaitez.
InformationsquelleAutor Roberto
3

Il y a une fonction builtin all:
```
all (x > limit for x in my_list)
```
Étant la limite de la valeur au-delà de laquelle tous les nombres doivent être.
- Comme my_list1 doit tester True, le test doit presque certainement être >= 30, pas > 30.
- Ainsi, lorsque l'OP du texte de la question contredit lui-même, qui suis-je pour juger qui est la bonne limite.
InformationsquelleAutor Hyperboreus
2

Vous pouvez utiliser all():
```
my_list1 = [30,34,56]
my_list2 = [29,500,43]
if all(i >= 30 for i in my_list1):
    print 'yes'
if all(i >= 30 for i in my_list2):
    print 'no'
```
Noter que cela inclut tous les nombres égaux à 30 ou plus, ne sont pas strictement au-dessus de 30.
- Comme my_list1 doit tester True, le test doit presque certainement être >= 30, pas > 30.
- merci, maintenant mis à jour. Question mentionne au dessus de 30, mais >= 30 semble destiné.
- Je sais, c'est pourquoi j'ai fait explicite. 🙂
InformationsquelleAutor Simeon Visser
1

Le vainqueur entre l'utilisation de la np.somme, np.min, et tout semble être np.min en termes de vitesse pour les grands tableaux:
```
N = 1000000
def func_sum(x):
    my_list = np.random.randn(N)
    return np.sum(my_list < x )==0

def func_min(x):
    my_list = np.random.randn(N)
    return np.min(my_list) >= x

def func_all(x):
    my_list = np.random.randn(N)
    return all(i >= x for i in my_list)
```
(j'ai besoin de mettre de la np.définition de tableau à l'intérieur de la fonction, sinon de la np.min fonction mémorise la valeur et de ne pas faire le calcul à nouveau lors des essais de vitesse avec timeit)

La performance de "tout" dépend très fortement lorsque le premier élément qui ne satisfait pas le critère est trouvé, le np.la somme doit faire un peu d'opérations, de la np.min est le plus léger en termes de calculs dans le cas général.

Lorsque le critère est presque immédiatement rencontré, et tous les boucle rapide, l'ensemble des fonctions est de gagner juste un peu plus de np.min:
```
>>> %timeit func_sum(10)
10 loops, best of 3: 36.1 ms per loop

>>> %timeit func_min(10)
10 loops, best of 3: 35.1 ms per loop

>>> %timeit func_all(10)
10 loops, best of 3: 35 ms per loop
```
Mais quand "tout" doit passer par tous les points, il est certainement bien pire, et de la np.min victoires:
```
>>> %timeit func_sum(-10)
10 loops, best of 3: 36.2 ms per loop

>>> %timeit func_min(-10)
10 loops, best of 3: 35.2 ms per loop

>>> %timeit func_all(-10)
10 loops, best of 3: 230 ms per loop
```
Mais en utilisant
```
np.sum(my_list<x)
```
peut être très utile est l'un veut savoir comment beaucoup de valeurs sont en dessous de x.

InformationsquelleAutor Chachni

Vous pouvez effectuer les opérations suivantes:

def Lists():

    my_list1 = [30,34,56]
    my_list2 = [29,500,43]

    for element in my_list1:
        print(element >= 30)

    for element in my_list2:
        print(element >= 30)

Lists()

Ce sera le retour de la que des valeurs supérieures à 30 comme Vrai, et les valeurs qui sont plus petits comme faux.

InformationsquelleAutor Filip Grebowski

J'écris cette fonction

def larger(x, than=0):
    if not x or min(x) > than:
        return True
    return False

Puis

print larger([5, 6, 7], than=5)  # False
print larger([6, 7, 8], than=5)  # True
print larger([], than=5)  # True
print larger([6, 7, 8, None], than=5)  # False

Liste vide sur min() va raise ValueError. J'ai donc ajouté if not x dans la condition.

InformationsquelleAutor Shameem

Vous devez vous connecter pour publier un commentaire.