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 é a criação de objetos. Isso é conhecido como Programação Orientada a Objetos (OOP).
Um objeto tem duas características:
- atributos
- comportamento
Vamos dar um exemplo:
Um papagaio pode ser um objeto, pois tem as seguintes propriedades:
- nome, idade, cor como atributos
- cantando, dançando como comportamento
O conceito de OOP 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 OOP segue alguns princípios básicos:
Classe
Uma classe é um projeto para o objeto.
Podemos pensar na classe como o esboço de um papagaio com etiquetas. 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:
classe Parrot: pass
Aqui, usamos a classpalavra-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 classe particular.
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 de objeto da classe papagaio pode ser:
obj = papagaio ()
Aqui, obj é um objeto de 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))
Resultado
Blu é um pássaro Woo também é um pássaro Blu tem 10 anos Woo tem 15 anos
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 da classe Parrot. Aqui, blu e woo são referências (valor) para nossos novos objetos.
Podemos acessar o atributo de classe usando __class__.species. Os atributos de classe são iguais para todas as instâncias de uma classe. Da mesma forma, acessamos os atributos da instância usando blu.namee 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, vá para 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: Criação de 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())
Resultado
Blu canta 'Happy' Blu agora está dançando
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, isto é blu.
Herança
Inheritance is a way of creating a new class for using details of an existing class without modifying it. The newly formed class is a derived class (or child class). Similarly, the existing class is a base class (or parent class).
Example 3: Use of Inheritance in 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()
Output
Bird is ready Penguin is ready Penguin Swim faster Run faster
In the above program, we created two classes i.e. Bird (parent class) and Penguin (child class). The child class inherits the functions of parent class. We can see this from the swim() method.
Again, the child class modified the behavior of the parent class. We can see this from the whoisThis() method. Furthermore, we extend the functions of the parent class, by creating a new run() method.
Additionally, we use the super() function inside the __init__() method. This allows us to run the __init__() method of the parent class inside the child class.
Encapsulation
Using OOP in Python, we can restrict access to methods and variables. This prevents data from direct modification which is called encapsulation. In Python, we denote private attributes using underscore as the prefix i.e single _ or double __.
Example 4: Data Encapsulation in 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()
Output
Selling Price: 900 Selling Price: 900 Selling Price: 1000
In the above program, we defined a Computer class.
We used __init__() method to store the maximum selling price of Computer. We tried to modify the price. However, we can't change it because Python treats the __maxprice as private attributes.
As shown, to change the value, we have to use a setter function i.e setMaxPrice() which takes price as a parameter.
Polymorphism
Polymorphism is an ability (in OOP) to use a common interface for multiple forms (data types).
Suppose, we need to color a shape, there are multiple shape options (rectangle, square, circle). However we could use the same method to color any shape. This concept is called Polymorphism.
Example 5: Using Polymorphism in 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)
Output
Parrot can fly Penguin can't fly
In the above program, we defined two classes Parrot and Penguin. Each of them have a common fly() method. However, their functions are different.
Para usar o polimorfismo, criamos uma interface comum, ou seja, uma flying_test()função que pega qualquer objeto e chama o fly()método do objeto . Portanto, quando passamos os objetos blu e peggy na flying_test()função, ela funcionou com eficácia.
Pontos-chave a serem lembrados:
- A Programação Orientada a Objetos torna o programa fácil de entender e eficiente.
- Como a classe é compartilhável, o código pode ser reutilizado.
- Os dados estão seguros e protegidos com abstração de dados.
- O polimorfismo permite a mesma interface para objetos diferentes, para que os programadores possam escrever um código eficiente.
