Tipos de Variáveis disponíveis no Python

Salve, salve senhor ou senhora Pythonista!

Nesse post vamos falar sobre os diversos Tipos de Variáveis do Python.

Independente se você vem de outra linguagem ou se está começando agora no Python, saber quais são e como utilizá-las é muito importante para quem desenvolve código em Python.

Vamos falar de todos os tipos para que você vire um verdadeiro Pythonista.

Vá Direto ao Assunto…

• O que são tipos de dados em Python?
• Introdução
• Tipo Inteiro (int)
• Ponto Flutuante ou Decimal (float)
• Complexo (complex)
• String (str)
• Booleano (bool)
• Listas (list)
• Tuplas (tuple)
• Dicionários (dict)
• Conjuntos (set e frozenset)
• Nulo (None)
• Tipos mutáveis e imutáveis em Python
• Como mudar o tipo de uma variável
• Erros comuns relacionados ao tipo da variável

O que são tipos de dados em Python?

Os tipos de dados em Python são as categorias que classificam um valor e definem o que é possível fazer com ele - por exemplo, int para números inteiros, str para texto e list para coleções. Em Python o tipo pertence ao objeto, não à variável: a variável é apenas um nome (uma referência) que aponta para um objeto na memória.

Isso é fundamental para entender a chamada tipagem dinâmica: a mesma variável pode apontar para objetos de tipos diferentes ao longo do programa, porque quem carrega o tipo é o objeto, não o nome.

1
2
3
4
5
6
7
8

x = 10              # x aponta para um objeto int
print(type(x))

x = "agora sou texto"   # o mesmo nome aponta para um str
print(type(x))

x = [1, 2, 3]       # e agora para uma list
print(type(x))

Saída:

1
2
3

<class 'int'>
<class 'str'>
<class 'list'>

Por isso, quando falamos de “tipo de variável” estamos, na prática, falando do tipo do objeto para o qual a variável aponta naquele momento.

Introdução

Vamos começar do começo!

Python é uma linguagem dinamicamente tipada, o que significa que não é necessário declarar o tipo da variável ou fazer casting (mudar o tipo de um objeto) manualmente, pois o Interpretador se encarrega disso para nós!

Isso significa também que o tipo do objeto referenciado por uma variável pode variar durante a execução do programa.

Os tipos de dados padrão do Python são:

• Inteiro (int)
• Ponto Flutuante ou Decimal (float)
• Tipo Complexo (complex)
• String (str)
• Booleano (bool)
• Lista (list)
• Tupla (tuple)
• Dicionário (dict)
• Conjunto (set e frozenset)
• Nulo (None, do tipo NoneType)

A tabela abaixo resume os principais tipos, com um exemplo, o que type() retorna e se o objeto é mutável (pode ser alterado depois de criado) ou não:

Tipo Inteiro (int)

O tipo int representa números inteiros em Python - valores numéricos sem componente decimal, que podem ser positivos, negativos ou zero.

Por ser inteiro, é o tipo usado para um número que pode ser escrito sem casas decimais, podendo ter ou não sinal, isto é: ser positivo ou negativo.

Por exemplo, 21, 4, 0, e −2048 são números inteiros, enquanto 9.75, 1/2, 1.5 não são.

Exemplos:

1
2
3
4
5

idade = 18
ano = 2002

print(type(idade))
print(type(ano))

Saída:

1
2

<class 'int'>
<class 'int'>

Ponto Flutuante ou Decimal (float)

O tipo float representa números decimais (com casas após a vírgula) em Python, como 1.80 ou 73.55.

O famoso ponto flutuante é usado para números racionais (números que podem ser representados por uma fração), informalmente conhecidos como “número quebrado”.

Exemplos:

1
2
3
4
5

altura = 1.80
peso = 73.55

print(type(peso))
print(type(altura))

Saída:

1
2

<class 'float'>
<class 'float'>

Complexo (complex)

Tipo de dado usado para representar números complexos (isso mesmo, aquilo que provavelmente estudou no terceiro ano do ensino médio).

Esse tipo normalmente é usado em cálculos geométricos e científicos.

Um tipo complexo contem duas partes: a parte real e a parte imaginária, sendo que a parte imaginária contem um j no sufixo.

A função complex(real[, imag]) do Python possibilita a criação de números imaginários passando como argumento: real, que é a parte Real do número complexo e o argumento opcional imag, representando a parte imaginária do número complexo.

Exemplos:

1
2
3
4
5
6

a = 5+2j
b = 20+6j

print(type(a))
print(type(b))
print(complex(2, 5))

Saída:

1
2
3

<class 'complex'>
<class 'complex'>
(2+5j)

String (str)

O tipo str representa texto em Python: um conjunto de caracteres dispostos numa determinada ordem, geralmente utilizado para representar palavras, frases ou textos. Strings são definidas entre aspas simples ('...') ou duplas ("...").

