【Python基础：语法第三课】Python 函数详解：定义、参数、返回值与作用域
🎬 个人主页：艾莉丝努力练剑
❄专栏传送门：《C语言》《数据结构与算法》《C/C++干货分享&学习过程记录》
《Linux操作系统编程详解》《笔试/面试常见算法：从基础到进阶》《Python干货分享》
⭐️为天地立心，为生民立命，为往圣继绝学，为万世开太平
🎬 艾莉丝的简介：
文章目录
- 1 ~> 什么是函数？
- 2 ~> 语法格式
- 3 ~> 函数参数：实参、形参
- 4 ~> 函数返回值
- 5 ~> 变量作用域
- 6 ~> 函数执行过程
- 7 ~> 链式调用和嵌套调用
- 8 ~> 局部变量和函数栈帧
- 9 ~> 函数递归
- 10 ~> 参数默认值
- 11 ~> 关键字参数
- 12 ~> Python基础语法：函数部分小结
- 结尾
1 ~> 什么是函数？
1.1 函数的概念
我们编程中的函数其实和数学中的函数有一定的相似之处：
数学上的函数，比如y=sinx，x取不同的值，y就会得到不同的结果
编程中的函数，指的是 一段可以被重复使用的代码片段。
1.2 代码示例
1.2.1 代码示例：求数列的和，不使用函数
# 1. 求 1 - 100 的和sum=0for i inrange(1,101):sum+= i print(sum)# 2. 求 300 - 400 的和sum=0for i inrange(300,401):sum+= i print(sum)# 3. 求 1 - 1000 的和sum=0for i inrange(1,1001):sum+= i print(sum)我们通过观察可以发现，这几组代码基本是相似的，只有一点点差异，可以把重复代码提取出来，写成一个函数。
实际开发中，复制粘贴是一种不太好的策略，实际开发的重复代码可能存在几十份甚至上百份。
一旦这个重复代码需要被修改，那就得改几十次，非常不便于维护。
1.2.2 代码示例：求数列的和，使用函数
# 定义函数defcalcSum(beg, end):sum=0for i inrange(beg, end +1):sum+= i print(sum)# 调用函数sum(1,100)sum(300,400)sum(1,1000)这里我们可以明显看到——重复的代码已经被消除了。
1.3 最佳实践：针对上面的示例
# 函数# 函数是什么# 三角函数 sin、cos# “隐射关系”# 函数：一段可以被反复使用的代码 ctrl + c，ctrl + v# 1、复制代码，必须要非常仔细地进行细节调整，尤其是在数据不同的情况下# 2、一旦复制过的代码需要调整，复制了几份就得调整几次（搞不清楚这个代码究竟被复制了几份了）# 因此，尽量还是不要复制代码，尽量做好代码“复用”# 其他逻辑都是一样的，我们可以用函数的方式，达到复用代码的效果# 1、求1 - 100的和 thSum =0for i inrange(1,101): thSum += i print(thSum)# 2、求300 - 400的和 thSum =0# 由于前面已经有了thSum了，这里相当于赋值操作for i inrange(300,401): thSum += i print(thSum)#3、求1 - 1000的和 thSum =0for i inrange(1,1001): thSum += i print(thSum)# 在新的文件里面实现这个函数
我们创建一个新的文件，并且在新的文件里面实现这个函数——
# 使用函数的方式来解决刚才的问题：# 有什么地方要改也只要改一次就好了# 定义一个求和函数defcalcSum(beg,end): theSum =0for i inrange(beg,end +1): theSum += i print(theSum)# 跟for同一级缩进# 调用函数# 求1 - 100的和 calcSum(1,100)#求300 - 400的和 calcSum(300,400)# 求1 - 1000的和 calcSum(1,1000)
2 ~> 语法格式
2.1 创建函数 / 定义函数
def 函数名(形参列表): 函数体 return 返回值 2.2 调用函数 / 使用函数
函数名(实参列表)// 不考虑返回值 返回值 = 函数名(实参列表)// 考虑返回值 2.2.1 函数定义并不会执行函数体内容，必须要调用才会执行：调用几次就会执行几次
deftest1():print('hello')# 如果光是定义函数, 而不调用, 则不会执行. 2.2.2 函数必须先定义，再使用
test3()# 还没有执行到定义, 就先执行调用了, 此时就会报错. deftest3():print('hello')报错——
2.2.3 类比
在霓虹国的热血动漫中，角色释放技能之前，需要大喊招式的名字，比如“草帽小子”蒙奇·D·路飞每次使用恶魔果实力量时就会喊出“橡胶橡胶！XXX”，像角色先喊招式再放大招这个行为就可以理解为 “先定义, 再使用”。
2.3 最佳实践
# 函数的定义和调用# 返回值 = 函数名（实参列表）# 先定义一个函数# 如果只是定义，而不去调用，则函数体里面的代码就不会执行！deftest():print('Alice')print('Alice')print('Alice')# 函数调用才会真正执行函数体里面的代码# 函数经过一次定义之后，可以被调用多次！ test() test() test() test() test()# 运行结果：# Alice# Alice# Alice# Alice# Alice# Alice# Alice# Alice# Alice# Alice# Alice# Alice# Alice# Alice# Alice# Python中要求，函数定义写在前面，函数调用写在后面-->先定义，后调用2.4 代码警告的处理
# 代码警告的处理# 警告-->提示你的代码可能存在问题，但是并不影响程序编译执行（比较严重）# 错误-->代码中实打实的有问题！（非常严重！影响到代码了）# 这两个事情严重程度是完全不同的！# 定义一个求和函数# 点击[忽略这个“错误（远不到错误这个级别，只能说是警告）”]defcalcSum(beg, end):# 报了警告 theSum =0# 刚才是函数名，这里是变量名，我们同样选择[忽略]for i inrange(beg,end +1): theSum += i print(theSum)# 跟for同一级缩进# 调用函数# 求1 - 100的和 calcSum(1,100)#求300 - 400的和 calcSum(300,400)# 求1 - 1000的和 calcSum(1,1000)# 文件末尾建议加上空行# PEP8，这是Pyhton里面一套非常流行的编程规范，也就是写代码中的一些“软性要求”# 未来咱们在公司里面究竟是使用啥样的规范？不确定，只要代码风格干净整洁即可。3 ~> 函数参数：实参、形参
3.1 概念
在函数定义的时候，可以在（）中指定“形式参数”（简称形参），然后在调用的时候，由调用者把“实际参数’（简称实参）传递进去。
这样就可以做到：一份函数，针对不同的数据进行计算处理。
3.2 示例
我们结合一下前面的代码示例——
defcalcSum(beg, end):sum=0for i inrange(beg, end +1):sum+= i print(sum)sum(1,100)sum(300,400)sum(1,1000)上面的代码中，beg，end就是函数的形参1，100 / 300，400就是函数的实参。
在执行sum(1，100)的时候，就相当于beg = 1，end = 100，然后在函数内部就可以针对1 - 100进行运算。
在执行sum(300，400)的时候，就相当于beg = 300，end = 400，然后在函数内部就可以针对300 - 400 进行运算。
实参和形参之间的关系，就像签合同一样。
甲方、乙方这就相当于形参，艾莉丝、鲁迪乌斯就是实参。
def 签合同(甲方, 乙方): 合同内容.... 签合同('艾莉丝','鲁迪乌斯') 签合同('艾莉丝','希露菲') 签合同('艾莉丝','洛琪希')3.3 注意
一个函数可以有一个形参，也可以有多个形参，也可以没有形参。
一个函数的形参有几个，那么传递实参的时候也得传几个，保证个数要匹配。
deftest(a, b, c):print(a, b, c) test(10)
和C++/Java不同，Python是动态类型的编程语言，函数的形参不必指定参数类型.换句话说，一个函数可以支持多种不同类型的参数。
deftest(a):print(a) test(10) test('hello') test(True)3.4 最佳实践
3.4.1 实参
# 函数的参数(1)# 形参和实参deftest(a,b,c):print(a,b,c) test(10)# 函数形参数量要和形参数量要匹配3.4.2 形参
# 函数的参数(2)# 形参和实参# def test(a):# print(a)## test(10)# test('hello')# test(True)defadd(a,b):return a + b print(add(10,20))# 整型相加print(add(1.5,2.5))# 浮点型相加print(add('hello','world'))# 字符串相加print(add(10,'hello'))# 报错，不能相加4 ~> 函数返回值
4.1 概念
函数的参数可以视为是函数的“输入”，则函数的返回值，就可以视为是函数的“输出”。
此处的“输入”，“输出”是更广义的输入输出，不是单纯指通过控制台输入输出。
我们可以把函数想象成一个“工厂"，工厂需要买入原材料，进行加工，并生产出产品。
函数的参数就是原材料，函数的返回值就是生产出的产品。
4.2 示例
4.2.1 示例代码
defcalcSum(beg, end):sum=0for i inrange(beg, end +1):sum+= i print(sum) calc(1,100)这段代码可以可以转换成——
defcalcSum(beg, end):sum=0for i inrange(beg, end +1):sum+= i returnsum result = calcSum(1,100)print(result)这两个代码的区别就在于，前者直接在函数内部进行了打印，后者则使用 return 语句把结果返回给函数调用者，再由调用者负责打印。
我们一般倾向于第二种写法。
实际开发中我们的一个通常的编程原则，是“逻辑和用户交互分离”而第一种写法的函数中，既包含了计算逻辑，又包含了和用户交互（打印到控制台上），这种写法是不太好的，如果后续我们需要的是把计算结果保存到文件中，或者通过网络发送，或者展示到图形化界面里，那么第一种写法的函数，就难以胜任了。
而第二种写法则专注于做计算逻辑，不负责和用户交互，那么就很容易把这个逻辑搭配不同的用户交互代码，来实现不同的效果。
4.2.2 一个函数中可以有多个return语句
# 判定是否是奇数defisOdd(num):if num %2==0:returnFalseelse:returnTrue result = isOdd(10)print(result)4.2.3 执行到return语句，函数就会立即执行结束，回到调用位置
# 判定是否是奇数defisOdd(num):if num %2==0:returnFalsereturnTrue result = isOdd(10)print(result)如果num是偶数，则进入 if 之后，就会触发return False，也就不会继续执行return True。
4.2.4 一个函数是可以一次返回多个返回值的，使用来分割多个返回值
4.2.5 一个函数是可以一次返回多个返回值的，使用_来分割多个返回值
defgetPoint(): x =10 y =20return x, y _, b = getPoint()4.3 最佳实践
# 函数的返回值（1）# 求beg，end这个范围的整数之和defcalSum(beg, end): theSum =0for i inrange(beg,end +1): theSum += i return theSum result = calSum(1,100)print(result)# 函数的返回值（2）# 这种情况下，不算是有多个 return 语句# def test1():# return 1# return 2# 一般多个 return 语句是搭配分支/循环语句的# def isOdd(num):# """# 用来判定 num 是不是奇数，如果是奇数就返回 True，不是就返回 False# :param num:要判定的整数# :return:返回 True False 表示是不是奇数# """# # 第一种写法# # if num % 2 == 0:# # return True# # else:# # return False## # 第二种写法# if num % 2 == 0:# return False# return True## print(isOdd(10))# print(isOdd(19))# 写一个函数，返回平面上的一个点# 横坐标，纵坐标defgetPoint(): x =10 y =20return x,y a,b = getPoint()print(a,b)5 ~> 变量作用域
5.1 示例
观察下面的代码——
defgetPoint(): x =10 y =20return x, y x, y = getPoint()在这个代码中，函数内部存在x，y，函数外部也有x，y，但是这两组x、y不是相同的变量，而只是恰好有一样的名字。
5.2 理论
5.2.1 变量只能在所在的函数内部生效
在函数getPoint内部定义的x、y只是在函数内部生效，一旦出了函数的范围，这两个变量就不再生效。
defgetPoint(): x =10 y =20return x, y getPoint()print(x, y)5.2.2 在不同的作用域中，允许存在同名的变量
虽然 名字相同，实际上是不同的变量。
x =20deftest(): x =10print(f'函数内部 x = {x}') test()print(f'函数外部 x = {x}')注意：
在函数内部的变量，也称为“局部变量”；
不在任何函数内部的变量，也称为“全局变量”。
5.2.3 如果函数内部尝试访问的变量在局部不存在，就会尝试去全局作用域中查找
x =20deftest():print(f'x = {x}') test()5.2.4 如果是想在函数内部，修改全局变量的值，需要使用global关键字声明
x =20deftest():global x x =10print(f'函数内部 x = {x}') test()print(f'函数外部 x = {x}')
如果此处没有global，则函数内部的x = 10就会被视为是创建一个局部变量x，这样就和全局变量x不相关了。
5.2.5 if / while / for等语句块不会影响到变量作用域
换而言之，在if / while / for中定义的变量，在语句外面也可以正常使用。
for i inrange(1,10):print(f'函数内部 i = {i}')print(f'函数外部 i = {i}')5.3 最佳实践
# 变量的作用域# 函数里面的x,y和函数外面的x,y是同一组变量吗？# 不同的变量，只不过名字恰好相同！# def getPoint():# x = 10# y = 20# return x,y# 函数内部的变量名，只能在函数内部生效，出了函数，就无效了！# x,y = getPoint()# print(x,y)# 变量的作用域！# 一个变量名的生效范围是一定的！只在一个固定的区域内生效# def getPoint():# x = 10# y = 20# return x,y## getPoint()# print(x,y)# 函数内部的x，y不生效-->NameError: name 'x' is not defined# 函数内部和函数外部是可以使用同名的变量的，虽然变量名相同，但是是不同的变量！# 全局变量和局部变量# 例子：# x = 10## def test():# x = 20# print(f"函数内部：{x}")## test()# print(f"函数外部：{x}")# 函数里，也是可以使用全局变量的！# 例子：在函数里尝试读取全局变量是可以的！# x = 10## def test():# print(f"x = {x}")## test()# x = 10## def test():# print(f"函数内部：{x}")## test()# print(f"函数外部：{x}")# 在函数中尝试访问某个变量的时候，会先尝试在局部变量中查找，如果找到，就直接访问；# 如果没找到，就会往上一级作用域中进行查找-->test再往上一级作用域，就是全局了# 使用这个函数，把全局变量 x 给改成 20！# x = 10## def test():# x = 20 # 这个x被当成函数内部的局部变量了## test()# print(f"x = {x}")# Python中的关键字：global# x = 10## def test():# # 声明，变成针对全局变量来进行的了# global x# x = 20 # 这个x被当成函数内部的局部变量了# # 由于修改全局变量的操作和创建变量的语法是一模一样的，所以Python把它当做是局部变量了# # （所以要加上 global 进行显式声明）## test()# print(f"x = {x}")# 没有 global ，此时就会把x = 20当做是在函数内部创建了一个局部变量 x# 而实际上是要修改全局变量 x ，为了让函数里面知道 x 是个全局变量，就使用 global 关键字先声明一下# if else，while，for这些关键字也会引入“代码块”，但是这些代码块不会对变量的作用域产生影响!!# 在上述语句代码块内部定义的变量，可以在外面被访问!# for i in range(1,11):# print(i)## print('------------------------')# print(i)# 输出：# 1# 2# 3# 4# 5# 6# 7# 8# 9# 10# ------------------------# 10ifTrue: x =10print(x)6 ~> 函数执行过程
6.1 概念
调用函数才会执行函数体代码，不调用则不会执行。
函数体执行结束（或者遇到return语句）则回到函数调用位置，继续往下执行。
6.2 示例
deftest():print("执行函数内部代码")print("执行函数内部代码")print("执行函数内部代码")print("1111") test()print("2222") test()print("3333")6.3 打断点
6.3.1 调试器观察函数执行过程
这个过程还可以使用PyCharm自带的调试器来观察。
点击行号右侧的空白，可以在代码中插入断点。
右键，Debug，可以按照调试模式执行代码，每次执行到断点，程序都会暂停下来。
使用StepInto(F7) 功能可以逐行执行代码。
6.3.2 举个🌰
6.4 最佳实践
# 函数的执行过程deftest():print('执行函数体代码')print('执行函数体代码')print('执行函数体代码')print("111111") test()print("222222") test()print("333333") test()print("444444") test()print("555555") test()# 还可以使用PyCharm的调试器，也能观察函数执行的过程# 调试执行相比于正常的区别：就是可以随时停下来，方便程序员观察程序的中间过程# 调试：F7，step into
7 ~> 链式调用和嵌套调用
7.1 链式调用
7.1.1 示例
# 判定是否是奇数defisOdd(num):if num %2==0:returnFalseelse:returnTrue result = isOdd(10)print(result)实际上也可以简化一下，写作——
print(isOdd(10))7.1.2 概念
把一个函数的返回值，作为另一个函数的参数，这种操作称为 链式调用。
这是一种比较常见的写法。
7.1.3 最佳实践
# 函数的链式调用和嵌套调用(1)# 链式调用defisOdd(num):if num %2==0:returnFalsereturnTruedefadd(x,y):return x + y # result = isOdd(10)# print(result)print(isOdd(add(5,5)))7.2 嵌套调用
7.2.1 概念
函数内部还可以调用其他的函数，这个动作称为 “嵌套调用”。
test函数内部调用了print函数，这里就属于嵌套调用。
7.2.2 一个函数里面可以嵌套调用任意多个函数
函数嵌套的过程是非常灵活的。
defa():print("函数 a")defb():print("函数 b") a()defc():print("函数 c") b()defd():print("函数 d") c() d()
如果把代码稍微调整，打印结果则可能发生很大变化。
defa():print("函数 a")defb(): a()print("函数 b")defc(): b()print("函数 c")defd(): c()print("函数 d") d()注意体会上述代码的执行顺序，我们可以通过画图的方式来理解。
函数之间的调用关系，在Python中会使用一个特定的数据结构来表示，称为 函数调用栈。每次函数调用，都会在调用栈里新增一个元素，称为 栈帧。
可以通过PyCharm调试器看到函数调用栈和栈帧。
在调试状态下，PyCharm左下角一般就会显示出函数调用栈。
7.2.3 每个函数的局部变量，都包含在自己的栈帧中
defa(): num1 =10print("函数 a")defb(): num2 =20 a()print("函数 b")defc(): num3 =30 b()print("函数 c")defd(): num4 =40 c()print("函数 d") d()
选择不同的栈帧，就可以看到各自栈帧中的局部变量。
思考： 上述代码，a，b，c，d函数中的局部变量名各不相同.如果变量名是相同的，比如都是 num，那么
这四个函数中的num是属于同一个变量，还是不同变量呢？
7.2.4 最佳实践
# 函数的链式调用和嵌套调用(2)# 嵌套调用# def test():# print("Alice")## test()# 嵌套调用层次可以有很多层# def a():# print('函数 a')## def b():# print('函数 b')# a()## def c():# print('函数 c')# b()## def d():# print('函数 d')# c()## d()# # 运行结果# 函数 d# 函数 c# 函数 b# 函数 a# 代码顺序稍作调整，打印顺序就会变化defa():print('函数 a')defb(): a()print('函数 b')defc(): b()print('函数 c')defd(): c()print('函数 d') d()# # 运行结果# 函数 a# 函数 b# 函数 c# 函数 d8 ~> 局部变量和函数栈帧
8.1 概念
8.2 最佳实践
# 局部变量和函数栈帧# 这几个变量虽然同名，但是是不同变量，属于不同的函数作用域# 每个变量也是保存在各自的栈帧中的(每个栈帧也是保存在内存中)# 变量本质是一块内存空间defa(): num =10print('函数 a')defb(): num =20 a()print('函数 b')defc(): num =30 b()print('函数 c')defd(): num =40 c()print('函数 d') d()
9 ~> 函数递归
9.1 函数递归的概念
递归是嵌套调用中的一种特殊情况：即一个函数嵌套调用自己。
9.2 示例：递归计算5！
deffactor(n):if n ==1:return1return n * factor(n -1) result = factor(5)print(result)上述代码中，就属于典型的递归操作。在 factor 函数内部，又调用了 factor 自身。
注意：递归代码务必要保证——
（1）存在递归结束条件：比如if n == 1就是结束条件，当n为1的时候，递归就结束了；
（2）每次递归的时候，要保证函数的实参是逐渐逼近结束条件的。
如果上述条件不能满足，就会出现“无限递归”，这是一种典型的代码错误。
deffactor(n):return n * factor(n -1) result = factor(5)print(result)
正如前面所描述的那样，函数调用时会在函数调用栈中记录每一层函数调用的信息。
但是函数调用栈的空间不是无限大的，如果调用层数太多，就会超出栈的最大范围，导致出现问题。
9.3 最佳实践
# 函数递归# 写一个函数，来求 n 的阶乘(n 是正整数)# 用循环的方式来写# def factor(n):# result = 1# for i in range(1,n + 1):# result *= i# return result## print(factor(5))# 用递归的方式来写# n! => n * (n - 1)# 1! => 1deffactor(n):if n ==1:return1return n * factor(n -1)print(factor(5))
9.4 递归的优缺点
9.4.1 递归的优点
（1）递归类似于“数学归纳法”，明确初始条件，和递推公式，就可以解决一系列的问题；
（2）递归代码往往代码量非常少。
9.4.2 递归的缺点
（1）递归代码往往难以理解，很容易超出掌控范围；
（2）递归代码容易出现栈溢出的情况；
（3）递归代码往往可以转换成等价的循环代码，并且通常来说循环版本的代码执行效率要略高于递归版本。
9.4.3 基于递归的优缺点，使用递归的结论
在我们实际开发的时候，使用递归要慎重！10 ~> 参数默认值
10.1 概念
Python中的函数，可以给形参指定默认值。
带有默认值的参数，可以在调用的时候不传参。
10.2 最佳实践
10.2.1 代码示例：计算两个数字的和
defadd(x, y, debug=False):if debug:print(f'调试信息: x={x}, y={y}')return x + y print(add(10,20))print(add(10,20,True))此处debug=False即为参数默认值。当我们不指定第三个参数的时候，默认debug的取值即为False。
10.2.2 带有默认值的参数需要放到没有默认值的参数的后面
defadd(x, debug=False, y):if debug:print(f'调试信息: x={x}, y={y}')return x + y print(add(10,20))带有默认值的参数如果没有放到没有默认值的参数的后面就会报错——
10.2.3 实践
# 函数形参的默认值# 通过这样的默认值，就可以让函数的设计更灵活！# debug：形参的默认值# 带有默认值的形参就可以在调用函数的时候，不必传参# 参数越多会提高使用者的成本defadd(x ,y ,debug=False):if debug:print(f'x = {x},y = {y}')return x + y # result = add(10,20) # 不开启调试信息的情况，只传了两个实参 result = add(10,20,True)# result = add(10,20,False)print(result)# 像默认值这样的语法，在编程界是存在争议的！# C++也支持形参默认参数，Java就不支持，但是Python还是引入默认参数的# 带有默认值的形参得在形参列表的后面，而不能在前面 / 中间！# 多个带有默认值的形参，这些都得在形参列表的后面# 报错：SyntaxError: parameter without a default follows parameter with a default11 ~> 关键字参数
11.1 概念
在调用函数的时候，需要给函数指定实参，一般默认情况下是按照形参的顺序，来依次传递实参的，但是我们也可以通过 关键字参数，来调整这里的传参顺序，显式指定当前实参传递给哪个形参。
11.2 示例
deftest(x, y):print(f'x = {x}')print(f'y = {y}') test(x=10, y=20) test(y=100, x=200)运行结果如下所示——
11.3 最佳实践
# 函数的关键字参数# 按照先后顺序来传参——这种传参风格，称为“位置参数” 这是各个编程语言中最普遍的方式！# 关键字传参：按照形参的名字来进行传参！deftest(x,y):print(f'x = {x}')print(f'y = {y}') test(x=10,y=20)# 非常明显地告诉程序员：你的参数要传给谁！另外可以无视形参和实参的顺序！ test(y=100,x=200)# 运行结果# x = 10# y = 20# x = 200# y = 100# 位置参数和关键字参数还能混着用，只不过混着用的时候要求位置参数在前。# 关键字参数在后# 关键字参数一般也就是搭配默认参数来使用的# 一个函数，可以提供很多的参数，来实现对这个函数的内部功能做出一些调整设定# 为了降低调用者的使用成本，就可以把大部分参数设定出默认值# 当调用者需要调整其中的一部分参数的时候，就可以搭配关键字参数来进行操作(在Python的文件操作部分会演示，这里不展开)12 ~> Python基础语法：函数部分小结
函数是编程语言中的一个核心语法机制。Python中的函数和大部分编程语言中的函数功能都是基本类似的。
我们当下最关键要理解的主要就是三个点：
函数的定义
函数的调用
函数的参数传递
在后续的编程中，我们会广泛的使用到函数，uu们要再反复加深对于函数的理解哦。
# 函数部分小结# 函数的定义# 函数的调用# 函数的参数传递过程# 函数的执行流程：# （1）进去，好进# （2）出来，不好出结尾
uu们，本文的内容到这里就全部结束了，艾莉丝再次感谢您的阅读！
结语：希望对学习Python相关内容的uu有所帮助，不要忘记给博主“一键四连”哦！
往期回顾：
【Python基础：语法第二课】Python 流程控制详解：条件语句 + 循环语句 + 人生重开模拟器实战
🗡博主在这里放了一只小狗，大家看完了摸摸小狗放松一下吧！🗡૮₍ ˶ ˊ ᴥ ˋ˶₎ა
