Tutorial de verificação de tipos em Python

A própria ajuda do interpretador faz a verificação de tipos em Python. Como o Python é uma linguagem dinâmica, ele não obriga você a declarar o tipo dos objetos, o que pode gerar bugs e tornar os erros mais difíceis de detectar. Para contornar isso, é possível usar Python em conjunto com outras ferramentas e implementar recursos de verificação estática de tipos, além do seu próprio duck typing.

Existem dois tipos de sistemas de tipos adotados por diferentes linguagens de programação, mostrados abaixo.

1. Linguagem de tipagem estática
2. Linguagem de tipagem dinâmica

Linguagem de tipagem estática

A verificação do tipo da variável é feita em tempo de compilação. Além disso, o sistema de tipos da linguagem exige declarar explicitamente o "tipo de dado" da variável antes do uso. Linguagens com tipagem estática incluem: Scala, Java, C++, etc.
Por exemplo, a declaração de String em Scala é definida abaixo:
var myCar:String = "Mercedes";
O código acima mostra que a variável 'myCar' é declarada explicitamente com o tipo de dado 'String' e o valor 'Mercedes'.

Linguagem de tipagem dinâmica

A verificação do tipo da variável é feita em tempo de execução. Além disso, o sistema de tipos da linguagem não obriga a declarar explicitamente o "tipo de dado" da variável antes do uso. Linguagens com tipagem dinâmica incluem: Python, JavaScript, Ruby, etc.
Por exemplo, a String em Python é definida abaixo:
myCar = "Mercedes"
O código acima mostra que a variável 'myCar' não precisa ser declarada explicitamente.

'type()' e 'isinstance()' em Python

Os tipos das variáveis podem ser conhecidos usando o próprio 'type()' do Python. O 'type()' pode ser usado em tempo de execução para depuração, ajudando a identificar os tipos exatos das variáveis no programa. Vamos ver o tipo de algumas variáveis no exemplo abaixo.

my_var = 12
print(type(my_var))

O código acima exibirá 'int'. Como o tipo de dado da variável é inteiro, 'type()' identifica isso.

O 'insinstance('obj','class')' do Python pode ser usado para saber se 'obj', que é o objeto, é instância da classe ou não. O valor retornado é booleano e pode ser True ou False.

my_var = "Hello"
print(isinstance(my_var,str))

O código acima exibirá True. Como o tipo de dado da variável é string, 'isinstance()' identifica isso.

Duck typing em Python

Há um princípio popular em Python: "Se parece um pato, nada como um pato e grasna como um pato, então provavelmente é um pato." Em resumo, o princípio diz que o tipo do objeto ou da classe não importa; se o objeto tiver métodos e propriedades compatíveis, ele pode ser usado para um determinado propósito.
Veja um exemplo para deixar isso mais claro.

No exemplo abaixo, existem duas classes: 'Duck' e 'Human'. Duck é uma classe que contém os métodos quack e fly. Da mesma forma, Human é uma classe com seus próprios métodos 'quack' e 'fly'. Duck e Human são classes diferentes e, portanto, objetos (tipos) diferentes. No entanto, Human contém métodos semelhantes ('fly' e 'quack') aos de Duck. Há também a função 'fly_quack', que funciona com algo que se parece mais com 'Duck' do que com 'Human' porque consegue voar e grasnar.

class Duck:
    def quack(self):
        print('Quack')
    def fly(self):
        print('Flap')
class Human:
    def quack(self):
        print('Trying to Quack like a duck')
    def fly(self):
        print('Spreading my arm to flap like a duck')      
def fly_quack(thing):
    thing.quack()
    thing.fly()

Vamos criar uma instância de 'Duck' como du e passar para a função 'fly_quack(du)'. Da mesma forma, uma instância de Human 'h' é criada e passada para a função 'fly_quack(h)'.

du = Duck()
fly_quack(du)
h = Human()
fly_quack(h)

A saída do código acima é a seguinte:

Trying to Quack like a duck
Spreading my arm to flap like a duck
Quack
Flap

Embora 'Human' seja uma classe diferente de 'Duck', o Python chama a função 'fly_quack' para o humano também. Mesmo com tipos de objetos diferentes, como 'Human' tem métodos semelhantes (quack e fly), ele se comporta como o necessário e fornece os métodos requeridos.

Type hint e mypy

Há um aspecto poderoso em linguagens de tipagem dinâmica como Python: o código fica acessível e legível. Mas há desvantagens. Uma delas é encontrar erros em tempo de execução, já que Python não impõe o tipo das variáveis. Isso pode gerar erros e bugs que ficam difíceis de detectar à medida que o código cresce.

O Python implementou type hints a partir da versão 3.5. Versões mais antigas podem não oferecer suporte a type hints.

Veja um exemplo simples sem type hinting e sem mypy.

A função abaixo deveria fazer a subtração de inteiros, subtraindo dois números inteiros e retornando o valor.

def sub_this(x,y):
    return 'Subtraction'
print(sub_this(8,'hello'))

A função acima precisaria aceitar dois inteiros 'x' e 'y', mas como não há regras impostas, ela pode receber qualquer tipo de dado. Além disso, o retorno pode ser qualquer coisa: aqui é retornada a 'str' ('Subtraction'), quando o esperado seria um 'int'.

Vamos ver uma implementação semelhante usando type hints e 'mypy', que ajudam a aplicar verificação estática de tipos e reduzem erros e bugs no programa com muito mais facilidade.

'mypy' é um módulo Python que ajuda na verificação estática de tipos, combinando a verificação dinâmica (duck typing) do próprio Python com type hints.

Você precisa instalar o pacote 'mypy'
pip install mypy

Crie um arquivo chamado 'mypy_example.py' na sua máquina local e digite o código a seguir.
O código abaixo é um programa simples que aceita dois inteiros como parâmetros e, após '->', indica o tipo de retorno, que também é um 'int'. No entanto, a função deveria retornar um int, mas retorna a string 'Subtracted two integers'.

def sub_this(x:int,y:int) -> int:
    return 'Subtracted two integers'
print(sub_this(8,4))

Execute o código acima no terminal com o comando a seguir.

mypy mypy_example.py

Será exibido um erro indicando que foi encontrado um valor de retorno "str" inesperado e que ele deveria ser "int".

Vamos alterar o retorno para a subtração dos dois inteiros, de modo que um inteiro seja devolvido.

def sub_this(x:int,y:int) -> int:
    return x - y
print(sub_this(8,4))

Os resultados acima mostram que a mensagem de sucesso foi impressa e nenhum problema foi encontrado.

Parabéns

Parabéns, você chegou ao fim deste tutorial!

Neste tutorial, você aprendeu sobre verificação de tipos, diferentes sistemas de tipos em várias linguagens, os métodos do Python ('type()' e 'isinstance()'), além de duck typing e type hinting combinado com 'mypy'.

Se você quiser aprender mais sobre Python, faça o curso Software Engineering for Data Scientists in Python da DataCamp.

Referências:

1. Vídeo do Corey no YouTube sobre Duck Typing