函数的定义和调用
# 函数，能够实现一个具体的功能，是多行代码的整合
# 函数的定义：使用关键字def
# def 函数名():
# 函数代码(函数体)
# 函数定义，函数中的代码不会执行，在函数调用的时候，才会执行
# 函数的好处：重复的代码不需要书写多次，减少代码冗余
# 函数的定义
def func():
print('好好学习，天天向上')
print('good good study, day day up')
print('授课认真听，莫要走神')
# 调用函数,函数的好处就是可以重复调用
func()
函数文档说明
# 函数的文档说明本质就说注释，告诉别人，这个函数怎么使用，是干什么事的
# 只不过这个注释，有特定的书写要求，要写在函数的名字下方
def fun():
"""
打印输出一个hello world
"""
print('hello world')
fun()
# 查看函数的文档注释可以使用help(函数名)
help(fun())
函数参数
# 定义一个函数，实现两个数的和
def add(a, b): # a和b称之为形式参数，简称形参
c = a + b
print(f'求和的结果{c}')
# 如果不传参数会报错
add(10,3)
局部变量
# 局部变量，就是在函数内部定义的变量，就是局部变量
# 局部变量，只能在函数内部使用，不能再函数外部使用和其他函数使用
def func():
# 定义局部变量 num
num = 100
print(num)
def func1():
num = 200 # 这个num和func中的num 是没有关系的
primt(num)
# 函数调用
func()
# print(num) # 代码报错，局部变量不能再外部和其他函数中调用
全局变量
# 全局变量：就是在函数外部定义变量
# 定义全局变量
g_num = 100
# 1. 能否在函数内部访问全局变量？ ====> 可以直接访问全局变量的值
def func():
print(g_num)
# 2. 能否在函数内部修改全局变量的值？ ====> 不能
def func1():
# g_num = 200 # 这里不是修改全局变量的值，定义的是一个局部变量，和全局变量的名字一样而已
# 想要在函数内部修改全局变量的值，需要使用global关键字声明这个变量为全局变量
global g_num
g_num = 200
func()
func1()
func()
函数的返回值
# 函数想要返回一个数据值，给调用的地方，需要用到关键字return
# return 关键字的作用
# 1. 将return后边的数据值进行返回
# 2. 程序遇到return会终止执行
# 3. return 关键字必须写在函数中
def add (a,b):
c = a + b
return c
result = add(15, 89)
print(f'函数外部获取的求和结果：{result}')
函数返回多个数据
def func(a,b):
c = a + b
d = a - b
# return [c,d] # 可以是用列表丶字典丶元组
return c,d # 也可以这样写，python默认返回的是元组 如果return不写返回值，那么默认的返回是None
reslut = func(20, 6)
print(reslut)
函数嵌套调用
def testB():
print('testB start....') # 第二步走这里
print('函数的其他代码')
print('testB end...')
def testA():
print('testA start....') # 第一步走这里
testB()
print('testA end...') # 最后走这里
testA()
函数应用
def func1(a):
print('func1 start....')
print('函数的其他代码', a)
print('func1 end....')
def func2():
print('func2 start....')
func1()
print('func2 end.....')
函数传参的方式
def func(a,b,c=10): # 形参c 称为缺省形参
print(f'a:{a}')
print(f'b:{b}')
print(f'c:{c}')
# 位置传参, 按照形参位置的顺序将实参传递给实参
func(1,2,3)
# 关键字传参,指定实参给那个形参，注意点:关键字必须是函数的形参名
func(a=10,b=20,c=30)
# 混合使用，先写位置传参，在写关键字传参
func(10, b=30, c=60)
# 缺省参数，形参，在函数定义的时候，给形参一个默认值，这个参数就是缺省参数
# 注意点：缺省参数要写在普通参数的后边
# 特点：在函数调用的时候，如果给缺省参数传递的是实参值，使用的是传递的实参值，如果没有传递，使用的是默认值
func(5, 20)
func(5, 20, 6)
# 不定长参数
# 在形参前边加上一个*，该形参变为不定长元组参数，可以接收所有位置的实参，类似元组
# 在形参前边加上两个*，该形参变为不定长字典形参，可以接收所有的关键字实参，类型是字典
def func1(*args, **kwargs):
num = 0
for i in args:
num += i
for j in kwargs.values():
num += j
print(num)
func1(1,2) # 这里打印的是(1,2) {}
func1(a=1,b=2,c=3) # 这里打印的是() {'a':1,'b':2, 'c': 3}
func1(1,2,3,a=1,b=2,c=3) # 这里打印的是(1,2,3) {'a':1,'b':2, 'c': 3}
# 函数形参的完整格式
def func2(a,*args,b=1,**kwargs): # 先普通在缺省
pass
# 拆包，组包
# 组包，将多个数据值，给一个变量
a = 1,2,3 # 类型是元组
# 拆包：将容器的数据分别给到多个变量，需要主意的是数据的个数和变量的数量要保持一致
b,c,d = a # 拆包
def fun3():
return 1, 2
e,f = fun3()
print(e,f)
引用及引用参数
# 可以使用id()查看变量的引用，可以将id值认为是内存发地址别名
# python中的数据值的传递的是引用
# 赋值运算符可以改变变量的引用
# 将数据10 存储到变量a中， 本质是将数据10所在的引用地址保存到了变量a中
a = 10
# 将变量a中保存的引用地址给到b
b = a
print(a,b) # 是用print函数打印变量a 和 b 引用中的存储值
print(id(a), id(b))
a = 20
print(a,b)
print(id(a), id(b)) # a值变了id也会跟着变
my_list = [1,2,3]
my_list1 = my_list
print(my_list, id(my_list))
print(my_list1, id(my_list1))
my_list.append(4) # 想列表中添加数据4.将数据4的引用保存到列表中
print(my_list, id(my_list))
print(my_list1, id(my_list1))
my_list[2] = 5
print(my_list, id(my_list))
print(my_list1, id(my_list1))
# 类型的可变与不可变
# 如果能改变是可变类型，如果不能改变，是不可变类型
# int floot bool str list tuple dict
# 不可变类型：int,floot,bool,str,tuple
num = 10
num = 20 # 这里改变的是内存地址
# 可变类型：list,dict
my_list = [1,2,3]
my_list.append(4)
# 引用做参数
# 函数传参传递的也是引用
# 函数传参传递的也是引用，所以在函数内部对参数的修改会影响到函数外部的变量
my_list = [1, 2, 3, 4, 5]
def func(a):
a.append(6)
def func2(a):
# 为啥这里不用global，因为没有修改 my_list 中的引用，只是修改了引用指向的对象
a.append(7)
def func3():
global my_list
my_list = [1, 2, 3] # 修改全局变量的值，也就是修改了引用指向的对象
def func4(a):
# 对于列表来说。类似列表的extend方法，不会修改变量的引用地址
a += a
func(my_list)
print(my_list) # Output: [1, 2, 3, 4, 5, 6]
func2(my_list)
print(my_list) # Output: [1, 2, 3, 4, 5, 6, 7]
func3()
print(my_list) # Output: [1, 2, 3]
func4(my_list)
print(my_list)