1. 函数简介（function）
- 函数也是一个对象
- 对象是内存中专门用来存储数据的一块区域
- 函数可以用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次的调用
- 创建函数：
def 函数名([形参1,形参2,...形参n]) :
代码块
- 函数名必须要符号标识符的规范
（可以包含字母、数字、下划线、但是不能以数字开头）
- 函数中保存的代码不会立即执行，需要调用函数代码才会执行
- 调用函数：
函数对象()
- 定义函数一般都是要实现某种功能的
2. 函数的参数
- 在定义函数时，可以在函数名后的()中定义数量不等的形参，
多个形参之间使用,隔开
- 形参（形式参数），定义形参就相当于在函数内部声明了变量，但是并不赋值
1.定义形参时，可为形参指定默认值
1.1 指定默认值后，如果用户传递了参数则默认值没有任何作用；如果用户没有传递，则默认值就会生效；
def fn(a = 5, b = 10, c):
print(a)
print(b)
print(c)
- 实参（实际参数）
1. 如果函数定义时，指定了形参，那么在调用函数时也必须传递实参，
实参将会赋值给对应的形参，简单来说，有几个形参就得传几个实参;
2. 实参的传递方式：
2.1 位置参数：将对应位置的实参复制给对应位置的形参；
第一个实参赋值给第一个形参，第二个实参赋值给第二个形参；
2.2 关键字参数：不按照形参定义的顺序去传递，而直接根据参数名去传递参数
def fn(a, b, c):
print(a)
print(b)
print(c)
fn( b=1, c=2, a=3) # 3 1 2
位置参数和关键字参数可混合使用，但必须将位置参数写到前面
2.3 函数在调用时，解析器不会检查实参的类型，可传递任意类型的对象
在函数中对形参进行重新赋值，不会影响其他的变量
若形参执行的是一个对象，当我们通过形参修改对象时 影响所有指向该对象的变量。若避免改变外部参数c，可将c的副本传入函数
def fn1(a): def fn2(a):
a = 20 a[0] = 20
print(a) # 20 print(a) # [20,2,3]
c = 10 c = [1,2,3]
fn1(c) fn2(c)
fn2(c.copy())
fn2(c[:])
print(c) #10 print(c) # [20,2,3]
# [1,2,3]
2.4 定义函数时，可在形参前边加一个*，这样形参将会获取所有的实参，它将所有的实参保存到一个元组中。
# 求任意个数字的和
def fn1(*nums):
result = 0
for a in nums:
result += a
print(result)
2.4.1 带*的参数只能有一个；带*的参数，可和其他参数配合使用；
*形参只能接收位置参数，不能接收关键字参数
注意：带*的参数后的所有参数，必须以关键字参数的形式传递
# 所有的位置参数都给a,b和c必须使用关键字参数
def fn2(*a,b,c):
print(a,b,c)
fn2(1,2,3,4,b=5,c=6)
2.4.2 **形参可接收其他的关键字参数，并将这些参数统一保存到一个字典中。字典的key就是参数的名字，字典的value就是参数的值。
**形参只能有一个，并且必须写在所有参数的最后；
def fn3(**a):
print(a)
fn3(b=1,c=3,d=4) # {'b':1,'c':3,'d':4}
参数的解包（拆包）
传递实参时，可在序列类型的参数前添加*，它会自动地将序列中的元素依次作为参数传递；
要求序列中元素的个数必须和形参的个数一致
def fn4(a,b,c):
print(a,b,c)
# 创建一个元组
t = (1,2,3)
fn4(*t)
通过**对一个字典进行解包操作
# 创建一个字典
d = {'a':1,'b':2,'c':3}
fn4(**d)
返回值：通过return指定函数的返回值
return 后边可跟任意的对象
如果仅仅写return 或者 不写 return ,则相当于 return None
return 后面的代码都不会执行
help():查询python中的内置函数
语法：help(函数对象) # help(print)
文档字符串(doc str):在函数内部编写文档字符串(函数的说明)
def fn(a:int,b:bool,c:str='hello') -> int:
'''
这是一个文档字符串的示例
'''
return 10
作用域(scope):变量生效的区域
全局作用域
在程序执行时创建，在程序执行结束时销毁
所有函数以外的区域都是全局作用域
全局变量可以在程序的任意位置被访问
函数作用域
在函数调用时创建，在调用结束时销毁
函数每调用一次就会产生一个新的函数作用域
局部变量只能在函数内部被访问
变量的查找
使用变量时，会优先在当前作用域中寻找该变量，如果有则使用，如果没有则继续去上一级作用域中，以此类推，
直到找到全局作用域，依然没有 则会抛出异常
a = 20
def fn3():
global a # 在函数内部修改全局变量，则需要使用global关键字来声明变量
a = 10 # 修改全局变量
print(a) #10
fn3()
print(a) #10
命名空间(namespace)
命名空间：变量存储的位置，每一个变量都需要存储到指定的命名空间中；
每一个作用域都会有一个它对应的命名空间；
全局命名空间：保存全局变量；函数命名空间：保存函数中的变量；
命名空间实际上就是一个字典，一个专门用来存储变量的字典；
locals() 用来获取当前作用域的命名空间，返回一个字典；
globals() 函数可用来在任意位置获取全局命名空间;
aa = 1
def fn1():
a = 10
scope = locals()
scope['b'] = 20
globalScope = globals()
print(scope) # {'a': 10, 'b': 20}
print(scope['a']) # 10
print(globalScope)
fn1(globalScope) # {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001856A170850>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'e:\\python开发\\code\\test.py', '__cached__': None, 'aa': 1, 'fn1': <function fn1 at 0x000001856BE1F1F0>}
递归式的函数（在函数中自己调用自己）：
1.两个要件：
1.1 基线条件：问题可被分解为最小问题，当满足基线条件时，递归就不在执行了;
1.2 递归条件：将问题继续分解的条件;
2.递归和循环类似，基本可以相互代替的；
创建一个函数，求任意数的阶乘
方法一（递归）：
def fn1(n):
# 基线条件：判断是否为1，如果为1 则此时不能再继续递归
if n == 1 :
return 1
# 递归条件
return n*fn1(n-1)
print(fn1(20)) # 2432902008176640000
方法二（循环）：
def fn2(n):
'''
该函数用来求任意数的阶乘
参数：
n 要求阶乘的数字
'''
result = n
for i in range(1,n):
result *= i
return result
print(fn2(20)) # 2432902008176640000
