En este artículo he reunido en la pequeña para darle método especial sobre la clase de objeto Python para explicar el código, amigos necesidad puede referirse a.
pitón Versión: 3.8
class object:
""" The most base type """
# del obj.xxx或delattr(obj,'xxx')时被调用，删除对象中的一个属性
def __delattr__(self, *args, **kwargs): # real signature unknown
""" Implement delattr(self, name). """
pass
# 对应dir(obj)，返回一个列表，其中包含所有属性和方法名（包含特殊方法）
def __dir__(self, *args, **kwargs): # real signature unknown
""" Default dir() implementation. """
pass
# 判断是否相等 equal ，在obj==other时调用。如果重写了__eq__方法，则会将__hash__方法置为None
def __eq__(self, *args, **kwargs): # real signature unknown
""" Return self==value. """
pass
# format(obj)是调用，实现如何格式化obj对象为字符串
def __format__(self, *args, **kwargs): # real signature unknown
""" Default object formatter. """
pass
# getattr(obj,'xxx')、obj.xxx时都会被调用，当属性存在时，返回值，不存在时报错（除非重写__getattr__方法来处理）。
# 另外，hasattr(obj,'xxx')时也会被调用（估计内部执行了getattr方法）
def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
pass
# 判断是否大于等于 greater than or equal，在obj>=other时调用
def __ge__(self, *args, **kwargs): # real signature unknown
""" Return self>=value. """
pass
# 判断是否大于 greater than，在obj>other时调用
def __gt__(self, *args, **kwargs): # real signature unknown
""" Return self>value. """
pass
# 调用hash(obj)获取对象的hash值时调用
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
# object构造函数，当子类没有构造函数时，会调用object的__init__构造函数
def __init__(self): # known special case of object.__init__
""" Initialize self. See help(type(self)) for accurate signature. """
pass
# 判断是否小于等于 less than or equal，在obj<=other时调用
def __le__(self, *args, **kwargs): # real signature unknown
""" Return self<=value. """
pass
# 判断是否小于 less than，在obj<other时调用
def __lt__(self, *args, **kwargs): # real signature unknown
""" Return self<value. """
pass
# 创建一个cls类的对象，并返回
@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
# 判断是否不等于 not equal,在obj!=other时调用
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
# 如果不重写__str__，则__repr__负责print(obj)和交互式命令行中输出obj的信息
# 如果重写了__str__，则__repr__只负责交互式命令行中输出obj的信息
def __repr__(self, *args, **kwargs): # real signature unknown
""" Return repr(self). """
pass
# 使用setattr(obj,'xxx',value)、obj.xxx=value是被调用（注意，构造函数初始化属性也要调用）
def __setattr__(self, *args, **kwargs): # real signature unknown
""" Implement setattr(self, name, value). """
pass
# 获取对象内存大小
def __sizeof__(self, *args, **kwargs): # real signature unknown
""" Size of object in memory, in bytes. """
pass
# 设置print(obj)打印的信息，默认是对象的内存地址等信息
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
# 某个对象是由什么类创建的，如果是object，则是type类<class 'type'>
__class__ = None
# 将对象中所有的属性放入一个字典，例如{'name':'Leo','age':32}
__dict__ = {}
# 类的doc信息
__doc__ = ''
# 类属于的模块,如果是在当前运行模块，则是__main__，如果是被导入，则是模块名（即py文件名去掉.py）
__module__ = ''
En segundo lugar, el método particular utilizado para explicar
1 .__ método getattribute__
1) ¿A qué hora se llama
Este método en particular es el objeto obj que usamos en clase. Cuando el nombre del atributo o getattr (obj, nombre de la propiedad) que toman el valor del atributo de objeto que se llama. Por ejemplo:
class Foo(object):
def __init__(self):
self.name = 'Alex'
def __getattribute__(self, item):
print("__getattribute__ in Foo")
return object.__getattribute__(self, item)
if __name__ == '__main__':
f = Foo()
print(f.name) # name属性存在 或者 getattr(f,name)
print(f.age) # age属性不存在
Independientemente de si existe la propiedad, __ método getattribute__ se llama. Si existe el atributo, el valor del atributo se devuelve si el atributo no existe, se devuelve None.
Tenga en cuenta que utilizamos hasattr (obj, nombre de la propiedad) para determinar si existe una propiedad, __ método getattribute__ se llamará.
La diferencia 2) y el __getattr__
Nos damos cuenta de la clase, puede anular __getattr__ método, entonces ¿cuál es la diferencia __getattr__ __getattribute__ métodos y métodos?
Sabemos __getattribute__ método, independientemente de si existe la propiedad, que se llamará. Y __getattr__ sólo cuando la propiedad no existe llamada, el valor por defecto arrojará AttributeError: objeto 'Foo' no tiene atributo 'edad' este error, pero podemos anularlo, tenemos que hacer la operación:
class Foo(object):
def __init__(self):
self.name = 'Alex'
def __getattribute__(self, item):
print("__getattribute__ in Foo")
return object.__getattribute__(self, item)
def __getattr__(self, item):
print("%s不存在,但我可以返回一个值" % item)
return 54
if __name__ == '__main__':
f = Foo()
print(f.name) # name属性存在
print(f.age) # age属性不存在,但__getattr__方法返回了54，所以这里打印54。
return resultado:
__getattribute__ in Foo
Alex
__getattribute__ in Foo
age不存在,但我可以返回一个值
54
Vemos, f.name y f.age llamados __getattribute__ método, pero el método se llama __getattr__ única f.age. Por lo tanto, podemos utilizar __getattr__ hacer muchas cosas, como un valor de la clase de un diccionario, o anormalidades de procesamiento.
2 .__ método setattr__
cuando ejecutamos obj.name = 'Alex' o setattr (obj, los nombres de atributos, valores de atributos), que se invoca cuando se asigna la propiedad.
class Foo(object):
def __init__(self):
self.name = 'Alex'
# obj.xxx = value时调用
def __setattr__(self, key, value):
print('setattr')
return object.__setattr__(self, key, value)
if __name__ == '__main__':
f = Foo()
f.name = 'Jone' # 打印setattr
print(f.name)
Si __setattr__ reescribirse (no llame a las palabras de la clase padre __setattr__). cesión de uso obj.xxx = valor no funcionará.
Especial atención, en el constructor de la clase se inicializa cuando este método se llama la asignación es:
class Foo(object):
def __init__(self):
self.name = 'Alex' # 这里也要调用__setattr__
...
Cuando tenemos que reescribir __setattr__ método, es necesario el uso de __setattr__ inicialización de clase de objeto de inicialización Nota:
class Local(object):
def __init__(self):
# 这里不能直接使用self.DIC={}，因为__setattr__被重写了
object.__setattr__(self, 'DIC', {})
def __setattr__(self, key, value):
self.DIC[key] = value
def __getattr__(self, item):
return self.DIC.get(item, None)
if __name__ == '__main__':
obj = Local()
obj.name = 'Alex' # 向DIC字典中存入值
print(obj.name) # 从DIC字典中取出值
3 .__ método delattr__
correspondiente al método del obj. Invoca cuando el nombre de propiedad y delattr (obj, nombre de atributo) ambos. Es decir, eliminar el objeto en una propiedad.
if hasattr(f,'xxx'): # 判断f对象中是否存在属性xxx
delattr(f, 'xxx') # 如果存在则删除。当xxx不存在时删除会报错
# del f.xxx # 同上
4 .__ método dir__
Corresponde dir (obj) obtener todos los nombres de las propiedades del objeto, todas sus propiedades y nombres de método.
f = Foo()
print(f.__dir__()) # ['name', '__module__', '__init__', '__setattr__', '__getattribute__', '__dir__', '__dict__', '__weakref__', '__doc__', '__repr__', '__hash__', '__str__', '__delattr__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__new__', '__reduce_ex__', '__reduce__', '__subclasshook__', '__init_subclass__', '__format__', '__sizeof__', '__class__']
Se devuelve una lista.
5. eq__ y __hash
eq__ se llama juicio obj == otra cuando el objeto es llamado por heredan por defecto __eq ir .
f1 = Foo()
f2 = f1
print(f1 == f2) # True
print(f1 is f2) # True
print(hash(f1) == hash(f2)) # True
Por defecto, f1 f2 ==, f1 f2 es, de hash (f1) == almohadilla (F2) debería al mismo tiempo que la verdadera (o no igual, lo mismo que Falso).
Si volvemos a escribir __eq__ métodos, como por ejemplo comparativo convertido en una propiedad que compara dos objetos:
class Foo(object):
def __init__(self):
self.name = 'Alex' # 这里也要调用__
self.ccc = object.__class__
def __eq__(self, other):
return self.name==other.name
Es decir, si self.name == other.name, se considera igual al objeto.
f1 = Foo()
f2 = Foo()
print(f1 == f2) # True
print(f1 is f2) # False
print(hash(f1) == hash(f2)) # 抛出异常TypeError错误
¿Por qué hash lanzar una excepción, ya que si volvemos a escribir el método __eq__ en una clase, el valor por defecto será __hash __ = Ninguno. Por lo tanto, cuando llamamos almohadilla (obj), __ método hash__ no se puede realizar.
resumen:
Cuando nos dimos cuenta que no queremos ser como la clase de hash, se puede reemplazar el método __eq__, entonces no reescribir __hash __, __ método hash__ se establece en None, el objeto de esta clase no será un hash.
__hash__ método proporcionado por defecto (almohadilla (obj)) para el mismo valor de la variable (tipo de restricciones, algunos tipos no se puede dispersar, por ejemplo, lista), con el mismo valor hash intérprete, diferentes valores de hash para los diversos intérpretes. Por lo tanto, si queremos hash de una meta, usted debe utilizar el módulo hashlib.
La diferencia entre hash y el identificador, el valor hash dos objetos es teóricamente el mismo valor debe ser el mismo, pero Id puede ser diferente (debe ser el mismo objeto, es decir, la misma dirección de memoria, de la identificación de la misma .ID (obj) obj es un identificador único de.)
6. gt , lt , ge , le
Estos tamaños son para la comparación, podemos volver a escribir ellos, (por ejemplo, el que solamente el valor del objeto de comparación de una propiedad) de la definición de la forma de comparar el tamaño del objeto.
7. El str__ y __repr
__str__ definición del contenido de la impresión de impresión (obj).
class Foo(object):
def __init__(self):
self.name = 'Alex'
def __str__(self):
return "我是Foo"
if __name__ == '__main__':
f1 = Foo()
print(f1) # 打印 我是Foo
En la línea de comandos:
>>> class Foo(object):
... def __str__(self):
... return "我是Foo"
...
>>> f1 = Foo()
>>> print(f1)
我是Foo
>>> f1
<__main__.Foo object at 0x0000023BF701C550>
Se puede ver usando __str__ palabras, la impresión puede imprimir el valor que se especifica, y la salida de línea de comandos es la dirección de memoria del objeto.
pitón repr__ para definir simultáneamente el contenido de la salida del comando obj, e imprimir (obj) del contenido de impresión (si no reescribir __str ).
class Foo(object):
def __init__(self):
self.name = 'Alex'
def __repr__(self):
return "我是Foo"
if __name__ == '__main__':
f1 = Foo()
print(f1) # 打印 我是Foo
En la línea de comandos:
>>> class Foo(object):
... def __repr__(self):
... return "我是Foo"
...
>>> f1 = Foo()
>>> print(f1)
我是Foo
>>> f1
我是Foo
Podemos ver, sólo Reescribimos __repr__, pero la impresión y salida directa para imprimir el valor que se especifica.
Cuando sobreescribimos tanto __str__ y __repr__:
>>> class Foo():
... def __str__(self):
... return "我是Foo---str"
... def __repr__(self):
... return "我是Foo---repr"
...
>>> f1 = Foo()
>>> print(f1)
我是Foo---str
>>> f1
我是Foo---repr
Se puede ver al mismo tiempo para reescribir dos métodos, __ str__ responsables de la impresión de la información, y __repr__ directamente responsable de la salida de línea de comandos.
8 .__ método new__
9 .__ método sizeof__
10. Las clases , dict , el módulo 1 , __ doc__ muestra una propiedad
clase : Devuelve la clase del objeto que generó
print(f1.__class__) # <class '__main__.Foo'>
dict : devolver todos los atributos del diccionario de objetos
print(f1.__dict__) # {'name': 'Alex'} 只有一个属性name
Módulo 1 : Devuelve el objeto dentro del módulo
class Foo(object):
def __init__(self):
self.name = 'Alex'
if __name__ == '__main__':
f1 = Foo()
print(f1.__module__) # 打印__main__
Si la clase de objeto que corresponde a la ejecución actual en el módulo, el __main__ impresión.
import test3
f = test3.Foo()
print(f.__module__) # 打印test3
Si la clase de objeto que corresponde a los otros módulos, se imprime el nombre del módulo.
doc comentarios como:
class Foo(object):
"""
这是一个类，名叫Foo
"""
def __init__(self):
self.name = 'Alex'
if __name__ == '__main__':
f1 = Foo()
print(f1.__doc__) # 打印 这是一个类，名叫Foo
Muchas gracias para leer
en la universidad eligió la auto-pitón, encontró que el consumo de un equipo de trabajo mal la pérdida básica, esto no es educado
no puede hacer, sólo puede ser adquirida para compensar, a continuación, abre su propio contraataque fuera de la codificación carretera, en constante aprendizaje pitón conocimiento básico, el conocimiento en profundidad del aprendizaje básico de la computadora, organizado, puse nuestra aprender Python hebilla qun: 250933691, si no están dispuestos a la mediocridad, es conmigo fuera de la codificación, constantemente crecer!
De hecho, no es no sólo cuestiones técnicas, más técnico de los que, por ejemplo, cómo hacer que un programador bien, en lugar de "alambre de Gallo", el programador sí es un noble presencia, ah, ¿verdad? [Haga clic para unirse a] quieren que desea ser una persona noble, vamos!
@ Este artículo proviene de número público: csdn2299, al igual que el número de programadores puede centrarse en las instituciones públicas
