Python: Como Verificar Instância de Classe com isinstance() e type()

Introdução

Neste laboratório, você explorará classes e instâncias em Python e aprenderá como verificar se um objeto é uma instância de uma classe. Começará criando uma classe Dog com atributos de classe e de instância, em seguida, criará instâncias da classe Dog e acessará seus atributos.

Em seguida, aprenderá a usar isinstance() para verificação de tipo e compará-la com type() para correspondências exatas. Isso permitirá que você determine se um objeto pertence a uma classe específica ou a uma subclasse dessa classe, proporcionando uma compreensão mais profunda da programação orientada a objetos em Python.

Explorar Classes e Instâncias

Nesta etapa, você aprenderá sobre classes e instâncias em Python. Classes são como plantas para criar objetos, e instâncias são os objetos reais criados a partir dessas plantas. Compreender classes e instâncias é fundamental para a programação orientada a objetos em Python.

Primeiro, vamos criar uma classe simples chamada Dog.

Abra o editor VS Code no ambiente LabEx.
Crie um novo arquivo chamado dog.py no diretório ~/project.
```
~/project/dog.py
```
Adicione o seguinte código a dog.py:
```
## Define a class called Dog
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## Instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age
```
Aqui, definimos uma classe chamada Dog. species é um atributo de classe, o que significa que é compartilhado por todas as instâncias da classe Dog. O método __init__ é um método especial chamado construtor. Ele é usado para inicializar os atributos de instância name e age quando um novo objeto Dog é criado.

Agora, vamos criar instâncias da classe Dog. Adicione o seguinte código ao final de dog.py:

## Create instances of the Dog class
buddy = Dog("Buddy", 9)
miles = Dog("Miles", 4)

## Access instance attributes
print(f"{buddy.name} is {buddy.age} years old.")
print(f"{miles.name} is {miles.age} years old.")

## Access class attribute
print(f"{buddy.name} is a {buddy.species}.")
print(f"{miles.name} is a {miles.species}.")

Nesta parte, criamos duas instâncias da classe Dog: buddy e miles. Em seguida, acessamos seus atributos de instância (name e age) e o atributo de classe (species) usando a notação de ponto (.).

Para executar o script dog.py, abra um terminal no VS Code e execute o seguinte comando:
```
python dog.py
```
Você deve ver a seguinte saída:
```
Buddy is 9 years old.
Miles is 4 years old.
Buddy is a Canis familiaris.
Miles is a Canis familiaris.
```
Esta saída confirma que você criou com sucesso instâncias da classe Dog e acessou seus atributos.

Usar isinstance() para Verificação de Tipo

Nesta etapa, você aprenderá como usar a função isinstance() em Python para verificar se um objeto é uma instância de uma classe específica. Esta é uma ferramenta útil para garantir que seu código lide com diferentes tipos de objetos corretamente.

Com base na classe Dog da etapa anterior, vamos criar um novo arquivo Python para explorar isinstance().

Abra o editor VS Code no ambiente LabEx.
Crie um novo arquivo chamado type_check.py no diretório ~/project.
```
~/project/type_check.py
```

Copie a definição da classe Dog de dog.py para type_check.py. Seu arquivo type_check.py agora deve ser semelhante a este:

class Dog:
    species = "Canis familiaris"

    def __init__(self, name, age):
        self.name = name
        self.age = age

Agora, vamos adicionar algum código para usar a função isinstance(). Adicione o seguinte código ao final de type_check.py:
```
## Create instances of the Dog class
buddy = Dog("Buddy", 9)
miles = Dog("Miles", 4)

## Check if buddy is an instance of the Dog class
print(isinstance(buddy, Dog))

## Check if miles is an instance of the Dog class
print(isinstance(miles, Dog))

## Check if a string is an instance of the Dog class
print(isinstance("Hello", Dog))
```
Aqui, criamos duas instâncias da classe Dog, buddy e miles. Em seguida, usamos a função isinstance() para verificar se essas instâncias são do tipo Dog. Também verificamos se uma string "Hello" é uma instância da classe Dog.
Para executar o script type_check.py, abra um terminal no VS Code e execute o seguinte comando:
```
python type_check.py
```
Você deve ver a seguinte saída:
```
True
True
False
```
A saída mostra que buddy e miles são de fato instâncias da classe Dog, enquanto a string "Hello" não é.

