Números em Python: inteiros, floats e matemática na prática

Iniciante20 min6 exercícios110 XP

Este tutorial foi traduzido do original em inglês.Read in English Leer en español Читать на русском อ่านภาษาไทย Avisar sobre um erro de tradução

Antes de começar

Variáveis e tipos de dados em Python: uma introdução prática

0/6 exercícios

Você está dividindo a conta do restaurante com três amigos. O total deu R$ 85. Quanto cada pessoa paga? Você pega a calculadora do celular, mas quem programa em Python digita 85 / 4 e tem a resposta na hora.

A matemática é a base da programação. Jogos usam matemática para a física. Aplicativos usam para calcular preços. A ciência de dados depende dela. A boa notícia? Com Python, fazer contas parece usar uma calculadora turbinada.

Neste tutorial, você vai aprender como o Python lida com números, quais operadores existem e como evitar os erros que mais confundem iniciantes. No final, você vai fazer cálculos do dia a dia com confiança.

O que são inteiros e floats?

O Python tem dois tipos principais de números. Os números inteiros (int) são números sem casa decimal. Os números de ponto flutuante (float) são números com casa decimal.

Pense em dinheiro. "5 reais" é um inteiro. "5,99 reais" é um float. As casas decimais fazem toda a diferença.

Inteiros e floats

# Integers - whole numbers

students = 30

lives = 3

year = 2025

negative = -15

# Floats - decimal numbers

price = 9.99

temperature = 98.6

pi = 3.14159

tiny = 0.001

print(type(students)) # <class 'int'>

print(type(price)) # <class 'float'>

print(type(negative)) # <class 'int'>

print(type(temperature)) # <class 'float'>

Saída

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

Quando usar cada um? Use inteiros para coisas que você conta: pessoas, itens, pontos, vidas. Use floats para coisas que você mede: peso, temperatura, porcentagens, dinheiro.

Como fazer contas em Python

O Python tem todas as operações matemáticas básicas que você já conhece. Os símbolos são quase iguais aos que você escreveria no papel.

Os quatro operadores básicos

# Addition

print(10 + 3) # 13

# Subtraction

print(10 - 3) # 7

# Multiplication

print(10 * 3) # 30

# Division (always returns a float!)

print(10 / 3) # 3.3333333333333335

Saída

13
7
30
3.3333333333333335

Adição, subtração e multiplicação funcionam do jeito que você espera. A divisão tem uma surpresa: ela sempre retorna um float, mesmo quando o resultado é um número inteiro.

A divisão sempre retorna um float

# Division ALWAYS gives a float

print(10 / 2) # 5.0 - not 5!

print(type(10 / 2)) # <class 'float'>

# Even when both numbers are integers

print(100 / 10) # 10.0

print(8 / 4) # 2.0

Saída

5.0
<class 'float'>
10.0
2.0

Você pode fazer contas com variáveis do mesmo jeito que com números. É aqui que a coisa fica útil.

Contas com variáveis

# Real-world example: calculating a total

price = 12.50

quantity = 4

tax_rate = 0.08

subtotal = price * quantity

tax = subtotal * tax_rate

total = subtotal + tax

print(f"Subtotal: ${subtotal}")

print(f"Tax: ${tax}")

print(f"Total: ${total}")

Saída

Subtotal: $50.0
Tax: $4.0
Total: $54.0

