Capítulo 2: Tipos de dados e Estruturas Condicionais

Capítulo 2: Tipos de dados e Estruturas Condicionais#

Variáveis são essenciais para armazenar informações durante a execução de um programa. Compreender os tipos de dados é fundamental para escrever programas funcionais e legíveis, pois cada tipo de dado é projetado para armazenar um tipo específico de informação, como inteiros, números reais, strings e booleanos. Sempre que precisar de mais detalhes sobre os tópicos, é recomendado acessar a documentação oficial do Python [Foundation, 2024].

Definindo Variáveis#

Uma variável é um identificador que representa um valor. A declaração de uma variável é feita usando o operador de atribuição (=). Por exemplo, a linha a seguir cria uma variável chamada nome e atribui o valor “Maria” a ela:

nome = "Maria"

Para acessar o valor armazenado em uma variável, basta utilizar o seu nome. O exemplo a seguir mostra como imprimir o valor armazenado na variável nome:

print(nome)

Saída do Código

Maria

Regras para Nomear Variáveis#

Python possui regras específicas para a criação de nomes de variáveis:

Regra	Exemplo Válido	Exemplo Inválido
Deve começar com letra ou `_`	`nome`, `_valor`	`1nome`
Pode conter letras, números e `_`	`nota1`, `valor_total`	`valor-total`
Não pode conter espaços	`minha_variavel`	`minha variavel`
Case-sensitive (diferencia maiúsculas)	`nome` ≠ `Nome`	-

Convenção de estilo: Em Python, a convenção para nomes de variáveis é utilizar snake_case, ou seja, palavras em minúsculas separadas por underscores (_).

# Boas práticas
idade_usuario = 25
valor_total = 100.50

# Evitar
IdadeUsuario = 25  # Estilo CamelCase (usado para classes)

Palavras Reservadas#

Python possui palavras reservadas que não podem ser utilizadas como nomes de variáveis, pois têm significados especiais na linguagem. Exemplos incluem: if, else, for, while, def, class, return, True, False, None, entre outras.

# Isso causará erro de sintaxe
# class = "Python"  # 'class' é palavra reservada

📌 Para ver a lista completa de palavras reservadas, consulte a documentação oficial do Python.

O vídeo a seguir demonstra como utilizar o interpretador Python no terminal para criar uma variável e exibir seu valor:

Formatando a Saída de Dados#

Vamos começar pela formatação, pois isso vai auxiliar no entendimento de todos os exemplos a seguir. A função print() é usada para exibir informações na tela, podendo imprimir strings, números e outros tipos de dados.

Exibindo uma Mensagem Simples

print("Olá, mundo!")

Saída do Código

Olá, mundo!

Mostrando Informações Concatenadas com Vírgulas

nome = "Maria"
idade = 30
print("O nome dela é", nome, "e ela tem", idade, "anos.")

Saída do Código

O nome dela é Maria e ela tem 30 anos.

O vídeo a seguir demonstra a criação de variáveis e o uso da função print() com concatenação:

Nesse exemplo, as variáveis nome e idade são concatenadas com strings e separadas por vírgulas para criar a mensagem final. O print() insere automaticamente um espaço entre os elementos.

Personalizando o Separador (sep)
Podemos modificar o separador usando o argumento sep, que define o que será inserido entre os itens:

print("Maria", "30 anos", sep=" - ")

Saída do Código

Maria - 30 anos

Por padrão, o separador é um espaço (" "), mas podemos alterá-lo conforme necessário.

Utilizando f-strings

nome = "Maria"
idade = 30
print(f"O nome dela é {nome} e ela possui {idade} anos.")

Saída do Código

O nome dela é Maria e ela possui 30 anos.

As f-strings permitem incorporar diretamente as variáveis dentro da string, tornando o código mais legível e conciso.

Exibindo Informações em Múltiplas Linhas com \n

nome = "Maria"
idade = 30
print("O nome dela é", nome, "\ne ela possui", idade, "anos.")

# Usando f-string para obter a mesma saída
print(f"O nome dela é {nome}\ne ela possui {idade} anos.")

Saída do Código

O nome dela é Maria 
e ela possui 30 anos.

A quebra de linha (\n) é utilizada para formatar a saída em múltiplas linhas.

Formatando Números com Casas Decimais

valor = 123.456789
print(f"O valor formatado é: {valor:.2f}")

Saída do Código

O valor formatado é: 123.46

Neste caso, o número armazenado na variável valor é formatado para exibir apenas duas casas decimais usando a expressão :.2f dentro da f-string.

O arredondamento segue a regra do round half to even, que arredonda números com dígito final 5 para o número par mais próximo. No entanto, nesse caso específico, como 123.456789 está mais próximo de 123.46 do que de 123.45, o arredondamento ocorre de maneira intuitiva.

Leitura de Dados com `input()`#

A função input() permite que o programa receba dados do usuário durante a execução. Ela exibe uma mensagem (opcional) e aguarda até que o usuário digite algo e pressione Enter.

Exemplo Básico

nome = input("Digite seu nome: ")
print(f"Olá, {nome}!")

Saída do Código

Digite seu nome: Maria
Olá, Maria!

Importante: A função input() sempre retorna uma string (str), mesmo que o usuário digite um número.

idade = input("Digite sua idade: ")
print(f"Tipo do dado: {type(idade)}")

Saída do Código

Digite sua idade: 25
Tipo do dado: <class 'str'>

Para realizar operações matemáticas com valores numéricos, é necessário converter o dado usando int() ou float():

idade = int(input("Digite sua idade: "))
altura = float(input("Digite sua altura: "))

print(f"Idade: {idade}, Altura: {altura}")
print(f"Tipos: {type(idade)}, {type(altura)}")

Saída do Código

Digite sua idade: 25
Digite sua altura: 1.75
Idade: 25, Altura: 1.75
Tipos: <class 'int'>, <class 'float'>

📌 A conversão de tipos será aprofundada na seção “Conversão de Tipos (Casting)” mais adiante neste capítulo.

Tipos de Dados Simples (Primitivos)#

Os tipos simples, também chamados de primitivos, são aqueles que representam valores básicos utilizados na maioria dos programas. Eles servem como a base para a construção de estruturas mais complexas, permitindo armazenar números, textos, valores lógicos, entre outros. Em Python, os principais tipos simples incluem inteiros, números de ponto flutuante, booleanos e strings.

Números Inteiros#

O tipo de dado inteiro é utilizado para representar números inteiros, tanto positivos quanto negativos, como 1, 2, 3, -1, -2, -3, entre outros. Esses valores são usados para expressar quantidades e índices em programação, desempenhando um papel importante em diversas aplicações.

Exemplos de Uso de Inteiros

# Declaração e inicialização de uma variável do tipo inteiro
x = 10
print(f"O valor de x é: {x}, e seu tipo é: {type(x)}")

# Atribuição de um novo valor a uma variável do tipo inteiro
x = 20
print(f"O novo valor de x é: {x}, e seu tipo continua sendo: {type(x)}")

# Soma de dois inteiros
resultado = x + 10
print(f"O resultado da soma é: {resultado}, e seu tipo é: {type(resultado)}")

Saída do Código

O valor de x é: 10, e seu tipo é: <class 'int'>
O novo valor de x é: 20, e seu tipo continua sendo: <class 'int'>
O resultado da soma é: 30, e seu tipo é: <class 'int'>

