Apostila de Python para Iniciantes

Introdução ao Python

Python é uma linguagem de programação de alto nível, interpretada, de script,

imperativa, orientada a objetos, funcional, de tipagem dinâmica e forte. Foi criada por
Guido van Rossum no final dos anos 80 e lançada pela primeira vez em 1991. Python é
conhecida por sua sintaxe clara e legível, o que a torna uma excelente escolha para
iniciantes em programação.

Por que aprender Python?

Python é uma das linguagens de programação mais populares do mundo e sua

demanda no mercado de trabalho continua a crescer. Ela é amplamente utilizada em
diversas áreas, como:

Desenvolvimento Web: Com frameworks como Django e Flask.

Análise de Dados e Machine Learning: Com bibliotecas como Pandas, NumPy,

Scikit-learn e TensorFlow.

Automação de Tarefas: Scripts para automatizar tarefas repetitivas.

Inteligência Artificial: Desenvolvimento de algoritmos e sistemas inteligentes.

Desenvolvimento de Jogos: Com bibliotecas como Pygame.

Computação Científica e Numérica: Para simulações e cálculos complexos.

Sua versatilidade e a vasta comunidade de desenvolvedores tornam o Python uma

ferramenta poderosa para resolver uma ampla gama de problemas.

Instalação do Python

Para começar a programar em Python, você precisa instalá-lo em seu computador.

Recomendamos a instalação da versão mais recente do Python 3.
Windows

1. Acesse o site oficial do Python: [Link]

2. Baixe o instalador executável para Windows (geralmente a versão de 64 bits).

3. Execute o instalador. Muito importante: Marque a opção "Add Python X.Y to

PATH" durante a instalação. Isso permitirá que você execute Python a partir de
qualquer diretório no seu terminal.

4. Siga as instruções do instalador para concluir a instalação.

macOS

1. Acesse o site oficial do Python: [Link]

2. Baixe o instalador para macOS.

3. Execute o instalador e siga as instruções.

4. Python já vem pré-instalado em muitas versões do macOS, mas é recomendável

instalar a versão mais recente para desenvolvimento.

Linux

Python geralmente já vem pré-instalado na maioria das distribuições Linux. Você pode
verificar a versão instalada abrindo o terminal e digitando:

python3 --version

Se precisar instalar ou atualizar, use o gerenciador de pacotes da sua distribuição:

Debian/Ubuntu: bash sudo apt update sudo apt install python3 sudo apt
install python3-pip

Fedora/RHEL: bash sudo dnf install python3 sudo dnf install python3-
pip

Primeiro Programa em Python

Tradicionalmente, o primeiro programa que se escreve em qualquer linguagem é o

"Olá, Mundo!".
 1. Abra um editor de texto (como VS Code, Sublime Text, Notepad++ ou até mesmo
o Bloco de Notas).

2. Crie um novo arquivo e digite o seguinte código:

python print("Olá, Mundo!")

3. Salve o arquivo com o nome [Link] (a extensão .py é importante).

4. Abra o terminal ou prompt de comando, navegue até o diretório onde você

salvou o arquivo e execute-o com o comando:

bash python [Link]

Você deverá ver a mensagem "Olá, Mundo!" impressa no terminal. Parabéns, você
acabou de executar seu primeiro programa em Python!

Tipos de Dados e Variáveis

Em programação, dados são as informações que seu programa manipula. Variáveis

são "contêineres" que armazenam esses dados. Cada dado tem um tipo, que define o
que pode ser feito com ele.

Variáveis

Uma variável em Python é criada no momento em que você atribui um valor a ela. Não
é necessário declarar o tipo da variável explicitamente, pois Python é uma linguagem
de tipagem dinâmica. O tipo da variável é determinado pelo valor que ela armazena.

Regras para nomes de variáveis:

Devem começar com uma letra (a-z, A-Z) ou um underscore (_).

Não podem começar com um número.

Podem conter letras, números e underscores.

São case-sensitive (idade é diferente de Idade).

Não podem ser palavras reservadas do Python (como if , else , for , while ,
etc.).
Exemplos:

nome = "Alice"
idade = 30
altura = 1.75
is_estudante = True

print(nome) # Saída: Alice

print(idade) # Saída: 30
print(altura) # Saída: 1.75
print(is_estudante) # Saída: True

Tipos de Dados Built-in

Python possui vários tipos de dados embutidos (built-in) para lidar com diferentes
tipos de informações.

1. Números

Python suporta três tipos numéricos:

int (inteiros): Números inteiros, positivos ou negativos, sem casas decimais.

python numero_inteiro = 10 print(type(numero_inteiro)) # Saída:
<class 'int'>

float (ponto flutuante): Números reais, com casas decimais. python

numero_decimal = 10.5 print(type(numero_decimal)) # Saída: <class
'float'>

complex (números complexos): Números com parte real e imaginária (ex: 3 +

5j ). python numero_complexo = 3 + 5j print(type(numero_complexo)) #
Saída: <class 'complex'>

2. Strings ( str )

