3
respostas

Checagem de saldo e valores

Boa noite! Eu acabei de assistir a aula do professor, porém já tinha "resolvido" esse problema do sacar antes, nas aulas anteriores.

Só gostaria de saber se fiz algo errado ou fora do padrão:

    def saca(self, valor):
        self.__saldo -= valor
        self.result = abs(self.__saldo)
        if self.result > self.__limite:
            self.__saldo += valor
            print("Você não tem saldo em conta disponível para saque.")
            print("Seu saldo em conta é de: R$ {} + R$ {} de limite. Total disponível para saque: R$ {}".format(
                self.__saldo, self.__limite, self.__check))
        else:
            print("Saque de R$ {} realizado com sucesso na conta de {}".format(valor, self.titular))
            print("Novo saldo é de:R$ {}".format(self.saldo))
3 respostas

Bom dia Wesley! Identifiquei algumas inconsistências em seu código e algumas sugestões de melhoria! Primeiro: A variável/atributo "self.limite" não foi identificada ou iniciada no código, seria um caso de "Dead Code". No caso do primeiro "if" você tenta examinar o saldo em conta disponível, mas ao invés de utilizar o "abs" como variável de condição, utiliza o limite acarretando em erro ao avaliar o Saldo em conta, seria uma avaliação do Limite disponível, seja do cartão ou cheque especial.

Você não iniciou nenhuma classe para a função, o que acarretaria no mal entendimento do self. nas funções. O uso do "" antes de um atributo deve ser utilizado na definição da Classe e não do método/função e então alterada a variável para um outro nome em que proteja o real nome da variável de atributo dentro da Classe.

Passarei o código completo da classe Conta e suas funções com as devidas proteções de dados assim como os @propertys e @setters que ficaram ausentes em seu código! Espero ajudar:

import math

class conta:
    def __init__(self, nome, extrato, cartaoLimite, cheque, id, totalDisp):
        self.titular = nome
        self.__saldo = extrato
        self.__limite = cartaoLimite
        self.__check = cheque
        self.__numero = id
        self.__total = totalDisp

    @property
    def nome(self):
        return self.titular
    @property
    def extrato(self):
        return self.__saldo
    @property
    def cartaoLimite(self):
        return self.__limite
    @property
    def cheque(self):
        return self.__check
    @property
    def id(self):
        return self.__numero
    @property
    def totalDisp(self):
        return self.__total
    @totalDisp.setter
    def totalDisp(self):
        self.totalDisp = self.extrato + self.cartaoLimite
    @cheque.setter
    def cheque(self):
        if self.totalDisp >= 0:
            self.cheque == False
        else:
            self.cheque == True

Essa é a** classe conta, como pode ver, você deve definir o método de retorno do atributo com uma variável diferente da real variável da Classe** para protegê-la e mantê-la em segredo para apenas quem tem acesso ao código fonte. O método para isso são os** @propertys**.

Com o poder da Orientação à Objetos nós podemos criar funções que definam as variáveis de totalDisp, ou total disponível, e se a conta esta em cheque especial de maneira mais simples, apenas executando a função dentro do código após como uma triagem para execução da função, seguem exemplos:

def especial(self):
    if self.cheque == True:
        print('-------------------------ATENÇÃO-----------------------------------')
        print('Conta {} se encontra com saldo NEGATIVo e utilizando o CHEQUE ESPECIAL'.format(self.id))
        self.especial == True
    else:
        self.especial == False

def sacavel(self, sacavel):
    if self.totalDisp >= self.extrato + self.cartaoLimite and especial == False:
        return sacavel == True
    else:
        return sacavel == False

Seguem exemplos de como ficariam as funções de saque e de checagem de extrato:

def checagemExtrato(self, value):
    value = self.extrato + self.cartaoLimite
    print('Olá {}, sobre a solicitação de checagem de saldo disponível, seguem informações da conta {}:'.format(self.nome, self.id))
    especial(self)
    if(value > self.cartaoLimite and value > self.extrato):
        print('Você possui um total de saldo de R$ {}, sendo que deste valor, R$ {} é referente ao saldo disponível em conta e R$ {} disponível em limite de cartao.'.format(value, self.extrato, self.cartaoLimite))       
    else:
        print('Você não possui valor suficiente para efetuar o saque. O seu extrato atual é de R$ {}' .format(self.extrato))



def saca(self, valor):
    self.totalDisp -= valor
    print('Olá {}, seja bem vindo, calculando a possibilidade de saque da conta {}'.format(self.nome, self.id))
    sacavel(self)
    if sacavel == False:
        especial(self)
        print('Você não possui saldo suficiente em conta')
        checagemExtrato(self)
    else:    
        especial(self)
        print("Saque de R$ {} realizado com sucesso na conta de número {}".format(valor, self.id))
        checagemExtrato(self)

