Variáveis e Tipos de Dados no Python: int, float, str, bool, list e mais

1
2
3
4
5
6

idade = 30
nome = "Ana"
notas = [8.5, 9.0]
print(type(idade))  # <class 'int'>
print(type(nome))   # <class 'str'>
print(type(notas))  # <class 'list'>

Salve, salve senhor ou senhora Pythonista!

Nesse post vamos falar sobre os diversos Tipos de Variáveis do Python: o que cada um guarda, como declarar variáveis, como converter de um tipo para outro e quais erros aparecem quando os tipos não combinam.

Vá Direto ao Assunto…

• O que são tipos de dados em Python?
• Como declarar uma variável em Python (e regras de nomes)
• 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
• Tipagem dinâmica e type hints
• Como mudar o tipo de uma variável
• Erros comuns relacionados ao tipo da variável
• Erros comuns
• Exercícios resolvidos

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.

A lista completa dos tipos embutidos, com todas as operações de cada um, está na documentação oficial sobre tipos embutidos.

Como declarar uma variável em Python (e regras de nomes)

Uma variável em Python é um nome que guarda uma referência para um valor na memória. Para criar (ou “declarar”) uma variável, basta escrever o nome, o sinal de atribuição = e o valor. Não existe palavra-chave como var ou let, e você não informa o tipo: o Python descobre o tipo a partir do valor.

1
2
3
4
5
6
7
8
9

nome = "Maria"
idade = 25
altura = 1.68

x, y, z = 1, 2, 3   # várias variáveis em uma linha
a = b = 0           # o mesmo valor para duas variáveis

print(nome, idade, altura)
print(x, y, z, a, b)

Saída:

1
2

Maria 25 1.68
1 2 3 0 0

A variável só passa a existir quando recebe um valor. Usar um nome antes de atribuir algo a ele gera NameError.

Regras de nomes de variáveis (quebrar qualquer uma delas gera SyntaxError):

• O nome deve começar com uma letra ou com underline (_). Nunca com número: 1nome é inválido, nome1 é válido.
• Depois do primeiro caractere, use apenas letras, números e _. Espaço, hífen e símbolos não são permitidos: minha-idade é inválido, minha_idade é válido.
• O nome não pode ser uma palavra reservada da linguagem, como class, if, for, def, True ou None.
• O Python diferencia maiúsculas de minúsculas: idade e Idade são duas variáveis diferentes.

1
2
3

idade = 30
Idade = 40
print(idade, Idade)

Saída:

1

30 40

Além das regras, há as convenções da PEP 8, o guia de estilo oficial do Python: nomes de variáveis em minúsculas com palavras separadas por _ (o chamado snake_case, como preco_total), nomes descritivos (quantidade em vez de q) e nada de reaproveitar nomes de funções embutidas, como list, str, dict, input ou sum (veja o porquê em Erros comuns).

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: o interpretador descobre o tipo a partir do valor atribuído. Já a conversão entre tipos (o casting), quando necessária, é feita por você, com funções como int(), float() e str() (veja em Como mudar o tipo de uma variável).

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 (muitas vezes chamados de “tipos primitivos” em apostilas e provas) 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:

Qual tipo usar para cada dado? Na hora de modelar um programa (ou responder uma questão de prova), pense no que você vai fazer com o valor:

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'>

Para que serve o int? Para tudo que é contado: idade, quantidade de itens, ano, posição em uma lista, número de tentativas. Em Python o int não tem limite de tamanho (só o da memória), então 2 ** 100 funciona sem estouro. Atenção a um detalhe que cai muito em prova: a divisão com / sempre devolve float (10 / 2 resulta em 5.0), enquanto a divisão inteira // devolve int (10 // 3 resulta em 3). Veja todos os operadores no post sobre operadores aritméticos e lógicos em Python.

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'>

Repare que o separador decimal no Python é o ponto, nunca a vírgula: altura = 1,80 não cria um float, e sim uma tupla com dois inteiros, (1, 80). Outro ponto importante: o float é armazenado em binário e nem todo decimal tem representação exata, por isso 0.1 + 0.2 não dá exatamente 0.3 (veja em Erros comuns).

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'>

Todo valor lido com input() chega como str, mesmo quando o usuário digita um número. Por isso "10" + "5" resulta em "105" (as strings são concatenadas) e não em 15. Para aprofundar em fatiamento, métodos como upper() e split() e formatação, veja o post completo sobre strings no Python.

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'>

Para acessar um valor, use a chave entre colchetes: altura['Ana'] retorna 1.6. Métodos como get(), keys(), values() e items() estão explicados no post sobre dicionários no Python.

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. Cuidado com um detalhe: {} vazio cria um dicionário, não um conjunto; para um set vazio, use set(). Operações como união e interseção estão no post sobre sets no Python.

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.

Tipagem dinâmica e type hints

Python tem tipagem dinâmica: o tipo é verificado durante a execução e está no valor, não no nome. Por isso a mesma variável pode receber um int e, depois, uma str. Ao mesmo tempo, Python tem tipagem forte: ele não converte tipos por conta própria em operações que não fazem sentido, e é por isso que "idade: " + 30 gera TypeError em vez de virar texto.

