Python基本语法

Python P1课程电子书籍系列

一、数学运算符与函数

1.1 Python 3 运算符

1.1.1 Python 算术运算符

假设有2个变量num1 = 10,num2 = 20

运算符	描述	实例
+	加法	num1 + num2
-	减法	num1 - num2
*	乘法	num1 * num2
/	除法	num1 / num2
%	取余(取模)	num1 % num2
**	幂(次方)	num1 ** num2
//	取整除(向下取整)	num1 // num2

# 以下演示Python算术运算符加法操作
num1 = 10
num2 = 20
print(num1 + num2) # 输出结果为30

1.1.2 Python比较运算符

假设有2个变量num1 = 10,num2 = 20

运算符	描述	实例
==	等于	num1 == num 2
!=	不等于	num1 != num 2
>	大于	num1 > num 2
<	小于	num1 < num 2
>=	大于等于	num1 >= num 2
<=	小于等于	num1 <= num 2

# 以下演示Python比较运算符等于操作
# Python比较运算符返回均为 True/False
num1 = 10
num2 = 20
print(num1 == num2) # 输出结果为 False

1.1.3 Python 赋值运算符

假设有2个变量num1 = 10,num2 = 20

运算符	描述	实例
=	简单的赋值运算符	num1 = num 2
+=	加法赋值运算符	num1 += num 2
-=	减法赋值运算符	num1 -= num 2
*=	乘法赋值运算符	num1 *= num 2
/=	除法赋值运算符	num1 /= num 2
%=	取模赋值运算符	num1 %= num 2
**=	幂赋值运算符	num1 **= num 2
//=	取整除赋值运算符	num1 //= num 2
:=	海象运算符	更新ing

# 以下演示Python赋值运算符部分操作 
num1 = 10
num2 = 20
num1 += num2 # 等价于 num1 = num1 + num2
print(num1) # 输出结果为 30

1.1.4 Python 位运算符

待更新

1.1.5 Python 逻辑运算符

假设有2个变量num1 = 10,num2 = 20

运算符	逻辑表达式	描述+实例
and	x and y	布尔与，num1 and num2
or	x or y	布尔或，num1 or num2
not	not x	布尔非，not num1

# 以下演示Python逻辑运算符部分操作 
num1 = 10
num2 = 20
print(num1 and num2) # 输出结果为 20
print(num1 or num2) # 输出结果为 10
print(not num1) # 输出结果为 False

1.1.6 Python成员运算符

假设有2个变量num1 = [10, 20 , 30, 40],num2 = 20

运算符	描述	实例
in	是否在指定序列	num2 in num1
not in	是否不在指定序列	num2 not in num1

# 以下演示Python逻辑运算符部分操作 
num1 = [10, 20 , 30, 40]
num2 = 20
print(num2 in num1) # 输出结果为 True
print(num2 not in num1) # 输出结果为 False

1.1.7 Python身份运算符

假设有2个变量num1 = 10,num2 = 20

运算符	描述	实例
is	是否引自同一对象	num1 is num2
is not	是否引自不同对象	num1 is not num2

# 以下演示Python逻辑运算符部分操作 
num1 = [10, 20 , 30, 40]
num2 = 20
print(num1 is num2) # 输出结果为 False
print(num1 is not num2) # 输出结果为 True

1.2 Python 3 运算符优先级(持续更新ing)

运算符	描述
**	乘方(指数/幂)
*, /, //, %	乘，除，整除，取余
+, -	加， 减
in,not in, is,is not, <, <=, >, >=, !=, ==	比较运算，成员运算，身份运算
not	逻辑非
and	逻辑与
or	逻辑或
if -- else	条件表达式
更新ing	更新ing

1.3 Python 常用数学函数(持续更新ing)

数学函数	描述	实例
pow()	幂运算	pow(2, 3)
round()	四舍五入	round(3.5)
max()	选取最大值	max(2, 3, 5)
min()	选取最小值	min(2, 3, 5)
sum()	求和	详看下方例子
abs()	求绝对值	abs(-7.8)

除上述函数外，Python还提供math库，常用math库函数待总结

# sum()函数实例
num = [1, 2, 3, 4, 5]
print(sum(num)) # 返回num的总和 15

二、输入输出与变量

_程序3个要素

• 输入 input
• 处理 process
• 输出 output

2.1 input() 输入函数

_函数语法：

input([prompt])

_参数说明：

• prompt – 提示信息

_input()实例：

input("请输入你的名字")

2.2 print() 打印(输出)函数

_函数语法：

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False) # 有=为有默认参数

_参数说明：

• objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。
• end – 用来设定以什么结尾。默认值是换行符 \n
• file – 要写入的文件对象。
• flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

_print()实例：

print("奥兰熊", 20) # 有默认参数时，可以不填参

2.3 Python变量

_变量的定义：

命名规则	实例
变量名只能包含字母、数字和下划线	name_1
变量名必须以字母或下划线开头	_name/ name
变量名区分大小写	Name/name
变量名不能是Python关键字	if/for/else均是关键字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

import keyword
print(keyword.kwlist)
# 以下为Python3.9输出结果
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

_变量的赋值：

name = "奥兰熊" # 汉字、英文、符号在python中均为字符串，需使用双引号括起来
age = 20 # 数字不加双引号为整型，双引号为字符串

_变量的修改：

name = "奥兰熊"
name = "奥兰熊1" # 修改后变量name的值会改变成奥兰熊1

_变量的删除：

name = "奥兰熊"
del name # 变量删除后无法被调用
print(name) # 程序会报错

2.4 Python常见数据类型

数据类型	函数	描述	实例
int	int()	强制转换为整型	int(“4”)
float	float()	强制转换为浮点型	float(“3.5”)
string	str()	强制转换为字符串	str(4)
bool		True/ False

三、条件语句

3.1 分支结构

• 分支结构是编程中的一个基本概念，比如，如果今天下雨，我们就带伞；如果不下雨，我们就不带伞。
  • 想象一下，你面前有两条路，一条通向糖果店，一条通向图书馆。你只有在完成作业的情况下才会选择去糖果店，否则就去图书馆。这里的“完成作业”就是条件，根据这个条件，你会选择不同的路。
  • 在编程中，我们用分支结构来告诉计算机：如果条件满足，就走这条路（执行这段代码），否则就走那条路（执行那段代码）
  • 在Python中，我们用if（如果）来表示条件，else（否则）来表示条件不满足时的选择。

示例：

3.1.1 单分支结构 if

Python单分支伪代码：

if 条件表达式:
    代码块

Python单分支示例：

# 满足成绩大于等于90可以吃糖果
成绩 = int(input("请输入你的成绩："))
if 成绩>=90:
    print("去糖果店")

3.1.2 双分支结构 if - else

Python双分支伪代码：

if 条件表达式:
    代码块1
else:
    代码块2

Python双分支示例：

# 成绩大于等于90去糖果店，小于90去图书馆
成绩 = int(input("请输入你的成绩："))
if 成绩>=90:
    print("去糖果店")
else: # 这里是成绩<90
    print("去图书馆")

3.1.3 多分支结构 if - elif- else

Python多伪代码：

if 条件表达式1:
    代码块1
elif 条件表达式2:
    代码块2
elif 条件表达式3:
    代码块3
...
else:
    代码块N

Python多分支示例：

成绩 = int(input("请输入你的成绩："))
if 成绩>=90:   # 成绩>=90
    print("去甜品、水果、糖果店")
elif 成绩>=80: # 80<=成绩<90
    print("去甜品、水果店")
elif 成绩>=60: # 60<=成绩<80
    print("去甜品店")
else:         #  成绩<60
    print("去图书馆")

3.2 分支结构注意事项更新ing

3.2.1 Python分支语句条件的判断之None

• None代表一个特殊的数据类型，代表一个空对象，没有任何值
• 数值0，空字符串，None，空列表， 空元组， 空字典， 等都被定义为False
• 非空的信息，作为条件判断时均为True

四、进制

进制转换魔法咒语：权重

4.1 Python中的进制：简单易懂的解释

在Python中，进制是一种表示数字的方法，它包括我们常见的十进制、二进制、八进制和十六进制。

4.1.1 十进制（Decimal）：

• 这是我们平时生活中最常用的进制，它由0到9这10个数字组成。
• 比如说，123表示1个100，2个10和3个1。

4.1.2 二进制（Binary）：

• 二进制在电脑里非常重要，它只有两个数字：0和1。
• 类似于电灯开关，开就是1，关就是0。
• 二进制的每一位代表的是2的幂次，从右到左依次是2的0次方，2的1次方，2的2次方，以此类推。
• 举个例子，二进制的1101表示的是1个8（2的3次方），1个4（2的2次方），0个2（2的1次方）和1个1（2的0次方），合起来就是13。

4.1.3 八进制（Octal）：

• 八进制使用0到7这8个数字。
• 每一位代表的是8的幂次。
• 例如，八进制的127表示的是1个64（8的2次方），2个8（8的1次方）和7个1（8的0次方），合起来就是87。

4.1.4 十六进制（Hexadecimal）：

• 十六进制使用0到9这10个数字，以及A, B, C, D, E, F这6个字母，总共16个字符。
• 在十六进制中，A到F分别代表了10到15。
• 每一位代表的是16的幂次。
• 举个例子，十六进制的1A表示的是1个16和10个1，合起来就是26。

4.2 玩转数字魔法：Python中的进制转换大揭秘

常见的进制转换包括十进制转换为二进制、八进制和十六进制，以及这些进制转换为十进制。

4.2.1 十进制转二进制：

• 十进制转二进制是通过将十进制数除以2，并记录每次除法的余数来完成的。
• 每次除法的余数从下到上排列，就是对应的二进制数。
• 例子：将十进制的13转换为二进制。
  • 13 ÷ 2 = 6 余 1
  • 6 ÷ 2 = 3 余 0
  • 3 ÷ 2 = 1 余 1
  • 1 ÷ 2 = 0 余 1
  • 二进制数为1101。

4.2.2 十进制转八进制：

• 十进制转八进制是通过将十进制数除以8，并记录每次除法的余数来完成的。
• 每次除法的余数从下到上排列，就是对应的八进制数。
• 例子：将十进制的123转换为八进制。
  • 123 ÷ 8 = 15 余 3
  • 15 ÷ 8 = 1 余 7
  • 1 ÷ 8 = 0 余 1
  • 八进制数为173。

4.2.3 十进制转十六进制：

• 十进制转十六进制是通过将十进制数除以16，并记录每次除法的余数来完成的。
• 每次除法的余数从下到上排列，就是对应的十六进制数。如果余数大于9，则用字母A到F表示10到15。
• 例子：将十进制的255转换为十六进制。
  • 255 ÷ 16 = 15 余 15（F）
  • 15 ÷ 16 = 0 余 15（F）
  • 十六进制数为FF。

4.2.4 二进制、八进制、十六进制转十进制：

• 二进制、八进制或十六进制转十进制是通过将每个数字乘以其所在位置的进制基数（2、8或16），然后求和来完成的。
• 例子：将二进制的1101转换为十进制。
  • 1*2^3+ 1*2^2 + 0*2^1 + 1*2^0 = 8 + 4 + 0 + 1 = 13
• 例子：将八进制的127转换为十进制。
  • 1*8^2 + 2*8^1 + 7*8^0 = 64 + 16 + 7 = 87
• 例子：将十六进制的1A转换为十进制。
  • 1*16^1 + A*16^0 = 1*16 + 10*1 = 26

在Python中，我们可以使用内置函数来进行这些转换：

# 十进制转二进制
print(bin(13))  # 输出 '0b1101'
# 十进制转八进制
print(oct(123))  # 输出 '0o173'
# 十进制转十六进制
print(hex(255))  # 输出 '0xff'
# 二进制、八进制、十六进制转十进制
print(int('1101', 2))  # 输出 13
print(int('127', 8))   # 输出 87
print(int('1a', 16))   # 输出 26

4.3 小数点后的秘密：二进制、八进制、十六进制与十进制小数的巧妙变身

小数部分的进制转换稍微有些不同，因为它涉及到除法后的乘法。下面我将解释如何将小数部分从十进制转换为二进制、八进制和十六进制。

4.3.1 十进制小数转二进制

1. 乘以2取整法：
   • 将小数部分乘以2。
   • 记录乘法结果的整数部分，这就是二进制小数点后的第一位。
   • 取乘法结果的小数部分，重复步骤1，直到小数部分为0或达到所需的精度。
     例子：将十进制的小数部分0.625转换为二进制。

   0.625 × 2 = 1.25 → 整数部分为1
   0.25 × 2 = 0.5 → 整数部分为0
   0.5 × 2 = 1.0 → 整数部分为1，小数部分为0，停止
   

   结果为二进制的0.101。

4.3.2 十进制小数转八进制

1. 乘以8取整法：
   • 将小数部分乘以8。
   • 记录乘法结果的整数部分，这就是八进制小数点后的第一位。
   • 取乘法结果的小数部分，重复步骤1，直到小数部分为0或达到所需的精度。
     例子：将十进制的小数部分0.625转换为八进制。

   0.625 × 8 = 5.0 → 整数部分为5，小数部分为0，停止
   

   结果为八进制的0.5。

4.3.3 十进制小数转十六进制

