元类补充
object.__new__
class Person():
def __init__(self,name,age):
print('__init__')
self.name=name
self.age=age
def __new__(cls, *args, **kwargs):
print('__new__')
#生成一个Person类的空对象
return object.__new__(cls)
p=Person('lqz',19)
print(p)
会发现结果为:
__new**__init**
<main.Person object at 0x000002217E7099E8>
为什么先会调用__new__呢?
因为Person加括号先调用了type类里的__call__,然后__call__调用了Person类的__new__
new 和__init__
new 创建空对象
init 初始化空对象
object.__new__(Person) :生成Person类的对象 空的
type.__new__(cls,name,bases,dic) :生了cls这个类对象,里面有东西
元类中:
init:控制类的产生,在__new__之后
call:对着对象的产生
new:控制类产生最根上,其实本质最根上也不是它,是type的__call__,但是我们控制不了了
class Mymeta(type):
def __init__(self,name,bases,dic):
#self 是Person类,Person类中有名称空间之类的了
# print('xxxxxxx')
# print(args)
# print(kwargs)
# print(name)
# print(bases)
# print(dic)
pass
# self.name='xxxxxxx'
def __new__(cls, name,bases,dic):
# print(name)
# print(bases)
# print(dic)
#产生空对象(空类),在这里面生成的并不是空类,是有数据的类了
#如何完成类的初始化,并且把name,bases,dic这些东西放入
# return type.__new__(cls,name,bases,dic)
dic2={'attr':{}}
for k,v in dic.items():
#加入这一句,类名称空间中带__的就不会放到attr中
if not k.startswith('__'):
dic2['attr'][k]=v
print('-------',dic2)
return type.__new__(cls,name,bases,dic2)
class Person(metaclass=Mymeta): # Person=Mymeta(name,bases,dic) 调用type的__call__,内部调用了Mymeta.__new__,又掉Mymeta的__init__
school='音乃木板学院'
age=10
def __init__(self,name,age):
self.name=name
self.age=age
print(Person.__dict__)
print(Person.attr['school'])
# p=Person('nick',18)
单例模式
单例模式是设计模式中的一种,其中一共有23种设计模式
单例模式:整个过程中只有一个实例,所有生成的实例都指向一块内存空间
方法一:
可以通过类的绑定方法来实现:当用户输入端口和地址,实例化产生新对象,当用户不输入端口和地址,每次拿到的对象,都是同一个
# settings.py
PORT=3306
HOST='127.0.0.1'
class Sql():
_instance=None
def __init__(self,port,host):
self.port=port
self.host=host
# @classmethod
# def get_sigoleton(cls):
# import settings
# if cls._instance:
# return cls._instance
# else:
# cls._instance=cls(settings.PORT,settings.HOST)
# return cls._instance
@classmethod
def get_sigoleton(cls):
import settings
if not cls._instance:
cls._instance = cls(settings.PORT, settings.HOST)
return cls._instance
#每次调用get_sigoleton 拿到的对象都是同一个
s1=Sql.get_sigoleton()
s2=Sql.get_sigoleton()
s3=Sql.get_sigoleton()
print(s1)
print(s2)
print(s3)
s4=Sql('33306','192.168.1.1')
print(s4)
方法二:
通过装饰器
def get_sigoleton(cls):
#cls就是Sql这个类
import settings
_instance=cls(settings.PORT, settings.HOST)
# _instance=Sql(settings.PORT, settings.HOST)
def wrapper(*args,**kwargs):
if len(args)!=0 or len(kwargs)!=0:
#表示传了参数,生成新对象
res=cls(*args,**kwargs)
return res
else:
return _instance
return wrapper
# def get_sigoleton(cls):
# _instance=None
# def wrapper(*args,**kwargs):
# if len(args)!=0 or len(kwargs)!=0:
# #表示传了参数,生成新对象
# res=cls(*args,**kwargs)
# return res
# else:
# import settings
# nonlocal _instance
# if not _instance:
# _instance=cls(settings.PORT, settings.HOST)
# return _instance
# return wrapper
@get_sigoleton #会把下面的Sql当中参数传入,相当于:Sql=get_sigoleton(Sql)
class Sql():
def __init__(self,port,host):
self.port=port
self.host=host
# Sql=get_sigoleton(Sql)
s1=Sql()
s2=Sql()
s3=Sql('33306','192.168.1.1')
s4=Sql('33306','192.168.1.1')
print(s1)
print(s2)
print(s3)
方法三
通过元类
class Mymeta(type):
def __init__(self,name,bases,dic):
#self 是Sql类
import settings
#把实例化好的对象,放到了类的名称空间
self._instance=self(settings.PORT, settings.HOST)
def __call__(self, *args, **kwargs):
#self是谁?是Sql类
if len(args)!=0 or len(kwargs)!=0:
obj=object.__new__(self)
obj.__init__(*args, **kwargs)
return obj
else:
return self._instance
class Sql(metaclass=Mymeta): #相当于 Sql=Mymeta(name,bases,dic) 这个会调用 Mymeta的__init__ 在里面已经向类的名称空间放了一个对象
def __init__(self,port,host):
self.port=port
self.host=host
print(Sql.__dict__)
s1=Sql()
#调用元类的__call__
s2=Sql()
s3=Sql('33306','192.168.1.1')
print(s1)
print(s2)
print(s3)
方法四
利用模块导入(python的模块是天然的单例)
# sigonleton.py
import settings
class Sql():
def __init__(self,port,host):
self.port=port
self.host=host
s1=Sql(settings.PORT,settings.HOST)
def test():
from sigonleton import s1
print(s1.port)
print(s1)
def test2():
from sigonleton import s1 as s2
print(s2)
test()
test2()
from sigonleton import s1
from sigonleton import Sql
s2=Sql(3306,'192.168.1.1')
print(s1)
print(s2)