bitarray 2.9.2

路线图

2024年（可能在大约7月），我们计划发布bitarray 3.0。3.0版本将

• 移除Python 2.7支持。

• 将.itersearch()重命名为.search()，将.iterdecode()重命名为.decode()（并移除它们的非迭代器对应物）。

• 移除util.rindex()，使用.index(..., right=1)代替

• 移除util.make_endian()，使用bitarray(..., endian=...)代替

• 移除对处理反序列化 bitarray() 的非法支持，详见#207 中的详细说明。这将关闭 #206。

主要特性

• 可以为每个 bitarray 对象指定位序，详见下文。

• 序列方法：切片（包括切片赋值和删除）、操作 +、*、+=、*=、in 操作符、len()

• 位运算：~、&、|、^、<<、>>（以及它们的就地版本 &=、|=、^=、<<=、>>=）。

• 快速编码和解码可变位长度前缀码的方法。

• bitarray 对象支持缓冲区协议（导入和导出缓冲区）。

• 将数据打包和解包为其他二进制数据格式，例如 numpy.ndarray。

• bitarray 对象的反序列化和反序列化。

• 不可变的 frozenbitarray 对象，它们是可哈希的

• 顺序搜索

• 类型提示

• 包含约 500 个单元测试的广泛测试套件。

• 实用模块 bitarray.util

  • 转换为和从十六进制字符串

  • （反）序列化

  • 美化打印

  • 转换为和从整数

  • 创建霍夫曼码

  • 稀疏 bitarray 的压缩

  • 各种计数函数

  • 其他有用函数

安装

Python 轮子在 PyPI 上对所有主要平台和 Python 版本都可用。这意味着您可以简单地

$ pip install bitarray

此外，conda 软件包也可用（包括默认的 Anaconda 仓库以及 conda-forge 支持的 bitarray）

$ conda install bitarray

安装完软件包后，您可能想对其进行测试

$ python -c 'import bitarray; bitarray.test()'
bitarray is installed in: /Users/ilan/bitarray/bitarray
bitarray version: 2.9.2
sys.version: 3.11.0 (main, Oct 25 2022) [Clang 14.0.4]
sys.prefix: /Users/ilan/Mini3/envs/py311
pointer size: 64 bit
sizeof(size_t): 8
sizeof(bitarrayobject): 80
HAVE_BUILTIN_BSWAP64: 1
default bit-endianness: big
machine byte-order: little
DEBUG: 0
.........................................................................
.........................................................................
................................................................
----------------------------------------------------------------------
Ran 502 tests in 0.416s

OK

test() 函数是 API 的一部分。它将返回一个 unittest.runner.TextTestResult 对象，这样可以通过以下方式验证所有测试是否成功运行：

import bitarray
assert bitarray.test().wasSuccessful()

用法

如上所述，bitarray 对象的行为非常类似于列表，因此没有太多要学习的。与列表对象最大的区别（除了 bitarray 显然是同质的以外）是能够访问对象的机器表示。在这样做的时候，位序是重要的；这个问题在下面的部分中进行了详细说明。在这里，我们展示了 bitarray 对象的基本用法

>>> from bitarray import bitarray
>>> a = bitarray()         # create empty bitarray
>>> a.append(1)
>>> a.extend([1, 0])
>>> a
bitarray('110')
>>> x = bitarray(2 ** 20)  # bitarray of length 1048576 (initialized to 0)
>>> len(x)
1048576
>>> bitarray('1001 011')   # initialize from string (whitespace is ignored)
bitarray('1001011')
>>> lst = [1, 0, False, True, True]
>>> a = bitarray(lst)      # initialize from iterable
>>> a
bitarray('10011')
>>> a[2]    # indexing a single item will always return an integer
0
>>> a[2:4]  # whereas indexing a slice will always return a bitarray
bitarray('01')
>>> a[2:3]  # even when the slice length is just one
bitarray('0')
>>> a.count(1)
3
>>> a.remove(0)            # removes first occurrence of 0
>>> a
bitarray('1011')