Espero ter ajudado!

Olá Wesley, tudo bem com você?

Fazendo alguns testes com o código apresento a seguinte proposta para correção da validação, destaco que devido ao código apresentado ser de apenas um método, a proposta poderá funcionar de maneira diferente em seu código.

Foi considerado que o atributo self.__check foi declarado no método __init__ assim o método inicializador ficaram como apresentado abaixo:

   def __init__(self, numero, titular, saldo, limite):
        print("Construindo objeto ... {}".format(self))
        self.__numero = numero
        self.__titular = titular
        self.__saldo = saldo
        self.__limite = limite
        self.__check = self.__saldo + self.__limite
`

A partir desse ponto, podemos modificar o laço de validação if, como o proposto na atividade é que o valor sacado não pode ultrapassar a soma do saldo com o limite declarado, podemos implementar a validação da seguinte forma.

 if valor > self.__check:

Onde será verificado se o valor é maior que a soma do limite com o saldo, caso seja, o valor será devolvido para o saldo.

Não foi feito o uso do atributo self.result, deixo abaixo o método completo para comparação.

    def saca(self, valor):
        self.__saldo -= valor
        if valor > self.__check:
            self.__saldo += valor
            print("Você não tem saldo em conta disponível para saque.")
            print(
                "Seu saldo em conta é de: R$ {} + R$ {} de limite. Total disponível para saque: R$ {}".format(
                    self.__saldo, self.__limite, self.__check))
        else:
            print(
                "Saque de R$ {} realizado com sucesso na conta de {}".format(
                    valor, self.titular))
            print("Novo saldo é de:R$ {}".format(self.saldo))

Terminal

from conta import Conta
conta = Conta(123, 'Ana', 500, 1000)
Construindo objeto ... <conta.Conta object at 0x0000023D58A9A830>
conta.saca(2000)
Você não tem saldo em conta disponível para saque.
Seu saldo em conta é de: R$ 500 + R$ 1000 de limite. Total disponível para saque: R$ 1500
conta.saldo
500
conta.saca(250)
Saque de R$ 250 realizado com sucesso na conta de Ana
Novo saldo é de:R$ 250

Fico à disposição em caso de dúvidas.

Abraços e bons estudos.

Caso este post tenha lhe ajudado, por favor, marcar como solucionado ✓. Bons Estudos!

@PEDRO AZEVEDO DE QUEIROZ bom dia!

Infelizmente eu terei que discordar em alguns pontos. Primeiro deles é que eu mostrei apenas a função de sacar, não o código inteiro. Todas as classes estão criadas, atributos e métodos tudo certo então não teria nenhum dead code.

O que não usei ai foram as @property que não vi sentido usar pois isso vem mais do java e achei cansativo usar o tempo todo.

Outro ponto é em relação ao limite. Não fiz limite de cartão e sim de conta. Se analisar bem o código, ele funciona assim:

        def saca(self, valor):
        # Aqui ele retira o valor solicitado, ou seja o saldo de fato é alterado
        self.__saldo -= valor
        # Aqui o resultado é inserido numa variável result, usando a função abs para retornar o valor absoluto da variável e salvá-la em result
        self.result = abs(self.__saldo)
        # A partir daqui, checo se o result é maior q o limite. se for, ele não deixa realizar o saque e devolve o valor à conta. 
        # Antes, em outro metodo, o limite é igual ao saldo da conta + o limite da conta, ou seja, por exemplo: 1000 + 50 = 1050
        if self.result > self.__limite:
            self.__saldo += valor
            print("Você não tem saldo em conta disponível para saque.")
            print("Seu saldo em conta é de: R$ {} + R$ {} de limite. Total disponível para saque: R$ {}".format(
                self.__saldo, self.__limite, self.__check))
        else:
            print("Saque de R$ {} realizado com sucesso na conta de {}".format(valor, self.titular))
            print("Novo saldo é de:R$ {}".format(self.saldo))

A minha dúvida era somente se o código que apresentei, tem algo fora do padrão. Funcional ele está, printa os avisos, certinho.

Insira aqui a descrição dessa imagem para ajudar na acessibilidade

@Fillipe Rafael, bom dia!

Obrigado pelo retorno, meu código está exatamente como você colocou a diferença foi a criação do Result.

Farei essa alteração! Obrigado!!

Quer mergulhar em tecnologia e aprendizagem?

Receba a newsletter que o nosso CEO escreve pessoalmente, com insights do mercado de trabalho, ciência e desenvolvimento de software