Enviar um café pro programador

Mostrando postagens com marcador Métodos. Mostrar todas as postagens
Mostrando postagens com marcador Métodos. Mostrar todas as postagens

Parâmetros e Argumentos no Método construtor __init__

Neste artigo de nosso curso de Python, vamos falar um pouco mais sobre o método __init__, também conhecido como o método construtor.

Tutorial anterior: Parâmetros e Argumentos em Classes
Estude offline: Apostila Python Progressivo

Método Construtor: __init__

O método init é bem especial, pois como já explicamos, ele é automaticamente executado sempre que instanciamos um objeto de uma classe.

Ele é chamado de construtor, e vimos ele apenas usando o parâmetro self:
def __init__(self)

Porém, é mais comum usarmos ele com outros parâmetros.
Por exemplo, para ele receber também um número, que representa o número de portas de um carro, através da variável num, fazemos:
def __init__(self, num)

E para usar esse método, basta passarmos um argumento ao criamos o Objeto.
Lembra que criamos um objeto da classe carro da seguinte maneira:
palio = Carro()

Para criar esse mesmo objeto, já enviando o número de portas (2 por exemplo), fazemos:
palio = Carro(2)


Veja um exemplo de código:

class Carro:
 def __init__(self, num):
  self.portas = num
  print("Carro criado! Ele tem", self.portas,"portas")
 
palio = Carro(2)

E o resultado:
Como usar o método __initit__ em Python


Nesse código nosso método construtor já atribui o número de portas recebido a variável portas, interna de toda classe Carro. Veja que o método init tem dois parâmetros: self e num

Mas na hora de passar os argumentos, só passamos o num, pois já estamos indicando o objeto (palio) que estamos fazendo isso.

Passando Vários Argumentos

Agora vamos fazer a mesma coisa, porém vamos usar dois parâmetros e dois argumentos.
Além do número de portas, primeiro vamos passar uma string, com o modelo do carro.

Vamos armazenar essa informação na variável nome (logo, self.nome), veja:

class Carro:
 def __init__(self,nome,num):
  self.nome = nome
  self.portas = num
  print(self.nome,"criado! Ele tem", self.portas,"portas")

palio = Carro("Palio", 2)

Resultado:
Método init
Note que fizemos:
self.nome = nome


Esse primeiro nome, junto com self, se refere ao atributo.
Já o segundo nome, se refere ao argumento, ok?

É como fazer:
count = count + 1

Usamos novamente a mesma variável, duas vezes, na mesma expressão. Leia assim: count vai receber seu valor antigo count somado mais um.

Método Construtor

Os métodos construtores são úteis para, como o nome diz, construir um objeto.
Por exemplo, se você cuida do sistema de uma empresa e tem a classe Funcionario.

Então, um novo empregado foi contratado e você vai cadastrar ele no sistema, para isso, vai criar um novo objeto, o funcionario[2112], ou seja, mais um objeto do tipo Funcionario na sua lista de empregados da firma.

Ora, todo empregado tem um nome, número, cargo e salário.
Já crie seu objeto com essas informações. O método construtor __init__ serve justamente pra isso, pra criar logo um objeto fazendo o necessário e obrigatório:

  • funcionario[2112] = Funcionario("Jose da Silva", 2112, "Gerente", 4800.00)

Prontinho, o Zé da Silva, de número 2112, vai ser gerente e ter um salario R$ 4.800,00 (ele é gerente da equipe de programadores, obviamente estudou Python pra ganhar isso).

Quer saber como ter um salário assim, programando em Python?
Como se tornar um programador profissional

Parâmetros e Argumentos, em Métodos de Classes em Python

Neste tutorial de Python, vamos aprender como criar métodos com parâmetros bem como chamar métodos usando argumentos. Vamos te explicar uma questão de segurança muito importante, fazendo isso.

Tutorial anterior: Métodos, método _init__ e Atributos
Baixe nossa: Apostila de Python

Método em Python

No tutorial anterior, de nosso curso de Python, vimos como usar métodos em nossas classes.
Além de conhecermos o método construtor __init__, criamos nosso próprio método, o exibePortas.

