一 函数知识体系
什么是函数？
为什么要用函数？
函数的分类：内置函数与自定义函数
如何自定义函数
语法
定义有参数函数，及有参函数的应用场景
定义无参数函数，及无参函数的应用场景
定义空函数，及空函数的应用场景
调用函数
如何调用函数
函数的返回值
函数参数的应用：形参和实参，位置参数，关键字参数，默认参数，*args，**kwargs
高阶函数（函数对象）
函数嵌套
作用域与名称空间
装饰器
迭代器与生成器及协程函数
三元运算，列表解析、生成器表达式
函数的递归调用
内置函数
面向过程编程与函数式编程
二 函数基础
# 注册功能 uname=input('username>>：').strip() pwd1=input('password>>: ').strip() pwd2=input('重复输入密码>>: ').strip() if pwd1 == pwd2: with open('db.txt','at',encoding='utf-8') as f: f.write('%s:%s ' %(uname,pwd1)) f.flush() #认证功能 inp_uname=input('请输入你的账号：').strip() inp_pwd=input('请输入你的密码：').strip() with open('db.txt','rt',encoding='utf-8') as f: for line in f: info=line.strip(' ').split(':') if inp_uname == info[0] and inp_pwd == info[1]: print('login successfull') break else: print('账号或密码错误')
一 为何要用函数之不用函数的问题
#1、代码的组织结构不清晰，可读性差 #2、遇到重复的功能只能重复编写实现代码，代码冗余 #3、功能需要扩展时，需要找出所有实现该功能的地方修改之，无法统一管理且维护难度极大
二 函数是什么
针对二中的问题，想象生活中的例子，修理工需要实现准备好工具箱里面放好锤子，扳手，钳子等工具，然后遇到锤钉子的场景，拿来锤子用就可以，而无需临时再制造一把锤子。
修理工===>程序员
具备某一功能的工具===>函数
要想使用工具，需要事先准备好，然后拿来就用且可以重复使用
要想用函数，需要先定义，再使用
1、什么是函数？
在程序中,函数就具备某一功能的工具
事先将工具准备好即函数的定义
遇到应用场景拿来就用即函数的调用
所以务必记住:#函数的使用必须遵循先定义,后调用的原则
2、为何要用函数
不用函数问题是：
1、程序冗长
2 程序的扩展性差
3 程序的可读性差
3 如何用函数:
函数的使用必须遵循先定义,后调用的原则
二 定义函数
一 如何自定义函数？
def 函数名(参数1,参数2,...): ''' 函数功能的描述信息 :param 参数1: 描述 :param 参数2: 描述 :return: 返回值 ''' 代码1 代码2 代码3 ... return 返回值
# 准备好工具=>函数的定义阶段 def register(): while True: uname=input('username>>：').strip() if uname.isalpha(): break else: print('用户名必须由字母组成傻叉') while True: pwd1=input('密码>>: ').strip() pwd2=input('重复输入密码>>: ').strip() if pwd1 == pwd2: break else: print('两次输入的密码不一致,眼瞎吗') with open('db.txt','at',encoding='utf-8') as f: f.write('%s:%s ' %(uname,pwd1)) f.flush() def auth(): #认证功能 inp_uname=input('请输入你的账号：').strip() inp_pwd=input('请输入你的密码：').strip() with open('db.txt','rt',encoding='utf-8') as f: for line in f: info=line.strip(' ').split(':') if inp_uname == info[0] and inp_pwd == info[1]: print('login successfull') break else: print('账号或密码错误') # 拿来就用=>函数的调用阶段 # print(register) # register() # auth() # register() # register()
二 函数使用的原则：先定义，再调用
函数的使用必须遵循先定义,后调用的原则,没有事先定义函数，而直接引用函数名，就相当于在引用一个不存在的变量名
#测试一 def foo(): print('from foo') bar() foo() #报错 #测试二 def bar(): print('from bar') def foo(): print('from foo') bar() foo() #正常 #测试三 def foo(): print('from foo') bar() def bar(): print('from bar') foo() #会报错吗? 不会 #测试四 def foo(): print('from foo') bar() foo() #会报错吗? 会 def bar(): print('from bar') #结论:函数的使用,必须遵循原则:先定义,后调用 #我们在使用函数时,一定要明确地区分定义阶段和调用阶段 #定义阶段 def foo(): print('from foo') bar() def bar(): print('from bar') #调用阶段 foo()
三 函数在定义阶段都干了哪些事？
只检测语法，不执行代码
也就说，语法错误在函数定义阶段就会检测出来，而代码的逻辑错误只有在执行时才会知道
四 定义函数的三种形式
#1、无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印 #2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值 #3、空函数：设计代码结构
#定义函数时的参数就是函数体接收外部传值的一种媒介，其实就一个变量名 #1、无参函数： # 在函数定义阶段括号内没有参数，称为无参函数 # 注意：定义时无参，意味着调用时也无需传入参数 # 应用： #如果函数体代码逻辑不需要依赖外部传入的值，必须定义无参函数 # def func(): # print('hello world') # func() #2、有参函数 # 在函数定义阶段括号内有参数，称为有参函数 # 注意：定义时有参，意味着调用时也必须传入参数 # 应用： #如果函数体代码逻辑需要依赖外部传入的值，必须定义成有参函数 # def sum2(x,y): # # x=10 # # y=20 # res=x+y # print(res) # # sum2(10,20) # sum2(30,40) def check_user(): while True: uname=input('username>>：').strip() if uname.isalpha(): return uname # break else: print('用户名必须由字母组成傻叉') def check_pwd(): while True: pwd1=input('密码>>: ').strip() pwd2=input('重复输入密码>>: ').strip() if pwd1 == pwd2: return pwd1 else: print('两次输入的密码不一致,眼瞎吗') def db_hanle(uname,pwd1): with open('db.txt','at',encoding='utf-8') as f: f.write('%s:%s ' %(uname,pwd1)) f.flush() def register(): # 检测用户名是否合法 x=check_user() #x='EGON' # 检测密码是否合法 y=check_pwd() #y='123' # 写入数据文件 # db_hanle(合法的用户名，合法的密码) db_hanle(x,y) # register() #3、空函数 # def func(): # pass def check_user(): pass def check_pwd(): pass def write_db(x,y): pass def register(): #1 输入用户名，并进行合法性校验 #2 输入密码，并进行合法性校验 #3 将合法的用户名、密码写入文件 x=check_user() y=check_pwd() write_db(x,y)
三 调用函数
一 调用函数
函数的调用：函数名加括号 1 先找到名字 2 根据名字调用代码
二 函数返回值
无return->None return 1个值->返回1个值 return 逗号分隔多个值->元组
什么时候该有返回值？ 调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值 通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果 什么时候不需要有返回值？ 调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值 通常无参函数不需要有返回值
三 函数调用的三种形式
1 语句形式：foo()
2 表达式形式：3*len('hello')
3 当中另外一个函数的参数：range(len('hello'))
四 函数的参数
一 形参与实参
#形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定
二 具体应用
#1、位置参数：按照从左到右的顺序定义的参数 位置形参：必选参数 位置实参：按照位置给形参传值 #2、关键字参数：按照key=value的形式定义的实参 无需按照位置为形参传值 注意的问题： 1. 关键字实参必须在位置实参右面 2. 对同一个形参不能重复传值 #3、默认参数：形参在定义时就已经为其赋值 可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参） 注意的问题： 1. 只在定义时赋值一次 2. 默认参数的定义应该在位置形参右面 3. 默认参数通常应该定义成不可变类型 #4、可变长参数： 可变长指的是实参值的个数不固定 而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs ===========*args=========== def foo(x,y,*args): print(x,y) print(args) foo(1,2,3,4,5) def foo(x,y,*args): print(x,y) print(args) foo(1,2,*[3,4,5]) def foo(x,y,z): print(x,y,z) foo(*[1,2,3]) ===========**kwargs=========== def foo(x,y,**kwargs): print(x,y) print(kwargs) foo(1,y=2,a=1,b=2,c=3) def foo(x,y,**kwargs): print(x,y) print(kwargs) foo(1,y=2,**{'a':1,'b':2,'c':3}) def foo(x,y,z): print(x,y,z) foo(**{'z':1,'x':2,'y':3}) ===========*args+**kwargs=========== def foo(x,y): print(x,y) def wrapper(*args,**kwargs): print('====>') foo(*args,**kwargs) #5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递 可以保证，传入的参数中一定包含某些关键字 def foo(x,y,*args,a=1,b,**kwargs): print(x,y) print(args) print(a) print(b) print(kwargs) foo(1,2,3,4,5,b=3,c=4,d=5) 结果： 2 (3, 4, 5) 3 {'c': 4, 'd': 5} 此乃重点知识！！！
#总的分类： # #1、形参：在函数定义阶段括号内定义的参数，称之为形式参数，简称形参，本质就是变量名 # def foo(x,y): #x=1,y=2 # print(x) # print(y) # #2、实参：在函数调用阶段括号内传入的值，称之为实际参数，简称实参，本质就是变量的值 # foo(1,2) # #详细的分类： #一、位置参数： #位置形参：在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参 #特点：但凡是按照位置定义的形参，都必须被传值，多一个不行，少一个也不行 # def foo(x,y): # print('x:',x) # print('y:',y) #位置实参：在函数调用阶段，按照从左到右的顺序依次定义的实参，称之为位置实参 #特点：按照位置为对应的形参依次传值 # foo(1,2) # foo(2,1) #二、关键字实参:在调用函数时，按照key=value的形式为指定的参数传值，称为关键字实参 #特点：可以打破位置的限制，但仍能为指定的形参赋值 # foo(y=2,x=1) #注意： #1、可以混用位置实参与关键字实参，但位置实参必须放在关键字实参的前面 # foo(1,y=2) # foo(y=2,1) #SyntaxError: positional argument follows keyword argument #2、可以混用，但不能对一个形参重复赋值 # foo(1,y=2,x=10) #三：默认参数：在函数定义阶段，就已经为形参赋值，该形参称为默认形参 #特点：在定义阶段就已经被赋值，意味着在调用可以不用为其赋值 # def foo(x,y=10): # print('x:',x) # print('y:',y) # foo(1) # foo(1,3) # 注意： #1、位置形参必须放到默认形参的前面，否则报语法错误 # def foo(x=1,y): # pass #2、默认参数的值只在定义阶段赋值一次，即默认参数的值在函数定义阶段就已经固定死了 # m=10 # def foo(x=m,y=11): # print(x) # print(y) # m=1111111111111111111111111111111111111111111111111111111111 # foo() #3、默认参数的值通常应该定义不可变类型 # def register(name,hobby,hobbies=[]): # hobbies.append(hobby) # print('%s的爱好' %name,end=':') # print(hobbies) # # register('egon','play') # register('alex','piao') # register('lxx','烫头') # def register(name,hobby,hobbies=None): # if hobbies is None: # hobbies=[] # hobbies.append(hobby) # print('%s的爱好' %name,end=':') # print(hobbies) # # register('egon','play') # register('alex','piao') # register('lxx','烫头') #总结： #实参的应用：取决于个人习惯， #形参的应用： #1、位置形参：大多数情况下的调用值都不一样，就应该将该参数定义成位置形参 #2、默认形参：大多数情况下的调用值都一样，就应该将该参数定义成默认形参 # def register(name,age,sex='male'): # print(name) # print(age) # print(sex) # # # register('egon',18,) # register('大脑门',73,'female') # register('小脑门',84,) # register('大高个',18,) #四：可变长参数：指的是在调用函数时，传入的参数个数可以不固定 #而调用函数时，传值的方式无非两种，一种位置实参，另一种时关键字实参 #所以对应着，形参也必须有两种解决方案，来分别接收溢出的位置实参(*)与关键字实参(**) #1、形参中某个参数带* #形参中的*会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给*后的变量名 # def foo(x,y,*z): #x=1,y=2,z=(3,4,5,6,7) # print(x) # print(y) # print(z) # foo(1,2,3,4,5,6,7) # 应用 # def my_sum(*nums): # res=0 # for num in nums: # res+=num # return res # # print(my_sum(1,2,3,4,5)) # 2、实参中的参数也可以带* # 实参中带*，*会将该参数的值循环取出，打散成位置实参 #ps：以后但凡碰到实参中带*的，它就是位置实参，应该立马打散成位置实参去看 # def foo(x,y,z): # print(x,y,z) # foo(1,*[2,3]) #foo(1,2,3) # foo(1,*'he') #foo(1,'h','e') # foo(1,*(2,3,4)) #foo(1,2,3,4) # def foo(x,y,z,*args): # print(x) # print(y) # print(z) # print(args) # # foo(1,2,3,4,5,6,7,*[8,9,10,11]) #foo(1,2,3,4,5,6,7,8,9,10,11) #注意：约定俗成形参中的*变量名的写法都是：*args #1、形参中某个参数带** #形参中的**会将溢出的关键字实参全部接收，然后存储字典的形式，然后把字典赋值给**后的变量名 # def foo(x,y,**z): #x=1,y=2,z={'c':5,'b':4,'a':3} # print(x) # print(y) # print(z) # foo(1,2,a=3,b=4,c=5) # 2、实参中的参数也可以带**,该参数必须是字典 # 实参中带**，**会将该参数的值循环取出，打散成关键字实参 #ps：以后但凡碰到实参中带**的，它就是关键字实参，应该立马打散成关键字实参去看 # def foo(x,y,z): # print(x) # print(y) # print(z) # foo(1,2,**{'a':1,'b':2,'c':3,'z':3}) #foo(1,2,c=3,b=2,a=1,z=3) # foo(**{'z':3,'x':1,'y':2}) #foo(y=2,x=1,z=3) #注意：约定俗成形参中的**变量名的写法都是：**kwargs # def index(name,age,sex): # print('welecome %s:%s:%s to index page' %(name,age,sex)) # # def wrapper(*args,**kwargs): #args=(1,),kwargs={'x': 1, 'y': 2, 'z': 3} # index(*args,**kwargs) #index(*(1,),**{'x': 1, 'y': 2, 'z': 3}) #index(1,x=1,y=2,z=3) # # wrapper(name='egon',sex='male',age=18) # # 五 命名关键字形参:在函数定义阶段，*后面的参数都是命名关键字参数(**) # 特点：在传值时，必须按照key=value的传，并且key必须命名关键字参数指定的参数名 # def register(x,y,z,**kwargs): #kwargs={'b':18,'a':'egon'} # if 'name' not in kwargs or 'age' not in kwargs: # print('用户名与年龄必须使用关键字的形式传值') # return # print(kwargs['name']) # print(kwargs['age']) # register(1,2,3,a='egon',b=18) # def register(x,y,z,*args,name='egon',age): # print(args) # print(name) # print(age) # register(1,2,3,4,5,6,7,age=18) # def foo(x,y=1,*args,z=1,a,b,**kwargs): # pass # foo(1,*[1,2,3],a=1,**{'x':1,'y':2}) #foo(1,1,2,3,a=1,y=2,x=1) # foo(1,2) # foo(x=1,y=2) # open('a.txt','w',encoding='utf-8')
# 五 命名关键字形参:在函数定义阶段，*后面的参数都是命名关键字参数(**) # 特点：在传值时，必须按照key=value的传，并且key必须命名关键字参数指定的参数名 def register(x,y,z,**kwargs): #kwargs={'b':18,'a':'egon'} if 'name' not in kwargs or 'age' not in kwargs: print('用户名与年龄必须使用关键字的形式传值') return print(kwargs['name']) print(kwargs['age']) register(1,2,3,a='egon',b=18) def register(x,y,z,*args,name='egon',age): print(args) print(name) print(age) register(1,2,3,4,5,6,7,age=18) def foo(x,y=1,*args,z=1,a,b,**kwargs): pass foo(1,*[1,2,3],a=1,**{'x':1,'y':2}) #foo(1,1,2,3,a=1,y=2,x=1)
4.动态参数
按位置传值多余的参数都由*args统一接收，保存成一个元组的形式
按关键字传值接受多个关键字参数，由**kwargs接收，保存成一个字典的形式
def 函数名(参数1,参数2,默认参数,*args,命名关键字参数,**kwargs):
#def foo(1,2,x=1,*args,name='han',**kwargs):
"""注释：函数功能和参数说明""" 函数体 …… return 返回值
