二十六. Python基础(26)--类的内置特殊属性和方法
● 知识框架
|
|
● 类的内置方法/魔法方法案例1: 单例设计模式
|
# 类的魔法方法 # 案例1: 单例设计模式 class Teacher: #创建一个老师类 __isinstance = None #创建一个私有静态变量, 准备用来指向一个裸着的对象 def __new__(cls, *args, **kwargs): #创建一个裸着的对象 if not cls.__isinstance: #如果__isinstance属性为None cls.__isinstance = object.__new__(cls) #用object.__new__创建一个裸着的对象 return cls.__isinstance #返回一个对象
def __init__(self,name,cloth): #self就是cls.__isinstance返回的对象 self.name = name #给self的name属性赋值 self.cloth = cloth #给self的cloth属性赋值
p1 = Teacher('Arroz','white') print(p1.name) p2 = Teacher('Paul','black') p3 = Teacher('Paul','black') print(p1.name) print(p2) print(p3)
|
● 类的内置方法/魔法方法案例2: 综合案例
|
# 案例2: 综合案例 class Person: # __init__是在类实例创建之后调用,而 __new__方法正是创建这个类实例的静态方法 def __new__(cls, *args, **kwargs): # __new__()方法的第一个参数必须是当前类cls(也可以用其它名字,但习惯写成cls),后续参数则可以自由指定 print('__new__') return object.__new__(cls) # object可以用其它新式类代替, 但不要写本类(如这里的Person) # 我们可以自由选择任意一个的其他的新式类（必定要是新式类，只有新式类必定都有new()，因为所有新式类都是object的后代，而经典类则没有new() 方法）的new()方法来制造实例，包括这个新式类的所有前代类和后代类，只要它们不会造成递归死循环。 # __new__()用来创建实例, 在返回的实例上执行__init__()方法. 当__new__()的参数是当前类时(可以写成__new__(cls), 或者__new__(Person)), __init__()方法才会自动执行, 否则, 如果参数是其它类, __init__()不执行 #还可以写成: return super().__new__(cls)或return super(Person, cls).__new__(cls) # __new()__是生产部经理，它以决定是否将原料提供给该生产部工人，即init()
def __init__(self,name,age,sex): # 构造方法, __init__()方法的第一个参数必须是当前类的对象self(也可以用其它名字,但习惯写成self),后续参数则可以自由指定 self.name=name self.age=age self.sex=sex
def __hash__(self): return hash(self.name+self.sex) # 将self.name和self.sex两个字符串结合, 作为hash()的实参
def __eq__(self, other): if self.name==other.name and self.sex==other.sex:return True
def __str__(self): # 定义当被str()调用时的行为, 定以后, print(对象)相当于 对象.__str__() return self.name+", "+self.sex
def __repr__(self): return repr(self.name+", "+self.sex)
def __call__(self,x,y): return x*y
def __len__(self): return len(self.__dict__)
def __getitem__(self, item): print(self.__dict__[item])
def __setitem__(self, key, value): self.__dict__[key]=value
def __delitem__(self, key): print('del obj[key]时,我执行') self.__dict__.pop(key)
def __delattr__(self, item): print('del obj.key时,我执行') self.__dict__.pop(item)
def __del__(self): print('__del__')
p1=Person('Arroz',20,'Male') p2=Person('Arroz',30,'Male') p3=Person('Arroz',40,'Male') p4=Person('Arroz',50,'Female') p_lst=[p1,p2,p3,p4] # 三个对象的地址不同, 但值相同 print(set(p_lst)) print('-------------------') print(p1) print(str(p1)) print(repr(p1)) print('-------------------') print(p1(3,7)) print('-------------------') print(len(p1)) print('-------------------') print('before:', p4.__dict__) p4['age']=60 #与魔法方法__setitem__()相关 p4['hobby']='swimming' print('after1:', p4.__dict__) del p4.hobby del p4['age'] p4['name']='Alex' print('after2:', p4.__dict__) print('-------------------')
# 反射：通过字符串操作对象的相关属性 print(hasattr(p4,'name')) print(getattr(p4,'name')) setattr(p4,'Nationality','China') delattr(p4,'name') print(p4.__dict__)
''' 如果没有定义__str__()和__repr__(), 那么打印结果是各对象的地址, 例如: {<__main__.Person object at 0x000000000265B9E8>, <__main__.Person object at 0x000000000265B940>} ''' |
|
__new__ __new__ __new__ __new__ {'Arroz, Female', 'Arroz, Male'} ------------------- Arroz, Male Arroz, Male 'Arroz, Male' ------------------- 21 ------------------- 3 ------------------- before: {'name': 'Arroz', 'age': 50, 'sex': 'Female'} after1: {'name': 'Arroz', 'age': 60, 'sex': 'Female', 'hobby': 'swimming'} del obj.key时,我执行 del obj[key]时,我执行 after2: {'name': 'Alex', 'sex': 'Female'} ------------------- True Alex del obj.key时,我执行 {'sex': 'Female', 'Nationality': 'China'} __del__ __del__ __del__ __del__ |
● 类的内置方法/魔法方法案例3: 斐波那契数列数列
|
# 案例3: 斐波那契数列 # 一个实现了__iter__()和__next__()方法的类可以作为迭代器使用。 # __next__方法：返回迭代器的下一个元素(py2中是next()) # __iter__方法：返回迭代器对象本身
class Fib(object): def __init__(self): self.a, self.b = 0, 1 # 初始化两个计数器a，b
def __iter__(self): return self # 实例本身就是迭代对象，故返回自己
def __next__(self): # py2中是next() self.a, self.b = self.b, self.a + self.b # 计算下一个值 if self.a > 10: # 退出循环的条件 raise StopIteration(); return self.a # 返回下一个值
# Fib()是一个生成器 print([i for i in Fib()]) # [1, 1, 2, 3, 5, 8] print(list(Fib())) # [1, 1, 2, 3, 5, 8] |
● 元类
|
|
● 元类案例
|
print('1. Metaclass declaration')
class Meta(type): def __init__(cls, name, bases, attrd): super(Meta, cls).__init__(name, bases, attrd) print('3. Create class %r' % (name))
print('2. Class Foo declaration')
class Foo(metaclass = Meta): def __init__(self): print('*. Init class %r' % (self.__class__.__name__))
class Child(Foo): pass
print('4. Class Foo f1 instantiation') f1 = Foo()
print('5. Class Foo f2 instantiation') f2 = Foo() ''' 1. Metaclass declaration 2. Class Foo declaration 3. Create class 'Foo' 3. Create class 'Child' 4. Class Foo f1 instantiation *. Init class 'Foo' 5. Class Foo f2 instantiation *. Init class 'Foo' ''' print(type(Meta)) # <class 'type'> print(Meta.__class__) # <class 'type'> print(type(Foo)) # <class '__main__.Meta'> print(Foo.__class__) # <class '__main__.Meta'> print(type(Child)) # <class '__main__.Meta'> print(Child.__class__) # <class '__main__.Meta'> |
|
class Te(object): def __new__(cls,a,b): print('__new__', a,b) return object.__new__(cls)
def __init__(self,a,b): print("this is a test") print('__init__', a, b)
a = Te(12,23)
''' __new__ 12 23 this is a test __init__ 12 23 ''' # 不能写class Te(type), 因为type是一个meta class,不是class,所以class不能继承于type |
● 元类的声明
|
# 声明元类的方法: class Foo(object): #py2 __metaclass__ = something
class Foo(metaclass=something): #py3 |
● 类的方法的装饰器
|
# 装饰器在类中 class A(object): def outer(func): def inner(self): print("222") r = func(self) print("333") return r
return inner
@outer def f(self): print("000")
obj = A() obj.f()
print("================")
# 装饰器不在类中 def outer(func): def inner(self): print("222") r = func(self) print("333") return r
return inner
class S(object): @outer def f(self): print("000")
a = S() a.f() |
|
222 000 333 ================ 222 000 333 |