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

Question

Je suis confus quant au moment où je devrais utiliser booléenne vs opérateurs binaires

• and vs &
• or vs |

Quelqu'un pourrait-il me éclairer quand puis-je utiliser chacun et quand sera en utilisant l'un sur l'autre sur mes résultats?

Answer 1

Voici quelques directives:

• Les opérateurs booléens sont généralement utilisés sur boolean valeurs, mais les opérateurs sont généralement utilisés au niveau du bit sur entier valeurs.
• Les opérateurs booléens sont court-circuit mais les opérateurs sont au niveau du bit pas court-circuit.

Le comportement de court-circuit est utile dans des expressions comme ceci:

if x is not None and x.foo == 42:
    # ...

Cela ne fonctionne pas correctement avec l'opérateur & bitwise parce que les deux parties seraient toujours évaluées, donnant AttributeError: 'NoneType' object has no attribute 'foo'. Lorsque vous utilisez le andoperator booléen la deuxième expression est pas évalué lorsque le premier est faux. De même or n'évalue le second argument si le premier est vrai.

Answer 2

En théorie, and et or viennent directement de la logique booléenne (et donc fonctionner sur deux booléens pour produire un booléen), tandis que & et | appliquent le booléen et / ou pour les bits individuels des nombres entiers. Il y a beaucoup de beaucoup de questions ici sur la façon dont ces derniers fonctionnent exactement.

Voici les différences pratiques qui peuvent affecter vos résultats:

1. court-circuit de and et or, à savoir True or sys.exit(1) ne quittera pas, parce que pour une certaine valeur (True or ..., False and ...) du premier opérande, le second ne changerait pas le résultat = n'a pas besoin d'être évalué. Mais | et & ne pas court-circuit - True | sys.exit(1) vous jette outta REPL
.
2. (uniquement pour certaines langues avec la surcharge des opérateurs, y compris Python :) & et | sont des opérateurs et peuvent être surchargées - and et or se forgent dans la langue (bien au moins en Python, la méthode spéciale pour la contrainte à booléen peut avoir des effets secondaires).
3. (uniquement pour quelques langues [voir le commentaire de KennyTM] :) and et retour or (toujours? Ne comprennent vraiment, et je ne ai besoin) 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 aussi. Mais il était autrefois utilisé pour émuler un opérateur conditionnel (cond ? true_val : false_val de la syntaxe C, true_val if cond else false_val en Python depuis quelques années). Pour & et |, le type de résultat dépend de la façon dont les opérandes surcharge des méthodes spéciales respectives (True & False est False, 99 & 7 est 3, pour les jeux il de syndicats / intersection ...).

Mais même quand par exemple a_boolean & another_boolean fonctionnerait de manière identique, la solution utilise and -. simplement parce que and et or sont associés à l'expression booléenne et de l'état en position de & et | pour le bit bidouilles

Answer 3

Voici une autre différence, qui me avait déconcerté pendant un certain temps 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 évaluent à différentes valeurs:

0 < 1 & 0 < 2

contre

0 < 1 and 0 < 2

A savoir, les premiers rendements False comme il est équivalent à 0 < (1 & 0) < 2, donc 0 < 0 < 2, donc 0 < 0 and 0 < 2.

Answer 4

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

Pour être du bon côté, vous pouvez utiliser les fonctions logiques numpy .

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)

Answer 5

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

opérations sont des opérations au niveau du bit sur les bits binaires.

Opérations au niveau du bit:

>>> k = 1
>>> z = 3
>>> k & z  
1
>>> k | z  
3

Les 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

Certaines des utilisations des opérations binaires:

1) Réglage et Bits de compensation

opérations booléennes:

>>> k = True
>>> z = False
>>> k & z  # and
False
>>> k | z  # or
True
>>> 

Answer 6

L'indice est dans le nom:

• Les opérateurs booléens permettent d'effectuer des opérations logiques (vérité test commun dans la programmation et la logique formelle)
• Opérateurs binaires sont pour "bit-bidouilles" (manipulation de niveau bas de bits dans un octet et les types de données numériques)

Bien qu'il soit possible et même parfois souhaitable (généralement pour des raisons d'efficacité) pour effectuer des opérations logiques avec les opérateurs au niveau du bit, vous devez les éviter généralement à ces fins pour éviter les bugs subtils et les effets secondaires indésirables.

Si vous avez besoin de manipuler des bits, alors les opérateurs sont construit à cet effet au niveau du bit. Le livre amusant: Hackers Delight contient des frais et des exemples véritablement utiles de ce qui peut être réalisé avec le bit-bidouilles.

Answer 7

La règle générale est d'utiliser l'opérateur approprié pour les opérandes existants. Utiliser les opérateurs booléens (logiques) avec opérandes booléens et les opérateurs au niveau du bit avec (plus larges) opérandes intégraux (Note: false est équivalent à 0 et True 1 ). Le seul scénario « difficile » applique des opérateurs booléens pour opérandes non booléennes.
Prenons un exemple simple, comme décrit dans [SO]: Python - Les différences entre « et 'et '&'[double] :.. 5 & 7 vs 5 and 7

Pour la bitwise et ( ), les choses sont assez simples:

5     = 0b101
7     = 0b111
-----------------
5 & 7 = 0b101 = 5

Pour la logique et , voici ce que [python 3]: les états de des opérations booléennes ( accent est le mien):

  

(Notez que ni et ni ou limiter la valeur et le type qu'ils reviennent à false et < em> True , mais retourner le dernier argument évalué .

Exemple :

>>> 5 and 7
7
>>> 7 and 5
5

Bien sûr, même pour |.. vs ou

Answer 8

Boolean 'et' par rapport à Bitwise '&':

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

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)

Answer 9

Opérations logiques

sont généralement utilisés pour des instructions conditionnelles. Par exemple:

if a==2 and b >10 then /*Do something...*/ endif Cela signifie que si les deux conditions (a == (2) (b> 10)) sont vraies en même temps, alors le corps de l'instruction conditionnelle peut être exécutée.

Opérations Bitwise

opérations sur les bits peut être utilisé pour la manipulation et l'extraction des données. Par exemple, si vous voulez extraire quatre LSB (bits les moins significatifs) d'un nombre entier, vous pouvez faire ceci:

Extraction:

poo & 0x000F

Masking:

poo | 0xFFF0