Exemplos:

1
2
3
4
5

nome = 'Guilherme'
profissao = 'Engenheiro de Software'

print(type(profissao))
print(type(nome))

Saída:

1
2

<class 'str'>
<class 'str'>

Booleano (bool)

O tipo bool representa um valor lógico em Python, que pode assumir apenas dois valores: verdadeiro ou falso (True ou False).

Na lógica computacional, podem ser considerados como 1 ou 0.

Exemplos:

1
2
3
4
5

fim_de_semana = True
feriado = False

print(type(fim_de_semana))
print(type(feriado))

Saída:

1
2

<class 'bool'>
<class 'bool'>

Curiosidade: em Python, bool é uma subclasse de int. Na prática, True vale 1 e False vale 0, então True == 1 é True e isinstance(True, int) retorna True - por isso é possível até somar booleanos (True + True resulta em 2).

Listas (list)

A list é uma coleção ordenada e mutável de elementos em Python - ou seja, mantém a ordem de inserção e pode ser alterada (adicionar, remover ou trocar itens) depois de criada. É um dos tipos mais importantes e muito utilizados no dia a dia do desenvolvedor Python!

Listas agrupam um conjunto de elementos variados, podendo conter: inteiros, floats, strings, outras listas e outros tipos.

Elas são definidas utilizando-se colchetes para delimitar a lista e vírgulas para separar os elementos, veja alguns exemplo abaixo:

1
2
3
4
5

alunos = ['Amanda', 'Ana', 'Bruno', 'João']
notas = [10, 8.5, 7.8, 8.0]

print(type(alunos))
print(type(notas))

Saída:

1
2

<class 'list'>
<class 'list'>

Aqui na Python Academy temos muito conteúdo sobre Listas para você ficar craque!

Para saber mais sobre Listas acesse nosso post sobre Listas, também nosso post sobre Manipulação de Listas, e nosso post completo sobre List Comprehensions.

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Tuplas (tuple)

A tuple é uma coleção ordenada e imutável de elementos em Python: assim como a lista, agrupa um conjunto de valores, mas, depois de criada, não pode ser modificada.

Sua forma de definição é diferente da lista: utilizamos parênteses, também separando os elementos por vírgula.

A diferença para a Lista é justamente a imutabilidade - após a definição, uma Tupla não pode ter seus itens alterados, o que a torna ideal para dados que não devem mudar.

Vamos ver alguns exemplos:

1
2
3
4
5

valores = (90, 79, 54, 32, 21)
pontos = (100, 94.05, 86.8, 62)

print(type(valores))
print(type(pontos))

Saída:

1
2

<class 'tuple'>
<class 'tuple'>

Caso haja uma tentativa de alterar os itens de uma tupla após sua definição, como no código a seguir:

1
2

numeros = (0, 1, 2, 3)
numeros[0] = 4

O seguinte erro do tipo TypeError será lançado pelo interpretador do Python:

1
2
3

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Dicionários (dict)

O dict é uma coleção mutável que organiza dados em pares de chave e valor - em vez de acessar elementos por posição, você os acessa pela chave. É um dos tipos mais flexíveis do Python.

Eles são utilizados para agrupar elementos através da estrutura de chave e valor, onde a chave é o primeiro elemento, seguido por dois pontos e pelo valor.

Vamos ver alguns exemplos:

1
2
3
4
5

altura = {'Amanda': 1.65, 'Ana': 1.60, 'João': 1.70}
peso = {'Amanda': 60, 'Ana': 58, 'João': 68}

print(type(altura))
print(type(peso))

Saída:

1
2

<class 'dict'>
<class 'dict'>

Dicionários possibilitam um tipo de manipulação muito poderosa, chamada de Dict Comprehensions! Você pode saber tudo sobre dict comprehensions clicando aqui e lendo nosso post sobre o assunto!

Criei o Ebookr.ai, uma plataforma que usa IA para gerar ebooks profissionais sobre qualquer tema - com capa gerada por IA, infográficos automáticos e exportação em PDF. Confere!

Conjuntos (set e frozenset)

O set é uma coleção não ordenada de elementos únicos em Python - ou seja, não garante ordem e não aceita itens repetidos, descartando automaticamente as duplicatas. É definido com chaves ({ }), assim como o dicionário, mas sem o par chave-valor.

1
2
3
4

tags = {'python', 'django', 'python', 'web'}

print(sorted(tags))
print(type(tags))

Saída:

1
2

['django', 'python', 'web']
<class 'set'>

Repare que a tag 'python', mesmo informada duas vezes, aparece apenas uma vez no resultado. Por isso o set é perfeito para remover duplicatas de uma coleção.

