目录

计算机将各种信息存储为称为位的二进制数字流。无论您是处理文本、图像还是视频，它们都归结为 1 和 0。Python 的按位运算符让您可以在最细粒度的级别上操作这些单独的数据位。

您可以使用按位运算符来实现压缩、加密和错误检测等算法，以及控制Raspberry Pi 项目或其他地方的物理设备。通常，Python 将您与具有高级抽象的底层位隔离开来。在实践中，您更有可能发现按位运算符的重载风格。但是，当您以它们的原始形式与它们合作时，您会惊讶于它们的怪癖！

在本教程中，您将学习如何：

• 使用 Python按位运算符操作单个位
• 以与平台无关的方式读取和写入二进制数据
• 使用位掩码将信息打包到单个字节上
• 在自定义数据类型中重载Python 按位运算符
• 在数字图像中隐藏秘密信息

Python 的按位运算符概述

Python 附带了几种不同类型的运算符，例如算术、逻辑和比较运算符。您可以将它们视为利用更紧凑的前缀和中缀语法的函数。

按位运算符在不同的编程语言中看起来几乎相同：

如您所见，它们用看起来很奇怪的符号而不是单词来表示。这使它们在 Python 中脱颖而出，比您可能习惯看到的要少一些冗长。您可能无法仅通过查看它们来弄清楚它们的含义。

大多数按位运算符是binary，这意味着它们期望使用两个操作数，通常称为左操作数和右操作数。按位非 ( ~) 是唯一的一元按位运算符，因为它只需要一个操作数。

所有二元按位运算符都有一个相应的复合运算符来执行扩充赋值：

这些是用于更新左操作数的速记符号。

这就是 Python 的按位运算符语法的全部内容！现在，您已准备好仔细查看每个运算符，以了解它们最有用的地方以及如何使用它们。首先，在查看两类按位运算符之前，您将快速复习一下二进制系统：按位逻辑运算符和按位移位运算符。

五分钟了解二进制系统

在继续之前，花点时间复习一下二进制系统的知识，这对于理解按位运算符至关重要。如果您已经对它感到满意，请继续并跳转到下面的位逻辑运算符部分。

二进制系统比十进制系统需要更多的存储空间，但在硬件中实现起来要简单得多。虽然您需要更多的积木，但它们更容易制作，而且种类较少。这就像将您的代码分解为更模块化和可重用的部分。

然而，更重要的是，二进制系统非常适合将数字转换为不同电压电平的电子设备。由于电压喜欢因各种噪声而上下漂移，因此您需要在连续电压之间保持足够的距离。否则，信号可能会失真。

通过仅采用两种状态，您可以使系统更加可靠和抗噪。或者，您可以升高电压，但这也会增加功耗，这是您绝对想要避免的。

二进制如何工作？

想象一下，您只有两个手指可以依靠。你可以数一个零、一个一和一个二。但是当你用完手指时，你需要记下你已经数到 2 的次数，然后重新开始，直到再次数到 2：

每次你写下另一对手指时，你还需要按 2 的幂对它们进行分组，这是系统的基础。例如，要数到 13，您必须同时用两个手指六次，然后再用一根手指。你的手指可以排列成一八、一四、一一。

这些 2 的幂对应于二进制数中的数字位置，并准确地告诉您要打开哪些位。它们从右到左增长，从最低有效位开始，这决定了数字是偶数还是奇数。

位置符号就像汽车中的里程表：一旦某个特定位置的数字达到其最大值（二进制系统中的 1），它就会滚动到零，然后向左移动。如果数字左侧已经有一些，这可能会产生级联效果。

计算机如何使用二进制

现在你知道了双星系统的基本原理和为什么计算机使用它，你就可以学会如何，他们代表了它的数据。

在以数字形式复制任何信息之前，您必须将其分解为数字，然后将它们转换为二进制系统。例如，纯文本可以被认为是一串字符。您可以为每个字符分配一个任意数字或选择现有的字符编码，例如ASCII、ISO-8859-1或UTF-8。