Strings são sequências de caracteres, usadas para representar texto. Podem ser
definidas com aspas simples ( ' ) ou duplas ( " ).

mensagem = "Olá, Python!"

nome = 'Maria'

print(mensagem)
print(nome)
print(type(mensagem)) # Saída: <class 'str'>
Strings são imutáveis, o que significa que uma vez criadas, não podem ser alteradas.
Operações com strings geralmente retornam novas strings.

3. Booleanos ( bool )

Booleanos representam valores de verdade: True (verdadeiro) ou False (falso). São

frequentemente usados em estruturas de controle de fluxo.

esta_chovendo = True
tem_sol = False

print(esta_chovendo)
print(type(esta_chovendo)) # Saída: <class 'bool'>

4. Listas ( list )

Listas são coleções ordenadas e mutáveis de itens. Podem conter itens de diferentes
tipos de dados e são definidas com colchetes [] .

frutas = ["maçã", "banana", "cereja"]

numeros = [1, 2, 3, 4, 5]
mista = ["texto", 10, True, 3.14]

print(frutas[0]) # Saída: maçã (acesso por índice, começa em 0)

[Link]("laranja") # Adiciona um item
print(frutas) # Saída: ['maçã', 'banana', 'cereja', 'laranja']
print(type(frutas)) # Saída: <class 'list'>

5. Tuplas ( tuple )

Tuplas são coleções ordenadas e imutáveis de itens. São definidas com parênteses
() .

coordenadas = (10.0, 20.0)

cores = ("vermelho", "verde", "azul")

print(coordenadas[0]) # Saída: 10.0

# [Link](30.0) # Isso geraria um erro, pois tuplas são imutáveis
print(type(coordenadas)) # Saída: <class 'tuple'>

6. Dicionários ( dict )

Dicionários são coleções não ordenadas e mutáveis de pares chave-valor. Cada chave
deve ser única e imutável (geralmente strings ou números).
 pessoa = {"nome": "João", "idade": 25, "cidade": "São Paulo"}

print(pessoa["nome"]) # Saída: João

pessoa["idade"] = 26 # Altera um valor
pessoa["profissao"] = "Engenheiro" # Adiciona um novo par
print(pessoa) # Saída: {'nome': 'João', 'idade': 26, 'cidade': 'São
Paulo', 'profissao': 'Engenheiro'}
print(type(pessoa)) # Saída: <class 'dict'>

7. Conjuntos ( set )

Conjuntos são coleções não ordenadas de itens únicos. São úteis para remover
duplicatas e realizar operações de conjunto (união, interseção, etc.). Definidos com
chaves {} ou pela função set() .

numeros_unicos = {1, 2, 3, 3, 4, 5}
print(numeros_unicos) # Saída: {1, 2, 3, 4, 5} (duplicatas removidas)

letras = set("abracadabra")
print(letras) # Saída: {'r', 'b', 'a', 'c', 'd'} (ordem pode variar)
print(type(letras)) # Saída: <class 'set'>

Conversão de Tipos (Type Casting)

Você pode converter valores de um tipo para outro usando funções de conversão de
tipo.

numero_str = "123"
numero_int = int(numero_str)
print(numero_int) # Saída: 123
print(type(numero_int)) # Saída: <class 'int'>

numero_float = float("3.14")
print(numero_float) # Saída: 3.14
print(type(numero_float)) # Saída: <class 'float'>

inteiro_para_str = str(50)
print(inteiro_para_str) # Saída: "50"
print(type(inteiro_para_str)) # Saída: <class 'str'>

Compreender os tipos de dados e como usá-los com variáveis é fundamental para

escrever programas eficazes em Python. No próximo capítulo, exploraremos os
operadores que nos permitem realizar cálculos e comparações com esses dados.
Operadores

Operadores são símbolos especiais que realizam operações em um ou mais operandos

(valores ou variáveis). Em Python, existem diversos tipos de operadores, cada um com
uma finalidade específica.

1. Operadores Aritméticos

Usados para realizar operações matemáticas básicas.

Operador Descrição Exemplo Resultado

+ Adição 10 + 5 15

- Subtração 10 - 5 5

* Multiplicação 10 * 5 50

/ Divisão 10 / 3 3.33...

% Módulo (resto) 10 % 3 1

** Exponenciação 2 ** 3 8

// Divisão inteira 10 // 3 3

Exemplos:

a = 15
b = 4

print(f"Adição: {a + b}") # Saída: Adição: 19

print(f"Subtração: {a - b}") # Saída: Subtração: 11
print(f"Multiplicação: {a * b}") # Saída: Multiplicação: 60
print(f"Divisão: {a / b}") # Saída: Divisão: 3.75
print(f"Módulo: {a % b}") # Saída: Módulo: 3
print(f"Exponenciação: {a ** 2}") # Saída: Exponenciação: 225
print(f"Divisão Inteira: {a // b}") # Saída: Divisão Inteira: 3

2. Operadores de Atribuição

Usados para atribuir valores a variáveis. O operador de atribuição mais comum é o = .

Existem também operadores de atribuição combinados.
 Exemplo
Operador Equivalente Descrição
Original

= x = 10 x = 10 Atribui o valor 10 a x

+= x += 5 x = x + 5 Adiciona 5 a x e atribui o resultado

-= x -= 3 x = x - 3 Subtrai 3 de x e atribui o resultado

*= x *= 2 x = x * 2 Multiplica x por 2 e atribui o resultado

/= x /= 4 x = x / 4 Divide x por 4 e atribui o resultado

%= x %= 3 x = x % 3 Atribui o resto da divisão de x por 3

x = x **
**= x **= 2 Eleva x à potência de 2 e atribui o resultado
2

x = x // Atribui o resultado da divisão inteira de x

//= x //= 2
2 por 2

Exemplos:

x = 10
print(f"Valor inicial de x: {x}") # Saída: Valor inicial de x: 10

x += 5
print(f"x depois de x += 5: {x}") # Saída: x depois de x += 5: 15

x *= 2
print(f"x depois de x *= 2: {x}") # Saída: x depois de x *= 2: 30

x /= 3
print(f"x depois de x /= 3: {x}") # Saída: x depois de x /= 3: 10.0

3. Operadores de Comparação

Usados para comparar dois valores e retornar um valor booleano ( True ou False ).
 Operador Descrição Exemplo Resultado

== Igual a 10 == 5 False

!= Diferente de 10 != 5 True

> Maior que 10 > 5 True

< Menor que 10 < 5 False

>= Maior ou igual a 10 >= 10 True

<= Menor ou igual a 10 <= 5 False

Exemplos:

a = 10
b = 20

print(f"a == b: {a == b}") # Saída: a == b: False

print(f"a != b: {a != b}") # Saída: a != b: True
print(f"a > b: {a > b}") # Saída: a > b: False
print(f"a < b: {a < b}") # Saída: a < b: True
print(f"a >= b: {a >= b}") # Saída: a >= b: False
print(f"a <= b: {a <= b}") # Saída: a <= b: True

4. Operadores Lógicos

Usados para combinar expressões condicionais e retornar um valor booleano.

Operador Descrição Exemplo Resultado

Retorna True se ambas as condições forem True and

and False
True False

Retorna True se pelo menos uma condição for

or True or False True
True

not Inverte o valor booleano not True False

Exemplos:
 idade = 25
tem_carteira = True

print(f"Pode dirigir (idade >= 18 and tem_carteira): {idade >= 18 and

tem_carteira}") # Saída: Pode dirigir (idade >= 18 and tem_carteira): True

tem_sol = False
esta_quente = True

print(f"Ir à praia (tem_sol or esta_quente): {tem_sol or esta_quente}") #

Saída: Ir à praia (tem_sol or esta_quente): True

esta_chovendo = False
print(f"Não está chovendo (not esta_chovendo): {not esta_chovendo}") # Saída:
Não está chovendo (not esta_chovendo): True

5. Operadores de Identidade

Usados para comparar se dois objetos são o mesmo objeto na memória, não apenas
se têm o mesmo valor.

Operador Descrição Exemplo Resultado

Retorna True se ambas as variáveis apontam para o

is x is y True
mesmo objeto

Retorna True se ambas as variáveis não apontam x is not

is not False
para o mesmo objeto y

Exemplos:

x = [1, 2, 3]
y = [1, 2, 3]
z = x

print(f"x == y: {x == y}") # Saída: x == y: True (valores são iguais)

print(f"x is y: {x is y}") # Saída: x is y: False (objetos diferentes na
memória)
print(f"x is z: {x is z}") # Saída: x is z: True (z aponta para o mesmo
objeto que x)

