目录
学前热知识
Python是一种高级编程语言，它的设计目标是让代码易于阅读、易于编写。Python的语法非常简洁，这就使得学习起来相对容易。另外，Python是一种解释型语言，这意味着你可以直接运行Python代码，而不用像其他编程语言那样先进行编译。
Python支持多种编程范式，例如面向对象编程、函数式编程和过程式编程。这就使得Python非常灵活，可以应用于各种不同的项目中。
Python有一个庞大的生态系统，包含了很多第三方库和框架，用于处理各种任务，如数据分析、机器学习、Web开发等。这些库和框架让Python变得非常强大，几乎可以应对任何编程挑战。
Python的一些主要特点包括：
- 可读性强：Python的语法设计非常简洁，使得代码易于阅读和编写。
- 易于学习：Python的语法简单，入门容易，适合初学者。
- 多范式支持：Python支持面向对象、函数式和过程式编程，适应不同的编程需求。
- 开源：Python是开源的，你可以自由地使用和修改。
- 跨平台：Python可以在不同的操作系统上运行，如Windows、Mac和Linux。
- 强大的标准库：Python有一个强大的标准库，提供了很多内置功能，可以帮助你快速实现各种功能。
- 第三方库丰富：Python有很多优秀的第三方库，可以帮助你完成各种任务，如NumPy、Pandas、TensorFlow等。
基础概述
Python是一种编程语言，它的设计目标是易读性和简洁性。它通常被用于网页开发、数据分析、人工智能和更多。
首先，我们来看看Python中的变量。变量就像是一个标签，你可以把它贴在任何数据上。例如：
x = 5
y = "Hello, World!"
在这个例子中，x是一个变量，我们给它赋值为5。y也是一个变量，我们给它赋值为"Hello, World!"。
接下来，我们看看Python中的数据类型。Python有许多内置的数据类型，包括整数（int）、浮点数（float）、字符串（str）等。例如：
x = 5 # 这是一个整数
y = 5.0 # 这是一个浮点数
z = "Hello, World!" # 这是一个字符串
Python还有一些复合数据类型，如列表（list）、元组（tuple）和字典（dict）。列表是一个有序的数据集合，元组是一个不可变的有序数据集合，而字典是一个无序的键值对集合。例如：
list1 = [1, 2, 3, 4, 5] # 这是一个列表
tuple1 = (1, 2, 3, 4, 5) # 这是一个元组
dict1 = {"apple": 1, "banana": 2, "cherry": 3} # 这是一个字典
接下来，我们看看Python中的控制流。控制流是程序执行的顺序。Python中的控制流包括条件语句（if...elif...else）和循环语句（for和while）。例如：
x = 5
if x > 0:
print("x is positive")
elif x < 0:
print("x is negative")
else:
print("x is zero")
在这个例子中，程序首先检查x是否大于0。如果是，它打印"x is positive"。如果不是，它检查x是否小于0。如果是，它打印"x is negative"。如果还不是，它打印"x is zero"。
二.基础知识
1.运算法则
当然，Python中的运算法则和我们在学校学到的基本数学运算法则非常相似。
1. 加法 (+) 和减法 (-)：这两个运算符在Python中的作用就如同它们在数学中的作用一样。
x = 5 + 3 # x现在是8
y = 5 - 3 # y现在是2
2. 乘法 (*) 和除法 (/)：这两个运算符也是和数学中一样的。
x = 5 * 3 # x现在是15
y = 5 / 3 # y现在是1.6666666666666667
3. 整除 (//) 和模数 (%)：整除运算符返回商的整数部分，而模数运算符返回除法的余数。
x = 5 // 3 # x现在是1
y = 5 % 3 # y现在是2
4. 幂运算符 (**)：这个运算符用于计算数的幂。
x = 5 ** 3 # x现在是125
5. 括号：你可以使用括号来改变运算的优先级，就像在数学中一样。
x = (5 + 3) * 2 # x现在是16，而不是11
注意：Python中的运算优先级是：括号 > 幂运算 > 乘法/除法/整除/模数 > 加法/减法。当有相同优先级的运算符时，Python会从左到右进行计算。
2.基本函数
str 函数
我们经常需要在消息中使用变量的值，使用str()可以避免错误
例如在输入数字23的时候，python可能理解为数值23也可能为字符2和3
trip 函数
-
strip()：这个函数用于去除字符串两边的空白字符，包括空格、换行符和其他一些特殊字符
-
lstrip()：这个函数只去除字符串左边的空白字符
-
rstrip()：这个函数只去除字符串右边的空白字符
操作列表函数
-
insert()：这个函数用于在列表的特定位置插入一个元素。例如，如果我们有一个列表 a = [1, 2, 3]，我们可以通过 a.insert(1, 'b') 来在位置 1 插入元素 'b'，然后列表 a 就变成了 [1, 'b', 2, 3]。
-
pop()：这个函数用于移除列表中的一个元素，并且返回这个元素的值。如果我们调用 a.pop(1)，那么 'b' 就会被从列表 a 中移除，并且这个函数会返回 'b'。
-
remove()：这个函数用于移除列表中的特定元素。例如，如果我们调用 a.remove(1)，那么数字 1 就会被从列表 a 中移除。如果列表中有多个相同的元素，只有第一个会被移除
-
sort() 是列表（list）的一个方法，它会直接修改原列表，使其元素按照一定的顺序排列，这种操作被称为就地排序（in-place sorting）。例如，如果我们有一个列表 a = [3, 1, 4, 1, 5, 9]，调用 a.sort() 之后，a 会变成 [1, 1, 3, 4, 5, 9]。
-
sorted() 是 Python 的一个内置函数，它可以接受任何可迭代的对象（如列表、元组、字符串等），并返回一个新的、包含了原序列所有元素、按照一定顺序排列的列表。原序列不会被修改。例如，如果我们有一个元组 t = (3, 1, 4, 1, 5, 9)，那么 sorted(t) 的结果就是 [1, 1, 3, 4, 5, 9]，而 t 本身仍然是 (3, 1, 4, 1, 5, 9)。
-
range() 是一个内置函数，它生成一个数列，通常用在循环中。这个函数可以接受一到三个参数。 当只有一个参数时，例如 range(n)，它将生成从 0 到 n-1 的整数序列。当有两个参数时，例如 range(m, n)，它将生成从 m 到 n-1 的整数序列。例如，range(5) 会生成 [0, 1, 2, 3, 4]，range(2, 5) 会生成 [2, 3, 4]，range(2, 10, 2) 会生成 [2, 4, 6, 8]。2是步长
-
list() 函数可以接收一个可迭代对象（如字符串、元组或其他序列类型）作为参数，并返回一个包含了所有迭代元素的列表。
例如，如果我们执行 list('hello')，那么返回的结果将会是 ['h', 'e', 'l', 'l', 'o']，这是一个字符列表。如果我们执行 list((1, 2, 3))，那么返回的结果将会是 [1, 2, 3]，这是一个整数列表。
3.列表切片
在Python中，切片是从列表（或任何序列类型，如字符串和元组）中提取出一部分元素的操作。
列表切片的基本语法是：`list[start:stop:step]`
- start：开始索引，从该索引位置开始切片。如果省略，默认从0开始。
- stop：结束索引，切片到此索引位置结束（但不包含此索引位置的元素）。如果省略，默认切片到列表的末尾。
- step：步长，每次切片跳过的元素数量。如果省略，默认为1。
例如，我们有一个包含0到9的列表：
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
我们可以使用切片来获取列表的一部分：
sub_numbers = numbers[1:5] # 获取索引1到4的元素，结果是[1, 2, 3, 4]
我们可以改变步长来获取列表的每个第二个元素：
even_numbers = numbers[::2] # 获取所有偶数索引的元素，结果是[0, 2, 4, 6, 8]
我们也可以使用负索引来从列表的末尾开始切片：
last_numbers = numbers[-3:] # 获取最后三个元素，结果是[7, 8, 9]
还有一点很有趣，我们可以使用切片来快速复制一个列表：
numbers_copy = numbers[:] # 创建一个新的列表，包含numbers的所有元素
4.流语句
for语句
在Python中，for语句是一种常见的循环结构，用于遍历可迭代对象（如列表、元组、字符串等）中的每个元素。for语句的基本语法如下：
for 变量 in 可迭代对象:
循环体（需要执行的代码块）
让我通过一个简单的例子来解释一下：
假设我们有一个列表，其中包含一些水果的名称：
fruits = ['apple', 'banana', 'orange']
我们想要遍历这个列表，并打印出每个水果的名字。我们可以使用for语句来实现这个目标：
for fruit in fruits:
print(fruit)
当我们运行这段代码时，我们将看到以下输出：
apple
banana
orange
在这个例子中，`fruit`是我们的变量，`fruits`是可迭代对象（一个列表）。在每次循环中，变量`fruit`将被赋值为列表中的下一个元素，然后执行循环体（`print(fruit)`）。当遍历完列表中的所有元素后，循环结束。
同样，我们也可以使用for语句遍历字符串中的每个字符：
word = 'python'
for char in word:
print(char)
这将输出：
p
y
t
h
o
n
for语句是Python中用于遍历可迭代对象的强大工具，可以帮助我们在编写代码时更加简洁高效。
if语句
在Python中，if语句用于基于条件执行特定的代码块。换句话说，当满足某个条件时，我们希望执行某些操作，而当条件不满足时，我们可能希望执行其他操作。if语句的基本语法如下：
if 条件:
代码块1（当条件为真时执行）
我们还可以使用`elif`（else if的缩写）和`else`子句来检查多个条件并在不同情况下执行不同的代码块：
if 条件1:
代码块1（当条件1为真时执行）
elif 条件2:
代码块2（当条件1为假，条件2为真时执行）
else:
代码块3（当条件1和条件2都为假时执行）
让我们通过一个简单的例子来说明这个概念：
假设我们有一个变量`age`，我们想要判断这个年龄所属的年龄段：
age = 18
if age < 13:
print("You are a child.")
elif age < 18:
print("You are a teenager.")
else:
print("You are an adult.")
当我们运行这段代码时，将会输出：
You are an adult.
在这个例子中，我们首先检查`age`是否小于13（`age < 13`），如果满足条件，我们输出"You are a child."。如果不满足第一个条件，我们继续检查第二个条件（`age < 18`），如果满足，我们输出"You are a teenager."。最后，如果前两个条件都不满足，我们执行`else`子句，输出"You are an adult."。
通过使用if语句，我们可以根据不同的条件执行不同的操作，从而使代码更加灵活和易于理解。
if-for嵌套语句
嵌套语句是指在一个代码块（如if语句、循环等）内部包含另一个代码块的情况。这使得我们可以在满足某个条件或在循环的每次迭代中执行更复杂的操作。嵌套语句可以是嵌套的if语句、嵌套的循环（如for或while循环）等。
1. 嵌套if语句
嵌套if语句是指在一个if语句内部包含另一个if语句。这可以让我们根据多个条件执行不同的操作。例如：
num = 12
if num >= 0:
if num == 0:
print("Zero")
else:
print("Positive number")
else:
print("Negative number")
在这个例子中，我们首先检查数字是否大于等于0，如果满足这个条件，我们进入第一个if语句的内部。然后我们检查数字是否等于0，如果满足这个条件，打印"Zero"，否则打印"Positive number"。如果最初的条件不满足（数字小于0），我们打印"Negative number"。
2. 嵌套循环
嵌套循环是指在一个循环内部包含另一个循环。这允许我们对多个维度进行迭代，例如在矩阵或列表的列表中。例如：
for i in range(3): # 外层循环
for j in range(3): # 内层循环
print(i, j)
在这个例子中，我们有两个循环：外层循环遍历变量i（取值0, 1, 2），内层循环遍历变量j（同样取值0, 1, 2）。在这种情况下，我们将打印出所有可能的(i, j)组合。
运行代码展示
例一：嵌套if语句
num = 12
if num >= 0:
if num == 0:
print("Zero")
else:
print("Positive number")
else:
print("Negative number")
当我们运行这段代码时，将会输出：
Positive number
在这个例子中，数字12大于0，因此我们进入第一个if语句的内部。然后我们检查12是否等于0，这个条件不满足，所以我们跳过`print("Zero")`，执行`else`子句，打印出"Positive number"。
例二：嵌套循环
for i in range(3): # 外层循环
for j in range(3): # 内层循环
print(i, j)
当我们运行这段代码时，将会输出：
0 0
0 1
0 2
1 0
1 1
1 2
2 0
2 1
2 2
在这个例子中，对于外层循环的每一次迭代（即，对于i = 0, 1, 2），我们都完全执行一次内层循环。在内层循环中，我们遍历j = 0, 1, 2，并打印出(i, j)。这就是为什么我们看到了所有可能的(i, j)组合。
例三：if-for组合嵌套
我们将找出1到10之间的所有奇数，并将它们乘以2。
for i in range(1, 11):
if i % 2 != 0:
doubled_odd_number = i * 2
print(f"{i}是奇数，它的两倍是{doubled_odd_number}")
在这个例子中，我们使用`for`循环遍历从1到10的整数（包括1，不包括11）。在循环内部，我们使用`if`语句判断当前数字`i`是否为奇数（即`i % 2 != 0`，其中`%`表示取余运算）。
如果`i`是奇数，我们将它乘以2得到`doubled_odd_number`，然后使用`print()`函数输出结果。这个例子展示了如何在Python中使用嵌套的if-for组合来完成特定任务。
它的运行结果为：
1是奇数，它的两倍是2
3是奇数，它的两倍是6
5是奇数，它的两倍是10
7是奇数，它的两倍是14
9是奇数，它的两倍是18
注意：过深的嵌套可能会使代码更难理解和维护，因此在使用时需要注意保持代码的清晰和简洁。
5.字典
基础性质
字典在Python中是一种非常重要的数据类型，我们可以把它看作是一个无序的键值对集合，也就是说它是一个容器，存放的数据是成对出现的。
字典的每个键值对就像一个条目，键是条目的名字，值是条目的内容。键值对在字典中是无序的，所以我们不能像列表那样通过索引位置来访问字典中的值，而是通过键来访问。
字典在Python中的定义非常简单，我们使用大括号{}来创建一个空字典，然后在大括号内部用逗号分隔开不同的键值对，键值对之间用冒号分隔开键和值。例如，我们可以创建一个包含人的姓名和年龄的字典：
person = {"name": "Alice", "age": 25}
在这个例子中，"name"和"age"就是键，"Alice"和25就是对应的值。我们可以通过键来访问字典中的值，像这样：
print(person["name"]) # 输出"Alice"
print(person["age"]) # 输出25
如果我们想要修改字典中的值，也可以直接通过键来做：
person["age"] = 26 # 修改字典中的值
print(person["age"]) # 输出26
字典是非常有用的数据结构，它可以帮助我们组织和处理大量的数据，并且访问速度非常快。在实际编程中，我们会经常使用到字典。
遍历字典
在Python中，遍历字典有多种方式。最常见的三种方式是遍历字典的键，遍历字典的值，以及遍历字典的键值对。
1. 遍历字典的键：
person = {"name": "Alice", "age": 25}
for key in person:
print(key)
这段代码会输出"name"和"age"，这就是字典的所有键。
2. 遍历字典的值：
`
person = {"name": "Alice", "age": 25}
for value in person.values():
print(value)
这段代码会输出"Alice"和"25"，这就是字典的所有值。
3. 遍历字典的键值对：
person = {"name": "Alice", "age": 25}
for key, value in person.items():
print(key, value)
这段代码会输出"name Alice"和"age 25"，这就是字典的所有键和对应的值。
这就是在Python中遍历字典的基本方法。你可以根据自己的需要选择合适的遍历方式。
break和continue，更好的操控字典
`break`和`continue`是Python中用于控制循环流程的关键字，它们通常与`for`或`while`循环一起使用。虽然它们不是字典特有的功能，但它们可以与字典结合使用。
让我们先了解`break`和`continue`的基本用法，然后再看一下如何将它们应用到字典中。
1. `break`：`break`关键字用于跳出当前循环，也就是说，当程序遇到`break`时，它会立即停止当前循环，跳到循环之后的代码。
for i in range(10):
if i == 5:
break
print(i)
在这个例子中，当`i`等于5时，`break`语句会被执行，循环会立即终止，所以输出结果是0, 1, 2, 3, 4。
2. `continue`：`continue`关键字用于跳过当前循环的剩余部分，然后继续下一次循环。
for i in range(10):
if i == 5:
continue
print(i)
在这个例子中，当`i`等于5时，`continue`语句会被执行，循环会跳过剩余的部分（即`print(i)`），然后继续下一次循环。所以输出结果是0, 1, 2, 3, 4, 6, 7, 8, 9。
现在我们来看一个与字典结合的例子：
my_dict = {"apple": 1, "banana": 2, "orange": 3, "grape": 4}
for key, value in my_dict.items():
if key == "banana":
break
print(key, value)
在这个例子中，我们遍历字典`my_dict`的键值对。当遇到键为"banana"时，`break`语句会被执行，循环会立即终止。所以输出结果是"apple 1"。
下面是一个使用`continue`的例子：
for key, value in my_dict.items():
if key == "banana":
continue
print(key, value)
在这个例子中，当遇到键为"banana"时，`continue`语句会被执行，循环会跳过剩余的部分（即`print(key, value)`），然后继续下一次循环。所以输出结果是"apple 1"、"orange 3" 和 "grape 4"。
6.用户输入和while循环
让我们先了解用户输入，然后再讲解while循环及其操作方法。
用户输入
在Python中，我们可以使用`input()`函数来获取用户输入。`input()`函数可以接受一个可选的字符串参数，这个字符串将作为提示信息显示给用户。例如：
name = input("请输入您的名字：")
print("您的名字是：", name)
这段代码将提示用户输入他们的名字，并将输入的名字赋值给变量`name`。然后，我们使用`print()`函数输出名字。
while循环
while循环是一种重复执行一段代码的结构，直到满足某个条件为止。它的基本语法如下：
while 条件:
# 循环体（需要执行的代码）
当条件为真（True）时，循环体中的代码将被执行。当条件变为假（False）时，循环将停止。
让我们通过一个简单的例子来说明如何使用while循环：
count = 0
while count < 5:
print("count的值是：", count)
count += 1 # 这相当于 count = count + 1
这段代码将输出count的值，从0到4。当count达到5时，循环将停止。
现在，让我们结合用户输入和while循环来创建一个简单的猜数字游戏：
import random
# 生成一个1到10之间的随机数
target_number = random.randint(1, 10)
user_guess = None
while user_guess != target_number:
user_guess = int(input("请输入一个1到10之间的数字："))
if user_guess < target_number:
print("猜小了，请再试一次！")
elif user_guess > target_number:
print("猜大了，请再试一次！")
else:
print("恭喜你，猜对了！")
这个游戏会不断提示用户输入一个数字，直到用户猜对为止。在每次循环中，我们会检查用户输入的数字与目标数字的大小关系，并给出相应的提示。
注：
randint()函数
是Python的random模块中的一个函数，用于生成一个指定范围内的随机整数。它的基本语法如下：
random.randint(a, b)
这里，`a`和`b`是两个整数，`randint(a, b)`会返回一个`a`和`b`之间的随机整数，包括`a`和`b`。
例如，`random.randint(1, 10)`将会生成一个1到10之间的随机整数。每次调用这个函数，都可能得到不同的结果。
下面是一个使用`randint()`函数的简单例子：
import random
for i in range(5):
print(random.randint(1, 10))
这段代码将打印出五个1到10之间的随机整数。每次运行这段代码，都可能得到不同的输出。
`randint()`函数非常适合于需要随机元素的场景，例如在创建一个猜数字游戏或者在随机选择元素时。
int（）函数
在Python中，`int()`函数用于将一个字符串或数字转换为整数。
如果你给`int()`函数一个字符串，它会尝试将这个字符串转换为整数：
num = int("123")
print(num) # 输出：123
这里，字符串"123"被转换为了整数123。
需要注意的是，如果你试图将一个不能转换为整数的字符串传给`int()`函数，例如一个包含非数字字符的字符串，Python会引发一个错误：
num = int("123abc") # 引发 ValueError: invalid literal for int() with base 10: '123abc'
你也可以给`int()`函数一个浮点数（即小数），它会将浮点数转换为整数。在这种情况下，`int()`函数将删除小数点及其后面的所有数字，这称为向下取整：
num = int(123.456)
print(num) # 输出：123
这里，浮点数123.456被转换为了整数123。
`int()`函数在你需要将用户输入或其他数据转换为整数时非常有用。例如，如果你使用`input()`函数获取用户输入，`input()`函数总是返回一个字符串，即使用户输入的是一个数字。你可以使用`int()`函数将这个字符串转换为整数，然后进行进一步的处理：
`
num = int(input("请输入一个整数："))
print("你输入的整数加10等于", num + 10)
这个例子会提示用户输入一个整数，然后输出这个整数加10的结果。
防混贴士（int和str函数）
虽然两者作用相反，但我平时就很容易搞不清楚，这里姑且提一下
str()和int()函数的主要区别在于它们的作用和使用场景。
int()函数，如我之前所述，用于将一个字符串或数字转换为整数。
而`str()`函数则用于将其他类型的数据转换为字符串。例如，你可以将一个整数或一个浮点数转换为字符串：
num_str = str(123)
print(num_str) # 输出：'123'
float_str = str(123.456)
print(float_str) # 输出：'123.456'
在这两个例子中，str()函数将一个整数和一个浮点数转换为了字符串。
`str()`函数在你需要将非字符串数据转换为字符串时非常有用。例如，如果你想将一个数字与一个字符串进行拼接，你需要先将这个数字转换为字符串：
num = 123
print("你的号码是：" + str(num)) # 输出：'你的号码是：123'
在这个例子中，如果你不使用str()函数，而是直接将一个数字与一个字符串进行拼接，Python会引发一个错误，因为它不知道如何将一个数字与一个字符串进行拼接。
int()和str()函数都是用于数据类型转换的工具，但它们适用于不同的场景：`int()`用于将数据转换为整数，str()用于将数据转换为字符串。
7.定义函数
在Python中，我们使用`def`关键字来定义一个函数。函数的定义包括以下几个部分：
1. 函数名：一个描述性的名字，用于表示这个函数的功能。函数名应该是小写的，多个单词之间可以使用下划线连接。
2. 参数列表：括号内的一系列变量，用于接收从外部传入的值。当调用函数时，我们需要给这些参数提供值。参数可以有默认值，如果调用函数时没有给某个参数提供值，那么这个参数将使用默认值。
3. 冒号：用于表示函数定义的开始。
4. 函数体：缩进的代码块，包含了函数要执行的任务。函数体中可以包含任意的Python代码。
5. 返回值：使用`return`关键字返回函数的结果。当函数被调用时，它将计算一个值并将其返回给调用者。如果没有返回值，函数将返回`None`。
下面是一个简单的函数定义示例：
def greet(name):
greeting = "Hello, " + name + "!"
return greeting
这个函数接受一个名为`name`的参数，然后拼接一个问候语，并将结果返回给调用者。
我们可以通过函数名和括号来调用函数，并传入所需的参数。例如：
greeting = greet("Alice")
print(greeting) # 输出：Hello, Alice!
通过定义和调用函数，可以将复杂的问题分解为更小、更易于管理的部分。
实参和形参
说到函数就要点一下实参和形参的概念，毕竟这可是万物基础๑乛◡乛๑
函数就好像是一个小工厂，你把原料（这里的原料就是参数）送进去，工厂就会按照一定的规则（函数中的代码）处理这些原料，然后出产产品（返回结果）。
在这个过程中，形参就好比是原料的模具，它只是定义了需要什么样的原料，但并没有实质的内容。比如，我们定义一个函数，用于计算两个数的和，那么这两个数就是形参。
def add(a, b): # 这里的a和b就是形参
return a + b
而实参，就是我们在调用函数时真正传入的“原料”，有了实质的内容。比如，我们要调用上面的add函数，需要给它提供两个数，这两个数就是实参。
result = add(3, 5) # 这里的3和5就是实参
在这个例子中，当我们调用add函数时，实参3和5就按照位置，分别赋值给了形参a和b。然后，函数就能正确地进行计算，并返回结果。
所以，形参和实参其实是相对的，形参是在定义函数时使用，用来描述函数需要什么样的输入；实参是在调用函数时使用，用来提供具体的输入。
传递实参
1. 位置实参：这是最直接的方式，实参的顺序和函数定义中的参数顺序一致。例如，有一个函数定义如下：
def describe_pet(pet_type, pet_name):
print(f"I have a {pet_type}")
print(f"My {pet_type}'s name is {pet_name}")
你可以这样调用它：
describe_pet('hamster', 'harry')
输出会是：
I have a hamster
My hamster's name is harry
这里，'hamster'和'harry'就是位置实参。
2. 关键字实参：是传递给函数的名称-值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆。关键字实参无需考虑函数调用中的实参顺序。同样的函数，你可以这样调用：
describe_pet(pet_name='harry', pet_type='hamster')
输出依然是：
I have a hamster
My hamster's name is harry
即使改变了实参的顺序，结果也是一样的。
3. **默认值**：当调用函数的时候，如果没有给参数提供值，那么这个参数就会使用默认值。在定义函数的时候，我们可以为参数设置默认值。例如，我们可以修改上面的函数，让大多数宠物都预设为'dog'：
def describe_pet(pet_name, pet_type='dog'):
print(f"I have a {pet_type}")
print(f"My {pet_type}'s name is {pet_name}")
然后这样调用它：
describe_pet('willie')
输出会是：
I have a dog
My dog's name is willie
这里，如果我们只提供了一个实参，那么Python将把这个实参视为位置实参，且用这个实参来填充第一个参数。因为我们没有给第二个参数提供值，所以它将使用默认值'dog'。
更新ing......
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
