Inteiros e floats são os principais tipos de dados numéricos em Python. Com eles, você pode armazenar dados numéricos e realizar operações matemáticas. Vamos ver o que são inteiros e floats, como realizar cálculos aritméticos com eles e vários métodos que o Python oferece para trabalhar com ambos. Números inteiros são números inteiros sem pontos decimais, positivos ou negativos:

my_int_1 = 56
my_int_2 = -4

print(type(my_int_1)) # <class 'int'>
print(type(my_int_2)) # <class 'int'>

Aqui está como realizar uma operação de adição com inteiros:

my_int_1 = 56
my_int_2 = 12

sum_ints = my_int_1 + my_int_2
print('Integer Addition:', sum_ints) # Integer Addition: 68

Aqui está como realizar uma subtração com inteiros:

my_int_1 = 56
my_int_2 = 12

# Subtraction
diff_ints = my_int_1 - my_int_2
print('Integer Subtraction:', diff_ints) # Integer Subtraction: 44

Aqui está como realizar uma operação de multiplicação com inteiros:

my_int_1 = 12
my_int_2 = 4

# Multiplication
product_ints = my_int_1 * my_int_2
print('Integer Multiplication:', product_ints) # Integer Multiplication: 48

E aqui está como realizar uma operação de divisão com inteiros:

my_int_1 = 56
my_int_2 = 12

# Division
div_ints = my_int_1 / my_int_2
print('Division:', div_ints) # Division: 4.666666666666667

Números de ponto flutuante são números positivos ou negativos com casas decimais, como 3.14, -0.5 ou 0.0.

my_float_1 = -12.0
my_float_2 = 4.9

print(type(my_float_1)) # <class 'float'>
print(type(my_float_2)) # <class 'float'>

Aqui está uma operação de adição com floats:

my_float_1 = 5.4
my_float_2 = 12.0

float_addition = my_float_1 + my_float_2
print('Float Addition:', float_addition) # Float Addition: 17.4

Aqui está uma operação de subtração com floats:

my_float_1 = 5.4
my_float_2 = 12.0

float_subtraction = my_float_2 - my_float_1
print('Float Subtraction:', float_subtraction) # Float Subtraction: 6.6

Aqui está uma operação de multiplicação com floats:

my_float_1 = 5.4
my_float_2 = 12.0

float_multiplication = my_float_2 * my_float_1
print('Float Multiplication:', float_multiplication) # Float Multiplication: 64.80000000000001

E aqui está uma operação de divisão com floats:

my_float_1 = 5.4
my_float_2 = 12.0

float_division = my_float_2 / my_float_1
print('Float Division:', float_division) # Float Division: 2.222222222222222

Se você adicionar um inteiro e um float, o resultado é automaticamente convertido para um float:

my_int = 56
my_float = 5.4

sum_int_and_float = my_int + my_float

print(sum_int_and_float) # 61.4
print(type(sum_int_and_float)) # <class 'float'>

Isso é verdade para outras operações aritméticas básicas também, como subtração, multiplicação e divisão. Se você misturar inteiros e floats, Python retornará um float como resultado. Você também pode realizar cálculos aritméticos mais complexos, como obter o resto de dois números com o operador modulo, divisão inteira e exponenciação com inteiros e floats. O operador módulo (%) retorna o resto quando o valor à esquerda é dividido pelo valor à direita:

my_int_1 = 56
my_int_2 = 12

my_float_1 = 5.4
my_float_2 = 12.0

mod_ints = my_int_1 % my_int_2
mod_floats = my_float_2 % my_float_1

print('Integer Modulo:', mod_ints) # Integer Modulo: 8
print('Float Modulo:', mod_floats) # Float Modulo: 1.1999999999999993

A divisão inteira divide dois números e retorna o maior inteiro menor ou igual ao resultado. Isso é feito com o operador de barra dupla para frente (//):

my_int_1 = 56
my_int_2 = 12

my_float_1 = 5.4
my_float_2 = 12.0

floor_div_ints = my_int_1 // my_int_2
floor_div_floats = my_float_2 // my_float_1

print('Integer Floor Division:', floor_div_ints) # Integer Floor Division: 4
print('Float Floor Division:', floor_div_floats) # Float Floor Division: 2.0

A exponenciação eleva um número à potência de outro e é feita com o operador de dois asteriscos (**):

my_int_1 = 56
my_int_2 = 12

my_float_1 = 5.4
my_float_2 = 12.0

exp_ints = my_int_1 ** my_int_2
exp_floats = my_float_1 ** my_float_2

print('Integer Exponentiation:', exp_ints) # Integer Exponentiation: 951166013805414055936
print('Float Exponentiation:',  exp_floats) # Float Exponentiation: 614787626.1765089

Às vezes, você pode notar que o resultado de uma operação envolvendo floats tem mais dígitos decimais do que o esperado. Por exemplo, a soma 0.1 + 0.2 é igual a 0.30000000000000004 em vez de 0.3. Isso acontece porque os números são armazenados em formato binário e algumas frações não podem ser representadas exatamente em binário. Como resultado, elas são armazenadas como aproximações finitas, da mesma forma que a fração 1/3 não pode ser representada com um número finito de dígitos em decimal e é truncada após um certo número de seus dígitos infinitos (0.33333...). Isso leva a pequenos erros de arredondamento. Python também fornece funções internas para converter dados numéricos ou strings em inteiros ou floats. A função float() retorna um número de ponto flutuante construído a partir do número fornecido:

my_int_1 = 56
my_float_1 = float(my_int_1)

print(my_float_1)  # 56.0
print(type(my_float_1))  # <class 'float'>

A função int() retorna um inteiro construído a partir do número fornecido:

my_float = 12.92563
my_int = int(my_float)

print(my_int)  # 12
print(type(my_int))  # <class 'int'>

Além disso, você pode usar as mesmas funções internas para converter uma string em um float ou integer:

my_str_int = '45'
my_str_float = '7.8'

converted_int = int(my_str_int)
converted_float = float(my_str_float)

print(converted_int, type(converted_int))  # 45 <class 'int'>
print(converted_float, type(converted_float))  # 7.8 <class 'float'>

Aqui estão alguns outros métodos que o Python fornece para trabalhar com inteiros e floats.

• round(): Arredonda um número para o número especificado de casas decimais. Por padrão essa função arredonda para o inteiro mais próximo e retorna um número inteiro sem casas decimais:

my_int_1 = 4.798
my_int_2 = 4.253

rounded_int_1 = round(my_int_1)
rounded_int_2 = round(my_int_2, 1)

print(rounded_int_1) # 5
print(rounded_int_2) # 4.3

• abs(): retorna o valor absoluto de um número,

num = -15

absolute_value = abs(num)
print(absolute_value) # 15

• pow(): eleva um número à potência de outro ou realiza exponenciação modular.

result_1 = pow(2, 3)  # Equivalent to 2 ** 3
print(result_1)  # 8

result_2 = pow(2, 3, 5)  # (2 ** 3) % 5
print(result_2)  # 3