Les opérateurs booléens vs opérateurs au niveau du Bit

Je suis confus quand je dois utiliser un Booléen vs opérateurs au niveau du Bit

and vs &, or vs |

Quelqu'un pourrait-il m'éclairer à quand dois-je utiliser chacun et quand l'aide de l'un sur l'autre incidence sur les résultats?

Notez que les réponses que vous obtiendrez à peu près s'appliquent à tous les autres ("mainstream" impératif) langues.

InformationsquelleAutor Jiew Meng | 2010-10-02

58

Ici sont un couple de lignes directrices:
- Opérateurs booléens sont généralement utilisés sur boolean valeurs, mais les opérateurs sur les bits sont généralement utilisés sur entier valeurs.
- Les opérateurs booléens sont de court-circuit mais les opérateurs sur les bits sont pas de court-circuit.
Le court-circuit comportement est utile dans des expressions comme ceci:
```
if x is not None and x.foo == 42:
    # ...
```
Ce ne serait pas fonctionner correctement avec le bit à bit & opérateur parce que les deux parties devaient toujours être évaluée, en donnant AttributeError: 'NoneType' object has no attribute 'foo'. Lorsque vous utilisez la fonction booléenne andopérateur de la seconde expression n'est pas évaluée lors de la première est Fausse. De même or n'évalue pas le deuxième argument si le premier est Vrai.
- Supplémentaire: En Python &, |, ^ sont définies les opérations de trop.
- Complémentaire: en Python, bit-wise ne permettra pas à de divers types, mais boolean volonté. par exemple, True or "True" est très bien (il sera de retour la première truthy valeur), mais True | "True" lèvera une exception.
- Qui n'a rien à voir avec les types mixtes. Les opérations bit à bit n'a de sens avec des entiers et tout autre type lèvera une exception. Le point ici est que Python traite de Faux et le Vrai comme 0 et 1 respectivement: 0 == False et 1 == True sont à la fois vrai.
- Assez vrai, c'est une explication plus précise. Merci!
- Merci!!!! C'était d'enseignement
InformationsquelleAutor Mark Byers
19

En théorie, and et or viennent tout droit de la logique booléenne (et donc fonctionner sur deux booléens pour produire un booléen), tandis que & et | appliquer les booléens et/ou pour les bits individuels d'entiers. Il y a beaucoup beaucoup de questions sur comment ces derniers fonctionnent exactement.

Ici sont les différences concrètes qui pourraient affecter vos résultats:
1. and et or de court-circuit, c'est à dire True or sys.exit(1) ne sera pas sortie, parce que, pour une certaine valeur (True or ..., False and ...) de l'opérande premier, le second n'aurait pas changé le résultat = n'a pas besoin d'être évalué. Mais | et & ne pas court-circuit - True | sys.exit(1) vous jette outta le REPL.
2. (S'applique uniquement à certains? langues avec la surcharge d'opérateur, y compris Python:) & et | sont régulièrement opérateurs et peuvent être surchargés - and et or sont forgées dans la langue (bien qu'au moins en Python, la méthode spéciale pour que la contrainte booléenne peut avoir des effets secondaires).
3. (ne s'applique qu'à un petit nombre de langues [voir KennyTM commentaire]:) and et or retour (toujours? jamais vraiment comprendre cela, et je n'ai besoin d'elle) la valeur d'un opérande au lieu de True ou False. Cela ne change pas le sens des expressions booléennes dans des conditions - 1 or True est 1, mais 1 est vrai, trop. Mais il était autrefois utilisé pour émuler un opérateur conditionnel (cond ? true_val : false_val dans la syntaxe du C, true_val if cond else false_val en Python depuis quelques années). Pour & et |, le type du résultat dépend de la façon dont les opérandes surcharge les méthodes (True & False est False, 99 & 7 est 3, pour les jeux c'est les syndicats/intersection...).
Mais même quand par exemple a_boolean & another_boolean serait fonctionnent de la même manière, la bonne solution est d'utiliser and - tout simplement parce que and et or sont associés avec une expression booléenne et de l'état tout en & et | stand pour peu tourner.
- Point #3 s'applique à Ruby, Perl et Javascript. Ce n'est pas que Python spécifiques.
InformationsquelleAutor
16

Voici une autre différence, qui m'avait laissé perplexe pendant un moment tout à l'heure: parce que & (et d'autres opérateurs au niveau du bit) ont une priorité plus élevée que and (et d'autres opérateurs booléens), les expressions suivantes évaluer à différentes valeurs:
```
0 < 1 & 0 < 2
```
contre
```
0 < 1 and 0 < 2
```
À l'esprit, le premier rendements False que c'est équivalent à 0 < (1 & 0) < 2, donc 0 < 0 < 2, donc 0 < 0 and 0 < 2.

