Tipos no Python

Este artigo explica os tipos no Python.

YouTube Video

Tipos no Python

O módulo typing no Python é usado para introduzir sugestões de tipos ao Python. Foi originalmente introduzido no Python 3.5 e é usado para melhorar a legibilidade e a manutenção do código. As sugestões de tipos não afetam a execução do código, mas permitem a verificação de tipos com IDEs e ferramentas de análise estática.

Noções básicas sobre sugestões de tipos

As sugestões de tipos esclarecem a intenção do código ao especificar explicitamente os tipos de funções e variáveis. No exemplo abaixo, os tipos são especificados para os argumentos e o valor de retorno.

1def add_numbers(a: int, b: int) -> int:
2    return a + b
3
4result: int = add_numbers(5, 10)
5print(result)  # 15

No código acima, a e b são do tipo inteiro (int), e o valor de retorno da função também é explicitamente declarado como um inteiro. Mesmo com as sugestões de tipos, os tipos não são estritamente aplicados, mas avisos podem ser exibidos durante o desenvolvimento se houver incompatibilidade de tipos.

Principais sugestões de tipos

O módulo typing no Python fornece várias classes e funções para definir sugestões de tipos. Abaixo está uma lista de sugestões de tipos comuns.

• int: inteiro
• str: string
• float: número de ponto flutuante
• bool: booleano
• List: lista
• Dict: dicionário
• Tuple: tupla
• Set: conjunto

Tipo List

O tipo de lista é especificado usando a classe List. Você também pode especificar explicitamente o tipo de elementos dentro de uma lista.

1from typing import List
2
3def sum_list(numbers: List[int]) -> int:
4    return sum(numbers)
5
6print(sum_list([1, 2, 3]))  # 6

Neste exemplo, espera-se que todos os elementos da lista sejam do tipo int.

Tipo Dict

Um tipo de dicionário é definido usando Dict. Os tipos de chaves e valores podem ser especificados.

1from typing import Dict
2
3def get_student_age(students: Dict[str, int], name: str) -> int:
4    return students.get(name, 0)
5
6students = {"Alice": 23, "Bob": 19}
7print(get_student_age(students, "Alice"))  # 23

Neste exemplo, o dicionário usa str como o tipo de chave e int como o tipo de valor.

Tipo Tuple

Tuples são especificados usando o tipo Tuple. Você pode especificar o tipo de cada elemento em uma tuple individualmente.

1from typing import Tuple
2
3def get_person() -> Tuple[str, int]:
4    return "Alice", 30
5
6name, age = get_person()
7print(name, age)  # Alice 30

Aqui, a função get_person retorna uma tuple contendo uma string e um número inteiro.

Tipo Union

O tipo Union é usado para indicar explicitamente que múltiplos tipos são aceitos.

1from typing import Union
2
3def process_value(value: Union[int, float]) -> float:
4    return value * 2.0
5
6print(process_value(10))  # 20.0
7print(process_value(3.5))  # 7.0

Neste exemplo, a função process_value aceita um argumento do tipo int ou float e retorna um resultado do tipo float.

Tipo Optional

O tipo Optional é usado quando uma variável pode ser None. Ele é fornecido como uma abreviação para Union[Type, None].

1from typing import Optional
2
3def greet(name: Optional[str] = None) -> str:
4    if name is None:
5        return "Hello, Guest!"
6    return f"Hello, {name}!"
7
8print(greet())  # Hello, Guest!
9print(greet("Alice"))  # Hello, Alice!

Aqui, é mostrado que quando name não é especificado, ele é tratado como None.

Tipos Genéricos

Tipos genéricos são uma forma de representar abstratamente quais tipos de elementos uma estrutura de dados contém. No módulo typing, você pode definir tipos genéricos usando TypeVar.

1from typing import TypeVar, List
2
3T = TypeVar('T')
4
5def get_first_element(elements: List[T]) -> T:
6    return elements[0]
7
8print(get_first_element([1, 2, 3]))  # 1
9print(get_first_element(["a", "b", "c"]))  # a

Neste exemplo, get_first_element é uma função que retorna o primeiro elemento de uma lista, e funciona independentemente do tipo da lista.

Aliases de Tipo

Um alias de tipo é uma maneira de simplificar definições de tipos complexos, atribuindo-lhes um nome claro.

1from typing import List, Tuple
2
3Coordinates = List[Tuple[int, int]]
4
5def get_coordinates() -> Coordinates:
6    return [(0, 0), (1, 1), (2, 2)]
7
8print(get_coordinates())  # [(0, 0), (1, 1), (2, 2)]

Neste exemplo, um alias de tipo Coordinates é definido para representar um tipo com tuples dentro de uma lista.

Resumo

O módulo typing no Python é muito útil para melhorar a legibilidade e a manutenção do código. Ao usar corretamente as dicas de tipo, você pode ajudar a evitar incompatibilidades de tipo e bugs, especialmente em projetos de grande escala ou no desenvolvimento em equipe. Os tipos são apenas uma ferramenta de suporte ao desenvolvimento e não afetam o comportamento em tempo de execução, mantendo assim a flexibilidade do código.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video