Construtores Python e __init__

Por que os construtores são realmente chamados de "Construtores"? Qual é seu propósito e como eles são diferentes dos métodos em uma classe?

Além disso, pode haver mais de um __init__em uma classe? Tentei o seguinte, alguém pode explicar o resultado?

>>> class test:
    def __init__(self):
        print "init 1"
    def __init__(self):
        print "init 2"

>>> s=test()
init 2

Finalmente, é __init__uma sobrecarga de operador?

Não há sobrecarga de função no Python, o que significa que você não pode ter várias funções com o mesmo nome, mas com argumentos diferentes.

Em seu exemplo de código, você não está sobrecarregando __init__() . O que acontece é que a segunda definição liga novamente o nome __init__ao novo método, tornando o primeiro método inacessível.

Quanto à sua pergunta geral sobre construtores, a Wikipedia é um bom ponto de partida. Para coisas específicas do Python, eu recomendo fortemente os documentos do Python .

Por que os construtores são realmente chamados de "Construtores"?

O construtor (nomeado __new__) cria e retorna uma nova instância da classe. Portanto, o C.__new__método da classe é o construtor da classe C.

O C.__init__método de instância é chamado em uma instância específica, depois de criado, para inicializá-lo antes de ser passado de volta ao chamador. Portanto, esse método é o inicializador para novas instâncias de C.

Como eles são diferentes dos métodos de uma classe?

Conforme declarado na documentação oficial, __init__ é chamado após a criação da instância . Outros métodos não recebem este tratamento.

Qual é o seu propósito?

O objetivo do construtor C.__new__é definir o comportamento personalizado durante a construção de uma nova Cinstância.

O objetivo do inicializador C.__init__é definir a inicialização personalizada de cada instância ou Capós sua criação.

Por exemplo, Python permite que você faça:

class Test(object):
    pass

t = Test()

t.x = 10   # here you're building your object t
print t.x

Mas se você quiser que cada instância de Testtenha um atributo xigual a 10, você pode colocar esse código dentro de __init__:

class Test(object):
    def __init__(self):
        self.x = 10

t = Test()
print t.x

Cada método de instância (um método chamado em uma instância específica de uma classe) recebe a instância como seu primeiro argumento. Esse argumento é convencionalmente nomeado self.

Os métodos de classe, como o construtor __new__, recebem a classe como seu primeiro argumento.

Agora, se você quiser valores personalizados para o xatributo, tudo o que você precisa fazer é passar esse valor como argumento para __init__:

class Test(object):
    def __init__(self, x):
        self.x = x

t = Test(10)
print t.x
z = Test(20)
print t.x

Espero que isso ajude você a tirar algumas dúvidas, e como você já recebeu boas respostas para as outras perguntas, vou parar por aqui :)

As classes são simplesmente projetos para criar objetos. O construtor é um código que é executado sempre que você cria um objeto. Portanto, não faz sentido ter dois construtores. O que acontece é que o segundo sobrescreve o primeiro.

Normalmente, você os usa para criar variáveis ​​para esse objeto como este:

>>> class testing:
...     def __init__(self, init_value):
...         self.some_value = init_value

Então, o que você poderia fazer é criar um objeto desta classe como este:

>>> testobject = testing(5)

O testobject terá então um objeto chamado some_valueque neste exemplo será 5.

>>> testobject.some_value
5

Mas você não precisa definir um valor para cada objeto, como fiz no meu exemplo. Você também pode fazer assim:

>>> class testing:
...     def __init__(self):
...         self.some_value = 5

então, o valor de algum_valor será 5 e você não precisa defini-lo ao criar o objeto.

>>> testobject = testing()
>>> testobject.some_value
5

o >>> e ... na minha amostra não é o que você escreve. É como ficaria no pyshell ...

os co-construtores são chamados automaticamente quando você cria um novo objeto, assim "construindo" o objeto. A razão pela qual você pode ter mais de um init é porque os nomes são apenas referências em python, e você tem permissão para alterar o que cada variável faz referência quando quiser (daí a tipagem dinâmica)

def func(): #now func refers to an empty funcion
    pass
...
func=5      #now func refers to the number 5
def func():
    print "something"    #now func refers to a different function

na definição de sua classe, ele apenas mantém o último

Não há noção de sobrecarga de método em Python. Mas você pode obter um efeito semelhante especificando argumentos opcionais e de palavra-chave