函数是第一类对象即可以被当做数据取使用
#1 可以被引用 #2 可以当作参数传递 #3 返回值可以是函数 #3 可以当作容器类型的元素
1、可以被引用
先看变量可以怎么玩 age=18 x=age 把age的内存地址赋值给x print(age,x) >>18 18 ****************************** 同理，变量可以这么玩 def func(): print('func run') x=func 注意：加括号代表的是函数体运行后的返回值 x() print(x) func run <function func at 0x0000021DFB1D1A60> —————————————————————————————————— def func(): print('func run') x=func() print(x) >>func run >>None 没有返回值
2、可以当做参数传给另一个函数
age=18 def old_func(): print("from func") def func(x): print(x) func(age) func(old_func) 18 <function old_func at 0x0000023AD58F1A60>
3、可以当做一个函数的返回值
age=18 def old_func(): print("from func") def func(x): return x res=func(age) print(res) res=func(old_func) print(res) 18 <function old_func at 0x000001882ACE1A60>
4、可以当做容器类型的元素
age=18 def old_func(): print("from china") l=[age,old_func,old_func()] print(l) from china [18, <function old_func at 0x000001FC9BF41A60>, None]
此功能实际运用
def login(): print('登录...') def register(): print('注册...') def shopping(): print('购物...') def pay(): print('支付...') msg=""" 0 退出 1 登录 2 注册 3 购物 4 支付 """ func_dic={ '4':pay, '3':shopping, '2':register, '1':login } while True: print(msg) choice = input('请输入您的操作：') if choice == '0': break if choice in func_dic: func_dic[choice]() else: print('输入有误')
二、函数的嵌套
1、函数的嵌套调用：在调用函数过程中，其内部代码调用了其他函数
def func(): print('from bar') def bar(): print('from func') func() bar()
2、函数的嵌套定义
默认情况下，只能内部使用，内部函数可以访问可以访问外层函数中的内容
def f1(): print('from f1') def f2(): print('from f2') def f3(): print('from f3') f3() f2() f1()
三、名称空间与作用域
1、什么是名称空间
用来存放名字与值内存地址绑定关系的地方（内存空间）
2、名称空间分三大类
内置名称空间：存放python解释器自带的名字
任何位置都能访问到
全局名称空间：存放的是文件级别的名字（顶着最左边，没有任何缩进的名称）
任何位置都能访问到
局部名称空间：在函数内定义的名字
只能在当前函数内访问到
生命周期
内置名称空间：在python解释器启动时生效，解释器关闭时失效
全局名称空间：在python解释器解释python文件时生效，文件执行完毕时失效
局部名称空间：只在调用函数时临时产生改函数的局部名称空间，该函数调用完毕则失效
加载顺序
内置->全局->局部
查找名字的顺序:
可以把名称空间想象成三层，最下边是局部，往上是全局，最上边是内置，基于当前所在位置往上查找
假设当前站在局部,查找顺序:局部->全局->内置
假设当前站在全局,查找顺序:全局->内置
x=000 def f1(): x=111 def f2(): x=222 def f3(): def f4(): # x=444 注释掉 print(x) x=333 f4() f3() f2() f1() >>333
名字的查找顺序,在函数定义阶段就已经固定死了(即在检测语法时就已经确定了名字的查找顺序),
与函数的调用位置无关,也就是说无论在任何地方调用函数,都必须回到当初定义函数的位置去确定名字的查找关系
案例二
案列二:
x=111
def outer():
def inner():
print('from inner',x) # x访问的时全局名称空间中x
return inner
f=outer()
x=222
f()
>>222
案例三
案列三:
x=111
def outer():
def inner():
print('from inner',x) # x访问的时全局名称空间中x
return inner
f=outer()
def func():
x=333
f()
x=444
func()
>>444
作用域
全局作用域：包含的是内置名称空间与全局名称空间中的名字
特点：全局有效 全局存货
局部作用域：包含的是名称空间中的名字
特点：局部有效 临时存活
global与nonlocal
global：在局部声明一个名字是来自全局作用域的，可以用来在局部修改全局的不可变类型
x=11
def func():
global x
x=22
return x
print(func())
>>22
lonlocal：声明一个名字来自于当前层外一层作用域的，可以用于在局部修改外层的不可变类型
x=11
def func():
global x
x=22
return x
print(func())
如果外一层没有，再往外一层找，直到找到外层，如果没有，就会报错
五、闭包函数
什么是闭包函数
#闭：指的是闭包函数是定义在一个函数内部的函数 #包：该内部函数包含对外层函数作用域名字的引用（内外函数中间部分） 需要结合函数对象的概念（return内部函数名），将闭包函数返回到全局作用域去使用，从而打破函数的层级限制 #特点：1.定义在另一个函数内的函数 2.内部的的函数访问了外部的名称（数据） 注意：不包含全局的
为何用闭包函数
#闭包函数提供了一种为函数体传值的解决方案
如何用闭包函数
def outter(): x=111 def inner(): print(x) return inner f=outter() #f=outter内的inner f()
#定义闭包函数，内层函数看成是定义一个变量，函数名是变量名 def outer(): a=10 return a f=outer() print(f) def outer(): def inner(): #类似a=10 pass return inner #类似return a f=outer() 执行外层函数，拿到的是内层函数的内存地址 print(f) f()
为函数传值的两种方式
def func(x,y): print(x+y) func(1,2)
def outter(x,y): # x=1 # y=2 def func(): print(x+y) return func f=outter(1,2) f()
#直接通过参数传参 def get(url): response=requests.get(url) if response.status_code == 200: print(len(response.text)) get('https://www.baidu.com') #来一次就需要输入完整的路径，较麻烦 get('https://www.baidu.com') get('https://www.baidu.com') get('https://www.tmall.com') #即使指定，这是全局作用域，任何函数都能访问到都能访问到， url1='https://www.baidu.com' url2='https://www.tmall.com' get(url1) get(url1) get(url2) get(url2) ------------------------------------------------------------------------ #通过闭包函数传参 def bar(url): def get(): response=requests.get(url) if response.status_code == 200: print(len(response.text)) return get baidu=bar('https://www.baidu.com') #指定好一个，下次直接使用，是绑定的关系 baidu() baidu() baidu() tmall=bar('https://www.tmall.com') #将该地址绑定给tmall tmall()
闭包函数之装饰器
装饰器基本简介
#装饰器就是用一个函数去扩展另一个已存在的函数的功能 #饰器其实是闭包函数的一种应用方式 #装饰器的原则： 1、不修改装饰对象的源代码 2、不修改被装饰对象的源代码 #装饰器的目标： 在遵循1和2的条件下，为被装饰对象添加新功能
装饰器的使用
无参装饰器
import time def index(): print('from index') time.sleep(3) def wrapper(func): def inner(): start=time.time() func() stop = time.time() print('run time %s' %(stop-start)) return inner #闭包函数，f=inner的内存地址 f = wrapper(index) #index = wrapper(index) 变量名可随意命名 f() #index()
有参装饰器
def index(name,age): print('my name is %s,age is %s' %(name,age)) return 1 #如果有返回值怎么拿 def outer(func): #外层函数接收的是被装饰函数名 def inner(*args,**kwargs): #内层函数接收被装饰对象需要的参数，想象执行过程 res = func(*args,**kwargs) #接收返回值并返回 return res #也就是在此处返回被装饰对象的返回值 return inner index=outer(index) data = index('pdun',1) print(data) my name is pdun,age is 1 1
语法糖
import time def outer(x): def inner(*args,**kwargs): s=time.time() res=x(*args,**kwargs) o=time.time() return res return inner @outer def func(name): time.sleep(1) print('my name is %s' %(name)) return 0 func('pdun')
62
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
