闭包:特殊语法
def fun01():
pass
print(func01) # 结果是个对象
开一片空间存放函数func01():xxx,func01执行在这片空间
函数名存放的是函数所在空间的地址
函数名是去这个空间执行里面的代码,()开辟新空间,创造新对象,万物皆对象
func02 = func01
func02() # 执行func01所在的空间
def func01():
pass
def test(func):
func()
test(func01)
func01被执行
类:提高代码服用率
闭包:节省系统资源
给实例对象加个(),自动调用call方法
"""美元兑人民币"""
class Count(object):
def __init__(self,rate):
self.rate = rate
def __call__(self,money):
print(self.rate * money)
usa_money = Count(0.7)
usa_money(100)
闭包要领:
1、必须发生函数嵌套
2、外层函数返回值必须是内层函数的函数名(地址/引用)
3、外层函数有参数(内层甘函数会用到)
def 外层函数(func):
def 内层函数():
func()
return 内层函数 # 不加(),加()表示返回结果
格式:
def func_out(func):
def func_in():
func()
return func_in
在写遍刚刚的汇率
def func_out(rate):
def func_in(money): # 假设下面代码的内存是0x11,func_in指向0x11
print(rate * money)
return func_in # 返回指向0x11
usa_money = func_out(0.7)
# func_out()执行结果返回一个0x11,usa_money接收这个指向0x11结果,也就是说usa_money和func_in都指向了0x11,里面装的都是print()函数(或者说对象print所指向的空间,万物皆对象嘛,print也是个对象)
usa_money(100)
usa_money(200)
再来一个例子
def func_out(func):
a = 200
print(a)
def func_in():
nonlocal a # 生命外层函数变量
print(func) # 使用外层变量
print(a)
a = 500
return func_in
test = func_out(100) # 这里有(),就已经实例化个对象出来了,func_out()被执行得到返回值对象,test指向这个对象,也就是test和func_in都指向func_in所指向的空间
test() # func_in()又实例化一个对象出来了,也就是func_in被执行了,没有变量接收它,也没有返回值,执行完空间就被释放了
nonlocal:声明外层函数变量(吃饱了撑的啊,谁没事用它啊)
内层函数能调用到外层函数变量
装饰器:
开放原则,函数里面已经实现的功能不允许修改,但可以实现扩展功能
装饰器:不改变函数原有代码的前提下,给函数添加新的功能
例:写了个函数实现登录功能,现在要在登录前加个验证,不改变函数
def func_out(func):
def func_in():
print("验证")
func()
return func_in
@func_out # @了一个返回值,下面跟个函数,这就是装饰器
def login():
print("登录")
login()
有装饰器,装饰器下面正好是一个函数
然后执行login = func_out(login) 重点
思考@,包括类里面静态方法@staicmethod的@
**@函数2** **函数1** **走到@会执行一句话:** **函数1 = 函数2(函数1)**装饰后的函数login ==> 闭包的内层函数
装饰有返回值的函数:
def func_out(func):
def func_in():
return func() # 这里加个return,搞定
return func_in
@func_out
def login():
return 100
f = login()
print(f)
装饰有参数的函数:
def func_out(func):
def func_in(a):
func(a)
return func_in
@func_out()
def login(a):
print(a)
login(a)
*通用版本,a换成*args,*args
Alt + 鼠标选中修改你想改的地方,批量修改
万物皆对象:
类:抽象的东西,比如人类、动物类、植物类
实例化对象:也就是创建了个对象,实际存在的东西,然后这个属于哪个类。例如你属于人类,旺财属于狗类。从人类中实例化个对象叫你,从狗类中实例化了个对象叫旺财。
对象.class:查看对象是从哪个类中被实例化的
对象:实际的东西,开辟了块内存,也就创建了个对象
怎么创建对象:也就是实例化对象,遇到(),应该就开辟了空间,实例化了对象。开辟空间后要是前面没有标识(没有变量接收,@怎么算?我不知道),应该是内存空间里代码跑完了资源就被释放了,二进制数据就被擦除了,对象就被销毁了
类和对象:类也是个对象,叫类对象。它是从其它类中被实例化出来的。例如从动物类中实例化出来个狗类。最顶层的是type,叫元类,自己创造自己
**怎么从类中实例化对象:要是类中有__new__(cls,*args,**args) (这是个类方法),用普通的 new_obj = CLS(object) (object是CLS的父类,二者都是从type元类中被实例化的,注意父类和__class__不要搞懵逼了),就ok了;要是类中没有__new__(cls,args,*args)这个类方法(例如function类、type类),用定义函数def、class这样来实例化的。反正遇到()就开辟内存空间就创建对象就对了
. 的含义:一个对象具有的属性、方法等等,我也不知道除了属性和方法外还有没有其它的东西
* :代表这个对象所有的属性、方法等等
() :说过了,开内存,创建对象
@ :装饰器,这个我觉得是最难的,一直想不通。@了个对象,对象有return,没(),但是它跑了,肯定开辟空间了,所以我前面想的不对。目前已知的就是 @类对象实际就是 @它实例化对象的返回值,而且类对象被实例化了(被执行了,开辟新空间了,没有() ),然后下面必须有 def 或 class出来,内存指向发生变化。
foo.py:py文件,或者叫模块,也可以把它当成个对象,怎么被实例化的呢,我想想,应该是用 import 把它实例化的吧。
import foo
print(foo.__class__)
return:返回了一个对象,跟继承、=类似,都是对内存地址进行某种操作吧
return、yield:是不是某个对象的方法呢?思考中
yield:跟return类似。
in :对象地址在另一个对象地址里面?
is、==、id()==id():pass,懒得写
import、def、class:这三个肯定是实例化对象用到的,我觉得这三个都有点添加的意思。import是添加个模块(文件)作为对象的属性、方法… ;def是给对象添加个函数(方法),因为你用import把你的文件变成别的对象的时候,它就能用你def的对象了。class和def一样,添加了个类。
with、as:我也不知道啊,没想通呢,只知道with的对象有个上下文关联的方法,__enter__和什么来着,记不清了
我觉得我应该从万物皆对象的角度在研究下python关键字,大家等我