在 Python 中，字符串表示为Unicode代码点数组。要显示它们的顺序值，请调用ord()每个字符：

>>> [ord(character) for character in "€uro"]
[8364, 117, 114, 111]

生成的数字唯一标识 Unicode 空间中的文本字符，但它们以十进制形式显示。你想用二进制数字重写它们：

请注意，位长度（二进制数字的数量）在字符之间变化很大。欧元符号 ( €) 需要 14 位，而其余字符可以轻松容纳 7 位。

>>> (42).bit_length()
6

可变位长是有问题的。例如，如果您将这些二进制数并排放置在光盘上，那么您最终会得到一长串没有字符之间明确界限的位流：

10000010101100111010111100101101111₂

了解如何解释此信息的一种方法是为所有字符指定固定长度的位模式。在现代计算中，最小的信息单位称为八位字节或字节，由八位组成，可以存储 256 个不同的值。

您可以用前导零填充二进制代码点以用字节表示它们：

现在每个字符需要两个字节，或 16 位。总的来说，您的原始文本大小几乎翻了一番，但至少它的编码可靠。

您可以使用霍夫曼编码为特定文本中的每个字符找到明确的位模式，或者使用更合适的字符编码。例如，为了节省空间，UTF-8 特意使用拉丁字母而不是您不太可能在英文文本中找到的符号：

>>> len("€uro".encode("utf-8"))
6

根据 UTF-8 标准编码，整个文本占用六个字节。由于 UTF-8 是 ASCII 的超集，因此字母u、r和o各占一个字节，而欧元符号在此编码中占用三个字节：

>>> for char in "€uro":
...     print(char, len(char.encode("utf-8")))
...
€ 3
u 1
r 1
o 1

其他类型的信息可以与文本类似地数字化。光栅图像由像素组成，每个像素都有将颜色强度表示为数字的通道。声音波形包含与给定采样间隔的气压相对应的数字。三维模型是根据由其顶点定义的几何形状构建的，等等。

归根结底，一切都是数字。

按位逻辑运算符

您可以使用按位运算符对单个位执行布尔逻辑。这是类似于使用逻辑运算符，如and，or和not，但有点水平。按位运算符和逻辑运算符之间的相似之处不止于此。

可以使用按位运算符而不是逻辑运算符来计算布尔表达式，但通常不鼓励这种过度使用。如果您对详细信息感兴趣，则可以展开下面的框以了解更多信息。

除非您有充分的理由并且知道自己在做什么，否则您应该仅将按位运算符用于控制位。否则很容易出错。在大多数情况下，您需要将整数作为参数传递给按位运算符。

结果位模式是运算符参数的交集。它在两个操作数都是 1 的位置打开了两个位。在所有其他地方，至少有一个输入具有零位。

在算术上，这相当于两个位值的乘积。您可以通过在每个索引i处乘以它们的位来计算数字a和b的按位与：

这是一个具体的例子：

结果位模式是运算符参数的联合。它打开了五个位，其中任何一个操作数都有一个 1。只有两个零的组合在最终输出中才会给出零。

它背后的算术是位值的总和和乘积的组合。要计算数字a和b的按位或，您需要将以下公式应用于它们在每个索引i处的位：

这是一个切实的例子：

它几乎就像两位的总和，但被限制在较高端，因此它永远不会超过 1 的值。您还可以取每对中两位的最大值来获得相同的结果。

按位异或

与按位AND、OR和NOT 不同，按位异或运算符 ( ^) 在 Python 中没有逻辑对应物。但是，您可以通过在现有运算符之上构建来模拟它：

def xor(a, b):
    return (a and not b) or (not a and b)

它评估两个相互排斥的条件，并告诉您是否正好满足其中之一。例如，一个人可以是未成年人也可以是成年人，但不能同时是两者。相反，一个人不可能既不是未成年人也不是成年人。选择是强制性的。

名称 XOR 代表“异或”，因为它对位对执行异或。换句话说，每个位对必须包含相反的位值才能产生一个：

从视觉上看，这是运算符参数的对称差异。结果中打开了三个位，其中两个数字具有不同的位值。其余位置的位相互抵消，因为它们是相同的。

