一、什么是函数？
在前面的一些作品里面，其实我们已经运用过了函数的内容了，只是之前对函数的概念还不太了解，其实我们前面用过的print（）和input（）等都是函数。那么什么是函数呢？举个例子，假如我们我们在公司上班，有一个查询的功能在很多个地方都要使用，那么是不是每一个程序猿都要在写一遍查询这个功能，这样就显得很麻烦，代码的重复度和工作的复杂度也会增加。其实我们只要一个人写了查询这个功能，然后把这个功能封装成函数，要使用查询功能的时候，直接调用查询函数就可以了。
所谓的函数就是⼀个 被命名的、独⽴的、完成特定功能的代码段（⼀段连续的代码），并可能给调⽤它的程序⼀个 返回值。简单来说，函数就是为了实现某一功能的一段代码，函数能直接被调用实现某一功能，比如max（）：求一段数字的最大值。min（）求一段数字的最小值：len（）求数据序列的数据元素数量等。
1、被命名的：在Python中，函数⼤多数是有名函数（普通函数）。当然Python中也存在没有名字的函数叫 做匿名函数。
2、 独⽴的、完成特定功能的代码段：在实际项⽬开发中，定义函数前⼀定要先思考⼀下，这个函数是为了完成某个操作或某个功能⽽定义的。（函数的功能⼀定要专⼀）
3、 返回值 ：很多函数在执⾏完毕后，会通过return关键字返回⼀个结果给调⽤它的位置。二、函数的作用？
使⽤函数的⽬的只有⼀个“让我们的代码可以被重复使⽤”。
函数的作⽤有两个：
① 代码重⽤（代码重复使⽤）
② 模块化编程（模块化编程的核⼼就是函数，⼀般是把⼀个系统分解为若⼲个功能，每个功能就是⼀个函数）
在编程领域，编程可以分为两⼤类：① 模块化编程。 ② ⾯向对象编程。
三、函数的定义和调用
函数定义基本语法：
# 函数的定义：
def 函数名称([参数1, 参数2, ...]):
函数体
...
[return 返回值]函数调用基本语法：
在Python中，函数和变量一样需要先定义后调用。
# 函数的定义：
def 函数名称([参数1, 参数2, ...]):
函数体
...
[return 返回值]
# 调⽤函数
函数名称(参数1, 参数2, ...)
# 先定义，后调用案例1：要实现一个找老婆认错的函数。
代码：
# 第一次认错:没有参
# 定义函数
def sorry():
print("第一次认错：————————————————")
print("我：我错啦！！！")
print("老婆：你叫的不够亲切,谁错了，错哪里了？我是不可能原谅你的！！！")
# 调用函数
sorry()
# 第二次认错：有参数
# 定义函数
def sorry1(Dear,my_name):
print("第二次认错：————————————————")
print(f"我：{Dear}的老婆，{my_name}错啦，我不应该呼吸，呼吸都是错的！！！")
print("老婆：勉强原谅你了！！！")
# 调用函数
sorry1("亲爱的","小宁爱Python")运行结果：
四、函数的返回值
观察我们的函数定义的语法，最后不应该是return函数吗，为什么我们刚刚的案例，没有return返回值呢？函数的设计原则“⾼内聚、低耦合”，函数执⾏完毕后，应该主动把数返回给调⽤处，⽽不应该都交由 print()等函数直接输出。那么具体什么时候使用return，什么时候使用return呢？当我们函数需要将函数体内部执行的结果传递到外部进行计算和加工时，我们会时候return将函数执行结果传递到外界。
在Python中，return有退出函数的作用。理论上⼀个函数只能返回⼀个结果。但是如果我们向让⼀个函数可以同时返回多个结 果，我们可以使⽤ return 元组 的形式。没有返回值的时候默认为None
案例1：使用return修改上面的
# 第一次认错:没有参
# 定义函数
def sorry():
return "我：我错啦！！！\n老婆：你叫的不够亲切,谁错了，错哪里了？我是不可能原谅你的！！！"
# 调用函数
print(sorry())
# 第二次认错：有参数
# 定义函数
def sorry1(Dear,my_name):
return f"我：{Dear}的老婆，{my_name}错啦，我不应该呼吸，呼吸都是错的！！！\n老婆：勉强原谅你了！！！"
# 调用函数
result = sorry1("亲爱的","小宁爱Python")
print(result)
运行结果：
案例2：return的返回时，退出函数
# 1、return可以退出函数
def my_return():
return "我是return1"
return "我是return2"
learn_return = my_return()
print(learn_return)
运行代码：
通过运行结果我们发现，第二个return的没有将值输出，原因是在执行第一个return的时候就退出函数了，所以return返回的值没有输出。
案例3：return返回元素时是元组类型。
传递两个参数都为数字，计算这两个数字四则运算的结果。
代码：
# 2、return返回多个值的时候返回的是一个元组
# 传递两个参数都为数字，计算这两个数字四则运算的结果
def compute(num1, num2):
addition = num1 + num2
subtract = num1 - num2
multiplication =num1 * num2
division = num1 / num2
return addition, subtract, multiplication, division
my_compute = compute(10, 2)
print(f"10和2加减乘除对应的结果为：{my_compute}")
print(f"return返回多个值时的类型：{type(my_compute)}")运行结果：
案例4：return能过返回哪一些数据类型。
代码：
# return能过返回哪一些数据类型
def my_function1():
return [1,2,True,"小宁爱Python"]
def my_function2():
return {1,23,"小宁爱Python"}
def my_function3():
return (1,2343,54.1,False)
def my_function4():
return {"name":"小宁爱Python","age":23,"sex":"男"}
print(f"返回值是列表类型：{my_function1()}")
print(f"返回值是结合类型：{my_function2()}")
print(f"返回值是元组类型：{my_function3()}")
print(f"返回值是字典类型：{my_function4()}")运行结果：
通过这个案例，我们发现return返回的数据可以是字符串，数值，列表，元组，字典、集合类型。
五、函数的说明文档
如果代码多，我们是不是需要在很多代码中找到这个函数定义的位置才能看到注释？如果想更⽅ 便的查看函数的作⽤怎么办？ 函数的说明⽂档（函数的说明⽂档也叫函数的⽂档说明）。当我们遇到一个函数的时候，我们要快速的知道函数的功能以及参数的传递的时候，我们这个时候就可以查看函数的说明文档了。
5.1、定义函数说明文档
在函数体内部使用多行注释，说明文档的要求：函数的功能，函数的参数传递。
代码：
# 函数的说明文档
def max_num(num1, num2):
# 定义函数说明文档
"""该函数是计算两数最大值的函数，需要传递两个数字"""
max = num1
if num2 > num1:
max = num2
return max
print(f"两数的最大值是：{max_num(1, 2)}")运行结果：
5.2、调用函数的说明文档
语法：help（函数名）
代码：
# 函数的说明文档
def max_num(num1, num2):
# 定义函数说明文档
"""该函数是计算两数最大值的函数，需要传递两个数字"""
max = num1
if num2 > num1:
max = num2
return max
print(f"两数的最大值是：{max_num(1, 2)}")
# 调用函数的说明文档
help(max_num)运行结果：
六、函数的参数
6.1、无参
代码：
# 1、无参
def no_function():
return "你好！"
print(no_function())
运行结果：
6.2、位置参数
6.2.1、无默认值
代码：
# 2、位置参数
# 2.1、无默认值
def no_mr_function(yourname,myname):
return f"{yourname},你好！我是{myname}"
print(no_mr_function(yourname="Tom",myname="小宁爱Python"))
运行结果：
6.2.2、有默认值
代码：
# 2.2、有默认值
def have_mr_function(yourname,myname="小宁爱Python"):
return f"{yourname},你好！我是{myname}"
print(have_mr_function(yourname="Tom"))
print(have_mr_function(yourname="Tom",myname="Python"))
# 不给默认参数赋值的时候，就是默认参数的值；如果给默认参数赋值，那么就会改变默认参数的值运行结果：
6.3、不定长参数
6.3.1、不定长元组参数（*参数名）
代码：
# 2.3、不定参数
# 2.3.1、不定长元组参数、
def tuple_fuction(*args):
return args
my_tuple = (1,2,3,4,5)
print(tuple_fuction(*my_tuple))
print(tuple_fuction(1, 2, 3,"小宁爱Python"))
print(type(tuple_fuction(1, 2, 3)))运行结果：
6.3.2、不定长关键字（字典）参数（**参数名）
代码：
# 2.3.2、不定长关键字参数
def dict_function(**kwargs):
return kwargs
my_dict = {"name":"小宁爱Python","age":12,"sex":"man"}
print(dict_function(**my_dict))
print(dict_function(name = "蔡文姬",age = 1, sex ="女"))
print(type(dict_function(name = "蔡文姬",age = 1, sex ="女")))运行结果：
6.4、复合参数
复合参数就是当我们有多种参数类型同时使用时。
正确示范：
直接报错：
运行报错
总结：
1、当使用可变参数时，如果函数还有其他位置参数，可变参数必须放在所有位置参数之后。
2、变关键字参数必须放在所有参数的最后。
3、在调用函数时，关键字参数必须放在位置参数之后。
4、默认参数值只被评估一次，当函数定义时，而不是每次函数被调用时。这在默认参数是可变对象时可能导致问题。
七、函数的嵌套
所谓函数嵌套调⽤指的是 ⼀个函数⾥⾯⼜调⽤了另外⼀个函数。 案例1： 代码：
运行结果：
案例2：
代码：
运行结果：
案例3：
代码：
运行结果：
案例4：
代码：
运行结果：
总结：
1、函数的嵌套，如果要外部函数生效，那么函数内部需要调用外部函数
2、内部函数不能直接调用外部函数，会出血超过最大递归深度的报错
3、在函数外部不能直接调用内部函数，但是可以调用外部函数
4、如果定义了内部函数，但是没有调用那么内部函数不会运行
八、变量的作用域
8.1、什么变量作业域
变量作⽤域指的是变量的作⽤范围（变量在哪⾥可⽤，在哪⾥不可⽤），主要分为两类： 全局作⽤域与 局部作⽤域。 其实作⽤域的划分⽐较简单，在函数内部定义范围就称之为局部作⽤域，在函数外部（全局）定义范围 就是全局作⽤域。8.2、局部变量和全局变量
全局变量：在整个程序范围内都可以直接使⽤。 局部变量：在函数的调⽤过程中，开始定义，函数运⾏过程中⽣效，函数执⾏完毕后，销毁。 案例1：函数里的变量和函数外的变量代码：
# 变量的作用域：
# 定义全局变量
# 全局变量：在整个程序范围内都可以直接使⽤。
# 局部变量：在函数的调⽤过程中，开始定义，函数运⾏过程中⽣效，函数执⾏完毕后，销毁
max = 1000
def max_num(*args):
# 说明文档
"""这是求一个列表最大值的函数，需要传递一个全部是数值的列表参数"""
# 定义局部变量
max = args[0]
for num in args:
if num > max:
max = num
return max
print(max_num(1, 2, 3))
# 输出结果是3，不是1000，因为函数使用的是局部变量没有使用全部变量
print(max)
# 输出的是1000，直接输出max表示的是使用的全局变量运行结果：
案例2：内部函数变量和外部函数变量
代码：
运行结果;发生inner_str未被定义的报错。
inner_str相当于局部变量，out_str相当于这个函数的全局变量。
8.3、global关键字和nonlocal关键字
假如我们有些时候一定要使用外部变量我们怎么办呢，这时候我们就可以使用关键字。
案例1：
代码：
# global和nonlocal关键字:
# 定义全局变量num
num = 10
def change_num():
# 定义局部变量num
num = 20
# 调用改变num的函数
change_num()
# 没有发生改变，因为change_num()函数改变的局部变量num的值，所有输出的结果还是10
print(num)运行结果：
案例2：
代码：
# global和nonlocal关键字:
# 定义全局变量num
num = 10
def change_num():
# 使用全局变量num
global num
num = 20
# 调用改变num的函数
change_num()
# 发生改变，加了global关键字，使用的num是全局变量的num
print(num)运行结果：
案例3：
代码：
# global和nonlocal关键字:
def out_function():
# 定义外部函数变量
num = 10
def inner_function():
# 定义内部函数变量
num = 20
# 输出的结果是20，使用的是内部函数的num
print(num)
# 调用内部函数
inner_function()
# 输出的结果是10，使用的是外部函数num
print(num)
out_function()
运行结果：
案例4：
代码：
# global和nonlocal关键字:
def out_function():
# 定义外部函数变量
num = 10
def inner_function():
# nonlocal调用外部函数的变量num
nonlocal num
num = 20 # 修改外部函数num = 20
# 输出的结果是20，使用的是外部函数的num
print(num)
# 调用内部函数，修改num = 20
inner_function()
# 输出的结果是20，使用的是外部函数num
print(num)
out_function()
运行结果：
九、综合练习
随机生成一个六位数的验证码的函数。
代码：
def identifying_code(code_str):
"""功能是根据参数提供的字符串生成一个长度为6的验证码，需要传递一个字符串类型的蚕食"""
import random
code = ""
len_code_str = len(code_str)
for i in range(6):
index = random.randint(0,len_code_str-1)
code = code + code_str[index]
print(f"验证码为：{code}")
identifying_code("QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890")运行结果：
