闭包、装饰器、万物皆对象(这个是自己想的，我觉得看了应该能有所启发)

本文链接：https://blog.csdn.net/weixin_42844490/article/details/82500460

闭包：特殊语法

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 ==> 闭包的内层函数

插入图jybday15-1

装饰有返回值的函数：

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 把它实例化的吧。