1. 乘以16取整法：
   • 将小数部分乘以16。
   • 记录乘法结果的整数部分，这就是十六进制小数点后的第一位。如果整数部分大于9，用字母A到F表示10到15。
   • 取乘法结果的小数部分，重复步骤1，直到小数部分为0或达到所需的精度。
     例子：将十进制的小数部分0.625转换为十六进制。

   0.625 × 16 = 10.0 → 整数部分为A，小数部分为0，停止
   

   结果为十六进制的0.A。

☆☆☆小数部分的进制转换也可以反过来进行

4.3.4 二进制小数转十进制

二进制小数转换为十进制的步骤如下：

1. 每位乘以其权重：
   • 从小数点后第一位开始，每一位数字乘以2的负幂次，从-1开始递减（即第一位乘以2^-1，第二位乘以2^-2，以此类推）。
   • 将所有乘积相加，得到十进制的小数部分。
     例子：将二进制的0.101转换为十进制。

   1 × 2^-1 + 0 × 2^-2 + 1 × 2^-3 = 0.5 + 0 + 0.125 = 0.625
   

   结果为十进制的0.625。

4.3.5 八进制小数转十进制

八进制小数转换为十进制的步骤如下：

1. 每位乘以其权重：
   • 从小数点后第一位开始，每一位数字乘以8的负幂次，从-1开始递减（即第一位乘以8^-1，第二位乘以8^-2，以此类推）。
   • 将所有乘积相加，得到十进制的小数部分。
     例子：将八进制的0.5转换为十进制。

   5 × 8^-1 = 0.625
   

   结果为十进制的0.625。

4.3.6 十六进制小数转十进制

十六进制小数转换为十进制的步骤如下：

1. 每位乘以其权重：
   • 从小数点后第一位开始，每一位数字（或字母）乘以16的负幂次，从-1开始递减（即第一位乘以16^-1，第二位乘以16^-2，以此类推）。如果数字是A到F，则将其转换为10到15。
   • 将所有乘积相加，得到十进制的小数部分。
     例子：将十六进制的0.A转换为十进制。

   A × 16^-1 = 10 × 0.0625 = 0.625
   

   结果为十进制的0.625。

在Python中，可以使用内置函数float()将二进制、八进制或十六进制的小数部分转换为十进制的小数。例如：

# 二进制小数转十进制
print(float('0b101'))  # 输出 5.0
# 八进制小数转十进制
print(float('0o12'))   # 输出 10.0
# 十六进制小数转十进制
print(float('0x1A'))   # 输出 26.0

请注意： 这些例子展示了整数部分的转换，对于小数部分，您需要在字符串中包含小数点，例如'0b1.101'。

五、字符串与转义字符

5.1字符串概念

Python字符串是一系列字符的有序序列，可以用单引号、双引号或三引号括起来表示，是Python中常用的数据类型之一。

# 把多个字符放置在单引号、双引号或者三引号中间
s1 = """你好"""
s2 = "你好"
s3 = '你好'
# python中可以利用type()函数查看数据的类型
print(type(s1))
print(type(s2))
print(type(s3))

5.2字符串的字符序号

正序	0	1	2
字符串	你	好	吗
倒序	-3	-2	-1

5.3字符串的截取

5.3.1 字符串截取的语法

Python字符串的截取可以通过使用切片语法 string[start:stop:step] 实现

• start 是起始索引
• stop 是结束索引（不包括）
• step 是步长。

5.3.2 字符串截取基本种类

设变量s=‘今天的课程是Python字符串’

• 基本切片：string[start:stop]，string[start:]，string[:stop]

s[0:4] # 今天的课
s[4:] # 程是Python字符串
s[:6] #	今天的课程是

• 带步长的切片：string[start:stop:step]

s[0:8:2] # 今的程P

• 负索引切片：string[-start:-stop]

s[-4:-1] # n字符

• 完整字符串复制：string[:]

s[:] # 今天的课程是Python字符串

###5.4 字符串变量

5.4.1 字符串变量的本质

字符串变量是指存储字符串值的变量。在Python中，你可以使用变量来存储字符串，然后对其进行操作、传递给函数等。
当你使用变量时，你实际上是在内存中创建了一个存储特定值的位置，并为该位置分配了一个名称。Python中的变量是动态的，因此你可以在程序执行过程中更改变量所引用的值。

下面是一个简单的例子，演示了如何创建一个字符串变量并随后更改它的值：

# 创建一个字符串变量
my_string = "Hello"

# 打印初始的字符串变量的值
print(my_string)  # 输出: Hello

# 将字符串变量的值更改为另一个字符串
my_string = "World"

# 打印更改后的字符串变量的值
print(my_string)  # 输出: World

在这个示例中，我们首先创建了一个名为 my_string 的字符串变量，并将字符串 "Hello" 赋给它。然后，我们将该变量的值更改为字符串 "World"。这是因为Python中的变量是动态的，可以根据需要引用不同的值。
来个图示更加容易理解

5.4.2 查看字符串变量的地址id(object)

在Python中，id() 函数用于返回对象的标识值，这个标识值是该对象在内存中的地址。每个对象在内存中都有一个唯一的标识值，可以通过 id() 函数获取。

id() 函数的基本语法是：

id(object)

其中 object 是要获取标识值的对象。

下面是一个简单的示例，演示了如何使用 id() 函数：

my_string = "Hello"
print(id(my_string))  # 输出一个整数值，表示字符串对象 "Hello" 的内存地址

my_list = [1, 2, 3]
print(id(my_list))  # 输出一个整数值，表示列表对象 [1, 2, 3] 的内存地址

id() 函数对于调试和理解Python中对象的生命周期和内存管理很有用。但需要注意的是，同一对象在不同的时间或不同的Python解释器中，其标识值可能会不同。

5.5 字符串比大小

在Python中，字符串的比较基于字符的Unicode码点值，按照字典顺序进行。可以使用比较运算符（<, <=, >, >=, ==, !=）来比较字符串。下面是一些例子：

5.5.1. 按字母顺序比较：

print("apple" < "banana")  # 输出: True
print("apple" > "banana")  # 输出: False

5.5.2. 比较字符串长度（如果前面的字符相同）：

print("apple" < "applepie")  # 输出: True
print("apple" > "app")       # 输出: True

5.5.3. 大小写敏感比较（大写字母的Unicode值小于小写字母）：

print("Apple" < "apple")  # 输出: True
print("Apple" == "apple")  # 输出: False

5.5.4. 混合字符比较（按字符的Unicode值逐个比较）：

print("a1" < "a2")  # 输出: True
print("a10" < "a2")  # 输出: True

这些比较方式适用于Python中的字符串比较，确保按字典顺序对字符串进行排序和比较。

5.6 字符串操作符

在Python中，有一些常见的字符串操作符，它们允许你执行各种操作，例如拼接、重复、成员检查等。下面是一些常见的字符串操作符：

5.6.1 加法操作符 +：

• 用于拼接字符串。

str1 = "Hello"
str2 = "World"
result = str1 + str2
print(result)  # 输出: HelloWorld

5.6.2. 乘法操作符 *：

• 用于重复字符串。

str1 = "Hello"
result = str1 * 3
print(result)  # 输出: HelloHelloHello

5.6.3. 成员操作符 in 和 not in：

• 用于检查字符串是否包含某个子串。

my_string = "hello"
print("h" in my_string)     # 输出: True
print("world" not in my_string)  # 输出: True

5.6.4. 索引操作符 []：

• 用于访问字符串中的单个字符或子串。

my_string = "hello"
print(my_string[0])   # 输出: h
print(my_string[-1])  # 输出: o
print(my_string[1:4]) # 输出: ell

5.6.5. 切片操作符 [:]：

• 用于获取字符串的子串。

my_string = "hello"
print(my_string[:3])   # 输出: hel
print(my_string[2:])   # 输出: llo

这些操作符可以帮助你执行各种字符串操作，包括拼接、重复、检查成员、索引和切片等。

5.7 字符串修改与替换

在Python中，字符串是不可变（immutable）的数据类型，这意味着你不能直接修改字符串的内容。每次对字符串执行操作时，都会生成一个新的字符串对象，而原始字符串保持不变。
因此，如果你想修改字符串，通常的做法是创建一个新的字符串，其中包含所需的修改。这可以通过字符串的各种方法来实现，比如 replace()、split()、join() 等。

5.7.1 Replace()函数替换

在Python中，你可以使用 replace() 方法来进行字符串的替换。replace() 方法接受两个参数：要替换的子字符串和替换后的字符串。它返回一个新的字符串，其中所有出现的子字符串都被替换为指定的替换字符串。

replace() 是Python字符串对象的一个方法，用于替换字符串中的子串。它的基本语法是：

new_string = old_string.replace(old, new[, count])

其中：

• old_string 是要进行替换操作的原始字符串。
• old 是要被替换的子串。
• new 是用来替换的新子串。
• count 是可选参数，指定替换的次数。如果指定了 count，则只替换前 count 次出现的子串。如果不指定 count，则所有匹配的子串都会被替换。

replace() 方法会返回一个新的字符串，其中所有出现的 old 子串都被替换为 new 子串。

下面是一个简单的示例：

original_string = "Hello, World!World!World!"
new_string = original_string.replace("World", "Python")
print(new_string)  # 输出: Hello, Python!

在这个示例中，原始字符串 "Hello, World!" 中的 "World" 被替换为 "Python"，生成了新的字符串 "Hello, Python!"。原始字符串 original_string 并没有改变，而是生成了一个新的字符串 new_string。

5.7.2 旧式的字符串格式化替换

在Python中，你可以使用 % 符号来进行字符串格式化。这种方法被称为 “旧式的字符串格式化”，它使用 % 运算符将格式化字符串和要插入其中的值结合起来。

基本的语法是：format_string % values

• format_string 是包含格式化占位符的字符串，如 %s、%d、%f 等。
• values 是要插入到格式化字符串中的值，可以是单个值或一个元组。

下面是一个简单的示例，演示了如何使用 % 运算符进行字符串替换：

name = "Alice"
age = 30
height = 5.8

# 使用 %s、%d、%f 等占位符进行字符串格式化
formatted_string = "Name: %s, Age: %d, Height: %.1f" % (name, age, height)
print(formatted_string)

在这个示例中，%s、%d、%.1f 是格式化占位符，它们分别代表字符串、整数和带有一位小数的浮点数。这些占位符会被后面的值替换，而 % 运算符左边的字符串就是格式化字符串。

虽然 % 格式化字符串在Python中仍然有效，但通常推荐使用更现代的方法，如 str.format() 方法或 f-strings（在Python 3.6及以上版本可用）。这些方法更直观、灵活，并且提供了更多的功能。

5.7.3 format()函数替换

在Python中，format() 方法提供了一种更灵活和现代的方式来进行字符串格式化。它允许你在字符串中使用占位符，并使用 format() 方法将这些占位符替换为实际的值。

基本的语法是：

formatted_string = "format_string".format(arguments)

其中 format_string 是包含格式化占位符 {} 的字符串，arguments 是要插入到格式化字符串中的值。

下面是一个简单的示例，演示了如何使用 format() 方法进行字符串替换：

name = "Alice"
age = 30
height = 5.8

# 使用 format() 方法进行字符串格式化 按顺序
formatted_string = "Name: {}, Age: {}, Height: {}".format(name, age, height)
print(formatted_string)

在这个示例中，大括号 {} 是格式化占位符，它们将被 format() 方法的参数替换。format() 方法可以接受任意数量的参数，并按顺序将它们替换到格式化字符串中。你还可以使用具名参数来更清晰地指定要替换的值。

# 使用具名参数
formatted_string = "Name: {name}, Age: {age}, Height: {height}".format(name=name, age=age, height=height)
print(formatted_string)

# 按指定序号
formatted_string = "Name: {0}, Age: {1}, Height: {2}".format(name, age, height)
print(formatted_string)

使用 format() 方法进行字符串替换比使用 % 运算符更灵活和更易读，因此通常被推荐作为首选的字符串格式化方法。

5.7.4 f-strings替换

f-strings 是 Python 3.6 及更高版本引入的一种字符串格式化方法，它提供了一种简洁、直观的方式来在字符串中插入变量的值。

在 f-strings 中，你可以在字符串前面加上 f 或 F 前缀，然后在字符串中使用花括号 {} 将变量名放入其中。在字符串中的这些花括号内的表达式将会被计算，并用计算结果替换它们。

下面是一个示例：

name = "Alice"
age = 30

formatted_string = f"Name: {name}, Age: {age}"
print(formatted_string)

在这个示例中，f 前缀指示这是一个 f-string。在字符串中的花括号 {} 内，可以放置变量名或任何表达式，它们将被计算，并用计算结果替换。

f-strings 是一种强大而直观的字符串格式化方法，它使得代码更易读、更易维护。相对于以前的格式化方法（如 format() 方法和 % 格式化字符串），f-strings 更简洁，而且通常更快。

5.8 字符串常见函数

字符串在Python中有很多常用的函数和方法，这些函数和方法可以帮助你处理和操作字符串。以下是一些常用的字符串函数和方法：

5.8.1. len()：

返回字符串的长度（字符数）。

my_string = "Hello"
print(len(my_string))  # 输出: 5

5.8.2. upper() 和 lower()：

将字符串转换为大写或小写。

my_string = "Hello"
print(my_string.upper())  # 输出: HELLO
print(my_string.lower())  # 输出: hello

5.8.3. capitalize() 和 title()：

将字符串的第一个字符大写或每个单词的第一个字符大写。

my_string = "hello world"
print(my_string.capitalize())  # 输出: Hello world
print(my_string.title())       # 输出: Hello World

5.8.4. count(substring)：

返回字符串中子串出现的次数。

