Python - Construtores

Em Pitão existem os chamados métodos "mágicos", isto é, métodos que são construídos e têm um nome especial e que são chamados apenas em certas circunstâncias, uma vez que a chamada direta desses métodos não é comum no âmbito de um programa.
Construtores
O método __iniciar__ está encarregado de atuar como construtor, ou seja, inicializará uma série de atributos e executará o código que definimos no momento em que um objeto da classe é criado, sendo denominado "__init__" com dois sublinhados no início e fim da palavra init então você já tem a sintaxe apropriada para isso Pitão considere-o um método "mágico" e saiba que ele deve ser executado ao instanciar a classe.
O que o construtor consegue é que, em vez de fazer o seguinte para inicializar um objeto:

 >>> f = FooBar () >>> f.init () 

Já colocando este código, o objeto inicializou seus atributos apenas usando:

>>> f = FooBar ()

Como você pode ver, é uma importante economia na hora de codificar e uma ajuda no caso de esquecermos de inicializar o objeto.
Criação do construtor
Crie o construtor em Pitão É bem simples, basta definir o método e adicionar o que deve ser feito quando o objeto for criado, vamos ver um exemplo:

Na imagem você pode ver o método definido e no que ele deve executar vemos que define o atributo somevar e é igual a 42. Vejamos um exemplo de como um objeto desta classe seria executado:

Na imagem vemos que ao definir o objeto f do tipo FooBar Ele é inicializado e ao acessar seu atributo, algumevar imprime 42, que é o valor definido no construtor.
Agora o que acontece se quisermos que os atributos sejam inicializados dinamicamente, vamos reescrever o método da seguinte maneira:

 classe FooBar: def __init __ (self, value = 42): self.somevar = value 

Fazendo o parâmetro opcional podemos passar um valor, caso não o passemos tomará 42 como valor padrão.
A execução do programa seria a seguinte:

 >>> f = FooBar ('Este é um argumento do construtor') >>> f.somevar 'Este é um argumento do construtor' 

Desta forma, tornamos nosso construtor dinâmico para que possamos atribuir diferentes atributos aos nossos objetos, dependendo de nossas necessidades dentro do programa.
Substituindo o construtor
Há momentos em que devemos herdar das superclasses, para isso às vezes devemos sobrescrever o construtor, vamos ver o exemplo a seguir para entender do que se trata:

Aqui criamos uma classe chamada Bird, onde o construtor define o atributo fome, executamos o seguinte e vemos como funciona:

 >>> b = Bird () >>> b.eat () Aaaah… >>> b.eat () Não, obrigado! 

Agora, o que acontece se herdarmos desta classe, vamos ver o seguinte código:

 class SongBird (Bird): def __init __ (self): self.sound = 'Squawk!' def sing (self): print self.sound 

Executamos um pequeno programa:

 >>> sb = SongBird () >>> sb.sing () Squawk! 

Agora, se chamarmos o método eat (), veremos um erro:

 >>> sb.eat () Traceback (última chamada mais recente): Arquivo "", linha 1, em? Arquivo "birds.py", linha 6, em eat if self.hungry: AttributeError: a instância do SongBird não tem o atributo 'faminto' 

A exceção nos diz que o atributo fome não existe, então devemos chamar o construtor da superclasse em nosso construtor:

 class SongBird (Bird): def __init __ (self): Bird .__ init __ (self) self.sound = 'Squawk!' def sing (self): print self.sound 

Agora, ao executar o código, tudo funcionará sem problemas:

 >>> sb = SongBird () >>> sb.sing () Squawk! >>> sb.eat () Aaaah… >>> sb.eat () Não, obrigado! 

Com isso encerramos o tutorial, já sabemos como usar o método __init__ de forma básica e como fazê-lo quando devemos herdar de uma classe superior.Gostou e ajudou este tutorial?Você pode recompensar o autor pressionando este botão para dar a ele um ponto positivo