Desde o Python 3.5 (para funções) e o 3.6 (para variáveis) você pode anotar o tipo esperado de variáveis, parâmetros e retornos com os chamados type hints (dicas de tipo). A sintaxe é nome: tipo = valor:

1
2
3
4
5
6
7
8
9
10
11

idade: int = 30
nome: str = "Ana"
precos: list[float] = [9.9, 15.0]

def calcular_total(preco: float, quantidade: int) -> float:
    return preco * quantidade

print(calcular_total(12.5, 4))

idade = "trinta"   # o Python NÃO impede isso
print(idade, type(idade))

Saída:

1
2

50.0
trinta <class 'str'>

Repare na última parte: as anotações não são verificadas pelo interpretador em tempo de execução. Elas servem de documentação e são usadas por editores (autocompletar) e por ferramentas como o mypy, que apontam o erro antes de você rodar o programa. A sintaxe list[float] funciona a partir do Python 3.9; em versões anteriores, use List[float] do módulo typing. Os detalhes estão na documentação do módulo typing e na PEP 484, que introduziu as dicas de tipo. Para ver anotações em funções com mais calma, leia o post sobre funções em Python.

Saber os tipos de cor é importante, mas o que separa quem estuda de quem programa é aplicar isso em projetos reais, com suporte de um professor. É esse o formato da Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

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
print(type(altura))
print(altura)

Saída:

1
2
3

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

Note que o zero final some: str(1.80) resulta em '1.8', porque o float 1.80 é o mesmo número que 1.8. Para mostrar sempre duas casas, formate com f-string: f"{altura:.2f}".

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

String (str) para Inteiro (int) e Decimal (float)

Essa é a conversão mais usada no dia a dia, porque o input() sempre devolve texto. Para fazer contas com o que o usuário digitou, converta com int() ou float():

1
2
3
4
5
6

quantidade = int("3")
preco = float("19.5")
print(quantidade * preco)

print(int(3.99))           # int() corta a parte decimal, não arredonda
print(int(float("3.5")))   # texto com ponto: converta para float primeiro

Saída:

1
2
3

58.5
3
3

Com input(), a conversão costuma ser feita na mesma linha: idade = int(input("Idade: ")) ou altura = float(input("Altura: ")). Se o texto não for um número válido (por exemplo "25 anos" ou "3,5" com vírgula), o Python lança ValueError. O post sobre input e print no Python mostra como tratar esses casos.

Quais valores viram False com bool()

A função bool() converte qualquer valor em True ou False. A regra é simples: zero, vazio e None viram False; todo o resto vira True.

1
2
3
4

valores = [0, "0", "", [], " ", None, 0.0, "False"]

for valor in valores:
    print(repr(valor), "->", bool(valor))

Saída:

1
2
3
4
5
6
7
8

0 -> False
'0' -> True
'' -> False
[] -> False
' ' -> True
None -> False
0.0 -> False
'False' -> True

Repare nas pegadinhas: a string "0", a string com um espaço " " e até a string "False" viram True, porque não são vazias. É essa mesma regra que o if usa quando você escreve if lista: ou if nome:.

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!

Erros comuns

Além do TypeError visto acima, estes são os erros de tipo e de variável que mais aparecem para quem está começando. Os tracebacks são reais, gerados rodando cada script com python3 main.py.

1. ValueError: invalid literal for int() with base 10

1

idade = int("25 anos")

1
2
3
4

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    idade = int("25 anos")
ValueError: invalid literal for int() with base 10: '25 anos'

Correção: o int() só aceita texto que represente um número inteiro (espaços nas pontas são tolerados). O mesmo erro aparece com int("3.5") e com int(input()) quando o usuário digita um decimal. Passe só os dígitos, ou use float() se o valor pode ter casas decimais: int(float("3.5")) resulta em 3.

2. TypeError ao somar str e int

1
2

idade = 25
print("Você tem " + idade + " anos")

1
2
3
4

Traceback (most recent call last):
  File "main.py", line 2, in <module>
    print("Você tem " + idade + " anos")
TypeError: can only concatenate str (not "int") to str

Correção: o + entre textos concatena, entre números soma, mas não mistura os dois. Converta o número com str(idade) ou, melhor ainda, use uma f-string, que converte sozinha:

1
2
3

idade = 25
print("Você tem " + str(idade) + " anos")
print(f"Você tem {idade} anos")

Saída:

1
2

Você tem 25 anos
Você tem 25 anos

3. SyntaxError por nome de variável inválido

1

minha-idade = 25

1
2
3

  File "main.py", line 1
    minha-idade = 25
SyntaxError: cannot assign to expression here. Maybe you meant '==' instead of '='?

Correção: o hífen é lido como o operador de subtração, então o Python entende minha - idade = 25. Use underline: minha_idade = 25. Pelo mesmo motivo, 1nome = "Ana" (começa com número) gera SyntaxError: invalid decimal literal e class = "3A" (palavra reservada) gera SyntaxError: invalid syntax. A mensagem exata varia um pouco entre versões do Python, mas o tipo do erro é sempre SyntaxError.

