什么是函数
函数是指将一组语句的集合通过一个名字（函数名）封装起来，想要执行这个函数，只需调用其函数名即可
1、减少重复代码
2、使程序变的可扩展
3、使程序变得易维护
定义函数的语法
形参
主要的作用就是接受实参参数的传递，并且被语法调用 #形参只有在被调用时才内存单元，在调用解释时，即可释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参
主要的作用就是讲参数传递给形参 #实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，他们都必须有确定的值，以便把这些值传递给形参。因此应预先用赋值，输入等办法使参数获得确定值
定义函数的形参，并且将实参传递给形参再调用
def calc(x，y): #def关键词，calc函数名，括号里的是形参
res = x**y
return res
c = calc(a,b) #括号里的是实参，传递给x和y
print(c)
位置形参:指的是在函数定义阶段按照从左到右的顺序依次定义的形参
特点: 必须被传值,多一个不行,少一个也不行
位置实参: 指的是在函数调用阶段按照从左到右的顺序依次传入的值
特点: 与形参一一对应
形参也可以是默认值
def calc（x,y=2） #这样在函数调用时如果形参不指定参数，则在调用时就是默认值，如果指定，则是指定值
默认参数(默认形参): 在函数定义阶段,就已经为形参赋值
特点: 在定义阶段就已经有值,意味着在调用阶段可以不用传值
注意: 可以混用位置形参与默认形参,但是
1、位置形参必须放在默认形参前面
2、默认形参的值只在函数定义阶段赋值一次,定义之后的任何改动都无法影响默认形参的值
3、默认形参的值通常应该是不可变类型
关键字参数
一般情况下，给函数传参数时要按顺序，不想按顺序就可以用关键字参数，只需指定参数名即可（指定了参数名的参数就叫关键参数），关键字参数必须放在位置参数（以位置顺序确定对应关系的参数）之后
关键字参数(单指关键字实参): 在函数调用阶段,按照key=value形式为指定的形参赋值
特点: 可以完全打乱传值的顺序,但仍然能指名道姓地为指定的形参赋值
注意:可以混用位置实参与关键字实参,但是
1、不能为同一个形参重复赋值
2、位置实参必须放在关键字实参的前面
PS：位置参数就是形参没有指定任何值，所以函数调用时候是按照位置传递的，关键字参数就是指定形参的默认值，所以必须放在位置参数的后面，不然在函数传递时候按照位置传递，会出现错误
例：def stu_register(name,age,course='Py',counter='CN')： #def是函数定义关键字，结尾必须用：结束，这是强制语法
print("姓名:"， name)
print("年龄:"， age)
print("课程:" ，course)
print("国籍:"， counter)
stu-register(‘Karl’,course='Py',age=22,counter='JP') #这里Karl没有用赋值去指定赋值给哪一个形参，所以必须对应形参的位置，而后面的实参都有赋值给指定的形参，所以可以不用按位置写
可变长参数
指的是在调用函数时传入的值(实参)个数不固定,而实参无非两种,一种位置实参
另外一种就是关键字实参,针对这两种形式实参的个数不固定,对应着形参也应该有两种解决方案来分别应对溢出位置实参(*)与关键字实参(**)
若在函数的定义时不确定用户想传入多少个参数，就可以使用非固定参数（*args和*kwargs）
*args会把多传入的参数变成一个元组形式
def stu(name,age,*args)
print(name,age,args)
stu('Karl',22)
输出的结果就是Karl 22() #输出结果后面有一个（），元组符号，这个就是args，因为没有传入任何值，所以就是一个空元组
**kwargs 会把多传入的参数变成一个dict的形式（字典形式）
def stu(name,age,*args,**kwargs)
print(name,age,args,kwargs)
stu('Karl',22,'cn','Py',sex='male')
输出结果就是Karl 22 ('cn', 'Py') {'sex': 'male'}
PS：*args前面是一个*，**kwargs前面是两个*，args传入时候单个字符串即可，而kwargs传入的时候必须以键值（key=value）传入（即字典形式传入）
PS:*args和**kwargs其实就是前面的*起作用，后面的名称只是约定俗成的名字（可以随便写），这样所有开发人员看到这个就知道一个是传入元祖，一个是将值变成关键字传入
PS:在实参中出现*: 但凡是在实参中出现*,都将*后的值打算成位置实参,然后再进行赋值
PS:在实参中出现**: 但凡是在实参中出现**,都将**后的值打算成关键字实参,然后再进行赋值
PS:在形参中出现**: **会将溢出的关键实参存成字典的形式,然后赋值紧跟其后的形参
PS:在形参中出现*: *会将溢出的位置实参存成元组的形式,然后赋值紧跟其后的形参
例：利用可变长参数在函数体内调用另一个函数的时候，将实参传递给被调用的函数
def index(a,b,c): #先定义一个有形参的函数
print('from index',a,b,c) #执行打印形参
def wrapper(*args,**kwargs): #这里再定义一个函数带有可变长参数
index(*args,**kwargs) #直接调用上面的函数并且形参定义成可变长参数
wrapper(1,c=3,b=2) #在调用的时候将wrpper实参传递给形参，然后在传递给调用的index的形参
PS：这里由于wapper函数执行的就是调用index
列：利用位置参数传递
def index(a,b,c):
print('from index',a,b,c) #这个函数执行的操作
def wrapper(name,age,sex): #这个带有形参的函数
index(name,age,sex) #这里调用函数时候的形参必须是这个函数块的形参
wrapper('karl','123','male') #这里按照位置实参传递
PS：这是一个相互传递的过程，调用时候将位置实参传递给形参，然后再传递给调用的函数
命名关键字形参:
在定义函数阶段,但凡是在*与**之间的参数称之为命名关键字形参
特点: 必须被传值, 并且在传值时必须按照key=value的形式传值
例：
def func(x,*args,m=111,n,**kwargs):
print(x)
print(m)
print(n)
print(kwargs)
print(args)
func(1,1,2,3,4,n=3,a=5,b=6)
PS:参数的顺序，先写位置，再写默认（*前面的才是默认参数），然后写*args，再跟关键字参数（*后面的是带有默认值（无默认值）的关键字参数），最后跟**kwargs
PS：位置实参必须按照位置传递，关键字和*和**之间则无需按照位置，位置后面如果没有传递默认参数的值，也没有传递关键字参数，则会将所有溢出字符传递给*，如果是k=v的值全部溢出的传递给**
返回值（return）
函数外部代码想要获取函数的执行结果，就可以在函数里用return语句把结果返回
def stu_register(name,age,course='Py',counter='CN')：
print("姓名:" ，name)
print("年龄:" ，age)
print("课程:" ，course)
print("国籍:" ，counter)
if age > 22: #这里输出一个判定条件，用return返回后面的结果
return False
else:
return True
s_reg = stu_register(‘Karl’,course='Py',age=22,counter='JP')
if s_reg:
print('注册成功')
else:
print('年龄太大‘’)
PS：函数在执行过程中只要遇到return语句，就会停止执行并返回结果，return语句就是函数运行结束的一个语句，如果未在函数中指定return，那么这个函数的返回值为None
全局变量和局部变量
1、在函数中定义的变量就是局部变量，在程序的一开始定义的变量称为全局变量
2、全局变量的作用域是整个程序，局部变量作用域就是定义该变量的函数
3、当全局变量与局部变量同名时，在定义局部变量的函数内，局部变量起作用，在其他地方则是全局变量起作用
name = 'Alex' #这个是全局变量
def change_name(name):
print('beore change:',name)
name ='Karl' #这个是局部变量，只给下面的调用
print('after change:',name)
change_name(name)
作用域
作用域（scope），通常来说，一段 程序代码中所用到的名字并不总是有效/可用的，而限定这个民资的可用性的代码范围就是这个名字的作用域
global 声明全局变量函数
def change_name(): #这里没有定义形参
global name #用global 函数声明name就是全局变量
name ='Karl'
print('after change:',name)
change_name() #用为用了global全局函数声明变量name，所以这里也可以打印name
嵌套函数
name = 'Alex'
def change_name():
name = 'Alex2'
def change_name2():
name = 'Alex3'
print('第三层：',name)
change_name2()
print('第二层：',name)
change_name()
print('最外层：',name)
PS：函数嵌套的调用也是需要按照层级来依次调用的，如果在第二层调用第三层则会报错，所以第二层只能调用第二层
匿名函数（lambda）
匿名函数就是不需要显式的指定函数名
通常函数的调用
def calc(x,y)
return x**y
print(clac(2,5))
采用匿名函数
calc = lambda x,y:x**y
print(calc(2,5))
匿名函数的主要用法是和其他函数搭配使用
res = map(lambda x:x**2,[1,5,7,4,8]) #这里直接定义了一个变量的计算过程，用lambda函数定义X，冒号后面传递一个计算的方式，最后用列表定义x的值
for i in res:
print(i)
闭包函数
什么是闭包函数=>函数嵌套+函数对象+名称空间与作用域
闭:定义在函数内的函数
包:该内部函数需要访问一个名字,该名字属于外层函数作用域的(强调:不是全局作用域)
为何要用闭包函数？
为了实现装饰器
如何用闭包函数
def outter(name): #定义函数
x = ‘456’
print（x） #
def inner(): #函数内嵌套一个函数
print（‘成功调取这一层值’）
return inner #返回函数，不能加括号，加了括号就是调取函数的功能，不加括号就是返回一个函数的内存空间地址
f = outter() #outter内最后将inner的内存地址做返回结果，所以outter函数的只会返回inner的内存空间地址，这里outter就是inner的内存空间地址并且赋值给f
f() #这里调用f就获得了inner局部变量的值
PS：首先定义一个函数，然后在下层定义一个函数，最后返回下层函数的内存空间地址给全局函数，然后将全局函数的赋值给一个变量
PS：由于全局函数outter下层有一个打印值，所以在打印f的时候也会打印出来
高阶函数
变量可以指向函数，函数的参数能接受变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数
只要满足以下任意一个条件，即是高阶函数
1、接受一个或多个函数作为输入
2、return返回另一个函数
def add(x,y,f):
return f(x) + f(y)
res = add(3,-6,abs)
print(res)
递归函数
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数
特性：
1、必须有一个明确的结束条件
2、每次进入更深一层的递归时，问题规模相比上次递归都应有所减少
3、递归效率不高，栈就会增加一层栈帧，每当函数返回，栈就会减一层栈。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出
def calc(n):
print(n)
if int(n/2) == 0:
return n
return calc(int(n/2)
calc(10)
私有地址 # 只能在函数的内部获取
定义方式 __funcname # 私有地址的命名方式就是在函数名前加__
在函数的内部调用方式
class FTPHandler():
def handle(self):
print('1')
if hasattr(self,"_FTPHandler__get"): # hasattr判断如果有这个函数名，调用私有地址的方式是_父类名+私有地址的函数名将名字拼成私有地址的格式
print('yes')
else:
print('没有找到')
def __get(self):
'''私有地址函数'''
print('123')
ftp = FTPHandler()
ftp.handle()