与列表一样，bitarray 对象支持切片赋值和删除

>>> a = bitarray(50)
>>> a.setall(0)            # set all elements in a to 0
>>> a[11:37:3] = 9 * bitarray('1')
>>> a
bitarray('00000000000100100100100100100100100100000000000000')
>>> del a[12::3]
>>> a
bitarray('0000000000010101010101010101000000000')
>>> a[-6:] = bitarray('10011')
>>> a
bitarray('000000000001010101010101010100010011')
>>> a += bitarray('000111')
>>> a[9:]
bitarray('001010101010101010100010011000111')

此外，切片可以赋值给布尔值，这比将值赋给所有值都相同的 bitarray 更容易（更快）

>>> a = 20 * bitarray('0')
>>> a[1:15:3] = True
>>> a
bitarray('01001001001001000000')

这比

>>> a = 20 * bitarray('0')
>>> a[1:15:3] = 5 * bitarray('1')
>>> a
bitarray('01001001001001000000')

注意，在后一种情况下，我们必须创建一个临时 bitarray，其长度必须已知或计算。将切片赋给布尔值的另一个例子是设置范围

>>> a = bitarray(30)
>>> a[:] = 0         # set all elements to 0 - equivalent to a.setall(0)
>>> a[10:25] = 1     # set elements in range(10, 25) to 1
>>> a
bitarray('000000000011111111111111100000')

从 bitarray 版本 2.8 开始，索引也可以是任意索引的列表（类似于 NumPy），或者是被视为掩码的 bitarray，详见 Bitarray 索引。

位运算符

bitarray 对象支持位运算符 ~、&、|、^、<<、>>（以及它们的就地版本 &=、|=、^=、<<=、>>=）。行为与预期非常相似

>>> a = bitarray('101110001')
>>> ~a  # invert
bitarray('010001110')
>>> b = bitarray('111001011')
>>> a ^ b
bitarray('010111010')
>>> a &= b
>>> a
bitarray('101000001')
>>> a <<= 2   # in-place left shift by 2
>>> a
bitarray('100000100')
>>> b >> 1
bitarray('011100101')

C语言没有指定负移位和大于或等于左操作数宽度的左移位的行为。确切的行为由编译器/机器特定。这个Python位数组库指定了以下行为

• 位数组的长度永远不会因为任何移位操作而改变

• 空白用0填充

• 负移位引发ValueError

• 大于或等于位数组长度的移位会导致所有值都为0的位数组

值得注意的是（无论字节序如何），位数组的左移（<<）始终向较低索引方向移动，而右移（>>）始终向较高索引方向移动。

字节序

除非明确转换为机器表示（使用.tobytes()，.frombytes()，.tofile()和.fromfile()方法），以及使用memoryview），否则字节序对任何计算都没有影响，可以跳过本节。

由于位数组允许对单个位进行寻址，而机器将8位表示为一个字节，因此在此映射中有两种明显的选择：小端序和大数据序。

处理位数组对象的机器表示时，建议始终明确指定字节序。

默认情况下，位数组使用大数据序表示

>>> a = bitarray()
>>> a.endian()
'big'
>>> a.frombytes(b'A')
>>> a
bitarray('01000001')
>>> a[6] = 1
>>> a.tobytes()
b'C'

大数据序意味着最高有效位最先出现。在这里，a[0]是最低地址（索引）和最高有效位，而a[7]是最高地址和最低有效位。

创建新的位数组对象时，可以始终明确指定字节序。

>>> a = bitarray(endian='little')
>>> a.frombytes(b'A')
>>> a
bitarray('10000010')
>>> a.endian()
'little'

在这里，最低位最先出现，因为小端序意味着数值重要性增加对应地址增加。所以a[0]是最低地址和最低有效位，而a[7]是最高地址和最高有效位。

位字节序是位数组对象的属性。一旦创建位数组对象，字节序就不能更改。在比较位数组对象时，字节序（以及机器表示）无关紧要；重要的是索引到位的映射。

