一、函数的作用
封装代码，代码重用
二、定义函数
def 函数名（参数）:
代码1
代码2
调用函数
函数名()
返回值
def add():
return '言'
sum = add()
print(sum)
返回值的应用
def sum1(a, b):
return a + b
rest = sum1(1, 2)
print(rest)
函数的说明文档
help() #help函数的作用：查看函数的说明文档（函数的解释说明的信息）
案例：
help(len)
#运行结果
#Help on built-in function len in module builtins:
len(obj, /)
Return the number of items in a container.
结果
快速体验
def sum1(a, b):
"""求和函数"""
return a + b
rest = sum1(1, 2)
print(rest)
help(sum1)
结果
函数嵌套调用
# B函数
def testB():
print('B函数开始----')
# 嵌套调用B
print("这是B函数")
print('B函数结束----')
#A函数
def testA():
print('A函数开始----')
#嵌套调用B
testB()
print('A函数结束----')
testA()
案例1：
# 打印五条条行线
def print_line():
print('_ ' * 20)
def print_lines(num):
i = 0
while i < num:
print_line() #调用上方函数
i += 1
print_lines(5)
案例2：
# 函数计算
# 1.求三个数之和
def sum_num(a,b,c):
return a + b + c
result = sum_num(1,2,3)
print(result)
# 2.求三个数平均值
def average_num(a,b,c):
sumResult = sum_num(a , b, c) #调用上方函数
return sumResult / 3
result_avg = average_num(1,2,3)
print(result_avg)
变量作用域
局部变量
#定义函数，声明一个变量：函数体内部访问、函数体外面访问
def testA():
a = 100
print(a) #函数体内部访问，能访问到a变量
testA()
注意a定义在testA()函数内部的变量，在函数外部访问则立即报错。
即当函数调用完成后，则销毁局部变量。
全局变量
a = 100
print("我是全局变量a",a)
def testB():
b = a
print("这是test里的a变量",a)
testB()
修改变量的值
a = 100
print("我是全局变量a",a)
def testB():
a = 200 #局部变量
print("这是test里的a变量",a)
testB()
print("我也是全局变量a，没有被修改",a)
使用global修改全局变量
a = 100
print("我是全局变量a",a)
def testB():
global a #声明a为全局变量
a = 200 #
global b #声明全局变量
b = 500
print(b)
print("这是test里的a变量",a)
testB()
print("被修改后的全局变量a",a)
print(b)
多函数程序执行流程
glo_num = 0
def test1():
global glo_num
glo_num = 100
def test2():
print(glo_num)
print(glo_num) #修改的函数没有执行
test1()
test2()
print(glo_num)
结论：随着函数的推进，数据会发生变化
返回值作为参数传递
def test1():
return 50
def test2(num):
print(num)
#1.保存函数test1的返回值
result = test1()
# print(result)
#2.将函数返回值所在变量作为参数传递到test2函数
test2(result) #50
一个函数多个返回值的写法
def return_num():
# return 1,2 #返回的是元组
#return 后面可以直接书写 元组 列表 字典，返回多个值
# return (10,20)
# return [100,200]
return {'name':'Python','age':30}
result = return_num()
print(result)
注意：
1.return a , b写法，返回多数据的时候，默认是元组类型。
2.return 后面可以直接书写 元组 列表 字典，返回多个值
函数的参数
位置参数：调用函数时根据函数定义的参数位置来传递参数。
def user_info(name,age,gender):
print(f"我叫{name}，今年{age}岁了，性别是{gender}")
user_info('Tom',18,'男')
注意：传递和定义参数的顺序及个数必须一致
关键字参数——不区分先后顺序
写法：键=值
def user_info(name,age,gender):
print(f"我叫{name}，今年{age}岁了，性别是{gender}")
user_info('Tom', gender='男', age=18)
注意：函数调用时，如果有位置参数，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。
缺省参数
def user_info(name,age,gender='男'):
print(f"我叫{name}，今年{age}岁了，性别是{gender}")
user_info('Tom', age=18, gender='女') #我叫Tom，今年18岁了，性别是女
注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。
不定长参数
不定长参数也叫可变参数，用于用于不确定调用的时候会传递多少个参数的场景。
这时可以用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常的方便。
包裹位置传递—返回的是元组
# 当不知道传递多少参数时可以使用包裹位置传递
def user_info(*args):
print(args)
user_info('gyq')
user_info('gyq','123')
user_info('gyq','123',00)#('gyq', '123', 0)
（这个单词可以换成其他任意单词），这就是包裹位置传递。
包裹关键字传递— 返回的是字典
def user_info(**kwargs):
print(kwargs)
user_info(name='TOM',age=18,id=1)#{'name': 'TOM', 'age': 18, 'id': 1}
结论：
1.无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。
2.收集零散数据组成一个整体叫组包。
拆包和交换变量值
拆包：元组
def return_num():
return 100, 200
return_num1,return_num2 = return_num()
print(return_num1)
print(return_num2)
拆包：字典
dict1 = {'name':'TOM','age':18}
a,b = dict1
# 取出来的是key
print(a) #name
print(b) #age
# 找到对应的key所对应的值
print(dict1[a]) #TOM
print(dict1[b]) #200
引用
可以先把引用当成一个变量名
aa=[10,20]
bb=aa
print(id(aa))
print(id(bb))
aa.append(30)
print(bb) #[10, 20, 30]
print(id(aa))
print(id(bb))
# 执行结果
# 1551394103944
# 1551394103944
# [10, 20, 30]
# 1551394103944
# 1551394103944
结论：即使修改列表后id地址值仍然不变，说明是引用传递。
可变和不可变类型
数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变。
- 可变类型
- 列表
- 字典
- 集合
- 不可变类型
- 整形
- 浮点型
- 字符串
- 元组