Programação Orientada a Objetos no Python

在本文中，您将通过示例了解Python中的面向对象编程(OOP)及其基本概念。

Python OOP简介

Python是一种多范式编程语言。意思是说，它支持不同的编程方法。

解决编程问题的一种流行方法是创建对象。也就是所谓的面向对象编程（OOP）。

一个对象具有两个特征：

• 属性

• 行为

让我们举个示例：

鹦鹉是一个物体，

• 名称，年龄，颜色是属性

• 唱歌，跳舞都是行为

Python中的OOP概念专注于创建可重用的代码。此概念也称为DRY（Don't Repeat Yourself）不要重复自己。

在Python中，OOP的概念遵循一些基本原则：

类（class）

类是对象的蓝图。

我们可以将类看作是带有标签的鹦鹉的素描。它包含有关名称，颜色，大小等的所有详细信息。基于这些描述，我们可以研究鹦鹉。在这里，鹦鹉是一个对象。

鹦鹉类的示例可以是：

class Parrot:
　　　　pass

在这里，我们使用class关键字来定义一个空类Parrot。我们从类中构造示例。示例是由特定类创建的特定对象。

对象（Object）

对象（示例）是类的示例。定义类时，仅定义对象的描述。因此，没有分配内存或存储。

鹦鹉类对象的示例可以是：

obj = Parrot()

在这里，obj是Parrot类的对象。

假设我们有鹦鹉的详细信息。下面，我们将展示如何构建鹦鹉的类和对象。

Exemplo1：在Python中创建类和对象

class Parrot:
　　　　# 类属性
　　　　species = "bird"
　　　　# Atributos de exemplo
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
# Criação de exemplos da classe Parrot
blu = Parrot("Pomba",　10)
woo = Parrot("Papagaio",　15)
# Acesso aos atributos de classe
print("Pomba é {}".format(blu.__class__.species))
print("Papagaio também é {}".format(woo.__class__.species))
# Acesso aos atributos de exemplo
print("{} tem {} anos".format(blu.name, blu.age))
print("{} tem {} anos".format(woo.name, woo.age))

Quando executamos o programa, a saída será:

Pomba é pássaro
Papagaio também é pássaro
Pomba tem　10　anos
Papagaio tem　15　anos

No programa acima, criamos um objeto chamadoParrotclasse. Em seguida, definimos atributos. Atributos são características do objeto.

Em seguida, criamosParrotExemplo de classe. Aqui,bluewooé a referência (valor) do nosso novo objeto.

Em seguida, usamos class .species para acessar atributos de classe. Os atributos de classe de todos os exemplos da classe são os mesmos. Da mesma forma, usamos blu.name e blu.age para acessar atributos de exemplo. No entanto, para cada exemplo da classe, os atributos de exemplo são diferentes.

Para obter mais informações sobre classes e objetos, vá paraClasse e objeto Python.

Métodos

Métodos são funções definidas dentro do corpo da classe. Eles são usados para definir o comportamento dos objetos.

Exemplo2：Métodos de criação em Python

class Parrot:
　　　　
　　　　# Atributos de exemplo
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　
　　　　# Métodos de exemplo
　　　　def sing(self, song):
　　　　　　　　return "{} canta {}".format(self.name, song)
　　　　def dance(self):
　　　　　　　　return "{} está dançando".format(self.name)
# Criação do objeto de exemplo
blu = Parrot("Blu",　10)
# Chama nossos métodos de exemplo
print(blu.sing("'Happy'"))
print(blu.dance())

Quando executamos o programa, a saída será:

Blu canta 'Happy'
Blu está dançando

No programa acima, definimos dois métodos, ou seja, sing() e dance(). Eles são chamados de métodos de exemplo porque são chamados no objeto de exemplo (ou seja, blu).

Herança

Herança é um método para criar uma nova classe, usando-a sem modificar os detalhes da classe existente. A nova classe formada é uma classe derivada (ou subclasse). Da mesma forma, a classe existente é uma classe base (ou classe pai).

Exemplo3：Uso de herança em Python

