Python从入门到精通——第三章基本数据类型-CSDN博客

Python语言的基本数据类型包括数字、字符串、布尔类型、bytes类型、列表、元组、字典和集合等，本章我们详细介绍数字、字符串、布尔值和bytes类型等相关内容，列表、元组、字典和集合将在后续章节详细讲解。

一.Python语言中的变量与赋值语句

（一）Python语言中的变量

Python语言中的变量是用来标识对象或引用对象的。变量通过变量名访问，变量的命名规则必须遵循第二章所介绍的标识符命名规则。

Python语言是动态类型语言，即变量不需要显示声明数据类型。根据变量的赋值，Python语言的解释器会自动确定其数据类型。

【例1】变量动态类型示例及讨论

>>> m=2                       #整数类型
>>> type(m)
<class 'int'>
>>> m=2.6                     #浮点类型
>>> type(m)
<class 'float'>
>>> m='你好'                  #字符串类型
>>> type(m)
<class 'str'>
>>> m=5+4j                   #复数类型
>>> type(m)
<class 'complex'>
>>> m=False                  #布尔类型
>>> type(m)
<class 'bool'>
>>> m=[1,2,3,4,5]            #列表类型
>>> type(m)
<class 'list'>

通过内置的type()函数，可以判断一个对象指向的数据类型。

（二）变量的赋值

变量的赋值就是用一个变量来标识某个对象，其语法格式如下：

变量=表达式

最简单的表达式就是一个字面量，例如，x=100，即表示用变量x来标识一个整数对象100，x为这个整数对象的引用。

表达式也可以很复杂。例如，x=(100-20)/2，这时Python语言的解释器会先求表达式的值，然后返回表达式结果对象，并用变量来引用该对象。

Python语言中的变量在访问之前，必须先绑定某个对象，也就是先赋值，否则会报错。

【例2】变量的赋值示例

>>> x=100
>>> print(x)
100
>>> str='I am a boy.'
>>> print(str)
I am a boy.
>>> print(y)
NameError: name 'y' is not defined

在例2中，x和str两个变量都可以正常使用。但是当试图输出y的时候，系统会报错，因为变量y未赋值，因此不能直接使用。

（三）链式赋值语句

链式赋值是Python中一种简洁的赋值方式，允许在单个语句中为多个变量赋相同的值。

【例3】链式赋值语句示例

a=b=c=10

这条语句将值10赋给变量a、b和c。

1.工作原理

（1）链式赋值的执行顺序是从右向左：

首先将最右边的值(10)赋给最右边的变量(c)
然后将c的值赋给b
最后将b的值赋给a

（2）所有变量都指向同一个对象(在内存中是同一个值)

2.注意事项

（1）可变对象的引用问题

当赋值的是可变对象(如列表、字典)时，所有变量都指向同一个对象：

x = y = []
x.append(1)
print(y)  # 输出[1]，因为x和y引用同一个列表

（2）不可变对象安全

对于不可变对象(如数字、字符串、元组)，链式赋值是安全的：

m = n = 5
m += 1
print(n)  # 输出5，因为整数是不可变的

（3）与并行赋值的区别

链式赋值是给多个变量赋同一个值，而并行赋值是同时给多个变量赋不同的值：

# 链式赋值
a = b = c = 0

# 并行赋值
x, y, z = 1, 2, 3

（4）表达式中的链式赋值

Python不支持在表达式中使用链式赋值：

# 这样是错误的
if (a = b = 0):
    pass

3.实际应用场景

（1）初始化多个变量为相同值：

counter = total = 0

（2）创建多个指向同一对象的引用：

default_config = user_config = system_config = {}

链式赋值可以使代码更简洁，但需要注意共享引用可能带来的副作用，特别是在处理可变对象时。

（四）解包赋值语句

解包赋值是Python中一种强大的特性，允许将序列或可迭代对象中的元素解包并赋值给多个变量。

1.基本解包赋值

（1）元组/列表解包

