面向对象的封装,多态,单例模式
1.特殊方法
2.设计模式:单例模式
isinstance()判断这个对象是否是本类实例化的,或者是此类的派生类实例化出来的.
例:
class A:
pass
class B(A):
pass
class C(B):
pass
class D:
pass
a = C()
print(isinstance(a,A)) # True
print(isinstance(a,B)) # True
print(isinstance(a,D)) # False
issubclass()判断一类是否是另一个类的派生类
class F:
pass
class A(F):
pass
class B(A):
pass
class C:
pass
print(issubclass(B,A)) # True
print(issubclass(C,A)) # False
print(issubclass(B,F)) # True
__len__,__hash__,__str__,__repr__
print(dir(list)
print(dir(str)
就会发现list和str里面都含有这四种方法.
li = list([1,3,2,5,6]) # li是list类实例化的一个对象
print(len(li)) #对一个对象len(),则他会执行这个对象从属于的类的__len__方法
class A:
def __init__(self,name,age):
self.name = name
self.age = age
a = A("alex",23)
print(len(a)) #会报错,因为A类没有__len__方法,且object里也没有.
class A:
def __init__(self,name,age):
self.name = name
self.age = age
def __len__(self):
return len(self.__dict__)
a = A("alex",23)
print(len(a)) #这样就不会报错!
如果对一个对象进行len()操作,他会找到对象从属于的类中的__len__方法,并且此方法中必须要有数字的返回值.
class A:
def __init__(self,name,age):
self.name = name
self.age = age
def __hash__(self):
return 100
a = A("alex",34)
print(hash(a))
如果对一个对象进行hash()操作,他会找到对象从属于的类中的__hash__方法,并且此方法中,必须要有数字的返回值.
__str__
class A:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return "3"
a = A("alex",34)
print(a) #执行__str__方法,并且打印返回值.
str(a) #执行__str__方法
"%s"%a #执行__str__方法
print("%s"%a) #执行__str__方法并打印返回值
如果执行__str__方法,必须有返回值,且返回值必须是字符串.
__repr__
class A:
def __init__(self):
pass
def __repr__(self):
return "3"
a = A()
print(a) #执行__repr__方法,并且打印返回值
repr(a) #执行__repr__方法
print("%s"%a) #执行__repr__方法,并且打印返回值
"%r"%a #执行__repr__方法.
如果执行__repr__方法,必须有返回值,且返回值必须是字符串.
__call__
class A:
def __init__(self):
pass
def __call__(self):
pass
a = A()
a() #对象() , 自动执行类中的__call__方法.
__eq__
class A:
def __init__(self):
self.a = 1
self.b = 2
def __eq__(self,obj):
if self.a == obj.a and self.a == obj.b:
return True
a = A()
b = A()
print(a==b) #对一个类实例化的两个对象进行比较运算的时候,他会自动执行__eq__方法
Python垃圾回收机制:文件中你创建的所有的变量,类等等.执行完毕之后,一段时间内如果没有用到,他会自动在内存中去除.
深入研究:他会将你的所有变量,类等等做个标记,在一段时间之内,没有被调用,则就会自动回收.
__del__方法(析构方法)
class A:
def __init__(self):
pass
def __del__(self):
print(666)
a = A()
一旦运行完毕之后就会自动清除,如果有用到的变量,类等等再从新加在一边就可以了
__new__:object产生并返回一个对象空间.
自己定义的__new__第一个参数自动接收类空间
执行顺序:先执行__new__方法,然后再执行__init__方法.
class A:
def __init__(self):
self.x = 1
print("in init function")
def __new__(cls,*args,**kwargs):
print(cls)
print("in new function")
return object.__new__(cls) #调用object类中的__new__方法,产生一个真正的对象空间,并返回给:类名()
a = A()
print(a)
类名() 自动执行类中__new__方法,类中没有,则找到object,找到__new__这个方法产生一个对象空间,自动执行类中的__init__,给这对象空间封装一些属性.最后返回给:类名(),然后再给变量
class A:
def __new__(cls,*args,**kwargs):
pass
class B(A):
def __init__(self):
self.x = 1
b = B()
pirnt(b)
print(b.x)
最详细版本:
1.类名()执行__new__方法,先从自己的类中寻找,如果没有找到,则从父类(直到object类为止)寻找,然后从object的__new__产生一个对象空间,返回给类名().
2.对象空间一旦产生并返回,则自动执行__init__方法,给这个对象空间封装属性.
3.最终将得到是封装好属性的对象空间.
设计模式:单例模式.最简单的设计模式.
单例模式:对一个类是只能实例化一个对象.
class A:
__name = None
def __new__(cls,*args,**kwargs):
if cls.__name == None:
obj = object.__new__(cls)
cls.__name = obj
return cls.__name
a = A()
b = A()
c = A()
print(a,b,c)
上面就是单例模式,要记住并会默写.
class A:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def __getitem__(self,item):
if hasattr(self,item):
return getattr(self,item)
else:
return "没有此属性"
#return getattr(self,item,"没有此属性")
def __setitem__(self,key,value):
setattr(self,key,value)
def __delitem__(self,key):
delattr(self,key)
def __delattr__(self,item):
print(item)
print("del obj.key是,我执行")
a = A("alex",34,"男")
print(a["name"])#对一个对象使用:对象名["属性名"]这种方法,自动触发__getitem__这个方法,将属性名传到这个方法中
print(a["name"]="wusir")#自动触发__setitem__这个方法.
del a["name"] #自动触发__delitem__这个方法
del a.name #自动触发__delattr__这个方法
如果对对象进行相似的字典的操作,就会主动触发类中__getitem__,__setitem__,__delitem__
