Python学习笔记

一、第一阶段

（一）进门

1.字面量

在 Python 中，字面量指的是程序中用于表示数据的常量值，这些常量值在程序中直接出现，不需要进行计算或求值。常见的 Python 字面量包括：

• 整型字面量：如 42、-15、0b101010（2进制）、0o755（8进制）、0x2a（16进制）
• 浮点型字面量：如 3.14、-7.5、4E-4
• 字符串字面量：如 “hello”、‘world’、‘’‘Python is awesome!’‘’
• 布尔型字面量：True 和 False
• 空值字面量：None

下面是一些字面量的示例：

x = 42          # 整型字面量
y = 3.14        # 浮点型字面量
s = "hello"     # 字符串字面量
b = True        # 布尔型字面量
n = None        # 空值字面量

2.注释

单行注释：# 单行注释

多行注释：“”“多行注释”“”

3.变量

在 Python 中，变量是用于存储数据的标识符，它们可以用于引用不同类型的值，包括数字、字符串、列表、元组、字典等等。不同于其他编程语言，Python 在创建变量时不需要指定变量类型，变量的类型会在赋值时自动确定。

Python 的变量命名规则如下：

• 变量名只能包含字母、数字和下划线，不允许使用空格或其他特殊字符。
• 变量名不能以数字开头。
• 变量名应该尽可能简短，但具有描述性。
• 变量名应该遵循下划线命名法或驼峰命名法等常见的命名规范。

下面是 Python 中声明变量的示例：

x = 42          # 整型变量
y = 3.14        # 浮点型变量
s = "hello"     # 字符串变量
b = True        # 布尔型变量

在 Python 中，还可以对不同类型的变量进行操作，比如数值类型变量的加减乘除运算，字符串变量的连接等等。同时，Python 还支持多重赋值，如下面的示例所示：

x, y, z = 1, 2, 3      # 一次性进行多重赋值
a = b = c = "hello"    # 多个变量同时赋值为同一个值

money = 100
print("余额为：", money)
money = money - 50
print("用了50后还有：", money)

4.数据类型

Python 是一种动态类型语言，它能够自动检测变量的数据类型，而不需要在代码中明确地指定数据类型。Python 支持各种数据类型，包括：

• 数值（Numbers）：整数、长整数、浮点数和复数
• 字符串（Strings）：由单引号、双引号或三引号括起来的文本字符串
• 列表（Lists）：由一系列逗号分隔的值组成，用中括号括起来
• 元组（Tuples）：由一系列逗号分隔的值组成，用圆括号括起来
• 集合（Sets）：由一系列不重复元素组成，用大括号括起来
• 字典（Dictionaries）：由一系列键值对组成

以下是一些常见数据类型的示例：

x = 42          # 整数
y = 3.14        # 浮点数
z = 4 + 3j      # 复数
s = "hello"     # 字符串
l = [1, 2, 3]   # 列表
t = (4, 5, 6)   # 元组
st = {1, 2, 3}  # 集合
d = {"name": "Tom", "age": 20}  # 字典

在 Python 中，可以使用 type() 函数来检查变量的数据类型，如下面的示例所示：

print(type(x))  # 输出：<class 'int'>
print(type(y))  # 输出：<class 'float'>
print(type(s))  # 输出：<class 'str'>
print(type(l))  # 输出：<class 'list'>
print(type(t))  # 输出：<class 'tuple'>
print(type(st)) # 输出：<class 'set'>
print(type(d))  # 输出：<class 'dict'>

5.数据类型转换

在 Python 中，可以使用内置函数 int()、float()、str()、list()、tuple()、set() 等来执行数据类型转换。以下是一些示例：

# 万物皆可字符串

# 将整数转换为字符串
x = int("42")
print(x)  # 输出：42
print(type(x))  # 输出：<class 'int'>

# 将浮点数转换为整数
y = int(3.14)
print(y)  # 输出：3
print(type(y))  # 输出：<class 'int'>

# 将整数转换为浮点数
z = float(42)
print(z)  # 输出：42.0
print(type(z))  # 输出：<class 'float'>

# 将整数转换为字符串
s1 = str(42)
print(s1)  # 输出："42"
print(type(s1))  # 输出：<class 'str'>

# 将列表转换为元组
l = [1, 2, 3]
t = tuple(l)
print(t)  # 输出：(1, 2, 3)
print(type(t))  # 输出：<class 'tuple'>

# 将字符串转换为列表
s2 = "hello"
l2 = list(s2)
print(l2)  # 输出：['h', 'e', 'l', 'l', 'o']
print(type(l2))  # 输出：<class 'list'>

需要注意的是，有些数据类型之间不能相互转换，比如字符串和整数之间不能直接转换。如果需要将一个字符串表示的数字转换为整数，需要确保该字符串只包含数字字符，并且没有任何其他字符（如空格、字母等）。

6.标识符

在 Python 中，标识符是用于标识变量、函数、类、模块或其他对象的名称。Python 中的标识符遵循以下规则：

