目录

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

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

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

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

Python 的按位运算符概述

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

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

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

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

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

二进制如何工作？

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

>>> [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将它们包裹起来：

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

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

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

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

>>> ~156
-157

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

>>> ~156 & 255
99

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

按位移位运算符

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

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

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

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

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

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

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

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

将诸如 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'

浮点数字

在IEEE 754标准定义了由所述的实数的二进制表示符号，指数和尾数位。在不涉及太多技术细节的情况下，您可以将其视为二进制数的科学记数法。小数点“浮动”以容纳不同数量的有效数字，但它是一个二进制小数点。

广泛支持符合该标准的两种数据类型：

1. 单精度： 1 个符号位、8 个指数位、23 个尾数位
2. 双精度： 1 个符号位、11 个指数位、52 个尾数位

Python 的float数据类型相当于双精度类型。请注意，某些应用程序需要更多或更少的位。例如，OpenEXR 图像格式利用半精度以合理的文件大小表示具有高动态颜色范围的像素。

数字 Pi (π) 在四舍五入到小数点后五位时具有以下单精度二进制表示：

符号位的工作方式与整数类似，因此零表示正数。然而，对于指数和尾数，可以根据一些边缘情况应用不同的规则。

首先，您需要将它们从二进制转换为十进制形式：

• 指数： 128 ₁₀
• 尾数： 2 ^-1 + 2 ^-4 + … + 2 ^-19 = 299261 ₁₀ /524288 ₁₀ ≈ 0.570795 ₁₀

指数存储为无符号整数，但为了说明负值，它通常在单精度下具有等于 127 ₁₀的偏差。您需要减去它以恢复实际指数。

尾数位代表一个分数，因此它们对应于 2 的负幂。此外，您需要向尾数添加一个，因为在这种特殊情况下，它假定小数点之前有一个隐式前导位。

综上所述，您可以得出以下公式将浮点二进制数转换为十进制数：

当您用变量替换上例中的实际值时，您将能够破译以单精度存储的浮点数的位模式：

>>> 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

Python中的整数

在过去的编程时代，计算机内存非常宝贵。因此，语言可以让您非常精细地控制为数据分配多少字节。让我们快速浏览一下 C 中的一些整数类型作为示例：

这些值可能因平台而异。但是，如此丰富的数字类型允许您在内存中紧凑地排列数据。请记住，这些甚至不包括无符号类型！

另一方面是诸如 JavaScript 之类的语言，它们只有一种数字类型来统治它们。虽然这对初学者来说不太容易混淆，但代价是增加了内存消耗、降低了处理效率和降低了精度。

在谈论按位运算符时，必须了解 Python 如何处理整数。毕竟，您将主要使用这些运算符来处理整数。Python 中有几种完全不同的整数表示形式，它们取决于它们的值。

>>> 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)