Tipos Numéricos e Operações em Python

Introdução

Neste laboratório, você obterá uma compreensão fundamental dos tipos de números e operações em Python. Exploraremos as características dos tipos de números inteiros, booleanos, de ponto flutuante (floating-point) e complexos, incluindo sua imutabilidade e como verificar seus tipos e endereços de memória. Através de exercícios práticos, você aprenderá a converter entre diferentes tipos numéricos e a realizar operações aritméticas básicas, solidificando seu conhecimento sobre as capacidades numéricas do Python.

Explore Tipos Inteiro e Booleano

Nesta etapa, exploraremos os tipos de dados inteiros (int) e booleanos (bool) em Python. Inteiros são números inteiros, como 10, -5 ou 0. Booleanos representam um de dois valores: True ou False, e são um subtipo de inteiros.

Um conceito importante em Python é a imutabilidade. Os tipos numéricos são imutáveis, o que significa que, uma vez que um objeto numérico é criado, seu valor não pode ser alterado. Se você reatribuir uma variável a um novo número, ela apontará para um novo objeto na memória. Podemos verificar isso usando a função nativa id(), que retorna o endereço de memória exclusivo de um objeto, e a função type(), que mostra seu tipo de dado.

O ambiente de laboratório já criou um arquivo para você. No explorador de arquivos do WebIDE à esquerda, abra o arquivo ~/project/number_types.py. Adicione o seguinte código a ele:

## Demonstrate immutability of integers
a = 5
print(f"Initial value of a: {a}")
print(f"Type of a: {type(a)}")
print(f"ID of a: {id(a)}")

## Reassign 'a' to a new value
a = 6
print(f"\nNew value of a: {a}")
print(f"New ID of a: {id(a)}")

## Demonstrate boolean type
print("\n--- Boolean Types ---")
is_true = True
is_false = False
print(f"Value of is_true: {is_true}, Type: {type(is_true)}")
print(f"Value of is_false: {is_false}, Type: {type(is_false)}")

## Booleans behave like integers (1 and 0) in arithmetic
print(f"\nTrue + 5: {True + 5}")
print(f"False * 3: {False * 3}")

Após adicionar o código, salve o arquivo. Para executar o script, abra o terminal integrado no WebIDE e execute o seguinte comando:

python ~/project/number_types.py

Você deverá ver uma saída semelhante à seguinte. Observe que os endereços de memória (ID) serão diferentes no seu sistema.

Initial value of a: 5
Type of a: <class 'int'>
ID of a: <memory_address_1>

New value of a: 6
New ID of a: <memory_address_2>

--- Boolean Types ---
Value of is_true: True, Type: <class 'bool'>
Value of is_false: False, Type: <class 'bool'>

True + 5: 6
False * 3: 0

A saída mostra que, quando a foi reatribuído de 5 para 6, seu ID mudou, confirmando que um novo objeto inteiro foi criado. Também demonstra que True é tratado como 1 e False como 0 nos cálculos.

Trabalhar com Números de Ponto Flutuante

Nesta etapa, trabalharemos com números de ponto flutuante (float), que representam números reais com um ponto decimal. Um problema comum com floats é sua precisão limitada, pois são armazenados em formato binário. Isso pode, às vezes, levar a pequenas imprecisões nos cálculos.

Vamos explorar esse comportamento. Abra novamente ~/project/number_types.py e adicione o seguinte código ao final do arquivo. Este código demonstrará o problema de precisão e apresentará duas maneiras de lidar com ele: a função round() para arredondamento simples e o módulo decimal para aritmética de alta precisão.

## Demonstrate floating-point numbers and precision
print("\n--- Floating-Point Numbers ---")
result = 1.1 + 2.2
print(f"1.1 + 2.2 = {result}")

## Using round() for approximation
print(f"round(result, 1) = {round(result, 1)}")

## Using the decimal module for accurate calculations
from decimal import Decimal

## Pass numbers as strings to Decimal to avoid initial float inaccuracy
d1 = Decimal('1.1')
d2 = Decimal('2.2')
decimal_result = d1 + d2
print(f"Decimal('1.1') + Decimal('2.2') = {decimal_result}")

Salve o arquivo e execute o script novamente no terminal:

python ~/project/number_types.py

Sua saída agora incluirá a seguinte seção:

--- Floating-Point Numbers ---
1.1 + 2.2 = 3.3000000000000003
round(result, 1) = 3.3
Decimal('1.1') + Decimal('2.2') = 3.3

Como você pode ver, a adição padrão de float 1.1 + 2.2 não resulta exatamente em 3.3. Embora round() possa ajudar a formatar a saída, o módulo decimal fornece uma maneira de realizar cálculos com a representação decimal exata, fornecendo a resposta precisa.

Introduzir Números Complexos

Python possui suporte nativo para números complexos, que são essenciais em muitos campos científicos e de engenharia. Um número complexo possui uma parte real e uma parte imaginária, escrito na forma a + bj, onde j representa a unidade imaginária.

Você pode criar números complexos usando esta notação ou com o construtor complex(real, imag). As partes real e imaginária podem ser acessadas usando os atributos .real e .imag.

Continue editando o arquivo ~/project/number_types.py. Adicione o seguinte código ao final para explorar números complexos:

