一、理解函数
1.为什么要用函数
#1.程序的组织结构不清晰，可读性差 #2.代码冗余 #3.程序的可扩展性极差
2.什么是函数
#1.具备某一功能的工具就是程序中的函数 #2.事先准备工具的过程称之为函数的定义 #3.遇到应用场景“拿来就用”就是函数的调用 ##综上所述，在程序中，函数的使用必须遵循：先定义，在调用
3.怎么用函数
name_from_db='egon' pwd_from_db='123' def auth(): name=input('用户名>>: ').strip() pwd=input('密码>>: ').strip() if name == name_from_db and pwd == pwd_from_db: print('login successfull') else: print('user or pwd error') auth()
二、函数的定义
# def 函数名(参数1,参数2,...): # """ # 函数的文档注释 # :param 参数1: 参数1的作用 # :param 参数2: 参数1的作用 # :return: 返回值的描述 # """ # 代码1 # 代码2 # 代码3 # .... # return 返回值
2.1 语法：在函数定义阶段只检测语法，不执行代码
# def foo(): # if #错误语法
2.2 先定义后调用
#定义阶段 def bar(): print('from bar') def foo(): print('from foo') bar() #调用阶段 foo()
2.3 定义函数的三种形式
#1.无参函数 def foo(): print ('from foo') foo() #使用场景： #需求：用户在选择界面选择不同ATM的功能，进入对应的函数（简单实现） def repay(): print ('我是支付功能') def check(): print ('我是查询功能') def transfer(): print ('我是转账功能') def run(): for i in func_dic: print (i ,func_dic[i][0]) choice=input('>>>:').strip() func_dic[int(choice)][1]() #执行对应的功能函数 func_dic={ 1:['支付',repay], 2:['查询',check], 3:['转账',transfer], } if __name__ =="__main__": run()
#2.有参函数 def bar(x,y): print (x,y) bar(1,2) #举例 #需求：比较俩个数大小 def max2(x,y): if x >y: print (x) else: print (y) max2(20,30)
#3.空函数 def foo(x,y): pass #使用场景：当写项目时，有了整体框架，但是还没细写功能，可先定义空函数
三、函数的调用
三种调用方式：
3.1语句形式
def foo(): print ('from foo') foo() #语句形式
3.2表达式形式
def max2(x,y): if x>y: return x else: return y salary= max2(3000,2000) #表达式形式 annual_salary = salary * 12 print (annual_salary)
3.3返回值当做参数传给另一个函数
#找出一个1,2,3最大的值 def max2(x,y): if x>y: return x else: return y res= max2(max2(3,2),1) #函数返回值当参数传递 print (res)
四、函数的返回值return
4.1特点：
return 是函数结束的标志，函数内可以有多个return，但是只要执行一个，函数就立即结束，并且把return后的值当做本次调用的结果
def foo(): print ('first') return 1 print ('second') #以下语句都不会被执行 return 2 print ('third') return 3 res = foo() print (res)
4.2 返回值注意事项：
#1.返回值没有类型限制 def bar(): return {'x',1} #可以为任意类型，如字符串，字典，函数，列表等等 print (bar()) #2. 返回值没有个数限制，可以用逗号分开多个值，一次返回 def bar(): return (1,'hello',{'x':1}) #以元组tuple形式返回 x,y,z = bar() print (x,y,z)
#3.可以没有return,默认返回None def bar(): pass res = bar() #无返回值，返回None print (res)
五、函数的参数
5.1 函数的参数分为两大类：形参和实参
#形参：指的是在定义函数时括号定义的参数，形参即变量名 def foo(x,y): #x=1,y=2 print (x,y) #实参：指的是在调用函数时括号内传入的值，实参即变量值 foo(1,2) #在调用时，实参的值会传给形参，可以理解为这是一个赋值操作
5.2 函数参数
5.2.1位置参数
#1.在定义函数时，按照从左到右的顺序依次定义的参数，称为位置形参 #特性：位置形参必须被传值，多一个不行少一个也不行 def foo(x,y,z): print (x,y,z) #2.在调用函数时，按照从左到右的顺序依次传入的值，称为位置实参 #特点：与形参一一对应 foo(1,2,3) foo(1,2) #报错 foo(1,2,3,4) #报错
5.2.2关键字实参
#1.在调用函数时，按照key=value的形式定义的实参，称为关键字参数 #特点：可以完全打乱顺序，但仍然能指名道姓为指定的参数传值 def foo(x,y,z): print (x,y,z) foo(z=3,x=1,y=2,) #2.位置实参与关键字实参可以混合使用，规则 ##2.1位置参数一定放在关键字参数的前面 ##2.2同一个形参只能被赋值一次 foo(1,2,z=3) #正常 foo(1,y=2,3) #报错，不符合2.1 foo(1,y=2,x=4) #报错,不符合2.2
5.2.3默认参数
#默认参数：在定义函数时，就已经被赋值的参数，称为默认形参 #有以下三个特征： #1.在定义阶段就已经被赋值，意味着在调用阶段就可以不用传值 def foo(x,y=10): print (x,y) foo(1) foo(1,3) foo(y=4,x=1) #2.默认参数必须跟在位置形参的后面 def foo(y=1,x): #定义函数阶段就会报错 pass #3*.默认参数的值只在定义阶段被赋值一次就固定死了，定义之后改变没有影响 m=10 def func(x,y=m): #定义阶段10赋值为y print (y) m=111 func(1) #4*.默认参数的值应该设置成不可变类型 #举例：如果想要将每个人的爱好存到各自的列表中，就不能将默认参数l设置成列表 #错误做法：不会报错，需求达不到预期 def func(name,hobby,l=[]): #['read','play'] l.append(hobby) print (name.l) func('lisl','read') func('zhangsan','play') func('lixi','eat') #正确做法 def func(name,hobby,l=None): if l is None: l=[] l.append(hobby) print(name,l) func('lisl','read') func('zhangsan','play') func('lixi','eat') #位置形参与默认参数的应用： ##1 大多数场景值都固定不变则需要定义成默认参数 ##2 大多数场景值需要改变则需要定义成位置形参 #eg1: def register(name,password,gender='male'): print(name) print(password) print(gender) register('lisl','123',) register('xiaohong','123','female')
5.2.4 可变长参数
#指的是在调用函数时，传入的实参个数可以不固定 #而实参无非两种形式：1 位置实参 2.关键字实参 #所以对应的形参也必须对应俩种解决方案，专门用于接收溢出位置实参和溢出的关键字实参 #*：接收溢出的位置实参，存在元组形式，然后赋值给*后面跟的那个变量名 ##用法1：在形参中用* def foo(x,y,*z): #z=(3,4,5) print (x,y) print (z) foo(1,2,3,4,5) foo(1,2,3,4,5,y=20) #报错，2已经传给y,y=20重复赋值报错 ##用法2：在实参中用* def foo(x,y,*z): print (x,y) print (z) foo (1,2,*(3,4,5)) #foo(1,2,3,4,5) 实参*是拆分元组元素 foo(1,2,*'abc') #foo(1,2,'a','b','c') #**：接收溢出关键字实参，存在字典形式，然后赋值给**后面跟的那个变量名 ##用法1：在形参中用** def foo(x,y,**z): #z={'b': 3, 'c': 4, 'a': 2} print (x,y) print (z) foo(1,a=2,b=3,c=4,y=5) ##用法2：在实参中用** def foo(x,y,**z): print (x,y) print (z) foo(1,**{'a':2,'c':3}) #foo(1,a=2,c=3) 实参**是拆分字典的key=value为关键字参数
六、函数嵌套
#1.函数的嵌套调用 def max2(x,y): if x >y: return x else: return y def max4(x,y,m,n): res1=max2(x,y) res2=max2(res1,m) res3 =max2(res2,n) return res3 print (max4(1,2,3,4)) #2.函数的嵌套定义 def f1(): print ('from f1') def f2(): print ('from f2') def f3(): print ('from f3') f3() f2() f1()
七、名称空间与作用域
7.1什么是名称空间
#存放名字与值绑定关系(内存地址)的地方
7.2名称空间的分类
#1.内置名称空间 存放python解释器自带名字，比如内置的函数名:len，max,sum 创建：随着python解释器启动而创建 销毁：随着python解释器关闭而销毁 #2.全局名称空间 存放文件级别的名字，比如x,f1,z x=1 def f1(): #定义阶段f1也属于全局名称空间 y=w 创建：文件开始执行时则立即创建 销毁：文件开始执行完毕时销毁 #3.局部名称空间 存放函数内的名字，强调函数的参数也属于局部的 创建：函数执行时才临时创建 销毁：函数执行完毕则立即销毁 def f1(): x=1 #局部名称空间 y=2 f1()
7.3名称空间的加载顺序
内置名称空间---》全局名称空间---》局部名称空间
注意：加载的目的是为了把名字存起来，然而存起来的目的就是为了取，
那么但凡查找一个名字一定会从三种名称空间之一找到
7.4名称空间的查找名字顺序
局部名称空间---》全局名称空间---》内置名称空间 len =10 def f1(): len =100 def f2(): len =100 def f3(): len=10000 print (len) f3() f2() f1() #结果10000
7.5 特性：名字的查找关系是在函数定义阶段就已经固定死的，与调用位置无关
x =100 def f1(): print (x) def f2(): x=1111 f1() f2() #结果为100
7.6 作用域：域=范围
#1.全局范围：内置名称空间中的名字，全局名称空间的名字 #特点：全局有效，全局存活 #2.局部范围：局部名称空间中的名字 #特点：局部有效，临时存活 #定义在全局作用域的名字称为全局变量 #定义在局部作用域的名字称为局部变量 len=10 #全局变量 def f2(): print (len) #局部变量 def f3(): print (len) #局部变量 f3() ############################## x=10 print (globals()) #查看全局作用域中的名字,结果包含'x':10 print (locals() is globals()) #结果：True,在全局作用域的局部变量就是全局变量 def f1(): y = 2 z = 3 print (locals()) #结果{'z': 3, 'y': 2},为函数内的局部变量 f1()
7.7 global与nonlocal 关键字
#一般情况下函数里的局部变量是无法影响到全局变量的，除非全局变量是可变类型，如：列表，字典，集合 #例1： s='hello' #不可变类型有数字，字符串，元组 def foo(): s='hello world' foo() print (s) #结果‘hello’ #例2： l=[] #空列表 def foo(): l.append('aa') foo() print (l) #结果['aa'] #global #特殊情况下，需要将局部变量定义成全局变量(不建议) x=10 def foo(): global x x=100 foo() print (x) #结果100 #nonlocal #定义：会从当前外一层开始查找一直找到最外层的函数，如果没有就报错 def f1(): x=10 def f2(): def f3(): nonlocal x x=11 f3() f2() print (x) #结果11 f1() #print (x) #报错，因为x变量全局没有定义
八、函数对象
8.1 函数对象定义：
#函数可以当做变量去处理
8.2函数对象的用法：
#1.可以被赋值 def foo() print ('from foo') f=foo print (f) #打印的是函数的内存地址 #2.可以当做参数传给一个函数 def foo(): print ('from foo') def bar(func): print (func) #打印函数地址 func() #执行函数 bar(foo) #3.可以当做函数的返回值 def foo(): print ('from foo') def bar(func): return func f=bar(foo) #返回函数foo的内存地址赋值给f print (f) #4.可以当做容器类型的元素 def foo(): print ('from foo') l=[foo,] print (l) l[0]() #执行foo函数 #需求1：打造用户选择界面 def get(): print ('使用下载功能') def put(): print ('使用上传功能') def ls(): print ('显示当前列表') def login(): pirnt ('用户登录') func_dic={ "1":[get,'下载'], "2":[put,'上传'], "3":[ls,'浏览'], "4":[login,'登录'], } for i,k in func_dic.items(): print (int(i),' ',k[1]) choice=input('>>:') if choice =='q':break if choice in func_dic: func_dic[choice][0]()
九、闭包函数
闭包函数就是：函数嵌套+名称空间与作用域+函数对象
9.1 什么是闭包函数
#1.定义在函数的内函数 #2.该函数体代码包含对该函数外层作用域中名字的引用 强调：函数外层指的不是全局作用域 #满足上述两个条件，那么该内部函数就称之为闭包函数 #例子： def outter(): x=1 def inner(): print (x) return inner #利用函数对象的概念，将一个内部函数返回并在全局中拿到使用，从而打破函数的层级限制 f=outter() #f=inner print (f) f()
9.2 为函数体传值的方式
#方式一：以参数的形式为函数体传值 import requests #pip3 install requests def get(url): response=requests.get(url) if response.status_code ==200: print (response.text) get('https://www.python.org') #每次都需要将url传进函数 get('https://www.python.org') #方式二:包给函数,（方便，推荐） def outter(url): def get(): response=requests.get(url) if response.status_code ==200: print (response.text) return get python = outter('https://www.python.org') #相同网站只需一次传值 python() python()
十、装饰器
10.1 开放封闭原则
#软件一旦上之后就应该开放封闭原则 #具体是指修改是封闭的，但对扩展是开放的
10.2 什么是装饰器
#装饰就是修饰，器指的就是工具 #装饰器本身可以是任意可调用的对象 #被装饰的对象也可以是任意可调用的对象 装饰器----》函数 被装饰的对象----》函数 #装饰器是用来为被装饰对象添加新功能的一种工具 #必须遵循： 1.不能修改被装饰对象的源代码 2.不能修改被装饰对象的调用方式
10.3 举例
import time def index(): time.sleep(1) print ('welcome to index') def outter(func): def wrapper(): start_time = time.time() func() stop_time = time.time() print ('run time is %s'%(stop_time-start_time)) return wrapper index = outter(index) #index=wrapper index()
import time def index(): time.sleep(1) print ('welcome to index') return '我是返回值' #定义有返回值 def outter(func): def wrapper(): start_time=time.time() res = func() stop_time = time.time() print ('run time is %s'%(stop_time-start_time)) return res #定义有返回值 return wrapper index=outter(index) #index=wrapper res=index() #res=wrapper() print ('返回值：',res)
def home(name): time.sleep(1) print ('welcome %s to home page'%name) def outter(func): def wrapper(*args,**kwargs): start_time = time.time() res = func(*args,**kwargs) stop_time=time.time() print ('run time is %s'%(stop_time-start_time)) return res return wrapper home=outter(home) #home=wrapper home('lisl') #wrapper('lisl')
10.4装饰器语法糖
#在被装饰器对象正上方单独一行写@装饰器的名字 def timmer(func): def wrapper(*args,**kwargs): start_time = time.time() res=func(*args,**kwargs) stop_time = time.time() print ('run time is %s'%(stop_time-start_time)) return res return wrapper @timmer def index(): time.sleep(1) print ('welcome to index') return 1234 @timmer def home(name): time.sleep(2) print ('welcome %s to home page'%name) index() home('lisl')
#例子：检测用户是否登录，没有要求登录在使用功能 import time current_user = {'login':False} def outter(func): def wrapper(*args,**kwargs): if current_user['login']: return func(*args,**kwargs) user=input('username>>>:').strip() pwd = input('password>>>:').strip() if user =='lisl' and pwd=='123': current_user['login']=True return func(*args,**kwargs) return wrapper @outter def index(): time.sleep(1) print ('welcome to index') return 1234 @outter def home(name): time.sleep(2) print ('welcome %s to home page'%name) index() home('lisl')
10.5 有参装饰器
import time current_user={'login':False} def auth(engine): def outter(func): def wrapper(*args,**kwargs): if current_user['login']: return func(*args,**kwargs) user=input('username>>>:').strip() pwd =input('password>>>:').strip() if engine =='file': if user =='lisl' and pwd=='123': current_user['login'] =True return func(*args,**kwargs) elif engine =='mysql': print ('基于mysql认证') elif engine =='ldap': print ('基于ldap的认证方式') return wrapper return outter @auth(engine='mysql') #@outter #index=outter(index) def index(): time.sleep(1) print ('welcome to index') return 1234 @auth(engine=='ldap') def home(name): time.sleep(2) print ('welcome %s to home page'%name) index() home('lisl')