my_string = "hello world"
print(my_string.count("l"))  # 输出: 3

5.8.5. find(substring) 和 index(substring)：

返回子串在字符串中第一次出现的位置。

my_string = "hello world"
print(my_string.find("world"))  # 输出: 6
print(my_string.index("world")) # 输出: 6

5.8.6. replace(old, new)：

将字符串中的指定子串替换为新的子串。

my_string = "hello world"
new_string = my_string.replace("world", "Python")
print(new_string)  # 输出: hello Python

5.8.7. split(separator)：

将字符串分割成子串列表，分割符为指定的分隔符。

my_string = "hello world"
words = my_string.split(" ")
print(words)  # 输出: ['hello', 'world']

5.8.8. join(iterable)：

将字符串列表中的每个字符串连接起来，用指定的分隔符隔开。

words = ['hello', 'world']
my_string = " ".join(words)
print(my_string)  # 输出: hello world

在Python中，有一些函数可以用于判断字符串的特性，例如是否全部由数字组成、是否全部由字母组成等。以下是一些常用的字符串判断相关函数：

5.8.9. isalpha()：

如果字符串中的所有字符都是字母，则返回 True；否则返回 False。

my_string = "Hello"
print(my_string.isalpha())  # 输出: True

5.8.10. isdigit()：

如果字符串中的所有字符都是数字，则返回 True；否则返回 False。

my_string = "12345"
print(my_string.isdigit())  # 输出: True

5.8.11. isalnum()：

如果字符串中的所有字符都是字母或数字，则返回 True；否则返回 False。

my_string = "Hello123"
print(my_string.isalnum())  # 输出: True

5.8.12. islower() 和 isupper()：

分别判断字符串中的所有字符是否都是小写或大写。

my_string = "hello"
print(my_string.islower())  # 输出: True

my_string = "HELLO"
print(my_string.isupper())  # 输出: True

5.8.13. isspace()：

如果字符串中的所有字符都是空格，则返回 True；否则返回 False。

my_string = "   "
print(my_string.isspace())  # 输出: True

5.8.14. startswith(prefix) 和 endswith(suffix)：

判断字符串是否以指定的前缀或后缀开头或结尾。

my_string = "hello world"
print(my_string.startswith("hello"))  # 输出: True
print(my_string.endswith("world"))    # 输出: True

这些是Python中字符串常用的一些函数和方法，它们可以帮助你对字符串进行各种操作，包括大小写转换、查找子串、替换子串、分割字符串、字符串的特性，从而执行相应的逻辑操作等。

5.9 字符串常见应用top

5.9.1. 字符串去空格

在Python中，你可以使用 strip() 方法来去除字符串两端的空格（包括空格、制表符和换行符）。如果你只想去除字符串左边的空格，可以使用 lstrip() 方法；如果只想去除右边的空格，可以使用 rstrip() 方法。

以下是这些方法的使用示例：

5.9.1.1 strip() 方法：

my_string = "  hello world  "
stripped_string = my_string.strip()
print(stripped_string)  # 输出: "hello world"

5.9.1.2. lstrip() 方法：

my_string = "  hello world  "
left_stripped_string = my_string.lstrip()
print(left_stripped_string)  # 输出: "hello world  "

5.9.1.3. rstrip() 方法：

my_string = "  hello world  "
right_stripped_string = my_string.rstrip()
print(right_stripped_string)  # 输出: "  hello world"

这些方法可以帮助你去除字符串中的不需要的空格，从而清理字符串的格式。

5.10 常用转义字符

在Python中，转义字符用于表示一些特殊的字符，例如换行符、制表符等。以下是一些常见的Python转义字符：

5.10.1 表格展示常用转义字符

转义字符	描述
\n	换行符。它将光标移动到下一行的开头。
\t	制表符。它在输出时会产生一个水平制表符，通常相当于四个空格。
\\	反斜杠。用于表示反斜杠字符本身。
\' 和 \"	单引号和双引号。用于在字符串中包含引号。
\b	退格符。用于在输出中产生一个退格（删除）操作。
\r	回车符。它将光标移动到当前行的开头。

5.10.2 代码展示常用转义字符

5.10.2.1. \n：

换行符。它将光标移动到下一行的开头。

print("Hello\nWorld")
# 输出:
# Hello
# World

5.10.2.2. \t：

制表符。它在输出时会产生一个水平制表符，通常相当于四个空格。

print("Hello\tWorld")
# 输出: Hello    World

5.10.2.3. \\：

反斜杠。用于表示反斜杠字符本身。

print("C:\\Users\\")
# 输出: C:\Users\

5.10.2.4. \' 和 \"：

单引号和双引号。用于在字符串中包含引号。

print("She said, \"Hello!\"")
# 输出: She said, "Hello!"

5.10.2.5. \b：

退格符。用于在输出中产生一个退格（删除）操作。

print("Hello\bWorld")
# 输出: HellWorld

5.10.2.6. \r：

回车符。它将光标移动到当前行的开头。

print("Hello\rWorld")
# 输出: World

这些转义字符可以在字符串中使用，以表示字符串中的特殊含义。

六丶列表与元组

6.1 列表

6.1.1 什么是列表？

假设你有一个装水果的盒子，盒子里可以放苹果、香蕉、橙子等等各种水果。这个盒子就像Python中的“列表”，它可以装很多东西，而且这些东西可以是不同的类型，比如数字、文字甚至其他列表。

6.1.2 列表的特点

1. 可以装很多东西：就像你的水果盒子，Python的列表可以装很多元素（我们把里面的东西叫做元素）。
2. 元素有顺序：盒子里的东西是有顺序的，你可以按顺序一个一个取出来。比如第一个是苹果，第二个是香蕉，依次类推。
3. 可以随时增减元素：你可以往盒子里添加水果，也可以从盒子里拿走水果。

举个例子:

想象一个列表装着你喜欢的三种水果：苹果、香蕉和橙子。在Python中，你可以这样写：

fruits = ["苹果", "香蕉", "橙子"]

这个fruits就是一个列表，里面有三个水果。

6.1.3 如何使用列表？

• 取出某个元素：比如你想取出第一个水果，可以这样写：

  first_fruit = fruits[0]
  print(first_fruit)  # 输出：苹果
  

  注意，列表的第一个元素的索引是0，而不是1。

• 添加元素：如果你想在列表里再加一个水果，比如葡萄，可以这样写：

  fruits.append("葡萄")
  print(fruits)  # 输出：['苹果', '香蕉', '橙子', '葡萄']
  

• 删除元素：如果你想把香蕉从列表里删除，可以这样写：

  fruits.remove("香蕉")
  print(fruits)  # 输出：['苹果', '橙子', '葡萄']
  

总结:

• 列表就像一个可以装很多东西的盒子。
• 盒子里的东西是有顺序的，可以一个个取出来。
• 可以往列表里添加东西，也可以从列表里删除东西。
• 在Python中创建列表非常简单。你可以使用方括号 [] 来包含列表中的元素，并且元素之间用逗号 , 分隔。以下是几种创建列表的方式和一些示例：

6.1.4 创建空列表

你可以创建一个不包含任何元素的空列表：

empty_list = []
print(empty_list)  # 输出：[]

1.创建包含元素的列表

你可以在列表中添加任何类型的元素，包括数字、字符串、甚至其他列表。

numbers = [1, 2, 3, 4, 5]
fruits = ["苹果", "香蕉", "橙子"]
mixed = [1, "香蕉", 3.5, ["a", "b"]]

print(numbers)  # 输出：[1, 2, 3, 4, 5]
print(fruits)   # 输出：['苹果', '香蕉', '橙子']
print(mixed)    # 输出：[1, '香蕉', 3.5, ['a', 'b']]

2. 使用 list() 函数创建列表

你也可以使用 list() 函数将其他可迭代对象（如字符串、元组、范围对象等）转换为列表。

string_list = list("hello")
print(string_list)  # 输出：['h', 'e', 'l', 'l', 'o']

tuple_list = list((1, 2, 3))
print(tuple_list)  # 输出：[1, 2, 3]

range_list = list(range(5))
print(range_list)  # 输出：[0, 1, 2, 3, 4]

3.创建列表的常见方法

1. 直接用方括号创建：

my_list = [1, 2, 3, 4, 5]

2. 通过追加元素创建：

my_list = []
my_list.append(1)
my_list.append(2)
my_list.append(3)
print(my_list)  # 输出：[1, 2, 3]

3. 用列表推导式创建：

squares = [x**2 for x in range(1, 6)]
print(squares)  # 输出：[1, 4, 9, 16, 25]

总结:

• 创建空列表：empty_list = []
• 创建包含元素的列表：fruits = ["苹果", "香蕉", "橙子"]
• 使用 list() 函数：string_list = list("hello")
• 用列表推导式：squares = [x**2 for x in range(1, 6)]

在Python中，列表的分片（也叫切片）是一种非常强大和灵活的操作，允许你从列表中提取一部分元素。分片操作使用冒号 : 来表示起始位置和结束位置。下面是一些关于列表分片的基本概念和示例：

6.1.5 列表分片操作

1.语法

list[start:stop:step]

• start：分片开始的索引（包含）。
• stop：分片结束的索引（不包含）。
• step：步长（默认为1）。

2.示例

1. 从列表中获取一个子列表

fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 获取前两个元素
sub_list = fruits[0:2]
print(sub_list)  # 输出：['苹果', '香蕉']

# 获取索引为1到3的元素
sub_list = fruits[1:4]
print(sub_list)  # 输出：['香蕉', '橙子', '葡萄']

2. 使用默认参数

如果不指定 start 或 stop，则默认从列表开头或到列表结尾。

# 从第3个元素开始到最后
sub_list = fruits[2:]
print(sub_list)  # 输出：['橙子', '葡萄', '草莓']

# 从开头到第3个元素（不包含）
sub_list = fruits[:3]
print(sub_list)  # 输出：['苹果', '香蕉', '橙子']

3. 使用负索引

负索引用于从列表末尾开始计数。

# 获取最后两个元素
sub_list = fruits[-2:]
print(sub_list)  # 输出：['葡萄', '草莓']

# 获取从开头到倒数第二个元素
sub_list = fruits[:-1]
print(sub_list)  # 输出：['苹果', '香蕉', '橙子', '葡萄']

4. 使用步长

步长用于指定提取元素的间隔。

# 每隔一个元素提取一个
sub_list = fruits[::2]
print(sub_list)  # 输出：['苹果', '橙子', '草莓']

# 反转列表
reversed_list = fruits[::-1]
print(reversed_list)  # 输出：['草莓', '葡萄', '橙子', '香蕉', '苹果']

5. 混合使用

可以同时使用起始位置、结束位置和步长。

# 从索引1开始，每隔一个元素提取一个，到索引4（不包含）
sub_list = fruits[1:4:2]
print(sub_list)  # 输出：['香蕉', '葡萄']

总结：

• list[start:stop]：从索引 start 开始（包含），到索引 stop 结束（不包含），提取元素。
• list[start:]：从索引 start 开始到列表末尾，提取元素。
• list[:stop]：从列表开头到索引 stop（不包含），提取元素。
• list[::step]：从列表开头到列表末尾，每隔 step 个元素提取一个。
• list[start:stop:step]：从索引 start 开始到索引 stop 结束，每隔 step 个元素提取一个。
• 负索引和步长用于更灵活的分片操作，如反转列表。

列表切片和列表赋值在Python中是两种不同的操作。下面我们来详细介绍它们的区别和用法：

6.1.6 列表分片操作列表切片和赋值的区别

1.列表切片

列表切片用于从列表中提取一个子列表。切片操作不会修改原列表，而是返回一个新的列表。

示例

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 切片获取子列表
sub_list = fruits[1:4]
print(sub_list)  # 输出：['香蕉', '橙子', '葡萄']
print(fruits)    # 原列表保持不变，输出：['苹果', '香蕉', '橙子', '葡萄', '草莓']

2.列表赋值

列表赋值用于给列表中的某些元素重新赋值，可以是单个元素赋值，也可以是切片赋值。切片赋值可以改变原列表。

示例

1. 单个元素赋值

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 修改索引为1的元素
fruits[1] = "西瓜"
print(fruits)  # 输出：['苹果', '西瓜', '橙子', '葡萄', '草莓']

2. 切片赋值

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 将索引为1到3的部分替换为新的子列表
fruits[1:4] = ["西瓜", "芒果"]
print(fruits)  # 输出：['苹果', '西瓜', '芒果', '草莓']

在切片赋值时，新子列表的长度可以与被替换的部分不同：

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 将索引为1到3的部分替换为新的子列表，长度不同
fruits[1:3] = ["西瓜", "芒果", "蓝莓"]
print(fruits)  # 输出：['苹果', '西瓜', '芒果', '蓝莓', '葡萄', '草莓']

列表切片和赋值的主要区别：

1. 目的不同：

   • 切片：用于提取子列表，不改变原列表。
   • 赋值：用于修改列表中的元素，改变原列表。

2. 结果不同：

   • 切片：返回一个新的列表。
   • 赋值：直接修改原列表，不返回新列表。

3. 操作对象不同：

   • 切片：可以获取列表的部分元素，但不影响原列表。
   • 赋值：可以修改列表的部分或全部元素，影响原列表。

总结：

• 列表切片：用于获取列表的一部分，不修改原列表，语法如 sub_list = fruits[1:4]。
• 列表赋值：用于修改列表中的元素，改变原列表，语法如 fruits[1] = "西瓜" 或 fruits[1:4] = ["西瓜", "芒果"]。