## Demonstrate complex numbers
print("\n--- Complex Numbers ---")
c1 = 3 + 4j
print(f"Complex number c1: {c1}")
print(f"Type of c1: {type(c1)}")
print(f"Real part of c1: {c1.real}")
print(f"Imaginary part of c1: {c1.imag}")

## Creating a complex number with the constructor
c2 = complex(5, -2)
print(f"\nComplex number c2: {c2}")
print(f"Real part of c2: {c2.real}")
print(f"Imaginary part of c2: {c2.imag}")

Salve o arquivo e execute o script novamente no terminal:

python ~/project/number_types.py

A nova saída será:

--- Complex Numbers ---
Complex number c1: (3+4j)
Type of c1: <class 'complex'>
Real part of c1: 3.0
Imaginary part of c1: 4.0

Complex number c2: (5-2j)
Real part of c2: 5.0
Imaginary part of c2: -2.0

Note que tanto a parte real quanto a parte imaginária são armazenadas como números de ponto flutuante, mesmo que você as defina com inteiros.

Converter Entre Tipos Numéricos

Python fornece funções nativas para converter entre diferentes tipos numéricos, como int(), float() e complex(). Isso é conhecido como type casting (conversão de tipo).

• int(x): Converte x para um inteiro. Ao converter um float, ele trunca (corta) a parte decimal, não arredonda.
• float(x): Converte x para um número de ponto flutuante.
• complex(real, imag): Cria um número complexo.

Vamos praticar a conversão de tipos. Adicione o seguinte código ao final do seu script ~/project/number_types.py:

## Demonstrate type conversion
print("\n--- Type Conversion ---")

## Convert float to int (truncation)
float_num = 9.9
int_num = int(float_num)
print(f"float_num = {float_num}")
print(f"int(float_num) = {int_num}")

## Convert int to float
int_val = 10
float_val = float(int_val)
print(f"\nint_val = {int_val}")
print(f"float(int_val) = {float_val}")

## Convert string to number
str_num = "123.45"
converted_float = float(str_num)
converted_int = int(float(str_num)) ## Must convert to float first
print(f"\nstr_num = '{str_num}'")
print(f"float(str_num) = {converted_float}")
print(f"int(float(str_num)) = {converted_int}")

Salve o arquivo e execute o script mais uma vez:

python ~/project/number_types.py

A saída agora incluirá esta seção:

--- Type Conversion ---
float_num = 9.9
int(float_num) = 9

int_val = 10
float(int_val) = 10.0

str_num = '123.45'
float(str_num) = 123.45
int(float(str_num)) = 123

Esta saída mostra claramente como int() trunca o decimal de 9.9 para 9. Também ilustra o processo de duas etapas necessário para converter uma string contendo um decimal em um inteiro.

Realizar Operações Aritméticas Básicas

Python suporta todas as operações aritméticas padrão. Quando você realiza uma operação com operandos de diferentes tipos numéricos (por exemplo, um int e um float), Python automaticamente "promove" o resultado para o tipo mais geral. A hierarquia é int -> float -> complex.

Aqui estão os operadores comuns:

• + (Adição)
• - (Subtração)
• * (Multiplicação)
• / (Divisão - sempre resulta em um float)
• // (Divisão de Piso - divide e arredonda para baixo para o inteiro mais próximo)
• % (Módulo - retorna o resto de uma divisão)
• ** (Exponenciação)

Para concluir nossa exploração, vamos adicionar uma seção final ao ~/project/number_types.py para praticar essas operações.

## Demonstrate basic arithmetic operations
print("\n--- Basic Arithmetic Operations ---")
a = 10
b = 3

print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")
print(f"{a} // {b} = {a // b}")
print(f"{a} % {b} = {a % b}")
print(f"{a} ** {b} = {a ** b}")

## Demonstrate mixed-type operations
print("\n--- Mixed-Type Operations ---")
int_op = 5
float_op = 2.5
result_mixed = int_op * float_op
print(f"{int_op} (int) * {float_op} (float) = {result_mixed} ({type(result_mixed)})")

Salve o arquivo e execute o script completo:

python ~/project/number_types.py

A saída final incluirá:

--- Basic Arithmetic Operations ---
10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3.3333333333333335
10 // 3 = 3
10 % 3 = 1
10 ** 3 = 1000

--- Mixed-Type Operations ---
5 (int) * 2.5 (float) = 12.5 (<class 'float'>)

Esta saída confirma o comportamento de cada operador. Note que a divisão padrão / produz um float, enquanto a divisão de piso // produz um inteiro. A operação de tipo misto entre um inteiro e um float resulta em um float, como esperado.

Resumo

Neste laboratório, você adquiriu uma base sólida nos tipos de dados numéricos do Python. Você aprendeu sobre inteiros, booleanos, floats e números complexos. Você explorou o conceito de imutabilidade e usou as funções id() e type() para inspecionar objetos. Você praticou o tratamento de problemas de precisão de ponto flutuante com o módulo decimal, a conversão entre diferentes tipos numéricos usando int(), float() e complex(), e a realização de uma série de operações aritméticas. Esse conhecimento é crucial para qualquer tarefa futura de programação ou análise de dados em Python.