1
votes

Comment faire la logique et l'opération sur la liste des objets booléens?

J'ai une liste d'objets booléens comme ceci:

[False, False, True, False]

Je veux bit et ces listes et obtenir le résultat:

[[True, True, True, False], [False, True, True, False], [False, False, True, True]]

Quelle est la meilleure façon de procéder?

python list logical-operators

2 commentaires

Ce n'est pas une liste de bits. C'est une liste d'objets bool .

@ juanpa.arrivillaga Merci, j'ai édité.

3 Réponses :

3
votes

Tant que vous utilisez boolean, vous pouvez zip et puis utilisez all :

[False, False, True, False]

Sortie

data = [[True, True, True, False], [False, True, True, False], [False, False, True, True]]
result = [all(e) for e in zip(*data)]
print(result)

4 commentaires

Cela fait des et logiques, pas des bits &

Puisque les bools ne sont qu'un peu, ne serait-ce pas pareil?

Je sais, le résultat est le même pour ce cas particulier. Mais puisque la question se pose spécifiquement ... ;-)

@schwobaseggl Merci, vous êtes tous la bonne réponse à ce que je voulais. J'ai changé le titre et le contenu de ma question en objets booléens , donc je choisis cette réponse comme solution.

2
votes

Vous pouvez utiliser functools.reduce et le bitwise "et" operator.and_ , ainsi que le zip (* ...) motif de transposition:

from functools import reduce
from operator import and_

lst = [[True, True, True, False], [False, True, True, False], [False, False, True, True]]

[reduce(and_, x) for x in zip(*lst)]
# [False, False, True, False]

1 commentaires

Ce serait le cas, mais c'est sémantiquement incorrect car il n'y a pas de mise à jour sur place (ne confondez pas reduction avec in-place). Notez que & et & = sont deux opérateurs entièrement différents. Chaque type peut les surcharger à sa guise. Que, pour de nombreux types, a = a & b et a & = b sont équivalents, est purement conventionnel.

1
votes

Si vous souhaitez utiliser spécifiquement l'opérateur & au niveau du bit, vous pouvez utiliser functools.reduce avec zip :

>>> def bitwise_and(x, y):
...     return x & y
...
>>> [reduce(bitwise_and, lst) for lst in zip(*l)]
[False, False, True, False]

Nous pouvons également créer notre propre mini-fonction pour remplacer lambda :

>>> from functools import reduce
>>> l = [[True, True, True, False], [False, True, True, False], [False, False, True, True]]
>>> [reduce(lambda x, y: x & y, lst) for lst in zip(*l)]
[False, False, True, False]

Ou utilisez simplement le module opérateur , comme indiqué dans Réponse de @ schwobaseggl .

0 commentaires