6.1.7 二维列表

二维列表（也叫嵌套列表）是指列表中的每个元素也是一个列表。这种结构在处理矩阵、表格数据或其他需要行列表示的数据时非常有用。下面是一些关于二维列表的基本概念和示例：

1.创建二维列表

示例

# 创建一个3x3的二维列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(matrix)
# 输出：
# [
#     [1, 2, 3],
#     [4, 5, 6],
#     [7, 8, 9]
# ]

2. 访问二维列表的元素

你可以通过使用两个索引来访问二维列表中的元素，第一个索引用于指定行，第二个索引用于指定列。

示例

# 访问第一行第二列的元素
element = matrix[0][1]
print(element)  # 输出：2

# 访问第三行第三列的元素
element = matrix[2][2]
print(element)  # 输出：9

3.修改二维列表的元素

你可以通过指定行和列的索引来修改二维列表中的元素。
示例

# 修改第一行第二列的元素
matrix[0][1] = 10
print(matrix)
# 输出：
# [
#     [1, 10, 3],
#     [4, 5, 6],
#     [7, 8, 9]
# ]

4.遍历二维列表

你可以使用嵌套的循环来遍历二维列表中的所有元素。
示例

# 遍历并打印二维列表中的所有元素
for row in matrix:
    for element in row:
        print(element, end=' ')
    print()
# 输出：
# 1 10 3 
# 4 5 6 
# 7 8 9 

5.常见操作

1. 获取行

你可以通过简单的索引来获取二维列表中的一行。

# 获取第一行
first_row = matrix[0]
print(first_row)  # 输出：[1, 10, 3]

2. 获取列

要获取某一列，可以使用列表推导式。

# 获取第二列
second_column = [row[1] for row in matrix]
print(second_column)  # 输出：[10, 5, 8]

3. 初始化二维列表

可以使用嵌套的列表推导式来初始化一个特定大小的二维列表。

# 初始化一个3x3的零矩阵
zero_matrix = [[0 for _ in range(3)] for _ in range(3)]
print(zero_matrix)
# 输出：
# [
#     [0, 0, 0],
#     [0, 0, 0],
#     [0, 0, 0]
# ]

总结：

• 创建二维列表：通过将列表嵌套到另一个列表中来创建。
• 访问元素：使用matrix[row][col]访问特定位置的元素。
• 修改元素：使用matrix[row][col] = value修改特定位置的元素。
• 遍历元素：使用嵌套的循环来遍历所有元素。
• 获取行和列：直接通过索引获取行，使用列表推导式获取列。

6.1.8 列表运算符

在Python中，列表支持多种运算符，可以对列表进行各种操作。以下是一些常用的列表运算符及其使用示例：

1. 加法运算符（+）

加法运算符用于将两个列表连接成一个新的列表。

示例

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2
print(combined_list)  # 输出：[1, 2, 3, 4, 5, 6]

2. 乘法运算符（*）

乘法运算符用于将列表中的元素重复指定的次数，生成一个新的列表。

示例

list1 = [1, 2, 3]
repeated_list = list1 * 3
print(repeated_list)  # 输出：[1, 2, 3, 1, 2, 3, 1, 2, 3]

3. 成员运算符（in 和 not in）

成员运算符用于检查某个元素是否在列表中。

示例

list1 = [1, 2, 3, 4, 5]
print(3 in list1)     # 输出：True
print(6 in list1)     # 输出：False
print(6 not in list1) # 输出：True

4. 列表比较运算符

列表比较运算符用于比较两个列表。比较从第一个元素开始，逐一比较，如果有一个元素不相等，则返回比较结果。

示例

list1 = [1, 2, 3]
list2 = [1, 2, 4]
list3 = [1, 2, 3]

print(list1 == list2)  # 输出：False
print(list1 == list3)  # 输出：True
print(list1 < list2)   # 输出：True
print(list1 > list2)   # 输出：False

5. 列表切片运算符

列表切片运算符用于从列表中提取一部分元素，返回一个新的列表。

示例

list1 = [1, 2, 3, 4, 5]

# 获取索引为1到3的元素（不包括索引3）
sub_list = list1[1:3]
print(sub_list)  # 输出：[2, 3]

# 获取从索引2开始到列表结尾的元素
sub_list = list1[2:]
print(sub_list)  # 输出：[3, 4, 5]

# 获取从列表开头到索引3的元素（不包括索引3）
sub_list = list1[:3]
print(sub_list)  # 输出：[1, 2, 3]

# 反转列表
reversed_list = list1[::-1]
print(reversed_list)  # 输出：[5, 4, 3, 2, 1]

6. 列表索引运算符

列表索引运算符用于访问列表中的某个元素。

示例

list1 = [1, 2, 3, 4, 5]

# 获取索引为2的元素
element = list1[2]
print(element)  # 输出：3

# 获取倒数第一个元素
element = list1[-1]
print(element)  # 输出：5

总结：

• 加法运算符（+）：将两个列表连接成一个新列表。
• 乘法运算符（*）：将列表重复指定的次数，生成一个新列表。
• 成员运算符（in 和 not in）：检查某个元素是否在列表中。
• 列表比较运算符：比较两个列表，从第一个元素开始逐一比较。
• 列表切片运算符：从列表中提取一部分元素，返回一个新列表。
• 列表索引运算符：访问列表中的某个元素。

6.1.9 修改列表元素

在Python中，列表是可变的数据结构，这意味着你可以修改列表中的元素。你可以通过索引或切片来修改列表元素。下面是一些常用的方法和示例：

1. 通过索引修改单个元素

你可以使用索引直接访问并修改列表中的某个元素。

示例

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 修改索引为1的元素
fruits[1] = "西瓜"
print(fruits)  # 输出：['苹果', '西瓜', '橙子', '葡萄', '草莓']

2. 通过切片修改多个元素

你可以使用切片一次修改多个元素。切片可以用来替换列表中的一部分元素，新的子列表不需要和原子列表长度相同。

示例

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 将索引为1到3的部分替换为新的子列表
fruits[1:4] = ["西瓜", "芒果"]
print(fruits)  # 输出：['苹果', '西瓜', '芒果', '草莓']

# 长度不同的替换
fruits[1:3] = ["蓝莓", "樱桃", "梨"]
print(fruits)  # 输出：['苹果', '蓝莓', '樱桃', '梨', '草莓']

3. 使用循环修改元素

你可以使用循环来遍历列表并修改满足特定条件的元素。

示例

# 定义一个列表
numbers = [1, 2, 3, 4, 5]

# 将列表中的所有偶数加倍
for i in range(len(numbers)):
    if numbers[i] % 2 == 0:
        numbers[i] *= 2

print(numbers)  # 输出：[1, 4, 3, 8, 5]

4. 使用列表推导式修改元素

列表推导式可以用来创建一个新的列表，其中的元素基于原列表中的元素进行修改。

示例

# 定义一个列表
numbers = [1, 2, 3, 4, 5]

# 将列表中的所有偶数加倍
numbers = [x * 2 if x % 2 == 0 else x for x in numbers]
print(numbers)  # 输出：[1, 4, 3, 8, 5]

5. 修改嵌套列表的元素

对于二维列表（嵌套列表），你可以通过指定行索引和列索引来修改特定元素。

示例

# 定义一个二维列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 修改第二行第三列的元素
matrix[1][2] = 10
print(matrix)
# 输出：
# [
#     [1, 2, 3],
#     [4, 5, 10],
#     [7, 8, 9]
# ]

总结：

• 通过索引修改单个元素：list[index] = new_value
• 通过切片修改多个元素：list[start:stop] = new_values
• 使用循环修改元素：遍历列表并修改满足条件的元素。
• 使用列表推导式修改元素：生成一个新的列表，基于原列表的元素进行修改。
• 修改嵌套列表的元素：通过指定行和列的索引来修改特定元素。

6.1.10 Python可操作列表的函数

Python 提供了一系列内置函数和方法，用于操作列表。这些函数和方法使得列表的处理变得更加方便和高效。以下是一些常用的操作列表的函数和方法，以及它们的使用示例：

1. len()

返回列表中的元素个数。

示例

fruits = ["苹果", "香蕉", "橙子"]
print(len(fruits))  # 输出：3

2. append()

在列表末尾添加一个元素。

示例

fruits.append("草莓")
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '草莓']

3. extend()

将另一个列表的所有元素添加到当前列表的末尾。

示例

more_fruits = ["葡萄", "芒果"]
fruits.extend(more_fruits)
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '草莓', '葡萄', '芒果']

4. insert()

在指定位置插入一个元素。

示例

fruits.insert(1, "西瓜")
print(fruits)  # 输出：['苹果', '西瓜', '香蕉', '橙子', '草莓', '葡萄', '芒果']

5. remove()

移除列表中第一个匹配的元素。

示例

fruits.remove("香蕉")
print(fruits)  # 输出：['苹果', '西瓜', '橙子', '草莓', '葡萄', '芒果']

6. pop()

移除并返回指定位置的元素（默认为最后一个元素）。

示例

last_fruit = fruits.pop()
print(last_fruit)  # 输出：芒果
print(fruits)      # 输出：['苹果', '西瓜', '橙子', '草莓', '葡萄']

7. clear()

移除列表中的所有元素。

示例

fruits.clear()
print(fruits)  # 输出：[]

8. index()

返回第一个匹配元素的索引。

示例

fruits = ["苹果", "香蕉", "橙子", "香蕉"]
index = fruits.index("香蕉")
print(index)  # 输出：1

9. count()

返回指定元素在列表中出现的次数。

示例

count = fruits.count("香蕉")
print(count)  # 输出：2

10. sort()

对列表中的元素进行排序。

示例

numbers = [3, 1, 4, 1, 5, 9]
numbers.sort()
print(numbers)  # 输出：[1, 1, 3, 4, 5, 9]

11. reverse()

反转列表中的元素。

示例

numbers.reverse()
print(numbers)  # 输出：[9, 5, 4, 3, 1, 1]

12. copy()

返回列表的浅拷贝。

示例

fruits_copy = fruits.copy()
print(fruits_copy)  # 输出：['苹果', '香蕉', '橙子', '香蕉']

13. max()

返回列表中的最大值。

示例

numbers = [1, 2, 3, 4, 5]
print(max(numbers))  # 输出：5

14. min()

返回列表中的最小值。

示例

print(min(numbers))  # 输出：1

15. sum()

返回列表中所有元素的和。

示例

print(sum(numbers))  # 输出：15

16. sorted()

返回列表的排序副本，不改变原列表。

示例

numbers = [3, 1, 4, 1, 5, 9]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出：[1, 1, 3, 4, 5, 9]
print(numbers)         # 输出：[3, 1, 4, 1, 5, 9]

总结：

• 修改列表的函数：append(), extend(), insert(), remove(), pop(), clear(), sort(), reverse()
• 查询列表的函数：len(), index(), count(), max(), min(), sum()
• 复制列表的函数：copy(), sorted()

6.2 元组

元组（Tuple）是 Python 中的一种数据结构，类似于列表（List），但具有不可变性。换句话说，元组一旦创建，其内容就无法更改。元组使用圆括号 () 来定义，其中的元素可以是任何类型，包括数字、字符串、列表、元组等。以下是一个简单的元组示例：

# 定义一个元组
my_tuple = (1, 2, "three", [4, 5])

# 输出元组
print(my_tuple)

6.2.1 元组分片

元组分片（slicing）指的是从一个元组中提取出部分元素组成一个新的元组。你可以使用索引来指定要提取的部分，并使用冒号 : 来指定范围。元组分片的语法如下：

new_tuple = old_tuple[start:end:step]

• start：开始索引（包含），默认为0。
• end：结束索引（不包含），默认为元组的长度。
• step：步长（可选），默认为1。

下面是一些元组分片的示例：

1. 提取部分元素

my_tuple = (1, 2, 3, 4, 5)
# 提取第二个到第四个元素（不包含第四个）
new_tuple = my_tuple[1:4]
print(new_tuple)  # 输出：(2, 3, 4)

2. 指定步长

my_tuple = (1, 2, 3, 4, 5)
# 每隔两个元素提取一次
new_tuple = my_tuple[::2]
print(new_tuple)  # 输出：(1, 3, 5)

3. 使用负索引

my_tuple = (1, 2, 3, 4, 5)
# 从倒数第三个元素到倒数第一个元素（不包含最后一个）
new_tuple = my_tuple[-3:-1]
print(new_tuple)  # 输出：(3, 4)

4. 反转元组

my_tuple = (1, 2, 3, 4, 5)
# 反转元组
new_tuple = my_tuple[::-1]
print(new_tuple)  # 输出：(5, 4, 3, 2, 1)

5. 元组复制

my_tuple = (1, 2, 3, 4, 5)
# 创建一个元组的副本
new_tuple = my_tuple[:]
print(new_tuple)  # 输出：(1, 2, 3, 4, 5)

6. 仅指定开始索引

my_tuple = (1, 2, 3, 4, 5)
# 从第二个元素开始到末尾
new_tuple = my_tuple[1:]
print(new_tuple)  # 输出：(2, 3, 4, 5)

6.2.2 元组运算符

在Python中，元组支持多种运算符，可以对元组进行各种操作。以下是一些常用的元组运算符及其使用示例：

1. 加法运算符（+）

加法运算符用于将两个元组连接成一个新的元组。

示例

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # 输出：(1, 2, 3, 4, 5, 6)

