Programação RPi Python 10: Python orientado a objetos

No tutorial anterioraprendemos sobre o sequências e coleções não ordenadas em Python, incluindo as operações, funções e métodos aplicáveis ​​a eles. Entretanto, pode haver estruturas de dados mais complexas em um aplicativo, conhecidas como classes e objetos definidos pelo usuário.

Qualquer aplicativo usa dados (valores/objetos/classes/objetos definidos pelo usuário) e comportamento de código (como os dados são manipulados).

Se um aplicativo for projetado de maneira que se concentre em:

  • Funcionalidade (comportamento do código) – é chamada de programação processual ou funcional
  • Dados (valores/objetos/objetos definidos pelo usuário) – é chamado de programação orientada a objetos

Embora Python seja uma linguagem de programação orientada a objetos, ela não força um aplicativo a ser definido por esse tipo de padrão de design. Isso significa que um aplicativo pode ser projetado em uma variedade de padrões, inclusive usando procedimentos e controle de visualização de modelo (MVC). Também é possível misturar vários padrões de design em um aplicativo.

Mas vale a pena explorar os recursos orientados a objetos do Python, pois ele é útil para criar estruturas de dados definidas pelo usuário e arquitetar determinados aplicativos com eficiência.

Aulas de Python
As classes são semelhantes a um projeto de objetos reais ou estruturas de dados. Assim, em qualquer aplicação, uma classe pode representar um objeto real ou uma estrutura de dados.

As propriedades da estrutura de objeto/dados são definidas como atributos da classe. Atributos são referências que podem conter objetos integrados ou definidos pelo usuário. Uma classe também pode ter funções que vinculam ou manipulam atributos associados a ela. Tais funções são chamadas de métodos.

Em Python, não há diferença entre atributos e métodos. Os métodos são tratados como atributos que podem ser chamados.

As classes Python também são objetos, que podem ser usados ​​como um tipo para criar outros objetos. Os tipos de dados em Python também são objetos, mas são usados ​​para definir o tipo de outros objetos. Quando um objeto de um determinado tipo de classe é criado, ele é chamado de instância ou objeto de instância dessa classe.

O objeto de instância possui todos os atributos (não solicitáveis ​​e solicitáveis) definidos para sua classe. Alguns atributos de um objeto herdado de sua classe podem ter valores de dados padrão. Esses atributos não solicitáveis ​​e solicitáveis ​​são chamados de descritores. Qualquer objeto pode ter atributos adicionais definidos.

Uma classe pode ser uma subclasse de outra classe, onde a classe pai é conhecida como superclasse. Assim como um objeto herda os atributos de sua classe, se sua classe for uma subclasse, ele herdará implicitamente os atributos de sua superclasse. Uma subclasse também herda implicitamente os atributos e métodos de sua superclasse.

A instrução class define as classes e é uma instrução composta com esta sintaxe:

classe className (classes base)
declarações)

O className pode ser qualquer identificador que sirva como referência para a classe. A definição de classe pode ter classes base como argumentos delimitados por vírgulas. As classes base são superclasses, onde essa classe é uma subclasse. As classes base são opcionais e só devem ser incluídas quando a classe definida for uma subclasse de outra classe.

Este é um exemplo ideal de uso de classes como objetos. Quando as classes base são passadas como argumentos, o Python as trata como objetos. As instruções incluídas na definição de uma classe são chamadas de corpo da classe.

Os atributos (não solicitáveis ​​ou solicitáveis) que se ligam a uma classe são chamados de atributos de classe. Esses atributos podem ser definidos dentro do corpo da classe e fora da definição da classe. Os atributos de classe são acessados ​​pela sintaxe class_name.attribute_name.

Aqui está um exemplo válido de definição de um atributo de classe dentro do corpo da classe:

classe C1 :
x = 25
imprimir (C1.x)

Agora, aqui está um exemplo válido de definição de um atributo de classe fora da definição de classe:

classe C1 :
passar
C1.x = 25
imprimir (C1.x)

As funções vinculadas a uma classe são chamadas de métodos. Mesmo que os atributos da classe sejam definidos no corpo da classe, ao usar as definições do método, eles devem ser referenciados na sintaxe class_name.attribute_name.

Este é um exemplo válido de método que acessa os atributos da classe:

classe C1 :
x = 25
defm :
C1.x +=1
imprimir (C1.x)

Quando um atributo é chamado e o identificador é usado como referência para esse atributo de classe, ou um método começa com dois sublinhados, o nome da classe com um sublinhado à esquerda é prefixado ao nome do atributo. Portanto, se um identificador __getData for chamado, o compilador Python alterará implicitamente o identificador para _className__getData.

