operadores booleanos vs operadores bit a bit

StackOverflow https://stackoverflow.com/questions/3845018

Pregunta

Estoy confundido en cuanto a cuándo debo utilizar booleana vs operadores de bits

  • and vs &
  • or vs |

Podría alguien me ilumine en cuanto a cuando no lo uso todos y cuando se va a usar uno sobre el otro afectar los resultados?

¿Fue útil?

Solución

Aquí hay un par de directivas:

  • operadores booleanos se utilizan por lo general en boolean valores, sino operadores de bits se utilizan por lo general en entero valores.
  • operadores booleanos son cortocircuito pero los operadores bit a bit son no cortocircuitos.

El comportamiento de cortocircuito es útil en expresiones como esta: 

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

Esto no funcionaría correctamente con el operador de bits & porque siempre serían evaluados ambos lados, dando AttributeError: 'NoneType' object has no attribute 'foo'. Cuando se utiliza la andoperator booleano la segunda expresión no se evalúa cuando la primera es falsa. Del mismo modo or no evalúa el segundo argumento si la primera es verdadera.

Otros consejos

En teoría, and y or vienen directamente de lógica booleana (y por lo tanto operar en dos booleanos para producir un booleano), mientras que & y | aplican el booleano y / o a los bits individuales de números enteros. Hay muchas muchas preguntas aquí en la forma en que el último trabajo exactamente.

Aquí hay diferencias prácticas que potencialmente afectan a sus resultados:

    no de salida, porque para un valor determinado (and, or) del primer operando, el segundo no cambiaría el resultado = no necesita ser evaluado
  1. True or sys.exit(1) y True or ... cortocircuitos, es decir False and .... Pero | y & No cortocircuito - True | sys.exit(1) te lanza Sal de la REPL
    2. .
  2. (Sólo se aplica a algunos idiomas con la sobrecarga de operadores, incluyendo Python :) & y | son regulares y los operadores pueden ser sobrecargados - and y or se forjan en la lengua (aunque al menos en Python, el método especial para la coacción para booleano puede tener efectos secundarios).
  3. (sólo se aplica a unos pocos idiomas [véase el comentario de KennyTM] :) and y el retorno or (siempre? En realidad nunca entienden esto, ni tampoco lo necesito) el valor de un operando en lugar de True o False. Esto no cambia el significado de expresiones booleanas en condiciones - 1 or True es 1, pero 1 es cierto, también. Pero una vez fue utilizado para emular un operador condicional (cond ? true_val : false_val en la sintaxis de C, true_val if cond else false_val en Python desde hace algunos años). Para & y |, el tipo del resultado depende de cómo los operandos sobrecarga de los métodos especiales respectivas (True & False es False, 99 & 7 es 3, para los conjuntos que de uniones / intersección ...).

Pero incluso cuando, por ejemplo, a_boolean & another_boolean funcionaría de forma idéntica, la solución correcta está utilizando and -. simplemente porque and y or están asociados con expresión booleana y condiciones mientras & y | soporte para haciendo girar bit

Aquí hay una diferencia adicional, que me tenía intrigado por un tiempo ahora: porque & (y otros operadores de bits) tienen una prioridad más alta que and (y otros operadores booleanos) las siguientes expresiones dan como resultado diferentes valores: 

0 < 1 & 0 < 2

frente 

0 < 1 and 0 < 2

A saber, los primeros rendimientos False ya que es equivalente a 0 < (1 & 0) < 2, por lo tanto 0 < 0 < 2, por lo tanto 0 < 0 and 0 < 2.

Si usted está tratando de hacer operaciones booleanas elemento a elemento en numpy, la respuesta es un tanto diferente. Puede utilizar & y | para las operaciones booleanas elemento a elemento, pero and y or volverá error de valor.

Para estar en el lado seguro, puede utilizar las funciones lógicas href="http://docs.scipy.org/doc/numpy/reference/routines.logic.html" rel="nofollow"> 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)

operación booleana son operaciones lógicas.

operaciones bit a bit son operaciones en bits binarios.

operaciones bit a bit: 

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

Las operaciones de: 

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

Algunos de los usos de las operaciones bit a bit:

1) poner y quitar Bits

Las operaciones booleanas: 

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

La regla general es utilizar el operador apropiado para los operandos existentes. Uso booleano (lógico) operadores con operandos booleanos y operadores bit a bit con operandos integrales (más anchos) (nota: false es equivalente a 0 y True a 1 ). El único escenario "complicado" es la aplicación de operadores booleanos para operandos booleanos no.
Tomemos un ejemplo sencillo, como se describe en [SO]: Pitón - Diferencias entre 'y 'y 'y'[duplicado] :.. 5 & 7 vs 5 and 7

Para la bit a bit y ( & ), las cosas son bastante sencillos: 

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

Para la lógica y , esto es lo [Python 3]: estados operaciones booleanas ( énfasis es mío):

  

(Nota que ni y ni o restringir el valor y el tipo regresan a false y < em> True , sino más bien devolver el último argumento evaluado .

Ejemplo : 

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

Por supuesto, lo mismo se aplica para los |.. vs o

booleano 'y' vs bit a bit '&':

Pseudocódigo / Python me ayudó a entender la diferencia entre estos: 

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)

operaciones lógicas

se utilizan por lo general para las sentencias condicionales. Por ejemplo:

if a==2 and b >10 then /*Do something...*/ endif Esto significa que si ambas condiciones ((a) (b> 10) == 2) son verdaderas al mismo tiempo, entonces cuerpo sentencia condicional puede ser ejecutado.

bit a bit Operaciones

operaciones bit a bit puede ser utilizado para la manipulación y extracción de datos. Por ejemplo, si desea extraer cuatro LSB (menos significativo) Los bits de un número entero, se puede hacer esto:

Extracción:

poo & 0x000F

Enmascaramiento:

poo | 0xFFF0

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top