9.1 Função type()
Em Python, há várias funções embutidas para verificação de tipos e classes de objetos. Essas funções são úteis para escrever código flexível e seguro, que pode trabalhar com diferentes tipos de dados.
Vou comentar sobre as mais populares: type(), isinstance(), issubclass(), e também funções para anotação de tipos, como getattr() e hasattr().
Função type()
A função type() retorna o tipo de um objeto. Já trabalhou com ela, não é mesmo?
x = 10
print(type(x)) # Output: <class 'int'>
Mas aposto que você não sabia que pode usar ela para criar novas classes!
Criando uma nova classe
Se passar três argumentos para ela, vai criar um novo tipo (classe).
A assinatura dessa operação:
type(name, bases, dict)
onde:
-
name— nome da classe que está sendo criada (string). -
bases— tupla de classes base (pais), das quais a nova classe herda. -
dict— dicionário contendo atributos e métodos da nova classe.
Criando uma classe simples:
MyClass = type('MyClass', (), {'say_hello': lambda self: print("Hello!")})
# Criar uma instância da classe
instance = MyClass()
instance.say_hello() # Output: Hello!
Você pode até criar algo mais complexo:
MyClass = type('MyClass', (), {
'attribute': 42,
'__init__': lambda self, value: setattr(self, 'value', value),
'display_value': lambda self: print(self.value)
})
# Criar uma instância da classe
instance = MyClass(10)
print(instance.attribute) # Output: 42
instance.display_value() # Output: 10
Agora você pode não apenas definir o tipo de um objeto, mas também criar uma classe, gerar objetos para ela, e depois determinar os tipos deles.
9.2 Função isinstance()
Função isinstance() é uma função embutida em Python, usada para verificar se um objeto é uma instância de uma classe específica ou de uma tupla de classes. Ela retorna True se o objeto é uma instância da classe indicada ou qualquer das classes indicadas na tupla, e False caso contrário.
Assinatura e parâmetros:
isinstance(object, classinfo)
onde:
-
object— objeto cuja associação com a classe ou classes precisa ser verificada. -
classinfo— classe, tipo ou tupla de classes e tipos contra os quais o objeto será verificado.
Exemplos de uso:
Verificação de pertença a uma única classe
x = 10
print(isinstance(x, int)) # Output: True
y = "Hello"
print(isinstance(y, str)) # Output: True
Verificação de pertença a várias classes — pelo menos uma das:
x = 10
print(isinstance(x, (int, float))) # Output: True
y = "Hello"
print(isinstance(y, (int, str))) # Output: True
z = 3.14
print(isinstance(z, (int, str))) # Output: False
Verificação de pertença a classes definidas pelo usuário
class Animal:
pass
class Dog(Animal):
pass
dog = Dog()
print(isinstance(dog, Dog)) # Output: True
print(isinstance(dog, Animal)) # Output: True
Diferente da comparação direta de tipos com type(), isinstance() funciona corretamente com herança, verificando a pertença de um objeto a qualquer classe na hierarquia.
9.3 Função issubclass()
Função issubclass() é uma função embutida em Python, utilizada para verificar se uma classe é uma subclasse de outra classe ou de qualquer das classes em uma tupla. Essa função retorna True se o primeiro argumento é realmente uma subclasse do segundo, e False caso contrário.
Assinatura e parâmetros:
issubclass(class, classinfo)
onde:
-
class— classe cuja pertença à classe ou classes precisa ser verificada. -
classinfo— classe, tipo ou tupla de classes e tipos contra os quais o primeiro argumento será verificado.
Exemplos de uso:
Verificação de pertença a uma única classe
class Animal:
pass
class Dog(Animal):
pass
print(issubclass(Dog, Animal)) # Output: True
print(issubclass(Animal, Dog)) # Output: False
Verificação de pertença a várias classes — pelo menos uma:
class Animal:
pass
class Dog(Animal):
pass
class Cat(Animal):
pass
print(issubclass(Dog, (Animal, Cat))) # Output: True
print(issubclass(Dog, (Cat,))) # Output: False
Exemplos com classes definidas pelo usuário
Herança de classes embutidas
class MyInt(int):
pass
print(issubclass(MyInt, int)) # Output: True
print(issubclass(int, MyInt)) # Output: False
Hierarquia de herança
class A:
pass
class B(A):
pass
class C(B):
pass
print(issubclass(C, A)) # Output: True
print(issubclass(C, B)) # Output: True
print(issubclass(B, A)) # Output: True
print(issubclass(A, C)) # Output: False
Vantagens de usar issubclass()
Verificação de hierarquia de classes: issubclass() permite verificar a hierarquia de classes, o que é útil para garantir a correção da herança e a estrutura do código.
Flexibilidade: A função suporta a verificação de uma única classe ou de uma tupla de classes, tornando-a flexível para uso em diferentes cenários.
Comodidade para metaprogramação: issubclass() é frequentemente usada em metaprogramação e ao escrever código que trabalha com tipos e classes dinâmicos. Vamos falar mais sobre isso futuramente :)
GO TO FULL VERSION