2. 乘法运算符（*）

乘法运算符用于将元组中的元素重复指定的次数，生成一个新的元组。

示例

tuple1 = (1, 2, 3)
repeated_tuple = tuple1 * 3
print(repeated_tuple)  # 输出：(1, 2, 3, 1, 2, 3, 1, 2, 3)

3. 成员运算符（in 和 not in）

成员运算符用于检查某个元素是否在元组中。

示例

tuple1 = (1, 2, 3, 4, 5)
print(3 in tuple1)     # 输出：True
print(6 in tuple1)     # 输出：False
print(6 not in tuple1) # 输出：True

4. 元组比较运算符

元组比较运算符用于比较两个元组。比较从第一个元素开始，逐一比较，如果有一个元素不相等，则返回比较结果。

示例

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
tuple3 = (1, 2, 3)

print(tuple1 == tuple2)  # 输出：False
print(tuple1 == tuple3)  # 输出：True
print(tuple1 < tuple2)   # 输出：True
print(tuple1 > tuple2)   # 输出：False

总结

• 加法运算符（+）：将两个元组连接成一个新元组。
• 乘法运算符（*）：将元组中的元素重复指定的次数，生成一个新元组。
• 成员运算符（in 和 not in）：检查某个元素是否在元组中。
• 元组比较运算符：比较两个元组，从第一个元素开始逐一比较。

6.2.3 Python自带与元组相关函数

在Python中，有许多内置函数可以与元组一起使用。这些函数使得操作元组更加方便和高效。以下是一些常见的与元组相关的内置函数及其使用示例：

1. len()

len() 函数返回元组中的元素个数。

示例

my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple))  # 输出：5

2. max()

max() 函数返回元组中的最大值。

示例

my_tuple = (1, 2, 3, 4, 5)
print(max(my_tuple))  # 输出：5

3. min()

min() 函数返回元组中的最小值。

示例

my_tuple = (1, 2, 3, 4, 5)
print(min(my_tuple))  # 输出：1

4. sum()

sum() 函数返回元组中所有元素的和。注意，元组中的所有元素必须是数值类型。

示例

my_tuple = (1, 2, 3, 4, 5)
print(sum(my_tuple))  # 输出：15

5. any()

any() 函数检查元组中是否有任何元素为 True。如果有任意一个元素为 True，则返回 True，否则返回 False。

示例

my_tuple = (0, 1, 2, 3)
print(any(my_tuple))  # 输出：True

6. all()

all() 函数检查元组中的所有元素是否都为 True。如果所有元素都为 True，则返回 True，否则返回 False。

示例

my_tuple = (1, 2, 3, 4)
print(all(my_tuple))  # 输出：True

7. sorted()

sorted() 函数返回元组中元素排序后的新列表。原元组保持不变。

示例

my_tuple = (3, 1, 4, 1, 5)
sorted_tuple = sorted(my_tuple)
print(sorted_tuple)  # 输出：[1, 1, 3, 4, 5]

8. tuple()

tuple() 函数将一个可迭代对象转换为元组。

示例

my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出：(1, 2, 3)

9. enumerate()

enumerate() 函数用于遍历元组，同时获取元素的索引和值。

示例

my_tuple = ('a', 'b', 'c')
for index, value in enumerate(my_tuple):
    print(index, value)
# 输出：
# 0 a
# 1 b
# 2 c

10. zip()

zip() 函数将多个可迭代对象（例如多个元组）打包成一个元组的迭代器。

示例

tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
zipped = zip(tuple1, tuple2)
print(list(zipped))  # 输出：[(1, 'a'), (2, 'b'), (3, 'c')]

总结

这些内置函数使得操作元组更加便捷和高效，涵盖了从计算长度、查找最大最小值到排序和遍历的各种需求。

6.2.4 元组自带函数

在Python中，元组（tuple）是一种不可变的数据结构，因此与列表（list）相比，元组自带的方法非常少。元组的内置方法只有两个：

1. count()

count() 方法用于统计元组中某个元素出现的次数。

示例

my_tuple = (1, 2, 3, 2, 4, 2, 5)
count_of_twos = my_tuple.count(2)
print(count_of_twos)  # 输出：3

2. index()

index() 方法用于在元组中查找某个元素第一次出现的位置（索引）。如果该元素不在元组中，则会引发 ValueError 异常。

示例

my_tuple = (1, 2, 3, 4, 5)
index_of_four = my_tuple.index(4)
print(index_of_four)  # 输出：3

# 如果查找不存在的元素
# my_tuple.index(6)  # 这将引发 ValueError: tuple.index(x): x not in tuple

总结：

由于元组的不可变性，它们自带的方法非常有限，只有 count() 和 index() 两个方法。更多的操作通常需要依赖于Python的内置函数（如 len()、max() 等）来实现。元组主要用于存储一组不可变的数据，例如作为函数的返回值、作为字典的键等。
如果需要对元组进行其他操作，可以借助内置函数或将元组转换为列表进行操作，然后再转换回元组。

6.2.5 元组和列表的转换

在Python中，元组和列表是两种常见的数据结构，有时我们需要在它们之间进行转换。下面介绍如何进行这种转换：

1. 列表转换为元组

可以使用 tuple() 函数将一个列表转换为元组。

示例

my_list = [1, 2, 3, 4, 5]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出：(1, 2, 3, 4, 5)

2. 元组转换为列表

可以使用 list() 函数将一个元组转换为列表。

示例

my_tuple = (1, 2, 3, 4, 5)
my_list = list(my_tuple)
print(my_list)  # 输出：[1, 2, 3, 4, 5]

应用场景

转换列表和元组在某些情况下非常有用。例如：

• 当你需要一个不可变的数据结构时，可以将列表转换为元组。
• 当你需要修改一个不可变的数据结构时，可以将元组转换为列表，进行修改后再转换回元组。

具体示例

1.修改元组中的元素

因为元组是不可变的，如果你需要修改元组中的元素，可以将其转换为列表，进行修改后再转换回元组。

my_tuple = (1, 2, 3, 4, 5)

# 将元组转换为列表
temp_list = list(my_tuple)

# 修改列表中的元素
temp_list[2] = 99

# 将列表转换回元组
my_tuple = tuple(temp_list)

print(my_tuple)  # 输出：(1, 2, 99, 4, 5)

2.用于函数返回多个值

在函数返回多个值时，通常会使用元组。如果你需要对返回的结果进行修改，可以将其转换为列表。

def return_multiple_values():
    return (1, 2, 3)

# 获取函数返回的元组
result = return_multiple_values()

# 将元组转换为列表
result_list = list(result)

# 修改列表中的元素
result_list.append(4)

# 将列表转换回元组
result = tuple(result_list)

print(result)  # 输出：(1, 2, 3, 4)

总结

• 列表转换为元组：使用 tuple() 函数。
• 元组转换为列表：使用 list() 函数。

七、Python for循环

7.1 什么是for循环

概念：for循环是编程中的一种控制结构，用于重复执行一段代码，直到达到特定条件。它是一种迭代语句，通常用于遍历数据结构（如列表、元组、字典和字符串）中的元素。

7.1.1 for循环基本语法

# for循环基本结构
for variable in iterable:
    # 执行代码块

• variable：在每次迭代中表示当前元素的变量。
• iterable：要迭代的对象，例如列表、字符串、元组或字典。
• 缩进的代码块是每次迭代时执行的代码。

7.1.2for循环4种基本用法

• 1.遍历列表：逐个访问列表中的元素。

# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
# 输出
apple
banana
cherry

• 2.遍历字符串：逐个访问字符串中的字符。

# 遍历字符串
for char in "hello":
    print(char)
# 输出
h
e
l
l
o

• 3.遍历元组：逐个访问元组中的元素。

# 遍历元组
numbers = (1, 2, 3)
for number in numbers:
    print(number)
# 输出
1
2
3

• 4.遍历字典：逐个访问字典中的键或键值对。

# 遍历字典
student_scores = {"Alice": 85, "Bob": 92, "Charlie": 78}
for student in student_scores:
    print(student, student_scores[student])
# 输出
Alice 85
Bob 92
Charlie 78

7.2 内置函数与for循环

7.2.1 range()函数

概念：range 函数是Python中一个非常有用的内置函数，用于生成一系列数字，通常用于在for循环中进行迭代。range 函数可以接受一个、两个或三个参数，根据提供的参数生成一个数字序列。
range()语法结构：

range(stop)
range(start, stop, step)

• start: 序列的起始值（包含在内）。如果省略，默认为0。
• stop: 序列的终止值（不包含在内）。
• step: 序列中数字之间的间隔。默认为1。如果提供负值，序列将以递减的方式生成。

# range(stop)示例
for i in range(5):
    print(i)

# range(start, stop)示例
for i in range(1, 5):
    print(i)

# range(start, stop, step)示例
# 步长为正
for i in range(1, 10, 2):
    print(i)

# range(start, stop, step)示例
# 步长为负
for i in range(10, 1, -2):
    print(i)

range()常见用法：

• 1.遍历\迭代

for i in range(5):
    print(i)

range()有趣的用法场景：

• 1.结合len()使用

# range 生成的序列是一个 range 对象，可以将其转换为列表查看完整序列。
numbers = list(range(5))
print(numbers)

7.2.2 len()函数

概念：len 函数是Python中的一个内置函数，用于返回对象（如列表、字符串、元组、字典、集合等）中元素的数量。
len()语法结构：

len(s)

• s：可以是序列（如字符串、列表、元组、范围对象）或集合（如字典、集合等）。

len()常见用法：

• 1. 计算字符串长度

string = "hello"
length = len(string)
print(length)

• 2. 计算列表长度

fruits = ["apple", "banana", "cherry"]
length = len(fruits)
print(length)

• 3. 计算元组长度

numbers = (1, 2, 3, 4)
length = len(numbers)
print(length)

• 4. 计算字典长度

student_scores = {"Alice": 85, "Bob": 92, "Charlie": 78}
length = len(student_scores)
print(length)

• 5. 计算集合长度

unique_numbers = {1, 2, 3, 4, 5}
length = len(unique_numbers)
print(length)

• 6. 计算范围对象长度

range_obj = range(10)
length = len(range_obj)
print(length)

len()有趣的用法场景：

• 1.搭配if语句使用

# 使用 len 函数检查列表是否包含元素。
items = []
if len(items) == 0:
    print("The list is empty")
else:
    print("The list is not empty")

# 根据字符串长度执行操作。
password = "mypassword123"
if len(password) < 8:
    print("Password is too short")
else:
    print("Password is long enough")

• 2.搭配for循环语句和range()使用

# 结合 len 和 range 函数遍历列表的索引。
fruits = ["apple", "banana", "cherry"]
for i in range(len(fruits)):
    print(f"Index {i}: {fruits[i]}")

7.2.3 zip()函数

概念：zip() 是Python内置函数之一，用于将多个可迭代对象（如列表、元组等）中对应的元素打包成一个元组，并返回一个由这些元组组成的迭代器。它常用于同时迭代多个序列，可以简单理解为将多个序列“拉链”在一起。

zip()语法结构：

zip(iterable1, iterable2, ...)

• iterable1, iterable2, …：可以是一个或多个可迭代对象，如列表、元组、字符串等。

zip()常见用法：

• 1. 合并两个列表

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
# 转换为列表查看结果
print(list(zipped))

• 2. 合并三个列表

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = ['!', '@', '#']
zipped = zip(list1, list2, list3)
# 转换为列表查看结果
print(list(zipped))

• 3. 迭代并打印

fruits = ['apple', 'banana', 'cherry']
counts = [10, 20, 15]
for fruit, count in zip(fruits, counts):
    print(f"There are {count} {fruit}s")

• 4. 解压缩

# 使用 zip() 可以方便地进行序列的解压缩。
pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
numbers, letters = zip(*pairs)
print(numbers)
print(letters)

zip()注意事项：

• 当传入的可迭代对象长度不同时，zip() 将会以最短的对象为准进行迭代。多余的元素将被忽略。

list1 = [1, 2, 3]
list2 = ['a', 'b']
zipped = zip(list1, list2)
# 转换为列表查看结果
print(list(zipped))

zip()有趣的用法场景：

• 合并多个序列进行并行迭代。
• 创建字典时同时迭代键和值。
• 进行数据的同时处理和操作，如计算、过滤等。

7.2.4 enumerate()函数

概念：enumerate() 函数是 Python 中一个非常有用的内置函数，用于将一个可迭代对象（如列表、元组、字符串等）组合为一个索引序列，同时列出数据和数据下标（索引）。这个函数返回一个枚举对象，可以用于在循环中获取索引及其对应的值。

enumerate()语法结构：

enumerate(iterable, start=0)

• iterable：必需，表示要枚举的可迭代对象，如列表、元组、字符串等。
• start：可选，表示起始索引，默认为 0。

enumerate()常见用法：

• 1. 基本用法

fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
    print(index, fruit)

• 2. 指定起始索引

fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)

enumerate()有趣的用法场景：

• 遍历并同时获取索引和元素值：适用于需要在循环中处理列表或其他可迭代对象元素时，同时需要索引信息的场景。
• 批量处理数据：当需要同时处理多个列表或数据结构的对应元素时，使用 enumerate() 可以简化代码并提高可读性。

enumerate()注意事项：

• enumerate() 返回的对象是一个迭代器（iterator），它生成一系列的元组，每个元组包含一个索引和对应的元素。
• 可以通过 list() 函数将枚举对象转换为列表，以便获取所有的索引和元素对。