Comparar com type() para Correspondências Exatas

Nesta etapa, você aprenderá como usar a função type() em Python e compará-la com isinstance() para verificação de tipo. Enquanto isinstance() verifica se um objeto é uma instância de uma classe ou suas subclasses, type() retorna o tipo exato de um objeto.

Para ilustrar a diferença, vamos criar uma subclasse da classe Dog e, em seguida, usar tanto isinstance() quanto type() para verificar o tipo de instâncias.

Abra o editor VS Code no ambiente LabEx.
Modifique o arquivo type_check.py no diretório ~/project.
```
~/project/type_check.py
```

Adicione uma nova classe chamada GermanShepherd que herda da classe Dog. Seu arquivo type_check.py agora deve ser semelhante a este:

class Dog:
    species = "Canis familiaris"

    def __init__(self, name, age):
        self.name = name
        self.age = age

class GermanShepherd(Dog):
    def __init__(self, name, age, training_level):
        super().__init__(name, age)
        self.training_level = training_level

Aqui, GermanShepherd é uma subclasse de Dog. Ela herda os atributos name e age da classe Dog e adiciona um novo atributo training_level.

Agora, vamos adicionar algum código para usar as funções isinstance() e type(). Adicione o seguinte código ao final de type_check.py:

## Create instances of the Dog and GermanShepherd classes
buddy = Dog("Buddy", 9)
sparky = GermanShepherd("Sparky", 3, "Advanced")

## Check types using isinstance()
print(f"buddy isinstance Dog: {isinstance(buddy, Dog)}")
print(f"sparky isinstance Dog: {isinstance(sparky, Dog)}")
print(f"sparky isinstance GermanShepherd: {isinstance(sparky, GermanShepherd)}")

## Check types using type()
print(f"type(buddy) == Dog: {type(buddy) == Dog}")
print(f"type(sparky) == Dog: {type(sparky) == Dog}")
print(f"type(sparky) == GermanShepherd: {type(sparky) == GermanShepherd}")

Nesta parte, criamos uma instância da classe Dog (buddy) e uma instância da classe GermanShepherd (sparky). Em seguida, usamos isinstance() e type() para verificar seus tipos.

Para executar o script type_check.py, abra um terminal no VS Code e execute o seguinte comando:
```
python type_check.py
```
Você deve ver a seguinte saída:
```
buddy isinstance Dog: True
sparky isinstance Dog: True
sparky isinstance GermanShepherd: True
type(buddy) == Dog: True
type(sparky) == Dog: False
type(sparky) == GermanShepherd: True
```
A saída mostra que isinstance(sparky, Dog) retorna True porque sparky é uma instância da classe GermanShepherd, que é uma subclasse de Dog. No entanto, type(sparky) == Dog retorna False porque type(sparky) retorna o tipo exato, que é GermanShepherd, não Dog.

Resumo

Neste laboratório, você explorou os fundamentos de classes e instâncias em Python. Você aprendeu como definir uma classe, incluindo atributos de classe e atributos de instância inicializados dentro do construtor __init__.

Em seguida, você criou instâncias da classe Dog, atribuindo valores aos seus atributos específicos. Finalmente, você acessou tanto os atributos de instância (nome, idade) quanto o atributo de classe (espécie) usando a notação de ponto, demonstrando como recuperar informações associadas a objetos e suas classes.

Como Verificar se um Objeto é uma Instância de uma Classe em Python

Introdução

Explorar Classes e Instâncias

Usar isinstance() para Verificação de Tipo

Comparar com type() para Correspondências Exatas

Resumo