InformationsquelleAutor Arend

Si vous essayez de faire de l'élément de sage opérations booléennes dans numpy, la réponse est quelque peu différente. Vous pouvez utiliser & et | pour l'élément-sage opérations booléennes, mais and et or aura valeur de retour d'erreur.

Pour être sur le côté sécuritaire, vous pouvez utiliser le numpy fonctions logiques.

np.array([True, False, True]) | np.array([True, False, False])
# array([ True, False,  True], dtype=bool)

np.array([True, False, True]) or np.array([True, False, False])
# ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

np.logical_or(np.array([True, False, True]), np.array([True, False, False]))
# array([ True, False,  True], dtype=bool)

InformationsquelleAutor C8H10N4O2

2

Opération booléenne sont des opérations logiques.

Des opérations bit à bit sont des opérations sur les bits binaires.

Des opérations bit à bit:
```
>>> k = 1
>>> z = 3
>>> k & z  
1
>>> k | z  
3
```
Opérations:
```
And & 1 if both bits are 1, 0 otherwise
Or  | 1 if either bit is 1
Xor ^ 1 if the bits are different, 0 if they're the same
Not ~ Flip each bit
```
De certaines utilisations des opérations bit à bit:

1) définition et la Compensation de Bits

Des opérations booléennes:
```
>>> k = True
>>> z = False
>>> k & z  # and
False
>>> k | z  # or
True
>>> 
```
- Pour vous les opérations booléennes, ne pas vous le dire "et" et "ou" au lieu de "&" et "|"?
- Oui .. Oui .. Merci , je ne veux dire que.
InformationsquelleAutor pyfunc
2

L'astuce est dans le nom:
- Les opérateurs booléens sont pour l'exécution de des opérations logiques (la vérité de test commun dans la programmation et la logique formelle)
- Opérateurs au niveau du bit sont pour "bit-tourner" (faible niveau de manipulation de bits dans les octets et les types de données numériques)
Alors qu'il est possible et parfois même souhaitable (généralement pour des raisons d'efficacité) pour effectuer des opérations logiques avec les opérateurs sur les bits, vous devriez éviter pour de telles fins de prévenir les bogues subtils et des effets secondaires indésirables.

Si vous avez besoin de manipuler des bits, le bit à bit les opérateurs sont construits à cet effet. Le livre amusant: Les Pirates Plaisir contient certains frais et réellement utiles, des exemples de ce qui peut être réalisé avec des bits de tourner.

InformationsquelleAutor Tendayi Mawushe
1

La règle générale est d'utiliser l'opérateur approprié pour les opérandes. Utiliser des booléens (logique) opérateurs booléens opérandes et d'opérateurs au niveau du bit avec (le plus large) font partie intégrante des opérandes (note: Faux est équivalent à 0, et Vrai à 1). La seule "difficulté" scénario de l'application des opérateurs booléens pour non opérandes booléens.
Nous allons prendre un exemple simple, comme décrit dans [AINSI,]: Python - les Différences entre " et " et "& " [dupliquer]: 5 & 7 vs 5 and 7.

Pour la au niveau du bit et (&), les choses sont assez simples:
```
5     = 0b101
7     = 0b111
-----------------
5 & 7 = 0b101 = 5
```
Pour la logique et, voici ce que [Python 3]: opérations Booléennes unis (accent est le mien):

(À noter que ni et ni ou restreindre la valeur et le type de leur retour à Faux et Vrai, mais plutôt de retour de la dernière évaluation argument.

Exemple:
```
>>> 5 and 7
7
>>> 7 and 5
5
```
Bien sûr, la même chose s'applique pour | vs ou.

InformationsquelleAutor CristiFati

Booléen " et "vs bit-à-Bit" &":

Pseudo-code/Python m'a aidé à comprendre la différence entre ces:

def boolAnd(A, B):
    # boolean 'and' returns either A or B
    if A == False:
        return A
    else:
        return B

def bitwiseAnd(A , B):
    # binary representation (e.g. 9 is '1001', 1 is '0001', etc.)

    binA = binary(A)
    binB = binary(B)



    # perform boolean 'and' on each pair of binaries in (A, B)
    # then return the result:
    # equivalent to: return ''.join([x*y for (x,y) in zip(binA, binB)])

    # assuming binA and binB are the same length
    result = []
    for i in range(len(binA)):
      compar = boolAnd(binA[i], binB[i]) 
      result.append(compar)

    # we want to return a string of 1s and 0s, not a list

    return ''.join(result)

InformationsquelleAutor Geoff Langenderfer

Vous devez vous connecter pour publier un commentaire.