web-dev-qa-db-fra.com

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 vérifier si toutes les valeurs de la liste sont> = 30? my_list1 devrait fonctionner et my_list2 ne devrait pas.

La seule chose à laquelle 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 2016:

Avec le recul, après avoir traité avec de plus grands jeux de données où la vitesse importe vraiment et en utilisant numpy..., je le ferais:

>>> 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
pythonlistfunctionmax
57
O.rka

Utilisez la fonction all() avec une expression génératrice:

>>> 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

Notez que ce test est supérieur à ou égal à 30, sinon my_list1 Ne réussirait pas le test non plus.

Si vous vouliez faire cela dans une fonction, vous utiliseriez:

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 existe une valeur inférieure à 30, vous retournez False et restituez True si vous n’avez trouvé aucune preuve du contraire.

De même, vous pouvez utiliser la any() fonction pour vérifier si au moins 1 valeur correspond à la condition.

102
Martijn Pieters

... une raison pour laquelle 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é ...

7
Roberto

Il y a une fonction intégrée all:

all (x > limit for x in my_list)

Être limite la valeur supérieure à ce que tous les nombres doivent être.

3
Hyperboreus

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'

Notez que cela inclut tous les nombres égaux ou supérieurs à 30, pas strictement supérieurs à 30.

2
Simeon Visser

Le gagnant final entre l'utilisation de np.sum, np.min et tout semble être np.min en termes de vitesse pour les tableaux de grande taille:

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 la définition np.array dans la fonction, sinon la fonction np.min mémorise la valeur et ne refait pas le calcul lors des tests de vitesse avec timeit)

La performance de "tout" dépend beaucoup du moment où le premier élément qui ne satisfait pas les critères est trouvé, le np.sum doit faire quelques opérations, le np.min est le plus léger en termes de calculs dans le cas général .

Lorsque les critères sont presque immédiatement satisfaits et que la boucle all se termine rapidement, la fonction all gagne un peu plus que 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, c'est nettement pire, et le np.min gagne:

>>> %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 si l’on veut savoir combien de valeurs sont inférieures à x.

1
Chachni

Vous pouvez faire ce qui suit:

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()

Cela retournera les valeurs supérieures à 30 en tant que True et les valeurs plus petites en tant que false.

0
Filip Grebowski

J'écris cette fonction

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

Ensuite

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


Une liste vide sur min () soulèvera ValueError. Alors j'ai ajouté if not x à la condition.

0
Shameem