Python POO

A programação orientada a objetos (OOP) é ​​a IKEA dos paradigmas de design. Lol. Isso é ridículo… mas um projeto é um projeto. A Ikea faz o trabalho. Qualquer pessoa, em qualquer lugar onde haja uma Ikea, pode comprar a mesma estante, montá-la (meh), pintá-la e enfeitá-la com o que quiser – livros, plantas, estatuetas de vidro. Mas ainda é a mesma estante. Ou uma escola poderia comprá-lo e colocar exatamente a mesma estante em cada sala de aula com o número exato de livros na mesma ordem. Se uma foto de cada estante fosse mostrada em uma fila, você não conseguiria perceber a diferença. E, claro, tudo o que está no meio. Isso é POO. Cada objeto possui os mesmos fundamentos com capacidade ilimitada de personalização.

A maneira mais voltada para o software de introduzir OOP: essa arquitetura organiza o código em torno de objetos. Os objetos incluem um estado que determina suas características e propriedades de valor. Os objetos executam comportamentos que podem alterar o próprio objeto ou o ambiente. Os princípios de design OOP auxiliam na modularidade e reutilização do código.

Programação Orientada a Objetos Python em estado selvagem

Uma imagem vale mais que 1.000 palavras e não precisamos ir muito longe para encontrar imagens detalhadas de OOP. As bibliotecas Python e Python usam OOP em todos os lugares. Se você escreve código Python ou está aprendendo Python, provavelmente já usa OOP em seu trabalho diário.

Se você digitar o seguinte código em um Jupyter Notebook (link de instalação):

my_list = ()
print(type(my_list))
dir(my_list)

uma lista de todos os métodos disponíveis e métodos dunder aparecerá. Os métodos dunder são denotados por __. Os métodos dunder são métodos especiais com nomes predefinidos que definem como os objetos de uma classe se comportam em resposta a determinadas operações. Os métodos regulares são funções definidas pelo usuário dentro de uma classe que são chamadas explicitamente. Ambos são passados ​​para cada lista criada em Python como resultado do paradigma de Programação Orientada a Objetos.

Isto é verdade para todas as estruturas de dados integradas e você encontrará um resultado semelhante para dicionários, conjuntos e outros.

Bibliotecas Externas

Você já trabalhou com a biblioteca GUI Tkinter do Python ou realizou análise de dados no Pandas? O import A instrução importa métodos e métodos dunder dessas bibliotecas. Ao escrever código usando essas bibliotecas, você personaliza sua estante Ikea.

Para ver isso em ação, instale o Pandas no Jupyter Notebook com !pip install pandas. Quando isso for concluído, a execução do código a seguir revelará todos os métodos e métodos dunder que vêm com a importação do Pandas.

import pandas as pd
dir(pd)

O básico

Para executar com sucesso um aplicativo usando a arquitetura OOP, você precisará construir objetos funcionais e bem pensados. Todos esses objetos começarão a partir de um projeto. Nem todos precisam começar com o mesmo projeto, mas o objetivo da OOP é que um projeto servirá a muitos objetos diferentes. Aqui estão algumas informações básicas que você precisará para construir qualquer projeto.

• Classe: Uma classe são as instruções, o próprio projeto. Tudo o que for passado para os objetos será incluído na classe (as instruções da Ikea que você esqueceu de ler antes de construir uma estante).ish item). Você pode definir uma classe adicionando a palavra-chave class antes da aula. Todos os nomes das classes têm letras maiúsculas.
• Atributos: Atributos são os detalhes associados à classe. Esses dados definem as características ou características dos objetos. Pense em variáveis. def__init__(self, attributes) inicializará os atributos.
• Métodos: Métodos são funções. As definições de métodos são iguais às definições de funções.
• Self: Self representa a instância da classe. Ele permite acessar variáveis, atributos e métodos de uma classe definida. A palavra-chave self pode ser renomeada.

A quantidade de atributos e métodos é insignificante, a sintaxe é o que importa neste exemplo.

class Example:
    def __init__(self, attribute_one, attribute_two):
        self.attribute_one = attribute_one  
        self.attribute_two = attribute_two

    def method_one(self):
        if self.attribute_one > self.attribute_two:
            return True
        else:
            return False

Para criar um objeto desta classe, que é chamado de instanciar uma instância desta classe, faremos o seguinte:

instantiated_object = Example(2, 8)

Para referenciar os atributos faremos o seguinte:

print(instantiated_object.attribute_one)
print(instantiated_object.attribute_two)

Se imprimirmos instantiated_object.self receberemos uma mensagem de erro.

instantiated_object.method_one() executa o método. Neste caso, ele retorna False.

Podemos refazer tudo isso com:

instantiated_object_two = Example(197, 18630) ou steve = Example(23, 78). Podemos continuar repetindo isso indefinidamente. Claro, existem objetos muito mais interessantes. Existem muitos casos de projetos idênticos personalizados exclusivamente. Perfis de mídia social (também conhecidos como Ikea virtual, se preferir) são um bom exemplo, sistemas de pedidos são outro. Mas nem todas as classes e instâncias terão a mesma aparência. Alguns projetos são apenas um ponto de partida. Para esses casos, temos…

Aulas para pais e filhos

Para isso, vamos primeiro pensar em um banco de dados de funcionários. Algumas informações são padrão, todo mundo tem nome, departamento e salário. Mas nem todo mundo tem subordinados diretos ou conhece uma linguagem de programação. É aqui que as aulas para pais e filhos são úteis. As classes filhas herdam todos os atributos da classe pai e podem transmitir seus próprios atributos quando instanciadas.

class Employee:
    def __init__(self, name, salary, department):
        self.name = name
        self.salary = salary
        self.department = department

    def employee_info(self):
        return f"{self.name}, Salary: ${self.salary}, Department: {self.department}"

Uma classe pai ainda é uma classe por si só. Podemos instanciar como faríamos com qualquer outra classe. O seguinte código

jenn = Employee("Jenn", 100000, "Sales")
jenn.employee_info()

produz estes resultados:

‘Jenn, Salário: $ 100.000, Departamento: Vendas’

Agora vamos falar dos gerentes. Os gerentes ainda são funcionários, mas os gerentes têm subordinados diretos e esta empresa exige que os gerentes participem de treinamentos trimestrais para gerentes. O Managera classe precisará ter critérios específicos que não precisam ser incluídos em todos os objetos. Como não queremos construir todos os Employee atributos de classe em um separado Manager classe (porque então teríamos que fazer isso para cada iteração disso), podemos criar o Manager classe como uma classe infantil com Employee como seu pai. Isso parecerá assim:

class Manager(Employee):
    def __init__ (self, name, salary, department, direct_reports, trainings_attended):
        super().__init__(name, salary, department)
        self.direct_reports = direct_reports
        self.trainings_attended = trainings_attended

    def add_direct_reports(self):
        self.direct_reports += 1

    def subtract_direct_reports(self):
        self.direct_reports -= 1
    
    def add_trainings_attended(self):
        self.trainings_attended += 1

    def manager_info(self):
        return f"Manager: {super().employee_info()}, Direct Reports: {self.direct_reports}, Trainings Attended: {self.trainings_attended}"

Você instanciará uma classe filha da mesma forma que faria com qualquer outra classe. lisa = Gerente(“Lisa”, 100000, “conteúdo”, 3, 4)`.

Uma coisa que você notará sobre esta classe filha: ainda temos atributos da classe funcionário escritos __init__ line antes de adicionarmos os novos atributos específicos da classe de gerenciador, como direct_reports’e trainings_attended. Você também verá diretamente na próxima linha que o Python usa super().__init__(). super().__init__()essencialmente aponta seu código para a lógica de inicialização definida na classe pai, que neste caso é o Employee aula. Portanto, mesmo que tenhamos que definir esse código no topo do objeto, não precisamos passar pelo trabalho de incluir também self.name = name na classe infantil.

Você também notará que temos quatro métodos, dois relacionados à adição e subtração de subordinados diretos, um para adição de treinamentos e outro para retornar todas as informações do gerente.

lisa.manager_info()

produz as seguintes informações:
‘Gerente: Lisa, Salário: $ 100.000, Departamento: conteúdo, Reportes diretos: 3, Treinamentos frequentados: 4’

Podemos ligar para o seguinte sempre que Lisa contratar alguém novo.

add.add_direct_reports()

lisa.direct_reports = 4 também terá o mesmo efeito.

Os desenvolvedores também trabalham nesta empresa. Esta empresa precisa de um conjunto diferente de detalhes de identificação para desenvolvedores. Por esse motivo, podemos construir outra classe filha do mesmo pai Employee aula.

class Developer(Employee):
    def __init__ (self, name, employee_id, salary, department, languages):
        super().__init__(name, employee_id, salary, department)
        self.languages = languages

    def add_language(self, new_language):
        self.languages.append(new_language)

    def employee_info(self):
        return f"Manager: {super().display_info()}, Languages: {', '.join(self.languages)}"

Podemos instanciar e verificar nosso novo objeto.

sarah = Developer("Sarah", 456, 100000, "engineering", ("SQL", "Python", "JavaScript"))
sarah.employee_info()

Próximo em Programação Orientada a Objetos Python

Há muito mais para aprender sobre este assunto. Este artigo apenas começa a arranhar a superfície. A programação orientada a objetos é um paradigma de design importante porque não apenas ajuda a manter o código modular e organizado, mas também porque exige uma execução cuidadosa. Se este é um tópico que você deseja continuar explorando, é hora de colocar as mãos em algum código. Pynative.com tem vários exercícios de Python. Aqui está um link para o curso de Programação Orientada a Objetos.

O post Python OOP apareceu pela primeira vez em The New Stack.