O que são a divisão inteira (//) e o módulo (%)?

O Python tem dois operadores especiais que andam juntos como goiabada e queijo: a divisão inteira (//) e o módulo (%). Eles respondem a duas perguntas diferentes sobre a mesma divisão.

Imagine que você tem 17 biscoitos e 5 amigos. 17 // 5 diz que cada amigo recebe 3 biscoitos. 17 % 5 diz que sobram 2 biscoitos.

Como funciona a divisão inteira (//)?

A divisão inteira (//) divide e arredonda para baixo até o número inteiro mais próximo. Com números positivos, isso significa descartar a parte decimal.

Divisão inteira com //

# Regular division vs integer division

print(17 / 5) # 3.4 - regular division (float)

print(17 // 5) # 3 - integer division (rounds down)

print(10 / 3) # 3.3333333333333335

print(10 // 3) # 3

print(7 / 2) # 3.5

print(7 // 2) # 3

# Works with negative numbers too (rounds toward negative infinity)

print(-17 // 5) # -4 (not -3!)

Saída

3.4
3
3.3333333333333335
3
3.5
3
-4

Como funciona o operador módulo (%)?

O operador módulo (%) retorna o resto da divisão. Ele é muito útil e aparece mais do que você imagina.

Operador módulo (%)

# Modulo gives the remainder

print(17 % 5) # 2 (17 = 5*3 + 2)

print(10 % 3) # 1 (10 = 3*3 + 1)

print(20 % 4) # 0 (20 = 4*5 + 0, divides evenly)

print(7 % 2) # 1 (7 = 2*3 + 1)

# The classic use: check if a number is even or odd

number = 42

if number % 2 == 0:

print(f"{number} is even")

else:

print(f"{number} is odd")

Saída

2
1
0
1
42 is even

O uso mais comum do módulo é verificar se uma divisão é exata. Se x % y == 0, então x é divisível por y. É assim que você verifica se um número é par ou ímpar, se um ano é bissexto e muito mais.

Como usar potências em Python

O Python usa ** para potenciação (elevar um número a uma potência). Linguagens como C e Java usam uma função para isso, mas no Python é um operador. Direto e limpo.

Potências com **

# Exponentiation with **

print(2 ** 3) # 8 (2 cubed: 2 * 2 * 2)

print(5 ** 2) # 25 (5 squared: 5 * 5)

print(10 ** 6) # 1000000 (10 to the 6th power)

# Works with floats too

print(9 ** 0.5) # 3.0 (square root of 9!)

print(27 ** (1/3)) # 3.0 (cube root of 27)

Saída

Um truque legal: elevar um número a 0.5 dá a raiz quadrada dele. E ** (1/3) dá a raiz cúbica. Você não precisa de uma função especial para raízes simples.

Juros compostos com potências

# Practical example: compound interest

# Formula: A = P * (1 + r) ** t

principal = 1000 # Starting amount

rate = 0.05 # 5% annual interest

years = 10 # Time period

amount = principal * (1 + rate) ** years

print(f"${principal} at {rate*100}% for {years} years = ${round(amount, 2)}")

Saída

$1000 at 5.0% for 10 years = $1628.89

Qual é a ordem das operações em Python?

O Python segue a mesma ordem das operações que você aprendeu nas aulas de matemática. Talvez você conheça a sigla em inglês PEMDAS: Parênteses, Expoentes, Multiplicação/Divisão, Adição/Subtração.

Ordem das operações

# Without parentheses - follows PEMDAS

print(2 + 3 * 4) # 14 (not 20!) - multiplication first

print(10 - 2 ** 3) # 2 - exponent first: 2**3=8, then 10-8=2

print(10 + 6 / 2) # 13.0 - division first: 6/2=3, then 10+3

# With parentheses - you control the order

print((2 + 3) * 4) # 20 - parentheses force addition first

print((10 - 2) ** 3) # 512 - parentheses first: 8**3=512

print((10 + 6) / 2) # 8.0 - parentheses first: 16/2=8

Saída

Esta é a lista completa de prioridades, da maior para a menor:

() - Parênteses (sempre primeiro)

** - Potenciação

-x - Negação, um sinal de menos na frente de um valor (por isso -2 ** 2 dá -4)

*, /, //, % - Multiplicação, divisão, divisão inteira, módulo

+, - - Adição e subtração

Confuso: depende da precedência dos operadores

result = base + rate * hours - discount / 2
print(result)

Claro: os parênteses mostram a intenção

result = base + (rate * hours) - (discount / 2)
print(result)

Quais funções matemáticas embutidas o Python tem?

O Python vem com várias funções embutidas para tarefas matemáticas comuns. Não é preciso importar nada: elas estão disponíveis em qualquer lugar.

Como usar abs(), round(), min() e max()

abs() e round()

# abs() - absolute value (distance from zero)

print(abs(-10)) # 10

print(abs(10)) # 10

print(abs(-3.7)) # 3.7

# round() - round to nearest value

print(round(3.7)) # 4

print(round(3.2)) # 3

print(round(3.14159, 2)) # 3.14 (round to 2 decimal places)

print(round(1234, -2)) # 1200 (round to nearest hundred!)

Saída

min() e max()

# min() - smallest value

print(min(5, 3, 8, 1)) # 1

print(min(-10, -20, -5)) # -20

# max() - largest value

print(max(5, 3, 8, 1)) # 8

print(max(-10, -20, -5)) # -5

# Practical: clamp a value between bounds

score = 150

clamped = min(max(score, 0), 100) # Keep between 0 and 100

print(f"Score {score} clamped to {clamped}") # Score 150 clamped to 100

Saída

1
-20
8
-5
Score 150 clamped to 100

Como converter entre inteiros e floats

Às vezes você precisa trocar o tipo de um número. Use int() para converter um float em inteiro e float() para converter um inteiro em float.

Convertendo entre tipos de número

# float → int (truncates, does NOT round)

print(int(3.9)) # 3 - chops off the decimal

print(int(3.1)) # 3

print(int(-2.7)) # -2 - truncates toward zero

# int → float

print(float(42)) # 42.0

print(float(-7)) # -7.0

# string → numbers

print(int("25")) # 25

print(float("3.14")) # 3.14

Saída

3
3
-2
42.0
-7.0
25
3.14

O Python também faz conversão automática em algumas situações. Quando você mistura um inteiro e um float numa operação, o Python converte o inteiro em float automaticamente.

Promoção automática de tipo

# Mixing int and float - Python "promotes" to float

result = 5 + 2.0

print(result) # 7.0 (float, not int)

print(type(result)) # <class 'float'>

# This happens with all operators

print(10 * 1.5) # 15.0

print(7 - 0.5) # 6.5

print(type(3 + 0.0)) # <class 'float'>

Saída

7.0
<class 'float'>
15.0
6.5
<class 'float'>

Quais são os erros comuns com números em Python?

Vamos ver os erros que mais confundem quem está começando em Python. Conhecê-los com antecedência vai poupar horas de depuração.

Erro 1: esperar que / retorne um inteiro

Bug: esperar um inteiro de /

total_items = 10
people = 2
each = total_items / people
print(f"Each gets {each} items")  # "Each gets 5.0 items"

Correção: use // para ter um resultado inteiro

total_items = 10
people = 2
each = total_items // people
print(f"Each gets {each} items")  # "Each gets 5 items"

Erro 2: confundir / e //

A diferença entre / e //

# / gives the full decimal answer

print(7 / 2) # 3.5

# // rounds DOWN to a whole number

print(7 // 2) # 3

# They give very different results!

print(15 / 4) # 3.75

print(15 // 4) # 3

Saída

Erro 3: esquecer os parênteses nas fórmulas

Bug: resultado errado sem parênteses

# Converting Fahrenheit to Celsius
fahrenheit = 212
celsius = fahrenheit - 32 * 5 / 9
print(celsius)  # 194.22... WRONG!

Correção: os parênteses garantem a ordem certa

# Converting Fahrenheit to Celsius
fahrenheit = 212
celsius = (fahrenheit - 32) * 5 / 9
print(celsius)  # 100.0 CORRECT!

Exercícios práticos

Hora de colocar suas habilidades com números em prática! Estes exercícios usam situações do dia a dia para você ver como a matemática do Python se aplica a problemas reais.

Tente resolver cada um sozinho antes de olhar as dicas. Errar faz parte do aprendizado.

Exercício 1: calcule o custo total

Escreva o código

Você está comprando itens numa loja. Calcule o custo total e exiba o resultado.

3 cadernos a $4,50 cada

2 canetas a $1,25 cada

Exiba o total exatamente neste formato:

Total: $16.0

# Item prices and quantities

notebook_price = 4.50

notebook_qty = 3

pen_price = 1.25

pen_qty = 2

# Calculate the total cost

# Print the result

Exercício 2: verificador de par ou ímpar

Escreva o código

Use o operador módulo (%) para verificar se um número é par ou ímpar.

A variável number já vem com o valor 37. Exiba o resultado exatamente neste formato:

37 is odd

Se o número fosse par (como 42), a saída seria:

42 is even

number = 37

# Use modulo to check if number is even or odd

# Print: "{number} is even" or "{number} is odd"

Exercício 3: corrija o bug: divisão errada

Corrija o erro

Este código deveria dividir 10 pizzas igualmente entre 3 grupos e informar quantas sobram. Mas ele usa os operadores de divisão errados!

Corrija o código para que a saída seja:

Each group gets 3 pizzas
Leftover pizzas: 1

total_pizzas = 10

groups = 3

# Bug: using the wrong division operators

pizzas_each = total_pizzas / groups

leftover = total_pizzas / groups

print(f"Each group gets {pizzas_each} pizzas")

print(f"Leftover pizzas: {leftover}")

Exercício 4: conversor de Fahrenheit para Celsius

Escreva o código

Converta uma temperatura de Fahrenheit para Celsius usando esta fórmula:

**Celsius = (Fahrenheit - 32) * 5 / 9**

A variável fahrenheit já vem com o valor 72. Calcule o valor em Celsius, arredonde para 1 casa decimal e exiba:

72F = 22.2C

fahrenheit = 72

# Convert to Celsius using the formula

# Round to 1 decimal place

# Print the result

Exercício 5: preveja a saída

Preveja a saída

Sem executar o código, tente prever o que cada linha vai exibir. Escreva suas previsões como comentários e depois execute o código para conferir.

print(10 // 3) # Your prediction:

print(10 % 3) # Your prediction:

print(2 ** 4) # Your prediction:

print(15 // 4) # Your prediction:

print(15 % 4) # Your prediction:

print(type(10 / 2)) # Your prediction:

Exercício 6: calculadora de juros compostos

Escreva o código

Calcule juros compostos usando esta fórmula:

**A = P * (1 + r) t

Onde:

P = capital (valor inicial) = $1000

r = taxa de juros anual = 0,05 (5%)

t = número de anos = 10

A = montante final

Calcule o montante final e os juros obtidos, depois exiba:

Final amount: $1628.89
Interest earned: $628.89

Arredonde os dois valores para 2 casas decimais.

principal = 1000

rate = 0.05

years = 10

# Calculate the final amount using the formula

# Calculate interest earned (final - principal)

# Print the results

Resumo: números e matemática em Python

Aqui está uma referência rápida de todos os operadores e funções deste tutorial:

Operador	Nome	Exemplo	Resultado
`+`	Adição	`5 + 3`	`8`
`-`	Subtração	`5 - 3`	`2`
`*`	Multiplicação	`5 * 3`	`15`
`/`	Divisão	`5 / 3`	`1.666...`
`//`	Divisão inteira	`5 // 3`	`1`
`%`	Módulo (resto)	`5 % 3`	`2`
`**`	Potenciação	`5 ** 3`	`125`

Funções embutidas:

Função	Para que serve	Exemplo
`abs(x)`	Valor absoluto	`abs(-5)` → `5`
`round(x, n)`	Arredonda para n casas decimais	`round(3.14, 1)` → `3.1`
`min(a, b, ...)`	Menor valor	`min(3, 1, 4)` → `1`
`max(a, b, ...)`	Maior valor	`max(3, 1, 4)` → `4`
`int(x)`	Converte para inteiro	`int(3.9)` → `3`
`float(x)`	Converte para float	`float(5)` → `5.0`

O que vem a seguir?

No próximo tutorial, Strings em Python, você vai aprender a trabalhar com texto em Python. Você vai conhecer o fatiamento, os métodos de string e como juntar strings e números numa saída fácil de ler.

O que são inteiros e floats?

Como fazer contas em Python

O que são a divisão inteira (//) e o módulo (%)?

Como funciona a divisão inteira (//)?

Como funciona o operador módulo (%)?

Como usar potências em Python

Qual é a ordem das operações em Python?

Quais funções matemáticas embutidas o Python tem?

Como usar abs(), round(), min() e max()

Como converter entre inteiros e floats

Quais são os erros comuns com números em Python?

Erro 1: esperar que / retorne um inteiro

Erro 2: confundir / e //

Erro 3: esquecer os parênteses nas fórmulas

Exercícios práticos

Resumo: números e matemática em Python

O que vem a seguir?

Tutoriais relacionados