Vamos agora ver um método mais interessante.
A classe inicia com o atributo portas com valor 2, por padrão.

Mas isso pode ser mudado, e vai ser possível fazer isso no método definePortas.
Ele pede ao usuário um número de portas, que seu carro deve ter e armazena na variável num.
Em seguida, ele atribui faz com que o atributo portas receba esse valor.

Veja que o atributo deve ser usado com self: self.portas
Veja como fica nosso código:

class Carro:
 portas = 2
 def __init__(self):
  print("Carro criado")
 
 def definePortas(self):
  num=int(input("Numero de portas:"))
  self.portas = num

 def exibePortas(self):
  return self.portas
 
carro = Carro()
carro.definePortas()
print("Numero de portas:", carro.exibePortas())

O código acima pede um número de portas ao usuário, atribui no atributo portas do objeto e exibe esse valor, via método exibePortas.


Argumentos e Parâmetros em Python

A coisa que você mais deve se lembrar, ao trabalhar com métodos e atributos de uma classe, é de usar o self.

Agora vamos fazer com que a definePortas receba um valor número, para atribuir ao atributo de número de portas.


Nosso método vai ter dois parâmetros, o self (que deve sempre estar lá) e o valor que vamos receber, o num, veja como fica nosso método:

def definePortas(self, num):
  self.portas = num

Agora, para chamar, você vai passar somente um argumento, o num, não precisa passar o self.
Veja bem: o método recebe dois parâmetros (self e um número), mas passamos apenas um argumento, o número de portas:

class Carro:
 portas = 2
 def __init__(self):
  print("Carro criado")
 
 def definePortas(self, num):
  self.portas = num

 def exibePortas(self):
  return self.portas
 
carro = Carro()
num=int(input("Numero de portas:"))

carro.definePortas(num)
print("Numero de portas:", carro.exibePortas())

Bem simples e intuitivo, não?

Já pensou em trabalhar em casa, como programador, como eu sou?
Certificado do Curso de Python

Segurança em Programas Python

De cara, pode parecer meio bobo ter dois métodos: um para definir o valor do número de portas, e outro para exibir esse valor.

Mas esse é o padrão: o mundo externo (programa fora da classe), deve ter o poder de mexer nos objetos através apenas de métodos específicos.

Não é seguro, em hipótese alguma, que seja possível ter acesso ao atributo portas senão via esses métodos. Ou seja, nenhum bug ou hacker deve ter acesso a esse atributo, somente por algum método.
Método este que deve 'tomar as rédeas' dos atributos.

No exemplo abaixo, vamos criar uma classe que representa a conta do banco de um cliente.
Temos a variável saldo, que inicia com valor R$ 0.00

Temos o método exibeSaldo, que retorna o saldo da pessoa (objeto) e também o método depositae.
Esse método de depositar, só deve funcionar se o valor depositado seja positivo.

Caso contrário, não é possível realizar depósito. Pode reclamar, tentar invadir, hackear ou o que for, mas só vai depositar um valor positivo:

class Conta:
 saldo = 0.0
 def __init__(self):
  print("Conta do cliente criada")
 
 def depositar(self, num):
  if(num>0):
   self.saldo = num
  else:
   print("Nao é possível depositar 0 ou menos")

 def exibeSaldo(self):
  return self.saldo
 
pessoa = Conta()
print("Saldo inicial:" , pessoa.saldo())
num=int(input("Depositar:"))

pessoa.depositar(num)

print("Saldo atual:", pessoa.saldo())

Exercício de Orientação a Objetos
Agora crie um método de saque, onde só deve ser possível fazer um saque se a pessoa tiver um saldo positivo, e o saque máximo é esse valor.

O programa deve exibir um looping infinito, perguntando se a pessoa desejar depositar ou sacar valores.

Primeiro, definimos o saldo na conta do cliente como saldo=0.0 afinal, o cliente acabou de criar a conta, não tem nada.

Para depositar, primeiro verificamos que o valor desejado para depósito seja maior que 0.
Se sim, ok, depositamos. Se não for, informamos o erro.

