一、函数的定义：
def 函数名（）：#函数定义函数名相当于是一个变量存函数内存地址，函数体相当于变量值
函数体 #函数定义时只会检查子代码语法错误，不会执行函数子代码
#返回值#可选
#函数中可以调用其他函数，
#函数定义的时候先后顺序不受影响，调用阶段在定义阶段后就可以了。
二、函数的调用:
函数名（）#相当于内存地址加括号调用函数，先通过内存地址找到函数体然后执行
print（函数名）#打印的是函数的内存地址
三、函数的返回值
函数返回值使用return关键字 +值
写了返回值的返回返回值，没有写返回和返回值的默认返回None
函数遇到return即终止，后面的代码不执行，即使在多层嵌套循环中也会终止
返回值默认返回到函数调用的地方
返回值可以返回一个表达式
返回多个值默认是元组类型，如需其他类型需手动加工
四、函数的参数
函数分，无参函数，有参函数，需要在定义时决定好
4.1参数的类型
函数定义时定义的参数名，称为形式参数，简称形参
函数调用时传入的参数，称为实际参数，简称实参
函数参数的写入的优先级，
位置形参，默认值关键字形参，不定长参数元组，不定长参数字典
不定长参数接收的都是溢出的参数，有位置形参或者关键字形参都是有值先传对应形参
除位置，关键字不定长参数外，
形参还有，*，单独出现的方式，用途是声明后面传递的参数都必须时关键字参数，
还有x:str,用途是声明函数形参的类型，并可以在函数内部调用对应类型的方法，但是不强制传固定类型，会报语法不规范警告
def fun(x:str):
x.split()
print(x)
除了默认值参数，不管以何种方式，每个形参位置必须接收一个实参，多了不行少了也不行。
##有参函数的类型
#位置（必传）参数：调用时的实际参数的个数和顺序，必须与定义的形式参数个数和顺序相同
#关键字参数：函数调用时，使用''形参=实参''的方式传参，传递参数顺序可以与定义时的不同
语法规定：位置参数与关键字参数可以混用传值，关键字参数需要写在位置传参后面，否则报位置参数跟随关键字参数异常。
#命名关键字参数，#单独出现*后关键字声明： 声明函数时 *号可以单独出现，单独出现*号后的参数必须以 关键字 传入
#默认值参数：函数定义时，就为其赋了默认值的参数，在调用时如果该参数不传值，那么将使用默认值，如果该参数传值，则使用传入的值。
语法规定：有多个形参（位置，默认值）时，默认值参数必须写在最后，否则报非默认参数跟随默认参数异常。
#默认参数的值时在函数定义的时候赋值的
c=20
def xun(x,y=c):#间接引用，把c的内存地址给到y
print(x,y)
c=30#更改了全局
xun(1)#结果还是1，20
#默认参数的值时在函数定义的时候赋值的
b=[1,20,30,40]
def xun(x,y=b):#间接引用，把b的内存地址给到y
print(x,y)
b.append(10000)#可变对象，其指向的没有变
xun(1)#结果时加入了10000的列表
# 函数的形参其实就是变量名，既然是变量名我们就可以给他赋值各种类型的值的
#不建议赋值成可变类型，因为一个函数的结果最好只跟函数的调用和它本身有关系
#就是给函数什么参数就能得到什么结果，而不会受到外界其他代码的影响，这样函数的调用结果才是可控的
初始：
def myappend(x,y,l=[]):#给append方法加个量，语法不规范警告
l.append(x)
l.append(y)
return l
print(myappend(1, 2))
def myappend(*x,l=[]):#
l.append(x)
return l
print(myappend(1, 2, 3,4,5,6,))
#但是我们有时又会有这种的需求，需要设成一个可变类型
改良：
def myappend(x,y,l=None):#这里设置成不可变类型，转到函数内做判断
if l is None：#小整数池中包含None,None用is是规范，==也可以但是不规范
l=[]#如果没传值用可变类型列表这个，传值了用默认，实现了可变默认形参规范化
l.append(x)
l.append(y)
return l
print(myappend(1, 2))
#不定长（可变长度位置）参数：
个数可变的的位置参数，在参数前加入一个*号，函数调用时可接收任意个数的实际参数，放到一个元组中
#不定长（可变长度关键字）参数：
个数可变的关键字参数，在参数前加入两个*号，在函数调用时可接收多个''参数=值''形式的参数，放到一个字典中
理论上来说，形参的不定长参数可以随意命名，但是从规范上来说，必须得用*args和**kwargs作为形参名
不定长参数接收的都是溢出的参数，有位置形参或者关键字形参都是有值先传对应形参
#形参和实参中同时带*号
def lianxi(*args):#不定长参数接收所有溢出的位置参数（这里是所有打散的参数）打包成元组赋值给args
print(args)
a=[100,200,300]
lianxi(*a)#这里作用是打散列表，相当于lianxi（100,200，300），如果这里不使用*号打散成位置实参，同样形参*args会打包成一个元组结果为([100,200,300]),作为一个参数打包成元组传给args
#形参和实参中同时带*号
def lianxi(*args,**kwargs):#不定长参数接收所有溢出的打散的元素打包赋值给kwargs，
print(args)
print(kwargs)
a={'1':100,'2':200,'x':300}#关键字只能是字符串，打散成关键字形参的字典的key也需要满足
lianxi(*a)#这里key打散成位置参数，传给args
lianxi(**a)#字典不能直接传，这里作用是打散字典称为关键字形参
所有可迭代对象都可以打散，集合元组，字符串字典都可以
def lianxi(*args,**kwargs)：#带*args和**kwargs的参数不管怎么传都能够接收
#不传值默认是空元祖和空字典
#传值的话，除去前置的位置参数，溢出的位置参数都会被*args接收打包成元组
#除去前置的关键字参数，溢出的关键字实参都会被**kwargs打包成字典
例子：嵌套返回参数加强函数扩展性
def fun(x,y,z,a):
print(x,y,z,a)#4.真正接受参数运行的
def fun1(*args,**kwargs):#2.将接收来的参数打包成元组和字典
fun(*args,**kwargs)#3.调用函数fun，打散元组和字典，传给对应的fun1的位置参数或关键字参数
fun1(1,2,3,a=100)#1.通过fun1调用fun，由fun1接收所有参数
# def fun(*args,**kwargs):#优化版
# print(args)
# print(kwargs)
# def fun1(x,y,z,a):
# print(x,y,z,a)
# return fun1(*args, **kwargs)
#
# fun(1,2,3,a=100)
##参数的类型
#位置（必传）参数：调用时的参数个数和顺序，必须与定义的参数个数和顺序相同
#关键字参数：函数调用时，使用''形参名称=值''的方式传参，传递参数顺序可以与定义时的不同
#命名关键字参数，#单独出现*后关键字声明： 声明函数时 *号可以单独出现，单独出现*号后的参数必须以 关键字 传入
#默认值参数：函数定义时，直接形式参数进行赋值，在调用时如果该参数不传值，那么将使用默认值，如果该参数传值，则使用传入的值。同时有多个参数时，默认值参数一般写在最后，便于使用。
#不定长（位置）参数：个数可变的的位置参数，在参数前加入一个*号，函数调用时可接收任意个数的实际参数，放到一个元组中
#不定长（关键字）参数：个数可变的关键字参数，在参数前加入两个*号，在函数调用时可接收多个''参数=值''形式的参数，放到一个字典中
不定长参数搭配其它参数使用的话作用是，接收多出来的形参打包成一个元组或字典
###强调注释：
*号和**在形参里搭配其它参数中，作用是不定长参数，打包在一起
在其它位置容器类型前出现，是解包的用法，单星号解字典的话会打散成key
**双星号解包字典的话还会是key：value键值对。
b=[100,200,300] x,y,z=b print(x,y,z)#解包赋值
b=[100,200,300] print(*b)#打散
a,*b='room';print(a);print(b)#扩展字符串解包赋值
def printme(str,n):#必传参数: 必须以正确的顺序传入参数，调用时的数量必须和定义声明时一致，不传出现语法错误会报错
print(str*n)
printme('我要调用自定义函数',10)
def printme(str,n):#关键字参数: 使用关键字参数允许传入顺序与定义声明时不一致，python解释器能够自动匹配参数名和参数值。
print(str*n)
printme(n=10,str='我要调用关键字函数')
def printme(n,*,str):#单独出现*后关键字声明： 声明函数时 *号可以单独出现，单独出现*号后的参数必须以 关键字 传入
print(n)
print(str)
return
printme(10,str=20)#第一个参数传入n，后面的需以关键字传入，不传报错
def printme(str,n=2):#默认参数: 使用默认参数时，若没有传递参数，则会使用默认参数，同时存在位置参数时，为便于使用，默认值参数最好写在后面。
print(str*n)
printme('我要调用自定义函数')
def printme(n,*str):#不定长参数: 使用不定长参数时,加了*号的参数会以元组的形式导入，存放所有未命名的参数
print(n)
print(str)
printme(10,20,30,40,20,30,405)#第一个参数传入n，后面的全传入str
printme(10)#第一个参数传入n，str不定长参数没有指定参数时，就是一个空元组
def printme(*str):
print(type(str))
for i in str:
print(i)
printme(10,20,30,40,20,30,405)
printme()#不传的话是个空元组
def printme(*str):
print(type(str))
for i in str:
print(i)
printme([10,20,30,40,20,30,405])#元组中的列表，会作为一个元素传入形参中
#调用时，实参前加一个*号，可以对列表进行解包
printme(*[10,20,30,40,20,30,405])#解包后列表将拆分作为多个元素
#不定长（关键字）参数：
def printme(n,**str):#不定长参数: 加了**号的参数会以字典的形式导入
print(n)
print(str)
printme(10,a=20,b=30,c=40,d=20,e=30,f=405)#第一个参数传入n，后面的全传入str
printme(10)#第一个参数传入n，**str不定长参数没有指定参数时，就是一个空字典
def printme(**str):
print(type(str))
for i,j in str.items():
print(i,j)
printme(a=10,b=20,c=30,d=40,f=20,g=30,h=405)#不定长关键字参数的实参以键值对的方式传入形参
dic={'a':10,'b':20,'c':30,'d':40,'e':20,'f':30,'h':405}
print(type(dic))
printme(**dic)#字典传入需在前面加两个*号，进行字典的解包
五、变量的作用域
#python中引用变量的时候尤其要注意变量的作用域，在函数中引用不可变类型的时候，
#函数执行结束是不会更改全局变量的值的；若想在结束后改变全局变量的值，引用的时候需要使用‘global 变量名，变量名’声明是全局变量，多个变量声明用逗号链接。
#对于可变变量，函数执行结束后全局变量的值是会被改变的。
a=100#声明的全局变量整数型a
def f1():
print(a)#在这里a是全局变量，可以直接打印输出，结果成功输出a的值100
# def f2():
# print(a)#报错，由于下一行重新声明了a=18，所以这里a是个局部变量，且该行a没有定义
# a = 18
def f3():
a = 99
print(a)#成功输出a在函数中的值，在这里a是局部变量，全局变量a100在函数中不可见，局部变量a覆盖了它，所以引用的是函数内的a，外面的a没有改变，打印的是函数内的
def f4():
global a
a = 18
print(a)#成功输出a在函数中的值18，函数内声明了a是全局变量，并对全局变量a进行重新赋值，所以函数外a的值也被改变了
f1()
#f2()报错
f3()
f4()#函数内声明全局了更改成了18
print(a)
#函数内定义的变量或重新赋值的都是局部变量，如果要对函数内定义的变量进行全局修改，需要用global在函数中声明，
传可变对象字典列表集合不用可以直接函数内更改