Esses identificadores são chamados de nomes privados ou variáveis ​​privadas de classe. Isso torna privadas as referências aos atributos e métodos vinculados à classe e reduz qualquer chance de colisão com outras referências no código.

Uma classe também pode ter métodos especiais com dois sublinhados iniciais e dois finais como parte de um identificador usado para sua referência. Por exemplo, __init__, __get__, __set__ e __delete__ são métodos especiais que podem ser fornecidos por uma classe.

Esses métodos implícitos têm um propósito especial em qualquer classe e são chamados métodos dunder, métodos mágicos ou métodos especiais.

Alguns atributos de classe podem ter acesso gerenciado. Os valores dos dados podem ser vinculados, religados ou desvinculados a eles somente por meio dos métodos dunder. Semelhante à forma como eles podem se vincular aos valores/objetos de dados padrão no método __init__, eles podem:

  • Retorne seu valor apenas através do método __get__
  • Ter seu valor modificado somente através do método __set__
  • Pode ser excluído somente através do método __delete__.

Para inicializar, obter, definir ou excluir esses atributos, os métodos __init__, __get__, __set__ e __delete__ devem ser explicitamente definidos no corpo da classe com as instruções apropriadas.

Esses atributos são chamados de descritores. Se um descritor não tiver o método __set__ definido, seu valor não pode ser alterado. Esses descritores são chamados de descritores não-substitutivos ou não-dados. Se um descritor tiver o método __set__ definido, seu valor poderá ser alterado no código chamando o método __set__ para ele.

Os descritores com valor podem ser alterados e são chamados de descritores de substituição. Esses descritores não pode vincular, religar ou desvincular por meio de instruções de atribuição regulares.

Aqui está um exemplo válido de descritores:

classe C1 (objeto):
def __init__(self, valor):
self.value = valor
def __set__(self, *_):
passar
def __get__(self, *_):
retornar self.value
classe C2 (objeto):
c = C1(25)
x = C2 #instancia objeto da classe C2
print(xc) # Imprime 25
xc = 52
print(xc) # Ainda imprime 25

Instâncias de classe
Ao criar uma instância (objeto de instância) de uma classe, uma referência pode ser atribuída ao objeto de classe como uma função.

Este é um exemplo válido de criação de uma instância:

X = C1 #C1 é uma classe

Se o método __init__ for fornecido para uma classe, pode haver inicialização padrão dos atributos desse método. Quando uma instância é criada, quaisquer argumentos necessários devem ser passados ​​para a instanciação para cumprir a inicialização.

Aqui está um exemplo:

classe C1 (objeto):
def __init__(self, valor1, valor2):
self.a = valor1
self.b = valor2
y = C1(25, 34)
print(ya) #Prints 25
print(yb) #Impressões 34

Neste caso, o __init__ funciona como uma função construtora em outras linguagens orientadas a objetos. Uma instância também pode herdar o método __init__ da superclasse de sua classe. Se não houver nenhum método __init__ definido para a classe ou sua superclasse na instanciação, a classe deverá ser chamada sem argumentos.

Isso significa que não deve haver nenhum argumento específico da instância. Além disso, o método __init__ não pode retornar nenhum valor diferente de None. Uma instância pode ter seus próprios atributos que não foram definidos no corpo da classe ou para sua classe.

Também é possível criar uma instância atribuindo uma função a uma referência. Neste caso, a função deve retornar um objeto de classe. Tais funções são chamadas de funções de fábrica.

Herança
A herança é um recurso poderoso na programação orientada a objetos. Conforme discutimos, qualquer definição de classe pode ter classes base que são argumentos. Essa classe é então chamada de subclasse e a classe base é chamada de superclasse ou classe pai.

Uma subclasse herda implicitamente todos os atributos e métodos de sua classe base. Da mesma forma, uma instância de subclasse herda todos os atributos e métodos de sua classe, bem como da classe base de sua classe. Esse recurso de atributos e métodos herdados de um objeto pai é chamado de herança no paradigma orientado a objetos.

Uma classe pode ter múltiplas classes base. Como tal, herda os atributos e métodos de todas as classes base. Isso é chamado de heranças múltiplas. Também é possível que a classe base tenha outra classe base. Nesse caso, o objeto herda os atributos e métodos de sua classe base e da classe base de sua classe base. Isso é chamado de herança multinível.

No próximo tutorialabordaremos como projetar interfaces gráficas em Python.

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

Os comentários precisam ser aprovados antes da publicação.