Diretório do artigo
Em primeiro lugar, qual é a maneira mágica para fazer isso? Em python se o nome do método é __xxxx __ (), então não é uma função especial, o chamado método de "mágica".
__ __ o () método init
- Inicialização chamada de método, chamado por padrão quando você cria um objeto quando uma instância é criada.
- __ __ o método Init () tem um nome padrão para o auto parâmetro, se dois parâmetros passados ao criar o objecto, __init __ () Método outro auto como o primeiro parâmetro precisa de dois parâmetro externo, por exemplo __init __ (self, x, y).
Antes de adicionar este atributo para o objeto:
class Student:
pass
stu1 = Student()
stu1.name = "张三"
stu1.age = 18
Agora usamos o __init __ () para simplificar o código
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
stu1 = Student("张三", 18)
Não é olhar o código mais conciso
__str __ () Método
- descrição geral para um objeto, ou um resultado de sua própria definição da saída desejada.
- Ao chamar str () chama __str __ (), ou seja, o objeto é convertido para um tipo de cadeia.
- Ao usar a saída de impressão () do objeto também chamado __str __ () método, desde que eles são definidos __str __ () método, ele irá imprimir os dados neste retorno do método.
Quando __ método __str () não é definida:
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
stu1 = Student("张三", 18)
print(stu1)
s = str(stu1)
print(s)
"""
输出结果：
<__main__.Student object at 0x03C3BCD0>
<__main__.Student object at 0x03C3BCD0>
"""
__str não está definida __ () método que retorna um endereço de memória padrão do objeto.
__str definido __ () método é tal que:
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return "姓名：%s\t年龄：%d"%(self.name, self.age)
stu1 = Student("张三", 18)
print(stu1)
s = str(stu1)
print(s)
"""
输出结果：
姓名：张三 年龄：18
姓名：张三 年龄：18
"""
__del __ () Método
Quando um objeto é excluído, interpretador Python será o padrão para uma chamada de método, este método é o método __del __ ().
Primeiro, ele deve primeiro entender um conceito, é uma referência ao número de objetos. Nós precisa sys módulo getrefcount () é usado para medir um número de referência de objecto, o valor de retorno = número real de uma referência . 2 para ilustrar o retorno real quando a referência ao número objecto é um, então não é uma referência para o objecto é variável.
import sys
class A:
pass
a = A()
# 现在只有变量a引用了A类创建的对象
print(sys.getrefcount(a))
"""
输出结果：
2
"""
# 那么现在再创建一个变量b，也引用a所引用的对象，那么它的引用个数就会加1，实际引用个数变成2.
b = a
print(sys.getrefcount(a))
"""
输出结果：
3
"""
Quando o interpretador é detectado, o número de objectos na verdade referenciado é 0, o objecto será suprimida, então não seria um método de __ () __del chamada correspondente. Outro caso é que o programa foi totalmente implementado ao longo, então a memória correspondente será libertado, ele executará __del __ () método.
Este é o caso de execução completamente normal do programa:
import sys
class A:
def __del__(self):
print("该对象被销毁")
a = A()
"""
输出结果：
该对象被销毁
"""
Há também um caso de referências manualmente variáveis remove:
import sys
class A:
def __del__(self):
print("该对象被销毁")
a = A() # 此时实际引用个数为1
b = a # 此时实际引用个数为2
print("删除了变量a")
del a # 删除变量a，此时实际引用个数为1
print("删除了变量b")
del b # 删除变量b，此时实际引用个数为0,python解释器就会删除该对象，即调用__del __()方法
print("程序结束")
"""
输出结果：
删除了变量a
删除了变量b
该对象被销毁
程序结束
"""
__new __ () Método
- __new __ método de classe é chamado quando instância é criada, ela __init __ chamadas do que o tempo antes.
- CLS __new __ Pelo menos um parâmetro, representante da classe a serem instanciados, este parâmetro é automaticamente fornecido pelo interpretador no pitão instanciação.
- __new __ deve ter um valor de retorno, o retorno para instanciar uma instância dele, e este ponto no tempo para alcançar seu próprio __new__ prestar especial atenção, pode retornar instância da classe pai __new__ fora, ou é objeto de fora __new__ direta instância. Em Python3 cada classe de objeto herda a classe pai padrão.
- uma auto parâmetro __init__, é um exemplo do __new__ retorno, __ init__ pode fazer algumas outras operações de inicialização na __new__ base, __ init__ nenhum valor de retorno
class A:
def __init__(self):
print("调用了init方法")
def __new__(cls):
print("调用了new方法")
return super().__new__(cls)
a = A()
"""
输出结果：
调用了new方法
调用了init方法
"""
Desenvolvimento: __ __new pode substituir o método implementar um singleton
Código é a seguinte:
class A:
# 定义一个私有的类属性，用于存储实例化出来的对象
_isinstance = None
def __new__(cls):
print("调用了new方法")
# 判断如果_isinstance为None，则创建一个实例，否则直接返回_isinstance
if not cls._isinstance:
cls._isinstance = super().__new__(cls)
return cls._isinstance
print(id(A))
print(id(A))
print(id(A))
print(id(A))
"""
输出结果：
19888488
19888488
19888488
19888488
"""
__slots __ propriedade
Nós todos sabemos que Python é uma linguagem dinâmica, você pode adicionar propriedades enquanto o programa está em execução. Como fazer se queremos limitar as propriedades dos casos? Por exemplo, adicionar apenas o nome e idade dos atributos da instância Person.
Para atingir o limite de tempo de destino, Python permite a definição de tempo de aula, a definição de uma especial ⼀ __slots__ variável para limitar os atributos de instância de classe podem ser adicionados:
class Person(object):
__slots__ = ("name", "age")
P = Person()
P.name = "⽼王"
P.age = 20
P.score = 100
"""
输出结果：
Traceback (most recent call last):
File "<input>", line 6, in <module>
AttributeError: 'Person' object has no attribute 'score'
"""
Nota: Use __slots__ prestar atenção, __ slots__ definido atributos para somente a instância atual da classe do uso de herança de classe submenus não é obra de Uso.
