python装饰器、类可以用来装饰、元类、type()的使用、python的存储机制：小整数池、intern机制

装饰器

foo = timefun(foo)
#foo先作为参数赋值给func后,foo接收指向timefun返回的wrappedfunc
foo()
#调用foo(),即等价调用wrappedfunc()
#内部函数wrappedfunc被引用，所以外部函数的func变量(自由变量)并没有释放
#func里保存的是原foo函数对象




from time import ctime,sleep
def timefun(func):
	def wrappedfunc(a,b):
		print("%s called at %s "%(func.__name__,ctime()))
		print(a,b)
		func(a,b)
	return wrappedfunc

@timefun
def foo(a,b):
	print(a+b)

foo(3,5)

类作为装饰器

一般都是函数作为装饰器，但是类也可以作为装饰器。

class TestCal(object):
	def __call__(self):
		print("the function of cal")


t=TestCal()
t() #这里直接运行__call__方法

class TestClass(object):
	def __init__(self,func):
		print("---init----")
		print("func name is %s"%func)
		self.__func=func
	def __call__(self):#类生成的新的对象指向新的函数
		print("the function inner")
		self.__func()#类生成的新的对象指向新的函数指向新的函数

@TestClass#相当于ClassTest作为参数传到类中，创建一个对象(自动调用__init__)，返回一个实例给了ClassTest
def ClassTest():
	print("----the class test ----")
'''
---init----
func name is <function ClassTest at 0x0000000000ACD1E0>
'''
#对象是不可以直接被调用的，若有个__call__()方法就可以直接被调用	

ClassTest()
'''
the function inner
----the class test ----
'''

元类

type()的使用

#类也是一个对象
print(type(100))#<class 'int'>  属于int类型
t1=TestCal()
print(type(t1))#<class '__main__.TestCal'> 属于当前函数中的类TestCal()

#type()的功能：可以得到对象的类型 2 可以动态的创建一个类
#不建议动态的创建类，一般自己定义好类就可以
class TypeClass():
	nums=0
tC1=TypeClass()

#元类，创建类的一种方法
#利用type()同样可以
#type("类名"，(父类的元组)，{"属性"：值，”方法名：已定义好的方法名})
def addFuncType(self):
	print("the num of type func is %s"%self.num)
tC2=type("TypeClass2",(),{"num":0,"FuncType":addFuncType})
t2=tC2()#创建一个实例
t2.num
t2.FuncType()#添加一个方法:the num of type func is 0


#type也可以创建继承父类的子类
class Animal:
	def eat(self):
		print("----can eat---")

class Dog(Animal):
	pass
Cat=type("Cat",(Animal,),{})
dog=Dog()
cat=Cat()
dog.eat()#----can eat---
cat.eat()#----can eat---

#函数type是一个元类，元类就是用来创建类对象的，元类就是类的类，元类创建了python的所有的类
#str是用来创建字符串对象的类，int是用来创建整数对象的类
print(dog.__class__)#显示对象所属的类型 <class '__main__.Dog'>
print(Animal.__class__)#<class 'type'>

#__metaclass__=upper_attr  这里的__metaclass__是规定元类创建的类的形式

python的存储机制：小整数池、大整数对象池、intern机制

#小整数对象池
a=100
b=100
c=100
id(a) 
id(b)
id(c)#会发现a,b,c 的id()是一样的，不可变的值python中只定义一次
#python对小整数的定义是[-5,257）这些整数对象是提前建立好的，不会被垃圾回收
#所有位于这个范围内的整数使用的都是同一个对象
#python早已经创建好了，在使用的时候添加引用
aa=1000
bb=1000 #aa,bb的id是不一样的

#单个字母也是定义好的
#但是当定义2个字母相同的字符串时，引用计数为0，触发垃圾回收。
#
##大整数对象池
#每一个大整数，均创建一个新的对象
#


#intern机制
# 单个单词，不可修改，默认开启intern机制，共用对象，引用计数为0，则销毁
# 单词中有空格，则会创建新的对象
#