7.3 列表生成式与for循环

7.3.1 什么是列表生成式

概念：列表生成式是一种用简洁语法创建列表的方式，它可以在一行代码中根据一个可迭代对象生成一个新的列表。
列表生成式基本语法：

[expression for item in iterable if condition]

• expression: 可以是任意操作，用来生成列表的元素。
• item: 可以是变量名，表示可迭代对象中的每个元素。
• iterable: 可以是列表、元组、字符串等可迭代对象。
• condition (optional): 可选的条件，用于过滤元素。

7.3.2 列表生成式与for循环实例

列表生成式与for循环实例1

# 生成一个列表，包含原始列表中每个元素的平方：
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares)

列表生成式与for循环实例2

# 使用条件过滤元素，生成一个列表，仅包含偶数的平方：
numbers = [1, 2, 3, 4, 5]
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(even_squares)

7.4 循环嵌套

概念：循环的嵌套是指在一个循环内部包含另一个或多个循环结构的情况。在编程中，循环的嵌套是一种常见的技术，用于处理复杂的迭代和数据结构。

7.4.1 嵌套 for 循环

最常见的嵌套循环是使用两个 for 循环。这种结构可以遍历二维数据结构（如列表的列表），或者进行组合操作。

# 二维列表的遍历
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for row in matrix:
    for element in row:
        print(element, end=' ')
    print()

# 输出
1 2 3 
4 5 6 
7 8 9 

7.4.2 嵌套 while 循环

除了 for 循环，while 循环也可以嵌套使用。这种情况通常用于需要根据条件重复执行一段代码块的场景。

# 嵌套的 while 循环
row = 1
while row <= 3:
    col = 1
    while col <= 3:
        print(f"({row}, {col})", end=' ')
        col += 1
    print()
    row += 1

# 输出
(1, 1) (1, 2) (1, 3) 
(2, 1) (2, 2) (2, 3) 
(3, 1) (3, 2) (3, 3) 

嵌套循环应用场景：

• 处理多维数据结构：例如矩阵、二维数组等。
• 组合和排列操作：例如生成排列组合、查找匹配等。
• 模式生成：例如生成金字塔、菱形等形状的图案。

注意事项：

• 性能考虑：嵌套循环的效率取决于内外循环的数量和循环体内的操作复杂度。在处理大数据量时，需要注意避免过深的嵌套。
• 代码可读性：尽量保持嵌套循环的代码结构清晰简洁，避免嵌套层级过深，可以通过函数或其他结构来分解复杂的嵌套逻辑。

7.5 for循环小案例

# 生成和打印菱形图案
size = 7  # 菱形的大小，必须是奇数