• 标识符可以包含字母、数字和下划线，但不能以数字开头，中文可以，但很不推荐。
• 标识符严格区分大小写。
• 关键字不能用作标识符名称，包括 Python 中保留的关键字和内置函数名称。
• 标识符应该具有描述性，遵循规范的命名约定（如使用下划线命名法或驼峰命名法）。

以下是一些符合 Python 命名规范的标识符：

my_variable = 42    # 变量名称使用下划线命名法
myFunction = ...    # 函数名称使用驼峰命名法
MyClass = ...       # 类名称使用驼峰命名法
my_module = ...     # 模块名称使用下划线命名法

Python 中的内置函数和保留关键字是不能用作标识符名称的。以下是 Python 的保留关键字：

False   await   else    import  pass
None    break   except  in      raise
True    class   finally is      return
and     continuefor     lambda  try
as      def     from    nonlocalwhile
assert  del     global  not     with
async   elif    if      or      yield

需要避免使用保留关键字作为标识符名称，因为这会引起语法错误。

7.运算符

在 Python 中，运算符是用于执行各种运算操作的特殊符号。Python 支持各种运算符，包括算术运算符、比较运算符、逻辑运算符、位运算符等等。

以下是 Python 中的一些常见运算符：

• 算术运算符：用于执行算术操作，如加、减、乘、除等。例如：+、-、*、/、%、**（指数）、//（取整除）等。
• 比较运算符：用于比较两个值，并返回一个布尔值，表示比较结果为真或假。例如：>、<、>=、<=、==（等于）和 !=（不等于）等。
• 逻辑运算符：用于执行逻辑操作，并返回一个布尔值，表示结果为真或假。例如：and（逻辑与）、or（逻辑或）和 not（逻辑非）等。
• 位运算符：用于执行位级运算操作，如按位与、按位或、按位取反等。例如：&（按位与）、|（按位或）、~（按位取反）等。
• 赋值运算符：用于将一个值赋给变量。例如：=、+=、-=、*=、/=、%=、&=、|=、^=等。
• 成员运算符：用于测试序列中是否包含一个指定的值。例如：in（存在于）和 not in（不存在于）。
• 身份运算符：用于比较两个对象的内存地址是否相等。例如：is（是）和 is not（不是）。

以下是一些示例：