6. Operadores de Associação (Membership Operators)

Usados para verificar se um valor está presente em uma sequência (string, lista, tupla,
conjunto, dicionário).
 Operador Descrição Exemplo Resultado

Retorna True se o valor estiver presente na

in 'a' in 'banana' True
sequência

Retorna True se o valor não estiver presente 'z' not in

not in True
na sequência 'banana'

Exemplos:

frutas = ["maçã", "banana", "cereja"]

print(f"'maçã' in frutas: {'maçã' in frutas}") # Saída: 'maçã' in frutas:

True
print(f"'uva' not in frutas: {'uva' not in frutas}") # Saída: 'uva' not in
frutas: True

texto = "Python é divertido"

print(f"'divertido' in texto: {'divertido' in texto}") # Saída: 'divertido' in
texto: True

Compreender e saber usar esses operadores é crucial para construir a lógica dos seus
programas em Python. Eles são a base para realizar cálculos, tomar decisões e
manipular dados de forma eficaz.

Estruturas de Controle

As estruturas de controle permitem que você altere o fluxo de execução do seu

programa, tomando decisões e repetindo blocos de código. Elas são fundamentais
para criar programas dinâmicos e interativos.

1. Estruturas Condicionais ( if , elif , else )

As estruturas condicionais são usadas para executar um bloco de código apenas se

uma determinada condição for verdadeira. Em Python, usamos as palavras-chave if ,
elif (else if) e else .

if Statement

O bloco de código dentro de um if só é executado se a condição for True .

 idade = 18

if idade >= 18:

print("Você é maior de idade.")

if-else Statement

O else é executado se a condição do if for False .

idade = 16

if idade >= 18:

print("Você é maior de idade.")
else:
print("Você é menor de idade.")

if-elif-else Statement

Use elif para verificar múltiplas condições. O Python verifica as condições em

ordem, e o primeiro bloco cuja condição é True é executado.

nota = 75

if nota >= 90:

print("Conceito A")
elif nota >= 80:
print("Conceito B")
elif nota >= 70:
print("Conceito C")
else:
print("Conceito D")

Importante: A indentação (espaços em branco no início da linha) é crucial em Python

para definir blocos de código. Erros de indentação resultarão em erros de sintaxe.

2. Estruturas de Repetição (Laços)

As estruturas de repetição, ou laços (loops), permitem que você execute um bloco de

código várias vezes.

for Loop

O laço for é usado para iterar sobre uma sequência (como uma lista, tupla, string, ou
range) ou outros objetos iteráveis.
 # Iterando sobre uma lista
frutas = ["maçã", "banana", "cereja"]
for fruta in frutas:
print(fruta)

# Iterando sobre uma string

