Programar é uma arte. E como na arte, selecionar os pincéis e tintas adequados é essencial para produzir os melhores trabalhos. A Programação Orientada a Objetos Python é uma dessas habilidades.
Escolher a linguagem de programação certa é uma parte crucial de qualquer projeto e pode levar a um desenvolvimento fluido e agradável ou a um pesadelo completo. Portanto, seria melhor se você usasse a linguagem mais adequada para o seu caso de uso.
Esse é o principal motivo para aprender programação orientada a objetos em Python, que também é uma das linguagens de programação mais populares.
Vamos aprender!
Um exemplo de programa Python
Antes de entrarmos no assunto, vamos fazer uma pergunta: você já escreveu um programa Python como o mostrado abaixo?
secret_number = 20
while True:
number = input('Guess the number: ')
try:
number = int(number)
except:
print('Sorry that is not a number')
continue
if number != secret_number:
if number > secret_number:
print(number, 'is greater than the secret number')
elif number < secret_number:
print(number, 'is less than the secret number')
else:
print('You guessed the number:', secret_number)
break
Este código é um adivinhador de número simples. Tente copiá-lo em um arquivo Python e executá-lo em seu sistema. Ele cumpre perfeitamente seu propósito.
Mas aí vem um grande problema: e se pedíssemos a você para implementar um novo recurso ? Pode ser algo simples - por exemplo:
“Se a entrada for um múltiplo do número secreto, dê uma dica ao usuário.”
O programa se tornaria complexo e pesado rapidamente à medida que você aumentasse o número de recursos e, portanto, o número total de condicionais aninhados.
Esse é precisamente o problema que a programação orientada a objetos tenta resolver.
Requisitos para aprender Python OOP
Antes de entrar na programação orientada a objetos, é altamente recomendável que você tenha um bom conhecimento dos fundamentos do Python.
Classificar tópicos considerados “básicos” pode ser difícil. Por causa disso, criamos uma folha de dicas com todos os principais conceitos necessários para aprender programação orientada a objetos em Python.
- Variável: nome simbólico que aponta para um objeto específico (veremos o que os objetos significam através do artigo).
- Operadores aritméticos: adição (+), subtração (-), multiplicação (*), divisão (/), divisão inteira (//), módulo (%).
- Tipos de dados embutidos: Numérico (inteiros, flutuantes, complexos), Sequências (strings, listas, tuplas), Booleano (Verdadeiro, Falso), Dicionários e Conjuntos.
- Expressões booleanas: expressões em que o resultado é verdadeiro ou falso.
- Condicional: avalia uma expressão booleana e realiza alguns processos dependendo do resultado. Gerenciado por instruções if / else .
- Loop: Execução repetida de blocos de código. Podem ser loops for ou while .
- Funções: Bloco de código organizado e reutilizável. Você os cria com a palavra-chave def .
- Argumentos: objetos passados para uma função. Por exemplo:
sum([1, 2, 4])
- Execute um script Python : abra um terminal ou linha de comando e digite “python <nome do arquivo>.”
- Abra um Python Shell : Abra um terminal e digite
pythonoupython3dependendo do seu sistema.
Agora que você tem esses conceitos claros como cristal, pode avançar no entendimento da programação orientada a objetos.
O que é programação orientada a objetos em Python?
A Programação Orientada a Objetos (OOP) é um paradigma de programação no qual podemos pensar em problemas complexos como objetos.
Um paradigma é uma teoria que fornece a base para a solução de problemas.
Portanto, quando estamos falando sobre OOP, estamos nos referindo a um conjunto de conceitos e padrões que usamos para resolver problemas com objetos.
Um objeto em Python é uma coleção única de dados (atributos) e comportamento (métodos). Você pode pensar em objetos como coisas reais ao seu redor. Por exemplo, considere calculadoras:
Uma calculadora pode ser um objeto.
Como você pode notar, os dados (atributos) são sempre substantivos, enquanto os comportamentos (método) são sempre verbos.
Essa compartimentação é o conceito central da Programação Orientada a Objetos. Você constrói objetos que armazenam dados e contêm tipos específicos de funcionalidade.
Por que usamos programação orientada a objetos em Python?
OOP permite que você crie software seguro e confiável. Muitos frameworks e bibliotecas Python usam esse paradigma para construir sua base de código. Alguns exemplos são Django, Kivy, pandas, NumPy e TensorFlow.
Vamos ver as principais vantagens de usar OOP em Python.
Vantagens do Python OOP
Os motivos a seguir farão com que você opte por usar a programação orientada a objetos em Python.
Todas as linguagens de programação modernas usam OOP
Este paradigma independe da linguagem. Se você aprender OOP em Python, poderá usá-lo da seguinte forma:
- Java
- PHP (certifique-se de ler a comparação entre PHP e Python )
- Rubi
- Javascript
- C #
- Kotlin
Todas essas linguagens são nativamente orientadas a objetos ou incluem opções para funcionalidade orientada a objetos. Se você quiser aprender qualquer um deles depois do Python, será mais fácil - você encontrará muitas semelhanças entre as linguagens que trabalham com objetos.
OOP permite que você codifique mais rápido
Codificar mais rápido não significa escrever menos linhas de código. Isso significa que você pode implementar mais recursos em menos tempo sem comprometer a estabilidade de um projeto.
A programação orientada a objetos permite que você reutilize o código implementando a abstração . Este princípio torna seu código mais conciso e legível.
Como você deve saber, os programadores passam muito mais tempo lendo código do que escrevendo. É a razão pela qual a legibilidade é sempre mais importante do que liberar recursos o mais rápido possível.
A produtividade diminui com código ilegível
Você verá mais sobre o princípio de abstração posteriormente.
OOP ajuda você a evitar o código espaguete
Você se lembra do programa adivinhador de números no início deste artigo?
Se você continuar adicionando recursos, terá muitas instruções if aninhadas no futuro. Esse emaranhado de linhas infinitas de código é chamado de código espaguete e você deve evitá-lo o máximo possível.
OOP nos dá a possibilidade de comprimir toda a lógica em objetos, evitando longos pedaços de aninhados se de .
OOP melhora sua análise de qualquer situação
Depois de obter alguma experiência com OOP, você será capaz de pensar nos problemas como objetos pequenos e específicos.
Esse entendimento leva a uma inicialização rápida do projeto.
Programação Estruturada versus Programação Orientada a Objetos
A programação estruturada é o paradigma mais usado por iniciantes porque é a maneira mais simples de construir um pequeno programa.
Envolve a execução de um programa Python sequencialmente. Isso significa que você está dando ao computador uma lista de tarefas e, em seguida, executando-as de cima para baixo.
Vejamos um exemplo de programação estruturada com um programa de cafeteria.
small = 2
regular = 5
big = 6
user_budget = input('What is your budget? ')
try:
user_budget = int(user_budget)
except:
print('Please enter a number')
exit()
if user_budget > 0:
if user_budget >= big:
print('You can afford the big coffee')
if user_budget == big:
print('It\'s complete')
else:
print('Your change is', user_budget - big)
elif user_budget == regular:
print('You can afford the regular coffee')
print('It\'s complete')
elif user_budget >= small:
print('You can buy the small coffee')
if user_budget == small:
print('It\'s complete')
else:
print('Your change is', user_budget - small)
O código acima atua como um vendedor de cafeteria. Ele pedirá um orçamento e, em seguida, “venderá” o maior café que você for capaz de comprar.
Tente executá-lo no terminal . Ele será executado passo a passo, dependendo de sua entrada.
Este código funciona perfeitamente, mas temos três problemas:
- Tem muita lógica repetida.
- Ele usa muitos condicionais aninhados se .
- Vai ser difícil ler e modificar.
OOP foi inventado como uma solução para todos esses problemas.
Vamos ver o programa acima implementado com OOP. Não se preocupe se você ainda não entendeu. É apenas para comparar a programação estruturada e a programação orientada a objetos.
class Coffee:
# Constructor
def __init__(self, name, price):
self.name = name
self.price = float(price)
def check_budget(self, budget):
# Check if the budget is valid
if not isinstance(budget, (int, float)):
print('Enter float or int')
exit()
if budget < 0:
print('Sorry you don\'t have money')
exit()
def get_change(self, budget):
return budget - self.price
def sell(self, budget):
self.check_budget(budget)
if budget >= self.price:
print(f'You can buy the {self.name} coffee')
if budget == self.price:
print('It\'s complete')
else:
print(f'Here is your change {self.get_change(budget)}$')
exit('Thanks for your transaction')
Nota: Todos os conceitos a seguir serão explicados mais profundamente ao longo do artigo.
O código acima representa uma classe chamada “Coffee”. Possui dois atributos - “nome” e “preço” - e ambos são usados nos métodos. O método principal é “vender”, que processa toda a lógica necessária para concluir o processo de venda.
Se você tentar executar essa classe, não obterá nenhuma saída. Isso ocorre principalmente porque estamos apenas declarando o “modelo” para os cafés, não os próprios cafés.
Vamos implementar essa classe com o seguinte código:
small = Coffee('Small', 2)
regular = Coffee('Regular', 5)
big = Coffee('Big', 6)
try:
user_budget = float(input('What is your budget? '))
except ValueError:
exit('Please enter a number')
for coffee in [big, regular, small]:
coffee.sell(user_budget)
Aqui estamos criando instâncias, ou objetos de café, da classe “Café” e, em seguida, chamando o método de “venda” de cada café até que o usuário possa pagar por qualquer opção.
Obteremos a mesma saída com ambas as abordagens, mas podemos estender a funcionalidade do programa muito melhor com OOP.
Abaixo está uma tabela que compara a programação orientada a objetos e a programação estruturada:
| OOP | Programação Estruturada |
| Mais fácil de manter | Difícil de manter |
| Abordagem de Don't Repeat Yourself (DRY) | Código repetido em muitos lugares |
| Pequenos pedaços de código reutilizados em muitos lugares | Uma grande quantidade de código em poucos lugares |
| Abordagem de objeto | Abordagem de código de bloco |
| Mais fácil de depurar | Mais difícil de depurar |
| Grande curva de aprendizado | Curva de aprendizado mais simples |
| Usado em grandes projetos | Otimizado para programas simples |
Para concluir a comparação do paradigma:
- Nenhum dos paradigmas é perfeito (OOP pode ser opressor de usar em projetos simples).
- Essas são apenas duas maneiras de resolver um problema; existem outros lá fora.
- OOP é usado em grandes bases de código, enquanto a programação estruturada é principalmente para projetos simples.
Vamos prosseguir para os objetos integrados em Python.
Tudo é um objeto em Python
Vamos lhe contar um segredo: você tem usado OOP o tempo todo sem perceber.
Mesmo ao usar outros paradigmas em Python, você ainda usa objetos para fazer quase tudo.
Isso porque, em Python, tudo é um objeto.
Lembre-se da definição de objeto: um objeto em Python é uma coleção única de dados (atributos) e comportamento (métodos).
Isso corresponde a qualquer tipo de dados em Python.
Uma string é uma coleção de dados (caracteres) e comportamentos ( superior () , inferior () , etc.). O mesmo se aplica a inteiros , flutuantes , booleanos , listas e dicionários.
Antes de continuar, vamos revisar o significado dos atributos e métodos.
Atributos e métodos
Atributos são variáveis internas dentro de objetos, enquanto métodos são funções que produzem algum comportamento.
Vamos fazer um exercício simples no shell Python. Você pode abri-lo digitando pythonou python3em seu terminal.
Shell Python
Agora, vamos trabalhar com o shell Python para descobrir métodos e tipos.
>>> kinsta = 'Kinsta, Premium WordPress hosting'
>>> kinsta.upper()
'KINSTA, PREMIUM WORDPRESS HOSTING'
Na segunda linha, estamos chamando um método de string, upper () . Ele retorna o conteúdo da string em maiúsculas. No entanto, isso não altera a variável original.
>>> kinsta
'Kinsta, Premium WordPress hosting'
Vamos nos aprofundar em funções valiosas ao trabalhar com objetos.
A função type () permite que você obtenha o tipo de um objeto. O “tipo” é a classe à qual o objeto pertence.
>>> type(kinsta)
# class 'str'
A função dir () retorna todos os atributos e métodos de um objeto. Vamos testar com a variável kinsta .
>>> dir(kinsta)
['__add__', '__class__', ........... 'upper', 'zfill']
Agora, tente imprimir alguns dos atributos ocultos deste objeto.
>>> kinsta.__class__ # class ‘str’ e>Isso irá gerar a classe à qual o objeto kinsta pertence. Portanto, podemos dizer que a única coisa que a função de tipo retorna é o atributo __class__ de um objeto.
Você pode experimentar todos os tipos de dados, descobrindo todos os seus atributos e métodos diretamente no terminal. Você pode aprender mais sobre os tipos de dados integrados na documentação oficial .
Seu primeiro objeto em Python
Uma classe é como um modelo . Ele permite que você crie objetos personalizados com base nos atributos e métodos que você define.
Você pode pensar nele como um cortador de biscoitos que você modifica para assar os biscoitos perfeitos (objetos, não cookies de rastreamento ), com características definidas: forma, tamanho e muito mais.
Por outro lado, temos instâncias. Uma instância é um objeto individual de uma classe, que possui um endereço de memória exclusivo.
Instâncias em Python
Agora que você sabe o que são classes e instâncias, vamos definir algumas!
Para definir uma classe em Python, você usa a palavra-chave class , seguida de seu nome. Nesse caso, você criará uma classe chamada Cookie .
Nota: Em Python, usamos a convenção de nomes de maiúsculas e minúsculas para nomear classes.
class Cookie:
pass
Abra seu shell Python e digite o código acima. Para criar uma instância de uma classe, basta digitar seu nome e parênteses a seguir. É o mesmo processo de invocar uma função.
cookie1 = Cookie()
Parabéns - você acabou de criar seu primeiro objeto em Python! Você pode verificar seu id e tipo com o seguinte código:
id(cookie1)
140130610977040 # Unique identifier of the object
type(cookie1)
<class '__main__.Cookie'>
Como você pode ver, esse cookie possui um identificador único na memória e seu tipo é Cookie .
Você também pode verificar se um objeto é uma instância de uma classe com a função isinstance () .
isinstance(cookie1, Cookie)
# True
isinstance(cookie1, int)
# False
isinstance('a string', Cookie)
# False
Método do Construtor
O método __init __ () também é chamado de “construtor”. É chamado de Python cada vez que instanciamos um objeto.
O construtor cria o estado inicial do objeto com o conjunto mínimo de parâmetros de que ele precisa para existir. Vamos modificar a classe Cookie , para que aceite parâmetros em seu construtor.
class Cookie:
# Constructor
def __init__(self, name, shape, chips='Chocolate'):
# Instance attributes
self.name = name
self.shape = shape
self.chips = chips
Na classe Cookie , cada cookie deve ter um nome, forma e chips. Definimos o último como “Chocolate”.
Por outro lado, self se refere à instância da classe (o próprio objeto).
Tente colar a classe no shell e criar uma instância do cookie como de costume.
cookie2 = Cookie()
# TypeError
Você obterá um erro. Isso porque você deve fornecer o conjunto mínimo de dados de que o objeto precisa para viver - neste caso, nome e forma, uma vez que já definimos chips como “Chocolate”.
cookie2 = Cookie('Awesome cookie', 'Star')
Para acessar os atributos de uma instância, você deve usar a notação de ponto.
cookie2.name
# 'Awesome cookie'
cookie2.shape
# 'Star'
cookie2.chips
# 'Chocolate'
Por enquanto, a classe Cookie não tem nada muito suculento. Vamos adicionar um método de amostra bake () para tornar as coisas mais interessantes.
class Cookie:
# Constructor
def __init__(self, name, shape, chips='Chocolate'):
# Instance attributes
self.name = name
self.shape = shape
self.chips = chips
# The object is passing itself as a parameter
def bake(self):
print(f'This {self.name}, is being baked with the shape {self.shape} and chips of {self.chips}')
print('Enjoy your cookie!')
Para chamar um método, use a notação de ponto e chame-o como uma função.
cookie3 = Cookie('Baked cookie', 'Tree')
cookie3.bake()
# This Baked cookie, is being baked with the shape Tree and chips of Chocolate
Enjoy your cookie!
Os 4 pilares da OOP em Python
A Programação Orientada a Objetos inclui quatro pilares principais:
1. Abstração
A abstração oculta a funcionalidade interna de um aplicativo do usuário. O usuário pode ser o cliente final ou outros desenvolvedores.
Podemos encontrar abstração em nossa vida diária. Por exemplo, você sabe como usar seu telefone, mas provavelmente não sabe exatamente o que está acontecendo dentro dele cada vez que abre um aplicativo.
Precisa de uma solução de hospedagem que ofereça vantagem competitiva? O Kinsta oferece a você uma velocidade incrível, segurança de última geração e escalonamento automático. Confira nossos planos
Outro exemplo é o próprio Python. Você sabe como usá-lo para construir um software funcional e pode fazê-lo mesmo que não entenda o funcionamento interno do Python.
Aplicar o mesmo ao código permite que você colete todos os objetos em um problema e abstraia funcionalidade padrão em classes.
2. Herança
A herança nos permite definir várias subclasses de uma classe já definida.
O objetivo principal é seguir o princípio SECO . Você será capaz de reutilizar muito código implementando todos os componentes de compartilhamento em superclasses .
Você pode pensar nisso como o conceito da vida real de herança genética . Crianças (subclasses) são o resultado da herança entre dois pais (superclasses). Eles herdam todas as características físicas (atributos) e alguns comportamentos comuns (métodos).
3. Polimorfismo
O polimorfismo nos permite modificar ligeiramente os métodos e atributos das subclasses previamente definidas na superclasse .
O significado literal é " muitas formas ". Isso porque construímos métodos com o mesmo nome, mas com funcionalidades diferentes.
Voltando à ideia anterior, as crianças também são um exemplo perfeito de polimorfismo. Eles podem herdar um comportamento definido get_hungry () mas de uma maneira ligeiramente diferente, por exemplo, ficando com fome a cada 4 horas em vez de 6.
4. Encapsulamento
Encapsulamento é o processo pelo qual protegemos a integridade interna dos dados em uma classe.
Embora não haja uma instrução privada no Python, você pode aplicar o encapsulamento usando mangling no Python . Existem métodos especiais chamados getters e setters que nos permitem acessar atributos e métodos exclusivos.
Vamos imaginar uma classe Humana que tem um atributo único chamado _height . Você pode modificar este atributo apenas dentro de certas restrições (é quase impossível ser superior a 3 metros).
Construir uma Calculadora de Resolvedor de Forma de Área
Uma das melhores coisas sobre Python é que ele nos permite criar uma ampla variedade de software, de um programa CLI (interface de linha de comando) a um aplicativo da web complexo.
Agora que você aprendeu os conceitos básicos da OOP, é hora de aplicá-los a um projeto real.
Observação: todos os códigos a seguir estarão disponíveis neste repositório GitHub . Uma ferramenta de revisão de código que nos ajuda a gerenciar versões de código com Git.
Sua tarefa é criar uma calculadora de área com as seguintes formas:
- Quadrado
- Retângulo
- Triângulo
- Círculo
- Hexágono
Classe Base da Forma
Em primeiro lugar, crie um arquivo calculator.py e abra-o. Como já temos os objetos com os quais trabalhar, será fácil abstraí- los em uma classe.
Você pode analisar as características comuns e descobrir que todas essas são formas 2D . Portanto, a melhor opção é criar uma classe Shape com um método get_area () do qual cada forma herdará.
Nota: todos os métodos devem ser verbos. Isso porque esse método é denominado get_area () e não area () .
class Shape:
def __init__(self):
pass
def get_area(self):
pass
O código acima define a classe; no entanto, ainda não há nada de interessante nisso.
Vamos implementar a funcionalidade padrão da maioria dessas formas.
class Shape:
def __init__(self, side1, side2):
self.side1 = side1
self.side2 = side2
def get_area(self):
return self.side1 * self.side2
def __str__(self):
return f'The area of this {self.__class__.__name__} is: {self.get_area()}'
Vamos detalhar o que estamos fazendo com este código:
- No método __init__ , estamos solicitando dois parâmetros, side1 e side2 . Eles permanecerão como atributos de instância .
- A função get_area () retorna a área da forma. Neste caso, está usando a fórmula da área de um retângulo, pois será mais fácil de implementar com outras formas.
- O método __str __ () é um “método mágico” assim como __init __ (). Ele permite que você modifique a maneira como uma instância será impressa.
- O atributo oculto self .__ class __.__ name__ refere-se ao nome da classe. Se você estivesse trabalhando com uma classe Triângulo , esse atributo seria “Triângulo”.
Classe Retângulo
Como implementamos a fórmula da área do Rectangle, poderíamos criar uma classe Rectangle simples que não faz nada além de herdar da classe Shape .
Para aplicar a herança em Python, você criará uma classe como de costume e colocará a superclasse da qual deseja herdar entre parênteses.
# Folded base class
class Shape: ...
class Rectangle(Shape): # Superclass in Parenthesis
pass
Classe Square
Podemos fazer uma abordagem excelente do polimorfismo com a classe Square .
Lembre-se de que um quadrado é apenas um retângulo cujos quatro lados são todos iguais. Isso significa que podemos usar a mesma fórmula para obter a área.
Podemos fazer isso modificando o método init , aceitando apenas um lado como parâmetro e passando esse valor lateral para o construtor da classe Rectangle .
# Folded classes
class Shape: ...
class Rectangle(Shape): ...
class Square(Rectangle):
def __init__(self, side):
super().__init__(side, side)
Como você pode ver, a função super passa o parâmetro lateral duas vezes para a superclasse . Em outras palavras, ele está passando lado como lado1 e lado2 para o construtor definido anteriormente.
Classe Triângulo
Um triângulo tem metade do tamanho do retângulo que o rodeia.
Relação entre triângulos e retângulos (fonte da imagem: tutores do time do colégio).
Portanto, podemos herdar da classe Rectangle e modificar o método get_area para corresponder à fórmula da área do triângulo, que é a metade da base multiplicada pela altura.
# Folded classes
class Shape: ...
class Rectangle(Shape): ...
class Square(Rectangle): ...
class Triangle(Rectangle):
def __init__(self, base, height):
super().__init__(base, height)
def get_area(self):
area = super().get_area()
return area / 2
Outro caso de uso da função super () é chamar um método definido na superclasse e armazenar o resultado como uma variável. Isso é o que está acontecendo dentro do método get_area () .
Classe de Círculo
Você pode encontrar a área do círculo com a fórmula πr² , onde r é o raio do círculo. Isso significa que temos que modificar o método get_area () para implementar essa fórmula.
Nota: podemos importar o valor aproximado de π do módulo matemático
# Folded classes
class Shape: ...
class Rectangle(Shape): ...
class Square(Rectangle): ...
class Triangle(Rectangle): …
# At the start of the file
from math import pi
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def get_area(self):
return pi * (self.radius ** 2)
O código acima define a classe Circle , que usa um construtor diferente e get_area () métodos .
Embora Circle herde da classe Shape , você pode redefinir cada método e atribuí-lo ao seu gosto.
Classe regular do hexágono
Precisamos apenas do comprimento de um lado de um hexágono regular para calcular sua área. É semelhante à classe Square , onde apenas passamos um argumento para o construtor.
Fórmula da área do hexágono (fonte da imagem: BYJU'S)
No entanto, a fórmula é bem diferente e implica o uso de uma raiz quadrada. É por isso que você usará a função sqrt () do módulo matemático.
# Folded classes
class Shape: ...
class Rectangle(Shape): ...
class Square(Rectangle): ...
class Triangle(Rectangle): …
class Circle(Shape): …
# Import square root
from math import sqrt
class Hexagon(Rectangle):
def get_area(self):
return (3 * sqrt(3) * self.side1 ** 2) / 2
Testando Nossas Classes
Você pode entrar em um modo interativo ao executar um arquivo Python usando um depurador. A maneira mais simples de fazer isso é usando a função de ponto de interrupção embutida.
Observação: esta função está disponível apenas no Python 3.7 ou mais recente.
from math import pi, sqrt
# Folded classes
class Shape: ...
class Rectangle(Shape): ...
class Square(Rectangle): ...
class Triangle(Rectangle): …
class Circle(Shape): …
class Hexagon(Rectangle): …
breakpoint()
Agora, execute o arquivo Python e brinque com as classes que você criou.
$ python calculator.py
(Pdb) rec = Rectangle(1, 2)(Pdb) print(rec)
The area of this Rectangle is: 2
(Pdb) sqr = Square(4)
(Pdb) print(sqr)
The area of this Square is: 16
(Pdb) tri = Triangle(2, 3)
(Pdb) print(tri)
The area of this Triangle is: 3.0
(Pdb) cir = Circle(4)
(Pdb) print(cir)
The area of this Circle is: 50.26548245743669
(Pdb) hex = Hexagon(3)
(Pdb) print(hex)
The area of this Hexagon is: 23.382685902179844
Desafio
Crie uma classe com um método executado onde o usuário pode escolher uma forma e calcular sua área.
Quando tiver concluído o desafio, você pode enviar uma solicitação pull para o repositório GitHub ou publicar sua solução na seção de comentários.
Resumo
A programação orientada a objetos é um paradigma no qual resolvemos problemas pensando neles como objetos . Se você entende Python OOP, também pode aplicá-lo facilmente em linguagens como Java , PHP , Javascript e C # .
Neste artigo, você aprendeu sobre:
- O conceito de orientação a objetos em Python
- Vantagens da programação orientada a objetos em relação à programação estruturada
- Noções básicas de programação orientada a objetos em Python
- Conceito de classes e como usá-las em Python
- O construtor de uma classe em Python
- Métodos e atributos em Python
- Os quatro pilares da OOP
- Implementando abstração , herança e polimorfismo em um projeto
Agora é com você!
Deixe-nos saber sua solução para o desafio abaixo nos comentários! E não se esqueça de verificar nosso guia de comparação entre Python e PHP .
Economize tempo, custos e maximize o desempenho do site com:
- Ajuda instantânea de especialistas em hospedagem do WordPress, 24 horas por dia, 7 dias por semana.
- Integração Cloudflare Enterprise.
- Alcance de público global com 28 data centers em todo o mundo.
- Otimização com nosso monitoramento de desempenho de aplicativos integrado.
Tudo isso e muito mais, em um único plano, sem contratos de longo prazo, migrações assistidas e garantia de devolução do dinheiro em 30 dias. Confira nossos planos ou fale com o departamento de vendas para encontrar o plano certo para você.