python(六):面型对象--类的特殊方法
一、跟实例创建和执行有关的
__new__、__init__、__call__.
类加括号调用了__init__方法来创建一个实例对象。这一过程分成了两步: 类调用__new__来创建实例对象,__new__调用__init__来初始化实例对象。
class A:
count = 0
def __init__(self):
print("__init__ has called. 2") def __new__(cls):
print("__new__ has called. 1")
return object.__new__(cls)
def __call__(cls):
print("__call__ has called. 3")
a = A()
a() """
__new__ has called. 1
__init__ has called. 2
__call__ has called. 3
"""
类的__new__()方法很少通过用户代码定义。如果定义了它,它通常是用原型__new__(cls, *args, **kwargs)编写的。其中args和kwargs与传递给__init__()的参数相同。__new__()始终是一个类方法,接受类对象作为第一个参数。尽管__new__()会创建一个实例,但它不会自动地调用__init__()。实例对象加括号会调用__call__方法,一般作为程序的入口,并且可以在这一步修改实例属性或调用实例方法。
class Obj(object):
def __init__(self, name, price):
self.name = name
self.__price = price def __say(self):
print("{}, {}.".format(self.name, self.__price)) def __call__(self, discount):
self.__price = discount * self.__price
self.__say() apple = Obj("apple", 10.0)
apple(0.8)
二、跟实例属性有关的
__getattribute__, __getattr__, __setattr__, __delattr__、__getitem__、__setitem__、__delitem__、__missing__
在__init__时,会调用__setattr__初始化实例属性,在__dict__添加键值对。
class Sample:
def __init__(self, name, age):
self.name = name
self.age = age def __setattr__(self, key, value):
print("__setattr__ has called.")
try:
self.__dict__[key] = value
except:
self.__dict__ = {key: value} sam = Sample("Li", 24) # __setattr__ has called.
# __setattr__ has called.
对实例属性的访问时,
1.首先执行__getattribute__方法(这又是一个特殊方法),去调用object基类的__getattribute__来查询__dict__里的键值对。如果存在则直接返回,相当于执行了member.__dict__.get(obj),如果不存在则调用__getattr__方法。
2.__getattr__方法会在实例内存空间中尽可能的搜索该属性值,如果搜索到则直接返回,搜索不到会抛出AttributeError。
注意下面两段代码的区别:__getattribute__的return只是一个硬编码的字符串而不是属性值,__getattr__的return则是实例的属性值。因此,如果有需求,一般会在__getattr__里写需求代码。
class MemberCounter:
def __init__(self, name, age):
self.name = name
self.age = age def __getattribute__(self, obj):
print("__getattribute__ is called.")
return object.__getattribute__(self, obj) def __getattr__(self, obj):
print("__getattr__ is called.")
return "{} Not assgined.".format(obj)
member = MemberCounter("An", 24) print(member.name)
print("\n------------------\n")
print(member.gender) """
__getattribute__ is called.
An ------------------ __getattribute__ is called.
__getattr__ is called.
gender Not assgined.
"""
class MemberCounter:
def __init__(self, name, age):
self.name = name
self.age = age
def __getattribute__(self, obj):
if obj == "gender":
return "male"
else:
return object.__getattribute__(self, obj) member = MemberCounter("An", 24)
print(member.gender)
member.gender = "female"
print(member.gender)
print(member.__dict__) """
male
male
{'name': 'An', 'age': 24, 'gender': 'female'}
"""
__getattribute__
class MemberCounter:
def __init__(self, name, age):
self.name = name
self.age = age
def __getattr__(self, obj):
if obj == "gender":
return "male"
else:
raise AttributeError member = MemberCounter("An", 24)
print(member.gender)
member.gender = "female"
print(member.gender)
print(member.__dict__) """
male
female
{'name': 'An', 'age': 24, 'gender': 'female'}
"""
__getattr__
当访问一个属性的时候:
解释器首先在实例的字典中搜索,
若找不到则去创建这个实例的类的字典中搜索,
若还找不到就到类的基类中搜索,
如果还不找不到最后会尝试调用类的__getattr__方法来获取属性值(若类中定义了该方法的话).
如果这个过程也失败,则引发AttributeError异常
在使用member.name = "Wei"和del member.age时,实际上调用了__setattr__和__delattr__。这两个函数没有类似__getattribute__的使用规则。即无论何时给属性赋值,都会调用 __setattr__()
方法;无论何时删除一个属性,都将调用 __delattr__()
方法。
class MemberCounter:
def __init__(self, name, age):
self.name = name
self.age = age def __setattr__(self, old, new):
print("\033[1;36m {} = {} \033[0m has been created.".format(old, new))
object.__setattr__(self, old, new) def __delattr__(self, key):
print("{} is deleted.".format(key))
del self.__dict__[key] def __getattr__(self, item):
return self.__dict__[item] # object.__getattr__(self, item) member = MemberCounter("An", 24)
print(member.__dict__)
del member.age
print(member.__dict__) """
name = An has been created.
age = 24 has been created.
{'name': 'An', 'age': 24}
age is deleted.
{'name': 'An'}
"""
class A:
def __init__(self, *args):
self.name, self.age = args def __getitem__(self, key):
print("__getitem__ has called.")
self.__dict__.get(key, ValueError) def __setitem__(self, key, value):
print("__setitem__ has called.")
self.__dict__.update({key: value}) def __delitem__(self, key):
print("__delitem__ has called.")
del self.__dict__[key] a = A("Li", 27)
print(a.__dict__)
a["name"]
print(a.__dict__)
a["name"] = "Alex"
print(a.__dict__)
del a["age"]
print(a.__dict__) """
{'name': 'Li', 'age': 27}
__getitem__ has called.
{'name': 'Li', 'age': 27}
__setitem__ has called.
{'name': 'Alex', 'age': 27}
__delitem__ has called.
{'name': 'Alex'}
"""
序号 | 目的 | 所编写代码 | Python 实际调用 |
---|---|---|---|
1 | 获取一个计算属性(无条件的) | x.my_property |
x.__getattribute__('my_property') |
2 | 获取一个计算属性(后备) | x.my_property |
x.__getattr__('my_property') |
3 | 设置某属性 | x.my_property = value |
x.__setattr__('my_property', value) |
4 | 删除某属性 | del x.my_property |
x.__delattr__('my_property') |
5 | 列出所有属性和方法 | dir(x) |
x.__dir__() |
序号 | 目的 | 所编写代码 | Python 实际调用 |
---|---|---|---|
1 | 通过键来获取值 | x[key] |
x.__getitem__(key) |
2 | 通过键来设置值 | x[key] = value |
x.__setitem__(key, value) |
3 | 删除一个键值对 | del x[key] |
x.__delitem__(key) |
4 | 为缺失键提供默认值 | x[nonexistent_key] |
x.__missing__(nonexistent_key) |
三、实例属性的保存格式---__slots__和__dict__
实例对象通常以字典的形式保存属性, 也即__dict__。这种格式可以被__slots__修改 。下面是从各个python书籍中摘下的关于__slots__描述。
定义__slots__后,可以在实例上分配的属性名称将被限制为指定的名称,否则将引发AttributeError异常。
这种限制可以阻止其他人向现有实例添加新属性,解决了用户将值分配给他们无法正确拼写的属性时出现的异常。
在实际使用时,__slots__从未被当做一种安全的特性来实现。它实际上是对内存和执行速度的一种性能优化。
使用__slots__的类的实例不再使用字典来存储实例数据。相反,会使用基于数组的更加紧凑的数据结构。
在会创建大量对象的程序中,使用__slots__可以显著减少内存占用和执行时间。
__slots__与集成的配合使用需要一定的技巧。如果类继承自使用__slots__的基类,那么它也需要定义__slots__来存储自己的属性(即使它不会添加任何属性)。这样才能充分利用__slots__提供的优势。如果忘记了这一点,派生类的运行速度将更慢,占用的内存也比未在任何类上使用__slots__时多。
__slots__的使用也可以使代码不必要求实例具有底层__slots__属性。尽管这一点通常不适用于用户代码。但可以编写其他支持对象实用工具库和其他工具。依靠__dict__来调试、序列化对象并执行其他操作。
__slots__的存在不会对__getattribute__()、__getattr__()、和__setattr__()等方法的调用产生任何影响。因为这些方法应该在类中重新定义。但是,这些方法的默认行为将考虑到__slots__。
此外,没用必要向__slots__添加方法或特性名称,因为它们存储在类中,而不是存储在每个实例中。
class MemberCounter:
__slots__ = ("name", "age")
# 注意, ()指定存储格式为元组,"name"和"age"严格限制了实例化对象的参数,不可随意增加,但可以删除
def __init__(self, name, age): # 不可再写*args, **kwargs
self.name = name
self.age = age
member = MemberCounter("An", 24, )
# member.__dict__ # 当__slots__被指定时,覆盖了__dict__ print(member.__slots__)
print(member.name, member.age)
# member.gender = "female" 报错
#('name', 'age')
# An 24age"
如何在定义了__slots__,来储存dict或者list等数据呢?以下面的例子为例:
class Local(object):
__slots__ = ('__dict__', '__list__') def __init__(self, name, age, gender):
object.__setattr__(self, "__dict__", {}) # 注意,__dict__和__list__只是我随意写的,你可以通篇把__dict__改成dict,照样没有关系
object.__setattr__(self, "__list__", []) # 也就是说,__dict__只是一个属性链接,它从__slots__中链接到一个字典对象并提供相关操作 self.name = name # 假定你已经知道self.name = name 实际上式调用了__setattr__方法,也就是自动存到了self.__dict__里
self.age = age
self.gender = gender def __setattr__(self, key, value):
try:
self.__dict__[key] = value
except KeyError:
self.__dict__ = {key: value} def __getattr__(self, name):
try:
return self.__dict__[name]
except KeyError:
raise AttributeError(name) def __delattr__(self, name):
try:
del self.__dict__[name]
except KeyError:
raise AttributeError(name) local = Local("Li", 24, "famle")
print(local.__slots__)
print(local.__dict__)
# 0('__dict__', '__list__')
# {'name': 'Li', 'age': 24, 'gender': 'famle'
四、跟运算有关的
__eq__(==)、__ge__(>=)、__gt__(>)、__le__ (<=)、__lt__ (<)、__ne__ (!=)、__bool__
参见: http://old.sebug.net/paper/books/dive-into-python3/special-method-names.html
class A:
def __init__(self, number):
self.number = number def __gt__(self, obj):
print("__gt__ has called.")
return self.number > obj.number def __ge__(self, obj):
print("__ge__ has called.") # 既然执行了这个函数,你可以尽情的在return之前写想写的功能
return self.number >= obj.number a = A(23) # 当你写 23 > 45时,实际等同于 a = int(23), b = int(45); a > b
b = A(45) # 这里A就相当于int
c = A(45) print(a > b)
print(b >= c) """
__gt__ has called.
False
__ge__ has called.
True
"""
序号 | 目的 | 所编写代码 | Python 实际调用 |
---|---|---|---|
1 | 加法 | x + y |
x.__add__(y) |
2 | 减法 | x - y |
x.__sub__(y) |
3 | 乘法 | x * y |
x.__mul__(y) |
4 | 除法 | x / y |
x.__truediv__(y) |
5 | 地板除 | x // y |
x.__floordiv__(y) |
6 | 取模(取余) | x % y |
x.__mod__(y) |
7 | 地板除 & 取模 | divmod(x, y) |
x.__divmod__(y) |
8 | 乘幂 | x ** y |
x.__pow__(y) |
9 | 左位移 | x << y |
x.__lshift__(y) |
10 | 右位移 | x >> y |
x.__rshift__(y) |
11 | 按位 and |
x & y |
x.__and__(y) |
12 | 按位 xor |
x ^ y |
x.__xor__(y) |
13 | 按位 or |
x | y |
x.__or__(y) |
此外,还有原地操作:
序号 | 目的 | 所编写代码 | Python 实际调用 |
---|---|---|---|
1 | 原地加法 | x += y |
x.__iadd__(y) |
2 | 原地减法 | x -= y |
x.__isub__(y) |
3 | 原地乘法 | x *= y |
x.__imul__(y) |
4 | 原地除法 | x /= y |
x.__itruediv__(y) |
5 | 原地地板除法 | x //= y |
x.__ifloordiv__(y) |
6 | 原地取模 | x %= y |
x.__imod__(y) |
7 | 原地乘幂 | x **= y |
x.__ipow__(y) |
8 | 原地左位移 | x <<= y |
x.__ilshift__(y) |
9 | 原地右位移 | x >>= y |
x.__irshift__(y) |
10 | 原地按位 and |
x &= y |
x.__iand__(y) |
11 | 原地按位 xor |
x ^= y |
x.__ixor__(y) |
12 | 原地按位 or |
x |= y |
x.__ior__(y) |
以及一些自身简单运算:
序号 | 目的 | 所编写代码 | Python 实际调用 |
---|---|---|---|
1 | 负数 | -x |
x.__neg__() |
2 | 正数 | +x |
x.__pos__() |
3 | 绝对值 | abs(x) |
x.__abs__() |
4 | 取反 | ~x |
x.__invert__() |
5 | 复数 | complex(x) |
x.__complex__() |
6 | 整数转换 | int(x) |
x.__int__() |
7 | 浮点数 | float(x) |
x.__float__() |
8 | 四舍五入至最近的整数 | round(x) |
x.__round__() |
9 | 四舍五入至最近的 n 位小数 | round(x, n) |
x.__round__(n) |
10 | >= x 的最小整数 |
math.ceil(x) |
x.__ceil__() |
11 | <= x 的最大整数 |
math.floor(x) |
x.__floor__() |
12 | 对 x 朝向 0 取整 |
math.trunc(x) |
x.__trunc__() |
13 | 作为列表索引的数字 | a_list[x] |
a_list[x.__index__()] |
五、跟字符串有关的
__str__、__repr__、__format__、[__bytes__]
这些都是跟字符串格式和字符串表示有关的特殊方法。
class Cls(object):
def __init__(self):
self.name = "alex"
self.age = 27
self.gender = "female"
def __str__(self):
print("__str__ has called.")
return "Str: my name is {}, {}.".format(self.name, self.age)
def __format__(self, special):
print("__format__ has called.")
if special == "":
return self.__str__() # 也可以写成str(self)
for _, v in self.__dict__.items(): # 实际上是{"name": "alex", "age": 27}
special = special.replace("%s", str(v), 1)
return special
观察下面二段代码打印的结果:
cls = Cls()
str1 = "{:%s, %s, %s}".format(cls)
print("-------------")
print(str1) """
__format__ has called.
-------------
alex, 27, female
"""
cls = Cls()
str2 = format(cls, "my name is %s, %s, %s.")
print("-------------")
print(str2) """
__format__ has called.
-------------
my name is alex, 27, female.
"""
以上两端代码本质都是一样的,即format和一个字符串匹配,也就是__format__函数传递了special参数(字符串)。
当format函数没有和字符串匹配,也就是__format__函数没有传入参数special时,会调用__str__函数。
cls = Cls() str3 = format(cls)
print("-------------")
print(str3) """
__format__ has called.
__str__ has called.
-------------
Str: my name is alex, 27.
"""
str(cls)调用了__str__方法。str(cls)调用__str__方法, string.format(cls)和format(cls)调用__format__方法。
cls = Cls()
print(str(cls)) """
__str__ has called.
Str: my name is alex, 27.
"""
再来看__str__和__repr__的区别和联系。当__str__存在时,print(obj)和str(obj)实际调用了__str__方法;当__str__不存在时,就会调用__repr__。但是当定义了__repr__时,obj本身会返回一个"合法"的字符串表达式,而不再返回一个描述符<'__main__.A object at XXX>,当然这个描述符也可以被__str__修改,只是会被__repr__覆盖。
class A:
def __str__(self):
print("__str__ has called.")
return self.__class__.__name__ + "__str__" a = A() a # <__main__.A at 0x110a764e0>
print(a)
# __str__ has called.
# A__str__ str(a)
# __str__ has called.
# A__str__
class A:
def __repr__(self):
print("__repr__ has called.")
return self.__class__.__name__ + "__repr__"
a = A() a
#__repr__ has called.
#A__repr__ print(a)
#__repr__ has called.
#A__repr__ str(a)
#__repr__ has called.
#A__repr__
class A:
def __str__(self):
print("__str__ has called.")
return self.__class__.__name__ + "__str__" def __repr__(self):
print("__repr__ has called.")
return self.__class__.__name__ + "__repr__"
a = A() a #__repr__ has called.
#A__repr__ print(a)
#__str__ has called.
#A__str__ str(a)
#__str__ has called.
#'A__str__'
序号 | 目的 | 所编写代码 | Python 实际调用 |
---|---|---|---|
1 | 初始化一个实例 | x = MyClass() |
x.__init__() |
2 | 字符串的“官方”表现形式 | repr(x) |
x.__repr__() |
3 | 字符串的“非正式”值 | str(x) |
x.__str__() |
4 | 字节数组的“非正式”值 | bytes(x) |
x.__bytes__() |
5 | 格式化字符串的值 | format(x, format_spec) |
x.__format__(format_spec) |
通常__str__()
和__repr__()
代码都是一样的,所以会这么写:
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name=%s)' % self.name
__repr__ = __str__
六、跟迭代器有关的
序号 | 目的 | 所编写代码 | Python 实际调用 |
---|---|---|---|
1 | 遍历某个序列 | iter(seq) |
seq.__iter__() |
2 | 从迭代器中获取下一个值 | next(seq) |
seq.__next__() |
3 | 按逆序创建一个迭代器 | reversed(seq) |
seq.__reversed__() |
iter内置函数对应的特殊方法是__iter_,它把一个序列变成迭代器。
class Iter:
def __init__(self, lis):
self.iterate = lis
def __iter__(self):
for v in self.iterate:
print("__iter__ has called.")
yield v a = Iter(list(range(5)))
b = iter(a) print(next(b))
print(next(b)) """
__iter__ has called.
0
__iter__ has called.
1 """
next内置函数对应的特殊方法是__iter_,对迭代器进行迭代(惰性行)。
class Iter:
count = 0
def __init__(self, lis):
self.iterate = lis
def __next__(self):
print("__next__ has called.")
try:
value = self.iterate[Iter.count]
Iter.count += 1
except StopIteration:
exit()
return value a = Iter(list(range(5))) print(next(a))
print(next(a)) """
__next__ has called.
0
__next__ has called.
1 """
至此我们已了解了绝大部分特殊方法,在python中,类对象的顶层是type类。下面是object类和type类的源码。它们的源码是底层实现的。
class object:
""" The most base type """
def __delattr__(self, *args, **kwargs): # real signature unknown
""" Implement delattr(self, name). """
pass def __dir__(self): # real signature unknown; restored from __doc__
"""
__dir__() -> list
default dir() implementation
"""
return [] def __eq__(self, *args, **kwargs): # real signature unknown
""" Return self==value. """
pass def __format__(self, *args, **kwargs): # real signature unknown
""" default object formatter """
pass def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
pass def __ge__(self, *args, **kwargs): # real signature unknown
""" Return self>=value. """
pass def __gt__(self, *args, **kwargs): # real signature unknown
""" Return self>value. """
pass def __hash__(self, *args, **kwargs): # real signature unknown
""" Return hash(self). """
pass def __init_subclass__(self, *args, **kwargs): # real signature unknown
"""
This method is called when a class is subclassed. The default implementation does nothing. It may be
overridden to extend subclasses.
"""
pass def __init__(self): # known special case of object.__init__
""" Initialize self. See help(type(self)) for accurate signature. """
pass def __le__(self, *args, **kwargs): # real signature unknown
""" Return self<=value. """
pass def __lt__(self, *args, **kwargs): # real signature unknown
""" Return self<value. """
pass @staticmethod # known case of __new__
def __new__(cls, *more): # known special case of object.__new__
""" Create and return a new object. See help(type) for accurate signature. """
pass def __ne__(self, *args, **kwargs): # real signature unknown
""" Return self!=value. """
pass def __reduce_ex__(self, *args, **kwargs): # real signature unknown
""" helper for pickle """
pass def __reduce__(self, *args, **kwargs): # real signature unknown
""" helper for pickle """
pass def __repr__(self, *args, **kwargs): # real signature unknown
""" Return repr(self). """
pass def __setattr__(self, *args, **kwargs): # real signature unknown
""" Implement setattr(self, name, value). """
pass def __sizeof__(self): # real signature unknown; restored from __doc__
"""
__sizeof__() -> int
size of object in memory, in bytes
"""
return 0 def __str__(self, *args, **kwargs): # real signature unknown
""" Return str(self). """
pass @classmethod # known case
def __subclasshook__(cls, subclass): # known special case of object.__subclasshook__
"""
Abstract classes can override this to customize issubclass(). This is invoked early on by abc.ABCMeta.__subclasscheck__().
It should return True, False or NotImplemented. If it returns
NotImplemented, the normal algorithm is used. Otherwise, it
overrides the normal algorithm (and the outcome is cached).
"""
pass __class__ = None # (!) forward: type, real value is ''
__dict__ = {}
__doc__ = ''
__module__ = ''
object
class type(object):
"""
type(object_or_name, bases, dict)
type(object) -> the object's type
type(name, bases, dict) -> a new type
"""
def mro(self): # real signature unknown; restored from __doc__
"""
mro() -> list
return a type's method resolution order
"""
return [] def __call__(self, *args, **kwargs): # real signature unknown
""" Call self as a function. """
pass def __delattr__(self, *args, **kwargs): # real signature unknown
""" Implement delattr(self, name). """
pass def __dir__(self): # real signature unknown; restored from __doc__
"""
__dir__() -> list
specialized __dir__ implementation for types
"""
return [] def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
pass def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__
"""
type(object_or_name, bases, dict)
type(object) -> the object's type
type(name, bases, dict) -> a new type
# (copied from class doc)
"""
pass def __instancecheck__(self): # real signature unknown; restored from __doc__
"""
__instancecheck__() -> bool
check if an object is an instance
"""
return False @staticmethod # known case of __new__
def __new__(*args, **kwargs): # real signature unknown
""" Create and return a new object. See help(type) for accurate signature. """
pass def __prepare__(self): # real signature unknown; restored from __doc__
"""
__prepare__() -> dict
used to create the namespace for the class statement
"""
return {} def __repr__(self, *args, **kwargs): # real signature unknown
""" Return repr(self). """
pass def __setattr__(self, *args, **kwargs): # real signature unknown
""" Implement setattr(self, name, value). """
pass def __sizeof__(self): # real signature unknown; restored from __doc__
"""
__sizeof__() -> int
return memory consumption of the type object
"""
return 0 def __subclasscheck__(self): # real signature unknown; restored from __doc__
"""
__subclasscheck__() -> bool
check if a class is a subclass
"""
return False def __subclasses__(self): # real signature unknown; restored from __doc__
""" __subclasses__() -> list of immediate subclasses """
return [] __abstractmethods__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default __bases__ = (
object,
)
__base__ = object
__basicsize__ = 864
__dictoffset__ = 264
__dict__ = None # (!) real value is ''
__flags__ = 2148291584
__itemsize__ = 40
__mro__ = (
None, # (!) forward: type, real value is ''
object,
)
__name__ = 'type'
__qualname__ = 'type'
__text_signature__ = None
__weakrefoffset__ = 368
type
最新文章
- shujuk
- 北京易信软科信息技术有限公司-仓库管理系统V1.0
- Collection 集合类
- Linux下pipe使用注意事项
- django1.9 创建项目和app并初始化项目
- iscroll 使用及遇到的问题
- WCF	异步调用问题
- 浅谈jquery选择器
- Python:映像、集合
- PHP5.4连接sqlserver
- Oracle工程师技能树
- 新出台的治理iMessage垃圾短信的规则
- 测试&;标准说明文章
- “百度杯”CTF比赛 十二月场_blog(kindeditor编辑器遍历,insert注入,文件包含)
- UML——类图
- day-10初级函数
- NB-IoT协议及其PSM
- js- caller、 callee
- 【Unity】第12章 导航网格和寻路
- PHP正则表达式笔记和实例