与按位 OR 运算符类似，XOR 的算术涉及求和。然而，虽然按位 OR 将值钳位为 1，但 XOR 运算符使用求和模 2将它们包裹起来：

模数是两个数字的函数——被除数和除数——执行除法并返回其余数。在 Python 中，有一个用百分号 ( )表示的内置模运算符%。

再一次，您可以通过查看示例来确认公式：

反转位是 1 的补码，它将零变成 1，将 1 变成零。它可以在算术上表示为从 1 中减去单个位值：

这是一个示例，显示了之前使用的数字之一：

虽然按位 NOT 运算符似乎是所有运算符中最直接的，但在 Python 中使用它时需要格外小心。到目前为止，您阅读的所有内容都基于数字用无符号整数表示的假设。

尽管有多种方法可以模拟无符号整数，但 Python 本身并不支持它们。这意味着无论您是否指定一个数字，所有数字都会附加一个隐式符号。这显示当您对任何数字进行按位 NOT 操作时：

>>> ~156
-157

您得到的不是预期的 99 ₁₀，而是负值！一旦您了解了各种二进制数表示法，原因就会变得很清楚。目前，快速修复解决方案是利用按位 AND 运算符：

>>> ~156 & 255
99

这是位掩码的一个完美示例，您将在接下来的部分中对其进行探讨。

按位移位运算符

按位移位运算符是另一种位操作工具。它们让您可以移动位，这对于稍后创建位掩码非常方便。过去，它们经常被用来提高某些数学运算的速度。

将单个位向左移动一个位置会使其值加倍。例如，该位将指示移位后的 4，而不是 2。将它向左移动两个位置将使结果值翻四倍。当您将给定数字中的所有位相加时，您会注意到它也会随着每个位置的移动而加倍：

通常，向左移动位对应于将数字乘以2的幂，指数等于移动的位数：

左移曾经是一种流行的优化技术，因为位移是一条指令，并且比指数或乘积的计算成本更低。然而，今天，编译器和解释器，包括 Python 的，非常有能力在幕后优化你的代码。

在纸面上，左移产生的位模式会随着您移位的位置而变长。由于 Python 处理整数的方式，一般来说这对 Python 也是如此。但是，在大多数实际情况下，您需要将位模式的长度限制为 8 的倍数，这是标准字节长度。

例如，如果您正在处理单个字节，则将其向左移动应该丢弃超出其左边界的所有位：

这有点像通过固定长度的窗口查看无限的比特流。有一些技巧可以让你在 Python 中做到这一点。例如，您可以使用按位 AND 运算符应用位掩码：

>>> 39 << 3
312
>>> (39 << 3) & 255
56

将 39 ₁₀向左移动三位会返回一个高于您可以存储在单个字节上的最大值的数字。它需要九位，而一个字节只有八位。要砍掉左边的一个额外位，您可以应用具有适当值的位掩码。如果您想保留更多或更少的位，则需要相应地修改掩码值。

右移

按位右移运算符 ( >>) 类似于左移运算符，但不是将位向左移动，而是将它们向右推指定的位数。最右边的位总是被丢弃：

每次向右移动一个位置，它的潜在价值就会减半。将相同的位向右移动两位会产生原始值的四分之一，依此类推。当您将所有单个位相加时，您会看到相同的规则适用于它们所代表的数字：

将诸如 157 _{10 之}类的奇数减半会产生一个分数。为了摆脱它，自动向右移位运算符楼层的结果。它实际上与按 2 的幂进行的楼层划分相同：

同样，指数对应于向右移动的位数。在 Python 中，您可以利用专用运算符来执行楼层划分：

>>> 5 >> 1  # Bitwise right shift
2
>>> 5 // 2  # Floor division (integer division)
2
>>> 5 / 2   # Floating-point division
2.5

按位右移运算符和地板除法运算符的工作方式相同，即使对于负数也是如此。但是，地板除法让您可以选择任何除数，而不仅仅是 2 的幂。使用按位右移是提高某些算术除法性能的常用方法。