No exemplo acima, a variável x é inicialmente declarada e inicializada com o valor 10. Em seguida, x recebe um novo valor, 20, mantendo seu tipo int. Por fim, a operação x + 10 resulta em 30, também do tipo int, que é impresso na tela.

Inteiros sem Limite de Tamanho

Diferentemente de outras linguagens de programação (como C ou Java), os inteiros em Python não possuem um limite fixo de tamanho. Isso significa que você pode trabalhar com números extremamente grandes sem se preocupar com overflow:

# Número muito grande
numero_grande = 10 ** 100  # 10 elevado a 100 (googol)
print(f"Número com {len(str(numero_grande))} dígitos")
print(f"Tipo: {type(numero_grande)}")

Saída do Código

Número com 101 dígitos
Tipo: <class 'int'>

O vídeo a seguir exemplifica o uso de inteiros grandes no Python:

📌 Essa característica torna Python especialmente útil para aplicações que envolvem criptografia, matemática computacional e cálculos com números muito grandes.

Números de Ponto Flutuante#

O tipo de dado ponto flutuante, representado pelo tipo float em Python, é utilizado para expressar valores decimais.

Exemplos de Uso:

# Declaração e inicialização de uma variável do tipo float  
y = 3.14  
print(f"O valor de y é: {y}, e seu tipo é: {type(y)}")  

# Atribuição de um novo valor a uma variável do tipo float  
y = 2.5  
print(f"O novo valor de y é: {y}, e seu tipo continua sendo: {type(y)}")  

# Subtração de dois floats  
resultado = y - 1.0  
print(f"O resultado da subtração é: {resultado}, e seu tipo é: {type(resultado)}")  

Saída do Código

O valor de y é: 3.14, e seu tipo é: <class 'float'>  
O novo valor de y é: 2.5, e seu tipo continua sendo: <class 'float'>  
O resultado da subtração é: 1.5, e seu tipo é: <class 'float'>  

Os valores float são essenciais para cálculos que envolvem precisão decimal, como operações matemáticas, científicas e financeiras.

Notação Científica

Python permite representar números muito grandes ou muito pequenos usando notação científica com a letra e (ou E):

# Notação científica
velocidade_luz = 3e8      # 3 × 10^8 = 300.000.000
massa_eletron = 9.1e-31   # 9.1 × 10^-31

print(f"Velocidade da luz: {velocidade_luz} m/s")
print(f"Massa do elétron: {massa_eletron} kg")
print(f"Tipos: {type(velocidade_luz)}, {type(massa_eletron)}")

Saída do Código

Velocidade da luz: 300000000.0 m/s
Massa do elétron: 9.1e-31 kg
Tipos: <class 'float'>, <class 'float'>

Precisão de Ponto Flutuante

É importante saber que números de ponto flutuante têm precisão limitada devido à forma como são armazenados em binário. Isso pode causar resultados inesperados:

# Problema clássico de precisão
resultado = 0.1 + 0.2
print(f"0.1 + 0.2 = {resultado}")
print(f"0.1 + 0.2 == 0.3? {resultado == 0.3}")

Saída do Código

0.1 + 0.2 = 0.30000000000000004
0.1 + 0.2 == 0.3? False

📌 Esse comportamento não é um bug do Python, mas uma característica da representação de números em ponto flutuante (padrão IEEE 754) comum a praticamente todas as linguagens de programação. Para cálculos financeiros que exigem precisão exata, considere usar o módulo decimal.

Booleanos#

Os tipos booleanos representam valores lógicos, ou seja, podem ser True ou False. Esses valores são comumente utilizados para representar condições, resultados de testes e expressões lógicas.

Exemplos de Uso de Booleanos

# Declaração de variáveis booleanas
ativo = True
concluido = False

print(f"Ativo: {ativo}, Tipo: {type(ativo)}")
print(f"Concluído: {concluido}, Tipo: {type(concluido)}")

# Comparação de dois valores
print(f"10 > 20: {10 > 20}")
print(f"5 == 5: {5 == 5}")

Saída do Código

Ativo: True, Tipo: <class 'bool'>
Concluído: False, Tipo: <class 'bool'>
10 > 20: False
5 == 5: True

Conversão com bool()

A função bool() converte outros tipos de dados para booleano:

# Convertendo diferentes valores para booleano
print(f"bool(1): {bool(1)}")
print(f"bool(0): {bool(0)}")
print(f"bool('texto'): {bool('texto')}")
print(f"bool(''): {bool('')}")
print(f"bool([1, 2, 3]): {bool([1, 2, 3])}")
print(f"bool([]): {bool([])}")

Saída do Código

bool(1): True
bool(0): False
bool('texto'): True
bool(''):False
bool([1, 2, 3]): True
bool([]): False

📌 De forma geral, valores “vazios” como 0, "", [], {} são convertidos para False, enquanto valores “preenchidos” são convertidos para True.

Strings#

O tipo de dado string, representado por str em Python, é utilizado para armazenar sequências de caracteres como texto.

Exemplos de Uso:

# Declaração e inicialização de uma variável do tipo string  
z = "Olá, turma!"  
print(f"O valor de z é: {z}, e seu tipo é: {type(z)}")  

# Atribuição de um novo valor  
z = "123"  
print(f"O novo valor de z é: {z}, e seu tipo continua sendo: {type(z)}")  

# Concatenação de strings  
resultado = z + ", como vai?"  
print(f"O resultado da concatenação é: {resultado}, e seu tipo é: {type(resultado)}")  

Saída do Código

O valor de z é: Olá, turma!, e seu tipo é: <class 'str'>  
O novo valor de z é: 123, e seu tipo continua sendo: <class 'str'>  
O resultado da concatenação é: 123, como vai?, e seu tipo é: <class 'str'>  

