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

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.

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.

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.

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.

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

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.

É importante destacar que em Python, o número 0 é frequentemente interpretado como False e o número 1 como True em contextos booleanos, ampliando a flexibilidade na expressão de condições e avaliação de expressões lógicas.

Aqui estão alguns exemplos de uso de booleanos:

# Declaração de uma variável do tipo booleano
a = True

# Atribuição de um valor a uma variável do tipo booleano
a = False

# Comparação de dois valores
print(10 > 20)

Saída do Código

False

No exemplo acima, a expressão 10 > 20 resulta em False porque 10 não é maior que 20. Esse tipo de avaliação é fundamental em operações lógicas e estruturas de controle que encontraremos em seções futuras.

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.

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 Base 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.

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 em Python

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

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

Estas conversões são especialmente úteis em programação de baixo nível, manipulação de bits e trabalhos com hardware.

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

Eletrônica/Embarcados
- Controle de registradores (hex/bin) em microcontroladores
- Configuração de GPIOs com máscaras binárias
Desenvolvimento Web
- Cores em hexadecimal (#RRGGBB)
- Permissões de arquivo (octal) em sistemas Unix
Redes e Segurança
- Endereçamento IP e máscaras de sub-rede
- Análise de pacotes e hashes criptográficos
Otimização de Código
- Operações bitwise para manipulação eficiente de dados
- Compactação de informações em estruturas binárias
Sistemas Legados
- Leitura de dumps de memória (hex)
- Interpretação de arquivos binários e headers

Estes conceitos são a base para áreas como IoT, criptografia, desenvolvimento de drivers e análise forense digital.

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])   # Saída: "Python"
print(linguagens[-1])  # Saída: "C++"

Saída do Código:

Python
C++

Modificando Listas

linguagens[1] = "JavaScript"
print(linguagens)

Saída do Código:

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

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

Usando desempacotamento (Python 3.5+)

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

Saída do Código:

[1, 2, 3, 4, 5]

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

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

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

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 chave não existe

# Adicionando ou atualizando valores
pessoa["salario"] = 7500.00
pessoa.update({"empresa": "Tech Solutions", "setor": "TI"})

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 úteis para operações matemáticas como união, interseção e diferença 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 com conjuntos#

Criação:

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

Adição e remoção:

numeros.add(4)           # Adiciona um elemento
numeros.remove(2)        # Remove elemento (gera erro se não existir)
numeros.discard(5)       # Remove se existir (não gera erro)

Saída do Código:

print(numeros)  # Saída: {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)  # Mostra os elementos que estão apenas no PRIMEIRO conjunto

Saída do Código:

{1, 2}

Veja a tabela completa a seguir.

Métodos úteis#

Método	Descrição	Exemplo	Saída típica
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}
clear()	Remove todos os elementos	numeros.clear()	set()

Exemplos práticos#

Conjunto de vogais:

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

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}

Conjunto de cores:

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.

Estrutura `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.

Estrutura `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.”

Estrutura `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

Tabela Resumo das Estruturas de Decisão

Estrutura	Descrição	Uso
if	Executa um bloco de código se a condição for verdadeira	Usado quando há uma única condição a ser verificada
if-else	Executa um bloco se a condição for verdadeira e outro se for falsa	Usado quando há duas condições possíveis (verdadeiro ou falso)
if-elif-else	Verifica múltiplas condições sequencialmente	Usado quando há mais de duas condições e é necessário tratar diferentes cenários

📝 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. Accessed: 2024-09-29. 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#

Formatando a Saída de Dados#

Números Inteiros#

Números de Ponto Flutuante#

Strings#

Booleanos#

Características da Dinamicidade de Tipo#

Conversão de tipos (Casting) e Base 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 com conjuntos#

Operações entre conjuntos#

Métodos úteis#

Exemplos práticos#

Boas práticas#

Estruturas de Decisão#

Estrutura if#

Estrutura if-else#

Estrutura if-elif-else#

Exemplo Básico:#

Comparação de Sintaxes:#

📝 Exercícios#

Referências#

Estrutura `if`#

Estrutura `if-else`#

Estrutura `if-elif-else`#