小陈那天在做一个串口通信的上位机程序。
下位机发过来的数据是一帧一帧的字节流，每帧有固定的帧头、长度、命令字、数据区和校验和。小陈需要解析这些帧，并且在某些时候还要构造指令发回去。
他先从串口读了一帧数据，拿到一个bytes对象：
frame = b'\xaa\x01\x03\x10\x20\x30\x05'
帧头是0xaa，长度是0x01，命令字是0x03，数据是0x10 0x20 0x30，校验和是0x05。他想在解析之前先做一点预处理，比如把帧头的0xaa改成0xbb，或者给数据区补几个字节。
他很自然地写下了：
frame[0] = 0xbb
结果直接报错：
TypeError: 'bytes' object does not support item assignment
小陈愣住了：列表能改，字典能改，怎么字节序列就不能改？他查了一下文档，发现还有一个叫bytearray的东西，说是“可变的字节序列”。他改成：
frame = bytearray(frame)
frame[0] = 0xbb
print(frame) # bytearray(b'\xbb\x01\x03\x10\x20\x30\x05')
可以改了。但改完之后他又发现新问题：有些函数要求传bytes，不认bytearray；有些地方bytes和bytearray混着用，比较结果居然是一样的；还有一些场景，他以为改的是副本，结果原数据被悄悄改了。
“同样是字节序列，怎么还分两种？到底什么时候用哪个？”
这个问题的答案，就是bytes和bytearray的核心区别：一个不可变，一个可变。
先看一个最直观的对比
b = b'\x01\x02\x03'
ba = bytearray(b'\x01\x02\x03')
print(b) # b'\x01\x02\x03'
print(ba) # bytearray(b'\x01\x02\x03')
# 尝试修改
b[0] = 0xff # TypeError: 'bytes' object does not support item assignment
ba[0] = 0xff # 正常
print(ba) # bytearray(b'\xff\x02\x03')
bytes创建之后内容就固定了，不能通过索引赋值、不能append、不能extend、不能remove。任何“修改”操作都会创建一个新的bytes对象。
bytearray是可变的，支持索引赋值、切片赋值、append、extend、insert、remove、pop、clear等所有列表式的修改操作。
用一个生活场景来理解。你有一块刻好的石碑，上面刻着字。
bytes就是那块石碑。刻好之后，字就固定了。你想改一个字，不能直接在石碑上改，只能重新刻一块新的石碑，把旧碑上的内容复制过去，再改那个字。
bytearray是一块白板。你可以在上面写字、擦掉、重写、追加。修改是就地发生的，不需要重新做一块白板。
区别一目了然：一个改不了，一个随便改。
bytes：不可变的字节序列
bytes是Python 3中表示二进制数据的标准类型。它是一串0到255之间的整数，创建后不可变。
创建bytes的方式有几种：
# 字面量
b1 = b'hello'
b2 = b'\x01\x02\x03'
# 从字符串编码
b3 = "中文".encode("utf-8")
# 从可迭代对象创建
b4 = bytes([1, 2, 3, 255]) # b'\x01\x02\x03\xff'
# 创建指定长度的零字节
b5 = bytes(5) # b'\x00\x00\x00\x00\x00'
bytes支持索引访问，返回的是整数，不是单字符的bytes：
b = b'\x01\x02\x03'
print(b[0]) # 1，整数
print(b[0:2]) # b'\x01\x02'，切片返回 bytes
这一点和字符串不同。字符串索引返回的是单字符字符串，bytes索引返回的是整数。因为bytes里的每个元素本质就是一个字节值。
bytes支持拼接、重复、查找、替换等操作，但所有操作都返回新的bytes对象：
b = b'hello'
b2 = b + b' world' # 新对象
b3 = b.replace(b'h', b'H') # 新对象
b4 = b.upper() # 新对象
原对象b始终不变。
bytearray：可变的字节序列
bytearray是bytes的可变版本。它同样是一串0到255之间的整数，但内容可以修改。
创建方式：
ba1 = bytearray(b'hello')
ba2 = bytearray([1, 2, 3, 255])
ba3 = bytearray(5) # bytearray(b'\x00\x00\x00\x00\x00')
ba4 = bytearray("中文", "utf-8")
bytearray支持所有列表式的修改操作：
ba = bytearray(b'\x01\x02\x03')
ba[0] = 0xff # 索引赋值
ba[1:3] = b'\xaa\xbb' # 切片赋值
ba.append(0x04) # 追加单个字节
ba.extend(b'\x05\x06') # 追加多个字节
ba.insert(0, 0x00) # 插入
ba.remove(0x02) # 按值删除
ba.pop() # 删除并返回最后一个
bytearray的索引访问也返回整数，切片返回bytearray：
ba = bytearray(b'\x01\x02\x03')
print(ba[0]) # 1，整数
print(ba[0:2]) # bytearray(b'\x01\x02')
坑一：以为 bytes 能原地修改
这是最直接的坑。从其他语言转过来的开发者，习惯了“字节数组可以随便改”，在Python里对着bytes索引赋值，直接报错。
data = b'\x01\x02\x03'
data[0] = 0xff # TypeError
解决方案有两种：
用bytearray：
data = bytearray(b'\x01\x02\x03')
data[0] = 0xff
data = bytes(data) # 需要 bytes 时再转回去
或者创建新的bytes：
data = b'\x01\x02\x03'
data = b'\xff' + data[1:] # 拼接出新 bytes
后者在需要频繁修改时效率很低，因为每次都要复制整个序列。bytearray才是频繁修改场景的正确选择。
坑二：bytes 和 bytearray 混用导致的行为差异
bytes和bytearray在很多操作上表现一致，但有些细节不同。
比较：bytes和bytearray的内容相同，比较结果是True。
print(b'\x01\x02' == bytearray(b'\x01\x02')) # True
哈希：bytes可哈希，bytearray不可哈希。
d = {}
d[b'key'] = 1 # 可以
d[bytearray(b'key')] = 1 # TypeError: unhashable type: 'bytearray'
因为bytearray可变，哈希值不稳定，所以不能作为字典键或集合元素。bytes不可变，可以。
类型检查：有些函数严格要求bytes，传bytearray会报错。
import hashlib
h = hashlib.md5()
h.update(b'data') # 可以
h.update(bytearray(b'data')) # 也可以，hashlib 接受 buffer
但有些库就不一定了。比如某些C扩展、某些网络库，可能只接受bytes。这时候需要显式转换：
result = some_function(bytes(ba))
坑三：以为切片是副本，结果不是
对于bytearray，切片返回的是一个新的bytearray，是副本，修改切片不影响原对象：
ba = bytearray(b'\x01\x02\x03\x04')
sub = ba[1:3]
sub[0] = 0xff
print(ba) # bytearray(b'\x01\x02\x03\x04')，没变
print(sub) # bytearray(b'\xff\x03')
但如果你把bytearray传给函数，函数内部修改它，原对象会变：
def modify(data):
data[0] = 0xff
ba = bytearray(b'\x01\x02')
modify(ba)
print(ba) # bytearray(b'\xff\x02')，被改了
而bytes传进函数，函数内部无法修改，只能返回新对象：
def modify(data):
return b'\xff' + data[1:]
b = b'\x01\x02'
b2 = modify(b)
print(b) # b'\x01\x02'，没变
print(b2) # b'\xff\x02'
这是可变对象和不可变对象在函数传参时的经典差异。bytearray是引用传递，函数内外看到的是同一个对象；bytes虽然也是引用传递，但因为不可变，函数内部任何“修改”都会创建新对象，原对象不受影响。
坑四：在循环里用 bytes 拼接
和字符串的+拼接一样，bytes的+拼接在循环里也是O(n²)。
result = b''
for i in range(10000):
result += bytes([i % 256])
每次+=都创建一个新的bytes，复制之前的所有内容。数据量大时非常慢。
正确的做法是用bytearray：
result = bytearray()
for i in range(10000):
result.append(i % 256)
result = bytes(result)
bytearray.append是O(1)的，追加1万个字节是O(n)。比bytes拼接快几个数量级。
或者用b''.join()：
parts = [bytes([i % 256]) for i in range(10000)]
result = b''.join(parts)
join一次性分配内存，也是O(n)。
坑五：bytes 和 str 混淆
bytes是字节，str是文本。两者不能直接拼接：
b'hello' + 'world' # TypeError: can't concat str to bytes
需要先编码或解码：
b'hello' + 'world'.encode('utf-8') # b'helloworld'
b'hello'.decode('utf-8') + 'world' # 'helloworld'
在Python 3里，str和bytes是严格区分的。Python 2的“字符串就是字节”的时代已经过去了。写代码时要清楚自己处理的是文本还是字节。
坑六：bytearray 的打印形式
bytearray的repr和bytes类似，但外面多了bytearray(...)：
print(b'\x01\x02') # b'\x01\x02'
print(bytearray(b'\x01\x02')) # bytearray(b'\x01\x02')
日志里看到bytearray(b'...')时，要知道它是可变字节序列，不是普通bytes。
性能差异
bytes因为不可变，创建后不需要担心被修改，某些操作可能更快（比如哈希计算可以缓存）。
bytearray因为可变，修改操作是O(1)（追加）或O(n)（插入/删除），但不需要每次创建新对象。
选择哪个，主要看是否需要修改：
- 只读数据：用
bytes。 - 需要频繁修改：用
bytearray。 - 需要作为字典键：只能用
bytes。
import timeit
# bytes 拼接
def bytes_concat():
result = b''
for i in range(1000):
result += bytes([i % 256])
return result
# bytearray 追加
def bytearray_append():
result = bytearray()
for i in range(1000):
result.append(i % 256)
return bytes(result)
t1 = timeit.timeit(bytes_concat, number=100)
t2 = timeit.timeit(bytearray_append, number=100)
print(f"bytes 拼接: {t1:.4f}")
print(f"bytearray 追加: {t2:.4f}")
在我的机器上，bytes拼接大约0.15秒，bytearray追加大约0.02秒。差距7倍多。数据量越大，差距越明显。
什么时候用 bytes，什么时候用 bytearray？
判断标准很清晰：
只读的二进制数据：用bytes。比如从文件读出的内容、网络收到的响应、编码后的字符串。
需要作为字典键或集合元素：只能用bytes，因为bytearray不可哈希。
需要频繁修改字节内容：用bytearray。比如协议封包、图像处理、逐字节解析。
需要拼接大量字节：用bytearray或b''.join()，不要用bytes的+。
**函数参数要求bytes**：如果内部需要修改，先转成bytearray，改完再转回bytes。
**函数参数要求bytearray**：直接传，或者传bytearray(data)。
相互转换
bytes和bytearray可以互相转换：
b = b'\x01\x02\x03'
ba = bytearray(b) # bytes -> bytearray
b2 = bytes(ba) # bytearray -> bytes
转换会创建一个新对象。对于bytearray -> bytes，新bytes是副本，之后修改bytearray不会影响bytes。
ba = bytearray(b'\x01\x02')
b = bytes(ba)
ba[0] = 0xff
print(b) # b'\x01\x02'，没变
print(ba) # bytearray(b'\xff\x02')
回到小陈的故事
小陈最终的串口通信代码是这样的：
# 接收数据，拿到 bytes
frame = ser.read(7) # b'\xaa\x01\x03\x10\x20\x30\x05'
# 需要修改，转成 bytearray
frame_ba = bytearray(frame)
# 修改帧头
frame_ba[0] = 0xbb
# 补数据
frame_ba.extend(b'\x00\x00')
# 需要发回去时，转回 bytes
send_data = bytes(frame_ba)
ser.write(send_data)
接收用bytes，修改用bytearray，发送前转回bytes。他说：“bytes是只读的，bytearray是读写都行的。需要改就转成bytearray，改完再转回去。别对着bytes索引赋值，它不认。”
他后来在团队文档里写了一条：“处理二进制数据，默认用bytes。需要逐字节修改、拼接、封包时，用bytearray。bytearray不能当字典键，需要哈希时转成bytes。在循环里拼字节，用bytearray.append，别用bytes的+。”
这个区分看起来简单，但真到写代码的时候，很多人会对着bytes报TypeError发呆，或者用bytes在循环里拼接，然后在数据量变大时突然卡住。
记住那个石碑和白板的比喻：bytes是刻好的石碑，改一个字就得重刻一块；bytearray是白板，随时可以擦掉重写。你要改，就用白板；你只是读，石碑也没问题。
字节序列本身不难，难的是想清楚“这份数据需不需要改、会不会被当成哈希键、要不要频繁拼接”。想清楚了，bytes和bytearray就不再是坑，而是两个各有适用场景的工具。
