Tipos Dinâmicos

Python é uma linguagem de tipagem dinâmica, o que significa que o interpretador verifica os tipos somente durante a execução e permite que variáveis mudem de tipo ao longo de seu ciclo de vida.

   >>> if False:
   ...     1 + "dois"  # Esta linha nunca é executada
   ... else:
   ...     1 + 2
   ...
   3

   >>> 1 + "dois"  # Agora há verificação de tipo
   TypeError: unsupported operand type(s) for +: 'int' e 'str'
   

Exemplo de alteração de tipo:

   >>> coisa = "Hello"
   >>> type(coisa)
   <class>

   >>> coisa = 28.1
   >>> type(coisa)
   <class>
   </class></class>

Tipos Estáticos

A tipagem estática é o oposto, onde a verificação de tipos é feita sem executar o programa. Em linguagens compiladas como C e Java, isso ocorre durante a compilação.

Tipagem Anafálica (Duck Typing)

No contexto do Python, o termo "tipagem anafálica" refere-se à idiea de que o tipo de um objeto é menos importante do que os métodos que ele define.

   >>> class Oi:
   ...     def __len__(self):
   ...         return 95022
   ...
   >>> oi = Oi()
   >>> len(oi)
   95022
   

Introdução a Tipos com Anotação

Python suporta anotações de tipo que permitem a verificação estática. Elas não são executadas durante a execução, mas ajudam a documentar e verificar tipos.

   def titulo(texto: str, alinhar: bool = True) -> str:
       if alinhar:
           return f"{texto.title()}\n{'-' * len(texto)}"
       else:
           return f" {texto.title()} ".center(50, "o")
   
   >>> print(titulo("tipos de dados em python"))
   Tipos De Dados Em Python
   -------------------------

   >>> print(titulo("usar mypy", alinhar=False))
   ooooUsar Mypy Oooo
   

Verificação Estática com Mypy

Para usar o Mypy:

   # test.py
   def titulo(texto: str, alinhar: bool = True) -> str:
       if alinhar:
           return f"{texto.title()}\n{'-' * len(texto)}"
       else:
           return f" {texto.title()} ".center(50, "o")

   print(titulo("tipos de dados"))
   print(titulo("mypy", alinhar="center"))
   

   $ mypy test.py
   test.py:10: error: Argumento "alinhar" para "titulo" tem tipo incompatível
   

Prós e Contras

• Prós:
  • Ajuda a capturar erros
  • Melhora a documentação
  • Suporta arquiteturas mais claras
• Contras:
  • Consumo de tempo durante a codificação
  • Possível aumento do tempo de importação

Tipos Complicados

   from typing import List, Tuple, Dict

   def criar_baralho(mostrar: bool = False) -> List[Tuple[str, str]]:
       """Cria um novo baralho de 52 cartas"""
       baralho = [(s, r) for r in RANKS for s in SUITS]
       if mostrar:
           random.shuffle(baralho)
       return baralho
   

Alias de Tipos

   from typing import List, Tuple

   Carta = Tuple[str, str]
   Baralho = List[Carta]

   def distribuir_maos(deck: Baralho) -> Tuple[Baralho, Baralho, Baralho, Baralho]:
       """Distribui as cartas no baralho em quatro mãos"""
       return (deck[0::4], deck[1::4], deck[2::4], deck[3::4])