>>> bitarray('11001', endian='big') == bitarray('11001', endian='little')
True

位运算（|，^，&=，|=，^=，~）通过在C中使用相应的字节操作有效地实现，即运算符作用于位数组对象的机器表示。因此，无法对具有不同字节序的位数组执行位运算。

在将位转换为机器表示以及从机器表示转换时，使用.tobytes()，.frombytes()，.tofile()和.fromfile()方法，字节序很重要

>>> a = bitarray(endian='little')
>>> a.frombytes(b'\x01')
>>> a
bitarray('10000000')
>>> b = bitarray(endian='big')
>>> b.frombytes(b'\x80')
>>> b
bitarray('10000000')
>>> a == b
True
>>> a.tobytes() == b.tobytes()
False

如上所述，一旦创建对象，字节序就不能更改。但是，您可以创建具有不同字节序的新位数组

>>> a = bitarray('111000', endian='little')
>>> b = bitarray(a, endian='big')
>>> b
bitarray('111000')
>>> a == b
True

缓冲区协议

位数组对象支持缓冲区协议。它们可以导出自己的缓冲区，也可以导入另一个对象的缓冲区。有关此主题的更多信息，请参阅缓冲区协议。还有一个示例，说明如何将文件内存映射到位数组：mmapped-file.py

可变位长度前缀码

.encode()方法接受一个映射符号到位数组的字典和一个可迭代对象，并在迭代过程中扩展位数组对象，以包含找到的编码符号。例如

>>> d = {'H':bitarray('111'), 'e':bitarray('0'),
...      'l':bitarray('110'), 'o':bitarray('10')}
...
>>> a = bitarray()
>>> a.encode(d, 'Hello')
>>> a
bitarray('111011011010')

请注意，字符串 'Hello' 是一个可迭代的，但符号不仅限于字符，事实上任何不可变 Python 对象都可以作为符号。以相同的字典为例，我们可以应用 .decode() 方法，这将返回一个符号列表。

>>> a.decode(d)
['H', 'e', 'l', 'l', 'o']
>>> ''.join(a.decode(d))
'Hello'

由于符号不仅限于字符，因此需要将它们作为列表的元素返回，而不是简单地返回连接的字符串。上述字典 d 可以使用函数 bitarray.util.huffman_code() 高效地构建。我还编写了 使用 bitarray 在 Python 中进行 Huffman 编码 以获取更多信息。

当代码很大，且您有很多解码调用时，大部分时间将花费在创建（相同的）内部解码树对象上。在这种情况下，创建一个 decodetree 对象会更快，该对象可以传递给 bitarray 的 .decode() 和 .iterdecode() 方法，而不是将这些方法本身的前缀代码字典传递给这些方法。

>>> from bitarray import bitarray, decodetree
>>> t = decodetree({'a': bitarray('0'), 'b': bitarray('1')})
>>> a = bitarray('0110')
>>> a.decode(t)
['a', 'b', 'b', 'a']
>>> ''.join(a.iterdecode(t))
'abba'

不可变 decodetree 对象的唯一目的是将其传递给 bitarray 的 .decode() 和 .iterdecode() 方法。

冻结 bitarray

frozenbitarray 对象与 bitarray 对象非常相似。区别在于这个 frozenbitarray 是不可变的，且可哈希的，因此可以用作字典键。

>>> from bitarray import frozenbitarray
>>> key = frozenbitarray('1100011')
>>> {key: 'some value'}
{frozenbitarray('1100011'): 'some value'}
>>> key[3] = 1
Traceback (most recent call last):
    ...
TypeError: frozenbitarray is immutable

bitarray 对象

bitarray(initializer=0, /, endian='big', buffer=None) -> bitarray

返回一个新 bitarray 对象，其项目是从可选的初始对象和字节序初始化的，并具有字节序。初始化器可以是以下类型之一

int：创建给定长度的 bitarray。初始值全部为 0。

str：从 0 和 1 的字符串创建 bitarray。