for letra in "Python":
print(letra)

# Usando range() para iterar um número específico de vezes

# range(5) gera números de 0 a 4
for i in range(5):
print(i)

# range(inicio, fim) - de inicio (inclusive) até fim (exclusive)

for i in range(1, 6):
print(i)

# range(inicio, fim, passo) - de inicio até fim, pulando de 'passo' em 'passo'

for i in range(0, 10, 2):
print(i)

while Loop

O laço while executa um bloco de código enquanto uma condição for True . É
importante garantir que a condição eventualmente se torne False para evitar um
laço infinito.

contador = 0
while contador < 5:
print(contador)
contador += 1 # Incrementa o contador para evitar laço infinito

break e continue

break : Usado para sair de um laço imediatamente.

```python for i in range(10): if i == 5: break # Sai do laço quando i for 5 print(i)

Saída: 0, 1, 2, 3, 4
```

continue : Usado para pular a iteração atual de um laço e ir para a próxima.

 ```python for i in range(5): if i == 2: continue # Pula a impressão quando i for 2
print(i)

Saída: 0, 1, 3, 4
```

Dominar as estruturas de controle é essencial para escrever programas que podem

responder a diferentes entradas e automatizar tarefas repetitivas. No próximo
capítulo, abordaremos as funções, que permitem organizar seu código em blocos
reutilizáveis.

Funções

Funções são blocos de código reutilizáveis que realizam uma tarefa específica. Elas
ajudam a organizar o código, torná-lo mais legível e evitar a repetição. Em Python,
você define uma função usando a palavra-chave def .

Definindo uma Função

Uma função é definida com def , seguida pelo nome da função, parênteses () (que
podem conter parâmetros) e dois pontos : . O corpo da função é indentado.

def saudar():
print("Olá! Bem-vindo ao curso de Python.")

# Chamando a função
saudar()

Parâmetros e Argumentos

Funções podem receber informações através de parâmetros. Quando você chama a

função, os valores que você passa são chamados de argumentos.
 def saudar_nome(nome):
print(f"Olá, {nome}! Como você está?")

saudar_nome("Alice")
saudar_nome("Bob")

Múltiplos Parâmetros

Uma função pode ter múltiplos parâmetros, separados por vírgulas.

def somar(a, b):

resultado = a + b
print(f"A soma de {a} e {b} é {resultado}")

somar(10, 5)
somar(7, 3)

Retorno de Valores ( return )

Funções podem retornar um valor usando a palavra-chave return . Isso permite que o
resultado da função seja usado em outras partes do seu programa.

def multiplicar(x, y):

return x * y

produto = multiplicar(4, 6)
print(f"O produto é: {produto}") # Saída: O produto é: 24

def eh_par(numero):
if numero % 2 == 0:
return True
else:
return False

print(f"10 é par? {eh_par(10)}") # Saída: 10 é par? True

print(f"7 é par? {eh_par(7)}") # Saída: 7 é par? False

Se uma função não tiver uma instrução return explícita, ela retornará None por
padrão.

Parâmetros Padrão (Default Parameters)

Você pode definir valores padrão para os parâmetros de uma função. Se um

argumento não for fornecido para esse parâmetro, o valor padrão será usado.
 def saudar_cidade(nome, cidade="Mundo"):
print(f"Olá, {nome}! Bem-vindo a {cidade}.")

saudar_cidade("Carlos") # Saída: Olá, Carlos! Bem-vindo a Mundo.

saudar_cidade("Ana", "Paris") # Saída: Olá, Ana! Bem-vindo a Paris.

Argumentos de Palavra-Chave (Keyword Arguments)

Você pode passar argumentos para uma função usando o nome do parâmetro, o que
torna o código mais legível e permite que você passe os argumentos em qualquer
ordem.

def descrever_carro(marca, modelo, ano):

print(f"Marca: {marca}, Modelo: {modelo}, Ano: {ano}")

descrever_carro(marca="Toyota", ano=2020, modelo="Corolla")

descrever_carro(modelo="Civic", marca="Honda", ano=2022)

Funções Anônimas (Lambda Functions)

Funções lambda são pequenas funções anônimas (sem nome) que podem ter
qualquer número de argumentos, mas apenas uma expressão. São úteis para tarefas
simples e rápidas.

somar_lambda = lambda a, b: a + b
print(f"Soma com lambda: {somar_lambda(2, 3)}") # Saída: Soma com lambda: 5

# Usando lambda com funções de ordem superior (como sorted, filter, map)
lista_numeros = [1, 5, 2, 8, 3]
lista_ordenada = sorted(lista_numeros, key=lambda x: x % 2) # Ordena por par/
ímpar
print(f"Lista ordenada por par/ímpar: {lista_ordenada}") # Saída: Lista
ordenada por par/ímpar: [2, 8, 1, 5, 3]

Funções são um dos pilares da programação modular e eficiente. Elas permitem que
você divida seu programa em partes menores e gerenciáveis, facilitando o
desenvolvimento e a manutenção. No próximo capítulo, exploraremos as estruturas
de dados mais avançadas que Python oferece.
Estruturas de Dados

Estruturas de dados são formas de organizar e armazenar dados de maneira eficiente,

permitindo acesso e manipulação otimizados. Python oferece várias estruturas de
dados built-in que são muito poderosas e fáceis de usar.

1. Listas ( list )

Listas são coleções ordenadas, mutáveis e que permitem elementos duplicados. São
definidas usando colchetes [] .

