12. As classes e os objetos
A classe é o molde a partir do qual os objetos são criados. Diz-se que o objeto é uma instância de uma classe.
Observação: a pasta [shared] foi colocada na pasta [Sources Root] do projeto.
12.1. script [classes_01]: uma classe Objeto
O script [classes_01] mostra um uso obsoleto das classes:
# uma classe
class Objet(object):
"""une classe Objet vide"""
# qualquer variável do tipo [Objet] pode ter atributos por definição
obj1 = Objet()
obj1.attr1 = "un"
obj1.attr2 = 100
# exibe o objeto
print(f"objet1=[{obj1}, {type(obj1)},{id(obj1)},{obj1.attr1},{obj1.attr2}]")
# altera o objeto
obj1.attr2 += 100
# exibe o objeto
print(f"objet1=[{obj1.attr1},{obj1.attr2}]")
# atribui a referência obj1 a obj2
obj2 = obj1
# altera o objeto apontado por obj2
obj2.attr2 = 0
# exibe os dois objetos — obj1 agora aponta para um objeto modificado
print(f"objet1=[{obj1.attr1},{obj1.attr2}]")
print(f"objet2=[{obj2.attr1},{obj2.attr2}]")
# obj1 e obj2 apontam para o mesmo objeto
print(f"objet1=[{obj1}, {id(obj1)},{obj1.attr1},{obj1.attr2}]")
print(f"objet2=[{obj2}, {id(obj2)},{obj2.attr1},{obj2.attr2}]")
print(obj1 == obj2)
# tipo da instância obj1
print(f"type(obj1)={type(obj1)}")
print(f"isinstance(obj1,Objet)={isinstance(obj1, Objet)}, isinstance(obj1,object)={isinstance(obj1, object)}")
# todo tipo é um objeto em Python
print(f"type(4)={type(4)}")
print(f"isinstance(4, int)={isinstance(4, int)}, isinstance(4, object)={isinstance(4, object)}")
Notas:
- linhas 2-3: uma classe [Objet] vazia;
- linha 2: a classe pode ser declarada de três formas:
- class Objet;
- class Objeto();
- class Objet(object);
- linha 3: outra forma de comentário. Este, precedido por três “”, pode se estender por várias linhas;
- linha 7: instanciação da classe Objet. O resultado é um endereço, conforme mostrado nas linhas 24 a 26;
- linhas 8-9: inicialização direta de dois atributos do objeto;
- linha 17: cópia de referências. As variáveis obj1 e obj2 são dois ponteiros (referências) para o mesmo objeto;
- linha 19: modifica-se o objeto apontado por [obj2]. Como [obj1] e [obj2] apontam para o mesmo objeto, as exibições dos objetos [obj1, obj2] nas linhas 21 e 22 mostrarão que o objeto apontado por [obj1] foi alterado;
- linhas 24-26: essas linhas têm como objetivo mostrar a igualdade entre as variáveis [obj1] e [obj2]. A exibição da linha 26 irá demonstrar isso. Nessa comparação, são os endereços [obj1] e [obj2] que são iguais;
- cada objeto Python é identificado por um número único, obtido com a expressão [id(objet)]. As linhas 24 e 25 mostrarão que os números dos objetos aos quais apontam [obj1] e [obj2] são idênticos, demonstrando, assim, que essas duas referências apontam para o mesmo objeto;
- linhas 27-29: a função [isinstance(expr,Type)] retorna o valor booleano True se a expressão [expr] for do tipo [Type]. Aqui, veremos que [obj1] é do tipo [Objet], o que parece natural, mas também é do tipo [object]. A classe [object] é a classe pai de todas as classes Python. Por propriedade da herança de classes, uma classe filha F possui todas as propriedades de sua classe pai P, e a função [isinstance(instance de F, P)] retorna True;
- linhas 30-32: mostram que o tipo [int] também é um tipo [object]. Todos os tipos do Python derivam da classe [object];
Resultados
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/classes/01/classes_01.py
objet1=[<__main__.Objet object at 0x0000025C3F469BB0>, <class '__main__.Objet'>,2595221838768,un,100]
objet1=[un,200]
objet1=[un,0]
objet2=[un,0]
objet1=[<__main__.Objet object at 0x0000025C3F469BB0>, 2595221838768,un,0]
objet2=[<__main__.Objet object at 0x0000025C3F469BB0>, 2595221838768,un,0]
True
type(obj1)=<class '__main__.Objet'>
isinstance(obj1,Objet)=True, isinstance(obj1,object)=True
type(4)=<class 'int'>
isinstance(4, int)=True, isinstance(4, object)=True
Process finished with exit code 0
12.2. Script [classes_02]: uma classe Pessoa
O script [classes_02] mostra que os atributos de uma classe são públicos: eles são acessíveis diretamente de fora da classe. Trata-se, mais uma vez, de um uso desaconselhado das classes. No entanto, apresentamos esse exemplo porque, às vezes, é possível encontrar esse tipo de código (o Python o aceita) e, nessas situações, é preciso ser capaz de compreendê-lo.
# classe Pessoa
class Personne:
# atributos da classe
# não declarados — podem ser criados dinamicamente
# método
def identité(self: object) -> str:
# a priori, utiliza atributos inexistentes
return f"[{self.prénom},{self.nom},{self.âge}]"
# ---------------------------------- main
# os atributos são públicos e podem ser criados dinamicamente
# instanciação da classe
p = Personne()
# inicialização direta de atributos da classe
p.prénom = "Paul"
p.nom = "de la Hûche"
p.âge = 48
# chamada de um método da classe
print(f"personne={p.identité()}")
# tipo da instância p
print(f"type(p)={type(p)}")
print(f"isinstance(Personne)={isinstance(p, Personne)}, isinstance(object)={isinstance(p, object)}")
Notas:
- linhas 2-9: uma classe com um método;
- linha 7: todo método de uma classe deve ter como primeiro parâmetro o objeto self, que designa o objeto atual. O método [identité] retorna uma sequência de caracteres;
- linha 15: instanciação de um objeto [Personne];
- linhas 16-19: mostram que os atributos do objeto podem ser criados dinamicamente (eles não existem na definição da classe);
- linha 9: os atributos da classe são designados pela notação [self.attribut];
- as linhas 23-24 mostram que o objeto [p] é, ao mesmo tempo, uma instância da classe [Personne] e da classe [object];
Resultados
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/classes/01/classes_02.py
personne=[Paul,de la Hûche,48]
type(p)=<class '__main__.Personne'>
isinstance(Personne)=True, isinstance(object)=True
Process finished with exit code 0
12.3. Script [classes_03]: a classe Pessoa com um construtor
O script [classes_03] mostra o uso normal de uma classe:
# classe Pessoa
class Personne:
# construtor — inicializa três atributos
def __init__(self: object, prénom: str, nom: str, âge: int):
# nome: nome da pessoa
# sobrenome: sobrenome da pessoa
# idade: idade da pessoa
self.prénom = prénom
self.nom = nom
self.âge = âge
# retorna os atributos da classe na forma de uma sequência de caracteres
def identité(self: object) -> str:
return f"[{self.prénom},{self.nom},{self.âge}]"
# ---------------------------------- mão
# um objeto Pessoa
p = Personne("Paul", "de la Hûche", 48)
# chamada de um método
print(f"personne={p.identité()}")
Observações:
- linha 4: o construtor de uma classe é chamado __init__. Assim como nos outros métodos, seu primeiro parâmetro é self;
- linha 20: um objeto Personne é criado com o construtor da classe;
- linhas 13-15: o método [identité] retorna uma sequência de caracteres que representa o conteúdo do objeto;
- linha 22: exibição da identidade da pessoa;
Resultados
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/classes/01/classes_03.py
personne=[Paul,de la Hûche,48]
Process finished with exit code 0
12.4. Script [classes_04]: métodos estáticos
Definimos na pasta [modules] a seguinte classe [Utils] (utils.py):
class Utils:
# método estático
@staticmethod
def is_string_ok(string: str) -> bool:
# string é uma sequência de caracteres
erreur = not isinstance(string, str)
if not erreur:
# a string está vazia?
erreur = string.strip() == ''
# resultado
return not erreur
Notas
- linha 3: a anotação [@staticmethod] indica que o método assim anotado é um método de classe e não um método de instância. Isso fica evidente pelo fato de que o primeiro parâmetro do método assim anotado não é a palavra-chave [self]. Portanto, o método estático não tem acesso aos atributos do objeto. Em vez de escrever:
escreve-se
Como acima escrevemos [Utils.is_string_ok], o método [is_string_ok] é denominado método de classe (a classe Utils, neste caso). Para isso, o método [Utils.is_string_ok] deve ser anotado com a palavra-chave [@staticmethod].
O método estático [Utils.is_string_ok] permite, neste caso, verificar se um dado é uma sequência de caracteres não vazia.
O script [classes_04] utiliza a classe [Utils] da seguinte maneira:
# configurando o aplicativo
import config
config = config.configure()
# o syspath está configurado — podemos fazer as importações
from utilitaires import Utils
print(Utils.is_string_ok(" "))
print(Utils.is_string_ok(47))
print(Utils.is_string_ok(" q "))
- linhas 1-4: utiliza-se um script de configuração;
O script de configuração [config.py] é o seguinte:
def configure():
import os
# pasta do arquivo de configuração
script_dir = os.path.dirname(os.path.abspath(__file__))
# caminhos absolutos das pastas a serem incluídas no syspath
absolute_dependencies = [
f"{script_dir}/shared",
"C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/venv/lib/site-packages",
"C:/myprograms/Python38/lib",
"C:/myprograms/Python38/DLLs"
]
# atualização do syspath
from myutils import set_syspath
set_syspath(absolute_dependencies)
# retornamos a configuração
return {}
- linha 9: a pasta [shared] será colocada no Python Path;
O resultado da execução é o seguinte:
12.5. Script [classes_05]: verificações de validade dos atributos
O script [classes_05] introduz novos conceitos:
- definição de um tipo de exceção proprietário;
- definição do método [_str_], que é o método de identidade padrão das classes;
- definição de propriedades;
# configuramos o aplicativo
import config
config = config.configure()
# o syspath está configurado — já é possível fazer as importações
from utilitaires import Utils
# uma classe de exceção proprietária derivada de [BaseException]
class MyException(BaseException):
# não se faz nada: classe vazia
pass
# classe Pessoa
class Personne:
# construtor
def __init__(self: object, prénom: str = "x", nom: str = "y", âge: int = 0):
# nome: nome da pessoa
# sobrenome: sobrenome da pessoa
# idade: idade da pessoa
# armazenamento dos parâmetros
# as inicializações serão feitas por meio dos setters
self.prénom = prénom
self.nom = nom
self.âge = âge
# método toString da classe
def __str__(self: object) -> str:
return f"[{self.__prénom},{self.__nom},{self.__âge}]"
# getters
@property
def prénom(self) -> str:
return self.__prénom
@property
def nom(self) -> str:
return self.__nom
@property
def âge(self) -> int:
return self.__âge
# setter
@prénom.setter
def prénom(self, prénom: str):
# o nome deve ser diferente de vazio
if Utils.is_string_ok(prénom):
self.__prénom = prénom.strip()
else:
raise MyException("Le prénom doit être une chaîne de caractères non vide")
@nom.setter
def nom(self, nom: str):
# o nome deve ser diferente de vazio
if Utils.is_string_ok(nom):
self.__nom = nom.strip()
else:
raise MyException("Le nom doit être une chaîne de caractères non vide")
@âge.setter
def âge(self, âge: int):
# a idade deve ser um número inteiro >=0
erreur = False
if isinstance(âge, int):
if âge >= 0:
self.__âge = âge
else:
erreur = True
else:
erreur = True
# erro?
if erreur:
raise MyException("L'âge doit être un entier >=0")
# ---------------------------------- main
# um objeto Pessoa
try:
# instanciação da classe Pessoa
p = Personne("Paul", "de la Hûche", 48)
# exibição do objeto p
print(f"personne={p}")
except MyException as erreur:
# exibição do erro
print(erreur)
# outro objeto Pessoa
try:
# instanciação da classe Pessoa
p = Personne("xx", "yy", "zz")
# exibição do objeto p
print(f"personne={p}")
except MyException as erreur:
# exibição de erro
print(erreur)
# outra pessoa, desta vez sem parâmetros
try:
# instanciação da classe Pessoa
p = Personne()
# exibição do objeto p
print(f"personne={p}")
except MyException as erreur:
# exibição da mensagem de erro
print(erreur)
# não é possível acessar os atributos privados __attr da classe
p.__prénom = "Gaëlle"
print(f"p.prénom={p.prénom}")
print(f"p.__prénom={p.__prénom}")
p.prénom = "Sébastien"
print(f"p.prénom={p.prénom}")
print(f"p.__prénom={p.__prénom}")
Notas:
- linhas 10-13: uma classe MyException derivada da classe BaseException (veremos esse ponto um pouco mais adiante). Ela não adiciona nenhuma funcionalidade a esta última. Ela existe apenas para ter uma exceção proprietária;
- linha 19: o construtor possui valores padrão para seus parâmetros. Assim, a operação p=Personne() é equivalente a p=Personne("x","y",0);
- linhas 34-45: as propriedades da classe. São métodos anotados com a palavra-chave [@property]. São utilizados para retornar o valor dos atributos;
- linhas 47-77: os setters da classe. São métodos anotados com a palavra-chave [@attributsetter]. São usados para definir o valor dos atributos;
- linhas 48-54: o setter do atributo [prénom]. Esse método será chamado sempre que for atribuído um valor ao atributo [prénom]:
A linha 2 provocará a chamada de [p.prénom(valeur)]. A vantagem de utilizar um setter para atribuir um valor a um atributo é que, como o setter é uma função, é possível verificar a validade do valor atribuído ao atributo;
- linha 51: verifica-se se o valor atribuído ao atributo [prénom] é uma sequência de caracteres não vazia. Para isso, utiliza-se o método estático [Utils.isStringOk] visto anteriormente;
- linha 52: o valor atribuído ao atributo [prénom] tem os “espaços” no início e no fim da string removidos e é atribuído ao atributo [self.__prénom]. Portanto, não é o atributo [prénom] que é utilizado aqui. Não seria possível fazê-lo de outra forma, pois teríamos uma chamada recursiva infinita. Poderíamos ter usado qualquer nome de atributo. O fato de termos usado o atributo [__prénom] com dois sublinhados no início do identificador tem um significado especial: os atributos precedidos por dois sublinhados são privados à classe. Isso significa que eles não são visíveis de fora dela. Portanto, não podemos escrever:
Na verdade, veremos em breve que é possível escrever isso, mas que isso não altera o nome. Isso faz outra coisa;
- linhas 53-54: se o valor atribuído ao nome não estiver correto, é lançada uma exceção. Assim, o código chamador saberá que sua chamada está incorreta;
- linhas 35-37: a propriedade [prénom]. Ela será chamada sempre que escrevermos [p.prénom] em uma expressão. Nesse caso, será chamado o método [p.prénom()]. Na linha 37, retorna-se o valor do atributo [__prénom], já que vimos que o setter do atributo [prénom] atribuía seu valor ao atributo privado [__prénom];
- linhas 56-62: o setter do atributo [nom] é construído de forma análoga ao do atributo [prénom]. O mesmo se aplica ao do atributo [âge] nas linhas 64-77;
- embora as propriedades [prénom, nom, valeur] não sejam os verdadeiros atributos — que, na realidade, são [__prénom, __nom, __âge] —, continuaremos a chamá-las de atributos da classe, pois são utilizadas como tal;
- linhas 19-28: o construtor da classe utiliza implicitamente os setters dos atributos [prénom, nom, âge]. De fato, ao escrever, na linha 26, [self.prénom = prénom], é implicitamente o método [prénom(self, prénom)] que será chamado. A validade do parâmetro [prénom] será então verificada. O mesmo ocorrerá com os outros dois atributos [nom, âge];
- com esse modelo, não é possível atribuir valores incorretos aos atributos [prénom, nom, âge] da classe;
- linhas 30-32: a função __str__ substitui o método que antes se chamava identité. O nome [__str__] (com dois sublinhados antes e depois) não é aleatório. Veremos isso mais adiante;
- linhas 83-86: instanciação de uma pessoa e, em seguida, exibição de sua identidade;
- linha 84: instanciação;
- linha 86: exibição. A operação solicita a exibição da pessoa p na forma de uma sequência de caracteres. O interpretador Python então chama automaticamente o método p.__str__(), caso ele exista. Esse método desempenha a mesma função que o método toString() em Java ou nas linguagens .NET;
- linhas 87-89: tratamento de uma possível exceção do tipo MyException. Em seguida, exibe o erro;
- linhas 91-99: o mesmo para uma segunda pessoa instanciada com parâmetros incorretos;
- linhas 102-109: o mesmo para uma terceira instância criada com os parâmetros padrão: não é passado nenhum parâmetro. Nesse caso, são utilizados os valores padrão desses parâmetros no construtor;
- linhas 112-117: definimos que o atributo [__prénom] era privado e, portanto, normalmente não acessível de fora da classe. Queremos verificar isso;
- linhas 112-114: atribui-se um valor ao atributo [__prénom] e, em seguida, verifica-se o valor dos atributos [__prénom] e [prénom], que normalmente são iguais;
- linhas 115-117: repete-se a operação, inicializando, desta vez, o atributo [prénom];
Resultados
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/classes/01/classes_05.py
personne=[Paul,de la Hûche,48]
L'âge doit être un entier >=0
personne=[x,y,0]
p.prénom=x
p.__prénom=Gaëlle
p.prénom=Sébastien
p.__prénom=Gaëlle
Process finished with exit code 0
Notas
- linhas 5-6: observa-se que a atribuição [p.__prénom = "Gaëlle"] não alterou o valor do atributo [prénom], linha 5;
- linhas 7-8: percebe-se que a atribuição [p.prénom = "Sébastien"] não alterou o valor do atributo [__prénom], linha 8;
O que se pode deduzir disso? Que, provavelmente, a operação [p.__prénom = "Gaëlle"] criou um atributo público [__prénom] na classe, mas que este é diferente do atributo privado [__prénom] manipulado dentro dela;
12.6. Script [classes_06]: adição de um método de inicialização do objeto
O script [classes_06] adiciona um método à classe [Personne]:
# configurando o aplicativo
import config
config = config.configure()
# o syspath está configurado — é possível realizar as importações
from utilitaires import Utils
# uma classe de exceção proprietária derivada de [BaseException]
class MyException(BaseException):
# não faz nada: classe vazia
pass
# classe Pessoa
class Personne:
# construtor
def __init__(self: object, prénom: str = "x", nom: str = "y", âge: int = 0):
# nome: nome da pessoa
# sobrenome: sobrenome da pessoa
# idade: idade da pessoa
# armazenamento dos parâmetros
# as inicializações serão feitas por meio dos setters
self.prénom = prénom
self.nom = nom
self.âge = âge
# outro método de inicialização
def init_with_personne(self: object, p: object):
# inicializa o objeto atual com uma pessoa p
self.__init__(p.prénom, p.nom, p.âge)
# método toString da classe
def __str__(self: object) -> str:
return f"[{self.__prénom},{self.__nom},{self.__âge}]"
# getters
…
# setters
…
# ---------------------------------- main
# um objeto Pessoa
try:
# instanciação da classe Pessoa
p = Personne("Paul", "de la Hûche", 48)
# exibição do objeto p
print(f"personne={p}")
except MyException as erreur:
# exibição da mensagem de erro
print(erreur)
# outro objeto Pessoa
try:
# instanciação da classe Pessoa
p = Personne("xx", "yy", "zz")
# exibição do objeto p
print(f"p={p}")
except MyException as erreur:
# exibição de mensagem de erro
print(erreur)
# outra pessoa, desta vez sem parâmetros
try:
# instanciação da classe Pessoa
p = Personne()
# exibição do objeto p
print(f"p={p}")
except MyException as erreur:
# exibição da mensagem de erro
print(erreur)
# outra Pessoa obtida por cópia
try:
# instanciação da classe Pessoa
p2 = Personne()
p2.init_with_personne(p)
# exibição do objeto p2
print(f"p2={p2}")
except MyException as erreur:
# exibição de mensagem de erro
print(erreur)
Notas:
- a diferença em relação ao script anterior está nas linhas 30 a 33. Foi adicionado o método initWithPersonne. Este utiliza o construtor __init__. Não é possível, como nas linguagens tipadas, ter métodos com o mesmo nome diferenciados pela natureza de seus parâmetros ou de seu resultado. Portanto, não é possível ter vários construtores que criariam o objeto a partir de parâmetros diferentes, neste caso, um objeto do tipo Personne;
Resultados
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/classes/01/classes_06.py
personne=[Paul,de la Hûche,48]
L'âge doit être un entier >=0
p=[x,y,0]
p2=[x,y,0]
Process finished with exit code 0
12.7. Script [classes_07]: uma lista de objetos Pessoa
Agora colocamos as classes [MyException] e [Personne] em um módulo para poder utilizá-las sem precisar copiar seu código:
As duas classes estarão no módulo [myclasses.py] acima.
O script [classes_07] mostra que é possível obter uma lista de objetos:
# configurando o aplicativo
import config
config = config.configure()
# o syspath está configurado — já é possível fazer as importações
from myclasses import Personne
# ---------------------------------- main
# criação de uma lista de objetos “pessoa”
groupe = [Personne("Paul", "Langevin", 48), Personne("Sylvie", "Lefur", 70)]
# identidade dessas pessoas
for i in range(len(groupe)):
print(f"groupe[{i}]={groupe[i]}")
Notas:
- linha 7: importamos a classe [Personne];
- linha 11: uma lista de objetos do tipo [Personne];
- linhas 13-14: percorremos essa lista para exibir cada um de seus elementos;
- linha 14: a função [print] exibirá a string que representa o objeto [groupe[i]]. Por padrão, será chamado o método [__str__] desses objetos;
Resultados
C:\Users\serge\.virtualenvs\cours-python-v02\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/v-02/classes/01/classes_07.py
groupe[0]=[Paul,Langevin,48]
groupe[1]=[Sylvie,Lefur,70]
Process finished with exit code 0
12.8. Script [classes_08]: criação de uma classe derivada da classe Pessoa
Definimos no módulo [myclasses] a seguinte classe [Enseignant]:
# classe Professor
class Enseignant(Personne):
# construtor
def __init__(self, prénom: str = "x", nom: str = "x", âge: int = 0, discipline: str = "x"):
# nome: nome da pessoa
# sobrenome: sobrenome da pessoa
# idade: idade da pessoa
# disciplina: disciplina lecionada
# inicialização do pai/mãe
Personne.__init__(self, prénom, nom, âge)
# outras iniciais
self.discipline = discipline
# toString
def __str__(self) -> str:
return f"enseignant[{super().__str__()},{self.discipline}]"
# propriedades
@property
def discipline(self) -> str:
return self.__discipline
@discipline.setter
def discipline(self, discipline: str):
# a disciplina deve ser uma sequência de caracteres não vazia
if Utils.is_string_ok(discipline):
self.__discipline = discipline
else:
raise MyException("La discipline doit être une chaîne de caractères non vide")
- linha 2: declara a classe Enseignant como uma classe derivada da classe Personne. Uma classe derivada possui todas as propriedades (atributos e métodos) de sua classe pai, além das que lhe são próprias;
- linha 13: a classe [Enseignant] define um novo atributo [discipline];
- linha 11: o construtor da classe derivada Enseignant deve chamar o construtor da classe pai Personne, passando-lhe os parâmetros esperados;
- linha 17: a função [super()] retorna a classe pai. Aqui, chama-se a função [__str__] da classe pai;
- linhas 19-30: definem-se os getter e setter do novo atributo [discipline];
O script [classes_08] utiliza a classe [Enseignant] da seguinte maneira:
# configura-se o aplicativo
import config
config = config.configure()
# o syspath está configurado — é possível fazer as importações
from myclasses import Personne, Enseignant
# ---------------------------------- main
# criação de um array de objetos Pessoa e derivados
groupe = [Enseignant("Paul", "Langevin", 48, "anglais"), Personne("Sylvie", "Lefur", 70)]
# identidade dessas pessoas
for i in range(len(groupe)):
print(f"groupe[{i}]={groupe[i]}")
Notas:
- linha 7: importam-se as classes [Personne] e [Enseignant] definidas no arquivo [myclasses.py];
- linhas 11-14: define-se um grupo de pessoas cuja identidade é exibida em seguida;
Resultados
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/classes/01/classes_08.py
groupe[0]=enseignant[[Paul,Langevin,48],anglais]
groupe[1]=[Sylvie,Lefur,70]
Process finished with exit code 0
12.9. Script [classes_09]: segunda classe derivada da classe Pessoa
O script [classes_09] introduz a classe [Etudiant], derivada da classe [Personne]. Esta é definida da seguinte forma no módulo [myclasses]:
# classe Aluno
class Etudiant(Personne):
# construtor
def __init__(self: object, prénom: str = "x", nom: str = "y", âge: int = 0, formation: str = "x"):
Personne.__init__(self, prénom, nom, âge)
self.formation = formation
# toString
def __str__(self: object) -> str:
return f"étudiant[{super().__str__()},{self.formation}]"
# propriedades
@property
def formation(self) -> str:
return self.__formation
@formation.setter
def formation(self, formation: str):
# a formação deve ser uma sequência não vazia
if Utils.is_string_ok(formation):
self.__formation = formation
else:
raise MyException("La formation doit être une chaîne de caractères non vide")
O script [classes_09] utiliza a classe [Etudiant] da seguinte maneira:
# configura-se o aplicativo
import config
config = config.configure()
# o syspath está configurado — é possível fazer as importações
from myclasses import Personne, Enseignant, Etudiant
# ---------------------------------- main
# criação de um array de objetos Pessoa e derivados
groupe = [Enseignant("Paul", "Langevin", 48, "anglais"), Personne("Sylvie", "Lefur", 70),
Etudiant("Steve", "Boer", 22, "iup2 qualité")]
# identidade dessas pessoas
for personne in groupe:
# exibição da pessoa
print(personne)
Observações:
- esse script é semelhante ao anterior.
Resultados
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/classes/01/classes_09.py
enseignant[[Paul,Langevin,48],anglais]
[Sylvie,Lefur,70]
étudiant[[Steve,Boer,22],iup2 qualité]
Process finished with exit code 0
12.10. Script [classes_10]: a propriedade [__dict__]
O script [classes_10] apresenta a propriedade [__dict__], que utilizaremos com frequência daqui em diante:
# configuração do aplicativo
import config
config = config.configure()
# o syspath está configurado — é possível realizar as importações
from myclasses import Etudiant
# ---------------------------------- main
# criação de um aluno
étudiant=Etudiant("Steve", "Boer", 22, "iup2 qualité")
# dicionário de propriedades
print(étudiant.__dict__)
Comentários
- linhas 1-4: o aplicativo é configurado;
- linha 7: a classe [Etudiant] é importada;
- linha 11: instanciação de um aluno;
- linha 13: uso do método predefinido [__dict__] (2 caracteres sublinhados antes e depois do identificador);
Os resultados são os seguintes:
- na linha 2, obtém-se um dicionário cujas chaves são as propriedades do objeto, precedidas pelo nome da classe à qual pertencem. Utilizaremos esse dicionário para estabelecer uma ponte entre o objeto e o dicionário;