iterable：从可迭代对象或整数 0 或 1 的序列创建 bitarray。

可选关键字参数

endian：指定创建的 bitarray 对象的位字节序。允许的值是 big 和 little（默认为 big）。位字节序影响 bitarray 的缓冲区表示。

buffer：任何公开缓冲区的对象。当提供时，initializer 不能存在（或必须是 None）。导入的缓冲区可以是只读的或可写的，具体取决于对象类型。

新功能：2.3 版本中的可选 buffer 参数。

bitarray 方法

all() -> bool

当 bitarray 中的所有位都为 True 时返回 True。请注意，a.all() 比 all(a) 快。

any() -> bool

当 bitarray 中的任何位都为 True 时返回 True。请注意，a.any() 比 any(a) 快。

append(item, /)

将 item 添加到 bitarray 的末尾。

buffer_info() -> tuple

返回一个包含以下内容的元组

0. 缓冲区的内存地址

1. 缓冲区大小（以字节为单位）

2. 作为字符串的位字节序

3. 填充位数量

4. 缓冲区分配的内存（以字节为单位）

5. 内存为只读

6. 缓冲区已导入

7. 缓冲区导出数量

bytereverse(start=0, stop=<缓冲区结束>, /)

对于 byte-range(start, stop) 范围内的每个字节，就地反转位。起始和停止索引以字节为单位给出（不是位）。请注意，此方法仅更改缓冲区；它不会更改位数组对象的字节序。填充位保持不变，因此连续调用两次将始终使位数组保持不变。

New in version 2.2.5: optional start and stop arguments.

clear()

从位数组中删除所有项。

New in version 1.4.

copy() -> bitarray

返回位数组的副本。

count(value=1, start=0, stop=<结束>, step=1, /) -> int

在位数组 [start:stop:step] 内 value 出现的次数。可选参数 start、stop 和 step 以切片表示法解释，即 a.count(value, start, stop, step) 等于 a[start:stop:step].count(value)。值也可以是子位数组。在这种情况下，在 [start:stop] 内（step 必须为 1）计算非重叠出现。

New in version 1.1.0: optional start and stop arguments.

New in version 2.3.7: optional step argument.

New in version 2.9: add non-overlapping sub-bitarray count.

decode(code, /) -> list

给定前缀码（映射符号到位数组的字典，或 decodetree 对象），解码位数组的内容，并将其作为符号列表返回。

encode(code, iterable, /)

给定前缀码（映射符号到位数组的字典），迭代符号对象，并将每个符号对应的位数组扩展到位数组中。

endian() -> str

以字符串形式返回位数组的位字节序（little 或 big）。

extend(iterable, /)

将 iterable 中的所有项目追加到位数组的末尾。如果可迭代对象是字符串，则将每个 0 和 1 追加为位（忽略空格和下划线）。

fill() -> int

向位数组的末尾添加零，使长度为8的倍数，并返回添加的位数量 [0..7]。

find(sub_bitarray, start=0, stop=<结束>, /, right=False) -> int

返回子位数组首次（或当 right=True 时为最右侧）出现在 [start:stop] 范围内的最低索引。当子位数组未找到时返回 -1。

New in version 2.1.

New in version 2.9: add optional keyword argument right.

frombytes(bytes, /)

使用来自字节对象（例如，字节或类似字节的对象）的原始字节扩展位数组。每个添加的字节将向位数组添加八个位。

New in version 2.5.0: allow bytes-like argument.

fromfile(f, n=-1, /)

从文件对象 f（或其他支持 .read() 方法的二进制流，例如 io.BytesIO）读取最多 n 个字节，并扩展位数组。每个读取的字节将向位数组添加八个位。当 n 被省略或为负时，读取所有字节直到文件末尾。当 n 为非负数但超过可用的数据时，引发 EOFError（但仍然读取并追加可用的数据）。

index(sub_bitarray, start=0, stop=<end>, /, right=False) -> int

