#函数定义：
#格式：def函数标识符（参数列表）：
#定义无参函数
def say_hello():
print("hello world!")
print("hello everyone!")
#定义有参函数
def mymax(a, b):
if a > b:
print("最大值是", a)
else:
print("最大值是", b)
#函数调用
#格式：函数名（实际参数列表）
#函数调用时需要注意实参要和形参数量一致
say_hello()
mymax(3, 2)
#return[结果]：[]中的结果可以省略
#1.在函数的内部，用来结束当前函数的执行，并将结果返回给调用者
#2.如果return，结果被省略，则默认返回return none
#3.如果函数中没有return语句，相当与在函数最后执行了return none
#4.如果函数中return了结果，该结果要返回给调用者，一般需要一个变量来接受结果
#5.函数中最多一个return被执行
def myadd(x,y):
print("sum:",x + y)
return x + y
#代码不会被执行
#print
sum1=myadd(2,3)
print(sum1)
#不可变类型参数
#做的是值传递
def change(a):
print(id(a))
a=10
change(a)
a=1
change(a)
def change1(a):
a+=1
print(id(a))
a=10
change1(a)
#可变类型参数
#引用传递
def change2(mylist):
mylist.append(10)
print(mylist)
mylist=[1,2,3]
change2(mylist)
print(mylist)
#位置形参
#实参位置要和形参位置一致，输出结果要完整
def add(a,b):
return a+b
result = add(3,5)
print(result)
#result = add(3)
#print(result)
#缺省参数（默认参数）
#在定义函数时，给形参进行默认赋值化（形参初始化）默认参数建议使用不可变类型
#当函数调用没有给默认参数传实参，则使用默认参数初始化的值，如果传了实参使用实参值
#默认参数要在位置参数之后定义
def myadd(a,b,c=0,d=0):
return a+b+c+d
print((myadd(1,2,)))
print(myadd(1,2,3,4))
#def myadd(a,c=0,d=0,b):
# return a+b+c+d
#星号元组形参
#格式：*变量名
#意义：星号元组形参可以接受任意数据量的位置参数，并封装为一个元组
def prnt(*args):
print(*args)
prnt(1)
prnt(1,2,3,4)
def myadd(a,b,*args):
sum = a+b
for i in args:
sum += i
return sum
print(myadd(1,2,3,4))
#命名关键字参数：
#要在*或者*args之后出现
#在函数调用时，参数传递组要以赋值方式进行传递
#*分隔符，用来分隔位置参数和关键字参数
#如果命名关键字参数在定义时指定了默认值（即缺省参数），则调用时可以不传递实参，函数会使用默认值。
#如果命名关键字参数在定义时没有指定默认值，则调用时必须传递实参，否则会抛出 `TypeError`。
def func1(*,a,b):
print(a,b)
func1(a=1,b=2)
def func2(*args,a=0,b=0):
print(a,b)
func2(1,a=1,b=2)
#双星号字典参数
#格式：**kwargs
#可以接收任意数量的关键字参数，并打包成一个字典
#**kwargs在函数中最多出现一次，用来收集多余参数
#**kwsrgs一般放在最后
def func3(**kwargs):
print(kwargs)
func3(a=1,b=2)
def func4(a,b,c):
print(a,b,c)
#解包
#如果函数调用值提供的数据是元组或列表，可以用*解包
#如果数据是字典，可以使用**解包
t=(1,2,3)
func4(*t)
d={'a':1,'b':2,'c':3}
func4(**d)
#result返回多个值
def func5(x):
return x**2,x%2
x,y=func5(5)
print(x,y)
def add(a,b):
return a+b
result = add(1,2)
print(result)
#匿名函数：lamba函数的参数列表：函数体代码的表达式
func= lambda a,b:a+b
print(func(1,2))
#全局变量：在函数外部、python文件自定义的变量
#函数内部可以直接访问局部变量，但是不能直接修改全局变量
#a=1
#局部变量：是定义在函数内部的变量，局部变量在函数调用时创建，在函数调用完成后自动释放
#局部变量例子
def add(a,b):
return a+b
result = add(1,2)
print(result)
#print(a,b)
#全局变量例子
#函数内部可以访问全局变量
a=1
def func(b,c):
return b,c
result = func(1,2)
print(result)
print(a)
#函数内部不能直接修改全局变量
#def func2():
# a+=1
'''def func():
print('func')
def func2():
print('func2')
def execute():
print('execute')
func()
func2()
execute()'''
#如果python文件中定义了两个重名的函数，后面的函数会覆盖前面的
def func():
print('func')
def execute():
print('execute')
def func():
print('local func')
func()
def func():
print('new func')
execute()
func()
#嵌套函数可以封装函数内部的实际逻辑
#函数调用会优先调用嵌套的内部函数，而不是外部
def func3():
print('out func3')
def execute2():
print('execute2')
def func4():
print('inner func4')
func4()
execute2()
def execute3():
name='zhangsan'
#当在内部函数中使用变量时，如果在局部作用域中找不到，则到上层作用域中找。
def func5():
print('outer func5')
func5()
execute3()
#嵌套函数中，外部函数不能直接使用内部函数使用的变量
#内部函数可以访问外部函数的变量和参数
def outer():
x=10
def inner():
y=20
print(x,y)
inner()
# print(y)
outer()
def outer2():
name='zhangsan'
def inner2():
print(name)
#返回的是函数，不是函数调用
return inner2
#接收的是函数本身
inner2=outer2()
#加上（）才是函数调用
inner2()
