Python Python, uso de multiparadigmas

[Bruno Coviello]

Olá a todos. Estou em uma enrascada, tenho 1 semana para fazer esse programa para a faculdade, e preciso muito a vossa ajuda. 

Vamos lá, eu nunca programei em python na minha vida e tenho noção dos conceitos que precisarei abordar neste programa para fazer o trabalho da faculdade, porém, eu não sei aplica-los no python. Por isso, se possível, preciso de ajuda nos seguintes quesitos: 

1. Como funciona a herança no Python? Posso fazer igual no java, em que eu crio um arquivo chamado de classe mãe e importo para a classe filha? E um terceiro arquivo que irá executar o programa?
2. Há outra maneira de aplicar uma linguagem procedural no Python com este meu código abaixo?

Obrigado!

class calculadora():
    def __init__(self):
        self.__num1 = None
        self.__num2 = None
def lerValores(self):
        self.__num1 = float(input('Digite um valor: '))
        self.__num2 = float(input('Digite outro valor: '))

def adicao(self):
        soma = self.__num1 + self._num2
        return soma

def subtracao(self):
        sub = self.__num1 - self.__num2
        return sub

def multiplicacao(self):
        mult = self.__num1 * self.__num2
        return mult

def divisao(self):
        div = self.__num1 / self.__num2
        return div


def calculate():
    operation = input('''
Entre com a operação a ser utilizada:
+ 
- 
* 
/ 
''')
    calculadora()
    lerValores(self)

    if operation == '+':
        adicao(self)

    elif operation == '-':
        subtracao(self)

    elif operation == '*':
       multiplicacao(self)

    elif operation == '/':
      divisao(self)

    else:
        print('Entrada inválida, tente novamente.')

    # Add again() function to calculate() function
    again()

def again():
    calc_again = input('''
Continuar?
S para continuar & N para encerrar.
''')

    if calc_again.upper() == 'S':
        calculate()
    elif calc_again.upper() == 'N':
        print('Obrigado por usar.')
    else:
        again()

calculate()

 

[Visitante]

@Bruno Coviello Olá. Segue um exemplo do uso de Herança em Python:

class Veiculo(object): # herda de object, tal como em Java, onde toda classe herda direta ou indiretamente de Object

    def __init__(self, tipo, modelo, cor): # construtor
        self.tipo = tipo
        self.modelo = modelo
        self.cor = cor

    def buzinar(self, som):
        print("%s %s buzinou: %s" % (self.tipo, self.modelo, som))


class Moto(Veiculo): # Moto herda de Veiculo

    def __init__(self, tipo, modelo, cor):
        super().__init__(tipo, modelo, cor)


class Caminhao(Veiculo): # Caminhão herda de Veiculo

    def __init__(self, tipo,  modelo, cor):
        super().__init__(tipo, modelo, cor)


if __name__ == '__main__': # aqui seria o método main em Python

    m = Moto("Moto", "Honda", "Azul")
    m.buzinar("Bi Bi")

    c = Caminhao("Caminhão", "Volkswagen", "Cinza")
    c.buzinar("Fom Fom")

Perceba que quando chamo o método buzinar, que poderia ser sobrescrito nas classes Filhas (Moto e Caminhao), eu não passo como argumento o "self", passo apenas o tipo do som da buzina como argumento

O self em Python equivale ao this do Java, e inclusive, se você mudar o self ( que seria o objeto propriamente dito) pelo this, em Python, funciona da mesma maneira

 

É possível sim tranquilamente usar programação procedural em Python

Veja esse pequeno relógio usando interface gráfica e programação multithread:

from datetime import *
import tkinter as tk
import threading


def atualizar_hora():

    dt = datetime.now()

    t = threading.Timer(1, atualizar_hora)
    t.start()

    label["text"] = "%02d:%02d:%02d" % (dt.hour, dt.minute, dt.second)


root = tk.Tk()
root.title("Clock")
root["bg"] = "darkgreen"

label = tk.Label(root, font="Times 18 bold", width=10)
label.pack(padx=40, pady=40)

atualizar_hora()

root.mainloop()

Veja que crio a função atualizar_hora e apenas chamo a mesma depois

 

A diferença é que quando se trata de um método de uma classe, self (ou this) é um parâmetro obrigatório e deve ser o primeiro parâmetro,  enquanto que se for uma função (programação procedural) não é necessário

E quando se trata de um atributo da classe, se usa também o self, tal como o this do Java

 

Só não entendi onde você quer usar herança no código que postou

 

Seu código corrigido poderia fica assim (por exemplo):

class Calculadora():
    
    def __init__(self):
        self.__num1 = None
        self.__num2 = None

    def lerValores(self):
        self.__num1 = float(input('Digite um valor: '))
        self.__num2 = float(input('Digite outro valor: '))

    def adicao(self):
        soma = self.__num1 + self.__num2
        return soma

    def subtracao(self):
        sub = self.__num1 - self.__num2
        return sub

    def multiplicacao(self):
        mult = self.__num1 * self.__num2
        return mult

    def divisao(self):
        div = self.__num1 / self.__num2
        return div

    def calculate(self):
        operation = input("Entre com a operação a ser utilizada (+ - * /): ")
        return operation


if __name__ == '__main__':

    calculadora = Calculadora()

    while True:

        calculadora.lerValores()

        operation = calculadora.calculate()

        if operation == '+':
            r = calculadora.adicao()

        elif operation == '-':
            r = calculadora.subtracao()

        elif operation == '*':
            r = calculadora.multiplicacao()

        elif operation == '/':
            r = calculadora.divisao()
        else:
            print('Entrada inválida, tente novamente.')
            continue

        print('Resultado: %.2f' % r)

        opcao = input('Deseja continuar? [s/n]: ')

        if opcao == 'n':
            break

Veja se é isso que quer e qualquer dúvida é só perguntar, ok?

 

Obs: Não é obrigatório definir que explicitamente que uma classe herda de object, dessa forma:

class Veiculo(object):

Poderia ser assim:

class Veiculo():

Ou mesmo assim:

class Veiculo:

Só é importante cuidar da identação do seu código

 

Outro ponto, que eu sinceramente não gosto muito, é que é bastante comum se misturar programação orientada a objetos com programação procedural em Pyhton