# Clase base
class　Bird:
　　　　
　　　　def　__init__(self):
　　　　　　　　print("Pássaro está pronto")
　　　　def　whoisThis(self):
　　　　　　　　print("Pássaro")
　　　　def swim(self):
　　　　　　　　print("Nadando mais rápido")
# Subclasse
class　Penguin(Bird):
　　　　def　__init__(self):
　　　　　　　　# Chamar função super()
　　　　　　　　super().__init__()
　　　　　　　　print("Pinguim está pronto")
　　　　def　whoisThis(self):
　　　　　　　　print("Pinguim")
　　　　def　run(self):
　　　　　　　　print("Correndo mais rápido")
peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

Quando executamos o programa, a saída será:

Pássaro está pronto
Pinguim está pronto
Pinguim
Nadando mais rápido
Correndo mais rápido

No programa acima, criamos duas classes, ou sejaPássaro（Classe pai）ePenguin（Subclasse）。A subclasse herda as funcionalidades da classe pai. Podemos ver isso no método swim(). A subclasse novamente muda o comportamento da classe pai. Isso pode ser visto no método whoisThis(). Além disso, através da criação de um novo método run(), expandimos as funcionalidades da classe pai.

Além disso, usamos a função super() antes do método init(). Isso porque queremos trazer o conteúdo do método init() da classe pai para a classe filha.

Encapsulamento

Ao usar OOP em Python, podemos limitar o acesso a métodos e variáveis. Isso evita que os dados sejam modificados diretamente (conhecido como encapsulamento). Em Python, usamos sublinhado como prefixo para representar atributos privados, ou seja, um único "_" ou dois "__".

Exemplo4：Encapsulamento de dados em Python

class　Computer:
　　　　def　__init__(self):
　　　　　　　　self.__maxprice　=　900
　　　　def　sell(self):
　　　　　　　　print("Preço de venda:　{}".format(self.__maxprice))
　　　　def　setMaxPrice(self,　price):
　　　　　　　　self.__maxprice　=　price
c　=　Computer()
c.sell()
# Alterar preço
c.__maxprice　=　1000
c.sell()
# Usar função setter
c.setMaxPrice(1000)
c.sell()

Quando executamos o programa, a saída será:

Preço:　900
Preço:　900
Preço:　1000

No programa acima, definimosComputerClasse. Usamos o método __init__() para armazenar o preço mais alto do computador. Tentamos modificar o preço. No entanto, não podemos alterá-lo porque o Python__maxpriceconsiderada propriedade privada. Para alterar esse valor, usamos a função setter, ou seja, setMaxPrice(), que usa price como parâmetro.

Polimorfismo

Polimorfismo é uma funcionalidade (em OOP) que pode usar uma interface comum para várias formas (tipos de dados).

Suponha que precisemos pintar uma forma, há várias opções de forma (retângulo, quadrado, círculo). No entanto, podemos usar o mesmo método para pintar qualquer forma. Este conceito é chamado de polimorfismo.

Exemplo5：Uso de polimorfismo em Python

class Parrot:
　　　　def fly(self):
　　　　　　　　print("O papagaio voa")
　　　　
　　　　def swim(self):
　　　　　　　　print("O papagaio não pode nadar")
class Penguin:
　　　　def fly(self):
　　　　　　　　print("O pinguim não voa")
　　　　
　　　　def swim(self):
　　　　　　　　print("O pinguim pode nadar")
# Interface genérica
def flying_test(bird):
　　　　bird.fly()
# Exemplo
blu = Parrot()
peggy = Penguin()
# Passar objetos
flying_test(blu)
flying_test(peggy)

Quando executamos o programa acima, a saída será:

O papagaio voa
O pinguim não voa

No programa acima, definimos duas classesParrotePenguin. Cada um deles tem um método fly() genérico. No entanto, suas funções são diferentes. Para permitir a polimorfia, criamos uma interface genérica, ou seja, a função flying_test() pode aceitar qualquer função de objeto. Em seguida, passamosbluepeggyObjeto, que opera eficazmente.

Ponto principal da programação orientada a objetos:

• Torna a programação simples e eficaz.

• As classes são compartilháveis, portanto, o código pode ser reutilizado.

• Aumenta a produtividade dos programadores

• Através da abstração de dados, os dados são seguros.