web-dev-qa-db-fra.com

Trouver les indices des éléments supérieurs à x

Étant donné le vecteur suivant,

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

J'ai besoin d'identifier les indices de "a" dont les éléments sont> = à 4, comme ceci:

idx = [3, 4, 5, 6, 7, 8]

Les informations dans "idx" seront utilisées pour supprimer les éléments d'une autre liste X (X a le même nombre d'éléments que "a"):

del X[idx] #idx is used to delete these elements in X. But so far isn't working.

J'ai entendu dire que numpy pourrait aider. Des idées? Merci!

pythonindexinglogical-operatorsindices
20
Oliver Amundsen

OK, je comprends ce que vous voulez dire et une seule ligne de Python suffira:

en utilisant la compréhension de la liste

[ j for (i,j) in Zip(a,x) if i >= 4 ]
# a will be the list compare to 4
# x another list with same length

Explanation:
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j']

La fonction Zip retournera une liste de tuples

>>> Zip(a,x)
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'j')]

La compréhension de liste est un raccourci pour boucler un élément sur une liste qui après "dans", et évaluer l'élément avec une expression, puis retourner le résultat à une liste, vous pouvez également ajouter une condition sur le résultat que vous souhaitez retourner

>>> [expression(element) for **element** in **list** if condition ]

Ce code ne fait que renvoyer toutes les paires zippées.

>>> [(i,j) for (i,j) in Zip(a,x)]
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'j')]

Ce que nous faisons est d'ajouter une condition dessus en spécifiant "si" suivi d'une expression booléenne

>>> [(i,j) for (i,j) in Zip(a,x) if i >= 4]
[(4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'j')]

en utilisant Itertools

>>> [ _ for _ in itertools.compress(d, map(lambda x: x>=4,a)) ]
# a will be the list compare to 4
# d another list with same length

Utilisez itertools.compress avec ne seule ligne dans Python pour terminer la fermeture de cette tâche

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> d = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j'] # another list with same length
>>> map(lambda x: x>=4, a)  # this will return a boolean list 
[False, False, False, True, True, True, True, True, True]


>>> import itertools
>>> itertools.compress(d, map(lambda x: x>4, a)) # magic here !
<itertools.compress object at 0xa1a764c>     # compress will match pair from list a and the boolean list, if item in boolean list is true, then item in list a will be remain ,else will be dropped
#below single line is enough to solve your problem
>>> [ _ for _ in itertools.compress(d, map(lambda x: x>=4,a)) ] # iterate the result.
['d', 'e', 'f', 'g', 'h', 'j']

Explication pour itertools.compress, je pense que cela sera clair pour votre compréhension:

>>> [ _ for _ in itertools.compress([1,2,3,4,5],[False,True,True,False,True]) ]
[2, 3, 5]
15
Shawn Zhang
>>> [i for i,v in enumerate(a) if v > 4]
[4, 5, 6, 7, 8]

enumerate renvoie l'index et la valeur de chaque élément d'un tableau. Donc, si la valeur v est supérieure à 4, incluez l'index i dans le nouveau tableau.

Ou vous pouvez simplement modifier votre liste en place et exclure toutes les valeurs ci-dessus 4.

>>> a[:] = [x for x in a if x<=4]
>>> a 
[1, 2, 3, 4]
26
Aesthete
>>> import numpy as np
>>> a = np.array(range(1,10))
>>> indices = [i for i,v in enumerate(a >= 4) if v]
>>> indices
[3, 4, 5, 6, 7, 8]

>>> mask = a >= 4
>>> mask
array([False, False, False,  True,  True,  True,  True,  True,  True], dtype=boo
l)
>>> a[mask]
array([4, 5, 6, 7, 8, 9])
>>> np.setdiff1d(a,a[mask])
array([1, 2, 3])
6
Joran Beasley

Le plus simple à mes yeux serait d'utiliser numpy

X[np.array(a)>4]#X needs to be np.array as well

Explication: np.array convertit a en tableau.

np.array (a)> 4 donne un tableau booléen avec tous les éléments à conserver

Et X est filtré par le tableau bool donc seuls les éléments où a est supérieur à 4 sont sélectionnés (et le reste est rejeté)

4
Okapi575

l'utilisation de la fonction intégrée de filtre est très bien

>>>a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>filter(lambda x : x < 4, a)
[1, 2, 3]

Explication

filtre (FUN, Iterable)

cette expression itérera tous les éléments de Iterable et fournira à FUN une fonction d'argument, si return est True, l'arugment sera ajouté à une liste interne

lambda x: x> 4

cela signifie une fonction anonyme qui prendra un argument et le testera s'il est supérieur à 4, et retournera la valeur True ou False

Votre solution

si vous essayez de supprimer tous les éléments supérieurs à 4, essayez de souffler

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> filter(lambda x: x<4 ,a)
[1, 2, 3]
1
Shawn Zhang