Ótimo!

Vou preparar uma aula introdutória de Python voltada para iniciantes, cobrindo os
fundamentos da linguagem, lógica de programação e como executar códigos no Google
Colab. A aula incluirá conceitos essenciais, exemplos práticos e exercícios para reforçar o
aprendizado.

Assim que estiver pronta, aviso você para que possa revisar o material!

Aula Introdutória de Python para

Iniciantes
1. Introdução ao Python
Python é uma linguagem de programação de alto nível, interpretada e muito popular na
atualidade. Foi criada por Guido van Rossum no início dos anos 1990 e seu nome é uma
referência ao grupo de comédia Monty Python. Python se destaca por ter uma sintaxe
simples e clara, o que a torna uma ótima escolha para iniciantes em programação. Além
disso, é extremamente versátil, sendo usada em diversas áreas como desenvolvimento
web, ciência de dados, inteligência artificial, automação de tarefas, entre outras.

Por que usar Python? Alguns motivos:

●​ Fácil de aprender: A sintaxe lembra pseudocódigo, tornando o código mais legível.

●​ Multiparadigma: Suporta programação procedural, orientada a objetos e funcional.
●​ Grande comunidade e bibliotecas: Existe uma grande quantidade de bibliotecas e
recursos disponíveis, o que facilita a realização de diversos projetos.
●​ Portabilidade: Python é multiplataforma (Windows, Linux, Mac) e pode ser
executada em diferentes ambientes.

Executando Python no Google Colab: Nesta aula, utilizaremos o Google Colab, uma
plataforma online que permite escrever e executar códigos Python diretamente do
navegador. O Colab é como um notebook Jupyter hospedado na nuvem, fornecendo um
ambiente pronto sem precisar instalar nada no seu computador. Para usar:

1.​ Acesse o site do Google Colab (colab.research.google.com) e faça login com sua
conta Google.
2.​ Crie um novo notebook (File > New notebook). Você verá uma célula de código
pronta para uso.
3.​ Escreva seu código em uma célula e clique no botão de Play (▶) à esquerda da
célula, ou use o atalho Shift+Enter para executá-la.
4.​ A saída do código aparecerá logo abaixo da célula após a execução.

Vamos testar o ambiente executando um simples comando Olá, Mundo!:

print("Olá, mundo!")
# Saída esperada: Olá, mundo!
 Dica: Em notebooks, você pode alternar entre células de texto (Markdown) para
explicações e células de código para executar Python. Experimente criar sua
própria célula de código e rodar alguma operação simples, como 2 + 3 ou
outra mensagem com print.*

2. Sintaxe Básica
Nesta seção, vamos abordar os elementos fundamentais da sintaxe Python: variáveis, tipos
de dados, operadores e como realizar entrada e saída de dados.

Variáveis e Tipos de Dados

Variáveis são espaços na memória para armazenar valores que podem ser usados pelo
programa. Em Python, você não precisa declarar o tipo da variável antecipadamente; basta
usar o operador de atribuição = para guardar um valor. Por exemplo:

x=5 # armazena o número 5 na variável x (um int)

y = 3.14 # armazena 3.14 na variável y (um float)
nome = "Ana" # armazena o texto "Ana" na variável nome (uma str)
esta_chovendo = False # armazena um valor booleano False

No exemplo acima, criamos quatro variáveis com tipos diferentes. Python é dinamicamente
tipado, ou seja, o tipo da variável é inferido a partir do valor atribuído e pode mudar se outro
valor de tipo diferente for atribuído depois.

Principais tipos de dados primitivos em Python:

●​ int (inteiros): números sem parte decimal, exemplo: -3, 0, 42.

●​ float (ponto flutuante/decimais): números com parte decimal, exemplo: 3.14, 0.0,
-7.5.
●​ str (string ou texto): sequências de caracteres, exemplo: "Olá", "123", "" (string
vazia).
●​ bool (booleano): valores lógicos Verdadeiro ou Falso, representados por True ou
False.

Você pode usar a função embutida type() para verificar o tipo de uma variável:

print(type(x)) # <class 'int'>

print(type(y)) # <class 'float'>
print(type(nome)) # <class 'str'>
print(type(esta_chovendo)) # <class 'bool'>

Operadores Matemáticos
Python suporta os operadores matemáticos básicos e alguns adicionais. Os principais
operadores aritméticos são:

