J'ai plusieurs listes ayant toutes le même nombre d'entrées (chacune spécifiant une propriété d'objet):

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

et liste avec des drapeaux de même longueur

good_objects = [True, False, False, True]

(qui pourrait facilement être remplacée par une liste d'index équivalente:

good_indices = [0, 3]

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

property_asel = [545., 33.]
property_bsel = [ 1.2, 0.3]

Vous pouvez simplement utiliser la 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]

Ce dernier est plus rapide car il y en a moins good_indicesque la longueur de property_a, en supposant qu'ils good_indicessont précalculés au lieu d'être générés à la volée.

Edit : La première option est équivalente à itertools.compressdisponible depuis Python 2.7 / 3.1. Voir la réponse de @Gary Kerr .

property_asel = list(itertools.compress(property_a, good_objects))

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. En utilisant une compréhension de liste et en la compressant:

   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]

Utilisez la fonction zip intégrée

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

ÉDITER

Il suffit de regarder 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

En supposant que vous ne disposiez que de la liste des éléments et d'une liste des indices vrais / requis, cela devrait être le plus rapide:

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

Cela signifie que la sélection de propriété ne fera que le nombre de tours qu'il y a d'indices vrais / requis. Si vous avez beaucoup de listes de propriétés qui suivent les règles d'une seule liste de balises (vrai / faux), vous pouvez créer une liste d'index en utilisant les mêmes principes de compréhension de liste:

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

Cela parcourt chaque élément de good_objects (tout en se souvenant de son index avec enumerate) et ne retourne que les indices où l'élément est vrai.

Pour ceux qui ne comprennent pas la liste, voici une version en prose en anglais avec le code surligné en gras:

lister l' index pour chaque groupe d' index, élément qui existe dans une énumération de bons objets , si (où) l' élément est Vrai

Les langages Matlab et Scilab offrent une syntaxe plus simple et plus élégante que Python pour la question que vous posez, donc je pense que le mieux que vous puissiez faire est d'imiter Matlab / Scilab en utilisant le package Numpy en Python. En faisant cela, la solution à votre problème est très concise et élégante:

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 essaie d'imiter Matlab / Scilab mais cela a un coût: vous devez déclarer chaque liste avec le mot-clé "array", quelque chose qui surchargera votre script (ce problème n'existe pas avec Matlab / Scilab). Notez que cette solution est limitée aux tableaux de nombres, ce qui est le cas dans votre exemple.