4. TypeError: 'list' object is not callable (nome embutido sobrescrito)

1
2

list = [1, 2, 3]
numeros = list((4, 5, 6))

1
2
3
4

Traceback (most recent call last):
  File "main.py", line 2, in <module>
    numeros = list((4, 5, 6))
TypeError: 'list' object is not callable

Correção: ao criar uma variável chamada list, você esconde a função embutida list() até o fim do programa. O mesmo acontece com str = "texto" seguido de str(25), que gera TypeError: 'str' object is not callable. Use nomes descritivos, como numeros ou texto. Se isso já aconteceu, del list apaga a sua variável e devolve acesso à função original.

5. 0.1 + 0.2 não é igual a 0.3 (float)

1
2
3

total = 0.1 + 0.2
print(total)
print(total == 0.3)

1
2

0.30000000000000004
False

Não é bug do Python: o float é guardado em binário, e valores como 0.1 não têm representação exata (a documentação oficial explica a aritmética de ponto flutuante). Correção: nunca compare float com ==. Use math.isclose(), arredonde com round() ou, para dinheiro, use Decimal criado a partir de string:

1
2
3
4
5
6
7

import math
from decimal import Decimal

total = 0.1 + 0.2
print(math.isclose(total, 0.3))
print(round(total, 2) == 0.3)
print(Decimal("0.1") + Decimal("0.2"))

Saída:

1
2
3

True
True
0.3

Exercícios resolvidos

Tente resolver cada um antes de abrir a solução. Nos exercícios com input(), o comentário mostra o que foi digitado no teste.

Exercício 1. Mostre o nome do tipo de cada um destes valores: 7, 7.0, "7", True, [7], (7,), {7} e None.

1
2
3
4

valores = [7, 7.0, "7", True, [7], (7,), {7}, None]

for valor in valores:
    print(repr(valor), "->", type(valor).__name__)

1
2
3
4
5
6
7
8

7 -> int
7.0 -> float
'7' -> str
True -> bool
[7] -> list
(7,) -> tuple
{7} -> set
None -> NoneType

Exercício 2. Leia a idade do usuário e mostre quantos anos ele terá daqui a 10 anos.

1
2

idade = int(input("Qual a sua idade? "))  # Qual a sua idade? 17
print(f"Daqui a 10 anos você terá {idade + 10} anos.")

Exercício 3 (questão de prova). Qual é o tipo da variável x após a execução de x = 10 / 2?

a) int
b) float
c) str
d) O código gera erro

1
2

x = 10 / 2
print(x, type(x))

Exercício 4 (questão de prova). Ao criar uma função para calcular o valor total de uma compra, um estudante escreveu o código abaixo e, ao executar, digitou 10 para o preço e 3 para a quantidade. O que acontece?

1
2
3
4
5
6

def calcular_total(preco, quantidade):
    return preco * quantidade

preco = input("Preço: ")            # Preço: 10
quantidade = input("Quantidade: ")  # Quantidade: 3
print(calcular_total(preco, quantidade))

a) Mostra 30
b) Mostra 30.0
c) Mostra 103
d) Gera um TypeError

1

TypeError: can't multiply sequence by non-int of type 'str'

1
2
3
4
5
6

def calcular_total(preco, quantidade):
    return preco * quantidade

preco = float(input("Preço: "))          # Preço: 10
quantidade = int(input("Quantidade: "))  # Quantidade: 3
print(calcular_total(preco, quantidade))

Exercício 5 (questão de prova). Qual das opções abaixo é um nome de variável válido em Python?

a) 2nota
b) nota-final
c) nota_final
d) class

1
2

nota_final = 8.5
print(nota_final)

Exercício 6. Você recebeu as notas de um aluno como texto: ["8", "7.5", "10"]. Converta para float e calcule a média.

1
2
3
4

notas_texto = ["8", "7.5", "10"]
notas = [float(nota) for nota in notas_texto]
media = sum(notas) / len(notas)
print(notas, media)

Exercício 7. Qual é a saída do código abaixo? Explique a diferença entre a e s.

1
2
3
4
5
6
7
8
9

a = [1, 2, 3]
b = a
b.append(4)

s = "oi"
t = s
t += "!"

print(a, s)

Exercício 8. Monte um dicionário aluno com os campos nome (texto), idade (inteiro), altura (decimal) e matriculada (lógico), e mostre cada campo com o nome do seu tipo.

1
2
3
4

aluno = {"nome": "Ana", "idade": 20, "altura": 1.65, "matriculada": True}

for campo, valor in aluno.items():
    print(f"{campo}: {valor!r} ({type(valor).__name__})")

1
2
3
4

nome: 'Ana' (str)
idade: 20 (int)
altura: 1.65 (float)
matriculada: True (bool)

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.

O próximo passo é usar esses tipos para resolver problemas de verdade: ler dados do usuário, tomar decisões e repetir tarefas. Se quiser praticar isso com projetos guiados, do básico ao avançado, conheça o nosso curso de Python completo.

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:

• 
• 
•