Uso de Aspas em Strings
Python permite usar tanto aspas simples (') quanto duplas (") para definir strings:

# String com aspas simples  
texto1 = 'Texto com aspas simples.' 
print(f"Exemplo 1: {texto1}")  

# String com aspas duplas  
texto2 = "Texto com aspas duplas."  
print(f"Exemplo 2: {texto2}")  

# String contendo aspas diferentes  
texto3 = "Contém 'aspas simples' dentro."  
texto4 = 'Contém "aspas duplas" dentro.'   
print(f"Exemplo 3: {texto3}")  
print(f"Exemplo 4: {texto4}")

Saída do Código

Exemplo 1: Texto com aspas simples.
Exemplo 2: Texto com aspas duplas.
Exemplo 3: Contém 'aspas simples' dentro.
Exemplo 4: Contém "aspas duplas" dentro.

Strings Multilinhas

Para criar strings que ocupam várias linhas, utilizamos aspas triplas (""" ou '''):

mensagem = """Este é um texto
que ocupa várias linhas.
Muito útil para textos longos."""

print(mensagem)

Saída do Código

Este é um texto
que ocupa várias linhas.
Muito útil para textos longos.

Caracteres de Escape

Caracteres de escape permitem inserir caracteres especiais em strings:

Sequência	Descrição	Exemplo
`\n`	Nova linha	`"Linha1\nLinha2"`
`\t`	Tabulação	`"Col1\tCol2"`
`\\`	Barra invertida	`"C:\\pasta"`
`\'`	Aspas simples	`'It\'s ok'`
`\"`	Aspas duplas	`"Ele disse \"Olá\""`

# Exemplos de caracteres de escape
print("Primeira linha\nSegunda linha")
print("Nome:\tJoão")
print("Caminho: C:\\Users\\pasta")
print("Ele disse: \"Python é incrível!\"")

Saída do Código

Primeira linha
Segunda linha
Nome:	João
Caminho: C:\Users\pasta
Ele disse: "Python é incrível!"

📌 Para evitar o processamento de caracteres de escape, utilize strings “raw” adicionando r antes das aspas: r"C:\Users\pasta".

Strings são fundamentais para manipulação de texto em Python, permitindo operações como concatenação, formatação e acesso a caracteres individuais.

Utilização do len para Calcular o Tamanho da String

O len é uma função incorporada Built-in Functions em Python que retorna o comprimento (número de caracteres) de uma sequência, como uma string. Vamos calcular o tamanho da string "Olá, turma!" usando len:

texto = "Olá, turma!"
tamanho = len(texto)
print("O tamanho da string é:", tamanho)

Saída do Código

O tamanho da string é: 11

Como Funcionam os Índices em uma String

Em Python, os índices de uma string começam em 0 e vão até (comprimento da string - 1). Isso significa que o primeiro caractere está no índice 0, o segundo no índice 1, e assim por diante. Podemos imprimir caracteres específicos e partes da string usando esses índices:

texto = "Olá, turma!"

# Impressão de caracteres usando índices
print("Primeiro caractere:", texto[0])
print("Segundo caractere:", texto[1])

# Impressão do último caractere usando índice -1
print("Último caractere:", texto[-1])

# Impressão de partes da string usando índices
print("Parte da string:", texto[4:9])

# Inverte a string (passo -1 percorre de trás pra frente)
print("String invertida:", texto[::-1])

Saída do Código

Primeiro caractere: O
Segundo caractere: l
Último caractere: !
Parte da string: turma
String invertida: !amrut ,álO

📌 No exemplo acima, texto[4:9] imprime a parte da string que vai do índice 4 até o índice 8 (o índice 9 não é incluído).

Manipulação de Strings Mais adiante neste material, faremos um estudo aprofundado sobre a manipulação de strings. Exploraremos uma série de métodos e operações que são essenciais para o processamento de texto. Por exemplo:

Utilizando .upper() e .lower()

.upper(): Este método é utilizado para converter todos os caracteres de uma string para maiúsculas. É útil quando queremos padronizar a entrada de dados ou destacar uma mensagem.

texto = "Olá, Mundo!"
print(texto.upper())

Saída do Código

OLÁ, MUNDO!

.lower(): Em contraste, .lower() transforma todos os caracteres de uma string para minúsculas. Isso é particularmente útil para comparações de strings, onde a capitalização pode ser ignorada.

texto = "Olá, Mundo!"
print(texto.lower())

Saída do Código

olá, mundo!

Esses métodos são apenas o começo do que podemos fazer com a manipulação de strings em Python. À medida que avançarmos, descobriremos mais técnicas e funções que nos permitirão manipular e analisar strings em diversas situações.

📌 Além dos tipos primitivos apresentados (int, float, bool e str), o Python também disponibiliza o tipo complex, destinado à representação de números complexos, embora seja menos empregado em aplicações cotidianas. Para saber mais sobre esse tipo (e outros tipos primitivos), consulte a seção Numeric Types — int, float, complex na documentação oficial do Python.

Características da Dinamicidade de Tipo#

Conforme discutido anteriormente, o Python se destaca como uma linguagem de programação dinamicamente tipada, o que implica que o tipo de uma variável é determinado durante a execução do programa, não durante a compilação. Ao contrário de linguagens estaticamente tipadas, como C++ ou Java, onde o tipo de uma variável deve ser declarado explicitamente antes de ser utilizada, o Python permite atribuir valores a variáveis sem a necessidade de declarar o tipo previamente.

É fundamental ressaltar a flexibilidade proporcionada pela Atribuição Dinâmica, especialmente quando combinada com None:

# Atribuição dinâmica de valores
variavel_dinamica = 42
print(variavel_dinamica)

variavel_dinamica = "Olá, mundo!"
print(variavel_dinamica)

# Declarando variáveis como None
variavel_nula = None
print(variavel_nula)

# Atribuindo um valor posteriormente
variavel_nula = 100
print(variavel_nula)

Saída do Código

42
Olá, mundo!
None
100

No exemplo acima, a variável variavel_dinamica é inicialmente atribuída ao inteiro 42 e, posteriormente, à string “Olá, mundo!”. Isso ilustra a flexibilidade e a dinamicidade de tipos em Python. Além disso, a variável variavel_nula é inicializada com None, indicando a ausência de valor, e mais tarde é atribuída ao valor inteiro 100.

Verificando Tipos com isinstance()

Em algumas situações, é necessário verificar o tipo de uma variável em tempo de execução. A função isinstance() permite fazer essa verificação de forma segura:

valor = 42

# Verificação simples
print(f"É int? {isinstance(valor, int)}")
print(f"É str? {isinstance(valor, str)}")

# Verificação com múltiplos tipos
print(f"É int ou float? {isinstance(valor, (int, float))}")

Saída do Código

É int? True
É str? False
É int ou float? True

📌 Prefira isinstance() em vez de type(valor) == int, pois isinstance() também considera herança de classes.

Removendo Variáveis com del

Outro recurso importante a ser mencionado é a instrução del, que possibilita remover uma variável existente.

# Removendo uma variável com o comando 'del'
del variavel_nula
# Tentar imprimir a variável após deletá-la resultará em um erro
print(variavel_nula)

Saída do Código

Traceback (most recent call last):
  File "<filename>", line 5, in <module>
    print(variavel_nula)
NameError: name 'variavel_nula' is not defined

No exemplo acima, o comando del é usado para remover a variável variavel_nula. Tentar imprimir essa variável após deletá-la resultará em um erro NameError, indicando que a variável não está mais definida. O uso de del é útil para liberar recursos e gerenciar a estrutura do programa de forma mais eficiente.

Conversão de tipos (Casting) e Bases numéricas#

Refere-se à conversão de um tipo de dado para outro. Isso pode ser necessário quando você deseja operar ou comparar valores de tipos diferentes. Um exemplo comum é a conversão de uma string para um número, como ao utilizar float(input()) para converter a entrada do usuário em um número de ponto flutuante.

Funções de Conversão#

Python oferece funções integradas para converter entre os tipos básicos:

Função	Descrição	Exemplo	Resultado
`int()`	Converte para inteiro	`int("42")`	`42`
`float()`	Converte para ponto flutuante	`float("3.14")`	`3.14`
`str()`	Converte para string	`str(100)`	`"100"`
`bool()`	Converte para booleano	`bool(1)`	`True`

Conversão entre int e float

# Float para int (trunca a parte decimal, não arredonda)
numero_float = 3.7
numero_int = int(numero_float)
print(f"int(3.7) = {numero_int}")

numero_float2 = 3.2
print(f"int(3.2) = {int(numero_float2)}")

# Int para float
numero_int = 5
numero_float = float(numero_int)
print(f"float(5) = {numero_float}")

Saída do Código

int(3.7) = 3
int(3.2) = 3
float(5) = 5.0

📌 Atenção: int() trunca o valor (remove a parte decimal), não arredonda. Para arredondar, use round().

Conversão para String

idade = 25
altura = 1.75
ativo = True

# Convertendo para string
print("Idade: " + str(idade))
print(f"Tipo de str(altura): {type(str(altura))}")
print(f"str(ativo) = '{str(ativo)}'")

Saída do Código

Idade: 25
Tipo de str(altura): <class 'str'>
str(ativo) = 'True'

Conversão de String para Inteiro

# Solicita ao usuário para digitar um número inteiro
entrada_usuario = input("Digite um número inteiro: ")

# Converte a entrada para um número inteiro
numero_inteiro = int(entrada_usuario)

# Imprime o resultado
print("Número inteiro digitado:", numero_inteiro)

Saída do Código

Digite um número inteiro: 15
Número inteiro digitado: 15

Conversão de String para Ponto Flutuante

# Solicita ao usuário para digitar um número de ponto flutuante
entrada_usuario = input("Digite um número de ponto flutuante: ")

# Converte a entrada para um número de ponto flutuante
numero_float = float(entrada_usuario)

# Imprime o resultado
print("Número de ponto flutuante digitado:", numero_float)

Saída do Código

Digite um número de ponto flutuante: 3.14
Número de ponto flutuante digitado: 3.14

Conversão entre Bases Numéricas#

Python oferece suporte nativo para conversão entre diferentes bases numéricas. As representações incluem prefixos que indicam a base:

0b para binário (base 2)
0o para octal (base 8)
0x para hexadecimal (base 16)

Decimal para Binário:

numero_decimal = 10
numero_binario = bin(numero_decimal)  # Retorna string com prefixo 0b
print(numero_binario)  # 0b1010 (onde 0b indica formato binário)

Saída do Código

0b1010

Binário para Decimal:

numero_binario = 0b1010  # Prefixo 0b permite escrever literal binário
numero_decimal = int(numero_binario)  # Converte para inteiro decimal
print(numero_decimal)

Saída do Código

Uma ilustração a seguir para ajudar a entender a matemática envolvida.

Decimal para Hexadecimal:

numero_decimal = 255
numero_hexadecimal = hex(numero_decimal)  # Retorna string com prefixo 0x
print(numero_hexadecimal)  # 0xff (onde 0x indica formato hexadecimal)

Saída do Código

0xff

Hexadecimal para Decimal:

numero_hexadecimal = 0xff  # Prefixo 0x permite escrever literal hexadecimal
numero_decimal = int(numero_hexadecimal)  # Converte para inteiro decimal
print(numero_decimal)

Saída do Código

Visualizando Endereços de Memória em Hexadecimal:

Em Python, podemos visualizar o endereço de memória onde uma variável está armazenada usando a função id() combinada com hex(). Isso é útil para entender como Python gerencia objetos na memória:

a = 123
b = 125

# Visualizando endereços de memória em hexadecimal
print(f"Endereço de 'a': {hex(id(a))}")
print(f"Endereço de 'b': {hex(id(b))}")

Saída do Código

Endereço de 'a': 0x7f8b3c0a1e70
Endereço de 'b': 0x7f8b3c0a1eb0

📌 Os endereços de memória variam a cada execução do programa e dependem do sistema operacional e da implementação do Python.

Observações importantes:

As funções bin(), oct() e hex() retornam strings com os respectivos prefixos
Você pode usar os prefixos diretamente no código para representar literais nessas bases
A função int() pode converter strings desses formatos para decimal quando usado com o parâmetro base:
```
int('1010', 2)   # Binário → 10
int('0xff', 16)  # Hexadecimal → 255
```

Aplicações Práticas das Conversões entre Bases Numéricas#

As conversões entre decimal, binário, octal e hexadecimal aparecem em diversas áreas da computação e da engenharia. Alguns exemplos:

Eletrônica e sistemas embarcados → configuração de registradores em microcontroladores (hex/bin) e uso de máscaras binárias para GPIOs.
Desenvolvimento de software e web → representação de cores em hexadecimal (#RRGGBB) e controle de permissões de arquivo (octal) em sistemas Unix/Linux.
Redes e segurança → endereços IP e máscaras de sub-rede, análise de pacotes e interpretação de hashes criptográficos.
Otimização e eficiência → operações bitwise para manipulação rápida de dados e compactação em estruturas binárias.
Sistemas legados e forense digital → leitura de dumps de memória em hexadecimal e interpretação de arquivos binários e headers de baixo nível.

Assim, conhecer e manipular diferentes bases numéricas é fundamental em áreas como IoT, criptografia, drivers, análise de sistemas e desenvolvimento web.

Tipos de Dados Compostos (Coleções)#

As coleções são estruturas fundamentais em Python que permitem o armazenamento e organização eficiente de dados diversos. Essas estruturas oferecem flexibilidade ao acomodar diferentes tipos de dados, facilitando a manipulação e análise de informações de maneira abrangente.

Listas#

Listas são estruturas de dados mutáveis, ordenadas e heterogêneas que permitem armazenar coleções de itens. São representadas por colchetes [] e itens separados por vírgulas.

Características Principais:

Mutáveis: Podem ser alteradas após criação
Ordenadas: Mantêm a ordem de inserção
Heterogêneas: Aceitam diferentes tipos de dados
Dinâmicas: Crescem ou diminuem conforme necessidade

# Exemplo básico
lista = [1, "Python", 3.14, True]

Operações Básicas com Listas#

Criando Listas

lista_vazia = []          # Sintaxe literal
lista_vazia = list()      # Usando construtor
numeros = [1, 2, 3]       # Lista de inteiros

Acessando Elementos

linguagens = ["Python", "Java", "C++"]

print(linguagens[0])   # Primeiro elemento
print(linguagens[-1])  # Último elemento

Saída do Código:

Python
C++

Fatiamento (Slicing)

O fatiamento permite extrair partes de uma lista usando a sintaxe lista[início:fim:passo]:

numeros = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Elementos do índice 2 ao 5 (não inclui o 5)
print(numeros[2:5])

# Do início até o índice 4
print(numeros[:4])

# Do índice 6 até o final
print(numeros[6:])

# Elementos de 2 em 2
print(numeros[::2])

# Lista invertida
print(numeros[::-1])

Saída do Código:

[2, 3, 4]
[0, 1, 2, 3]
[6, 7, 8, 9]
[0, 2, 4, 6, 8]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Sintaxe	Descrição	Exemplo	Resultado
`lista[i:j]`	Elementos do índice `i` até `j-1`	`[0,1,2,3,4][1:4]`	`[1, 2, 3]`
`lista[:j]`	Do início até `j-1`	`[0,1,2,3,4][:3]`	`[0, 1, 2]`
`lista[i:]`	De `i` até o final	`[0,1,2,3,4][2:]`	`[2, 3, 4]`
`lista[::p]`	Todos, pulando de `p` em `p`	`[0,1,2,3,4][::2]`	`[0, 2, 4]`
`lista[::-1]`	Lista invertida	`[0,1,2,3,4][::-1]`	`[4, 3, 2, 1, 0]`

Modificando Listas

linguagens = ["Python", "Java", "C++"]
linguagens[1] = "JavaScript"
print(linguagens)

Saída do Código:

['Python', 'JavaScript', 'C++']

Modificando com Slicing

numeros = [0, 1, 2, 3, 4, 5]
numeros[1:4] = [10, 20, 30]  # Substitui elementos do índice 1 ao 3
print(numeros)

Saída do Código:

[0, 10, 20, 30, 4, 5]

Métodos Principais de Listas#

Método	Descrição	Exemplo	Saída
`append(x)`	Adiciona `x` ao final	`[1, 2].append(3)`	`[1, 2, 3]`
`extend(iter)`	Adiciona itens de outro iterável	`[1, 2].extend([3, 4])`	`[1, 2, 3, 4]`
`insert(i, x)`	Insere `x` na posição `i`	`['a', 'c'].insert(1, 'b')`	`['a', 'b', 'c']`
`remove(x)`	Remove primeira ocorrência de `x`	`[1, 2, 2, 3].remove(2)`	`[1, 2, 3]`
`pop([i])`	Remove e retorna item no índice `i`	`[1, 2, 3].pop(1)`	Retorna `2`, lista: `[1, 3]`
`clear()`	Remove todos os itens	`[1, 2, 3].clear()`	`[]`
`index(x)`	Retorna índice da primeira ocorrência	`['a', 'b', 'c'].index('b')`	`1`
`count(x)`	Conta ocorrências de `x`	`[1, 2, 2, 3].count(2)`	`2`
`sort()`	Ordena a lista (in-place)	`[3, 1, 2].sort()`	`[1, 2, 3]`
`reverse()`	Inverte a ordem (in-place)	`[1, 2, 3].reverse()`	`[3, 2, 1]`
`copy()`	Retorna cópia superficial	`[1, 2].copy()`	`[1, 2]`

Combinação de Listas#

Usando + (cria nova lista)

lista1 = [1, 2]
lista2 = [3, 4]
combinada = lista1 + lista2
print(combinada)

Saída do Código:

[1, 2, 3, 4]

Usando += (modifica a primeira lista)

lista1 = [1, 2]
lista2 = [3, 4]
lista1 += lista2
print(lista1)

Saída do Código:

[1, 2, 3, 4]

Usando extend()

lista1 = ['a', 'b']
lista2 = ['c', 'd']
lista1.extend(lista2)
print(lista1)

Saída do Código:

['a', 'b', 'c', 'd']

Exemplo Prático Integrado#

# Criando lista de compras
compras = ["Maçã", "Leite"]
compras.append("Pão")
compras.extend(["Ovos", "Queijo"])
compras.insert(1, "Banana")

# Concatenando com outra lista
bebidas = ["Suco", "Água"]
lista_final = compras + bebidas

print("Lista de compras completa:", lista_final)

Saída do Código:

Lista de compras completa: ['Maçã', 'Banana', 'Leite', 'Pão', 'Ovos', 'Queijo', 'Suco', 'Água']

Boas Práticas#

Prefira append()/extend() ao invés de + para listas grandes (melhor performance)
Use lista.copy() ou list(lista) para evitar modificações indesejadas
Utilize lista.clear() para esvaziar listas de forma legível
Verifique existência de elementos com x in lista (retorna True ou False)

Tuplas#

As tuplas são estruturas de dados fundamentais em Python, caracterizadas por serem imutáveis, ordenadas e heterogêneas. Sua sintaxe utiliza parênteses () com elementos separados por vírgulas – sendo a vírgula, e não os parênteses, o elemento definidor da tupla.

Características Essenciais:

Imutabilidade: Uma vez criada, não pode ser alterada.
Preservação de ordem: Mantém a sequência de inserção.
Flexibilidade tipográfica: Aceita diferentes tipos de dados na mesma estrutura.
Eficiência: Consome menos recursos que listas para dados constantes.

# Demonstração básica
linguagem = ("Python", 1991, "Guido van Rossum", True)

Operações Fundamentais#

Criação de Tuplas

vazia = ()                       # Tupla vazia
vazia = tuple()                  # Tupla vazia
unitária = (42,)                 # Tupla com único elemento (vírgula obrigatória)
coordenadas = (23.5, -46.6)      # Tupla de floats
registro = ("ID123", "João", 28) # Tupla heterogênea

# Conversão de outros iteráveis
de_lista = tuple([1, 2, 3])
de_string = tuple("Python")

Saída do Código:

('P', 'y', 't', 'h', 'o', 'n')

Acesso a Elementos

dados = ("Python", 3.11, "Open Source")

print(dados[0])       # Acesso por índice positivo
print(dados[-1])      # Acesso por índice negativo

Saída do Código:

Python
Open Source

Tentativa de Modificação

tupla = (1, 2, 3)
try:
    tupla[1] = 99  # Tentativa de alteração
except TypeError as e:
    print(f"Erro: {e}")

Saída do Código:

Erro: 'tuple' object does not support item assignment

Veja mais detalhes de como usar o try except no Capítulo 8.

Métodos Nativos#

Método	Descrição	Exemplo	Resultado
`count()`	Conta ocorrências de um valor	`(1,2,2,3).count(2)`	`2`
`index()`	Posição da primeira ocorrência	`('a','b','c').index('b')`	`1`

Combinação de Tuplas#

Concatenação (+)

t1 = (1, 2)
t2 = (3, 4)
combinada = t1 + t2
print(combinada)

Saída do Código:

(1, 2, 3, 4)

Repetição (*)

saudacao = ("Olá",) * 3
print(saudacao)

Saída:

('Olá', 'Olá', 'Olá')

Desempacotamento Moderno

cores_base = ("vermelho", "azul")
cores_extras = ("verde", "amarelo")
paleta = (*cores_base, "roxo", *cores_extras)
print(paleta)

Saída:

('vermelho', 'azul', 'roxo', 'verde', 'amarelo')

Observação: O * funciona em qualquer tipo de sequência (listas, tuplas, strings, etc.), “espalhando” os elementos no novo contexto.

Aplicações Práticas#

Sistemas de Coordenadas

ponto_a = (-23.55, -46.63)  # São Paulo
ponto_b = (-22.91, -43.17)  # Rio de Janeiro
print(f"Rota: {ponto_a} -> {ponto_b}")

Saída do Código:

Rota: (-23.55, -46.63) -> (-22.91, -43.17)

Chaves Compostas em Dicionários (vamos estudar a seguir)

estoque = {
    ("camiseta", "M"): 42,
    ("calça", "40"): 15
}
print(estoque[("camiseta", "M")])

Saída do Código:

Sintaxe Alternativa

# Tupla sem parênteses (packing)
valores = 10, 20, 30
print(type(valores))

# Unpacking
x, y, z = valores
print(f"x={x}, y={y}, z={z}")

Saída do Código:

<class 'tuple'>
x=10, y=20, z=30

Exemplo prático com função#

Para quando tiver estudado o Capítulo 5.

# Sistema de geolocalização
def calcular_distancia(p1, p2):
    from math import sqrt
    return sqrt((p2[0]-p1[0])**2 + (p2[1]-p1[1])**2)

sp = (-23.55, -46.63)
rj = (-22.91, -43.17)

distancia_km = calcular_distancia(sp, rj) * 111
print(f"Distância SP-RJ: {distancia_km:.1f} km")

Saída do Código:

Distância SP-RJ: 358.1 km

Boas Práticas#

Dados constantes: Use tuplas para informações imutáveis.
Chaves compostas: Ideal para dicionários com múltiplos índices.
Retorno múltiplo: Padrão eficiente para funções.
Segurança de dados: Proteção contra modificações acidentais.
Desempenho: Prefira para coleções estáticas de grande porte.

Dicionários#

Os dicionários são estruturas de dados mutáveis que armazenam informações como pares chave-valor, oferecendo acesso rápido aos dados através de chaves únicas. São representados por chaves {} e cada elemento consiste em uma chave e seu valor correspondente, separados por dois pontos.

Características principais:

Acesso eficiente aos valores através de chaves únicas
Não permitem chaves duplicadas
Podem ser modificados após criação
Aceitam diversos tipos de dados como valores
Otimizados para operações básicas em tempo constante

# Exemplo básico de dicionário
pessoa = {
    "nome": "Maria",
    "idade": 28,
    "profissao": "Engenheira",
    "habilidades": ["Python", "CAD", "Gestão"]
}

Operações básicas com dicionários#

Criação:

vazio = {}                  # Sintaxe literal
vazio = dict()              # Usando construtor

cadastro = {
    "id": "user123",
    "ativo": False,
    "ultimo_acesso": "2023-10-15"
}

Acesso e modificação:

# Acesso direto
print(pessoa["nome"])       

# Acesso seguro com get()
print(pessoa.get("salario", "Não informado"))  
# Retorna valor padrão se a chave não existe

# Adicionando ou atualizando valores
pessoa["salario"] = 7500.00   # Ideal para alterar ou criar uma única chave
pessoa.update({"empresa": "Tech Solutions", "setor": "TI"})  
# Útil (e necessário) quando queremos alterar ou adicionar várias chaves de uma só vez

Saída do Código:

Maria
Não informado
{'nome': 'Maria', 'idade': 28, 'profissao': 'Engenheira', 'habilidades': ['Python', 'CAD', 'Gestão'], 'salario': 7500.0, 'empresa': 'Tech Solutions', 'setor': 'TI'}

Remoção de itens:

del pessoa["habilidades"]   # Remove a chave especificada
idade = pessoa.pop("idade") # Remove e retorna o valor
ultimo = pessoa.popitem()   # Remove e retorna o último item inserido

Saída do Código:

28
('setor', 'TI')
{'nome': 'Maria', 'profissao': 'Engenheira', 'salario': 7500.0, 'empresa': 'Tech Solutions'}

Métodos úteis#

Método	Descrição	Exemplo	Saída típica
keys()	Retorna todas as chaves	pessoa.keys()	dict_keys([‘nome’, ‘profissao’, …])
values()	Retorna todos os valores	pessoa.values()	dict_values([‘Maria’, ‘Engenheira’, …])
items()	Retorna pares (chave, valor) como tuplas	pessoa.items()	dict_items([(‘nome’, ‘Maria’), …])
get(chave, pad)	Retorna valor ou padrão se chave ausente	pessoa.get(“idade”, 30)	30
update()	Atualiza com pares de outro dicionário	pessoa.update({“idade”: 29})	{‘nome’: ‘Maria’, ‘idade’: 29, …}
clear()	Remove todos os itens	pessoa.clear()	{}

Exemplos práticos#

Dicionário simples:

aluno = {
    "nome": "João Silva",
    "matricula": "2023001",
    "curso": "C&T"
}
print(aluno)

Saída do Código:

{'nome': 'João Silva', 'matricula': '2023001', 'curso': 'Ciência da Computação'}

Acesso e modificação:

print(aluno["nome"])      
aluno["curso"] = "Engenharia de Software"
print(aluno)

Saída do Código:

João Silva
{'nome': 'João Silva', 'matricula': '2023001', 'curso': 'Engenharia de Software'}

Verificação de chaves:

tem_matricula = "matricula" in aluno
print(tem_matricula)  

Saída do Código:

True

Dicionário com diferentes tipos:

produto = {
    "codigo": 123,
    "nome": "Teclado",
    "preco": 99.90,
    "disponivel": True
}
print(produto)

Saída do Código:

{'codigo': 123, 'nome': 'Teclado', 'preco': 99.9, 'disponivel': True}

Dicionário com lista como valor:

contatos = {
    "João": ["joao@email.com", "(83) 9999-1111"],
    "Maria": ["maria@email.com", "(84) 8888-2222"]
}
print(contatos["Maria"])

Saída do Código:

['maria@email.com', '(84) 8888-2222']

Boas práticas#

Use chave in dicionario para verificar existência de chaves
Prefira get() para evitar erros com chaves inexistentes
Tuplas podem ser usadas como chaves quando necessário
Dicionários mantêm a ordem de inserção (Python 3.7+)
clear() é mais eficiente que criar novo dicionário vazio

Conjuntos#

Os conjuntos são estruturas de dados que armazenam elementos únicos, sem duplicatas. São muito úteis para operações matemáticas como união, interseção, diferença e diferença simétrica entre coleções.

Características principais

Armazenam elementos únicos (não permitem duplicatas)
Não mantêm ordem específica dos elementos
Não suportam indexação
Otimizados para verificação rápida de pertencimento
Aceitam tipos de dados imutáveis como elementos

# Exemplo básico de conjunto
vogais = {'a', 'e', 'i', 'o', 'u'}

Operações básicas#

Criação

vazio = set()        # Conjunto vazio
numeros = {1, 2, 3}  # Conjunto com elementos

Adição e remoção

numeros.add(4)        
numeros.remove(2)     
numeros.discard(5)    

print(numeros)

Saída do Código:

{1, 3, 4}

Operações entre conjuntos#

União

A = {1, 2, 3}
B = {3, 4, 5}
print(A | B)  # Ou A.union(B)

Saída do Código:

{1, 2, 3, 4, 5}

Interseção

print(A & B)  # Ou A.intersection(B)

Saída do Código:

{3}

Diferença

print(A - B)  # Elementos que estão apenas no primeiro conjunto

Saída do Código:

{1, 2}

Diferença simétrica

print(A ^ B)  # Ou A.symmetric_difference(B)

Saída do Código:

{1, 2, 4, 5}

Métodos úteis#

Método	Descrição	Exemplo	Saída
`add()`	Adiciona um elemento	`numeros.add(5)`	`{1, 3, 4, 5}`
`remove()`	Remove elemento (gera erro se não existe)	`numeros.remove(3)`	`{1, 4, 5}`
`discard()`	Remove elemento (não gera erro)	`numeros.discard(2)`	`{1, 4, 5}`
`union()`	Retorna união com outro conjunto	`A.union(B)`	`{1, 2, 3, 4, 5}`
`intersection()`	Retorna interseção com outro conjunto	`A.intersection(B)`	`{3}`
`difference()`	Retorna diferença entre conjuntos	`A.difference(B)`	`{1, 2}`
`symmetric_difference()`	Retorna diferença simétrica	`A.symmetric_difference(B)`	`{1, 2, 4, 5}`
`clear()`	Remove todos os elementos	`numeros.clear()`	`set()`

Operadores e métodos equivalentes#

Operador	Método	Descrição	Exemplo	Saída
`\|`	`union()`	União (elementos em pelo menos um)	`{1,2} \| {2,3}`	`{1, 2, 3}`
`&`	`intersection()`	Interseção (elementos em ambos)	`{1,2} & {2,3}`	`{2}`
`-`	`difference()`	Diferença (elementos só no primeiro)	`{1,2,3} - {2,3}`	`{1}`
`^`	`symmetric_difference()`	Diferença simétrica (em um OU outro)	`{1,2,3} ^ {2,3,4}`	`{1, 4}`

📌 Dica rápida: | → tudo, & → comum, - → só no primeiro, ^ → apenas em um

Exemplos práticos#

Verificando pertencimento

vogais = {'a', 'e', 'i', 'o', 'u'}
print('a' in vogais)

Saída do Código:

True

Removendo duplicatas de uma lista

lista = [1, 2, 2, 3, 3, 3]
unicos = set(lista)
print(unicos)

Saída do Código:

{1, 2, 3}

Trabalhando com conjuntos de strings

cores = {'vermelho', 'verde', 'azul'}
cores.add('amarelo')
print(cores)

Saída do Código:

{'vermelho', 'verde', 'azul', 'amarelo'}

Boas práticas#

Use conjuntos para eliminar duplicatas de listas
Ideal para testar pertencimento de forma eficiente
Não use para dados que precisam de ordem
Elementos devem ser imutáveis (números, strings, tuplas)
Prefira discard() a remove() quando não tem certeza da existência

Estruturas de Decisão#

As estruturas de decisão controlam o fluxo de execução de um programa, permitindo que o código tome decisões com base em condições específicas e execute ações diferentes de acordo com o resultado dessas condições.

`if`#

A estrutura if executa um bloco de código somente se uma condição for avaliada como verdadeira (True). Veja o exemplo:

idade = 21

if idade >= 18:
    print("Você é maior de idade.")

Saída do Código:

Você é maior de idade.

No exemplo acima, a mensagem “Você é maior de idade.” será impressa, pois a condição idade >= 18 é verdadeira.

`if-else`#

A estrutura if-else permite que o código execute uma ação quando a condição é verdadeira e outra quando a condição é falsa. Veja o exemplo:

idade = 15

if idade >= 18:
    print("Você é maior de idade.")
else:
    print("Você é menor de idade.")

Saída do Código:

Você é menor de idade.

Se a condição idade >= 18 for falsa, o código dentro do else será executado, imprimindo “Você é menor de idade.”

`if-elif-else`#

A estrutura condicional if-elif-else é utilizada quando precisamos verificar múltiplas condições de forma sequencial. O elif (abreviação de “else if”) permite testar condições intermediárias entre o if inicial e o else final.

Exemplo Básico#

idade = 30

if idade < 18:
    print("Você é menor de idade.")
elif 18 <= idade < 65:  # Forma pythonica
    print("Você é adulto.")
else:
    print("Você é um idoso.")

Saída do Código:

Você é adulto.

Comparação de Sintaxes#

Forma	Exemplo	Observação
Tradicional	`idade >= 18 and idade < 65`	Mais explícita
Pythonica	`18 <= idade < 65`	Mais concisa e idiomática

Ambas as formas são válidas, mas a versão pythonica é preferível por:

Ser mais legível
Assemelhar-se à notação matemática
Reduzir a repetição da variável

`match case`#

A partir do Python 3.10, foi introduzida a estrutura match case, que permite comparar um valor contra múltiplos padrões de forma mais clara e organizada. Ela funciona de maneira semelhante ao switch de outras linguagens, mas com a vantagem de suportar pattern matching, o que torna o recurso muito mais poderoso.

Exemplo Básico#

opcao = 2

match opcao:
    case 1:
        print("Opção 1 selecionada")
    case 2:
        print("Opção 2 selecionada")
    case 3 | 4:   # Combinação de padrões
        print("Opção 3 ou 4 selecionada")
    case _:
        print("Opção inválida")

Saída do Código:

Opção 2 selecionada

Nesse exemplo:

O valor em opcao é comparado com cada case.
O operador | permite combinar múltiplos padrões.
O _ (underscore) funciona como um coringa (equivalente ao else), capturando qualquer valor não tratado anteriormente.

Exemplo com Estrutura de Dados#

O match case também permite desempacotar valores diretamente dentro da comparação, tornando o código mais expressivo.

ponto = (0, 5)

match ponto:
    case (0, y):
        print(f"Ponto no eixo Y, coordenada {y}")
    case (x, 0):
        print(f"Ponto no eixo X, coordenada {x}")
    case (x, y):
        print(f"Ponto em ({x}, {y})")

Saída do Código:

Ponto no eixo Y, coordenada 5

Tabela Resumo (completa):

Estrutura	Descrição	Uso
if	Executa um bloco se a condição for verdadeira	Quando há uma única condição
if-else	Executa um bloco se a condição for verdadeira e outro se for falsa	Quando há duas possibilidades (verdadeiro/falso)
if-elif-else	Verifica múltiplas condições sequencialmente	Quando há mais de duas condições a serem tratadas
match case	Compara valores contra múltiplos padrões (com suporte a pattern matching)	Quando há muitas alternativas ou quando lidamos com estruturas de dados

📝 Exercícios#

Escreva um programa que solicita ao usuário dois valores, um do tipo inteiro (int) e outro do tipo ponto flutuante (float). Após receber esses valores como entrada, o programa deve atribuí-los a duas variáveis distintas e, em seguida, imprimir na tela o resultado das seguintes operações matemáticas:

Soma dos dois valores.
Subtração do valor do tipo float pelo valor do tipo inteiro.
Multiplicação dos dois valores.
Divisão do valor do tipo inteiro pelo valor do tipo float.

Certifique-se de formatar adequadamente a saída dos resultados.

# Teste 1
Entrada:
10
2.5
Saída:
Soma: 12.5
Subtração: -7.5
Multiplicação: 25.0
Divisão: 4.0

# Teste 2
Entrada:
15
3.0
Saída:
Soma: 18.0
Subtração: -12.0
Multiplicação: 45.0
Divisão: 5.0 

Escreva um programa que solicite ao usuário que insira uma palavra ou frase. Em seguida, o programa deve imprimir o comprimento da string, a primeira letra da string, a última letra da string e a string invertida.

# Teste 1
Entrada: A felicidade está nas pequenas coisas
Saída:
37
A
s
sasioc saneuqep san átse edadicilef A
   
# Teste 2
Entrada: A verdadeira liberdade está em conhecer a si mesmo
Saída:
50
A
o
omsem is a recehnoc me átse edadrebil ariedadrev A

Escreva um programa que compare duas strings fornecidas pelo usuário, considerando valores booleanos "True" ou "False". O programa deve ignorar diferenças de capitalização (maiúsculas e minúsculas) e imprimir na tela se as strings são iguais ou diferentes.

# Teste 1
Entrada: 
True
true   
Saída: 
São iguais
   
# Teste 2
Entrada: 
True
False
Saída: 
São diferentes

Faça um programa que calcule o Índice de Massa Corporal (IMC) de uma pessoa. O IMC é calculado dividindo-se o peso da pessoa pela sua altura ao quadrado. O IMC é uma medida da relação entre o peso e a altura de uma pessoa. O programa deve imprimir o IMC da pessoa, classificando-o de acordo com a tabela abaixo:

IMC | Classificação

< 18.5      | Abaixo do peso
18.5 - 24.9 | Saudável
25.0 - 29.9 | Sobrepeso
30.0 - 34.9 | Obesidade grau I
35.0 - 39.9 | Obesidade grau II
>= 40.0     | Obesidade grau III

# Teste 1
Entrada: 
71
1.70
Saída: 
Seu IMC é 24.57 (Saudável).
   
# Teste 2
Entrada: 
85
1.60
Saída: 
Seu IMC é 33.20 (Obesidade grau I).

Crie um programa que solicite ao usuário a inserção de cinco frutas diferentes. Antes da leitura dos dados, crie uma lista vazia chamada frutas. Em seguida, armazene as frutas fornecidas pelo usuário nessa lista e, ao final, imprima a lista completa na tela.

# Teste 1
Entrada: 
maçã
banana
laranja
pera
melancia
Saída:
Lista de frutas: ['maçã', 'banana', 'laranja', 'pera', 'melancia']
   
# Teste 2
Entrada: 
uva
abacaxi
morango
manga
kiwi
Saída:
Lista de frutas: ['uva', 'abacaxi', 'morango', 'manga', 'kiwi']

Escreva um programa que solicite ao usuário a inserção de duas coordenadas (x e y). Em seguida, crie uma tupla chamada coordenadas com esses valores e imprima o conteúdo da tupla na tela.

# Teste 1
Entrada: 
2.5
3.8
Saída:
Coordenadas: (2.5, 3.8)
   
# Teste 2
Entrada:
-1.0
0.0
Saída:
Coordenadas: (-1.0, 0.0)

Crie um dicionário chamado contato. Solicite ao usuário que forneça os dados correspondentes às chaves "nome", "telefone" e "endereco". Em seguida, imprima o conteúdo completo do dicionário.

# Teste 1
Entrada: 
Python da Silva
8499999999
Rua da Programação, 123
Saída:
Nome: Python da Silva, Telefone: 8499999999, Endereço: Rua da Programação, 123.
   
# Teste 2
Entrada:
João da Silva
9876543210
Avenida dos Códigos, 456
Saída:
Nome: João da Silva, Telefone: 9876543210, Endereço: Avenida dos Códigos, 456.

Crie, antes da leitura dos números, um conjunto vazio chamado numeros utilizando a função set(). Em seguida, armazene os valores fornecidos pelo usuário nesse conjunto, utilizando o método .add(). Ao final, exiba o conjunto completo na saída.

# Teste 1
Entrada:
3
5
7
9
11
Saída:
{3, 5, 7, 9, 11}
   
# Teste 2
Entrada:
-2
0
4
6
8
Saída:
{0, 4, 6, 8, -2}

Faça um programa que solicite ao usuário a inserção de três números inteiros distintos para cada conjunto. Os conjuntos conjunto_a e conjunto_b devem ser criados utilizando a função set() e preenchidos com os números fornecidos pelo usuário, utilizando o método .add(). Em seguida, realize as seguintes operações e imprima os resultados:

União: combinar os elementos únicos de ambos os conjuntos.
Interseção: encontrar os elementos que estão presentes em ambos os conjuntos.
Diferença: identificar os elementos que estão em conjunto_a, mas não em conjunto_b.

# Teste 1
Entrada:
3
5
7
7
9
11
Saída:
União: {3, 5, 7, 9, 11}
Interseção: {7}
Diferença: {3, 5}
   
# Teste 2
Entrada:
1
2
3
4
5
1
Saída:
União: {1, 2, 3, 4, 5}
Interseção: {1}
Diferença: {2, 3}

Dada duas strings fornecidas pelo usuário, realize as seguintes operações e imprima os resultados:

Transformar em maiúsculas: converta toda a primeira string para letras maiúsculas.
Transformar em minúsculas: converta toda a segunda string para letras minúsculas.
Concatenar as strings: combine a primeira e a segunda string em uma única string.
Imprimir o resultado: exiba a string concatenada na tela.

# Teste 1
Entrada:
Olá, mundo.
Mundo
Saída:
OLÁ, MUNDO.
mundo
OLÁ, MUNDO. mundo
  
# Teste 2
Entrada:
A Verdade Está Lá Fora, Neo.
Mas Você Tem Que Escolher Se Quer Vê-la.
Saída:
A VERDADE ESTÁ LÁ FORA, NEO.
mas você tem que escolher se quer vê-la.
A VERDADE ESTÁ LÁ FORA, NEO. mas você tem que escolher se quer vê-la.

Você deve criar um programa que verifica se os números em uma lista são pares ou ímpares. A lista possui tamanho 5 e será fornecida pelo usuário. Cada número na lista deve ser avaliado individualmente, sem o uso de estruturas de repetição (como loops). O programa deve exibir na tela se cada número é par ou ímpar.

# Teste 1
Entrada:
4
9
12
17
6
Saída:
O número 4 é par.
O número 9 é ímpar.
O número 12 é par.
O número 17 é ímpar.
O número 6 é par.
   
# Teste 2
Entrada:
5
6
7
1
2   
Saída:
O número 5 é ímpar.
O número 6 é par.
O número 7 é ímpar.
O número 1 é ímpar.
O número 2 é par.

Escreva um programa para coletar informações de um aluno. Utilizando um dicionário denominado “aluno”, solicite ao usuário as seguintes informações:

Nome do aluno.
Matrícula do aluno.
Três notas do aluno.

Posteriormente, exiba na tela os dados registrados, incluindo o nome, matrícula e a média das três notas do aluno. Utilize somente os métodos especiais dos dicionários para inserir e acessar os dados.

# Teste 1
Entrada:
Linus Benedict Torvalds
12345
8.5
7.2
9.0
Saída:
Nome: Linus Benedict Torvalds
Matrícula: 12345
Média: 8.23

# Teste 2
Entrada:
Ada Lovelace
67890
9.8
8.7
10.0
Saída:
Nome: Ada Lovelace
Matrícula: 67890
Média: 9.5

Referências#

[Fou24]

Python Software Foundation. Python 3 Documentation. 2024. URL: https://docs.python.org/3/tutorial/index.html.

Capítulo 2: Tipos de dados e Estruturas Condicionais

Contents

Capítulo 2: Tipos de dados e Estruturas Condicionais#

Definindo Variáveis#

Regras para Nomear Variáveis#

Palavras Reservadas#

Formatando a Saída de Dados#

Leitura de Dados com input()#

Tipos de Dados Simples (Primitivos)#

Números Inteiros#

Números de Ponto Flutuante#

Booleanos#

Strings#

Características da Dinamicidade de Tipo#

Conversão de tipos (Casting) e Bases numéricas#

Funções de Conversão#

Conversão entre Bases Numéricas#

Aplicações Práticas das Conversões entre Bases Numéricas#

Tipos de Dados Compostos (Coleções)#

Listas#

Operações Básicas com Listas#

Métodos Principais de Listas#

Combinação de Listas#

Exemplo Prático Integrado#

Boas Práticas#

Tuplas#

Operações Fundamentais#

Métodos Nativos#

Combinação de Tuplas#

Aplicações Práticas#

Exemplo prático com função#

Boas Práticas#

Dicionários#

Operações básicas com dicionários#

Métodos úteis#

Exemplos práticos#

Boas práticas#

Conjuntos#

Operações básicas#

Operações entre conjuntos#

Métodos úteis#

Operadores e métodos equivalentes#

Exemplos práticos#

Boas práticas#

Estruturas de Decisão#

if#

if-else#

if-elif-else#

Exemplo Básico#

Comparação de Sintaxes#

match case#

Exemplo Básico#

Exemplo com Estrutura de Dados#

📝 Exercícios#

Referências#

Leitura de Dados com `input()`#

`if`#

`if-else`#

`if-elif-else`#

`match case`#