O frozenset é a versão imutável do set: tem o mesmo comportamento de conjunto (itens únicos, sem ordem garantida), mas não pode ser modificado após criado.

1
2
3
4
5

linguagens = {'python', 'ruby'}
permissoes = frozenset({'leitura', 'escrita'})

print(type(linguagens))
print(type(permissoes))

Saída:

1
2

<class 'set'>
<class 'frozenset'>

Nulo (None)

O None representa a ausência de valor em Python e é o único valor do tipo NoneType. É usado para indicar que uma variável existe, mas ainda não possui um valor significativo - e é o que uma função retorna quando não tem um return explícito.

1
2
3
4
5
6
7

def saudacao(nome):
    print(f'Olá, {nome}!')

retorno = saudacao('Ana')

print(retorno)
print(type(retorno))

Saída:

1
2
3

Olá, Ana!
None
<class 'NoneType'>

Para testar se uma variável é None, o correto é usar o operador is (if retorno is None:), e não ==, pois None é um objeto único na memória.

Tipos mutáveis e imutáveis em Python

Em Python, os tipos se dividem entre imutáveis (não podem ser alterados após criados) e mutáveis (podem ser modificados depois de criados). Como o tipo pertence ao objeto, essa distinção é uma propriedade do objeto, não da variável.

• Imutáveis: int, float, str, bool, tuple, frozenset e None (NoneType).
• Mutáveis: list, dict e set.

Na prática: tentar alterar um item de uma list funciona, mas fazer o mesmo em uma tuple (como vimos acima, em numeros[0] = 4) lança um TypeError, justamente por ela ser imutável.

Como mudar o tipo de uma variável

Para mudar o tipo de uma variável em Python, use as funções de conversão embutidas, como int(), float(), str() e bool(), passando o valor a ser convertido. Esse processo é chamado de casting e é muito simples - uma das vantagens de uma linguagem dinamicamente tipada.

Abaixo veremos exemplos de como converter entre os tipos mais comuns.

Decimal (float) para String (str)

1
2
3
4
5
6
7
8
9
10

# Antes da conversão
altura = 1.80
print(type(altura))

# Conversão do tipo
altura = str(altura)

# Depois da conversão
type(altura)
print(altura)

Saída:

1
2
3

<class 'float'>
<class 'str'>
'1.8'

Inteiro (int) para Decimal (float):

1
2
3
4
5
6
7
8
9
10

# Antes da conversão
idade = 18
print(type(idade))

# Conversão do tipo
idade = float(idade)

# Depois da conversão
print(type(idade))
print(idade)

Saída:

1
2
3

<class 'int'>
<class 'float'>
18.0

Booleano (bool) para Inteiro (int)

1
2
3
4
5
6
7
8
9
10

# Antes da conversão
fim_de_semana = True
print(type(fim_de_semana))

# Conversão do tipo
fim_de_semana = int(fim_de_semana)

# Depois da conversão
print(type(fim_de_semana))
print(fim_de_semana)

Saída:

1
2
3

<class 'bool'>
<class 'int'>
1

Erros comuns relacionados ao tipo da variável

Entre os erros mais comuns que acontecem principalmente com quem está iniciando sua jornada com a linguagem Python estão os famosos TypeError!

Portanto preste sempre atenção nesse tipo de erro pois ele está relacionado a tipagem errada de uma variável ou objeto.

Além disso, pode representar uma operação incompatível, como tentar fazer uma operação matemática com variáveis de tipo incompatíveis.

Por exemplo, suponha as seguintes variáveis, do tipo float e str, respectivamente:

1
2

peso = 65.55
altura = '1.7'

Se tentarmos fazer a seguinte operação:

1

imc = peso/altura**2

O seguinte erro será lançado:

1
2
3

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

Para fazer esse cálculo corretamente a altura não pode ser string, podendo ser float ou inteiro (caso não fosse um valor decimal).

Uma forma correta de realizar esse cálculo seria da seguinte maneira:

1
2
3
4

peso = 65.55
altura = 1.7
imc = peso/altura**2
print(imc)

Dessa forma, obteríamos a seguinte saída:

1

22.68166089965398

Sempre que o tipo TypeError aparecer em seu programa, preste atenção aos tipos dos dados e as operações que estão sendo executadas.

Caso seja necessário, faça a conversão das variáveis para se trabalhar com os tipos correto!

Conclusão

Espero que esse post tenha te ajudado a entender melhor os diversos tipos que o Python nos disponibiliza - de int, float e str a list, tuple, dict, set e None - além de fixar dois conceitos importantes: em Python o tipo pertence ao objeto (e não à variável) e cada tipo é mutável ou imutável.

Por Guilherme Euzébio em 19/06/2021

Com grandes poderes vêm grandes responsabilidades - Stan Lee

Bora se conectar no LinkedIn! guilhermeeuzebio

Minhas redes: