Classes abstratas de Python – Acervo Lima Tutorials

Resumo : neste tutorial, você aprenderá sobre as classes abstratas do Python e como usá-las para criar um blueprint para outras classes.

Introdução às classes abstratas do Python

Na programação orientada a objetos, uma classe abstrata é uma classe que não pode ser instanciada. No entanto, você pode criar classes que herdam de uma classe abstrata.

Normalmente, você usa uma classe abstrata para criar um modelo para outras classes.

Da mesma forma, um método abstrato é um método sem implementação. Uma classe abstrata pode ou não incluir métodos abstratos.

Python não oferece suporte direto a classes abstratas. Mas oferece um módulo que permite definir classes abstratas.

Para definir uma classe abstrata, você usa o abcmódulo (classe base abstrata).

O abcmódulo fornece a infraestrutura para definir classes base abstratas.

Por exemplo:

from abc import ABC


class AbstractClassName(ABC):
    pass
Linguagem de código:  Python  ( python )

Para definir um método abstrato, você usa o @abstractmethoddecorador:

from abc import ABC, abstractmethod


class AbstractClassName(ABC):
    @abstractmethod
    def abstract_method_name(self):
        pass
Linguagem de código:  Python  ( python )

Exemplo de classe abstrata Python

Suponha que você precise desenvolver um programa de folha de pagamento para uma empresa.

A empresa possui dois grupos de funcionários: funcionários em tempo integral e funcionários horistas. Os funcionários em tempo integral recebem um salário fixo, enquanto os funcionários horistas são pagos por hora por seus serviços.

O programa de folha de pagamento precisa imprimir uma folha de pagamento que inclua os nomes dos funcionários e seus salários mensais.

Para modelar o programa de folha de pagamento de maneira orientada a objetos, você pode criar as seguintes classes: Employee, FulltimeEmployee, HourlyEmployee, e Payroll.

Para estruturar o programa, usaremos module , onde cada classe é colocada em um módulo (ou arquivo) separado.

A classe Funcionário

A Employeeclasse representa um funcionário, seja em tempo integral ou horista. A Employeeclasse deve ser uma classe abstrata porque existem apenas funcionários em tempo integral e funcionários horistas, não existem funcionários gerais.

A Employeeclasse deve ter uma propriedade que retorne o nome completo de um funcionário. Além disso, deveria ter um método que calculasse o salário. O método de cálculo do salário deve ser abstrato.

O seguinte define a Employeeclasse abstrata:

from abc import ABC, abstractmethod


class Employee(ABC):
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    @abstractmethod
    def get_salary(self):
        pass
Linguagem de código:  Python  ( python )

A classe FulltimeEmployee

A FulltimeEmployeeclasse herda da Employeeclasse. Ele fornecerá a implementação do get_salary()método.

Como os funcionários em tempo integral recebem salários fixos, você pode inicializar o salário no construtor da classe.

O seguinte ilustra a FulltimeEmployeeclasse:

class FulltimeEmployee(Employee):
    def __init__(self, first_name, last_name, salary):
        super().__init__(first_name, last_name)
        self.salary = salary

    def get_salary(self):
        return self.salary
Linguagem de código:  Python  ( python )

A classe HourlyEmployee

O HourlyEmployeetambém herda da Employeeclasse. No entanto, os funcionários horistas são pagos de acordo com as horas de trabalho e suas taxas. Portanto, você pode inicializar essas informações no construtor da classe.

Para calcular o salário dos horistas, você multiplica as horas de trabalho e as taxas.

O seguinte mostra a HourlyEmployeeclasse:

class HourlyEmployee(Employee):
    def __init__(self, first_name, last_name, worked_hours, rate):
        super().__init__(first_name, last_name)
        self.worked_hours = worked_hours
        self.rate = rate

    def get_salary(self):
        return self.worked_hours * self.rate
Linguagem de código:  Python  ( python )

A classe da folha de pagamento

A Payrollclasse terá um método que adiciona um funcionário à lista de funcionários e imprime a folha de pagamento.

Já que funcionários em tempo integral e horistas compartilham as mesmas interfaces ( full_timepropriedade e get_salary()método). Portanto, a classe Folha de Pagamento não precisa distingui-los.

O seguinte mostra a Payrollclasse:

class Payroll:
    def __init__(self):
        self.employee_list = []

    def add(self, employee):
        self.employee_list.append(employee)

    def print(self):
        for e in self.employee_list:
            print(f"{e.full_name} \t ${e.get_salary()}")
Linguagem de código:  Python  ( python )

O programa principal

A seguir app.pysão utilizadas as classes FulltimeEmployee, HourlyEmployeee Payrollpara imprimir a folha de pagamento de cinco funcionários.

from fulltimeemployee import FulltimeEmployee
from hourlyemployee import HourlyEmployee
from payroll import Payroll

payroll = Payroll()

payroll.add(FulltimeEmployee('John', 'Doe', 6000))
payroll.add(FulltimeEmployee('Jane', 'Doe', 6500))
payroll.add(HourlyEmployee('Jenifer', 'Smith', 200, 50))
payroll.add(HourlyEmployee('David', 'Wilson', 150, 100))
payroll.add(HourlyEmployee('Kevin', 'Miller', 100, 150))

payroll.print()Linguagem de código:  Python  ( python )

Saída:

John Doe         $6000
Jane Doe         $6500
Jenifer Smith    $10000
David Wilson     $15000
Kevin Miller     $15000Linguagem de código:  Python  ( python )

Quando usar classes abstratas

Na prática, você usa classes abstratas para compartilhar o código entre diversas classes intimamente relacionadas. No programa de folha de pagamento, todas as subclasses da Employeeclasse compartilham a mesma full_namepropriedade.

Resumo

Classes abstratas são classes das quais você não pode criar instâncias.
Use abcmódulo para definir classes abstratas.

Python __slots__

Protocolo Python