Битовые операторы

Введение

Примеры

  • 6

    Побитовое И

    & Оператор выполнит двоичный И, где бит копируется , если она существует в обоих операндов. Это означает:

     # 0 & 0 = 0
    # 0 & 1 = 0
    # 1 & 0 = 0
    # 1 & 1 = 1
    
    # 60 = 0b111100
    # 30 = 0b011110
    60 & 30
    # Out: 28
    # 28 = 0b11100
    
    bin(60 & 30)
    # Out: 0b11100 
  • 3

    Побитовое ИЛИ

    | Оператор выполнит двоичное «или», где бит копируется, если он существует в любом из операндов. Это означает:

     # 0 | 0 = 0
    # 0 | 1 = 1 
    # 1 | 0 = 1
    # 1 | 1 = 1
    
    # 60 = 0b111100 
    # 30 = 0b011110
    60 | 30
    # Out: 62
    # 62 = 0b111110
    
    bin(60 | 30)
    # Out: 0b111110 
  • 7

    Побитовое XOR (исключающее ИЛИ)

    ^ Оператор будет выполнять двоичный XOR , в котором двоичный 1 копируется тогда и только тогда , когда это значение ровно один операнд. Другой способ задания этого является то , что результат 1 только если операнды разные. Примеры включают в себя:

     # 0 ^ 0 = 0
    # 0 ^ 1 = 1
    # 1 ^ 0 = 1
    # 1 ^ 1 = 0
    
    # 60 = 0b111100
    # 30 = 0b011110
    60 ^ 30
    # Out: 34
    # 34 = 0b100010
    
    bin(60 ^ 30)
    # Out: 0b100010 
  • 3

    Побитовый сдвиг влево

    << оператор выполняет побитовое «сдвиг влево» , где значение левого операнда перемещается влево на число битов данных в правом операнде.

     # 2 = 0b10
    2 << 2
    # Out: 8
    # 8 = 0b1000
    
    bin(2 << 2)
    # Out: 0b1000
    
     

    Выполнение левого разрядное смещение 1 эквивалентно умножению на 2 :

     7 << 1
    # Out: 14
    
     

    Выполнение левого разрядного смещения n эквивалентно умножения на 2**n :

     3 << 4
    # Out: 48 
  • 3

    Побитовый сдвиг вправо

    >> оператор выполняет побитовое «сдвиг вправо» , где значение левого операнда перемещается вправо на число битов данных в правом операнде.

     # 8 = 0b1000
    8 >> 2
    # Out: 2
    # 2 = 0b10
    
    bin(8 >> 2)
    # Out: 0b10
    
     

    Выполнение правильного битового смещения 1 эквивалентно целочисленного деления на 2 :

     36 >> 1
    # Out: 18
    
    15 >> 1
    # Out: 7
    
     

    Выполнение правильного битового смещения n эквивалентно целочисленное деление на 2**n :

     48 >> 4
    # Out: 3
    
    59 >> 3
    # Out: 7 
  • 11

    Побитовое НЕ

    ~ Оператор переворачивает все биты числа. Поскольку компьютеры используют прямой код - прежде всего, в дополнении до двух обозначений для кодирования отрицательных двоичных чисел , где отрицательные числа записываются с ведущим один (1) вместо ведущего нуля (0).

    Это означает , что если вы используете 8 бит для представления номера вашего дополнительного кода комплемента, вы бы относиться к модели от 0000 0000 до 0111 1111 для представления чисел от 0 до 127 и резервного 1xxx xxxx для представления отрицательных чисел.

    Восьмиразрядные числа с двумя дополнительными числами

    Биты Значение без знака Значение двух дополнений
    0000 0000 0 0
    0000 0001 1 1
    0000 0010 2 2
    0111 1110 126 126
    0111 1111 127 127
    1000 0000 128 -128
    1000 0001 129 -127
    1000 0010 130 -126
    1111 1110 254 -2
    1111 1111 255 -1

    По существу, это означает , что в то время как 1010 0110 имеет беззнаковое значение 166 (прибыл в путем добавления (128 * 1) + (64 * 0) + (32 * 1) + (16 * 0) + (8 * 0) + (4 * 1) + (2 * 1) + (1 * 0) ), оно имеет значение дополнительного код дополнение -90 (прибыли в добавлении (128 * 1) - (64 * 0) - (32 * 1) - (16 * 0) - (8 * 0) - (4 * 1) - (2 * 1) - (1 * 0) , и дополняя значение).

    Таким образом, отрицательные числа в диапазоне до -128 ( 1000 0000 ). Ноль (0) представляется в виде 0000 0000 , и минус один (-1) , как 1111 1111 .

    В целом, однако, это означает , ~n = -n - 1 .

     # 0 = 0b0000 0000
    ~0
    # Out: -1
    # -1 = 0b1111 1111
    
    # 1 = 0b0000 0001
    ~1
    # Out: -2
    # -2 = 1111 1110
    
    # 2 = 0b0000 0010
    ~2
    # Out: -3
    # -3 = 0b1111 1101
    
    # 123 = 0b0111 1011
    ~123
    # Out: -124
    # -124 = 0b1000 0100
    
     

    Обратите внимание, что общий эффект этой операции при нанесении на положительные числа можно суммировать:

    ~n -> -|n+1|

    И затем, применительно к отрицательным числам, соответствующий эффект:

    ~-n -> |n-1|

    Следующие примеры иллюстрируют это последнее правило ...

     # -0 = 0b0000 0000
    ~-0
    # Out: -1 
    # -1 = 0b1111 1111
    # 0 is the obvious exception to this rule, as -0 == 0 always
    
    # -1 = 0b1000 0001
    ~-1
    # Out: 0
    # 0 = 0b0000 0000
    
    # -2 = 0b1111 1110
    ~-2
    # Out: 1
    # 1 = 0b0000 0001
    
    # -123 = 0b1111 1011
    ~-123
    # Out: 122
    # 122 = 0b0111 1010
    
    
     
  • 2

    Операции на месте

    Все операторы Побитового (кроме ~ ) имеет свои собственные места версии

    a = 0b001
    a &= 0b010 
    # a = 0b000
    
    a = 0b001
    a |= 0b010 
    # a = 0b011
    
    a = 0b001
    a <<= 2 
    # a = 0b100
    
    a = 0b100
    a >>= 2 
    # a = 0b001
    
    a = 0b101
    a ^= 0b011 
    # a = 0b110

Синтаксис

Параметры

Примечания