●​ + (adição)
●​ - (subtração)
●​ * (multiplicação)
●​ / (divisão, resultado em ponto flutuante)
●​ // (divisão inteira, descartando o resto)
●​ % (módulo, resto da divisão inteira)
●​ ** (exponenciação, potência)

Vamos ver alguns exemplos de uso desses operadores:

a=7
b=3
print(a + b) # Adição -> 10
print(a - b) # Subtração -> 4
print(a * b) # Multiplicação -> 21
print(a / b) # Divisão -> 2.333...
print(a // b) # Divisão inteira -> 2
print(a % b) # Módulo (resto) -> 1
print(a ** b) # Exponenciação -> 343 (7 elevado à 3)

Observe que:

●​ A divisão normal a / b resulta em 2.333... (um float), enquanto a divisão inteira

a // b resulta em 2 (int), truncando o valor decimal.
●​ O operador módulo a % b fornece o resto da divisão de a por b (no caso, 1 porque
7 dividido por 3 tem resto 1).
●​ a ** b calcula 7³ (7 elevado à terceira potência), resultando em 343.

Além disso, Python segue a precedência matemática padrão. Por exemplo, multiplicações e
divisões são feitas antes de somas e subtrações. Você pode usar parênteses para deixar a
ordem de avaliação explícita e melhorar a legibilidade.

Entrada e Saída de Dados

Saída de dados: Em Python, usamos a função print() para exibir informações na tela
(saída padrão). Você pode passar múltiplos argumentos separados por vírgula que serão
impressos em sequência com espaço, ou concatenar strings usando o operador +.
Exemplo:

print("Olá, mundo!")
print("A soma de 2 + 3 é", 2 + 3)
Saída:

Olá, mundo!
A soma de 2 + 3 é 5

Entrada de dados: Para ler dados do usuário (entrada padrão), usamos a função
input(). Essa função pausa a execução do programa e espera o usuário digitar algo,
retornando o texto digitado como uma string. Podemos passar uma mensagem (prompt)
para input() para orientar o usuário. Por exemplo:

nome = input("Qual é o seu nome? ") # o usuário digita o nome e pressiona Enter
print("Olá,", nome, "! Prazer em te conhecer.")

Ao executar o código acima, o programa exibirá a pergunta e aguardará a entrada. Se o

usuário digitar Maria, a saída será:

Olá, Maria ! Prazer em te conhecer.

Perceba que input() sempre retorna uma string. Se você precisar ler um número do
usuário para realizar cálculos, deve converter a string para o tipo numérico apropriado (por
exemplo, usar int() para inteiro ou float() para decimal):

numero_str = input("Digite um número: ") # o valor retornado é uma string

numero = int(numero_str) # converte a string para int
dobro = numero * 2
print("O dobro de", numero, "é", dobro)

No exemplo acima, se o usuário digitar 4, a variável numero_str será "4" (string) e após a
conversão int(numero_str), a variável numero conterá o valor inteiro 4. Em seguida, o
programa calcula o dobro (8) e exibe na tela.

Dica: Você pode combinar as chamadas de input() e conversão em uma

única linha, por exemplo: numero = int(input("Digite um número:
")). Assim, o valor lido já será convertido para inteiro.

3. Estruturas de Controle
As estruturas de controle permitem direcionar o fluxo de execução do programa, tomando
decisões (condicionais) ou repetindo blocos de código (laços de repetição). Em Python,
blocos de código são definidos pela indentação (espaços ou tabulação no início da linha).
Geralmente usamos 4 espaços para indentar blocos.

Condicionais (if, elif, else)

Em Python, utilizamos a estrutura if para executar um bloco de código caso uma condição
seja verdadeira. Podemos usar elif (abreviação de "else if") para checar outras condições
caso a primeira seja falsa, e um else final para o caso "nenhuma das condições anteriores
foi verdadeira". A sintaxe básica é:

if condição:
# bloco executado se condição for True
elif outra_condição:
# bloco executado se condição inicial for False e outra_condição for True
else:
# bloco executado se todas as condições acima forem False

A condição dentro do if ou elif é uma expressão booleana, isto é, algo que resulta em
True ou False. Costumamos usar operadores de comparação dentro das condições:

●​ == (igualdade)
●​ != (diferente)
●​ > (maior que), < (menor que)
●​ >= (maior ou igual), <= (menor ou igual)

Também podemos conectar condições com operadores lógicos:

●​ and (e) – Verdadeiro se ambas as condições forem verdadeiras.

●​ or (ou) – Verdadeiro se pelo menos uma condição for verdadeira.
●​ not (não) – Inverte o valor booleano (True vira False e vice-versa).

Exemplo: Vamos ler um número e verificar se ele é positivo, negativo ou zero:

x = int(input("Digite um número inteiro: "))

if x > 0:
print("O número é positivo.")
elif x == 0:
print("O número é zero.")
else:
print("O número é negativo.")

Se o usuário digitar 7, a saída será O número é positivo.; se digitar 0, O número é

zero.; se digitar -3, O número é negativo..

Outro exemplo de condicional simples: verificar se um número é par ou ímpar usando o

operador módulo %:

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

if numero % 2 == 0:
print("É par!")
else:
print("É ímpar!")

Observe a importância da indentação: o que define o conjunto de instruções pertencentes a

cada bloco (if, elif ou else) é o recuo (espaços) antes das linhas de código. Por
convenção, usamos 4 espaços para cada nível de indentação.

Laços de Repetição (for e while)

Laço for: O for em Python é usado para iterar sobre uma sequência (como uma lista,
tupla, string ou range de números). A sintaxe é for variavel in sequencia:. Um
caso comum é usar a função range() para gerar uma sequência de números. Por
exemplo, range(5) gera os números 0, 1, 2, 3, 4 (iniciando do 0 e indo até 4, um antes do
5):

for i in range(5):
print(i)
# Saída:
#0
#1
#2
#3
#4

Se quisermos um intervalo diferente, podemos passar início e fim para range. Por exemplo,
range(1, 6) vai de 1 até 5:

for num in range(1, 6):

print(num, end=" ")
# Saída: 1 2 3 4 5

(Usamos end=" " no print acima apenas para imprimir os números na mesma linha,
separados por espaço.)

Também podemos iterar sobre itens de uma lista ou outros iteráveis:

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

for fruta in frutas:
print("Eu adoro", fruta)

Saída:

Eu adoro maçã
Eu adoro banana
Eu adoro uva

Laço while: O while repete um bloco de código enquanto uma condição for verdadeira. A
sintaxe é:

while condição:
# bloco executado repetidamente enquanto condição for True

É importante que algo dentro do laço eventualmente faça a condição se tornar False, caso
contrário teremos um loop infinito.

Exemplo de uso do while para contar de 1 a 5:

contador = 1
while contador <= 5:
print("Contagem:", contador)
contador += 1 # incrementa o contador em 1 a cada loop

Saída:

Contagem: 1
Contagem: 2
Contagem: 3
Contagem: 4
Contagem: 5

No código acima, iniciamos contador em 1 e, a cada iteração do laço, exibimos seu valor
e depois o incrementamos. Quando contador se torna 6, a condição contador <= 5
passa a ser falsa e o laço é encerrado.

Tanto for quanto while podem ser interrompidos prematuramente com a instrução break.
E a instrução continue pode ser usada dentro do laço para pular diretamente para a
próxima iteração, ignorando o restante do bloco atual. Exemplo rápido do uso de break:

while True:
texto = input("Digite algo (ou 'sair' para encerrar): ")
if texto == "sair":
break # sai do laço while
print("Você digitou:", texto)

O laço acima continuará solicitando que o usuário digite algo até que o texto "sair" seja
digitado, momento em que o break interrompe o loop.
 Dica: Use for quando souber antecipadamente quantas vezes o loop deve
executar (por exemplo, percorrer uma lista de 10 itens) ou estiver iterando
sobre uma coleção. Use while quando a repetição depende de uma condição
que precisa ser avaliada a cada iteração (por exemplo, continuar perguntando
algo ao usuário até ele fornecer uma resposta válida).

4. Funções e Modularização
À medida que programas ficam maiores, torna-se importante organizar o código em partes
reutilizáveis. Funções são blocos de código que realizam uma tarefa específica e podem
ser chamados (executados) quando necessário. Usar funções ajuda a modularizar o
programa, evitando repetição de código e facilitando a manutenção.

Em Python, definimos uma função usando a palavra-chave def, seguida do nome da

função e parâmetros entre parênteses. Após os dois pontos :, vem o bloco indentado com o
corpo da função. Opcionalmente, uma função pode usar a instrução return para devolver
um valor ao final. Sintaxe básica:

def nome_da_funcao(param1, param2, ...):

# corpo da função
# (faça algo com param1, param2, ...)
return valor_opcional

Exemplo 1: Função simples sem parâmetro que apenas imprime uma mensagem:

def saudacao():
print("Olá! Seja bem-vindo.")

Chamando a função:

saudacao()

Saída:

Olá! Seja bem-vindo.

Exemplo 2: Função com parâmetros e retorno de valor. Vamos criar uma função que soma
dois números:

def soma(a, b):

resultado = a + b
return resultado
Agora podemos usar (chamar) essa função sempre que precisarmos somar dois números:

x=5
y=8
print(soma(x, y)) # Chama a função soma(5, 8) e imprime o resultado -> 13
print(soma(10, 20)) # Podemos chamar com números diretamente -> 30

z = soma(3, 4)
print("O resultado da soma é", z) # Armazena o retorno em uma variável -> 7

No exemplo acima, a e b são parâmetros (variáveis locais à função que recebem os valores
passados na chamada). Dentro de soma, calculamos resultado e o devolvemos com
return. Ao chamar soma(5, 8), por exemplo, a função retorna 13, que é então impresso
pelo print.

Você pode definir quantas funções forem necessárias para estruturar melhor seu
programa. É recomendável que cada função realize uma tarefa específica (princípio da
responsabilidade única). Assim, seu código fica mais organizado e fácil de entender. Além
disso, funções evitam repetição: se você precisa executar a mesma lógica em diferentes
partes do programa, basta chamar a função em vez de duplicar código.

Nota: Python também vem com várias funções embutidas (built-in), como
print(), len(), input(), etc., e permite importar funções adicionais de
módulos (bibliotecas). Modularização pode se referir também a separar o
código em múltiplos arquivos (módulos) e importar onde necessário, mas isso
foge do escopo desta introdução.

5. Estruturas de Dados
Até agora trabalhamos com tipos primitivos (números, strings, booleanos). Python fornece
estruturas de dados integradas mais complexas para armazenar coleções de valores de
forma organizada. As principais vistas nesta introdução são listas, tuplas e dicionários.

Listas

Lista (list) é uma coleção ordenada de elementos, mutuável (ou seja, podemos alterar,
adicionar ou remover elementos). Listas em Python são definidas usando colchetes [ ],
com os elementos separados por vírgula. Por exemplo:

# Exemplo de lista de números

numeros = [10, 20, 30, 40]

# Lista de strings
frutas = ["maçã", "banana", "laranja"]

# Lista mista (contendo diferentes tipos de dados)

misto = [1, "abc", True, 3.14]

Uma lista pode estar vazia [] ou conter qualquer quantidade de itens. Podemos acessar
elementos individuais usando índices (posição do elemento na lista). Importante: o índice
em Python começa em 0. Ou seja, o primeiro elemento está no índice 0, o segundo no
índice 1, e assim por diante. Exemplos:

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

print(frutas[0]) # acessa o primeiro elemento -> "maçã"
print(frutas[2]) # acessa o terceiro elemento -> "laranja"
# print(frutas[3]) # isso causaria um erro, pois não existe índice 3 (a lista tem índices 0,1,2)

Também é possível usar índices negativos para acessar a partir do final: frutas[-1]
retorna o último item ("laranja"), frutas[-2] retorna o penúltimo ("banana"), e assim por
diante.

Algumas operações úteis em listas:

●​ Tamanho da lista: use len(lista) para obter a quantidade de elementos.

●​ Adicionar elemento: lista.append(item) adiciona item ao final da lista.
●​ Remover elemento: lista.remove(item) remove a primeira ocorrência de item
na lista; ou lista.pop(indice) remove o elemento no índice especificado (ou o
último, se nenhum índice for dado).
●​ Percorrer lista: você pode usar um laço for para iterar sobre os elementos da lista
facilmente (como vimos acima).

Exemplos de manipulação de lista:

nums = [5, 2, 8]
print(len(nums)) # tamanho -> 3

nums.append(10)
print(nums) # agora nums -> [5, 2, 8, 10]

nums.remove(2)
print(nums) # agora nums -> [5, 8, 10]

print(nums[1]) # imprime o elemento no índice 1 -> 8

nums[1] = 20
print(nums) # modificando o valor do índice 1, agora nums -> [5, 20, 10]

Tuplas

Tupla (tuple) é muito semelhante a uma lista, porém imutável: depois de criada, seus
elementos não podem ser alterados, adicionados ou removidos. Tuplas são definidas
usando parênteses ( ) em vez de colchetes, ou mesmo sem nada, apenas separando os
valores por vírgulas. Exemplos:

coord = (10, 20) # tupla com dois números

cores = ("vermelho", "azul", "verde") # tupla de strings
valores = 1, 2, 3 # tupla definida sem parênteses explicitamente (também é válida)
unico = (42,) # tupla com um único elemento (note a vírgula)
vazia = () # tupla vazia

O acesso a elementos em tuplas é igual ao de listas (usando índices, começando em 0). A

principal diferença é que você não pode modificar a tupla após criada:

print(coord[0]) # acessa o primeiro valor -> 10

# coord[0] = 15 # isto causaria um erro, tuplas são imutáveis

Tuplas são úteis para representar coleções de itens que não devem mudar, ou para
devolver múltiplos valores em funções. Por exemplo, uma função pode retornar uma tupla
contendo dois resultados.

Dicionários

Dicionário (dict) é uma estrutura que armazena pares de chave: valor. Em vez de
acessar elementos por índice numérico (como nas listas/tuplas), acessamos por meio de
sua chave. Pense em um dicionário real: você procura por uma palavra (chave) para
encontrar seu significado (valor). Em Python, definimos dicionários com chaves { },
utilizando a sintaxe "chave": valor para cada par, separados por vírgulas:

aluno = {
"nome": "João",
"idade": 21,
"curso": "Engenharia"
}

No exemplo acima, temos um dicionário com três chaves: "nome", "idade" e "curso",
cada uma associada a um valor. Podemos acessar cada valor referenciando sua chave:

print(aluno["nome"]) # -> João

print(aluno["idade"]) # -> 21

Também podemos adicionar ou modificar entradas no dicionário:

aluno["idade"] = 22 # atualiza o valor da chave "idade"

aluno["universidade"] = "UFBA" # adiciona uma nova chave "universidade" com um valor
print(aluno)
# Saída: {'nome': 'João', 'idade': 22, 'curso': 'Engenharia', 'universidade': 'UFBA'}

Algumas observações sobre dicionários:

●​ As chaves geralmente são strings, mas podem ser de outros tipos imutáveis
(números, tuplas). Os valores podem ser de qualquer tipo.
●​ Para verificar a existência de uma chave: use o operador in (por exemplo, "nome"
in aluno retorna True se a chave "nome" existir no dicionário).
●​ Para remover um elemento: utilize del aluno["curso"] para remover a chave
"curso" e seu valor associado.
●​ Para iterar no dicionário: você pode usar um laço for para percorrer as chaves ou
valores. Ex: for chave in aluno: print(chave, aluno[chave]) imprimirá
cada par chave-valor.

Dicionários são muito úteis para representar estruturas mais complexas de dados, como
registros (ex: informações de uma pessoa), resultados de processamento, etc., onde
precisamos de uma associação nomeada a valores.

6. Exercícios Práticos
Agora é hora de praticar! Tente resolver os seguintes desafios usando o que aprendemos.
Você pode criar células de código no Colab abaixo de cada enunciado para testar suas
soluções.

1.​ Soma de dois números: Escreva um programa que solicite dois números ao
usuário (usando input), calcule a soma desses números e exiba o resultado com
print.
2.​ Par ou ímpar?: Peça ao usuário um número inteiro e informe se ele é par ou ímpar.
(Dica: use o operador % e uma estrutura condicional.)
3.​ Contagem com loop: Peça ao usuário um número inteiro positivo N e imprima todos
os números de 1 até N utilizando um laço de repetição (for ou while).
4.​ Função soma3: Crie uma função chamada soma3 que receba três números como
parâmetros e retorne a soma deles. Demonstre o uso da função imprimindo o
resultado para diferentes conjuntos de três números.
5.​ Maior elemento da lista: Crie uma lista com pelo menos 5 números inteiros e,
usando um laço de repetição, encontre o maior número nessa lista. Imprima o
resultado. (Não vale usar funções prontas como max() — faça a lógica
manualmente!)
6.​ Dicionário de aluno: Crie um dicionário para armazenar informações de um aluno,
contendo chaves como nome, idade e curso. Depois, imprima frases exibindo
cada uma dessas informações, por exemplo: "Nome do aluno: ...", "Idade do aluno:
...", etc.

Resolva cada exercício e teste seu código no Colab. Esses exercícios vão ajudar a fixar os
conceitos e dar mais prática na programação em Python. Bons estudos!