Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> python

Programação Orientada a Objetos Python

Programação Orientada a Objetos em Python


Neste tutorial, você aprenderá sobre Programação Orientada a Objetos (OOP) em Python e seu conceito fundamental com a ajuda de exemplos.

Vídeo:programação orientada a objetos em Python

Programação Orientada a Objetos


Python é uma linguagem de programação multiparadigma. Ele suporta diferentes abordagens de programação.

Uma das abordagens populares para resolver um problema de programação é criando objetos. Isso é conhecido como Programação Orientada a Objetos (OOP).

Um objeto tem duas características:

Vamos dar um exemplo:

Um papagaio é um objeto, pois tem as seguintes propriedades:

O conceito de POO em Python se concentra na criação de código reutilizável. Este conceito também é conhecido como DRY (Don't Repeat Yourself).

Em Python, o conceito de POO segue alguns princípios básicos:

Classe


Uma classe é um modelo para o objeto.

Podemos pensar na aula como um esboço de um papagaio com rótulos. Ele contém todos os detalhes sobre o nome, cores, tamanho etc. Com base nessas descrições, podemos estudar sobre o papagaio. Aqui, um papagaio é um objeto.

O exemplo para classe de papagaio pode ser:
class Parrot:
    pass

Aqui, usamos o class palavra-chave para definir uma classe vazia Parrot . Da classe, construímos instâncias. Uma instância é um objeto específico criado a partir de uma determinada classe.

Objeto


Um objeto (instância) é uma instanciação de uma classe. Quando a classe é definida, apenas a descrição do objeto é definida. Portanto, nenhuma memória ou armazenamento é alocado.

O exemplo para objeto da classe papagaio pode ser:
obj = Parrot()

Aqui, obj é um objeto da classe Parrot .

Suponha que temos detalhes de papagaios. Agora, vamos mostrar como construir a classe e os objetos dos papagaios.

Exemplo 1:criando classe e objeto em Python

class Parrot:

    # class attribute
    species = "bird"

    # instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age

# instantiate the Parrot class
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)

# access the class attributes
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))

# access the instance attributes
print("{} is {} years old".format( blu.name, blu.age))
print("{} is {} years old".format( woo.name, woo.age))

Saída
Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old

No programa acima, criamos uma classe com o nome Parrot . Em seguida, definimos atributos. Os atributos são uma característica de um objeto.

Esses atributos são definidos dentro do __init__ método da classe. É o método inicializador que é executado pela primeira vez assim que o objeto é criado.

Em seguida, criamos instâncias do Parrot classe. Aqui, azul e uau são referências (valor) para nossos novos objetos.

Podemos acessar o atributo class usando __class__.species . Os atributos de classe são os mesmos para todas as instâncias de uma classe. Da mesma forma, acessamos os atributos da instância usando blu.name e blu.age . No entanto, os atributos de instância são diferentes para cada instância de uma classe.



Para saber mais sobre classes e objetos, acesse Python Classes and Objects

Métodos


Métodos são funções definidas dentro do corpo de uma classe. Eles são usados ​​para definir os comportamentos de um objeto.

Exemplo 2:Criando métodos em Python

class Parrot:
    
    # instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # instance method
    def sing(self, song):
        return "{} sings {}".format(self.name, song)

    def dance(self):
        return "{} is now dancing".format(self.name)

# instantiate the object
blu = Parrot("Blu", 10)

# call our instance methods
print(blu.sing("'Happy'"))
print(blu.dance())

Saída
Blu sings 'Happy'
Blu is now dancing

No programa acima, definimos dois métodos, ou seja, sing() e dance() . Eles são chamados de métodos de instância porque são chamados em um objeto de instância, ou seja, blu .

Herança


A herança é uma maneira de criar uma nova classe para usar detalhes de uma classe existente sem modificá-la. A classe recém-formada é uma classe derivada (ou classe filha). Da mesma forma, a classe existente é uma classe base (ou classe pai).

Exemplo 3:uso de herança em Python

# parent class
class Bird:
    
    def __init__(self):
        print("Bird is ready")

    def whoisThis(self):
        print("Bird")

    def swim(self):
        print("Swim faster")

# child class
class Penguin(Bird):

    def __init__(self):
        # call super() function
        super().__init__()
        print("Penguin is ready")

    def whoisThis(self):
        print("Penguin")

    def run(self):
        print("Run faster")

peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

Saída
Bird is ready
Penguin is ready
Penguin
Swim faster
Run faster

No programa acima, criamos duas classes, ou seja, Bird (classe pai) e Pinguim (classe infantil). A classe filha herda as funções da classe pai. Podemos ver isso no swim() método.

Novamente, a classe filha modificou o comportamento da classe pai. Podemos ver isso no whoisThis() método. Além disso, estendemos as funções da classe pai, criando um novo run() método.

Além disso, usamos o super() função dentro do __init__() método. Isso nos permite executar o __init__() método da classe pai dentro da classe filha.

Encapsulação


Usando OOP em Python, podemos restringir o acesso a métodos e variáveis. Isso evita que os dados sejam modificados diretamente, o que é chamado de encapsulamento. Em Python, denotamos atributos privados usando sublinhado como prefixo, ou seja, _ único ou duplo __ .

Exemplo 4:encapsulamento de dados em Python

class Computer:

    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print("Selling Price: {}".format(self.__maxprice))

    def setMaxPrice(self, price):
        self.__maxprice = price

c = Computer()
c.sell()

# change the price
c.__maxprice = 1000
c.sell()

# using setter function
c.setMaxPrice(1000)
c.sell()

Saída
Selling Price: 900
Selling Price: 900
Selling Price: 1000

No programa acima, definimos um Computador classe.

Usamos __init__() método para armazenar o preço máximo de venda de Computer . Aqui, observe o código
c.__maxprice = 1000

Aqui, tentamos modificar o valor de __maxprice fora da aula. No entanto, como __maxprice é uma variável privada, essa modificação não é vista na saída.

Como mostrado, para alterar o valor, temos que usar uma função setter, ou seja, setMaxPrice() que toma o preço como parâmetro.

Polimorfismo


Polimorfismo é uma habilidade (em OOP) de usar uma interface comum para vários formulários (tipos de dados).

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

Exemplo 5:usando polimorfismo em Python

class Parrot:

    def fly(self):
        print("Parrot can fly")
    
    def swim(self):
        print("Parrot can't swim")

class Penguin:

    def fly(self):
        print("Penguin can't fly")
    
    def swim(self):
        print("Penguin can swim")

# common interface
def flying_test(bird):
    bird.fly()

#instantiate objects
blu = Parrot()
peggy = Penguin()

# passing the object
flying_test(blu)
flying_test(peggy)

Saída
Parrot can fly
Penguin can't fly

No programa acima, definimos duas classes Parrot e Pinguim . Cada um deles tem um fly() comum método. No entanto, suas funções são diferentes.

Para usar o polimorfismo, criamos uma interface comum, ou seja, flying_test() função que recebe qualquer objeto e chama o fly() do objeto método. Assim, quando passamos pelo blu e peggy objetos no flying_test() função, ele funcionou de forma eficaz.

Pontos-chave a serem lembrados:


python

  1. Python - Strings
  2. Programação Orientada a Objetos Python
  3. Python Timeit() com exemplos
  4. Python List index() com exemplo
  5. Módulo de tempo Python
  6. Copiar arquivo em Python:método shutil.copy(), shutil.copystat()