Python教程009 字节对象bytes

字节对象bytes

字节对象bytes是单字节的不可变序列，用于存储和传输。字节对象语法与字符串对象语法基本相同，只是添加了b或B前缀。与字符串相对应，bytes也叫做字节串。
单引号: b'aaaa' 或 B'aaaa'
双引号: b"aaaa" 或 B"aaaa"
三重单引号: b'''aaaa''' 或 B'''aaaa'''
三重双引号: b"""aaaa""" 或 B"""aaaa"""

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


a = b'string a'
b = b"string b"
c = b'''string c'''
d = b"""string d"""
print(a)
print(b)
print(c)
print(d)

e = B'string e'
f = B"string f"
g = B'''string g'''
h = B"""string h"""
print(e)
print(f)
print(g)
print(h)

执行以上程序会输出如下结果：

1
2
3
4
5
6
7
8


b'string a'
b'string b'
b'string c'
b'string d'
b'string e'
b'string f'
b'string g'
b'string h'

单引号 ‘ 里面可以包含双引号 “ 。
双引号 “ 里面可以包含单引号 ‘ 。
三重引号'''里面可以包含双引号 “ 。
三重引号"""里面可以包含单引号 ‘ 。

例如：

1
2
3
4
5
6
7
8


a = b'string "a"'
b = b"string 'b'"
c = b'''string "c"'''
d = b"""string 'd'"""
print(a)
print(b)
print(c)
print(d)

执行以上程序会输出如下结果：

1
2
3
4


b'string "a"'
b"string 'b'"
b'string "c"'
b"string 'd'"

字节对象的字面量，使用下列三种不同的方式显示。

可打印的ASCII范围内的字节（从空格到 ~），使用ASCII字符本身。
制表符、换行符、回车符和 \ 对应的字节，使用转义序列 \t、\n、\r 和 \\。
其他字节的值，使用十六进制转义序列（例如，\x00 是空字节）。

例如：

1
2
3
4
5
6
7
8


>>> a = b'caf\xc3\xa9'  # 字节a转化为字符串是café，其中caf都是ASCII范围内的字节。é的字节是\xc3\xa9
>>> a
b'caf\xc3\xa9'
>>> a = b'你好'         # '你好'是不能被识别的字符，应该是转化为十六进制后才可以使用
 File "main.py", line 1
    a = b"你好"
       ^
SyntaxError: bytes can only contain ASCII literal characters.

关于ASCII

　ASCII（American Standard Code for Information Interchange，美国信息互换标准代码，ASCⅡ）是基于拉丁字母的一套电脑编码系统。它主要用于显示现代英语和其他西欧语言。它是现今最通用的单字节编码系统，并等同于国际标准ISO/IEC 646。

　　ASCII第一次以规范标准的型态发表是在1967年，最后一次更新则是在1986年，至今为止共定义了128个字符，其中33个字符无法显示（这是以现今操作系统为依归，但在DOS模式下可显示出一些诸如笑脸、扑克牌花式等8-bit符号），且这33个字符多数都已是陈废的控制字符，控制字符的用途主要是用来操控已经处理过的文字，在33个字符之外的是95个可显示的字符，包含用键盘敲下空白键所产生的空白字符也算1个可显示字符（显示为空白）。

关于ASCII的详细内容，请参照ASCII。

转义字符

同字符串一样，反斜杠（\）字符用于转义其他具有特殊含义的字符，如换行符、反斜杠本身或引号字符。
a = b'It\'s a string.' #输出b"It's a string."

原始字节串

与字符串一样，字节对象也可以使用r或者R前缀来禁用转义序列的处理。

例如：

1
2
3
4
5
6
7


a = b'It\'s a string.'
b = bR'It\'s a string.'
c = br'It\'s a string.'

print(a)
print(b)
print(c)

执行以上程序会输出如下结果：

1
2
3


b"It's a string."
b"It\'s a string."
b"It\'s a string."

索引操作

bytes对象的各个元素是介于0~255（含）之间的整数，通过索引获取的字节将是一个0到255之间的整数。

格式如下：
字节对象[i]

i是索引值。i是正数，从左向右计算，第一个是0，第二个是1，依次类推。i是负数，从右向左计算，第一个是-1，第二个是-2，依次类推。

字节对象索引操作

例如：

1
2
3
4
5
6
7
8


a = b"Hello World"
b = a[0]   # i是正数，从左向右计算，0表示是第一个。
c = a[-1]  # i是负数，从右向左计算。-1表示第一个。
d = a[6]

print(b)
print(c)
print(d)

执行以上程序会输出如下结果：

索引值i超出字节长度时，报错，抛出IndexError异常。

例如：

1
2
3


a = b"Hello"
b = a[10]
print(b)

执行以上程序会输出如下结果：

1
2
3
4


Traceback (most recent call last):
  File "main.py", line 2, in <module>
    b = a[10]
IndexError: index out of range

字节对象是不可改变的，以下赋值操作也会报错，抛出TypeError异常。

例如：

1
2


a = b"Hello"
a[0:1] = "h"

执行以上程序会输出如下结果：

1
2
3
4


Traceback (most recent call last):
  File "/home/main.py", line 2, in <module>
    a[0:1] = "h"
TypeError: 'bytes' object does not support item assignment

注意： 因为bytes对象是整数序列（类似于元组），对于bytes对象b，b[0]将是整数，而b[0:1]将是长度为1的bytes对象。（这与字符串不同，在字符串中，索引和切片都将生成长度为1的字符串对象）

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


s = "abc"
b = b"abc"

s1 = s[0]
s2 = s[0:1]
b1 = b[0]
b2 = b[0:1]
print(type(s1))
print(s1)
print(type(s2))
print(s2)
print(type(b1))
print(b1)
print(type(b2))
print(b2)

s3 = s[1]
s4 = s[1:2]
b3 = b[1]
b4 = b[1:2]
print(type(s3))
print(s3)
print(type(s4))
print(s4)
print(type(b3))
print(b3)
print(type(b4))
print(b4)

执行以上程序会输出如下结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


<class 'str'>
a
<class 'str'>
a
<class 'int'>
97
<class 'bytes'>
b'a'
<class 'str'>
b
<class 'str'>
b
<class 'int'>
98
<class 'bytes'>
b'b'

切片操作

字节对象也支持切片操作，语法格式如下：
字节对象[start:end]

start，end都是整数。索引值以 0 为开始值，如果是负数，则从尾部开始。-1为最末尾。
省略start，从0开始。
省略end，则获取剩余所有。
同时省略start和end，则复制当前的字节对象。

字节对象[start:end]获取索引值start开始，end结束(不包括end)的范围值。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


a = b"Hello World"
a1 = a[0:2]  #获取索引值从0到2(不包括2)的字节对象，结果是b'He'
a2 = a[6:8]  #获取索引值从6到8(不包括8)的字节对象，结果是b'Wo'
a3 = a[6:-1]  #获取索引值从6到-1(不包括-1)的字节对象，结果是b'Worl'
a4 = a[:2]  #获取索引值从0到2(不包括2)的字节对象，结果是b'He'
a5 = a[6:]  #获取索引值从6开始的所有字节对象，结果是b'World'
a6 = a[:]   #复制当前的字节对象b'Hello World'

print(a1)
print(a2)
print(a3)
print(a4)
print(a5)
print(a6)

执行以上程序会输出如下结果：

1
2
3
4
5
6


b'He'
b'Wo'
b'Worl'
b'He'
b'World'
b'Hello World'

字节对象切片还有第三个参数step。表示步长。格式如下：
字节对象[start:end:step]

省略step参数时，默认是1，也就是获取索引从start开始，步长为1，到end结束的值。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


a = b"Hello World"
a1 = a[0:6:2]      #获取索引值从0到6(不包括6)，步长为2的字节对象，结果是b'Hlo'
a2 = a[2:6:2]      #获取索引值从2到6(不包括6)，步长为2的字节对象，结果是b'lo'
a3 = a[::3]        #步长为3的字节对象，结果是b'HlWl'
a4 = a[0:-1:2]     #获取索引值从0到-1(不包括-1)，步长为2的字节对象，结果是b'HloWr'

print(a1)
print(a2)
print(a3)
print(a4)

执行以上程序会输出如下结果：

1
2
3
4


b'Hlo'
b'lo'
b'HlWl'
b'HloWr'

字节连接，复制

加号 + 是字节的连接符，将两边的bytes链接起来。

实例，字节连接

1
2
3
4
5
6
7
8


a = b"Hello"
b = b"World"

print(a)
print(b)

c = a + b
print(c)

执行以上程序会输出如下结果：

1
2
3


b'Hello'
b'World'
b'HelloWorld'

星号 * 表示复制当前字节，紧跟的数字为复制的次数。数字必须是正整数。

实例，字节复制

1
2
3
4
5


a = b"Hello"
print(a)

a = a * 2
print(a)

执行以上程序会输出如下结果：

1
2


b'Hello'
b'HelloHello'

转载请注明本网址。

文章目录

字节对象bytes

关于ASCII

转义字符

原始字节串

索引操作

切片操作

字节连接，复制