a, b, c = [1, 2, 3]  # a=1, b=2, c=3
x, y, z = (4, 5, 6)  # x=4, y=5, z=6

（2）字符串解包

c1, c2, c3 = "abc"  # c1='a', c2='b', c3='c'

（3）交换变量值

x, y = 10, 20
x, y = y, x  # 交换后 x=20, y=10

2.高级解包特性

（1）使用星号(*)收集多余元素

first, *middle, last = [1, 2, 3, 4, 5]
# first=1, middle=[2, 3, 4], last=5

（2）嵌套解包

data = [1, (2, 3), 4]
a, (b, c), d = data  # a=1, b=2, c=3, d=4

（3）字典解包

d = {'x': 1, 'y': 2, 'z': 3}
x, y, z = d.values()  # x=1, y=2, z=3
a, b, c = d.keys()    # a='x', b='y', c='z'

（4）解包函数返回值

def get_coords():
    return 10, 20
    
x, y = get_coords()  # x=10, y=20

3.注意事项

（1）元素数量必须匹配

# 会引发ValueError
a, b = [1, 2, 3]

（2）星号变量始终是列表：

first, *rest = [1]  # first=1, rest=[]

（3）解包字典时顺序问题：

Python 3.7+中字典保持插入顺序，但早期版本不保证顺序

（4）下划线(_)作为占位符：

a, _, b = (1, 2, 3)  # 忽略第二个元素

4.实际应用场景

（1）处理函数返回的多个值

（2）迭代时获取键值对：

for k, v in {'a':1, 'b':2}.items():
    print(k, v)

（3）从复杂数据结构中提取特定值

（4）函数参数传递时使用解包：

def func(a, b, c):
    return a + b + c

args = [1, 2, 3]
result = func(*args)  # 解包列表作为参数

二.标准数据类型

Python3中常见的数据类型有Number（数字）、String（字符串）、Bool（布尔类型）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）

Python3 的六个标准数据类型中：

不可变类型：数字、字符串、元组；
可变类型：列表、字典、集合。

三.数字

（一）数字类型分类

1.整数（int）

表示整数值，无大小限制（仅受内存限制）
可以是正数、负数或零
支持十进制、二进制(0b)、八进制(0o)和十六进制(0x)表示法

a = 10         # 十进制
b = 0b1010     # 二进制 (10)
c = 0o12       # 八进制 (10)
d = 0xA        # 十六进制 (10)

2.浮点数（float）

表示实数，带有小数部分
可以用小数或科学计数法表示
精度受限于双精度浮点数(约15-17位有效数字)

f1 = 3.14
f2 = -0.001
f3 = 2.5e3     # 2500.0
f4 = 1.6e-19   # 1.6 × 10⁻¹⁹

3.复数（complex）

表示复数，形式为 a + bj
a 是实部，b 是虚部
虚部后缀可以是 j 或 J

c1 = 1 + 2j
c2 = 3 - 4J
c3 = complex(5, 6)  # 5 + 6j

4.布尔值（bool）

是 int 的子类，只有两个值：True(1) 和 False(0)
常用于逻辑运算和条件判断

b1 = True
b2 = False

（二）数字类型转换

# 显式类型转换
x = 3.14
int_x = int(x)      # 3 (截断小数部分)
float_y = float(5)  # 5.0
complex_z = complex(3)  # (3+0j)

# 自动类型转换 (向上转型)
result = 5 + 2.5    # 结果为 7.5 (float)

（三）数字运算

1.基本数字运算