# 算术运算符示例
x = 5
y = 2
print(x + y)   # 输出：7
print(x - y)   # 输出：3
print(x * y)   # 输出：10
print(x / y)   # 输出：2.5
print(x % y)   # 输出：1
print(x ** y)  # 输出：25
print(x // y)  # 输出：2

# 比较运算符示例
x = 5
y = 2
print(x > y)   # 输出：True
print(x < y)   # 输出：False
print(x >= y)  # 输出：True
print(x <= y)  # 输出：False
print(x == y)  # 输出：False
print(x != y)  # 输出：True

# 逻辑运算符示例
x = 5
y = 2
print(x > 3 and y < 4)    # 输出：True
print(x > 3 or y < 1)     # 输出：True
print(not(x > 3 and y < 4))# 输出：False

# 赋值运算符示例
x = 5
x += 2   # 等价于 x = x + 2
print(x)   # 输出：7

# 成员运算符示例
fruits = ['apple', 'banana', 'orange']
print('apple' in fruits)   # 输出：True
print('melon' in fruits)   # 输出：False

# 身份运算符示例
x = 5
y = x
print(x is y)   # 输出：True
print(x is not y)   # 输出：False

赋值运算符拓展：

Python 中的复合赋值运算符是一类特殊的赋值运算符，可以让我们在赋值时，同时完成某种算术运算操作，具有简洁、便捷的优点。

以下是 Python 中的复合赋值运算符：

运算符	例子	等价于
+=	x += 1	x = x + 1
-=	x -= 1	x = x - 1
*=	x *= 2	x = x * 2
/=	x /= 2	x = x / 2
%=	x %= 2	x = x % 2
//=	x //= 2	x = x // 2
**=	x **= 2	x = x ** 2
&=	x &= 1	x = x & 1
`	=`	`x
^=	x ^= 1	x = x ^ 1
>>=	x >>= 1	x = x >> 1
<<=	x <<= 1	x = x << 1

示例：

x = 5
x += 2   # 相当于 x = x + 2
print(x)   # 输出：7

x = 8
x //= 3  # 相当于 x = x // 3
print(x)  # 输出：2

y = 4
y **= 3  # 相当于 y = y ** 3
print(y)  # 输出：64

需要注意的是，复合赋值运算符并不会带来性能上的实际提升，只是让我们的代码更加简洁清晰。每个复合赋值运算符中的计算过程，本质上与其对应的纯赋值运算符一致。

（二）字符串

1.字符串

在 Python 中，字符串是一种表示文本数据的数据类型，用单引号 '' 、双引号 "" 或三引号""" """括起来。通常用于存储文本信息，如名称、地址、描述等。

以下是一些 Python 操作字符串的常用方法：

• 访问字符串中的字符可以通过下标索引获取，下标从 0 开始计数。例如：s = "hello"，则 s[0] 是字符串的第一个字符，即 h。

• 字符串切片可以用于获取一段子字符串，语法为 s[start:end]，其中 start 表示子字符串开始的位置，end 表示子字符串结束的位置，不包括 end 对应的字符。例如：s = "hello"，则 s[1:4] 返回 ell。

• 字符串长度可以通过内置函数 len() 来获取，例如：s = "hello"，则 len(s) 返回 5。

• 字符串拼接可以使用 + 运算符、join() 或者字符串格式化。例如：

  s1 = "hello"
  s2 = "world"
  s3 = s1 + ", " + s2   # 使用 + 运算符拼接字符串
  print(s3)   # 输出：hello, world
  
  s4 = "-".join(["hello", "world"])   # 使用 join() 方法拼接字符串
  print(s4)   # 输出：hello-world
  
  s5 = "这是一段%s" % (s1+" "+s2) # 使用字符串格式化
  print(s5) # 输出：这是一段hello world
  

• 字符串查找可以使用 find()、rfind()、index()、rindex()、startswith()、endswith() 等方法。例如：

  s = "hello python world"
  print(s.find("python"))    # 输出：6
  print(s.rfind("o"))        # 输出：15
  print(s.index("world"))    # 输出：12
  print(s.rindex("o"))       # 输出：17
  print(s.startswith("hello"))  # 输出：True
  print(s.endswith("world"))     # 输出：True
  

• 字符串替换可以使用 replace() 方法，例如：

  s = "hello python"
  s2 = s.replace("python", "world")
  print(s2)   # 输出：hello world
  

• 字符串分割可以使用 split() 方法，例如：

  s = "hello,world"
  lst = s.split(",")
  print(lst)   # 输出：['hello', 'world']
  

• 字符串格式化可以使用 format() 方法或者f"{占位}"，例如：

  name = "Tom"
  age = 20
  print("My name is {}, I am {} years old.".format(name, age))
  # 输出：My name is Tom, I am 20 years old.
  
  print(f"My name is {name}, I am {age} years old.")
  # 输出：My name is Tom, I am 20 years old.
  

• 字符串嵌套

  # 单引号嵌套双引号
  name_1 = '”这是汤姆。“'
  print(name_1) # 输出：”这是汤姆。“
  
  # 双引号嵌套单引号
  name_2 = "‘这是汤姆。’"
  print(name_2) # 输出：‘这是汤姆。’
  
  # 使用\转义 只能转义英文符号
  name_3 = "\"这是汤姆。\""
  print(name_3) # 输出：“这是汤姆。"
  

• 字符串中的数字精度控制

  x = 3.1415926
  print("限制长度为5，小数限制1，结果为：%5.1f" % x) # 输出：限制长度为5，小数限制1，结果为：  3.1
  print("不限制长度，小数限制3，结果为：%.3f" % x) # 输出：不限制长度，小数限制3，结果为：3.142
  
  y = 1314
  print("限制长度为6，结果为:%6" % y) # 输出：限制长度为6，结果为:  1314
  

字符串是不可变的（immutable）数据类型，即它们一旦创建就不能改变，只能通过新建字符串来实现修改。例如，尝试给字符串中的某个字符赋值会导致语法错误。

2.键盘输入

在 Python 中，可以使用内置的 input() 函数来读取用户输入的数据。input() 函数会读取用户在键盘上输入的所有字符（包括空格、制表符等），并返回一个字符串类型的值，该值包含用户输入的所有内容。示例：

name = input("请输入您的姓名：")
print("您好，" + name + "！")

在上面的示例中，input() 函数会要求用户输入姓名，用户输入完成后，通过 print() 函数输出“您好，XXX！”的问候语，其中 XXX 为用户输入的姓名。

需要注意的是，input() 函数返回的始终是字符串类型的值，如果需要将其转换为其他数据类型，需要通过相应的数据类型转换函数来实现。例如，若需要将用户输入的字符串转换为整数，可以使用 int() 函数，若需要将其转换为浮点数，则可以使用 float() 函数。示例：

x = input("请输入一个整数：")
y = int(x) + 1   # 将用户输入的字符串转换为整数
print("您输入的数字是：" + x)
print("加 1 后，其值为：" + str(y))   # 将结果转换为字符串类型，然后输出

在该示例中，用户需要输入一个整数，然后使用 int() 函数将用户输入的字符串转换为整数，然后将其加1，再通过 print() 函数输出结果。需要注意的是，str() 函数可以将其他类型的值（如整数、浮点数等）转换为字符串类型的值。

（三）判断与循环

1.if语句

在 Python 中，if 语句可以用来实现条件判断，根据不同的条件执行不同的代码块。if 语句的基本语法如下：

if condition:
    # 如果条件表达式成立，则执行这里的代码块

其中，condition 是需要判断的条件表达式，它返回一个布尔值（True 或 False）。如果 condition 为 True，则执行缩进块中的代码；如果 condition 为 False，则跳过整个缩进块，继续执行后面的代码。

除了 if 语句，Python 还提供了 if-else 语句和 if-elif-else 语句，它们的语法如下：

• if-else 语句：

  if condition:
      # 如果条件表达式成立，则执行这里的代码块
  else:
      # 如果条件表达式不成立，则执行这里的代码块
  

  在这种语法下，如果 condition 为 True，则执行 if 后面的代码块；否则执行 else 后面的代码块。

• if-elif-else 语句：

  if condition1:
      # 如果条件表达式 1 成立，则执行这里的代码块
  elif condition2:
      # 如果条件表达式 2 成立，则执行这里的代码块
  elif condition3:
      # 如果条件表达式 3 成立，则执行这里的代码块
  else:
      # 如果所有条件表达式都不成立，则执行这里的代码块
  

  在这种语法下，如果 condition1 为 True，则执行 if 后面的代码块；否则判断 condition2，如果 condition2 为 True，则执行 elif 后面的代码块；以此类推，如果都不满足，则执行 else 后面的代码块。

示例：

score = 80

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("中等")
elif score >= 60:
    print("及格")
else:
    print("不及格")

在上面的示例中，我们根据 score 的值，判断学生的成绩是否达到优秀、良好、中等、及格和不及格等程度，并使用 print() 函数分别输出相应的结果。

需要注意的是，在 Python 中，if 语句下面缩进的代码块需要保持一致，否则会产生语法错误。另外，在比较两个值是否相等时，需要使用双等号 ==，而不是单等号 =。

2.if语句的嵌套

在 Python 中，if 语句中可以嵌套其他的 if 语句，以实现更复杂的条件判断。例如：

age = input("请输入年龄：")
gender = input("请输入性别：")

if gender == "女":
    if int(age) < 18:
        print("女生未成年不能参军")
    else:
        print("女生可以参军")
else:
    if int(age) < 18:
        print("男生未成年不能参军")
    else:
        print("男生可以参军")

在上面的示例中，我们需要判断用户输入的年龄和性别，然后根据不同的条件输出不同的结果。首先，我们通过两个 input() 函数获取了用户输入的年龄和性别（注意，用户输入的年龄是字符串类型，需要使用 int() 函数将其转换为整数类型）。然后，我们使用 if 语句判断用户的性别，如果是女性，则再根据年龄判断能否参军；如果是男性，则同样根据年龄判断能否参军。需要注意的是，在嵌套的 if 语句中，内层的 if 语句需要缩进更多。

需要注意的是，嵌套的 if 语句虽然可以实现更复杂的条件判断，但是过多的嵌套会增加代码的复杂性，不利于程序的维护和阅读。因此，建议尽量避免过多的嵌套，可以使用其他控制语句（如循环语句和函数调用）来简化程序逻辑。

3.循环语句

在 Python 中，循环语句可以用来重复执行相同的代码块，以实现一定的逻辑。常见的循环语句有 while 循环和 for 循环。

3.1while循环

while 循环用于当指定条件为真时执行代码块，其基本语法如下：

while condition:
    # 如果条件为真，则执行这里的代码块

其中，condition 是需要判断的条件表达式，它返回一个布尔值（True 或 False）。如果 condition 为 True，则执行缩进块中的代码；如果 condition 为 False，则跳过整个缩进块，继续执行后面的代码。

可以通过在缩进块中使用循环控制语句（如 break、continue、pass 等）来控制循环的流程和停止条件。示例：

i = 0
while i < 5:
    print("第", i + 1, "次循环")
    i += 1
print("循环结束")

在上面的示例中，我们使用 while 循环打印出"第 1 次循环"、"第 2 次循环"等信息，当 i 的值大于等于 5 时，循环停止。需要注意的是，i += 1 的作用是使 i 的值每次加一，实现循环的次数计数。

3.2for循环

for 循环用于遍历序列和集合等可迭代对象，其基本语法如下：

for val in sequence:
    # 遍历序列中的每个元素，将其赋值给变量 val，然后执行这里的代码块

其中，sequence 是需要遍历的序列对象，如字符串、列表、元组等；val 是循环过程中取到的序列中的每个元素。在循环过程中，依次将序列中的每个元素赋值给 val，然后执行缩进块中的代码。需要注意的是，遍历过程中它会按照顺序遍历，因此输出的结果是按照列表元素的顺序排列的。

需要注意的是，Python 中的 for 循环并不像其他语言中的 for 循环一样，需要事先定义计数器变量，并进行循环次数的控制。在 Python 中，通过遍历序列元素的方法来实现循环操作。

示例：

fruits = ["苹果", "香蕉", "橘子"]
for fruit in fruits:
    print(fruit)

在上面的示例中，我们定义了一个列表 fruits，并使用 for 循环依次遍历该列表中的每个元素，并使用 print() 函数输出相应的水果名称。循环过程中，fruit 变量依次取到每个元素的值，然后执行缩进块中的代码。

需要注意的是，for 循环还可以与函数调用、条件语句等结合使用，以实现更复杂的循环操作。

3.3range语法

range() 是 Python 内置函数之一，用于生成一个序列，常用于 for 循环中控制循环次数。range() 函数的基本语法如下：

range(stop)
range(start, stop[, step])

其中，start、stop、step 均为整数类型的参数，表示序列的起始值、结束值和步长。需要注意的是，stop 参数是必需的，而 start 和 step 参数是可选的，默认值分别为 0 和 1。下面是 range() 函数的三种用法：

1. range(stop)：生成一个从 0 开始、到 stop-1 结束、步长为 1 的整数序列。

示例：

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

输出：

0
1
2
3
4

2. range(start, stop[, step])：生成一个从 start 开始、到 stop-1 结束、步长为 step 的整数序列。

示例：

for i in range(1, 10, 2):
    print(i)

输出：

1
3
5
7
9

3. list(range(start, stop[, step]))：将 range() 函数生成的序列转换为列表。

示例：

list(range(3))
# 输出：[0, 1, 2]

list(range(1, 8, 2))
# 输出：[1, 3, 5, 7]

需要注意的是，如果希望生成一个包含浮点数的序列，可以使用 numpy 库的 arange() 函数来实现。例如：

import numpy as np
x = np.arange(0, 1, 0.1)
print(x)

输出：

[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

需要注意的是，numpy 库是科学计算中常用的库之一，可以帮助我们快速地进行数组和矩阵计算等操作。在使用 numpy 库前，需要先通过 pip install numpy 命令安装该库。

3.4while嵌套循环

在 Python 中，可以在 while 循环中嵌套其他的循环语句，以实现更复杂的循环操作。例如，可以使用嵌套循环来打印九九乘法表。示例：

i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(j, "*", i, "=", i*j, end="\t")
        j += 1
    print()
    i += 1

在上面的示例中，我们使用两个嵌套的 while 循环来实现九九乘法表的打印。外层循环控制乘法表的行数，内层循环控制每行中的列数。需要注意的是，print() 函数的第三个参数 end="\t" 表示以制表符作为分隔符来输出内容，同时将光标移动到下一个制表符位置。

需要注意的是，嵌套循环的代码块需要严格按照缩进的层次关系来书写，否则会导致程序语法错误。此外，嵌套循环可能会导致程序效率降低，因此需要在实际应用中慎重选择循环方式。

3.5for嵌套循环

案例如下：

for i in range(1, 10):
    for j in range(1, i+1):
        print(j, "*", i, "=", i*j, end="\t")
    print()

在上面的示例中，我们使用两个嵌套的 for 循环来实现九九乘法表的打印。外层循环控制乘法表的行数，内层循环控制每行中的列数。需要注意的是，内层循环的结束位置应该为 i+1，因为我们需要打印的是从 1 到 i 的乘法表格。

另外，由于 range() 函数的起始值默认为 0，因此需要将其设置为 1，以保证第一行正确输出。此外，print() 函数的参数 end="\t" 同样用于控制输出的格式，以制表符作为分隔符来输出内容，同时将光标移动到下一个制表符位置。

需要注意的是，与之前的 while 循环相比，for 循环的代码更加简洁，同时还可以通过 range() 函数来控制循环次数，从而使循环更加灵活。但是，在实际应用中，需要根据具体情况选择不同的循环语句。

3.6变量作用域

在 for 循环中，循环变量是一个临时变量，其作用域仅限于循环体内。也就是说，如果在循环体外部定义了一个与循环变量同名的变量，那么在循环体内使用该变量时，会覆盖循环变量的值。

例如，下面的代码片段展示了这个情况：

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

上面的代码片段中，循环体仅包含一个 pass 语句，因此循环变量 i 的值并没有被修改。但是，当我们在循环体外部尝试输出 i 的值时，会得到如下错误提示：

NameError: name 'i' is not defined

这是因为在循环体内部定义的 i 变量的作用域仅限于循环体内部，当循环结束后，变量 i 不再存在，因此无法在循环体外部访问该变量。

如果需要在循环体外部使用循环变量的值，需要在循环体内将其赋值给另外一个变量，例如：

result = 0
for i in range(5):
    result += i
print(result)

在上面的代码片段中，我们在循环体内部累加了变量 i 的值，最终将累加结果赋值给了变量 result。由于变量 result 的作用域覆盖了整个代码块，因此可以在循环体外部使用该变量的值。

3.7中断循环

在 Python 中，如果需要在循环执行过程中中断循环，可以使用 break 语句。break 语句可以用于循环语句（for 循环和 while 循环），其作用是立即终止当前的循环，并跳出循环语句。在循环体中执行 break 语句之后，程序会跳过循环的剩余部分，直接开始执行循环体后面的语句。

下面是一个使用 break 语句中断 while 循环的示例：

i = 0
while i < 5:
    if i == 3:
        break
    print(i)
    i += 1

在上面的代码中，我们定义了一个 while 循环，在循环体中使用 if 语句判断变量 i 的值是否等于 3，如果是则执行 break 语句来中断循环。因此，最终在程序的输出中，只会输出 0、1、2 三个数字，而不会输出 3 和 4。

除了 break 语句，Python中还提供了一个 continue 语句，它可以用于结束本次循环，进入下一轮循环。当 continue 语句被执行时，程序会跳过本轮循环剩余的部分，直接开始下一轮循环。与 break 语句不同，continue 语句仅中断本轮循环，而不会完全终止整个循环。下面是一个使用 continue 语句的示例：

for i in range(5):
    if i == 2:
        continue
    print(i)

在上面的代码中，我们使用了 for 循环来迭代一个序列，然后使用 if 语句判断 i 的值是否等于 2。如果是，则执行 continue 语句，跳过这一轮循环的剩余部分，直接开始下一轮循环。因此，在最终的输出中，会省略掉数字 2。

4.综合案例

4.1猜数字游戏

import random

secret_number = random.randint(1, 100)

count = 0

print("猜数字游戏开始！")

guess = None

while guess != secret_number:
    guess = int(input("请猜一个1到100之间的整数："))
    count += 1

    if guess < secret_number:
        print("太小了，请再试一次！")
    elif guess > secret_number:
        print("太大了，请再试一次！")
    else:
        print("恭喜你，猜对了！")

print(f"你总共猜了{count}次。")

（四）函数

1.入门

在 Python 中，函数被定义为一段可复用的代码块，其可以接收参数、执行特定的操作，并最终返回值。通过函数，在 Python 程序中可以将特定的功能模块划分为独立的单元，增强了代码的可读性、可维护性和可重用性。

Python 中定义函数使用关键字 def，基本语法如下：

def function_name(parameters):
    statement(s)
    return expression

其中，function_name 是函数名，parameters 是函数参数列表，可以是多个参数，也可以为空。函数参数可以包括位置参数、默认参数、可变位置参数和可变关键字参数，具体的介绍在下面会详细讲解。statement(s) 是函数体，包含一组 Python 语句。可选的 return 用于从函数中返回一个值，如果没有指定表达式，则默认返回 None。

下面是一个简单的 Python 函数示例，用于计算两个数的和：

def add(a, b):
    return a + b

在上面的示例中，我们定义了一个名为 add 的函数，接收两个参数 a 和 b，并返回它们的和。在函数体中，我们使用了 return 语句来返回计算结果。

在 Python 中，可以通过调用函数来执行函数体中的代码，从而实现特定的功能。调用函数时需要传入相应的参数，然后函数会根据参数来进行相应的计算，并将结果返回给调用方。例如，在上面的示例中，我们可以调用 add() 函数来计算两个数的和，代码如下：

result = add(1, 2)
print(result)

在上面的代码中，我们首先将 add() 函数的返回值赋值给变量 result，然后使用 print() 函数输出该变量的值。由于 add() 函数的参数是 1 和 2，因此函数返回的结果为 3，最终输出结果为 3。

需要注意的是，函数也可以嵌套调用，从而实现更为复杂的功能。此外，函数还可以使用全局变量和局部变量，通过参数来传递数据等。函数与 Python 中的模块和类一起，构成了 Python 编程语言中面向过程和面向对象编程的基本要素。

2.参数

在 Python 中，函数的参数可以分为四种类型：位置参数、默认参数、可变位置参数和可变关键字参数。下面我们逐一介绍这几种参数类型。

2.1位置参数

位置参数是函数定义中最常用的参数类型，也是函数中最常见的参数类型。位置参数是按照顺序依次传递的参数，其顺序需要与函数定义时参数的顺序相同。下面是一个位置参数的例子：

def greet(name, age):
    print("Hello, my name is " + name + ", and I am " + age + " years old.")

greet("Bob", "20")

在上面的代码中，name 和 age 是位置参数，分别用来存储姓名和年龄。当我们调用 greet() 函数时，需要按照位置依次传递 name 和 age 参数。在上面的示例中，我们使用 greet("Bob", "20") 语句来调用 greet() 函数，其中 "Bob" 为 name 参数，而 "20" 为 age 参数。

2.2默认参数

默认参数是指在定义函数时，为参数指定默认值，如果调用函数时未指定该参数，则使用默认值。可以在参数列表中给参数赋默认值，这样在调用函数时如果没有提供该参数，则会使用默认值。下面是一个默认参数的例子：

def greet(name, age, city="New York"):
    print("Hello, my name is " + name + " and I am " + age + " years old. I live in " + city + ".")

greet("Bob", "20", "Los Angeles")
greet("Alice", "25")

在上面的代码中，city 是默认参数，其默认值为 "New York"。在函数定义中，我们为 city 参数指定了默认值，因此在调用函数时可以省略该参数。在上面的示例中，第一个调用 greet("Bob", "20", "Los Angeles") 语句传递了 name、age 和 city 三个参数，其中 city 参数使用了非默认值 "Los Angeles"。而第二个调用 greet("Alice", "25") 语句中省略了 city 参数，因此使用了默认值 "New York"。

2.3可变位置参数

可变位置参数是指函数调用时，在参数列表前添加一个 * 号，表示该参数是一个可变位置参数，它将所有传入的参数打包成一个元组，函数可以使用这个元组进行相关的操作。下面是一个可变位置参数的例子：

def greet(*names):
    for name in names:
        print("Hello, my name is " + name + ".")

greet("Bob", "Alice", "Charlie")

在上面的代码中，我们使用 *names 作为可变位置参数，这意味着 greet() 函数可以接受任意数量的参数，并将这些参数打包成一个元组。在函数体中，我们使用 for 循环遍历元组中的每个元素，并输出相应的字符串。在上面的示例中，我们调用了 greet("Bob", "Alice", "Charlie") 语句，并将 "Bob"、"Alice" 和 "Charlie" 三个参数作为可变位置参数传递给了函数。

2.4可变关键字参数

可变关键字参数是函数调用时，在参数列表前添加两个 * 号，表示该参数是一个可变关键字参数，它将所有传入的关键字参数打包成一个字典，函数可以使用这个字典进行相关的操作。下面是一个可变关键字参数的例子：

def greet(**kwargs):
    for key, value in kwargs.items():
        print("My " + key + " is " + value + ".")

greet(name="Bob", age="20", city="New York")

在上面的代码中，我们使用 **kwargs 作为可变关键字参数，这意味着 greet() 函数可以接受任意数量的关键字。

3.返回值

在 Python 中，函数可以通过 return 语句来将结果返回给调用方。当函数执行到 return 语句时，函数会立即停止执行，并将结果返回给调用方。如果函数没有指定 return 语句，则默认返回 None。

下面是一个函数返回值的例子：

def add(a, b):
    return a + b

result = add(1, 2)
print(result)

在上面的代码中，我们定义了一个 add() 函数，用于计算两个数的和。当函数执行到 return 语句时，会将计算结果返回给调用方。在 main() 函数中，我们调用 add() 函数，并将计算结果赋值给变量 result，然后使用 print() 函数输出该变量的值。

需要注意的是，在函数中可以返回任何类型的值，包括数字、字符串、布尔值、列表、元组、字典等等。需要根据具体的情况来选择合适的返回值类型，以便于调用方方便地使用该返回值。

此外，在函数中可以有多个 return 语句，返回不同的值。需要根据函数的具体需求来决定何时返回相应的值。在函数中，当有 return 语句被执行时，表示函数已经执行完毕，因此后面的代码将不会被执行。

4.函数变量

在 Python 中，变量的作用域指的是变量的可见范围，也就是变量生效的区域。Python 的变量作用域分为全局作用域和局部作用域两种。

4.1全局变量

在函数外部定义的变量是全局变量，全局变量在程序的任何地方都可以被访问，包括函数内部和外部。当在函数内部修改全局变量的值时，需要在函数内部通过 global 关键字显式声明变量名，并且在之后的代码中使用变量名时需要使用到该关键字。如果在函数内部没有通过 global 声明变量名，则视为在函数内部创建了一个新的局部变量，不会对全局变量产生影响。下面是一个全局变量的例子：

a = 10

def foo():
    global a
    a = a + 1
    print(a)

foo()
print(a)

在上面的代码中，我们在函数外部定义了一个全局变量 a，并赋值为 10。在函数内部，我们使用 global 关键字声明 a 变量为全局变量，并对其进行操作。在函数调用时，我们将会输出 11，其中 a 的值被改变为了 11。在函数调用完毕之后，在程序的其它地方输出 a 的值，仍然为 11。

4.2局部变量

在函数内部定义的变量是局部变量，只能在函数内部被访问和修改。当函数结束时，局部变量的生命周期也将结束，变量将被垃圾回收。下面是一个局部变量的例子：

def foo():
    b = 20
    print(b)

foo()

在上面的代码中，我们在函数内部定义了一个局部变量 b，其作用域只能是在该函数内部。在函数调用时，我们将会输出局部变量 b 的值 20。

需要注意的是，在嵌套函数中，内部函数可以访问外部函数中定义的变量，但是无法修改其值（除非通过 nonlocal 关键字声明为非局部变量）。例如：

def outer():
    a = 10
    def inner():
        nonlocal a
        a = a + 1
        print(a)
    inner()
    print(a)

outer()

在上面的代码中，inner() 函数可以访问 outer() 函数中定义的变量 a，但是无法通过赋值语句来修改其值。如果需要修改该变量，则需要在 inner() 函数中通过 nonlocal 关键字将其声明为非局部变量。在函数调用完毕之后，我们将输出 a 的值，其值为 11。

（五）数据容器

在 Python 中，数据容器（也称为序列）是一种可变或不可变对象，用于存储多个对象（通常是相同类型）的数据结构。Python 提供了多种内置的数据容器，包括列表（list）、元组（tuple）、字符串（string）、集合（set）和字典（dict）等。下面将对这些数据容器进行简单的介绍。

1.列表（list）

列表是 Python 中最常用的数据容器之一，它是一组有序的、可变的对象集合。列表用方括号 [] 来表示，列表中的各个元素之间用逗号 , 分隔。列表中的元素可以是任何数据类型，包括数字、字符串、列表等。列表中的元素可以通过下标（索引）来访问，列表中的第一个元素下标为 0。下面是一个列表的例子：

fruits = ['apple', 'banana', 'orange']

在 Python 中，列表（list）是一种有序、可变的数据容器，可以存储任意类型的数据，包括数字、字符串、列表、元组、集合、字典等。列表用方括号 [] 来表示，列表中的各个元素之间用逗号 , 分隔。列表中的元素可以通过下标（索引）来访问，其中第一个元素的下标为 0。

1.1创建列表

创建列表可以使用以下方式：

# 空列表
list1 = []

# 指定元素的列表
list2 = [1, 2, 3, 4]

# 混合类型的列表
list3 = [1, 'apple', [2, 3], {'name': 'Bob'}]

# 列表推导式
list4 = [x ** 2 for x in range(5)]

1.2访问列表元素

访问列表元素需要使用下标（索引），下标从 0 开始，可以是整数或负数。当下标为负数时，表示从右侧往左数的索引，其中 -1 表示最后一个元素。

fruits = ['apple', 'banana', 'orange']
print(fruits[0])    # 输出: apple
print(fruits[-1])   # 输出: orange

1.3修改列表元素

通过下标可以修改列表元素，也可以使用切片来批量修改列表元素。

# 修改单个元素
fruits = ['apple', 'banana', 'orange']
fruits[1] = 'pear'
print(fruits)   # 输出: ['apple', 'pear', 'orange']

# 切片修改元素
fruits = ['apple', 'banana', 'orange', 'pear']
fruits[1:3] = ['pineapple', 'watermelon']
print(fruits)   # 输出: ['apple', 'pineapple', 'watermelon', 'pear']

1.4添加/删除列表元素

可以使用 append() 方法向列表末尾添加一个元素，也可以使用 insert() 方法在指定位置插入一个元素。可以使用 remove() 方法删除列表中指定的元素，也可以使用 pop() 方法弹出列表中指定下标的元素。

# 添加单个元素
fruits = ['apple', 'banana', 'orange']
fruits.append('pear')
print(fruits)   # 输出: ['apple', 'banana', 'orange', 'pear']

# 插入元素
fruits = ['apple', 'banana', 'orange']
fruits.insert(1, 'pear')
print(fruits)   # 输出: ['apple', 'pear', 'banana', 'orange']

# 删除元素
fruits = ['apple', 'banana', 'orange', 'pear']
fruits.remove('orange')
print(fruits)   # 输出: ['apple', 'banana', 'pear']

# 弹出元素
fruits = ['apple', 'banana', 'orange', 'pear']
fruit = fruits.pop(1)
print(fruit)    # 输出: banana
print(fruits)   # 输出: ['apple', 'orange', 'pear']

2.元组（tuple）

元组是一组有序的、不可变的对象集合。在 Python 中，元组用圆括号 () 来表示，元组中的各个元素之间用逗号 , 分隔。和列表类似，元组中的元素可以是任何数据类型，不同点在于元组一旦创建就不能修改。元组中的元素可以通过下标（索引）来访问，元组中的第一个元素下标为 0。下面是一个元组的例子：

months = ('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December')

3.字符串（string）

字符串是一组有序的、不可变的字符集合。在 Python 中，字符串可以用单引号、双引号或三引号表示。字符串中的各个字符之间可以使用下标访问，其中第一个字符下标为 0。字符串是不可变的，一旦创建就无法修改其中的元素。下面是一个字符串的例子：

greeting = "Hello, World!"

4.集合（set）

集合是 Python 中不重复元素集合。在 Python 中，集合用花括号 {} 或 set() 函数来表示。集合中的元素是无序的，且每个元素只出现一次。集合中的元素可以是任何不可变的数据类型，例如数字、字符串、元组等。下面是一个集合的例子：

set1 = {1, 2, 3, 4}
set2 = set([2, 3, 4, 5])

5.字典（dict）

字典是 Python 中一种映射类型的数据容器，它使用键来访问值。在 Python 中，字典用花括号 {} 表示，键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。字典中的键必须是唯一的、不可变的类型（例如数字、字符串、元组等），而值可以是任意数据类型。下面是一个字典的例子：

person = {'name': 'Bob', 'age': 20, 'city': 'New York'}

以上是 Python 中常用数据容器的简单介绍。需要注意的是，这些数据容器都有各自的优缺点和适用场景，我们需要根据具体需求选择合适的数据容器来存储数据。