Python: Sélectionner un sous-ensemble de la liste basée sur l'indice d'ensemble

J'ai plusieurs listes ayant tous le même nombre d'entrées (chaque spécification d'une propriété de l'objet):

property_a = [545., 656., 5.4, 33.]
property_b = [ 1.2,  1.3, 2.3, 0.3]
...

et de la liste avec des drapeaux de la même longueur

good_objects = [True, False, False, True]

(qui pourrait facilement être remplacé par un équivalent de l'indice de la liste:

good_indices = [0, 3]

Quelle est la façon la plus simple de générer de nouvelles listes de property_asel, property_bsel, ... qui ne contiennent que les valeurs indiquées soit par le True les entrées ou les indices?

property_asel = [545., 33.]
property_bsel = [ 1.2, 0.3]
InformationsquelleAutor fuenfundachtzig | 2010-07-05
  1. 97

    Vous pouvez simplement utiliser compréhension de liste:

    property_asel = [val for is_good, val in zip(good_objects, property_a) if is_good]

    ou

    property_asel = [property_a[i] for i in good_indices]

    Le dernier est plus rapide car il y a moins de good_indices que la longueur de property_a, en supposant good_indices sont précalculées au lieu de généré à la volée.

    Modifier: La première option est équivalente à itertools.compress disponibles depuis le Python 2.7/3.1. Voir @Gary Kerr's réponse.

    property_asel = list(itertools.compress(good_objects, property_a))
    • N'utilisant zip ici introduire une perte de performance?
    • Oui. Provoque beaucoup sur Python 2 (itertools.izip au lieu de cela), pas tellement sur Python 3. C'est parce que le zip en Python 2 créer une nouvelle liste, mais sur Python 3, il va juste revenir un (paresseux) générateur.
    • OK, donc je devrait s'en tenir à votre 2ème proposition ensuite, parce qu'il constitue la partie centrale de mon code.
    • pourquoi êtes-vous soucier de la performance? Écrire ce que vous avez à faire, si c'est lent, puis de tester pour trouver les goulots d'étranglement.
    • Si il y a deux équivalents options, il est bon de savoir laquelle est la plus rapide, et l'utiliser immédiatement.
    • Je soupçonne que le deuxième est plus lent, car où que good_indices liste de la première place? Probablement par l'énumération de tous good_objects et d'enregistrement de l'index où good_objects[i] est Vrai. Donc, pas d'épargne, après tout, plus vous avez eu à construire une deuxième liste. Utilisez la première option, avec izip dans Py2 ou zip dans Py3, lire les deux listes à la fois, et de créer directement la sortie désirée, sans aucun intermédiaire des listes.
    • Vous pouvez simplement utiliser from itertools import izip et l'utiliser à la place de zip dans le premier exemple. Qui crée un itérateur, de même que Python 3.
    • McGuire: Vous avez raison, je suis en boucle sur les propriétés et l'application des tests pour déterminer quels objets sont bonnes. Donc, en principe, il serait possible de construire des listes directement dans cette boucle. C'est aussi probablement le moyen le plus rapide.
    • Comment cela fonctionne pour un multidimensionnelle tableau numpy?

    InformationsquelleAutor kennytm
  2. 19

    Je vois 2 options.

    1. Utilisation de numpy:

      property_a = numpy.array([545., 656., 5.4, 33.])
property_b = numpy.array([ 1.2,  1.3, 2.3, 0.3])
good_objects = [True, False, False, True]
good_indices = [0, 3]
property_asel = property_a[good_objects]
property_bsel = property_b[good_indices]

    2. À l'aide d'une liste de la compréhension et de la fermeture-éclair:

      property_a = [545., 656., 5.4, 33.]
property_b = [ 1.2,  1.3, 2.3, 0.3]
good_objects = [True, False, False, True]
good_indices = [0, 3]
property_asel = [x for x, y in zip(property_a, good_objects) if y]
property_bsel = [property_b[i] for i in good_indices]
    • L'utilisation de 8 espaces de format de code à l'intérieur d'une liste.
    • Utilisation de Numpy est une bonne suggestion depuis l'OP semble vouloir stocker des nombres dans les listes. Un tableau à deux dimensions serait encore mieux.
    • C'est aussi une bonne idée parce que ce sera très syntaxe familière aux utilisateurs de R, où ce type de sélection est très puissant, surtout quand imbriquées et/ou multidimensionnelles.
    • [property_b[i] for i in good_indices] est un bon pour une utilisation sans numpy
    InformationsquelleAutor Wolph
  3. 15

    Utiliser le construit en fonction de zip

    property_asel = [a for (a, truth) in zip(property_a, good_objects) if truth]

    MODIFIER

    Simplement en regardant les nouvelles fonctionnalités de 2.7. Il y a maintenant une fonction dans le module itertools qui est similaire au code ci-dessus.

    http://docs.python.org/library/itertools.html#itertools.compress

    itertools.compress('ABCDEF', [1,0,1,0,1,1]) =>
  A, C, E, F
    • Je suis refroidi par l'utilisation de itertools.compress ici. La compréhension de liste est présent plus lisible, sans avoir à creuser jusqu'à ce que le diable compresser est en train de faire.
    • Hm, je trouve le code à l'aide de compresser beaucoup plus lisible 🙂 Peut-être que je suis partial, parce que c'est exactement ce que je veux.
    InformationsquelleAutor Gary Kerr
  4. 7

    En supposant que vous n'avez que la liste des éléments et une liste de vrai/requis indices, ce devrait être le plus rapide:

    property_asel = [ property_a[index] for index in good_indices ]

    Cela signifie que la propriété de sélection ne pourra faire autant de tours qu'il y a du vrai et nécessaire indices. Si vous avez beaucoup de listes de propriété que de suivre les règles d'un seul balises (vrai/faux) liste, vous pouvez créer une liste des indices à l'aide de la même compréhension de liste principes:

    good_indices = [ index for index, item in enumerate(good_objects) if item ]

    Ce parcourt chaque élément dans good_objects (tout en se souvenant de son index avec énumérer) et renvoie uniquement les indices d'où l'article est vrai.

    Pour quiconque n'est pas d'avoir la liste de compréhension, voici une prose anglaise version avec le code surligné en gras:

    liste les index pour chaque groupe de indice, élément qui existe dans un énumération de les bons objets, si (où) les article est Vrai

    InformationsquelleAutor Eyrofire
  5. 1

    Matlab et Scilab langues offre un moyen plus simple et plus élégant de la syntaxe de Python pour la question posée, donc je pense que le mieux que vous pouvez faire est d'imiter Matlab/Scilab à l'aide de la Numpy paquet Python. En faisant cela, la solution à votre problème est très concis et élégant:

    from numpy import *
property_a = array([545., 656., 5.4, 33.])
property_b = array([ 1.2,  1.3, 2.3, 0.3])
good_objects = [True, False, False, True]
good_indices = [0, 3]
property_asel = property_a[good_objects]
property_bsel = property_b[good_indices]

    Numpy tente d'imiter Matlab/Scilab, mais il a un coût: vous devez déclarer chaque liste avec le mot-clé "array", quelque chose qui ne va pas surcharger votre script (ce problème n'existe pas avec Matlab/Scilab). Notez que cette solution est limitée à des tableaux de nombre, ce qui est le cas dans ton exemple.

    • Nulle part dans la question, il ne mentionner NumPy -- il n'est pas nécessaire d'exprimer votre opinion sur NumPy vs Matlab. Python, les listes sont pas la même chose que les tableaux NumPy, même si ils correspondent approximativement à des vecteurs. (Python, les listes sont comme Matlab tableaux de cellules, chaque élément peut avoir un type de données différent. Les tableaux NumPy sont plus restreintes afin de permettre à certaines optimisations). Vous pouvez obtenir la même syntaxe que votre exemple via Python intégré dans filter ou de la bibliothèque externe pandas. Si vous voulez remplacer les langues, vous pouvez également essayer de R, mais ce n'est pas la question.
    InformationsquelleAutor FredAndre