a, b = 10, 3
print(a + b)  # 13  加法
print(a - b)  # 7   减法
print(a * b)  # 30  乘法
print(a / b)  # 3.333... 真除法(返回float)
print(a // b) # 3   地板除法(返回int)
print(a % b)  # 1   取模
print(a ** b) # 1000 幂运算

2.增强赋值运算

x = 5
x += 2   # 等同于 x = x + 2
x **= 3  # 等同于 x = x ** 3

3.比较运算

print(5 > 3)   # True
print(5 == 5.0) # True (值相等)
print(5 is 5.0) # False (不是同一对象)

4.数字函数

Python 的 math 模块提供了更多数学函数：

import math

print(math.sqrt(16))    # 4.0 平方根
print(math.fabs(-5))    # 5.0 绝对值
print(math.ceil(3.2))   # 4   向上取整
print(math.floor(3.8))  # 3   向下取整
print(round(3.14159, 2)) # 3.14 四舍五入

（四）数字类型特点

1.不可变性

数字对象创建后不可被修改

x = 5
y = x  # y和x指向同一个对象
x = 10 # 现在x指向新对象，y仍指向5

2.内存效率

小整数(-5到256)会被Python缓存，重复使用同一对象

3.精度问题

浮点数运算可能存在精度误差

0.1 + 0.2 == 0.3  # False (实际为0.30000000000000004)

4.大整数支持

Python的int可以表示任意大小的整数

big_num = 10**1000  # 一个非常大的数

（五）其他有用功能

1.分数表示（fractions模块）

from fractions import Fraction
f = Fraction(3, 4)  # 3/4

2.十进制精确计算 (decimal模块)

from decimal import Decimal
d = Decimal('0.1') + Decimal('0.2')  # 精确等于0.3

3.随机数生成 (random模块)

import random
print(random.randint(1, 100))  # 1-100之间的随机整数
print(random.random())         # [0,1)之间的随机浮点数

*补充：random库的基本应用

Python语言内置的random库，提供了与随机数有关的功能，主要是提供一些生成各种随机数的函数。random库中定义了下列函数：

（1）random()。返回左闭右开区间[0.0,1.0)中的一个随机浮点数。

（2）randrange(n)、randrange(m,n)、randrange(m,n,d)。返回给定区间的一个随机整数（参考range()规定，这几个函数相当于按同样形式调用range()，从生成的序列中随机选出一个数返回）。

（3）randint(m,n)。相当于randrange(m,n+1)。

（4）choice(s)。从序列s里随机选择一个元素。

（5）uniform(m,n)。生成一个[m,n]之间的随机小数。

（6）sample(pop,k)。从pop类型中随机选取k个元素，以列表类型返回。

（7）shuffle(s)。将序列类型中的元素随机排序，返回打乱后的序列。

（8）seed(n)。用整数n重置随机数生成器。seed()函数利用系统当时的时间重置随机数生成器。调用seed()函数，相当于要求重新开始一个随机序列。

四.字符串

（一）字符串类型数据

使用单引号或双引号括起来的内容，称为字符串类型数据（str），Python语言的解释器会自动创建str型对象实例。Python语言中的字符串数据类型可以使用以下4种方式定义。

（1）单引号（' '）。包含在单引号中的内容为字符串数据类型，其中可以包含双引号。

（2）双引号（'' ''）。包含在双引号中的内容为字符串数据类型，其中可以保护单引号。

（3）三单引号（''' '''）。包含在三单引号中的内容为字符串数据类型，其中可以保护单引号和双引号，可以跨行。

（4）三双引号（'''''' ''''''）。包含在三双引号的内容为字符串数据类型，其中可以包含单引号和双引号，可以跨行。

【例4】字符串类型数据使用示例

>>> 'abc'
'abc'
>>> 'Hello'
'Hello'

>>> print('''"Python程序设计"
"C++程序设计"''')
"Python程序设计"
"C++程序设计"

>>> print("""'Python程序设计'
'C++程序设计'""")
'Python程序设计'
'C++程序设计'

>>> '中' '国'           #两个紧邻的字符串，如果中间只有空格分隔，则自动拼接为一个字符串
'中国'

（二）字符串的索引与切片

1.字符串索引

正向索引（从左到右）

从0开始，第一个字符索引为0
最后一个字符索引为 len(str)-1

s = "Python"
print(s[0])   # 'P' (第一个字符)
print(s[2])   # 't' (第三个字符)
print(s[5])   # 'n' (第六个字符)

反向索引（从右到左）

从-1开始，最后一个字符索引为-1
第一个字符索引为 -len(str)

s = "Python"
print(s[-1])  # 'n' (最后一个字符)
print(s[-3])  # 'h' (倒数第三个字符)
print(s[-6])  # 'P' (第一个字符)

2.字符串切片

基本语法：str[start:stop:step]

基本切片

s = "Python Programming"

# 获取索引2到5(不包括5)的子串
print(s[2:5])   # 'tho'

# 从开始到索引5
print(s[:5])    # 'Pytho'

# 从索引6到结束
print(s[6:])    # ' Programming'

# 获取整个字符串
print(s[:])     # 'Python Programming'

# 从索引2到倒数第2个字符
print(s[2:-2])  # 'thon Programmi'

步长切片

s = "0123456789"

# 每隔一个字符取一个
print(s[::2])    # '02468'

# 从索引1开始，每隔一个字符取一个
print(s[1::2])   # '13579'

# 反转字符串
print(s[::-1])   # '9876543210'

# 从索引8到3，步长为-2
print(s[8:2:-2]) # '864'

（三）字符串处理与操作

1.内置的字符串运算符

运算符	描述
+	字符串拼接，如“AB”+“123”结果为“AB123”
*	字符串复制，如“Tom”*3，结果为“TomTomTom”
in	判断是否为子串，如“H” in “Hello”结果为True； “h” in “Hello”结果为False

2.内置的字符串处理函数

函数	描述
len(s)	返回字符串x的长度
str(x)	将任意类型x转换为字符串类型
chr(x)	返回Unicode编码为x的字符
ord(x)	返回字符x的Unicode编码值
hen(x)	将整数x转换为十六进制数，并返回其小写字符形式
oct(x)	将整数x转换为八进制数，并返回其小写字符形式

3.内置的字符串处理方法

（1）字符串查找类方法

字符串查找类方法主要有find()、rfind()、index()、rindex()和count()等几种。

find()和rfind()方法分别用来查找一个字符串在另一个字符串指定范围（默认是整个字符串）首次和最后一次出现的位置，如果不存在则返回-1。

>>> s='bird,fish,monkey,rabbit'
>>> s.find('fish')
5
>>> s.find('b')
0
>>> s.rfind('b')
20
>>> s.find('tiger')
-1

index()和rindex()方法分别用来查找一个字符串在另一个字符串指定范围（默认是整个字符串）中首次和最后一次出现的位置，如果不存在则抛出异常。

>>> s='bird,fish,monkey,rabbit'
>>> s.index('bird')
0
>>> s.rindex('i')
21
>>> s.index('tiger')
ValueError: substring not found

count()方法用来返回一个字符串在另一个字符串中出现的次数，如果不存在则返回0。

>>> s='bird,fish,monkey,rabbit'
>>> s.count('bird')
1
>>> s.count('b')
3
>>> s.count('tiger')
0

（2）字符串分隔类方法

字符串分隔类方法有split()、rsplit()、partition()和rpartition()等。

split()和rsplit()方法分别用来指定字符为分隔符，从原字符串左端和右端开始将其分隔为多个字符串，并返回包含分隔结果的列表。

>>> s='bird,fish,monkey,rabbit'
>>> s.split(',')
['bird', 'fish', 'monkey', 'rabbit']
>>> s='I am a boy'
>>> s.split()
['I', 'am', 'a', 'boy']
>>> s.rsplit()
['I', 'am', 'a', 'boy']

split()和rsplit()方法可以指定最大分隔次数，当然并不是一定要分这么多次。

>>> s='南京 上海 天津 杭州 无锡'
>>> s.split(maxsplit=2)
['南京', '上海', '天津 杭州 无锡']
>>> s.rsplit(maxsplit=2)
['南京 上海 天津', '杭州', '无锡']

partition()和rpartition()方法分别用来以指定字符串为分隔符将原字符串分隔为3个部分，即分隔符之前的字符串、分隔符字符串和分隔符之后的字符串。如果指定的字符串不在原字符串中，则返回原字符串和两个空字符串。如果字符串中有多个分隔符，那么partition()方法按从左向右遇到的第一个分隔符来进行分隔，rpartition()方法按从右向左遇到的第一个分隔符来进行分隔。

>>> s='bird,fish,monkey,fish,rabbit'
>>> s.partition('fish')
('bird,', 'fish', ',monkey,fish,rabbit')
>>> s.rpartition('fish')
('bird,fish,monkey,', 'fish', ',rabbit')
>>> s.partition('tiger')                   #分隔符不存在，则返回原串浩然两个空串
('bird,fish,monkey,fish,rabbit', '', '')

（3）字符串拼接方法

join()方法是Python语言中的字符连接方法。

字符串的join()方法用来将列表中多个字符串进行连接，并在相邻两个字符串之间插入指定字符，返回新字符串。

>>> li=['apple','banana','pear','peach']
>>> ':'.join(li)
'apple:banana:pear:peach'
>>> '-'.join(li)
'apple-banana-pear-peach'

（4）大小写字符转换方法

Python语言中大小写字符转换方法有lower()、upper()、capitalize()、title()和swapcase()。

lower()方法用来将字符串转换为小写字符串；upper()方法用来将字符串转换为大写字符串；capitalize()方法用来将字符串首字母变为大写；title()方法用来讲讲字符串中每个单词的首字母变为大写；swapcase()方法用来将字符串中的字符大小写互换。以上字符转换方法会生成新的字符串，不对原字符串做任何修改。

>>> s='I have two big eyes.'
>>> s.lower()
'i have two big eyes.'
>>> s.upper()
'I HAVE TWO BIG EYES.'
>>> s.capitalize()
'I have two big eyes.'
>>> s.title()
'I Have Two Big Eyes.'
>>> s.swapcase()
'i HAVE TWO BIG EYES.'

（5）字符串替换方法

replace()方法用来替换字符串中指定字符或字符串，每次职能替换一个字符或子字符串，类似于Word、记事本等文本编辑器的查找和替换功能。该方法不修改原字符串，而是返回一个新字符串。

>>> s='你说我的小呀小苹果儿'
>>> s.replace('小','samll')
'你说我的samll呀samll苹果儿'

（6）删除字符串两端、右端或左端连续空白字符和指定字符方法

strip()、rstrip()、lstrip()方法

>>> s='   abc   '
>>> s.strip()         #删除两端空白字符
'abc'
>>> s.rstrip()       #删除右端空白字符
'   abc'
>>> s.lstrip()       #删除左端空白字符
'abc   '

>>> s='=====Mike====='
>>> s.strip('=')     #删除两端指定字符“=”
'Mike'
>>> s.rstrip('=')    #删除右端指定字符“=”
'=====Mike'
>>> s.lstrip('=')    #删除左端指定字符“=”
'Mike====='

（7）判断字符串是否以指定字符开始或结束方法

startswith()和endswith()方法

>>> s='Python程序设计.py'
>>> s.startswith('Python')      #检测字符串是否以“Python”开始
True
>>> s.endswith('py')            #检测字符串是否以“py”结束
True

（8）判断字符串类型方法

isupper()、islower()、isdigit()、isalnum()和isalpha()方法

>>> s='years'
>>> s.islower()            #判断字符串是否为全小写
True
>>> s='YEARS' 
>>> s.isupper()            #判断字符串是否为全大写
True
>>> s='20100405'
>>> s.isdigit()            #判断字符串是否为全数字
True
>>> s='He is 10 years old'
>>> s.replace(' ','')       #取出字符串中的空格
'Heis10yearsold'
>>> s.isalnum()             #判断字符串是否为数字或字母或汉字
False
>>> s.isalpha()             #判断字符串是否为权字母和汉字
False

（9）字符串排版方法

Python语言中字符串排版方法有4种：center()、ljust()、rjust()和zfill()。

>>> s='Hello Mike'
>>> s.center(30,'=')                 #字符串居中对齐，输出宽度为30，不足的以“=”填充
'==========Hello Mike=========='
>>> s.ljust(20,'*')                  #字符串居左对齐，输出宽度为30，不足的以“*”填充
'Hello Mike**********'
>>> s.rjust(20,'*')                  #字符串居右对齐，输出宽度为30，不足的以“*”填充
'**********Hello Mike'              
>>> s.zfill(20)                      #输出宽度为20，在字符串左侧以字符“0”填充
'0000000000Hello Mike'

（四）format()格式化方法

1.基本用法

format()方法是Python字符串的内置方法，用于格式化字符串：

"字符串{}".format(值)

2.位置参数

# 按顺序填充
"{} {}".format("Hello", "World")  # 'Hello World'

# 指定位置
"{1} {0}".format("World", "Hello")  # 'Hello World'

3.关键字参数

"{name}今年{age}岁".format(name="张三", age=25)  # '张三今年25岁'

4.数字格式化

格式化方式	说明	示例	输出
`{:.2f}`	保留2位小数	`"{:.2f}".format(3.14159)`	'3.14'
`{:+.2f}`	带符号保留2位小数	`"{:+.2f}".format(3.14159)`	'+3.14'
`{:.0f}`	不带小数	`"{:.0f}".format(3.14159)`	'3'
`{:0>2d}`	数字补零(填充左边, 宽度为2)	`"{:0>2d}".format(5)`	'05'
`{:x<4d}`	数字补x(填充右边, 宽度为4)	`"{:x<4d}".format(5)`	'5xxx'
`{:,}`	以逗号分隔的数字格式	`"{:,}".format(1000000)`	'1,000,000'
`{:.2%}`	百分比格式	`"{:.2%}".format(0.25)`	'25.00%'
`{:.2e}`	指数记法	`"{:.2e}".format(1000000)`	'1.00e+06'
`{:10d}`	右对齐(默认, 宽度为10)	`"{:10d}".format(13)`	' 13'
`{:<10d}`	左对齐(宽度为10)	`"{:<10d}".format(13)`	'13 '
`{:^10d}`	中间对齐(宽度为10)	`"{:^10d}".format(13)`	' 13 '

5.格式化字典

person = {'name': '李四', 'age': 30}
"{name}今年{age}岁".format(**person)  # '李四今年30岁'

6.格式化列表

numbers = [1, 2, 3]
"数字是: {0[0]}, {0[1]}, {0[2]}".format(numbers)  # '数字是: 1, 2, 3'

7.对象属性访问

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("王五", 40)
"{0.name}今年{0.age}岁".format(p)  # '王五今年40岁'

8.特殊格式化

# 进制转换
"{:b}".format(11)  # 二进制: '1011'
"{:d}".format(11)  # 十进制: '11'
"{:o}".format(11)  # 八进制: '13'
"{:x}".format(11)  # 十六进制(小写): 'b'
"{:#X}".format(11)  # 十六进制(大写, 带前缀): '0XB'

# 千位分隔符
"{:,}".format(123456789)  # '123,456,789'

9.动态参数

# 动态指定宽度和精度
"{0:{1}.{2}f}".format(3.1415926, 10, 4)  # '   3.1416'

10.f-string (Python 3.6+)

虽然不属于format()方法，但f-string提供了更简洁的格式化方式：

name = "赵六"
age = 35
f"{name}今年{age}岁"  # '赵六今年35岁'

五.bool（布尔类型）

（一）布尔值基础

Python中的布尔类型只有两个值：
- True - 表示真
- False - 表示假
注意首字母大写，true和false不是有效的布尔值

is_active = True
is_admin = False

（二）布尔类型转换

使用bool()函数可以将其他类型转换为布尔值
转换规则：
- 数字类型：0为False，非0为True
- 字符串：空字符串""为False，非空为True
- 列表/元组/字典等容器：空容器为False，非空为True
- None：转换为False

print(bool(0))     # False
print(bool(1))     # True
print(bool(""))    # False
print(bool(" "))   # True
print(bool([]))    # False
print(bool([1]))   # True
print(bool(None))  # False

（三）布尔运算

Python支持三种布尔运算：

and - 逻辑与
or - 逻辑或
not - 逻辑非

x = True
y = False

print(x and y)  # False
print(x or y)   # True
print(not x)    # False

（四）布尔运算的短路特性

and：如果第一个表达式为False，则不会计算第二个表达式
or：如果第一个表达式为True，则不会计算第二个表达式

def foo():
    print("foo called")
    return False

False and foo()  # foo()不会被调用
True or foo()    # foo()不会被调用

（五）布尔值与其他类型的比较

True实际上等于整数1
False实际上等于整数0

print(True == 1)    # True
print(False == 0)   # True
print(True + True)  # 2

六.bytes类型

（一）bytes类型基础

bytes是Python 3中引入的不可变字节序列类型，用于处理二进制数据。

特点：

不可变序列（类似元组）
每个元素是0-255之间的整数
前缀使用b表示

b = b'hello'  # 创建bytes对象
print(type(b))  # <class 'bytes'>
print(b[0])     # 104 (h的ASCII码)

（二）创建bytes对象

方法1：使用b前缀

b1 = b'Python'
b2 = b"\x50\x79\x74\x68\x6f\x6e"  # 十六进制表示

方法2：使用bytes()构造函数

# 从字符串创建(需指定编码)
b3 = bytes('Python', encoding='utf-8')

# 从可迭代对象创建
b4 = bytes([80, 121, 116, 104, 111, 110])  # ASCII码序列

# 创建指定长度的全0 bytes
b5 = bytes(10)  # b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

方法3：使用encode()方法

b6 = 'Python'.encode('utf-8')

（三）bytes的常用操作

基本操作

b = b'hello'

# 索引和切片
print(b[0])     # 104
print(b[1:3])   # b'el'

# 长度
print(len(b))   # 5

# 拼接
print(b + b' world')  # b'hello world'

# 重复
print(b * 2)  # b'hellohello'

查找和替换

b = b'hello world'

# 查找
print(b.find(b'll'))  # 2
print(b.count(b'l'))  # 3

# 替换(需创建新bytes对象)
new_b = b.replace(b'world', b'Python')

（四）bytes与str的转换

str → bytes (编码)

s = '你好'
b = s.encode('utf-8')  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

bytes → str (解码)

b = b'\xe4\xbd\xa0\xe5\xa5\xbd'
s = b.decode('utf-8')  # '你好'

（五）bytes的不可变性

bytes对象是不可变的，修改需要创建新对象：

b = b'hello'
# b[0] = 72  # 会报错 TypeError

# 正确修改方式
new_b = b[:1] + b'E' + b[2:]  # b'hEllo'

（六）bytes与bytearray

bytearray是bytes的可变版本：

ba = bytearray(b'hello')
ba[0] = 72  # 可以修改
print(ba)   # bytearray(b'Hello')

（七）实际应用场景

1.文件I/O：读写二进制文件

with open('image.jpg', 'rb') as f:
    data = f.read()

2.网络通信：发送/接收二进制数据

import socket
sock.send(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')

3.加密/哈希：处理二进制数据

import hashlib
hash_obj = hashlib.sha256(b'secret data')

4.协议处理：如解析二进制协议

（八）常用方法

方法	描述
`decode()`	解码为字符串
`hex()`	转换为十六进制字符串
`fromhex()`	从十六进制字符串创建bytes
`startswith()`	检查是否以指定bytes开头
`endswith()`	检查是否以指定bytes结尾
`split()`	分割bytes

# hex()示例
b = b'\xde\xad\xbe\xef'
print(b.hex())  # 'deadbeef'

# fromhex()示例
b = bytes.fromhex('deadbeef')

（九）注意事项

编码问题：转换str和bytes时务必明确编码方式
不可变性：bytes对象不可修改，需要修改时考虑使用bytearray
Python 2区别：Python 2中str就是bytes类型，Python 3做了明确区分
内存效率：bytes比str更节省内存，适合处理大量二进制数据