# Criação de uma lista

minha_lista = [1, 2, 3, "quatro", 5.0]
print(f"Lista: {minha_lista}")

# Acesso a elementos (indexação)

print(f"Primeiro elemento: {minha_lista[0]}") # Saída: 1
print(f"Último elemento: {minha_lista[-1]}") # Saída: 5.0

# Fatiamento (slicing)
print(f"Elementos do índice 1 ao 3: {minha_lista[1:4]}") # Saída: [2, 3,
'quatro']

# Modificação de elementos
minha_lista[0] = 10
print(f"Lista modificada: {minha_lista}") # Saída: [10, 2, 3, 'quatro', 5.0]

# Adicionar elementos
minha_lista.append("novo") # Adiciona ao final
minha_lista.insert(1, "inserido") # Adiciona em um índice específico
print(f"Lista com novos elementos: {minha_lista}")

# Remover elementos
minha_lista.remove("quatro") # Remove o primeiro 'quatro' encontrado
pop_elemento = minha_lista.pop(2) # Remove e retorna o elemento do índice 2
print(f"Lista após remoção: {minha_lista}")
print(f"Elemento removido com pop: {pop_elemento}")

# Iterar sobre uma lista

for item in minha_lista:
print(item)

# Tamanho da lista
print(f"Tamanho da lista: {len(minha_lista)}")

2. Tuplas ( tuple )

Tuplas são coleções ordenadas, imutáveis e que permitem elementos duplicados. São
definidas usando parênteses () .
 # Criação de uma tupla
minha_tupla = (1, 2, 3, "quatro", 5.0)
print(f"Tupla: {minha_tupla}")

# Acesso a elementos (indexação e fatiamento funcionam como em listas)

print(f"Primeiro elemento: {minha_tupla[0]}") # Saída: 1

# Tentativa de modificação (resultará em erro)

# minha_tupla[0] = 10 # TypeError: 'tuple' object does not support item
assignment

# Iterar sobre uma tupla

for item in minha_tupla:
print(item)

# Tamanho da tupla
print(f"Tamanho da tupla: {len(minha_tupla)}")

Tuplas são frequentemente usadas para dados que não devem ser alterados, como
coordenadas geográficas ou configurações.

3. Dicionários ( dict )

Dicionários são coleções não ordenadas, mutáveis e que armazenam dados em pares
de chave-valor. Cada chave deve ser única e imutável. São definidos usando chaves
{} .
 # Criação de um dicionário
meu_dicionario = {"nome": "Alice", "idade": 30, "cidade": "São Paulo"}
print(f"Dicionário: {meu_dicionario}")

# Acesso a valores por chave

print(f"Nome: {meu_dicionario["nome"]}") # Saída: Alice

# Modificação de valores
meu_dicionario["idade"] = 31
print(f"Idade modificada: {meu_dicionario["idade"]}") # Saída: 31

# Adicionar novos pares chave-valor

meu_dicionario["profissao"] = "Engenheira"
print(f"Dicionário com nova chave: {meu_dicionario}")

# Remover pares chave-valor

del meu_dicionario["cidade"]
print(f"Dicionário após remoção: {meu_dicionario}")

# Iterar sobre chaves, valores ou itens

print("Chaves:")
for chave in meu_dicionario.keys():
print(chave)

print("Valores:")
for valor in meu_dicionario.values():
print(valor)

print("Itens (chave, valor):")

for chave, valor in meu_dicionario.items():
print(f"{chave}: {valor}")

# Verificar se uma chave existe

print(f"'nome' está no dicionário? {'nome' in meu_dicionario}") # Saída: True

4. Conjuntos ( set )

Conjuntos são coleções não ordenadas de elementos únicos. São úteis para operações
matemáticas de conjunto (união, interseção, diferença) e para remover duplicatas. São
definidos usando chaves {} ou a função set() .
 # Criação de um conjunto
meu_conjunto = {1, 2, 3, 2, 4, 5}
print(f"Conjunto: {meu_conjunto}") # Saída: {1, 2, 3, 4, 5} (duplicatas
removidas)

# Adicionar elementos
meu_conjunto.add(6)
print(f"Conjunto após adicionar: {meu_conjunto}")

# Remover elementos
meu_conjunto.remove(3)
print(f"Conjunto após remover: {meu_conjunto}")

# Operações de conjunto
conjunto_a = {1, 2, 3, 4}
conjunto_b = {3, 4, 5, 6}

print(f"União: {conjunto_a.union(conjunto_b)}") # Saída: {1, 2, 3, 4,

5, 6}
print(f"Interseção: {conjunto_a.intersection(conjunto_b)}") # Saída: {3, 4}
print(f"Diferença (A - B): {conjunto_a.difference(conjunto_b)}") # Saída: {1,
2}

# Verificar se um elemento está no conjunto

print(f"5 está no conjunto A? {5 in conjunto_a}") # Saída: False

Escolher a estrutura de dados correta para cada situação é fundamental para a

eficiência e clareza do seu código. Com essas estruturas, você pode lidar com uma
grande variedade de problemas de armazenamento e manipulação de dados em
Python.

Exercícios

Para consolidar o conhecimento adquirido, é fundamental praticar. Esta seção

apresenta exercícios para cada tópico abordado, além de desafios de lógica de
programação. Tente resolvê-los antes de consultar as soluções.

Exercícios de Introdução ao Python

1. Olá, Mundo Personalizado: Modifique o programa "Olá, Mundo!" para que ele
imprima uma mensagem de saudação com o seu nome.