>>> 2 >> 5
0

>>> -2 >> 5
-1

就像左移运算符一样，位模式在右移后改变其大小。虽然向右移动位会使二进制序列更短，但这通常无关紧要，因为您可以在不更改值的情况下在位序列前面放置任意数量的零。例如， 101 ₂与 0101 ₂相同，00000101 ₂也是如此，前提是您处理的是非负数。

有时您会希望在右移后保留给定的位长以将其与另一个值对齐或适合某处。您可以通过应用位掩码来做到这一点：

它只雕刻出您感兴趣的那些位，并在必要时用前导零填充位模式。

Python 中负数的处理与传统的按位移位方法略有不同。在下一节中，您将更详细地研究这一点。

算术与逻辑移位

您可以将按位移位运算符进一步分类为算术和逻辑移位运算符。虽然 Python 只允许您进行算术移位，但了解其他编程语言如何实现按位移位运算符以避免混淆和意外是值得的。

这种区别来自他们处理符号位的方式，符号位通常位于有符号二进制序列的最左边缘。实际上，它仅与右移运算符相关，这会导致数字翻转其符号，从而导致整数溢出。

通常，打开的符号位表示负数，这有助于保持二进制序列的算术特性：

从左边看这两个二进制序列，您可以看到它们的第一位携带符号信息，而其余部分由幅度位组成，这两个数字相同。

逻辑右移，也称为无符号右移或零填充右移，移动整个二进制序列，包括符号位，并用零填充左边的结果间隙：

请注意有关数字符号的信息是如何丢失的。不管原始符号如何，它总是会产生一个非负整数，因为符号位被零替换。只要您对数值不感兴趣，逻辑右移在处理低级二进制数据时就很有用。

但是，由于在大多数语言中，有符号二进制数通常存储在固定长度的位序列上，因此它可以使结果环绕极值。您可以在交互式 Java Shell 工具中看到这一点：

jshell> -100 >>> 1
$1 ==> 2147483598

结果数字的符号从负变为正，但它也会溢出，最终非常接近 Java 的最大整数：

jshell> Integer.MAX_VALUE
$2 ==> 2147483647

这个数字乍一看似乎是任意的，但它与 Java 为Integer数据类型分配的位数直接相关：

jshell> Integer.toBinaryString(-100)
$3 ==> "11111111111111111111111110011100"

它采用32位来存储有符号整数的二进制补码表示。去掉符号位后，剩下 31 位，其最大十进制值等于 2 ³¹ - 1 或 2147483647 ₁₀。

另一方面，Python 存储整数就好像有无数位可供您使用一样。因此，在纯 Python 中无法很好地定义逻辑右移运算符，因此语言中缺少它。不过，您仍然可以模拟它。

这样做的一种方法是利用通过内置模块公开的C中可用的无符号数据类型ctypes：

>>> from ctypes import c_uint32 as unsigned_int32
>>> unsigned_int32(-100).value >> 1
2147483598

它们让您传入一个负数，但不给符号位附加任何特殊含义。它被视为其余的幅度位。

虽然 C 中只有几种预定义的无符号整数类型，它们的位长不同，但您可以在 Python 中创建一个自定义函数来处理任意位长：

>>> def logical_rshift(signed_integer, places, num_bits=32):
...     unsigned_integer = signed_integer % (1 << num_bits)
...     return unsigned_integer >> places
...
>>> logical_rshift(-100, 1)
2147483598

这会将有符号位序列转换为无符号位序列，然后执行常规算术右移。

但是，由于 Python 中的位序列长度不固定，因此它们实际上没有符号位。此外，它们不像在 C 或 Java 中那样使用传统的二进制补码表示。为了缓解这种情况，您可以利用模运算，这将保留正整数的原始位模式，同时适当地环绕负整数。

算术右移 ( >>)，有时称为有符号右移运算符，通过在向右移动位之前复制其符号位来保持数字的符号：

换句话说，它用符号位填充左边的空白。结合有符号二进制的二进制补码表示，这会产生算术上正确的值。无论数字是正数还是负数，算术右移都相当于地板除法。