返回子位向量在[start:stop]内找到的最低（或当right=True时为最右）的索引，使得子位向量包含在[start:stop]内。如果子位向量不存在，则引发ValueError。

New in version 2.9: add optional keyword argument right.

insert(index, value, /)

在索引前插入value到位向量中。

invert(index=<所有位>, /)

原地反转位向量中的所有位。如果提供了可选的index，则只反转索引处的单个位。

新功能：版本1.5.3中添加了可选的index参数。

iterdecode(code, /) -> iterator

给定一个前缀码（将符号映射到位向量的字典或decodetree对象），解码位向量的内容并返回一个符号迭代器。

itersearch(sub_bitarray, start=0, stop=<end>, /, right=False) -> iterator

返回子位向量在[start:stop]内找到的索引迭代器，使得子位向量包含在[start:stop]内。索引按升序迭代（从最低到最高），除非right=True，这将按降序迭代（从最右边的匹配开始）。

新功能：版本2.9中添加了可选的start和stop参数 - 添加了可选关键字参数right。

pack(bytes, /)

从类似bytes的对象扩展位向量，其中每个字节对应单个位。字节b'\x00'映射到位0，所有其他字节映射到位1。

此方法以及.unpack()方法旨在在位向量对象和其他具有不同内存视图的Python对象（例如NumPy的ndarray对象）之间高效地传输数据。

New in version 2.5.0: allow bytes-like argument.

pop(index=-1, /) -> item

移除并返回索引处的项目（默认为最后一个）。如果索引超出范围，则引发IndexError。

remove(value, /)

移除第一次出现的value。如果value不存在，则引发ValueError。

reverse()

原地反转位向量中的所有位。

search(sub_bitarray, limit=<none>, /) -> list

在self中搜索给定的子位向量，并返回起始位置列表。可选参数限制搜索结果的数量为指定的整数。默认情况下，返回所有搜索结果。

setall(value, /)

将位向量中的所有元素设置为value。请注意，a.setall(value)等价于a[:] = value。

sort(reverse=False)

原地排序位向量中的所有位。

to01() -> str

返回一个包含位向量中位的字符串（'0'和'1'）。

tobytes() -> bytes

返回位向量缓冲区的字节（填充位设置为0）。

tofile(f, /)

将位向量的字节表示写入文件对象f。

tolist() -> list

将位向量作为整数项列表返回。a.tolist()等于list(a)。

请注意，创建的列表对象将比位向量对象需要32或64倍的内存（取决于机器体系结构），这可能会导致内存错误，如果位向量非常大。

unpack(zero=b'\x00', one=b'\x01') -> bytes

返回包含位向量中每个位的字符的字节，使用指定的映射。

位向量数据描述符

数据描述符是在版本2.6中添加的。

nbytes -> int

以字节为单位的缓冲区大小

padbits -> int

填充位数量

只读 -> 布尔型

布尔值，表示缓冲区是否为只读

其他对象

frozenbitarray(initializer=0, /, endian='big', buffer=None) -> frozenbitarray

返回一个 frozenbitarray 对象。初始化方式与 bitarray 对象相同。一个 frozenbitarray 是不可变的且可哈希的，因此可以作为字典键使用。

自版本 1.1 以来新增。

decodetree(code, /) -> decodetree

给定一个前缀码（一个将符号映射到位向量的字典），创建一个二叉树对象，以便传递给 .decode() 或 .iterdecode()。

自版本 1.6 以来新增。

在 bitarray 模块中定义的函数

bits2bytes(n, /) -> int

返回存储 n 位所需的字节数。

get_default_endian() -> str

返回创建新 bitarray 对象的默认字节序。除非调用了 _set_default_endian('little')，否则默认字节序为大端。

自版本 1.3 以来新增。

test(verbosity=1) -> TextTestResult

运行自测，并返回 unittest.runner.TextTestResult 对象。

在 bitarray.util 模块中定义的函数

此子模块自版本 1.2 以来添加。

zeros(length, /, endian=None) -> bitarray