```python
 Seu código aqui
```

2. Cálculo Simples: Escreva um programa que calcule a soma de dois números

inteiros e imprima o resultado.

```python

Seu código aqui

```

Exercícios de Tipos de Dados e Variáveis

1. Informações Pessoais: Crie variáveis para armazenar seu nome (string), idade
(inteiro), altura (float) e se você é estudante (booleano). Imprima o tipo de cada
variável.

```python

Seu código aqui

```

2. Conversão de Temperatura: Crie uma variável com a temperatura em Celsius

(ex: 25). Converta essa temperatura para Fahrenheit usando a fórmula F = C *
9/5 + 32 e imprima o resultado.

```python
 Seu código aqui
```

3. Manipulação de String: Crie uma string com uma frase. Imprima o primeiro e o
último caractere da frase. Em seguida, imprima a frase em letras maiúsculas.

```python

Seu código aqui

```

Exercícios de Operadores

1. Calculadora Básica: Peça ao usuário para digitar dois números e uma operação
(+, -, *, /). Use operadores aritméticos para realizar a operação e imprimir o
resultado.

```python

Seu código aqui

```

2. Verificação de Idade: Peça ao usuário sua idade. Use operadores de

comparação para verificar se a idade é maior ou igual a 18 e imprima True ou
False .

```python
 Seu código aqui
```

3. Condição Múltipla: Crie duas variáveis booleanas, tem_dinheiro e tem_fome .

Use operadores lógicos para verificar se você pode comprar comida (tem
dinheiro E tem fome) e imprima o resultado.

```python

Seu código aqui

```

Exercícios de Estruturas de Controle

1. Par ou Ímpar: Peça ao usuário um número inteiro. Use uma estrutura

condicional para determinar se o número é par ou ímpar e imprima a mensagem
correspondente.

```python

Seu código aqui

```

2. Contagem Regressiva: Use um laço for para imprimir uma contagem

regressiva de 10 até 1. Em seguida, imprima "Lançar!".

```python
 Seu código aqui
```

3. Tabuada: Peça ao usuário um número. Use um laço for para imprimir a

tabuada desse número de 1 a 10.

```python

Seu código aqui

```

4. Adivinhe o Número: Crie um número secreto (ex: 7). Use um laço while para
pedir ao usuário para adivinhar o número. Dê dicas se o número é maior ou
menor, e pare quando ele acertar.

```python

Seu código aqui

```

Exercícios de Funções

1. Função de Saudação: Crie uma função chamada saudar_usuario que receba

um nome como parâmetro e imprima "Olá, [nome]!". Chame a função com seu
nome.

```python
 Seu código aqui
```

2. Calculadora de Média: Crie uma função chamada calcular_media que receba

três notas como parâmetros e retorne a média. Imprima o resultado.

```python

Seu código aqui

```

3. Verificador de Palíndromo: Crie uma função que receba uma string e retorne
True se ela for um palíndromo (lê-se igual de trás para frente) e False caso
contrário. Ignore espaços e case-sensitivity.

```python

Seu código aqui

```

Exercícios de Estruturas de Dados

1. Lista de Compras: Crie uma lista de compras com pelo menos 5 itens. Adicione
um novo item, remova um item existente e imprima a lista final.

```python
 Seu código aqui
```

2. Informações de Livro: Crie um dicionário para representar um livro, com chaves

como titulo , autor , ano e genero . Acesse e imprima o título e o autor.
Adicione uma nova chave editora .

```python

Seu código aqui

```

3. União de Conjuntos: Crie dois conjuntos de números. Encontre e imprima a

união e a interseção desses conjuntos.

```python

Seu código aqui

```

Desafios de Lógica de Programação

1. Sequência de Fibonacci: Escreva um programa que gere os primeiros n termos

da sequência de Fibonacci. A sequência começa com 0 e 1, e cada termo
subsequente é a soma dos dois anteriores (0, 1, 1, 2, 3, 5, 8...). Peça ao usuário o
valor de n .

```python
 Seu código aqui
```

2. Número Primo: Crie uma função que receba um número inteiro e retorne True
se ele for primo (divisível apenas por 1 e por ele mesmo) e False caso contrário.

```python

Seu código aqui

```

3. Inverter String: Escreva uma função que receba uma string e retorne a string
invertida, sem usar funções built-in de inversão (como [::-1] ).

```python

Seu código aqui

```

4. Contagem de Vogais: Crie uma função que receba uma string e retorne o
número de vogais (a, e, i, o, u, maiúsculas e minúsculas) presentes na string.

```python

Seu código aqui

```

5. Fatorial: Escreva uma função que calcule o fatorial de um número inteiro não
negativo. O fatorial de n (n!) é o produto de todos os inteiros positivos menores
 ou iguais a n . Por exemplo, 5! = 5 * 4 * 3 * 2 * 1 = 120.

```python

Seu código aqui

```

6. Remover Duplicatas de Lista: Crie uma função que receba uma lista com
elementos duplicados e retorne uma nova lista contendo apenas os elementos
únicos, mantendo a ordem original.

```python

Seu código aqui

```

7. Soma de Dígitos: Escreva uma função que receba um número inteiro e retorne a
soma de seus dígitos. Por exemplo, se o número for 123, a soma deve ser 1 + 2 + 3
= 6.

```python

Seu código aqui

```

8. Maior Elemento de uma Lista: Crie uma função que receba uma lista de
números e retorne o maior elemento da lista sem usar a função max() .

