Python3: 字节类型 bytes 和 bytearray

た入场券 2021-09-21 22:42 417阅读 0赞

本文链接: [https://blog.csdn.net/xietansheng/article/details/115557553][https_blog.csdn.net_xietansheng_article_details_115557553]

[Python3 学习笔记（目录）][Python3]

# 1. bytes #

Python 官网 bytes: [Bytes Objects][]

bytes 对象是由单个字节构成的 **不可变字节序列**，该序列的每个元素都为 \[0, 255\] 区间内的整数。

bytes 的构造方法:

class bytes([source[, encoding[, errors]]])

参数:

*  source 为整数，则返回长度为 source，元素以零值填充的字节序列。
 *  source 为字符串，则使用 encoding 把字符串编码为字节序列。
 *  source 为可迭代类型(list、bytes等)，则迭代元素必为\[0, 255\] 区间内的整数，迭代元素的整数值依次作为字节序列的字节数值。
 *  不传任何参数，返回长度为 0 的字节序列，即 b’’。

bytes 对象还可以使用字符串字面值语法来创建，在字符串字面值前加`b`前缀:

*  单引号: `b'同样允许嵌入"双"引号'`
 *  双引号: `b"同样允许嵌入'单'引号"`
 *  三重引号: `b'''三重单引号'''` 或 `b"""三重双引号"""`
 *  原生字符串: `br'原生字符串\n不转义'`

bytes 的字面值中只允许 ASCII 字符，如果字符编码值超过 127，则必须使用相应的转义形式表示，例如`b"\xFF\xEF"`。

使用字面值语法创建 bytes 实例:

>>> a = b"abc123"       # 创建 bytes, 把字符的 ASCII 值转换为 bytes 的元素数值,
    >>> a                   # 其中的 ASCII 字母并不是表示字母字符, 
    b'abc123'               # 而是表示其对应的 ASCII 的一个整数值
    >>> type(a)
    <class 'bytes'>
    >>> 
    >>> a[0]                # bytes 元素的类型为整数
    97
    >>> type(a[0])
    <class 'int'>
    >>> 
    >>> a = b"a\x62\xFF"    # 使用 \x 转义, \x62 表示一个字节元素
    >>> a
    b'ab\xff'
    >>> a[2]
    255

使用 bytes 构造方法创建实例:

>>> a = bytes(3)                    # 创建一个长度为 3, 元素值为 0 的 bytes
    >>> a
    b'\x00\x00\x00'
    >>> 
    >>> a = bytes("abc你好", "utf-8")   # 把字符串编码为 bytes
    >>> a
    b'abc\xe4\xbd\xa0\xe5\xa5\xbd'
    >>> 
    >>> a = bytes([1, 2, 3, 65, 97])    # 把整数列表中的各元素串起来转换为 bytes
    >>> a
    b'\x01\x02\x03Aa'

十六进制字符串 与 bytes 之间的转换:

>>> bytes.fromhex("FFEF6162")       # 十六进制 -> bytes
    b'\xff\xefab'
    >>> 
    >>> b'\xff\xefab'.hex()             # bytes -> 十六进制
    'ffef6162'

字符串 与 bytes 之间的转换:

>>> # str -> bytes: str.encode(encoding)
    >>> # bytes -> str: bytes.decode(encoding)
    >>>
    >>> # 字符串 编码为 bytes
    >>> "abc你好".encode("utf-8")
    b'abc\xe4\xbd\xa0\xe5\xa5\xbd'
    >>> 
    >>> # bytes 解码为 字符串
    >>> b'abc\xe4\xbd\xa0\xe5\xa5\xbd'.decode("utf-8")
    'abc你好'

附加: 字符 与 Uhicode 之间的转换

chr(int)            # Unicode整数值 -> 字符(单个字符)
    ord(str)            # 字符(单个字符) -> Unicode整数值
    ascii(obj|str)      # 对象的字符串形式, 把其中非 ASCII 字符使用 \u 编码

# 2. bytearray #

Python 官网 bytearray: [Bytearray Objects][]

bytearray 对象是由单个字节构成的 **可变字节序列**，该序列的每个元素都为 \[0, 255\] 区间内的整数。bytearray 是 bytes 的可变版本（内容和长度均可变）。

bytearray 的构造方法:

class bytearray([source[, encoding[, errors]]])

bytearray 构造方法的参数与 bytes 一致:

*  source 为整数，则返回长度为 source，元素以零值填充的字节数组。
 *  source 为字符串，则使用 encoding 把字符串编码为字节数组。
 *  source 为可迭代类型(list、bytes等)，则迭代元素必为\[0, 255\] 区间内的整数，迭代元素的整数值依次作为字节序列的字节数值。
 *  不传任何参数，返回一个空数组。

创建 bytearray 实例:

>>> a = bytearray(3)            # 创建一个长度为 3, 元素值为 0 的 bytearray
    >>> a
    bytearray(b'\x00\x00\x00')
    >>> a[0] = 97; a[1] = 255       # 修改数字元素的值
    >>> a
    bytearray(b'a\xff\x00')
    >>> a.append(65)                # 追加一个元素到末尾
    >>> a
    bytearray(b'a\xff\x00A')
    >>> 
    >>> a = bytearray("abc你好", "utf-8")    # 编码字符串创建 bytearray
    >>> a
    bytearray(b'abc\xe4\xbd\xa0\xe5\xa5\xbd')
    >>> 
    >>> a = bytearray([1, 2, 3, 65, 97])    # 把整数列表中的各元素串起来转换为 bytearray
    >>> a
    bytearray(b'\x01\x02\x03Aa')
    >>> 
    >>> a = bytearray(b"abc123")            # 根据 bytes 序列创建 bytearray
    >>> a
    bytearray(b'abc123')

# 3. bytes 与 bytearray 对象的方法 #

bytes 与 bytearray 相比，除了可改变的特性之外，其他基本相同，bytes 有的方法 bytearray 都有。bytes 和 bytearray 的相关操作的方法和 str 的方法相类似。

bytearray 特有的方法:

def append(item: int) -> None               # 添加一个元素到末尾, 值为 [0, 255] 区间内的整数
    def insert(index: int, item: int) -> None   # 在 index 位置插入一个元素, 值为 [0, 255] 区间内的整数
    def extend(iterable) -> None                # 把可迭代对象的所有元素依次添加到数组的末尾, 
                                                # 迭代元素的值必须为 [0, 255] 区间内的整数
    
    def remove(item: int) -> None               # 移除一个元素, 从左到右查找
    def pop(index: int = -1) -> int             # 移除并返回指定位置元素, 默认是最后一个
    
    def reverse() -> None                       # 反转所有数组元素
    def copy() -> bytearray                     # 复制数组的内容, 创建其副本返回
    
    def clear() -> None                         # 清空数组内的所有元素

bytes 与 bytearray 的相同方法:

def index(sub, start=None, end=None)    # 左往右查找子序列在序列中的位置, 找不到抛出异常
    def rindex(sub, start=None, end=None)   # 右往左查找子序列在序列中的位置, 找不到抛出异常
    
    def find(sub, start=None, end=None)     # 左往右查找子序列在序列中的位置, 找不到返回 -1
    def rfind(sub, start=None, end=None)    # 右往左查找子序列在序列中的位置, 找不到返回 -1
    
    def startswith(prefix, start=None, end=None)    # 判断序列是否已指定前缀开头
    def endswith(suffix, start=None, end=None)      # 判断序列是否已指定后缀结尾
    
    def upper()                             # 把序列中的所有字母转换为大写
    def lower()                             # 把序列中的所有字母转换为小写
    def title()                             # 标题化序列, 所有单词首字母大写, 其他字母小写
    def capitalize()                        # 将序列中的第一个字符转换为大写
    def swapcase()                          # 序列中的字母, 大写转换为小写, 小写转换为大写
    
    def lstrip(chars=b" \t\r\n")            # 删除左边所有 chars 中出现过的字节元素
    def rstrip(chars=b" \t\r\n")            # 删除右边所有 chars 中出现过的字节元素
    def strip(chars=b" \t\r\n")             # 删除两边所有 chars 中出现过的字节元素
    
    def ljust(width, fillchar=b" ")     # 原序列左对齐返回, 最小宽度为 width, 不够使用 fillchar 字节填充
    def rjust(width, fillchar=b" ")     # 原序列右对齐返回, 最小宽度为 width, 不够使用 fillchar 字节填充
    def center(width, fillchar=b" ")    # 原序列居中对齐返回, 最小宽度为 width, 不够使用 fillchar 字符填充
    def zfill(width)                    # 原序列右对齐返回, 最小宽度为 width, 不够使用 b"0" 填充
    
    @classmethod def fromhex(hex_str)   # 类方法, 从十六进制表示的字符串创建序列(bytes/bytearray)
    def hex()                           # 把字节序列以十六进制字符串的形式表示并返回
    def decode(encoding)                # 把字节序列以指定编码格式解码为字符串
    
    def split(sep, maxsplit=-1)         # 从左往右切分序列, maxsplit 表示最大切分次数, -1表示不限制
    def rsplit(sep, maxsplit=-1)        # 从右往左切分序列, maxsplit 表示最大切分次数, -1表示不限制
    def splitlines(keepends=False)      # 以换行符(b"\r", b"\r\n", b"\n")作为分隔符切分序列, 
                                        # keepends 表示结果子序列是否保留换行符
    
    def join(iterable[bytes/bytearray]) # 把 iterable 中的所有元素用本序列对象作为连接符连接成新的一个序列
    def replace(old, new, count=-1)     # 序列替换, count 表示最大替换次数, -1表示替换所有, 返回替换后的副本
    def expandtabs(tabsize=8)           # 把序列中的 b"\t" 替换为空格
    
    def isupper()                       # 所有字母是否为大写（不包括无大小写的字符）
    def islower()                       # 所有字母是否为小写（不包括无大小写的字符）
    def isdigit()                       # 序列是否只包含数字字符
    def isalnum()                       # 序列是否只由字母和数字组成
    def isalpha()                       # 序列是否只由字母组成
    def isascii()                       # 序列是否为空 或 所有字符均为 ASCII 字符（U+0000-U+007F）
    def isspace()                       # 序列是否只包含空格
    def istitle()                       # 序列是否是标题（所有的单词首字大写, 其他字母小写）
    
    def partition(sep)                  # sep(序列)首次出现的位置拆分序列, 
                                        # 返回一个 3 元祖 (seq前面的子序列, seq, seq后面的子序列)
    def rpartition(sep)                 # sep(序列)最后一次出现的位置拆分序列, 
                                        # 返回一个 3 元祖 (seq前面的子序列, seq, seq后面的子序列)
    
    def count(sub, start=None, end=None)    # 子序列 sub 在 [start, end] 范围内非重叠出现的次数
    
    def maketrans(frm, to)          # 创建字节映射的 转换表, frm 和 to 是长度相同的 bytes（字节相对映）
    def translate(table, del=b"")   # 根据 转换表, 转换字节序列中的字节, del 表示需要删除的字节

[https_blog.csdn.net_xietansheng_article_details_115557553]: https://blog.csdn.net/xietansheng/article/details/115557553
[Python3]: https://blog.csdn.net/xietansheng/article/details/109266600
[Bytes Objects]: https://docs.python.org/zh-cn/3/library/stdtypes.html#bytes-objects
[Bytearray Objects]: https://docs.python.org/zh-cn/3/library/stdtypes.html#bytearray-objects