创建一个长度为 length 的位向量，所有值均为 0，并可选字节序，可以是 'big' 或 'little'。

ones(length, /, endian=None) -> bitarray

创建一个长度为 length 的位向量，所有值均为 1，并可选字节序，可以是 'big' 或 'little'。

自版本 2.9 以来新增。

urandom(length, /, endian=None) -> bitarray

返回一个长度为 length 的随机位向量（使用 os.urandom）。

自版本 1.7 以来新增。

pprint(bitarray, /, stream=None, group=8, indent=4, width=80)

在 stream（默认为 sys.stdout）上打印对象的格式化表示。默认情况下，元素按字节分组（8 个元素），每行 8 个字节（64 个元素）。非位向量对象通过标准库函数 pprint.pprint() 打印。

自版本 1.8 以来新增。

make_endian(bitarray, /, endian) -> bitarray

当给定位向量的字节序与 endian 不同时，返回一个新的位向量，其字节序为 endian，与原始位向量具有相同的元素。否则（字节序已经是 endian），则返回原始位向量，不做更改。

自版本 1.3 以来新增。

自版本 2.9 起已弃用 - 使用 bitarray()。

rindex(bitarray, sub_bitarray=1, start=0, stop=<end>, /) -> int

返回 sub_bitarray（或项 - 默认为 1）在 bitarray（a）中找到的最右侧（最高）索引，使得 sub_bitarray 被包含在 a[start:stop] 内。当 sub_bitarray 不存在时，引发 ValueError。

自版本 2.3.0 以来新增：可选的 start 和 stop 参数。

自版本 2.9 起已弃用 - 使用 .index(..., right=1)。

strip(bitarray, /, mode='right') -> bitarray

返回一个新的位向量，从左侧、右侧或两侧移除了零。允许的 mode 值为字符串：left、right、both

count_n(a, n, value=1, /) -> int

返回第一个满足 a[:i].count(value) == n 的索引 i。当 n 超过总数时（a.count(value)），引发 ValueError。

自 2.3.6 版本开始：可选的 value 参数。

parity(a, /) -> int

返回位数组 a 的奇偶性。 parity(a) 等价于 a.count() % 2，但更高效。

自 1.9 版本开始。

count_and(a, b, /) -> int

以内存高效的方式返回 a & b 的计数，因为没有创建中间位数组对象。

count_or(a, b, /) -> int

以内存高效的方式返回 a | b 的计数，因为没有创建中间位数组对象。

count_xor(a, b, /) -> int

以内存高效的方式返回 a ^ b 的计数，因为没有创建中间位数组对象。

这也被称为汉明距离。

any_and(a, b, /) -> bool

高效的 any(a & b) 实现。

自 2.7 版本开始。

subset(a, b, /) -> bool

如果位数组 a 是位数组 b 的子集，则返回 True。 subset(a, b) 等价于 a | b == b（同样 a & b == a），但更高效，因为没有创建中间位数组对象，并在找到第一个不匹配时停止缓冲区迭代。

intervals(bitarray, /) -> 迭代器

计算所有连续的 1 和 0 的区间，并返回一个元组 (value, start, stop) 的迭代器。这些区间保证有序，并且它们的尺寸始终不为零（stop - start > 0）。

自 2.7 版本开始。

ba2hex(bitarray, /) -> hexstr

返回包含位数组十六进制表示的字符串（长度必须是 4 的倍数）。

hex2ba(hexstr, /, endian=None) -> bitarray

十六进制表示的位数组。hexstr 可以包含任意数量的十六进制数字（包括奇数个数字），可以是大小写。

ba2base(n, bitarray, /) -> str

返回包含位数组基 n ASCII 表示的字符串。允许的 n 值为 2、4、8、16、32 和 64。位数组的长度必须是 1、2、3、4、5 或 6 的倍数。对于 n=32，使用 RFC 4648 Base32 字母表，对于 n=64，使用标准 base 64 字母表。