```python
 Seu código aqui
```

9. Ordenação Simples: Implemente uma função que ordene uma lista de números
em ordem crescente sem usar a função sort() ou sorted() .

```python

Seu código aqui

```

10. Jogo da Forca Simplificado: Crie um jogo da forca simples. Escolha uma palavra
secreta. O usuário tenta adivinhar letras. Se acertar, a letra é revelada. Se errar,
ele perde uma "vida". Limite o número de erros.

```python

Seu código aqui

```

Soluções dos Exercícios

Esta seção contém as soluções para os exercícios propostos. Tente resolver os

exercícios por conta própria antes de consultar as soluções. Elas servem como guia e
para ver diferentes abordagens.

Soluções de Introdução ao Python

1. Olá, Mundo Personalizado:

python nome = input("Qual é o seu nome? ") print(f"Olá, {nome}!")

 2. Cálculo Simples:

python num1 = 10 num2 = 20 soma = num1 + num2 print(f"A soma de

{num1} e {num2} é: {soma}")

Soluções de Tipos de Dados e Variáveis

1. Informações Pessoais:

```python nome = "Seu Nome" idade = 25 altura = 1.70 is_estudante = True

print(f"Nome: {nome}, Tipo: {type(nome)}") print(f"Idade: {idade}, Tipo:

{type(idade)}") print(f"Altura: {altura}, Tipo: {type(altura)}") print(f"É estudante:
{is_estudante}, Tipo: {type(is_estudante)}") ```

2. Conversão de Temperatura:

python celsius = 25 fahrenheit = celsius * 9/5 + 32 print(f"{celsius}

°C é igual a {fahrenheit}°F")

3. Manipulação de String:

python frase = "Python é uma linguagem poderosa" print(f"Primeiro

caractere: {frase[0]}") print(f"Último caractere: {frase[-1]}")
print(f"Frase em maiúsculas: {[Link]()}")

Soluções de Operadores

1. Calculadora Básica:

```python num1 = float(input("Digite o primeiro número: ")) operacao =

input("Digite a operação (+, -, *, /): ") num2 = float(input("Digite o segundo
número: "))

if operacao == '+': resultado = num1 + num2 elif operacao == '-': resultado = num1
- num2 elif operacao == '*': resultado = num1 * num2 elif operacao == '/': if num2
!= 0: resultado = num1 / num2 else: resultado = "Erro: Divisão por zero!" else:
resultado = "Operação inválida!"

print(f"Resultado: {resultado}") ```

2. Verificação de Idade:
 python idade = int(input("Digite sua idade: ")) maior_idade = idade
>= 18 print(f"É maior de idade? {maior_idade}")

3. Condição Múltipla:

```python tem_dinheiro = True tem_fome = True

pode_comprar_comida = tem_dinheiro and tem_fome print(f"Pode comprar

comida? {pode_comprar_comida}") ```

Soluções de Estruturas de Controle

1. Par ou Ímpar:

```python numero = int(input("Digite um número inteiro: "))

if numero % 2 == 0: print(f"O número {numero} é par.") else: print(f"O número

{numero} é ímpar.") ```

2. Contagem Regressiva:

python for i in range(10, 0, -1): print(i) print("Lançar!")

3. Tabuada:

```python numero = int(input("Digite um número para ver a tabuada: "))

for i in range(1, 11): print(f"{numero} x {i} = {numero * i}") ```

4. Adivinhe o Número:

```python import random

numero_secreto = [Link](1, 10) tentativa = 0

while True: tentativa = int(input("Adivinhe o número secreto (entre 1 e 10): ")) if

tentativa == numero_secreto: print("Parabéns! Você acertou!") break elif
tentativa < numero_secreto: print("Tente um número maior.") else: print("Tente
um número menor.") ```

Soluções de Funções

1. Função de Saudação:
 ```python def saudar_usuario(nome): print(f"Olá, {nome}!")

saudar_usuario("Maria") ```

2. Calculadora de Média:

```python def calcular_media(nota1, nota2, nota3): return (nota1 + nota2 +

nota3) / 3

media = calcular_media(7.5, 8.0, 9.0) print(f"A média é: {media:.2f}") ```

3. Verificador de Palíndromo:

```python def eh_palindromo(texto): texto_limpo = "".join([Link]() for char

in texto if [Link]()) return texto_limpo == texto_limpo[::-1]

print(f""""Arara" é palíndromo? {eh_palindromo("Arara")}""") print(f""""Ame a

ema" é palíndromo? {eh_palindromo("Ame a ema")}""") print(f""""Python" é
palíndromo? {eh_palindromo("Python")}""") ```

Soluções de Estruturas de Dados

1. Lista de Compras:

```python lista_compras = ["Arroz", "Feijão", "Macarrão", "Carne", "Leite"]

print(f"Lista inicial: {lista_compras}")

lista_compras.append("Pão") print(f"Lista após adicionar: {lista_compras}")

lista_compras.remove("Feijão") print(f"Lista após remover: {lista_compras}")

```

2. Informações de Livro:

```python livro = { "titulo": "O Pequeno Príncipe", "autor": "Antoine de Saint-

Exupéry", "ano": 1943, "genero": "Fábula" }

print(f"Título: {livro["titulo"]}") print(f"Autor: {livro["autor"]}")

livro["editora"] = "Agir" print(f"Livro com editora: {livro}") ```

3. União de Conjuntos:

```python conjunto1 = {1, 2, 3, 4, 5} conjunto2 = {4, 5, 6, 7, 8}

 uniao = [Link](conjunto2) intersecao =
[Link](conjunto2)

print(f"Conjunto 1: {conjunto1}") print(f"Conjunto 2: {conjunto2}") print(f"União:

{uniao}") print(f"Interseção: {intersecao}") ```

Soluções de Desafios de Lógica de Programação

1. Sequência de Fibonacci:

```python def fibonacci(n): if n <= 0: return [] elif n == 1: return [0] else: lista_fib =
[0, 1] while len(lista_fib) < n: proximo_termo = lista_fib[-1] + lista_fib[-2]
lista_fib.append(proximo_termo) return lista_fib

num_termos = int(input("Quantos termos da sequência de Fibonacci você quer

gerar? ")) print(fibonacci(num_termos)) ```

2. Número Primo:

```python def eh_primo(numero): if numero <= 1: return False for i in range(2,

int(numero**0.5) + 1): if numero % i == 0: return False return True

print(f"7 é primo? {eh_primo(7)}") print(f"10 é primo? {eh_primo(10)}") print(f"2

é primo? {eh_primo(2)}") ```

3. Inverter String:

```python def inverter_string(s): invertida = "" for char in s: invertida = char +

invertida return invertida

print(f"String original: Python, Invertida: {inverter_string("Python")}")

print(f"String original: Hello, Invertida: {inverter_string("Hello")}") ```

4. Contagem de Vogais:

```python def contar_vogais(texto): vogais = "aeiouAEIOU" contador = 0 for char

in texto: if char in vogais: contador += 1 return contador

print(f"Número de vogais em 'Programação': {contar_vogais("Programação")}")

print(f"Número de vogais em 'Inteligencia Artificial': {contar_vogais("Inteligencia
Artificial")}") ```

5. Fatorial:
 ```python def fatorial(n): if n < 0: return "Número não pode ser negativo" elif n
== 0: return 1 else: resultado = 1 for i in range(1, n + 1): resultado *= i return
resultado

print(f"Fatorial de 5: {fatorial(5)}") print(f"Fatorial de 0: {fatorial(0)}")

print(f"Fatorial de 7: {fatorial(7)}") ```

6. Remover Duplicatas de Lista:

```python def remover_duplicatas(lista): lista_unica = [] for item in lista: if item

not in lista_unica: lista_unica.append(item) return lista_unica

lista_com_duplicatas = [1, 2, 2, 3, 4, 4, 5, 1] print(f"Lista original:

{lista_com_duplicatas}") print(f"Lista sem duplicatas:
{remover_duplicatas(lista_com_duplicatas)}") ```

7. Soma de Dígitos:

```python def soma_digitos(numero): soma = 0 for digito in str(numero): soma

+= int(digito) return soma

print(f"Soma dos dígitos de 123: {soma_digitos(123)}") print(f"Soma dos dígitos

de 9876: {soma_digitos(9876)}") ```

8. Maior Elemento de uma Lista:

```python def maior_elemento(lista): if not lista: return None # Retorna None se

a lista estiver vazia maior = lista[0] for elemento in lista: if elemento > maior:
maior = elemento return maior

numeros = [3, 1, 4, 1, 5, 9, 2, 6] print(f"O maior elemento da lista {numeros} é:

{maior_elemento(numeros)}") ```

9. Ordenação Simples (Bubble Sort):

```python def ordenar_lista(lista): n = len(lista) for i in range(n): for j in range(0, n

- i - 1): if lista[j] > lista[j+1]: lista[j], lista[j+1] = lista[j+1], lista[j] # Troca os
elementos return lista

lista_desordenada = [64, 34, 25, 12, 22, 11, 90] print(f"Lista desordenada:
{lista_desordenada}") print(f"Lista ordenada:
{ordenar_lista(lista_desordenada)}") ```
10. Jogo da Forca Simplificado:

```python import random

def jogo_da_forca(): palavras = ["python", "programacao", "computador",

"desenvolvimento", "inteligencia"] palavra_secreta =
[Link](palavras).lower() letras_descobertas = ["_" for _ in
palavra_secreta] letras_tentadas = set() vidas = 6

print("Bem-vindo ao Jogo da Forca!")

print("_".join(letras_descobertas))

while vidas > 0 and "_" in letras_descobertas:

tentativa = input("\nDigite uma letra: ").lower()

if len(tentativa) != 1 or not [Link]():

print("Por favor, digite apenas uma letra válida.")
continue

if tentativa in letras_tentadas:
print("Você já tentou essa letra. Tente outra.")
continue

letras_tentadas.add(tentativa)

if tentativa in palavra_secreta:
print(f"Boa! A letra '{tentativa}' está na palavra.")
for i, letra in enumerate(palavra_secreta):
if letra == tentativa:
letras_descobertas[i] = letra
else:
vidas -= 1
print(f"Ops! A letra '{tentativa}' não está na palavra. Você tem
{vidas} vidas restantes.")

print(" ".join(letras_descobertas))
print(f"Letras já tentadas: {',
'.join(sorted(list(letras_tentadas)))}")

if "_" not in letras_descobertas:

print(f"\nParabéns! Você adivinhou a palavra: {palavra_secreta}")
else:
print(f"\nQue pena! Suas vidas acabaram. A palavra era:
{palavra_secreta}")
Para jogar, descomente a linha abaixo:

jogo_da_forca()
```