# 上半部分菱形
for i in range(size//2 + 1):
    for j in range(size//2 - i):
        print(" ", end="")
    for j in range(2*i + 1):
        print("*", end="")
    print()

# 下半部分菱形
for i in range(size//2):
    for j in range(i + 1):
        print(" ", end="")
    for j in range(size - 2*i - 1):
        print("*", end="")
    print()

八丶随机数

8.1 随机数介绍

概念：在Python中，生成随机数可以通过random模块完成。这个模块提供了许多函数来生成各种类型的随机数，包括整数、浮点数、以及从序列中随机选择元素。下面是一些常用的random模块的函数及其用法：

8.1.1 random.seed()

概念：random.seed(a=None, version=2) 是 random 模块中的一个方法，用于初始化随机数生成器。通过设置种子，可以控制随机数生成器的初始状态，使得生成的随机数序列可以被复现。具体解释如下：

import random
random.seed(42, version=1)
print(random.random())  # 每次运行结果相同，但与version=2的结果不同

参数说明:

• a：种子值，可以是任意可哈希对象。如果未提供或为 None，则使用当前系统时间或系统状态作为种子。
• version：指定种子的版本。Python 3.2 之后添加了 version 参数。
  • version=2（默认）：使用较新的种子生成算法，基于二进制数据生成种子。
  • version=1：使用较旧的种子生成算法，兼容早期版本的Python。

8.1.2 random.random()

概念：在 Python 中，random.random() 是一个用于生成随机浮点数的函数。它会返回一个范围在 [0.0,1.0)之间的随机浮点数，即大于等于 0.0 并且小于 1.0。

import random

# 生成一个随机浮点数
random_number = random.random()
print(random_number)

8.1.3 random.uniform()

概念：random.uniform(a, b) 函数用于生成一个在 [a, b] 范围内的随机浮点数。如果 a 大于 b，则 uniform 会在 [b, a] 范围内生成一个随机浮点数。

import random

# 生成一个在 [1.0, 10.0] 范围内的随机浮点数
random_float_1 = random.uniform(1.0, 10.0)
print(random_float_1)

# 生成一个在 [-5.0, 5.0] 范围内的随机浮点数
random_float_2 = random.uniform(-5.0, 5.0)
print(random_float_2)

# 生成一个在 [10.0, 1.0] 范围内的随机浮点数（相当于 [1.0, 10.0]）
random_float_3 = random.uniform(10.0, 1.0)
print(random_float_3)

参数详细说明：

• a (number): 生成随机数的下界，可以是整数或浮点数。如果 a 大于 b，它将成为上界。
• b (number): 生成随机数的上界，可以是整数或浮点数。如果 b 小于 a, 它将成为下界。

8.1.4 random.randint()

概念：random.randint(a, b) 函数用于生成一个在 [a, b] 范围内的随机整数。它包括了 a 和 b 这两个端点值。这个函数的两个参数都是整数。

import random

# 生成一个在 [1, 10] 范围内的随机整数
random_int_1 = random.randint(1, 10)
print(f"随机整数在 [1, 10]: {random_int_1}")

# 生成一个在 [-5, 5] 范围内的随机整数
random_int_2 = random.randint(-5, 5)
print(f"随机整数在 [-5, 5]: {random_int_2}")

# 生成一个在 [0, 0] 范围内的随机整数（结果只能是 0）
random_int_3 = random.randint(0, 0)
print(f"随机整数在 [0, 0]: {random_int_3}")

参数说明：

• a (int): 生成随机整数的下界（包括在内）。
• b (int): 生成随机整数的上界（包括在内）。

8.1.5 random.randrange()

概念：random.randrange(start, stop[, step]) 是 Python 中用于生成指定范围内随机整数的函数。

random.randrange(start, stop[, step])

参数说明：

• start：范围的起始值（包含在内）。
• stop：范围的结束值（不包含在内）。
• step（可选）：值之间的步长。默认为1

# 基本用法
import random

# 生成一个在范围 [0, 10) 内的随机整数
num = random.randrange(0, 10)
print(num)

# 指定步长
import random

# 生成一个在范围 [0, 10) 内、步长为2的随机整数
num = random.randrange(0, 10, 2)
print(num)

# 使用负数范围和步长
import random

# 生成一个在范围 [-10, -1) 内、步长为-2的随机整数
num = random.randrange(-10, -1, -2)
print(num)

注意事项：

• 如果未指定 step，默认为1。
• stop 参数是不包含在范围内的，即生成的随机整数不会等于 stop。
• 如果 start 等于 stop，会引发 ValueError，因为在这个范围内无法生成有效的整数。

8.1.6 random.choice()

概念：random.choice(seq) 是 Python 中用于从非空序列 seq 中随机选择一个元素的函数。

random.choice(seq)

参数说明：

• seq：表示一个非空的序列，可以是列表、元组或其他可迭代对象。

# 使用列表
import random

# 从列表中随机选择一个元素
my_list = ['apple', 'banana', 'cherry', 'date']
chosen_fruit = random.choice(my_list)
print(chosen_fruit)

# 使用元组
import random

# 从元组中随机选择一个元素
my_tuple = ('apple', 'banana', 'cherry', 'date')
chosen_fruit = random.choice(my_tuple)
print(chosen_fruit)

``注意事项：```

• 如果 seq 是空序列（即没有元素），则会引发 IndexError 异常。
• random.choice() 函数适用于需要从一个集合中随机挑选一个元素的情况，比如随机选取一个单词、随机选择一个答案等等。

8.1.7 random.choices()

概念：random.choices(population, weights=None, *, cum_weights=None, k=1) 是 Python 中用于从指定的总体（population）中以指定权重进行有放回抽样的函数

random.choices(population, weights=None, *, cum_weights=None, k=1)

参数说明：

• population：表示总体，可以是一个序列（如列表或元组），包含了可以被选择的元素。
• weights：是一个可选参数，用于指定每个元素被选择的概率。如果未指定，则所有元素被视为具有相等的概率。
• cum_weights：也是一个可选参数，与 weights 相同，但它是累积权重（cumulative weights），这意味着每个元素的选择概率是由其在累积权重列表中的值决定的。如果同时指定了 weights 和 cum_weights，则会引发 TypeError 异常。
• k：表示要返回的元素个数（即抽样次数），默认值为 1。

# 使用默认权重进行抽样
import random

# 从列表中随机选择一个元素，每个元素的选择概率相等
population = ['apple', 'banana', 'cherry', 'date']
chosen_fruit = random.choices(population)
print(chosen_fruit)

# 使用权重进行抽样
import random

# 从列表中随机选择一个元素，每个元素的选择概率不同
population = ['apple', 'banana', 'cherry', 'date']
weights = [0.1, 0.2, 0.3, 0.4]  # 对应每个元素的选择概率
chosen_fruit = random.choices(population, weights, k=2)
print(chosen_fruit)

# 使用累计权重进行抽样
import random

# 从列表中随机选择一个元素，使用累积权重
population = ['apple', 'banana', 'cherry', 'date']
cum_weights = [0.1, 0.3, 0.6, 1.0]  # 对应每个元素的累积选择概率
chosen_fruit = random.choices(population, cum_weights=cum_weights, k=3)
print(chosen_fruit)

注意事项：

• 如果同时指定了 weights 和 cum_weights，会引发 TypeError 异常。
• 如果 population 是空序列且未提供 weights 或 cum_weights，会引发 IndexError 异常。
• random.choices() 函数适用于需要根据指定的概率从总体中进行多次有放回抽样的情况。

8.1.8 random.sample()

概念：random.sample(population, k) 是 Python 中用于从总体（population）中无放回地抽取指定数量（k）的唯一元素的函数。

random.sample(population, k)

参数说明：

• population：表示总体，可以是一个序列（如列表或元组），包含了可以被选择的元素。
• k：表示要抽取的唯一元素的数量

# 从列表中抽取唯一元素
import random

# 从列表中无放回地抽取3个唯一的元素
my_list = ['apple', 'banana', 'cherry', 'date']
chosen_fruits = random.sample(my_list, 3)
print(chosen_fruits)

# 从元组中抽取唯一元素
import random

# 从元组中无放回地抽取2个唯一的元素
my_tuple = ('apple', 'banana', 'cherry', 'date')
chosen_fruits = random.sample(my_tuple, 2)
print(chosen_fruits)

注意事项：

• 如果 k 大于总体的长度（即 len(population)），会引发 ValueError 异常。
• 如果 population 是空序列且 k 大于0，会引发 ValueError 异常。
• random.sample() 函数适用于需要从总体中无放回地抽取一定数量的唯一元素的情况。

8.1.9 random.shuffle()

概念：random.shuffle(x[, random]) 是 Python 中用于将序列 x 中的元素随机排序的函数。

random.shuffle(x[, random])

参数说明：

• x：表示要随机排序的可变序列，可以是列表（list）。
• random：是一个可选的随机数生成器函数（如 random.random），用于指定自定义的随机数生成器。默认情况下，使用 random.random。

import random

# 定义一个列表
my_list = [1, 2, 3, 4, 5]

# 将列表元素随机打乱顺序
random.shuffle(my_list)

# 打印打乱后的列表
print(my_list)

注意事项：

• random.shuffle() 直接修改了原始列表 x，并且不返回任何值（返回值为 None）。
• 如果 x 是一个不可变序列（如元组），会引发 TypeError 异常，因为不可变序列无法进行就地修改。
• 如果指定了 random 参数，它必须是一个可调用的对象，返回一个随机浮点数，用于控制随机化过程。

8.1.10 random.gauss()

概念：random.gauss(mu, sigma) 是 Python 中用于生成一个服从高斯分布（正态分布）的随机数的函数。

random.gauss(mu, sigma)

参数说明：

• mu：是高斯分布的均值（mean）。
• sigma：是高斯分布的标准差（standard deviation）。

import random

# 生成一个均值为 0，标准差为 1 的随机数
random_number = random.gauss(0, 1)
print(random_number)

特点：

• 高斯分布也称为正态分布，它是统计学中最常见的分布之一。
• 均值 mu 决定了分布的中心位置，标准差 sigma 决定了分布的宽度或者说分散程度。

注意事项：

• mu 和 sigma 必须是非负数，否则会引发 ValueError 异常。
• 生成的随机数可能会超出指定均值和标准差的范围，因为高斯分布是连续分布。

8.2 随机点名案例

import random
import turtle as t
import time



# 创建海龟画布
screen = t.Screen()
screen.title("随机点名示例")
t.hideturtle()

# 创建海龟对象
t.speed(0.05)  # 设置绘制速度

# 假设这是一个班级的学生名单
students = ['Alice', 'Bob', 'Carol', 'David', 'Eve', 'Frank', 'Grace']
num = random.randint(50, 100)

for i in range(num):
    t.clear()
    name = students[random.randint(0,len(students) -1)]
    t.write(name, align="center", font=("Arial", 50))
    time.sleep(0.05)
t.done()

8.3 随机验证码

import turtle
import random
import string

# 设置画布
screen = turtle.Screen()
screen.title("简易验证码")
screen.bgcolor("white")
screen.setup(width=400, height=200)

# 创建海龟对象
t = turtle.Turtle()
t.speed(0)  # 设置海龟速度为最快
t.hideturtle()

# 定义验证码字符集
characters = string.ascii_letters + string.digits

def generate_code(length=5):
    """生成随机验证码字符串"""
    return ''.join(random.choice(characters) for _ in range(length))

def draw_code(code):
    """在画布上绘制验证码"""
    t.penup()
    t.goto(-150, 50)
    t.pendown()
    for char in code:
        t.penup()
        t.goto(random.randint(-150, 150), random.randint(-50, 50))
        t.write(char, font=("Arial", 24, "bold"))

# 生成验证码
code = generate_code()

# 绘制验证码和噪点
draw_code(code)

# 退出程序的函数
def close_program(x, y):
    screen.bye()

# 绑定点击事件，点击画布关闭程序
screen.onclick(close_program)

# 保持画布显示
turtle.done()

九、while循环

9.1 while循环的定义

while 循环是Python中一种基本的循环控制结构，用于重复执行某段代码，直到指定的条件不再满足。while 循环的语法结构如下：

while condition:
    # Code block to be executed

condition: 一个布尔表达式。当这个表达式为 True 时，循环体内的代码将被执行。当表达式为 False 时，循环将终止。

9.2 while循环中的break语句

break 语句用于立即退出当前的循环，无论循环条件是否仍为真。当程序执行到 break 语句时，循环立即终止，程序控制流会跳出循环体，继续执行循环之后的代码。

count = 0
while True:
    count += 1
    print(count)
    if count >= 5:
        break
print("循环结束")

9.3 while循环中的continue语句

continue 语句用于跳过当前循环的剩余部分，直接进入下一次循环的开始。如果在循环体内遇到 continue 语句，循环将不会执行 continue 语句后面的代码，而是重新检查循环条件，决定是否继续执行下一次循环。

count = 0
while count < 10:
    count += 1
    if count % 2 == 0:
        continue
    print(count)

总结

• break 语句用于完全退出循环。
• continue 语句用于跳过当前循环的剩余部分，直接进入下一次循环

9.4 Python模拟 do-while 循环

while True:
    # 循环体
    print("这行代码至少会执行一次")

    # 循环条件
    user_input = input("是否继续？ (yes/no): ")
    if user_input.lower() != 'yes':
        break

do-while与while的区别：

• do-while 循环：在执行循环体中的代码之后，再检查循环条件。这确保了循环体至少执行一次，即使条件一开始就不满足。
• while 循环：在每次执行循环体之前，先检查循环条件。如果条件一开始不满足，循环体可能不会执行。

9.5 while循环与else搭配使用

在 Python 中，while 循环可以与 else 语句一起使用，这种结构在其他编程语言中较少见。else 语句在循环正常结束时执行（即循环条件变为 False），但不会在循环被 break 语句终止时执行。

基本语法结构

while 条件:
    # 循环体
else:
    # 循环正常结束后的代码

9.5.1 无break情况

count = 0
while count < 5:
    print(count)
    count += 1
else:
    print("循环正常结束")

9.5.2 使用break情况

count = 0
while count < 5:
    print(count)
    count += 1
    if count == 3:
        print("触发了 break")
        break
else:
    print("循环正常结束")

在这个例子中，while 循环因为 break 语句而被中断，所以 else 块中的代码不会被执行。程序会输出：

0
1
2
触发了 break

总结

• else 块：只有当 while 循环正常结束时，else 块才会被执行。如果 while 循环是通过 break 语句中断的，else 块中的代码将不会被执行。
• 用途：这种结构在需要区分正常循环结束和因条件中断循环的场景下很有用。比如，用于检测循环是否被完全执行，还是在某个条件下提前退出

十、集合与字典

10.1 集合

10.1.1 集合定义

Python 中的集合（set）是一种无序且元素唯一的可变数据类型。集合中的元素必须是不可变类型，这意味着列表和字典不能作为集合的元素，但字符串、数字和元组可以。

创建集合

# 创建一个空集合
empty_set = set()

# 使用花括号创建集合，但请注意，创建空集合时不能使用这种方法，因为 {} 创建的是空字典
filled_set = {1, 2, 3, 4, 5}

# 使用集合推导式
 squares_set = {x**2 for x in range(10)}

10.1.2 集合操作

10.1.2.1并集

在Python中，并集是指将两个或多个集合中的所有元素合并在一起，同时去除重复的元素，只保留唯一的元素。

1.使用 | 运算符

# 定义两个集合
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
# 使用 | 运算符获取并集
union_set = A | B
print(union_set)  # 输出: {1, 2, 3, 4, 5, 6}

2.使用 union() 方法

# 使用 union() 方法获取并集
union_set = A.union(B)
print(union_set)  # 输出: {1, 2, 3, 4, 5, 6}

3.使用 update() 方法
如果你想在原地修改集合A，使其包含A和B的并集，可以使用 update() 方法：

# 在原地修改集合A，使其包含A和B的并集
A.update(B)
print(A)  # 输出: {1, 2, 3, 4, 5, 6}

如果你想获取多个集合的并集，可以依次使用 | 运算符或 union() 方法：

# 定义更多的集合
C = {5, 6, 7, 8}
# 使用 | 运算符合并多个集合
union_set = A | B | C
# 或者使用 union() 方法
union_set = A.union(B, C)
print(union_set)  # 输出: {1, 2, 3, 4, 5, 6, 7, 8}

注无论使用哪种方法，结果都是一个包含所有集合中唯一元素的新集合。

10.1.2.2交集

在Python中，交集是指两个或多个集合共有的元素。

1 使用 & 运算符

# 定义两个集合
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
# 使用 & 运算符获取交集
intersection_set = A & B
print(intersection_set)  # 输出: {3, 4}

2 使用 intersection() 方法

# 使用 intersection() 方法获取交集
intersection_set = A.intersection(B)
print(intersection_set)  # 输出: {3, 4}

3 使用 intersection_update() 方法
如果你想在原地修改集合A，使其只包含A和B的交集，可以使用 intersection_update() 方法：

# 在原地修改集合A，使其只包含A和B的交集
A.intersection_update(B)
print(A)  # 输出: {3, 4}

如果你想获取多个集合的交集，可以依次使用 & 运算符或 intersection() 方法：

# 定义更多的集合
C = {4, 5, 6}
# 使用 & 运算符合并多个集合
intersection_set = A & B & C
# 或者使用 intersection() 方法
intersection_set = A.intersection(B, C)
print(intersection_set)  # 输出: {4}

无论使用哪种方法，结果都是一个新集合，它只包含所有给定集合共有的元素。如果集合之间没有共同元素，则结果将是一个空集合。

10.1.2.3差集

在Python中，差集是指属于一个集合而不属于另一个集合的元素组成的集合。

1 使用 - 运算符

# 定义两个集合
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
# 使用 - 运算符获取差集（在A中但不在B中）
difference_set = A - B
print(difference_set)  # 输出: {1, 2}

2 使用 difference() 方法

# 使用 difference() 方法获取差集
difference_set = A.difference(B)
print(difference_set)  # 输出: {1, 2}

3 使用 difference_update() 方法
如果你想在原地修改集合A，使其只包含在A中但不在B中的元素，可以使用 difference_update() 方法：

# 在原地修改集合A，使其只包含在A中但不在B中的元素
A.difference_update(B)
print(A)  # 输出: {1, 2}

如果你想获取多个集合的差集，可以依次使用 - 运算符或 difference() 方法：

# 定义更多的集合
C = {1, 5, 6}
# 使用 - 运算符合并多个集合
difference_set = A - B - C
# 或者使用 difference() 方法
difference_set = A.difference(B, C)
print(difference_set)  # 输出: set()，因为1也在C中，所以最终差集为空

无论使用哪种方法，结果都是一个新集合，它只包含在第一个集合中但不在其他集合中的元素。如果两个集合完全相同，那么差集将是一个空集合。如果第一个集合是其他集合的超集，那么差集也将是一个空集合。

10.1.2.4对称差集

对称差集（Symmetric Difference）是指属于两个集合之一但不同时属于两个集合的元素组成的集合。在Python中，对称差集可以通过集合的运算符或方法来获取。

1 使用 ^ 运算符

# 定义两个集合
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
# 使用 ^ 运算符获取对称差集
symmetric_difference_set = A ^ B
print(symmetric_difference_set)  # 输出: {1, 2, 5, 6}

2 使用 symmetric_difference() 方法

# 使用 symmetric_difference() 方法获取对称差集
symmetric_difference_set = A.symmetric_difference(B)
print(symmetric_difference_set)  # 输出: {1, 2, 5, 6}

3 使用 symmetric_difference_update() 方法
如果你想在原地修改集合A，使其包含A和B的对称差集，可以使用 symmetric_difference_update() 方法：

# 在原地修改集合A，使其包含A和B的对称差集
A.symmetric_difference_update(B)
print(A)  # 输出: {1, 2, 5, 6}

如果你想获取多个集合的对称差集，可以依次使用 ^ 运算符或 symmetric_difference() 方法：

# 定义更多的集合
C = {5, 6, 7, 8}
# 使用 ^ 运算符合并多个集合的对称差集
symmetric_difference_set = A ^ B ^ C
# 或者使用 symmetric_difference() 方法
symmetric_difference_set = A.symmetric_difference(B).symmetric_difference(C)
print(symmetric_difference_set)  # 输出: {1, 2, 7, 8}

无论使用哪种方法，结果都是一个新集合，它只包含那些仅属于A和B中的一个集合但不同时属于A和B的元素。对称差集是一个组合操作，它不关心元素的顺序，并且是交换的，即 A ^ B 和 B ^ A 的结果是相同的。

10.1.3 集合方法

1. add() - 添加一个元素到集合中。
2. clear() - 移除集合中的所有元素。
3. copy() - 返回集合的一个浅拷贝。
4. difference() - 返回多个集合的差集。
5. difference_update() - 移除集合中在另一个集合中的元素。
6. discard() - 移除集合中的一个元素，如果该元素存在。
7. intersection() - 返回集合的交集。
8. intersection_update() - 修改集合，只保留与另一个集合共有的元素。
9. isdisjoint() - 如果两个集合没有共同元素，则返回True。
10. issubset() - 如果集合是另一个集合的子集，则返回True。
11. issuperset() - 如果集合是另一个集合的超集，则返回True。
12. pop() - 移除并返回集合中的一个随机元素。
13. remove() - 移除集合中的一个元素，如果该元素不存在，则会引发KeyError。
14. symmetric_difference() - 返回两个集合的对称差集。
15. symmetric_difference_update() - 用对称差集更新集合。
16. union() - 返回两个或多个集合的并集。
17. update() - 用另一个集合或迭代器中的元素更新集合。

10.1.4 集合的遍历

遍历集合中的所有元素可以通过多种方式完成，以下是一些常用的方法：

1 使用for循环

my_set = {1, 2, 3, 4, 5}
for element in my_set:
    print(element)

2 使用列表推导式
虽然集合本身是无序的，但你可以通过列表推导式来遍历集合中的元素。

my_set = {1, 2, 3, 4, 5}
[element for element in my_set]

上面的代码会返回一个列表，其中包含集合中的所有元素。

3 使用next()和迭代器

my_set = {1, 2, 3, 4, 5}
iterator = iter(my_set)
while True:
    try:
        element = next(iterator)
        print(element)
    except StopIteration:
        break

上面的代码通过创建一个迭代器来遍历集合，当迭代器耗尽时，会抛出StopIteration异常，这时循环结束。

10.1.5 集合的推导式

在Python中，集合推导式（Set Comprehensions）是一种简洁的方式来创建集合。它是基于列表推导式的概念，但是使用花括号 {} 而不是方括号 []。集合推导式可以用来生成一个新的集合，该集合包含了对某个序列中每个元素执行操作后的结果。

集合推导式的语法如下：

{ expression for variable in iterable if condition }

expression 是你想要放在集合中的元素
variable 是循环中使用的变量
iterable 是你想要遍历的序列
if condition 是一个可选的条件表达式，用来过滤元素

例子1：生成一个包含数字平方的集合

squares = {x**2 for x in range(10)}
print(squares)  # 输出 {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

例子2：生成一个包含字符串中每个字符的集合

letters = {char for char in "hello world" if char.isalpha()}
print(letters)  # 输出 {'h', 'e', 'l', 'o', 'w', 'r', 'd'}

例子3：使用条件过滤

even_squares = {x**2 for x in range(10) if x**2 % 2 == 0}
print(even_squares)  # 输出 {0, 4, 16, 36, 64}

需要注意的是，由于集合是无序的且不包含重复元素，所以集合推导式在处理重复元素时会自动去重。例如，如果上面的例子中的字符串"hello world"包含重复的字母，集合推导式会确保集合中每个字母只出现一次。

10.1.6 集合的特点

• 集合是无序的，因此无法通过索引来访问或修改元素。
• 集合中的元素是唯一的，重复的元素会被自动去除。
• 集合是可变的，但是它们只能包含不可变（不可变意味着不可修改）的元素。

由于集合内部实现基于哈希表，所以集合在执行成员检查（如 x in s）时通常比列表要快得多。这使得集合成为执行快速成员测试、消除重复元素和执行数学集合运算的理想选择。

10.2字典

Python 字典（dict）是一种可变容器模型，它可以存储任意类型对象，其中每个对象都存储为一个键值对。在字典中，键用于唯一地标识数据，值则表示与键相关联的数据。

10.2.1 字典的定义

字典的定义语法如下：

{key1: value1, key2: value2, ..., key_n: value_n}

• {} 表示字典的开始和结束。
• key1, key2, …, key_n 是字典中的键，它们必须是不可变的数据类型，如字符串、数字或元组。
• value1, value2, …, value_n 是与键相关联的值，可以是任何数据类型。
• 每个键值对之间用逗号 , 分隔。
  例如，下面是一个包含三个键值对的字典定义：

person = {'name': '张三', 'age': 30, 'city': '北京'}

'name'、'age' 和 'city' 是键，而 '张三'、30 和 '北京' 是对应的值。

10.2.2 字典的常用方法

1. dict.clear()
   • 删除字典中的所有元素。
2. dict.copy()
   • 返回一个字典的浅复制。
3. dict.fromkeys(seq[, value])
   • 创建一个新字典，以序列 seq 中元素做字典的键，value 为所有键对应的初始值。
4. dict.get(key[, default])
   • 返回指定键的值，如果键不在字典中返回 default 的值。
5. dict.items()
   • 返回字典中所有的键值对，形式为列表中的元组。
6. dict.keys()
   • 返回字典中所有的键，形式为列表。
7. dict.pop(key[, default])
   • 删除字典中指定的键值对，并返回该键对应的值。如果键不存在，返回 default 的值，如果没有提供 default，则抛出 KeyError。
8. dict.popitem()
   • 删除字典中的一个键值对，并返回该键值对。
9. dict.setdefault(key[, default])
   • 如果键在字典中，返回键对应的值。如果键不在字典中，插入键，并设置值为 default，然后返回 default。
10. dict.update([other])
    • 使用另一个字典中的键值对更新当前字典。如果当前字典中存在相同的键，则会被覆盖。
11. dict.values()
    • 返回字典中所有的值，形式为列表。

# 字典常用方法示例
# 创建一个字典
d = {'name': 'Alice', 'age': 30, 'city': 'New York'}
# 获取键对应的值
print(d.get('name', 'Unknown'))  # 输出: Alice
# 更新字典
d.update({'age': 32, 'country': 'USA'})
print(d)  # 输出: {'name': 'Alice', 'age': 32, 'city': 'New York', 'country': 'USA'}
# 获取所有的键
print(d.keys())  # 输出: dict_keys(['name', 'age', 'city', 'country'])
# 获取所有的值
print(d.values())  # 输出: dict_values(['Alice', 32, 'New York', 'USA'])
# 获取所有的键值对
print(d.items())  # 输出: dict_items([('name', 'Alice'), ('age', 32), ('city', 'New York'), ('country', 'USA')])
# 删除一个键值对
d.pop('age')
print(d)  # 输出: {'name': 'Alice', 'city': 'New York', 'country': 'USA'}
# 清空字典
d.clear()
print(d)  # 输出: {}

10.2.3 字典的推导式

在Python中，字典推导式是一种简洁的方式来创建字典，它基于一个迭代器，按照一定的规则来生成键值对。其语法类似于列表推导式，但它在方括号内包含键值对。
字典推导式的语法如下：

{key_expression: value_expression for item in iterable}

如果需要添加一个条件，可以进一步扩展为：

{key_expression: value_expression for item in iterable if condition}

字典推导式的例子：

1. 将一个列表中的元素作为键，其平方作为值来创建一个字典：

numbers = [1, 2, 3, 4, 5]
squared_dict = {x: x**2 for x in numbers}
print(squared_dict)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

2. 使用字典推导式来过滤一个字典中的键值对，只保留值大于10的键值对：

original_dict = {'a': 5, 'b': 12, 'c': 8, 'd': 15}
filtered_dict = {k: v for k, v in original_dict.items() if v > 10}
print(filtered_dict)  # 输出: {'b': 12, 'd': 15}

3. 将两个列表合并为一个字典，其中第一个列表的元素作为键，第二个列表的元素作为值：

keys = ['a', 'b', 'c']
values = [1, 2, 3]
combined_dict = {k: v for k, v in zip(keys, values)}
print(combined_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

10.2.4 字典的遍历

字典的遍历可以通过几种方式完成，以下是一些常用的方法：

1. 遍历字典的键（keys）：

d = {'a': 1, 'b': 2, 'c': 3}
for key in d.keys():
    print(key)  # 输出: a, b, c

2. 遍历字典的值（values）：

for value in d.values():
    print(value)  # 输出: 1, 2, 3

3. 遍历字典的键值对（items）：

for key, value in d.items():
    print(key, value)  # 输出: a 1, b 2, c 3

4. 直接遍历字典，默认遍历的是键：

for key in d:
    print(key)  # 输出: a, b, c

综合示例遍历字典

d = {'a': 1, 'b': 2, 'c': 3}
# 遍历字典的键
print("Keys:")
for key in d:
    print(key)
# 遍历字典的值
print("\nValues:")
for value in d.values():
    print(value)
# 遍历字典的键值对
print("\nItems (Key: Value):")
for key, value in d.items():
    print(f"{key}: {value}")

输出结果为：

Keys:
a
b
c
Values:
1
2
3
Items (Key: Value):
a: 1
b: 2
c: 3

10.2.5 字典的特点

字典（Dictionary）在Python中是一种非常强大和灵活的数据结构，它具有以下特点：

1. 键值对存储：字典以键值对（key-value pairs）的形式存储数据，每个键对应一个值。
2. 键的唯一性：在同一个字典中，每个键必须是唯一的，但是值不必唯一。
3. 动态大小：字典可以根据需要动态地添加和删除键值对，不需要预先定义大小。
4. 无序性：在Python 3.6之前，字典是无序的，即键值对的顺序是不固定的。从Python 3.7开始，字典是有序的，它们会按照键值对被添加的顺序来维护顺序。
5. 键的不可变性：字典的键必须是不可变的数据类型，如字符串、数字或元组。不可变意味着这些类型的值一旦创建，就不能更改。
6. 值的可变性：字典的值可以是任何数据类型，包括可变的列表、集合、字典等。
7. 快速访问：字典通过哈希表实现，因此对于查找、插入和删除操作，通常可以在常数时间内完成，即与字典中元素的数量无关。

具体特点：

• 灵活的键操作：可以通过键来快速访问、更新或删除字典中的值。
• 方法丰富：字典提供了许多内置方法，如clear(), copy(), fromkeys(), get(), items(), keys(), pop(), popitem(), setdefault(), update() 和 values()，用于操作和查询字典。
• 推导式支持：可以使用字典推导式来简洁地创建字典。
• 遍历能力：可以方便地遍历字典的键、值或键值对。

十、函数与递归

10.1 函数

在Python中，函数是一块组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。它可以提高代码的模块性和代码的复用率。在Python中定义一个函数需要使用def关键字。

10.1.1 定义函数

def 函数名(参数):
    """文档字符串（docstring）- 描述函数的作用，可选"""
    # 在这里写上函数要执行的操作
    ...
    return 返回值  # 如果函数没有返回值，这行可以省略

10.1.2 调用函数

函数名(参数)

函数实例：求两个数的和

def add(x, y):
    """返回两个数的和"""
    return x + y

# 调用函数
result = add(5, 3)
print(result)  # 输出 8

10.1.3 函数的参数

• 必需参数：必须按照正确的顺序传入函数。上面的add函数中的x和y就是必需参数。
• 默认参数：调用函数时，如果没有传递参数，则会使用默认参数。
• 不定长参数：你可能需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数。

1.默认参数

def say_hello(name, greeting="Hello"):
    return f"{greeting}, {name}"

print(say_hello("World"))        # 输出 "Hello, World"
print(say_hello("World", "Hi"))  # 输出 "Hi, World"

2.不定长参数

def print_people(*people):
    for person in people:
        print(f"Hello, {person}")

print_people("Alice", "Bob", "Charlie")  # 依次输出 "Hello, Alice", "Hello, Bob", "Hello, Charlie"

参数实例：计算列表中所有数字的总和：

def sum_of_list(numbers_list):
    """计算列表中所有数字的总和"""
    total = 0
    for number in numbers_list:
        total += number
    return total

# 定义一个数字列表
numbers = [1, 2, 3, 4, 5]

# 调用函数并打印结果
result = sum_of_list(numbers)
print(f"列表中数字的总和是: {result}")  # 输出: 列表中数字的总和是: 15

10.1.4 匿名函数

在Python中，匿名函数是通过lambda关键字定义的，它是一种简洁的、不需要显式定义函数名称的函数。匿名函数通常用于需要短小精悍的函数定义的场景，尤其是当你需要一个简单的函数，并且这个函数只在某个地方使用一次时。

1.匿名函数的特点

• 使用lambda关键字定义，而不是def。
• 函数体通常是一行表达式，而不是代码块。
• 该表达式自动返回结果，不需要return语句。

2.匿名函数的基本语法

lambda 参数: 表达式

3.简单匿名函数实例

add = lambda x, y: x + y
print(add(5, 3))  # 输出 8

4.匿名函数通常用于以下场景

• 高阶函数，比如map(), filter(), 和sorted()，它们可以接受函数作为参数。
• 需要短小函数的场合，比如排序时的键函数。

# 假设有一个字典列表
data = [{'name': 'Alice', 'age': 25}, 
{'name': 'Bob', 'age': 20}, 
{'name': 'Charlie', 'age': 30}]

# 使用匿名函数按照年龄排序
sorted_data = sorted(data, key=lambda x: x['age'])

print(sorted_data)
'''输出: [{'name': 'Bob', 'age': 20}, 
{'name': 'Alice', 'age': 25}, 
{'name': 'Charlie', 'age': 30}]
'''

10.2 递归

在Python中，递归是一种编程技巧，它允许函数调用自身。递归通常用于解决可以分解为更小、相似问题的问题，例如计算阶乘、处理树形结构的数据（如文件系统目录）等。

10.2.1 递归的基本概念

• 基线条件（Base Case）：这是递归终止的条件，防止函数无限地调用自身。
• 递归步骤（Recursive Step）：函数调用自身的步骤，通常涉及将问题分解为更小的实例

def 函数名(参数):
    # 基线条件：判断递归的终止条件
    if 条件判断:
        return 基线结果  # 当满足基线条件时，返回一个结果以终止递归

    # 递归步骤：在函数内部调用自身
    else:
        # 可能包含一些操作，然后进行递归调用
        return 函数名(修改后的参数)  # 递归调用自身，通常参数会有所改变

递归函数的示例:

def factorial(n):
    # 基线条件：如果n为0或1，返回1
    if n == 0 or n == 1:
        return 1
    # 递归步骤：调用自身计算n * (n-1)!
    else:
        return n * factorial(n - 1)

# 调用函数
print(factorial(5))  # 输出 120

注意事项

• 递归深度限制：Python默认的递归深度限制是1000，这意味着如果递归调用超过这个深度，将会抛出RecursionError。可以通过sys模块的setrecursionlimit()函数来调整这个限制。
• 效率问题：递归可能会比迭代解决方案更慢，因为它涉及多次函数调用，这会增加调用栈的大小。
• 内存消耗：每次递归调用都会在调用栈上占用空间，如果递归深度很大，可能会导致大量的内存消耗。

10.2.2 迭代与递归

递归虽然是一种强大的工具，但许多递归算法也可以用迭代（循环）来实现。在某些情况下，迭代可能比递归更高效，因为它避免了函数调用的开销。

迭代方式计算阶乘的示例:

def factorial_iterative(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# 调用函数
print(factorial_iterative(5))  # 输出 120

10.3 栈

在Python中，栈（Stack）是一种数据结构，它按照特定的顺序来存储和检索数据，遵循后进先出（Last In, First Out, LIFO）的原则。

10.3.1 栈的基本操作

• 推入（Push）：在栈顶添加一个元素。
• 弹出（Pop）：移除栈顶的元素。
• 查看栈顶元素（Peek或Top）：查看栈顶的元素，但不移除它。
• 检查栈是否为空（IsEmpty）：检查栈是否不包含任何元素。
• 获取栈的大小（Size）：返回栈中元素的数量。

10.3.2 栈的特点

• 后进先出（LIFO）：最后被推入栈的元素将是第一个被弹出的元素。
• 限制性访问：只能访问栈顶元素，即最后被推入的元素。

10.3.3 栈的实现

在Python中，可以使用列表（List）来实现栈的所有功能：

• 使用list.append(item)方法来实现推入操作。
• 使用list.pop()方法来实现弹出操作，它默认移除列表的最后一个元素。
• 使用list[-1]来查看栈顶元素。
• 使用len(list)来获取栈的大小。

栈的简单实现：列表方式

class Stack:
    def __init__(self):
        self.items = []  # 使用列表存储栈元素

    def is_empty(self):
        return len(self.items) == 0

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        else:
            raise IndexError("pop from an empty stack")

    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        else:
            raise IndexError("peek from an empty stack")

    def size(self):
        return len(self.items)

# 使用栈
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.peek())  # 输出 3
print(stack.pop())   # 输出 3
print(stack.size())  # 输出 2

注意：
虽然不是专门为栈设计的，但其他数据结构，如字典或集合，第三方库，也可以用来实现栈，只要遵循LIFO原则即可。然而，这通常不是最佳实践，因为这些数据结构不是为了模拟栈的行为而设计的。