Ajude nosso projeto a se manter online, faça um PIX de qualquer valor:
programacao.progressiva@gmail.com

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?

Nenhum comentário:

Postar um comentário