正如您即将发现的那样，Python 并不总是以简单的二进制补码形式存储整数。相反，它遵循自定义自适应策略，其工作方式类似于具有无限位数的符号大小。它在数字的内部表示和二进制补码之间来回转换数字，以模仿算术移位的标准行为。

二进制数表示

在使用按位求反 ( ~) 和右移运算符 ( >>)时，您已经亲身体验到 Python 中缺少无符号数据类型。您已经看到有关在 Python 中存储整数的不寻常方法的提示，这使得处理负数变得棘手。要有效地使用按位运算符，您需要了解二进制数字的各种表示形式。

>>> from ctypes import c_uint8 as unsigned_byte
>>> unsigned_byte(-42).value
214

>>> f"{-5 & 0b1111:04b}"
'1011'
>>> f"{-5 & 0b11111111:08b}"
'11111011'

>>> 0.1 + 0.2
0.30000000000000004

>>> from decimal import Decimal, localcontext
>>> with localcontext() as context:
...     context.prec = 5  # Number of digits
...     print(Decimal("123.456") * 1)
...
123.46

>>> a = 256
>>> b = 256
>>> a is b
True
>>> print(id(a), id(b), sep="\n")
94050914330336
94050914330336

>>> a = 257
>>> b = 257
>>> a is b
False
>>> print(id(a), id(b), sep="\n")
140282370939376
140282370939120

>>> a = 257
>>> b = 257
>>> print(id(a), id(b), sep="\n")
140258768039856
140258768039728
>>> print(id(257), id(257), sep="\n")
140258768039760
140258768039760

>>> import sys
>>> sys.maxsize
9223372036854775807

>>> from math import factorial
>>> factorial(42)
1405006117752879898543142606244511569936384000000000

>>> factorial(42).bit_length()
170

>>> import sys
>>> sys.int_info
sys.int_info(bits_per_digit=30, sizeof_digit=4)

>>> print(f"{42:b}")  # Print 42 in binary
101010
>>> print(f"{42:032b}")  # Print 42 in binary on 32 zero-padded digits
00000000000000000000000000101010

>>> bin(42)
'0b101010'

>>> age = 0b101010
>>> print(age)
42

>>> hex(42)
'0x2a'
>>> oct(42)
'0o52'

>>> 052
  File "<stdin>", line 1
SyntaxError: leading zeros in decimal integer literals are not permitted;
use an 0o prefix for octal integers

>>> 42 == 0b101010 == 0x2a == 0o52
True

>>> 0b101 == 0B101
True

>>> 0b101010
42

>>> int("101010", 2)
42
>>> int("cafe", 16)
51966

>>> print(bin(-42), bin(42), sep="\n ")
-0b101010
 0b101010

>>> int("-101010", 2)
-42

>>> mask = 0b11111111  # Same as 0xff or 255
>>> bin(-42 & mask)
'0b11010110'

>>> bin(-42 % (1 << 8))  # Give me eight bits
'0b11010110'

>>> from ctypes import c_uint8 as unsigned_byte
>>> bin(unsigned_byte(-42).value)
'0b11010110'

>>> from array import array
>>> signed = array("b", [-42, 42])
>>> unsigned = array("B")
>>> unsigned.frombytes(signed.tobytes())
>>> unsigned
array('B', [214, 42])
>>> bin(unsigned[0])
'0b11010110'
>>> bin(unsigned[1])
'0b101010'

>>> from struct import pack, unpack
>>> unpack("BB", pack("bb", -42, 42))
(214, 42)
>>> bin(214)
'0b11010110'

def from_twos_complement(bit_string, num_bits=32):
    unsigned = int(bit_string, 2)
    sign_mask = 1 << (num_bits - 1)  # For example 0b100000000
    bits_mask = sign_mask - 1        # For example 0b011111111
    return (unsigned & bits_mask) - (unsigned & sign_mask)

>>> int("11010110", 2)
214
>>> from_twos_complement("11010110")
214
>>> from_twos_complement("11010110", num_bits=8)
-42