另请参阅：[位数组表示](https://github.com/ilanschnell/bitarray/blob/master/doc/represent.rst)

自 1.9 版本开始。

base2ba(n, asciistr, /, endian=None) -> bitarray

基 n ASCII 表示的位数组。允许的 n 值为 2、4、8、16、32 和 64。对于 n=32，使用 RFC 4648 Base32 字母表，对于 n=64，使用标准 base 64 字母表。

另请参阅：[位数组表示](https://github.com/ilanschnell/bitarray/blob/master/doc/represent.rst)

自 1.9 版本开始。

ba2int(bitarray, /, signed=False) -> int

将给定的位数组转换为整数。位字节序受位数组位字节序的影响。 signed 表示是否使用二进制补码来表示整数。

int2ba(int, /, length=None, endian=None, signed=False) -> bitarray

将给定的整数转换为位数组（具有指定的字节序，且不包含前导（大端）或尾部（小端）零），除非提供了位数组的长度。如果整数不能用指定的位数表示，将引发< span class="docutils literal">OverflowError。 signed确定是否使用二进制补码表示整数，并且需要提供length。

serialize(bitarray, /) -> bytes

返回位数组的序列化表示，可以传递给 deserialize()。它有效地表示了位数组对象（包括其位字节序）并且保证在未来的版本中不会改变。

另请参阅：[位数组表示](https://github.com/ilanschnell/bitarray/blob/master/doc/represent.rst)

自版本 1.8 以来新增。

deserialize(bytes, /) -> bitarray

返回一个位数组，给定一个类似于由 serialize() 返回的字节表示。

另请参阅：[位数组表示](https://github.com/ilanschnell/bitarray/blob/master/doc/represent.rst)

自版本 1.8 以来新增。

New in version 2.5.0: allow bytes-like argument.

sc_encode(bitarray, /) -> bytes

压缩稀疏位数组并返回其二进制表示。这种表示对于有效地存储稀疏位数组很有用。使用 sc_decode() 进行解压缩（解码）。

另请参阅：稀疏位数组压缩

自 2.7 版本开始。

sc_decode(stream) -> bitarray

解压缩稀疏压缩（sc）位数组的二进制流（一个整数迭代器或字节类似对象），并返回解码后的位数组。此函数仅消耗一个位数组并保持剩余流不变。使用 sc_encode() 进行压缩（编码）。

另请参阅：稀疏位数组压缩

自 2.7 版本开始。

vl_encode(bitarray, /) -> bytes

返回位数组的可变长度二进制表示。这种表示对于有效地在二进制流中存储小型位数组很有用。使用 vl_decode() 进行解码。

另请参阅：可变长度位数组格式

新版本 2.2。

vl_decode(stream, /, endian=None) -> bitarray

解码二进制流（一个整数迭代器或字节类似对象），并返回解码后的位数组。此函数仅消耗一个位数组并保持剩余流不变。使用 vl_encode() 进行编码。

另请参阅：可变长度位数组格式

新版本 2.2。

huffman_code(dict, /, endian=None) -> dict

给定一个频率映射，一个将符号映射到其频率的字典，计算霍夫曼码，即一个将符号映射到位数组的字典（具有给定的字节序）。请注意，符号不限于字符串。符号可以是任何可散列对象（如 None）。

canonical_huffman(dict, /) -> tuple

给定一个频率映射，一个将符号映射到其频率的字典，计算规范霍夫曼码。返回一个包含以下内容的元组

0. 规范霍夫曼码，它是一个将符号映射到位数组的字典

1. 包含每个码长符号数量的列表

2. 包含符号的规范顺序的列表

注意：这两个列表可以用作canonical_decode()的输入。

另请参阅：规范霍夫曼编码

新版本 2.5。

canonical_decode(bitarray, count, symbol, /) -> iterator

使用规范霍夫曼解码表解码位数组，其中count是一个包含每个长度的符号数量的序列，而symbol是一个包含符号的规范顺序的序列。

另请参阅：规范霍夫曼编码

新版本 2.5。