Tenho várias listas com o mesmo número de entradas (cada uma especificando uma propriedade de objeto):

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

e lista com sinalizadores do mesmo comprimento

good_objects = [True, False, False, True]

(que poderia ser facilmente substituído por uma lista de índice equivalente:

good_indices = [0, 3]

Qual é a maneira mais fácil de gerar novas listas property_asel, property_bsel... que contêm apenas os valores indicados quer pelas Trueentradas ou os índices?

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

Você pode simplesmente usar a compreensão de lista :

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]

O último é mais rápido porque há menos do good_indicesque o comprimento de property_a, supondo que good_indicessejam pré-computados em vez de gerados instantaneamente.

Editar : a primeira opção é equivalente ao itertools.compressdisponível desde Python 2.7 / 3.1. Veja a resposta de @Gary Kerr .

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

Vejo 2 opções.

1. Usando 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. Usando uma lista de compreensão e compactá-la:

   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]

Use a função integrada zip

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

EDITAR

Basta olhar para os novos recursos do 2.7. Agora existe uma função no módulo itertools que é semelhante ao código acima.

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

itertools.compress('ABCDEF', [1,0,1,0,1,1]) =>
  A, C, E, F

Supondo que você tenha apenas a lista de itens e uma lista de índices verdadeiros / obrigatórios, este deve ser o mais rápido:

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

Isso significa que a seleção da propriedade só fará tantas rodadas quantos forem os índices verdadeiros / obrigatórios. Se você tiver muitas listas de propriedades que seguem as regras de uma única lista de tags (verdadeiro / falso), pode criar uma lista de índices usando os mesmos princípios de compreensão de lista:

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

Isso itera por meio de cada item em good_objects (enquanto lembra seu índice com enumerar) e retorna apenas os índices onde o item é verdadeiro.

Para quem não está entendendo a lista, aqui está uma versão em prosa em inglês com o código destacado em negrito:

liste o índice para cada grupo de índice, item que existe em uma enumeração de objetos bons , se (onde) o item é Verdadeiro

As linguagens Matlab e Scilab oferecem uma sintaxe mais simples e elegante do que Python para a pergunta que você está fazendo, então acho que o melhor que você pode fazer é imitar Matlab / Scilab usando o pacote Numpy em Python. Ao fazer isso, a solução para o seu problema é muito concisa e elegante:

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]

O Numpy tenta imitar o Matlab / Scilab, mas tem um custo: você precisa declarar todas as listas com a palavra-chave "array", algo que sobrecarregará seu script (esse problema não existe no Matlab / Scilab). Observe que esta solução é restrita a matrizes de número, que é o caso em seu exemplo.