Trouver les indices d'éléments supérieurs à x

Le suivant vecteur,

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

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

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

Les infos dans "idx" sera utilisé pour supprimer des éléments à partir 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!

source d'informationauteur Oliver Amundsen

  1. 11

    OK, je comprends ce que tu veux et une Seule ligne de Python sera assez:

    l'aide de la liste de compréhension

    [ 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']

    Zip fonction retourne 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')]

    Compréhension de liste est un raccourci vers la boucle d'un élément sur la liste, qui après "dans", et d'évaluer l'élément avec l'expression, puis retourner le résultat dans une liste, vous pouvez aussi ajouter une condition sur le résultat de qui vous voulez retourner

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

    Ce code ne fait rien, mais le retour de toutes les paires de zippée.

    >>> [(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 sur en de préciser "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')]

    à l'aide de 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

    Utilisation itertools.compresser avec seule ligne en Python pour terminer à proximité 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.compresser, je pense que ce sera clair pour votre compréhension:

    >>> [ _ for _ in itertools.compress([1,2,3,4,5],[False,True,True,False,True]) ]
[2, 3, 5]
  2. 21
    >>> [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 dans un tableau. Donc, si la valeur v est plus grand que 4insérer l'index i dans le nouveau tableau.

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

    >>> a[:] = [x for x in a if x<=4]
>>> a 
[1, 2, 3, 4]
  3. 5
    >>> 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])
  4. 3

    La plus simple à mes yeux, serait d'utiliser numpy

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

    Explication:
    np.tableau convertit un à un tableau.

    np.array ()>4 donne un bool array avec tous les éléments qui doivent être conservés

    Et X est filtré par le bool array de sorte que les éléments où a est plus grand que 4 sont sélectionnés (et le reste rejeté)

  5. 1

    utilisation d'un filtre de fonction intégrée 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, Itérable)

    cette expression va se répéter tous les éléments de Itératif et d'approvisionnement à l'AMUSEMENT de la fonction en tant qu'argument, si le retour est True ,alors la arugment sera ajouter à une liste interne

    lambda x: x > 4

    cela signifie qu'une fonction anonyme qui prennent un argument et tester, si plus grand que 4, et retourne True False la valeur

    Votre solution

    si vous essayez de supprimer tous les éléments de taille supérieure à 4 ,puis essayez de souffler

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