函数
函数是将一组语句的集合通过一个名字（函数名）封装起来，要想执行这个函数，只需要调用函数名即可
注：函数在没有执行前，内部代码不执行
特性：
减少重复的代码
使程序变得可扩展
使程序变得易维护
实例：
def hel(): # 定义函数名
print('Hello World!') # 函数内的内容
hel() # 调用函数
# 执行结果
Hello World!
函数的参数
- 形参变量
只有在被调用是才分配内存单元，形参只在函数内部有效，函数调用结束后返回主程序后则不在调用此形参变量
- 实参
可以是常亮，变量，表达式，函数等，无论实参是何种类型的变量，在进行函数调用时，它们都必须有特定的值，以便把这些值传给形参
实例：
def calc(x, y): # x,y 为形参
res = x**y
return res
s = calc(2, 5) # 2,5 是需要传送的实参数据
print(s)
# 执行结果
32
关键参数
实例：
def stu_register(name, age, country, course='CN'): #如传入的某个参数值是一样的,就可以在定义函数是指定参数值是多少，且指定的变量值的后面不允许有需要传入值的变量
print('注册学生信息'.center(10, '-'))
print('姓名:', name)
print('age:', age)
print('国籍:', course)
print('课程:', country)
stu_register('zevin', 22, 'python') #此处传入字符串需要严格对应参数内的变量
# 执行结果
--注册学生信息--
姓名: zevin
age: 22
国籍: CN
课程: python
# 也可以在传入参数值时指定变量
def stu_register(name, age, country, course):
print('注册学生信息'.center(10, '-'))
print('姓名:', name)
print('age:', age)
print('国籍:', course)
print('课程:', country)
stu_register('zevin',23, course='JP', country='python') #若没有指定变量的参数，需要按照函数格式传入值
# 执行结果
--注册学生信息--
姓名: zevin
age: 23
国籍:JP
课程: python
非固定参数
若函数中有些定义的变量需要传入多个参数，就可以使用非固定参数
用法：*变量， 在变量前加个 * 星号
实例：
# 变量前一个 * 星号
def stu_register(name, age, *args): # *args 会把多传入的值变成一个元祖形式
print(name, age, args)
stu_register('zevin', 22)
# 执行结果
# zevin 22 () #后面这个()就是args的值，因为没有传入值，所以为空
stu_register('zevin', 22, 'CN', 'JP')
# 执行结果
# zevin 22 ('CN', 'JP') # 最后多传入的值变成元祖
# 变量前两个 * 星号
def stu_register(name, age, *args, **kwargs): # **kwargs会把多传入的值变成一个字典形式
print(name, age, args, kwargs)
stu_register('zeivn', 22, 'CN', 'JP', sex='abc', pro=123)
# 执行结果
# zeivn 22 ('CN', 'JP') {'sex': 'abc', 'pro': 123}
函数的返回值
函数外部的代码想要获取函数执行的结果，就可以在函数内用 return 语句把结果返回，不加默认返回 None
注意：
函数在执行过程中只要遇到 return 语句，就会停止执行并返回结果
实例：
def sun(x, y):
if x > y:
x*y
else:
x**y
fo = sun(5, 6)
print(fo)
# 执行结果为 None
def sun(x, y):
if x > y:
return x*y
else:
return x**y
fo = sun(5, 6)
print(fo)
# 执行结果为 15625
局部变量
在函数中定义的变量称为局部变量，在程序一开始定义的变量称为全局变量
当全局变量和局部变量同名时，在定义局部变量的函数内，局部变量起作用，在其他地方全局变量起作用
实例：
name = 'anv' # 在程序开始定义 name = anv
def change_name():
name = 'dsf' # 在函数内定义 name = dsf
print('函数内name为:', name, id(name)) #在函数内打印name
change_name()
print('函数外name为:', name, id(name)) #在函数外打印name
# 执行结果
函数内name为: dsf 140357042555120
函数外name为: anv 140357042555064
# 要想在函数内修改全局变量，需要用参数 global 修改
name = 'anv' # 在程序开始定义 name = anv
def change_name():
global name # global声明需要修改的变量，建议不要更改全局变量
name = 'dsf' # 在函数内修改为 name = dsf
print('函数内name为:', name, id(name)) #在函数内打印name
change_name()
print('函数外name为:', name, id(name)) #在函数外打印name
# 执行结果
函数内name为: dsf 140056539031792
函数外name为: dsf 140056539031792
嵌套函数
函数内部可以再次定义函数，执行需要调用
# 实例 1
age = 18 # 全局定义 age = 18
def func1():
age = 73 # 函数内定义 age = 73
print('func1:', age)
def func2():
age = 84
print('func2:', age)
func1() # 调用 func1()
# 执行结果,未调用 func2() 所有以输出 func1 的值
func1:73
# 实例 2
age = 18 # 全局定义 age = 18
def func1():
age = 73 # 函数内定义 age = 73
print('func1:', age)
def func2():
age = 84
print('func2:', age)
func2() # 调用 func2()
func1() # 调用 func1()
# 执行结果
func1:73
func2:84
# 实例 3
age = 18 # 全局定义 age = 18
def func1(): # 函数内定义 age = 73
print('func1:', age) # 此age 直接调用的是全局变量 age 值
def func2():
print('func2:', age)
func2() # 调用 func2()
func1() # 调用 func1()
# 执行结果
func1: 18
func2: 18
# 实例 4
age = 18 # 全局定义 age = 18
def func1(): # 函数内定义 age = 73
age = 73 # 函数内定义 age = 73
print('func1:', age)
def func2():
print('func2:', age) # func2()函数内的age从上一层父级获取 age 值，如果上一层 age未赋值，则在往上一层查找
func2() # 调用 func2()
func1() # 调用 func1()
# 执行结果
func1: 73
func2: 73
匿名函数
把多行语句提供成一行，不需要函数名，支持三元运算,主要是和其他方式搭配运算
# 如以下代码
def calc(x, y):
return x*y
print(calc(2, 5))
# 执行结果
10
# 换成匿名函数
calc = lambda x, y: x*y
print(calc(2, 5))
# 执行结果
10
# 还可以进行三元运算
calc = lambda x, y: x*y if x < y else x/y
print(calc(16, 8))
# 执行结果
2.0
# 匿名函数主要搭配其他函数使用
# map(func, list) 是将后面列表中的每一个值交给前面的函数去执行一边
res = map(lambda x: x*2, [1, 5, 6, 7]) #将后面的列表内每一个值交给前面的 lamba 函数进行自乘
for line in res:
print(line)
# 执行结果
2
10
12
14
高阶函数
变量可以指向函数，函数的参数能接受变量，那么一个函数可以接受另一个函数作为参数，这种就是 高阶函数
- 接受一个或多个函数作为输入
- return 返回另外一个函数
def calc(x, y):
return x*y
def func(x):
return x+x
print(calc(func(4), 5)) # 将func(4)返回的函数结果作为calc函数的参数
# 执行结果
40
作用域
Python 中作用域，变量会由内向外查找，先在自己作用域查找，如果没有就再去上级查找，依次向上，直到找不到就报错
# 先看这段代码
name = 'li'
def f1():
print(name)
def f2():
name = 'al'
return f1
res = f2()
res()
# 输出：li
# 分析上面的代码，先执行f2()函数，而f2()执行结果返回的 f1 的内存地址，所以res=f1，在后面执行res()就等于执行f1()，而执行f1()时和执行f2()没有关系，f1()内并没有定义变量name的值，所以f1()就上级查找name变量的值，所有 name = "li" 就是和 f1()为一个作用域链，最后返回的结果为 li
# 最后看这段代码
name = 'li'
def f1():
print(name)
def f2():
name = 'al'
f1()
f2()
# 输出: li
# 此段代码和上面的基本是一样的，执行f2()后调用了f1()，最后的结果为f1()向上级查找name变量值，最后返回name变量值
# 在函数未执行之前，作用域已经形成了，而作用域链也生成了
作用域的查找顺序：
LEGB：
- locals: 函数内部的名称空间，包括局部变量和形参
- enclosing: 外部嵌套函数的名称空间
- globals: 全局变量，函数定义所在模块的名称空间
- builtins 内置模块的名称空间
递归
在函数内部可以调用其他函数，如果一个函数在内部调用自己本身时，这个函数就一个递归函数
递归特性：
- 必须要有一个明确的结束条件
- 每次进入更深一层递归时，问题规模应该比上级递归减少
- 递归的效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。)
# 递归的用法
# 计算 介乘，
def num(n):
if n == 1:
return 1
return n * num(n - 1)
print(num(5))
# 输出：120