Depois, é o método sacar, que vai sacar um valor valor.
Esse valor deve ser menor ou igual ao saldo, pra poder sacar.

Se não der, exibe mensagem de erro.
Nosso código fica:


class Conta:
 saldo = 0.0
 def __init__(self):
  print("Conta do cliente criada")
 
 def depositar(self, num):
  if(num>0):
   self.saldo += num
  else:
   print("Nao é possível depositar 0 ou menos")
 def sacar(self, valor):
  if(valor<=self.saldo):
   self.saldo -= valor
  else:
   print("Valor insuficiente. Você tem:", self.saldo)

 def exibeSaldo(self):
  return self.saldo
 
pessoa = Conta()
op = True

while op:
 print("0. Sair")
 print("1. Exibir saldo")
 print("2. Depositar")
 print("3. Sacar")
 op=int(input())

 if(op==1):
  print("Saldo:", pessoa.exibeSaldo() )
 elif(op==2):
  num=float(input("Valor para depositar:"))
  pessoa.depositar(num)
 elif(op==3):
  num=float(input("Valor para sacar:"))
  pessoa.sacar(num)
 else:
  print("Saindo do sistema...")
 


Prontinho, você acabou de criar um sistema bancário em Python, onde um usuário pode fazer depósito, sacar e consultar seu saldo.

Simples, esse Python, não?

Como Criar Classes e Objetos em Python

Neste tutorial de POO em Python, vamos aprender como criar classes, instanciar objetos, definir atributos e métodos (finalmente).

Tutorial anterior: O que é Classe e Objeto

Como definir e criar uma classe


Definimos uma classe através da instrução class, seguido de um nome para sua classe, dois pontos e as instruções:

class MinhaClasse:
   [codigo da classe]
   [atributos]
   [metodos]

Prontinho. Você acabou criar uma classe de nome MinhaClasse
.Abaixo dela, indentado, vai todo o seu código.

Nesse trecho do código onde vai os métodos que irão trabalhar e atuar nos objetos, bem como seus atributos (informações).



Como Criar e Instanciar um Objeto

Agora que já criamos a classe MinhaClasse, vamos aprender como criar, ou melhor dizendo: como instanciar objetos dessa classe.

Primeiro definimos o nome da variável, depois fazemos ela receber o nome da classe, seguido de um par de parêntesis.
  • meuObjeto1 = MinhaClasse()
  • meuObjeto2 = MinhaClasse()
  • etc
Prontinho. Só isso.




Todo o código definido para MinhaClasse será um código interno de cada objeto. Ou seja, todos os objetos que você instanciou (imagine a classe como uma fábrica de objetos, uma fabricadora de instâncias de objetos) vão todos os métodos e atributos da MinhaClasse.

E não importa se você instanciou nenhum, um ou 1 bilhão de objetos.
Todos vão herdar essas informações automaticamente.

Ah...e mudou o código da sua classe?
Passa a valer pra todas as instâncias.

Exemplo de Classe e Objeto em Python

Copie o código abaixo e rode ele:


class Carro:
 def __init__(self):
  print("Carro criado")

corolla = Carro()
civic = Carro()


Definimos a classe Carro nele.
Escrevemos um método nele, o __init__, que recebe o parâmetro self (são dois underline antes da palavra init e dois depois, ok?)

E método é o mesmo que função, mas função interna de uma classe, que só existe e atua nos seus objetos. Ela só é vista fora do escopo do objeto se o programador desejar. Veremos essa questão de segurança depois também.

Esse método, que iremos explicar melhor no próximo tutorial o que é e para que serve, manda a mensagem na tela: Carro criado!

Instanciamos dois objetos dessa classe, o corolla e o civic, veja o resultado:

Como criar um objeto em Python


Ou seja, você acabou de criar uma classe e objetos, já está vendo a programação orientada a objetos em funcionamento! Show!

Mas a pergunta que não quer calar: qual melhor, Corolla ou Civic ?

Próximo tutorial: Métodos, método __init__ e Atributos