Python: Tipos
Tags: python, programming
Published: 2023-05-03 18:41:14

[Post anterior](https://dev.to/iugstav/python-o-comeco-de-tudo-2bjh)

As linguagens de programação são um meio para expressar instruções para um computador realizar uma determinada tarefa. Um elemento fundamental dessas linguagens são os tipos de dados, que permitem representar informações de diferentes formas, tais como números, textos, o cachorro da vizinha, entre outros. A escolha dos tipos de dados pode ter um grande impacto na clareza e eficiência do código. Por exemplo, uma linguagem que permite a manipulação precisa de números reais ( {% katex inline %} \Reals {% endkatex %}) pode ser ideal para cálculos científicos. 

Python, por sua vez, possui tipagem dinâmica e forte, mas o que isso nos diz? Para entender esses conceitos, primeiro vamos entender o que vem a ser um sistema de tipos.

## Tipagem

Bom, um sistema de tipos é feito de tipos. Só por essa frase eu já merecia um Nobel.

Brincadeiras à parte, na verdade, para entender os sistemas de tipos, temos que dar mais um passo para trás e entender o que seria a sintaxe e a semântica de uma linguagem:

- A sintaxe dita as regras que instruções devem ser seguir para que um programa de uma determinada linguagem as execute corretamente. Um exemplo disso é a criação de variáveis em Python, onde você declara seu nome, seguido de um sinal de igual `=` e o valor que será atribuido à variavel.

    
    ```python
    # <nome_da_variavel> = <valor>
    usuario = "Fulaninho"
    nota = 8
    ```

    Podemos ver claramente uma estrutura a ser seguida para que o interpretador entenda que estamos criando uma variável e atribuindo um valor a ela. Qualquer coisa fora dessa regra é tratado como *erro sintático* quando o programa for executado.
    
- A semântica, por sua vez, atribui um significado e dita o comportamento por trás desses termos da linguagem. A semântica do exemplo citado acima seria:
    1. Uma variável de nome `usuario` é criada;
    2. a string `Fulaninho` é atribuída a essa variável;
    3. Outra variável de nome `nota` é criada;
    4. O número 8 é atribuído a ela;

Partindo dos conceitos de sintaxe e semântica, podemos tomar as seguintes afirmações:

- Matematicamente falando, o número 8 faz parte do conjunto dos inteiros ({% katex inline %} \Z {% endkatex %});
- No trecho de código acima, a variável `nota` recebe o valor {% katex inline %} 8 \in \Z {% endkatex %};
- Logo, se {% katex inline %} nota=8 {% endkatex %} e {% katex inline %} 8 \in \Z {% endkatex %}, logo {% katex inline %} nota \in \Z {% endkatex %};

Decorrente das afirmações, foi visto que a variável é inteira e, com isso, podemos afirmar que sua faixa de valores está restrita ao conjunto dos inteiros. Obviamente, o conjunto dos inteiros de uma linguagem não possui o mesmo intervalo dos inteiros na matemática, pois o computador não suporta números infinitos. Dito isso, podemos inferir que um tipo trabalha como uma regra, adicionando semântica a algum dado. Se um tipo é uma regra, então um sistema de tipos pode ser compreendido como um conjunto dessas regras. 

Quando dizemos que o sistema de tipos de Python é dinâmico e forte, isso implica diretamente na forma como escrevemos e entendemos código.

O dinamismo de um sistema de tipos em uma linguagem de programação nos diz que os tipos atribuídos aos termos da linguagem podem mudar ao longo da execução do programa, ou seja, não há um mecanismo de verificação estática de tipos. O oposto de um sistema de tipos dinâmico é chamado de *sistema de tipos estático*, onde a vinculação de tipos aos elementos do código ocorre numa etapa antes da execução.

Já a força de um sistema de tipos está atrelada a intensidade da ligação de um tipo com algum elemento da linguagem. Viajei legal? Então pensa comigo: se um tipo adiciona semântica a um termo, esse vínculo pode ter uma força, tal como forte ou fraco, e essa força vai medir o comportamento desse vínculo ao longo da execução do programa. Podemos categorizar um vínculo de tipo-termo como forte quando durante a execução, o termo sofre poucas ou nenhuma alteração de significado, ou seja, seu tipo se mantém sem conversões implícitas. Já um vínculo fraco seria o oposto, podendo produzir código com diversas conversões implícitas de tipo e resultados imprevisíveis.

Na verdade, esse debate sobre tipagem forte ou fraca se refere à segurança de um sistema de tipos, já que tudo que é falado é se seus tipos serão convertidos sem sua permissão ou não. Uma definição de “segurança” que se encaixa nesse contexto é:

> *Segurança: Se qualquer tentativa de interpretar mal os dados é pega em tempo de compilação ou gera um erro específico para isso em tempo de execução*
> 

Às vezes, linguagens ou ferramentas pouco seguras são necessárias e o contrário também é válido. Uma possibilidade não exclui a outra e se excluísse eu não estaria aqui falando sobre esse conceito.

## Tipos Predefinidos em Python

Existem vários tipos de dados que podem ser usados para representar diversos tipos de informações. Dentre eles, temos os tipos de dados predefinidos da linguagem e os definidos pelo usuário. Dentre os predefinidos, temos:

### Números

Os números em Python podem ser inteiros, de ponto flutuante ou complexos. Os números inteiros são representados pelo tipo `int`, enquanto os números de ponto flutuante são representados pelo tipo `float`. Os números complexos são representados pelo tipo `complex`, que consiste em uma parte real e uma parte imaginária.

O tipo `int` é usado para representar números inteiros positivos ou negativos ({% katex inline %} \Z {% endkatex %}). Python é capaz de lidar com inteiros de tamanho arbitrário, o que significa que não há limite para o tamanho do número que pode ser armazenado. Isso é útil para cálculos que envolvem números muito grandes.

O tipo `float` é usado para representar números reais ({% katex inline %} \R {% endkatex %}), com casas decimais. Embora os números de ponto flutuante tenham uma precisão limitada, eles são úteis para cálculos que envolvem frações decimais, como cálculos financeiros ou científicos.

O tipo `complex` é usado para representar números complexos ({% katex inline %} \Complex {% endkatex %}), que consistem em uma parte real e uma parte imaginária. Esses números são úteis para cálculos que envolvem fases ou oscilações, como em processamento de sinais ou imagens.

Abaixo temos exemplos de cada um dos tipos:

```python
# int
idade = 23 + 2

# float
nota_p1 = 4.6

# complexos podem ser definidos dos dois jeitos abaixo
complexo = 2 + 3j
complexo_funcao = complex(1, 2)  # 1 + 2j
```

### Booleanos

Os valores booleanos em Python são `True` (verdadeiro) e `False` (falso). Esses valores são usados para avaliar condições em programas Python. Por exemplo, se uma condição for verdadeira, um determinado bloco de código será executado. Se a condição for falsa, o bloco de código será ignorado. Quem nunca fez gambiarra em condicionais, que atire a primeira pedra!

Os valores booleanos também são usados para fazer comparações entre valores. Por exemplo, se o valor de uma variável é maior que outro, a expressão retornará `True`. Caso contrário, retornará `False`.

```python
passou_em_calculo = True

if passou_em_calculo == True:
    print("Parabéns! Você passou!!!")
else:
    print("Eita, colega... E vamos de chorar.")
```

No trecho de código acima, temos uma variável `passou_em_calculo` que recebe o booleano `True`. Logo em seguida, temos uma condicional que escreve uma mensagem no terminal se a variável for True e outra mensagem se for False. Se você rodar o código abaixo, terá o resultado:

```
$> Parabéns! Você passou!!!
```

### Sequências

As sequências em Python são usadas para representar uma coleção ordenada de valores. Existem três tipos principais de sequências em Python: listas, tuplas e strings.

As listas são os arrays de Python. São coleções mutáveis de valores ordenados, que podem ser alteradas adicionando, removendo ou modificando os elementos da lista. As listas são definidas entre colchetes (`[]`).

As tuplas são semelhantes às listas, mas são imutáveis. Isso significa que uma vez que uma tupla é criada, seus elementos não podem ser alterados. As tuplas são definidas entre parênteses (`()`).

As strings são sequências de caracteres que representam texto. As strings são imutáveis em Python, o que significa que uma vez criada, uma string não pode ser alterada. Isso significa que quando você altera uma string, na verdade está criando uma nova string com as modificações desejadas. As strings são definidas entre aspas simples (`''`) ou duplas (`""`). Strings podem, ainda, ser escritas em diversas linhas utilizando aspas triplas (`””” ”””`).

Abaixo temos exemplos de sequências:

```python
# lista de strings
compras_mercado = ["banana", "aveia", "pão"]

# tupla de floats
coordenadas = (-23.588254, -46.632477)

# string
mensagem = "viu como é fácil criar sequências?"
```

Você pode, ainda, escrever cada uma dessas variáveis no terminal com a função `print()`, basta escrever o nome da variável desejada entre os parênteses.

### Sets ou Conjuntos

Os conjuntos em Python são usados para representar uma coleção não ordenada e mutável de valores únicos. Os conjuntos são definidos entre chaves (`{}`). O set em si é mutável, mas seus elementos devem ser imutáveis

O trecho abaixo ilustra a criação de um Set pela função `set()` com o valor que será convertido num set entre os parênteses.

```python
# lista de inteiros
lista_repetida = [1, 1, 2, 2, 3, 4, 4]

# set a partir de uma lista
set_unico = set(lista_repetida)

print(set_unico)
```

Se você rodar o código, terá o resultado:

```
$> {1, 2, 3, 4}
```

### Dicts ou Dicionários

Os dicionários em Python são usados para representar uma coleção de pares chave-valor. Cada chave deve ser única e é associada a um valor. Os dicionários são definidos entre chaves (`{}`), com a chave se separando do valor por por dois pontos (`:`) e cada par chave-valor se separando por vírgula.

O exemplo abaixo ilustra a criação de um Dict:

```python
dados_jogador = {
    "nome": "Pedro",
    "idade": 25,
    "apelido": "queixada",
    "time": "flamengo"
}

print(dados_jogador)
```

O resultado deste exemplo é:

```python
{'nome': 'Pedro', 'idade': 25, 'apelido': 'queixada', 'time': 'flamengo'}
```
[Próximo post](https://dev.to/iugstav/python-conceitos-e-palavras-reservadas-4740)