Curso Básico de Python: Saia do Zero em 10 Aulas Grátis

Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.

Introdução

Se você quer aprender a programar e não sabe por onde começar, este Curso Básico de Python foi feito para você. São 10 aulas gratuitas que levam você do zero absoluto até buscar dados reais da internet com poucas linhas de código, sempre com exemplos do dia a dia de uma empresa: faturamento, custos, vendas e cadastro de clientes.

Para sair do zero, você só precisa de duas instalações, o Python e o VS Code, e de alguns fundamentos que se encaixam como peças: variáveis, textos, listas, condicionais, dicionários, repetições com for, funções e tuplas. Na última aula, você junta tudo isso usando bibliotecas como os e requests. Se quiser uma visão geral antes de começar, confira o nosso guia de Python para iniciantes e o mapa para aprender Python do zero.

Cada aula traz código pronto para copiar, o resultado esperado e exercícios para praticar. A promessa é simples: ao final deste curso de Python gratuito, você vai entender o que está escrevendo e vai conseguir criar seus próprios programas.

Para fazer o download do(s) arquivo(s) utilizados na aula, preencha com o seu e-mail:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

Aula 0: Instale o Python e o VS Code e rode seu primeiro código

Nesta primeira aula você prepara o ambiente: instala o Python, instala o editor de código e roda seu primeiro programa. É um passo que se faz uma vez só, então vale seguir com calma.

Descubra por que Python é a melhor porta de entrada na programação

Python é uma linguagem de programação criada para ser simples de ler e de escrever. O código lembra frases em inglês, o que tira boa parte do medo de quem está começando. Ao mesmo tempo, é uma linguagem profissional: roda em Windows, macOS e Linux e é usada por empresas de todos os tamanhos, de startups a gigantes como o Instagram.

Mesmo que você não queira virar programador, aprender a programar muda sua rotina de trabalho. Tarefas repetitivas viram scripts que rodam sozinhos, bases de dados enormes são analisadas em segundos e problemas específicos ganham soluções sob medida, sem depender das limitações de uma ferramenta pronta.

Instale o Python no seu computador

O Python é gratuito e deve ser baixado no site oficial, em python.org/downloads. A série atual é a 3.14, mas não se preocupe com o número exato: tudo o que você vai ver neste curso funciona em qualquer versão recente do Python 3.

O jeito de instalar muda um pouco conforme o sistema operacional. Siga o passo correspondente ao seu computador.

No Windows: use o Python Install Manager

Desde o Python 3.14, o caminho oficial no Windows é o Python Install Manager, uma ferramenta que instala o Python, cuida das atualizações e permite ter mais de uma versão no mesmo computador. O instalador tradicional deixará de ser lançado a partir do Python 3.16, então vale começar já pelo caminho novo.

1. Na página de downloads do Python, baixe o Python Install Manager. Se preferir, procure por "Python Install Manager" na Microsoft Store.
2. Execute a instalação. Na primeira vez que for usado, ele faz algumas perguntas de configuração, e você pode aceitar as sugestões.
3. Se nenhuma versão do Python tiver sido instalada automaticamente, abra o terminal (PowerShell ou Prompt de Comando) e rode py install 3.14.
4. A partir daí, o comando py abre o Python no terminal.

Os detalhes de cada opção estão na documentação oficial do Python para Windows.

No Windows: use o instalador clássico marcando Add python.exe to PATH

Se preferir o instalador tradicional, ele ainda está disponível e funciona muito bem. O cuidado principal é marcar a opção Add python.exe to PATH logo na primeira tela. É ela que permite que o terminal e o VS Code encontrem o Python sem nenhuma configuração extra.

Depois, clique em Install Now e aguarde a mensagem de instalação concluída.

Instale no macOS e no Linux

No macOS, baixe o instalador em python.org/downloads e siga as telas, como em qualquer outro programa. No Linux, o Python 3 costuma vir instalado; se não vier, use o gerenciador de pacotes da sua distribuição (no Ubuntu, por exemplo, sudo apt install python3). Nesses dois sistemas, o comando no terminal normalmente é python3 em vez de python.

Confirme que o Python foi instalado

Para ter certeza de que deu tudo certo, abra o terminal e digite:

python --version

No Windows com o Install Manager, você também pode usar py --version; no macOS e no Linux, python3 --version. Se aparecer algo como Python 3.14.7, está tudo pronto.

Se o terminal disser que não reconhece o comando, feche e abra o terminal de novo. No Windows, se digitar python abrir a Microsoft Store, use o comando py ou desative os aliases de execução do Python nas configurações do Windows. Se nada disso resolver, reinstale conferindo a opção de PATH.

Instale o VS Code e deixe o editor pronto

Com o Python instalado, você precisa de um lugar para escrever o código. Neste curso usamos o VS Code, um editor gratuito, leve e disponível para Windows, macOS e Linux. Baixe no site oficial, em code.visualstudio.com/download, e siga o instalador.

A instalação é simples, mas, se quiser, temos um passo a passo detalhado de instalação do VS Code. E se tiver curiosidade sobre outros editores de código para Python, também comparamos as opções.

Adicione as extensões Python e Dracula

Extensões são complementos que deixam o VS Code mais inteligente. Para instalar uma, clique no ícone de extensões na barra lateral esquerda.

A primeira, e indispensável, é a Python, publicada pela Microsoft. Ela faz o VS Code reconhecer seu código, colore a sintaxe, sugere comandos enquanto você digita e aponta erros antes mesmo de você rodar o programa.

A segunda é opcional: o Dracula é um tema de cores que deixa o código mais agradável de ler. Se preferir outro tema, sem problema, isso não muda nada no funcionamento.

Com as extensões instaladas, clique no ícone Explorer na barra lateral para voltar à área de arquivos.

Crie sua pasta e seu primeiro arquivo .py

Crie uma pasta no seu computador para guardar os códigos do curso, por exemplo, uma pasta chamada Curso Python na área de trabalho. Depois, no VS Code, clique em File, em Open Folder e selecione essa pasta.

A pasta começa vazia. Clique no ícone New File e crie um arquivo chamado codigo.py.

O arquivo aparece na lista da pasta, pronto para receber código.

A extensão .py avisa ao VS Code que aquele é um arquivo Python. Repare que, no canto inferior direito, o editor mostra a versão do Python que vai executar o código.

Se nenhuma versão aparecer, reinicie o VS Code. Se ainda assim não aparecer, clique nesse aviso e selecione manualmente o Python instalado no seu computador.

Entenda comandos, funções, textos e números

Antes de escrever a primeira linha, vale conhecer três ideias que vão aparecer o tempo todo:

• Comandos são as instruções que você dá ao computador. O Python executa uma linha por vez, de cima para baixo.
• Funções são comandos prontos que executam uma ação. Elas sempre têm parênteses depois do nome, como print(), e o que vai dentro dos parênteses é a informação de que a função precisa para trabalhar.
• Textos e números são escritos de formas diferentes. Texto sempre fica entre aspas, simples ou duplas, como "texto" ou 'texto'. Número vai sem aspas, e o separador decimal é o ponto, como 42 ou 3.14.

Exiba seu primeiro resultado com print()

A primeira função que você vai usar é o print(), que exibe informações no terminal. Escreva no arquivo codigo.py:

print("Meu primeiro programa em Python")

Para executar, clique no botão Run, o triângulo no canto superior direito do VS Code.

A mensagem aparece no terminal, na parte de baixo da tela:

Outra forma de rodar é pelo próprio terminal, dentro da pasta do arquivo, com o comando python codigo.py (ou py codigo.py e python3 codigo.py, conforme o seu sistema).

O print() também mostra números, e nesse caso não precisa de aspas:

print("Meu primeiro programa em Python")
print(30)

Repare que as mensagens saíram na mesma ordem em que foram escritas. Essa execução de cima para baixo é uma das bases da lógica de programação: mudar a ordem das linhas muda o resultado.

Um alerta para os primeiros dias: um parêntese ou uma aspa esquecida já basta para o Python acusar erro. Isso acontece com todo mundo, e ler a mensagem de erro com calma costuma mostrar exatamente onde está o problema.

Voltar ao índice do curso

Aula 1: Guarde valores com variáveis em Python e faça cálculos

Com o ambiente pronto, é hora de fazer o Python trabalhar com números. Nesta aula você aprende variáveis em Python, os tipos de dados mais usados e as operações matemáticas, a base de praticamente todo programa.

Mostre textos e cálculos juntos no print()

Crie um arquivo chamado variaveis.py na mesma pasta da aula anterior.

O print() aceita mais de uma informação ao mesmo tempo, basta separá-las por vírgulas. Ele exibe tudo na mesma linha, com um espaço entre cada item. Imagine uma empresa que faturou 1000 e teve 600 de custo:

print("Faturamento:", 1000)
print("Custo:", 600)

Visualmente, daria no mesmo escrever print("Faturamento: 1000"). A diferença aparece quando você precisa calcular. Compare:

print("Lucro:", 1000 - 600)
print("Lucro: 1000 - 600")

No primeiro comando, o Python fez a conta, porque os números estão fora das aspas. No segundo, tudo está dentro das aspas, então ele apenas repetiu o texto. Organizando as três informações, cada uma com seu texto explicativo e seu valor:

print("Faturamento:", 1000)
print("Custo:", 600)
print("Lucro:", 1000 - 600)

Funciona, mas tem um problema: os valores estão escritos direto no código. É aqui que entram as variáveis.

Crie variáveis em Python para mudar valores em um só lugar

Suponha que o faturamento passou de 1000 para 1200. Com os números espalhados pelo código, você teria que procurar e trocar cada ocorrência. Em um script de três linhas tudo bem, mas em um programa real isso vira fonte de erro.

Uma variável é como uma caixinha com nome, onde você guarda um valor para usar depois. Você cria a variável escolhendo um nome e atribuindo um valor com o sinal de igual (=):

faturamento = 1000
custo = 600
lucro = faturamento - custo

print("Faturamento:", faturamento)
print("Custo:", custo)
print("Lucro:", lucro)

Resultado:

Faturamento: 1000
Custo: 600
Lucro: 400

Repare que o nome da variável não fica entre aspas: ele não é um texto, é a caixinha que guarda o valor. Agora, para mudar o faturamento, você altera um único lugar e o lucro é recalculado sozinho:

faturamento = 1200
custo = 600
lucro = faturamento - custo

print("Faturamento:", faturamento)
print("Custo:", custo)
print("Lucro:", lucro)

A ordem das linhas continua importando. Se você tentar usar uma variável antes de criá-la, o Python não sabe do que se trata:

custo = 600
lucro = faturamento - custo

print("Lucro:", lucro)

faturamento = 1200

Esse é o NameError, um dos erros mais comuns no Python. A mensagem diz que o nome faturamento não está definido, porque, na linha em que ele foi usado, a variável ainda não existia. A solução é sempre criar a variável antes de usá-la.

Atualize o valor de uma variável

Variáveis têm esse nome porque o valor pode variar ao longo do código. Imagine que a empresa fez mais 500 em vendas:

faturamento = 1200
custo = 600
novas_vendas = 500

faturamento = faturamento + novas_vendas
lucro = faturamento - custo

print("Faturamento:", faturamento)
print("Custo:", custo)
print("Lucro:", lucro)

A linha faturamento = faturamento + novas_vendas se lê da direita para a esquerda: o Python pega o valor atual de faturamento (1200), soma 500 e guarda o resultado (1700) de volta na mesma variável. Todo cálculo feito depois dessa linha já usa o valor novo.

Esse tipo de atualização é tão comum que existe um atalho, o +=:

faturamento += novas_vendas  # mesmo efeito de faturamento = faturamento + novas_vendas

Também existem -=, *= e /=, que funcionam da mesma forma. Guarde o +=, porque ele vai ser muito útil na Aula 6.

Dê nomes claros às variáveis

Nomes bons fazem o código se explicar sozinho, para você e para quem ler depois. Algumas regras e boas práticas:

• Use nomes que digam o que a variável guarda, como faturamento ou margem_lucro, e evite nomes genéricos como a ou x.
• Escreva em letras minúsculas e separe as palavras com underline (_), o padrão conhecido como snake_case.
• Não use espaços, não comece o nome com número e evite acentos, que funcionam, mas costumam dar dor de cabeça.
• O Python diferencia maiúsculas de minúsculas, então Lucro e lucro são variáveis diferentes.
• Não use palavras reservadas do Python, como if, for ou True.

Para mais exemplos, confira as boas práticas para nomear variáveis.

Conheça os tipos de dados int, float, str e bool

Toda variável guarda um valor de algum tipo, e o Python define esse tipo automaticamente a partir do valor atribuído. Os quatro mais usados são:

Dois detalhes pegam muita gente: o separador decimal é o ponto, não a vírgula, e True e False são escritos com a primeira letra maiúscula. Para descobrir o tipo de qualquer valor, use a função type():

faturamento = 1200
custo = 750.32
email = "emailqualquer@gmail.com"
teve_lucro = True

print(type(faturamento))
print(type(custo))
print(type(email))
print(type(teve_lucro))

Resultado:

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

Existem outros tipos, como listas, dicionários e tuplas, que você vai conhecer nas próximas aulas.

Explique seu código com comentários

Tudo o que vem depois de # em uma linha é um comentário: o Python ignora e não executa. Comentários servem para explicar o que o código faz, tanto para outras pessoas quanto para você mesmo daqui a alguns meses.

# Este é um comentário
faturamento = 1000  # Variável que armazena o faturamento

print(faturamento)

Uma dica: use comentários para explicar o motivo de uma decisão, e não para repetir o que o código já diz claramente.

Faça operações matemáticas no Python

O Python funciona como uma calculadora muito poderosa, e você pode calcular tanto com números digitados direto quanto com variáveis. Estes são os operadores básicos do Python:

Some, subtraia, multiplique e divida

A adição e a subtração funcionam como na matemática da escola:

faturamento = 1500
novas_vendas = 500

faturamento = faturamento + novas_vendas

print("Faturamento:", faturamento)

faturamento = 2200
custo = 550.30
lucro = faturamento - custo

print("Lucro:", lucro)

A multiplicação usa asterisco (*) e a divisão usa barra (/). Um exemplo de divisão é a margem de lucro, que é o lucro dividido pelo faturamento:

faturamento = 1000
custo = 500
lucro = faturamento - custo

margem_lucro = lucro / faturamento

print("Margem de Lucro:", margem_lucro)

Repare que a divisão com / sempre devolve um float, mesmo quando a conta é exata: 1000 / 500 resulta em 2.0.

Calcule porcentagens

No Python, o símbolo % não calcula porcentagem. Para trabalhar com percentuais, use o número decimal equivalente: 15% vira 0.15, 10% vira 0.1, e assim por diante.

faturamento = 1000
imposto = 0.15 * faturamento

print("Imposto:", imposto)

Resultado:

Imposto: 150.0

O resultado vem como 150.0 porque multiplicar por um número decimal gera um float. A mesma lógica vale para aumentos: para somar 10% a um valor, multiplique por 1.1.

Use o resto da divisão (%) e a divisão inteira (//)

O % é o operador módulo, que devolve o resto da divisão. Dividindo 10 por 3, o resultado inteiro é 3 e sobra 1:

print(10 % 3)

Já o // faz a divisão inteira, devolvendo só a parte inteira do resultado: 10 // 3 dá 3. Juntos, os dois resolvem um problema clássico. Um contrato de 310 meses equivale a quantos anos e meses?

anos = 310 // 12
meses = 310 % 12

print(anos, "anos")
print(meses, "meses")

O resultado é 25 anos e 10 meses. Outra forma de chegar aos anos seria int(310 / 12), mas o // é mais direto e deixa a intenção do código clara.

Respeite a ordem das operações

O Python segue a mesma ordem da matemática: primeiro potência, depois multiplicação e divisão, e por último soma e subtração. Veja a diferença que os parênteses fazem:

preco = 100
desconto = 20
quantidade = 3

total_errado = preco - desconto * quantidade
total_certo = (preco - desconto) * quantidade

print(total_errado)
print(total_certo)

Resultado:

40
240

No primeiro cálculo, o Python multiplicou o desconto pela quantidade antes de subtrair. Na dúvida, use parênteses: eles deixam a conta explícita e evitam erros difíceis de perceber.

Nesta aula você aprendeu a guardar valores em variáveis, conheceu os tipos de dados e fez cálculos com os operadores. Na próxima, é a vez dos textos.

Voltar ao índice do curso

Aula 2: Manipule textos e strings em Python

Nomes de clientes, e-mails, mensagens na tela: boa parte das informações de um sistema é texto. Nesta aula você aprende a juntar, limpar, recortar e formatar textos, que no Python se chamam strings.

Junte textos e variáveis em uma mensagem

Mostrar um resultado como "O lucro foi de 400" exige juntar um texto fixo com o valor de uma variável. Existem três formas de fazer isso, e vale conhecer todas, porque você vai encontrá-las em códigos de outras pessoas.

Separe valores com vírgula no print()

faturamento = 1000
custo = 600
lucro = faturamento - custo

print("O lucro foi de", lucro, "e o faturamento foi de", faturamento)

Resultado:

O lucro foi de 400 e o faturamento foi de 1000

O print() coloca sozinho um espaço entre cada item separado por vírgula. Por isso não é preciso deixar espaços dentro das aspas: se deixar, o texto sai com espaços duplos. O ponto fraco desse método é que ele só funciona dentro do print(), então não dá para guardar a mensagem pronta em uma variável.

Concatene com + e str()

O sinal de + também junta textos, o que se chama concatenação. O detalhe é que ele só junta texto com texto. Tentar somar uma string com um número gera erro:

texto = "O lucro foi de " + lucro

Resultado:

TypeError: can only concatenate str (not "int") to str

A solução é converter o número em texto com a função str():

texto = "O lucro foi de " + str(lucro) + " e o faturamento foi de " + str(faturamento)
print(texto)

Resultado:

O lucro foi de 400 e o faturamento foi de 1000

Aqui os espaços dentro das aspas são obrigatórios, porque o + gruda os pedaços exatamente como eles estão.

Use f-strings, o jeito mais prático

A forma mais prática e mais usada hoje é a f-string. Coloque a letra f antes das aspas e escreva as variáveis entre chaves, no ponto do texto onde elas devem aparecer:

texto = f"O lucro foi de {lucro} e o faturamento foi de {faturamento}."
print(texto)

Resultado:

O lucro foi de 400 e o faturamento foi de 1000.

Sem conversão, sem se preocupar com espaços e muito fácil de ler. Dentro das chaves dá até para fazer contas, como {faturamento - custo}. A partir daqui, o curso usa f-strings em todos os exemplos, e você pode conhecer todas as formatações com f-strings quando quiser ir além.

Padronize textos com lower, upper, capitalize, title e strip

Pense em um formulário de cadastro: uma pessoa digita o e-mail todo em maiúsculas, outra deixa espaços sobrando no fim. Os métodos de string resolvem isso. Um método é uma função que pertence a um tipo de dado, e se usa com um ponto depois da variável.

Veja como limpar um e-mail digitado de qualquer jeito:

email = "  EMAIL_FALSO@GMAIL.COM  "
email = email.lower()
email = email.strip()

print(email)

Resultado:

email_falso@gmail.com

Repare que foi preciso reatribuir o resultado à variável, com email = email.lower(). Strings são imutáveis: os métodos não alteram o texto original, eles devolvem um texto novo. Também dá para encadear os dois métodos em uma linha só: email = email.lower().strip().

Para nomes, atenção à escolha do método. O capitalize() deixa maiúscula apenas a primeira letra do texto inteiro, então o sobrenome continua minúsculo. Para nomes completos, o certo é o title():

nome = "joão lira"

print(nome.capitalize())
print(nome.title())

Resultado:

João lira
João Lira

Encontre posições e fatie strings

Cada caractere de uma string ocupa uma posição. Saber trabalhar com essas posições permite extrair só a parte do texto que interessa, como o servidor de um e-mail ou o primeiro nome de uma pessoa.

Meça o tamanho com len()

A função len() conta quantos caracteres a string tem, incluindo letras, números, símbolos e espaços:

email = "email_falso@gmail.com"
print(len(email))

Resultado:

21

Localize trechos com find()

O método .find() devolve a posição de um caractere ou trecho dentro do texto:

posicao = email.find("@")
print(posicao)

Resultado:

11

Três observações importantes: as posições começam a contar do zero; se o trecho aparecer mais de uma vez, o find() devolve a primeira ocorrência; e, se o trecho não existir, o resultado é -1.

Recorte partes do texto com fatiamento

Com a posição em mãos, você recorta o texto usando colchetes. Um número sozinho pega um caractere. Para pegar um intervalo, informe a posição inicial e a final separadas por dois-pontos, lembrando que a posição final não entra no recorte:

email = "email_falso@gmail.com"

print(email[0])      # e
print(email[11])     # @
print(email[12:17])  # gmail
print(email[:11])    # email_falso
print(email[12:])    # gmail.com
print(email[-3:])    # com

Deixar o início em branco significa "desde o começo", e deixar o final em branco significa "até o fim". Números negativos contam de trás para frente, então -3 é o terceiro caractere a partir do final.

Substitua trechos com replace()

Para trocar um trecho por outro, use o .replace(), que funciona como o Localizar e Substituir do Word (Ctrl+U):

email = "email_falso@gmail.com"
novo_email = email.replace("gmail.com", "yahoo.com.br")

print(novo_email)

Resultado:

email_falso@yahoo.com.br

Por padrão, todas as ocorrências são trocadas. Para limitar, passe um terceiro argumento com a quantidade de substituições:

texto = "python, python, python"
print(texto.replace("python", "Python", 1))

Resultado:

Python, python, python

Um uso muito comum é substituir um trecho por nada (""), o que na prática apaga esse trecho. Você vai usar esse recurso na Aula 3 para limpar valores digitados pelo usuário.

Formate números com f-strings

Números grandes ficam difíceis de ler. No código, você pode separar os milhares com underline, que o Python ignora: 1_000_000 é o mesmo que 1000000. Não use pontos para isso, porque o ponto é o separador decimal. Já na hora de exibir o número, a formatação é feita dentro da f-string, depois de dois-pontos.

Mostre casas decimais, milhar e percentual

faturamento = 1_000_000
custo = 600_000
lucro = faturamento - custo
margem = lucro / faturamento

print(f"Lucro: R${lucro:,.2f}")
print(f"Faturamento: R${faturamento:,.2f}")
print(f"Margem: {margem:.0%}")

Resultado:

Lucro: R$400,000.00
Faturamento: R$1,000,000.00
Margem: 40%

Lendo os códigos de formatação:

• A vírgula (,) coloca o separador de milhar.
• O .2f mostra duas casas decimais, e o f indica que o número é tratado como decimal.
• O .0% multiplica o valor por 100, acrescenta o símbolo de porcentagem e mostra zero casas decimais. Com .1%, a margem sairia como 40.0%.

Exiba valores no padrão brasileiro

Repare que o resultado anterior saiu no padrão americano, com vírgula no milhar e ponto no decimal. Para exibir no formato brasileiro, um truque simples é formatar com underline no milhar e depois trocar os símbolos:

lucro = 400000

texto = f"{lucro:_.2f}"
texto = texto.replace(".", ",").replace("_", ".")

print(f"Lucro: R$ {texto}")

Resultado:

Lucro: R$ 400.000,00

Primeiro o número vira 400_000.00; depois, o ponto decimal vira vírgula e os underlines viram pontos. Veja outras opções na aula sobre formatação numérica no padrão brasileiro.

Pratique com 3 exercícios de Python sobre strings

Hora de praticar. Tente resolver cada exercício sozinho antes de olhar a solução. Não precisa chegar a um código idêntico: o importante é que a lógica faça sentido e o resultado esteja certo.

Exercício 1: extraia o servidor do e-mail e o primeiro nome

Com as variáveis abaixo, faça o Python descobrir o servidor do e-mail (tudo o que vem depois do @) e o primeiro nome do usuário, com a inicial maiúscula.

nome = "joão paulo lira"
email = "emailfalsodolira@gmail.com"

Solução: para o servidor, encontre a posição do @ e pegue tudo a partir da posição seguinte. Para o primeiro nome, encontre o primeiro espaço e pegue tudo o que vem antes dele.

nome = "joão paulo lira"
email = "emailfalsodolira@gmail.com"

# Servidor do e-mail
posicao_arroba = email.find("@")
servidor = email[posicao_arroba + 1:]
print(servidor)

# Primeiro nome
posicao_espaco = nome.find(" ")
primeiro_nome = nome[:posicao_espaco].capitalize()
print(primeiro_nome)

Resultado:

gmail.com
João

Aqui o capitalize() é a escolha certa, porque o recorte tem uma palavra só.

Exercício 2: monte a mensagem de cadastro

Usando as mesmas variáveis, monte e exiba a mensagem: Usuário João foi cadastrado com sucesso no e-mail emailfalsodolira@gmail.com.

Solução: reaproveite a lógica do primeiro nome e use uma f-string para montar a frase.

nome = "joão paulo lira"
email = "emailfalsodolira@gmail.com"

posicao_espaco = nome.find(" ")
primeiro_nome = nome[:posicao_espaco].capitalize()

mensagem = f"Usuário {primeiro_nome} foi cadastrado com sucesso no e-mail {email}."
print(mensagem)

Resultado:

Usuário João foi cadastrado com sucesso no e-mail emailfalsodolira@gmail.com.

Exercício 3: gere um resumo financeiro formatado

Uma loja faturou R$ 152.340,50 no mês e teve R$ 98.720,30 de custo. Exiba um resumo com faturamento, custo e lucro no padrão brasileiro e a margem de lucro com uma casa decimal.

Solução: calcule lucro e margem, formate cada valor com o truque do padrão brasileiro e exiba com f-strings.

faturamento = 152340.50
custo = 98720.30
lucro = faturamento - custo
margem = lucro / faturamento

faturamento_br = f"{faturamento:_.2f}".replace(".", ",").replace("_", ".")
custo_br = f"{custo:_.2f}".replace(".", ",").replace("_", ".")
lucro_br = f"{lucro:_.2f}".replace(".", ",").replace("_", ".")

print(f"Faturamento: R$ {faturamento_br}")
print(f"Custo: R$ {custo_br}")
print(f"Lucro: R$ {lucro_br}")
print(f"Margem: {margem:.1%}")

Resultado:

Faturamento: R$ 152.340,50
Custo: R$ 98.720,30
Lucro: R$ 53.620,20
Margem: 35.2%

Percebeu que a mesma linha de formatação se repetiu três vezes? Na Aula 7 você vai aprender a transformar esse tipo de repetição em uma função.

Nesta aula você aprendeu a juntar, padronizar, recortar e formatar textos. Na próxima, o programa começa a receber dados do usuário.

Voltar ao índice do curso

Python Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agora

Aula 3: Receba dados com input() e organize tudo em listas

Até aqui, todos os valores estavam escritos no código. Nesta aula, o programa passa a conversar com o usuário usando o input(), e você aprende a organizar vários valores de uma vez com listas.

Peça informações ao usuário com input()

O input() pausa o programa, espera o usuário digitar algo e apertar Enter, e devolve o que foi digitado. O texto entre parênteses é a mensagem que orienta quem vai digitar. Crie um arquivo input.py e teste:

faturamento = input("Preencha com o faturamento (apenas números): ")
print(faturamento)

Resultado:

Preencha com o faturamento (apenas números): 20000
20000

Parece simples, mas há uma pegadinha importante: tudo o que vem do input() é texto, mesmo que a pessoa digite só números.

Converta e trate os inputs antes de calcular

Como o valor chega como string, qualquer conta com ele exige um cuidado extra. Estes são os três pontos que você precisa dominar.

Transforme texto em número com int() e float()

Para calcular com o valor digitado, converta o texto em número. Use int() para números inteiros e float() para números que podem ter casas decimais:

faturamento = input("Preencha com o faturamento (apenas números): ")
faturamento = float(faturamento)

custo = 600
lucro = faturamento - custo

print(lucro)

Resultado:

Preencha com o faturamento (apenas números): 20000
19400.0

O .0 aparece porque o faturamento virou float. Para valores em dinheiro, prefira o float(), porque o int() gera erro se o usuário digitar casas decimais, como 20000.50.

Limpe valores digitados como R$ 20.000,00

Nem sempre o usuário segue a instrução. Se alguém digitar R$ 20.000,00, o float() quebra, porque não entende o R$, o espaço, o ponto de milhar nem a vírgula decimal. A solução é limpar o texto antes de converter, com replace() e strip(), na ordem certa:

faturamento = input("Preencha com o faturamento: ")   # usuário digita R$ 20.000,00

faturamento = faturamento.replace("R$", "").strip()   # "20.000,00"
faturamento = faturamento.replace(".", "")            # "20000,00"
faturamento = faturamento.replace(",", ".")           # "20000.00"
faturamento = float(faturamento)

print(faturamento)

Resultado:

20000.0

A ordem faz toda a diferença. Se você trocar a vírgula por ponto antes de remover o ponto de milhar, o texto vira 20.000.00, com dois pontos, e o float() continua dando erro. Essa limpeza cobre o formato brasileiro mais comum; validar qualquer coisa que o usuário possa digitar exige verificações mais completas, que vêm com a prática.

Evite juntar textos quando queria somar

Outra consequência de o input() devolver texto aparece na hora de somar:

vendas_dia1 = input("Vendas Dia 1: ")   # usuário digita 15000
vendas_dia2 = input("Vendas Dia 2: ")   # usuário digita 12000

print(vendas_dia1 + vendas_dia2)

Resultado:

1500012000

Como são dois textos, o + fez uma concatenação, igual à que você viu na Aula 2. Para evitar isso, converta o valor já na mesma linha do input():

vendas_dia1 = float(input("Vendas Dia 1: "))
vendas_dia2 = float(input("Vendas Dia 2: "))

total_vendas = vendas_dia1 + vendas_dia2
print(total_vendas)

Resultado:

27000.0

Crie listas e acesse itens pela posição

Uma lista guarda vários valores em uma única variável. Os itens ficam entre colchetes, separados por vírgulas, e podem ser de qualquer tipo. Assim como os caracteres de uma string, cada item tem uma posição, que começa em zero.

lista_vendas = [100, 50, 1000, 800, 35]

print(len(lista_vendas))  # 5
print(lista_vendas[0])    # 100
print(lista_vendas[1])    # 50
print(lista_vendas[-1])   # 35
print(lista_vendas[-2])   # 800

O len() conta os itens, os colchetes acessam um item pela posição e os índices negativos contam de trás para frente. O fatiamento também funciona igual ao das strings:

print(lista_vendas[1:4])  # [50, 1000, 800]
print(lista_vendas[:2])   # [100, 50]
print(lista_vendas[2:])   # [1000, 800, 35]

Se você tentar acessar uma posição que não existe, como lista_vendas[10], o Python mostra um IndexError. Para ver tudo o que dá para fazer com essa estrutura, confira o nosso guia completo de listas no Python.

Calcule soma, média, maior e menor valor

Com listas de números, o Python já traz funções prontas para os cálculos mais comuns:

lista_vendas = [100, 50, 1000, 800, 35]

total_vendas = sum(lista_vendas)
quantidade = len(lista_vendas)
media_vendas = total_vendas / quantidade

print(f"Total: {total_vendas}")
print(f"Maior venda: {max(lista_vendas)}")
print(f"Menor venda: {min(lista_vendas)}")
print(f"Média: {media_vendas}")

Resultado:

Total: 1985
Maior venda: 1000
Menor venda: 35
Média: 397.0

Não existe uma função embutida só para média, por isso a conta é o total dividido pela quantidade. Guardar cada passo em uma variável com nome claro deixa o código fácil de conferir. Na Aula 9 você vai ver que o módulo statistics, que já vem com o Python, tem a função mean(), mas fazer a conta na mão agora ajuda a entender o que está acontecendo.

Encontre, edite e remova itens

Listas são mutáveis: você pode alterar, incluir e excluir itens depois que elas são criadas. Veja como localizar e modificar o que já está lá.

Verifique se um item existe com in e index()

Para saber se um item está na lista, use a palavra in, que devolve True ou False. Para descobrir a posição do item, use o método .index():

lista_produtos = ["iphone", "ipad", "apple watch", "airpod", "macbook"]

print("airpod" in lista_produtos)  # True

posicao = lista_produtos.index("airpod")
print(posicao)                     # 3
print(lista_produtos[posicao:])    # ['airpod', 'macbook']

Um cuidado: se o item não existir, o .index() gera um ValueError. Por isso, quando não tiver certeza, verifique com in antes. Na próxima aula você aprende a fazer essa verificação com if.

Edite um item pela posição

Para alterar um item, atribua um novo valor à posição dele. Aqui o primeiro preço da lista sobe 10%:

lista_precos = [5000, 7000, 3000, 1000, 10000]
lista_precos[0] = lista_precos[0] * 1.1

print(lista_precos)

Resultado:

[5500.0, 7000, 3000, 1000, 10000]

Remova itens com remove() e pop()

O .remove() apaga um item pelo valor:

lista_produtos = ["iphone", "ipad", "apple watch", "airpod", "macbook"]
lista_produtos.remove("macbook")

print(lista_produtos)

Resultado:

['iphone', 'ipad', 'apple watch', 'airpod']

Já o .pop() apaga um item pela posição e devolve o item removido, que pode ser guardado em uma variável:

lista_produtos = ["iphone", "ipad", "apple watch", "airpod", "macbook"]
item_removido = lista_produtos.pop(-1)

print(f"O item {item_removido} foi removido. A lista agora é {lista_produtos}.")

Resultado:

O item macbook foi removido. A lista agora é ['iphone', 'ipad', 'apple watch', 'airpod'].

Adicione itens com append(), extend() e insert()

Existem três formas de colocar itens em uma lista. Nos exemplos, todas partem da mesma lista inicial, para você comparar os resultados.

O .append() adiciona um item no final da lista:

lista_produtos = ["iphone", "ipad", "apple watch", "airpod", "macbook"]
lista_produtos.append("airtag")

print(lista_produtos)

Resultado:

['iphone', 'ipad', 'apple watch', 'airpod', 'macbook', 'airtag']

O .extend() junta todos os itens de outra lista ao final:

lista_produtos = ["iphone", "ipad", "apple watch", "airpod", "macbook"]
lista2_produtos = ["PC", "airtag", "caixa de som"]
lista_produtos.extend(lista2_produtos)

print(lista_produtos)

Resultado:

['iphone', 'ipad', 'apple watch', 'airpod', 'macbook', 'PC', 'airtag', 'caixa de som']

Se você usasse append(lista2_produtos), a lista inteira entraria como um único item, ou seja, uma lista dentro da lista. Essa diferença entre append e extend confunde muita gente no começo.

Por fim, o .insert() coloca o item em uma posição específica e empurra os demais para a direita. Ele recebe dois argumentos: a posição e o item.

lista_produtos = ["iphone", "ipad", "apple watch", "airpod", "macbook"]
lista_produtos.insert(1, "airtag")

print(lista_produtos)

Resultado:

['iphone', 'airtag', 'ipad', 'apple watch', 'airpod', 'macbook']

Como a contagem começa em zero, a posição 1 corresponde ao segundo lugar da lista.

Ordene listas com sort()

O .sort() organiza a lista em ordem crescente. Para inverter a ordem, use o parâmetro reverse=True:

lista_precos = [5000, 7000, 3000, 1000, 10000]

lista_precos.sort()
print(lista_precos)  # [1000, 3000, 5000, 7000, 10000]

lista_precos.sort(reverse=True)
print(lista_precos)  # [10000, 7000, 5000, 3000, 1000]

Com textos, a ordem é alfabética, com um detalhe: para o Python, todas as letras maiúsculas vêm antes das minúsculas. Por isso o "PC" aparece em primeiro lugar:

lista_produtos = ["iphone", "ipad", "PC", "airtag", "caixa de som"]
lista_produtos.sort()

print(lista_produtos)

Resultado:

['PC', 'airtag', 'caixa de som', 'ipad', 'iphone']

O .sort() altera a lista original. Se quiser manter a original intacta e gerar uma cópia ordenada, use a função sorted(): lista_ordenada = sorted(lista_produtos).

Nesta aula você aprendeu a receber e tratar dados do usuário e a trabalhar com listas. Na próxima, seu código começa a tomar decisões.

Voltar ao índice do curso

Aula 4: Tome decisões no código com if, elif e else

Programas úteis tomam decisões: dar ou não um desconto, cadastrar ou recusar um produto, pagar um bônus maior ou menor. Nesta aula você aprende as estruturas condicionais, que fazem o código seguir caminhos diferentes conforme a situação.

Escreva sua primeira estrutura if e else

A lógica é a mesma de uma frase do dia a dia: se a condição for verdadeira, faça isto; senão, faça aquilo. No Python, fica assim:

faturamento = 1000
custo = 600
lucro = faturamento - custo

if lucro >= 0:
    print("Lucro de", lucro)
    print("Deu lucro")
else:
    print("Prejuízo de", lucro)
    print("Deu prejuízo")

print("Acabou")

Resultado:

Lucro de 400
Deu lucro
Acabou

Três detalhes de sintaxe que você precisa observar:

• A linha do if e a linha do else terminam com dois-pontos (:).
• As linhas que pertencem a cada bloco ficam indentadas, com um recuo de 4 espaços. O VS Code faz isso sozinho quando você aperta Enter depois dos dois-pontos. É a indentação que diz ao Python o que está dentro de cada bloco, então ela não é só estética.
• O print("Acabou") está sem recuo, então fica fora da estrutura e roda em qualquer caso.

Experimente trocar o custo para 1500 e rodar de novo: o programa segue pelo else e mostra um prejuízo de -500. Para mais exemplos, veja a aula sobre estruturas condicionais no Python.

Compare valores com os operadores de comparação

A condição do if é sempre uma pergunta que o Python responde com True ou False. Para montar essas perguntas, você usa os operadores de comparação:

Atenção ao erro mais comum de todos: um sinal de igual (=) atribui um valor, enquanto dois sinais (==) comparam. Escrever if lucro = 0: gera um erro de sintaxe, e a própria mensagem do Python sugere que talvez você quisesse usar ==.

As comparações também funcionam com textos, e aí maiúsculas e minúsculas fazem diferença:

print("iphone" == "iphone")  # True
print("iPhone" == "iphone")  # False

Por isso é tão comum padronizar os textos com .lower() antes de comparar, como você vai ver no próximo exemplo.

Evite cadastros duplicados com if e listas

Voltando à loja de eletrônicos: antes de cadastrar um produto novo, o sistema precisa verificar se ele já existe. É uma combinação de input, lista e if:

produtos = ["iphone", "ipad", "airpod"]

novo_produto = input("Digite o nome do produto: ")
novo_produto = novo_produto.strip().lower()

if novo_produto in produtos:
    print("Produto já existente")
else:
    produtos.append(novo_produto)
    print(f"{novo_produto} cadastrado com sucesso")

print(produtos)

Resultado:

Digite o nome do produto: macbook
macbook cadastrado com sucesso
['iphone', 'ipad', 'airpod', 'macbook']

Digitando macbook, o produto é adicionado. Digitando iPad , o strip() e o lower() transformam o texto em ipad, que já está na lista, e o cadastro duplicado é bloqueado. Sem essa limpeza, o sistema aceitaria "iPad" como se fosse um produto diferente.

Trate vários cenários com elif

Quando existem mais de dois cenários, entra o elif, abreviação de else if ("senão, se"). Um sistema de bônus por faixa de vendas fica assim:

vendas = 17000

if vendas >= 15000:
    bonus = 500
elif vendas >= 5000:
    bonus = 100
else:
    bonus = 0

print(f"Bônus do funcionário: R$ {bonus}")

Resultado:

Bônus do funcionário: R$ 500

O Python testa as condições de cima para baixo e executa apenas o primeiro bloco verdadeiro, ignorando os demais. Veja como isso funciona com valores diferentes:

• Com vendas de 17000, a primeira condição já é verdadeira, então o bônus é R$ 500 e a verificação para aí.
• Com vendas de 8000, a primeira condição é falsa e a segunda é verdadeira, então o bônus é R$ 100.
• Abaixo de 5000, nenhuma condição é atendida e o else define o bônus como zero.

Por isso a ordem importa. Se o teste vendas >= 5000 viesse primeiro, quem vendeu 17000 também cairia nele e receberia só R$ 100.

Combine condições com and, or e not

Às vezes a decisão depende de mais de uma condição ao mesmo tempo. Para isso existem os operadores lógicos:

Com and, o funcionário só ganha bônus se vender bem e a empresa bater a meta:

vendas_empresa = 200_000
meta_empresa = 100_000
vendas_funcionario = 16000

if vendas_funcionario >= 15000 and vendas_empresa >= meta_empresa:
    bonus = 500
elif vendas_funcionario >= 5000 and vendas_empresa >= meta_empresa:
    bonus = 100
else:
    bonus = 0

print(f"Bônus do funcionário: R$ {bonus}")

Resultado:

Bônus do funcionário: R$ 500

Se a empresa não bater a meta, o bônus é zero, por melhor que o funcionário tenha ido. Já o or é mais flexível. Imagine uma loja que dá frete grátis para clientes VIP ou para compras acima de R$ 300:

cliente_vip = False
valor_compra = 450

if cliente_vip or valor_compra > 300:
    print("Frete grátis")
else:
    print("Frete pago")

Resultado:

Frete grátis

O cliente não é VIP, mas a compra passou de R$ 300, e uma condição verdadeira basta. Por fim, o not inverte uma condição, o que deixa certas verificações mais naturais de ler:

produto_esgotado = False

if not produto_esgotado:
    print("Produto disponível para compra")

Resultado:

Produto disponível para compra

Nesta aula você aprendeu a fazer o código tomar decisões com if, elif e else, a comparar valores e a combinar condições. Na próxima, você conhece uma nova forma de organizar dados.

Voltar ao índice do curso

Aula 5: Organize informações com dicionários em Python

Listas são ótimas para sequências, mas nem sempre a posição é a melhor forma de encontrar uma informação. Nesta aula você conhece os dicionários, que guardam dados em pares e permitem buscar tudo pelo nome.

Entenda a lógica de chave e valor

Um dicionário funciona como uma agenda de contatos: você procura pelo nome, que é a chave, e encontra a informação associada a ele, que é o valor. Em vez de lembrar que o preço do iPad está na posição 0 de uma lista, você simplesmente pergunta pelo "ipad".

Os dicionários ficam entre chaves ({}), e cada item é um par chave: valor, separado dos outros por vírgula. Na loja de eletrônicos, as chaves são os produtos e os valores são os preços. Esse formato é ideal para cadastros de clientes, tabelas de preços, configurações e qualquer informação que você precise consultar pelo nome.

Crie um dicionário do zero ou a partir de duas listas

A forma mais direta de criar um dicionário é escrevê-lo à mão:

dic_produtos = {"ipad": 7000, "iphone": 5000, "airpod": 2000}

Agora imagine que os produtos e os preços já estão em duas listas separadas, na mesma ordem. Em vez de digitar tudo de novo, a função zip() junta as listas item a item, e a função dict() transforma essa junção em um dicionário:

lista_produtos = ["ipad", "iphone", "airpod"]
lista_precos = [7000, 5000, 2000]

dic_produtos = dict(zip(lista_produtos, lista_precos))
print(dic_produtos)

Resultado:

{'ipad': 7000, 'iphone': 5000, 'airpod': 2000}

Repare que o Python exibe os textos com aspas simples. Isso é só a forma de mostrar: aspas simples ou duplas dão no mesmo.

Acesse, edite, adicione e remova itens

Manipular um dicionário é parecido com manipular uma lista, com uma diferença central: no lugar da posição, você sempre usa a chave.

Busque valores pela chave e evite erros com get()

Para acessar um valor, coloque a chave entre colchetes:

print(dic_produtos["ipad"])  # 7000

Se a chave não existir, o Python gera um KeyError. Quando não tiver certeza de que a chave está lá, use o método .get(), que devolve None em vez de erro, ou um valor padrão escolhido por você:

print(dic_produtos.get("macbook"))     # None
print(dic_produtos.get("macbook", 0))  # 0

Edite e adicione itens

Para alterar um valor, atribua um novo valor à chave. Aqui o preço do iPhone sobe 10%:

dic_produtos["iphone"] = dic_produtos["iphone"] * 1.1
print(dic_produtos["iphone"])  # 5500.0

Para adicionar um item, a lógica é a mesma e não é preciso nenhum método especial, como o append() das listas: basta atribuir um valor a uma chave que ainda não existe, e ela passa a existir.

dic_produtos["macbook"] = 12000
print(dic_produtos)

Resultado:

{'ipad': 7000, 'iphone': 5500.0, 'airpod': 2000, 'macbook': 12000}

Uma regra importante: as chaves são únicas. Se você atribuir um valor a uma chave que já existe, o valor antigo é substituído, sem nenhum aviso de erro. Os valores, por outro lado, podem se repetir à vontade.

Remova itens com pop()

O .pop() remove o item da chave informada e, assim como nas listas, devolve o valor removido:

item_removido = dic_produtos.pop("macbook")

print(item_removido)  # 12000
print(dic_produtos)

Resultado:

12000
{'ipad': 7000, 'iphone': 5500.0, 'airpod': 2000}

Verifique chaves e valores com in, keys() e values()

Para saber se algo existe no dicionário, use o in, que devolve True ou False:

dic_produtos = {"ipad": 7000, "iphone": 5000, "airpod": 2000}

print("iphone" in dic_produtos)         # True
print("iphone" in dic_produtos.keys())  # True
print(2000 in dic_produtos.values())    # True
print(2000 in dic_produtos)             # False

As duas primeiras linhas fazem a mesma coisa, porque, por padrão, o in procura nas chaves. Para procurar nos valores, é preciso indicar isso com .values(). É por isso que a última linha dá False: 2000 é um valor, não uma chave.

Transforme partes do dicionário em listas e conte itens

Às vezes você precisa só dos produtos ou só dos preços, por exemplo para somar ou ordenar. Basta converter as chaves ou os valores em lista com a função list():

produtos = list(dic_produtos.keys())
precos = list(dic_produtos.values())

print(produtos)           # ['ipad', 'iphone', 'airpod']
print(precos)             # [7000, 5000, 2000]
print(sum(precos))        # 14000
print(len(dic_produtos))  # 3

A função len() conta a quantidade de pares chave e valor. Existe ainda um terceiro método, o .items(), que devolve os pares completos:

print(list(dic_produtos.items()))

Resultado:

[('ipad', 7000), ('iphone', 5000), ('airpod', 2000)]

Os parênteses em cada par indicam tuplas, assunto da Aula 8. O .items() vai ser muito útil na próxima aula, quando você percorrer dicionários com o for.

Exercício: crie uma consulta de preços

Juntando f-strings, tratamento de input e condicionais, crie um sistema em que o usuário digita o nome de um produto e recebe o preço. Se o produto não existir, o programa deve avisar. Use este dicionário:

dic_produtos = {"ipad": 7000, "iphone": 5000, "airpod": 2000, "macbook": 12000}

Solução: limpe o texto digitado, verifique se ele é uma chave do dicionário e, se for, busque e exiba o preço.

dic_produtos = {"ipad": 7000, "iphone": 5000, "airpod": 2000, "macbook": 12000}

produto_buscado = input("Digite o nome do produto: ")
produto_buscado = produto_buscado.strip().lower()

if produto_buscado in dic_produtos:
    preco = dic_produtos[produto_buscado]
    print(f"Produto: {produto_buscado} | Preço: R$ {preco:,.2f}")
else:
    print("Produto não encontrado")

Resultado:

Digite o nome do produto:   MacBook
Produto: macbook | Preço: R$ 12,000.00

Mesmo digitado com espaços e maiúsculas, o produto foi encontrado graças à limpeza. Como desafio extra, aplique no preço o truque do padrão brasileiro que você aprendeu na Aula 2.

Nesta aula você aprendeu a criar, consultar e modificar dicionários. Na próxima, vai automatizar repetições e percorrer listas e dicionários inteiros.

Voltar ao índice do curso

Aula 6: Automatize repetições com o for em Python

Repetir a mesma tarefa várias vezes é exatamente o tipo de trabalho que computadores fazem melhor que pessoas. Nesta aula você aprende o for, a estrutura de repetição que percorre listas, dicionários e sequências de números sem que você precise reescrever código.

Repita tarefas com for e range()

Imagine que você precisa exibir uma mensagem 7 vezes. Sem uma estrutura de repetição, seriam 7 linhas iguais de print(). Com o for, são duas:

for i in range(7):
    print("Aprenda Python")

O range(7) gera a sequência de números de 0 a 6, ou seja, 7 números. A cada volta do laço, chamada de iteração, a variável i assume o próximo número dessa sequência e o código indentado abaixo é executado. Assim como no if, a linha do for termina com dois-pontos e o bloco que se repete fica recuado.

O nome i é só uma convenção, você pode escolher qualquer nome. E dá para usar o valor da variável dentro do bloco:

for numero in range(3):
    print(f"Repetição número {numero}")

Resultado:

Repetição número 0
Repetição número 1
Repetição número 2

O range() aceita até três argumentos: o início, o fim (que não entra na sequência) e o passo.

print(list(range(1, 6)))      # [1, 2, 3, 4, 5]
print(list(range(0, 11, 5)))  # [0, 5, 10]

O list() aparece aqui só para você enxergar os números. Sozinho, o range não é uma lista: ele gera os números à medida que o for precisa deles, o que economiza memória.

Percorra listas com for

O uso mais comum do for é percorrer uma lista, item por item. Você nem precisa saber quantos itens ela tem: o for vai do primeiro ao último sozinho. Veja o cálculo de 10% de imposto sobre cada preço:

lista_precos = [1500, 1000, 800, 200]
taxa_imposto = 0.1

for preco in lista_precos:
    imposto = preco * taxa_imposto
    print(f"O preço do produto é {preco}, o imposto é de {imposto}")

Resultado:

O preço do produto é 1500, o imposto é de 150.0
O preço do produto é 1000, o imposto é de 100.0
O preço do produto é 800, o imposto é de 80.0
O preço do produto é 200, o imposto é de 20.0

A cada iteração, a variável preco assume um valor da lista, na ordem. Um bom hábito é dar à variável do for o nome, no singular, do que a lista guarda: for preco in lista_precos, for produto in produtos. Para mais exemplos, veja a aula sobre a estrutura de repetição for.

Aplique regras diferentes com for e if

Agora a regra muda: produtos acima de R$ 1000 pagam 15% de imposto e os demais pagam 10%. Basta colocar um if dentro do for:

lista_precos = [1500, 1000, 800, 200]

for preco in lista_precos:
    if preco > 1000:
        taxa = 0.15
    else:
        taxa = 0.1
    imposto = preco * taxa
    print(f"O preço do produto é {preco}, o imposto é de {imposto}")

Resultado:

O preço do produto é 1500, o imposto é de 225.0
O preço do produto é 1000, o imposto é de 100.0
O preço do produto é 800, o imposto é de 80.0
O preço do produto é 200, o imposto é de 20.0

Repare nos níveis de indentação: o if está dentro do for, e as linhas da taxa estão dentro do if. Já o cálculo do imposto volta um nível e roda em todas as iterações. E o produto de 1000 pagou 10%, porque a condição é maior que 1000, e não maior ou igual.

Acumule totais dentro do loop

E se você quiser saber o total de impostos? A técnica é criar uma variável antes do for, começando em zero, e somar a ela o imposto de cada iteração com o += que você conheceu na Aula 1:

lista_precos = [1500, 1000, 800, 200]
total_imposto = 0

for preco in lista_precos:
    if preco > 1000:
        taxa = 0.15
    else:
        taxa = 0.1
    imposto = preco * taxa
    total_imposto += imposto

print(f"Total de imposto: {total_imposto}")

Resultado:

Total de imposto: 425.0

O print final está fora do for, então aparece uma vez só, depois de todas as somas. Se ele estivesse indentado, você veria o total parcial a cada volta. Esse padrão de acumulador aparece em todo tipo de programa: somar vendas, contar clientes, juntar resultados.

Percorra dicionários e calcule o crescimento das vendas

O for também percorre dicionários e, por padrão, passa pelas chaves. Com as vendas dos primeiros meses de dois anos, dá para calcular o crescimento de cada mês:

vendas_23 = {"jan": 15000, "fev": 10000, "mar": 5000}
vendas_24 = {"jan": 16000, "fev": 11000, "mar": 5100}

for mes in vendas_24:
    valor_23 = vendas_23[mes]
    valor_24 = vendas_24[mes]
    crescimento = (valor_24 / valor_23) - 1
    print(f"No mês de {mes}, o crescimento foi de {crescimento:.1%}")

Resultado:

No mês de jan, o crescimento foi de 6.7%
No mês de fev, o crescimento foi de 10.0%
No mês de mar, o crescimento foi de 2.0%

O crescimento percentual é o valor atual dividido pelo anterior, menos 1. A cada iteração, mes assume uma chave (jan, fev, mar), que serve para buscar o valor correspondente nos dois dicionários. A formatação :.1% da Aula 2 transforma o resultado em porcentagem com uma casa decimal.

Quando precisar da chave e do valor ao mesmo tempo, o .items() entrega os dois de uma vez:

for mes, valor in vendas_24.items():
    print(f"{mes}: R$ {valor}")

Resultado:

jan: R$ 16000
fev: R$ 11000
mar: R$ 5100

Essa forma de usar duas variáveis no for se chama desempacotamento, e você vai entendê-la de vez na Aula 8.

Saiba quando usar o while

O Python tem uma segunda estrutura de repetição, o while. A diferença é simples: o for é ideal quando você sabe o que vai percorrer, como uma lista, um dicionário ou um intervalo de números; o while repete enquanto uma condição for verdadeira, sem um número definido de repetições.

senha = ""

while senha != "python123":
    senha = input("Digite a senha: ")

print("Acesso liberado")

O programa continua pedindo a senha até o usuário acertar. O cuidado com o while é garantir que a condição, em algum momento, se torne falsa; caso contrário, o laço nunca termina, o famoso loop infinito. Se quiser se aprofundar, veja a aula completa sobre while em Python. Para os exemplos deste curso, o for resolve tudo.

Nesta aula você aprendeu a repetir tarefas com o for, a combinar repetição com condições e a acumular resultados. Na próxima, vai organizar seu código em funções.

Voltar ao índice do curso

Aula 7: Reaproveite código com funções em Python

Nas aulas anteriores, alguns trechos se repetiram, como o cálculo de imposto e a formatação no padrão brasileiro. Nesta aula você aprende a criar funções em Python, que transformam esses trechos em comandos reutilizáveis com nome próprio.

Entenda por que usar funções em Python

Uma função é um bloco de código com nome, que você escreve uma vez e usa quantas vezes quiser. Você já usa funções desde a Aula 0: print(), len() e sum() são funções que vêm prontas com o Python. Agora você vai criar as suas, e os ganhos são três:

• Menos repetição: o código fica menor, e você não precisa copiar e colar o mesmo trecho.
• Manutenção mais fácil: se a regra mudar, você altera em um lugar só.
• Organização: o nome da função explica o que aquele bloco faz. Ler calcular_imposto(lista_precos) é bem mais claro do que ler dez linhas de cálculo.

Crie funções com def, parâmetros e return

A estrutura de uma função é esta:

def nome_da_funcao(parametro1, parametro2):
    # código que a função executa
    return resultado

• def é a palavra que define uma função.
• O nome segue as mesmas regras das variáveis: letras minúsculas, sem espaços nem acentos, com underline entre as palavras.
• Os parâmetros, entre parênteses, são as informações que a função recebe para trabalhar. Ela pode ter nenhum, um ou vários.
• O corpo é o código indentado abaixo da linha do def.
• O return devolve o resultado para quem chamou a função.

Um exemplo mínimo:

def somar(a, b):
    return a + b

resultado = somar(10, 5)
print(resultado)  # 15

Na definição, a e b são os parâmetros. Na chamada, os valores 10 e 5 são os argumentos, que ocupam o lugar dos parâmetros naquela execução. Um detalhe importante: criar a função não executa nada, o código só roda quando você a chama. Para ver mais exemplos, confira a aula sobre funções em Python com def.

Calcule impostos com uma função reutilizável

Lembra do cálculo de imposto com taxas diferentes da Aula 6? Transformado em função, ele fica assim:

def calcular_imposto(lista_valores):
    imposto_total = 0
    for preco in lista_valores:
        if preco > 1000:
            taxa = 0.15
        else:
            taxa = 0.1
        imposto_total += preco * taxa
    return imposto_total

A função recebe uma lista de valores, percorre cada um, aplica 15% para valores acima de 1000 e 10% para os demais, acumula o total e devolve o resultado. Agora ela funciona com qualquer lista:

lista_precos = [1500, 1000, 800, 2000]
lista2_precos = [500, 4000, 3200, 2600, 1000]

imposto_lista1 = calcular_imposto(lista_precos)
imposto_lista2 = calcular_imposto(lista2_precos)

print(imposto_lista1)  # 705.0
print(imposto_lista2)  # 1620.0

São duas listas e uma única lógica. Se amanhã a taxa mudar, você altera só dentro da função. E guardar o resultado em variáveis permite reaproveitá-lo depois, em outros cálculos.

Crie funções sem parâmetros

Nem toda função precisa receber informações. Algumas sempre executam a mesma ação:

def confira_nossos_conteudos():
    print("Confira outras publicações incríveis sobre Python em nosso site!")

confira_nossos_conteudos()

Resultado:

Confira outras publicações incríveis sobre Python em nosso site!

Mesmo sem parâmetros, os parênteses são obrigatórios, tanto na definição quanto na chamada. Sem eles na chamada, o Python não executa a função.

Entenda a diferença entre return e print

Essa é uma das confusões mais comuns de quem está começando. O print() apenas mostra algo na tela. O return devolve um valor, que pode ser guardado e usado em outras contas. Veja o que acontece com a função anterior, que não tem return:

resultado = confira_nossos_conteudos()
print(resultado)

Resultado:

Confira outras publicações incríveis sobre Python em nosso site!
None

A mensagem aparece porque a função executou o print. Mas, como ela não devolve nada, a variável resultado recebe None, o valor que o Python usa para representar "nada". A regra prática: se você vai usar o resultado depois, use return.

Outro detalhe: quando o Python chega a um return, a função termina ali. Qualquer linha que venha depois dele, dentro da função, não é executada.

Chame uma função dentro de outra

Funções podem chamar outras funções. No cálculo de imposto, a escolha da taxa pode virar uma função própria:

def definir_taxa_imposto(preco):
    if preco > 1000:
        return 0.15
    return 0.1

def calcular_imposto(lista_valores):
    imposto_total = 0
    for preco in lista_valores:
        taxa = definir_taxa_imposto(preco)
        imposto_total += preco * taxa
    return imposto_total

print(calcular_imposto([1500, 1000, 800, 2000]))  # 705.0

Repare que definir_taxa_imposto nem precisa de else: se o preço for maior que 1000, o primeiro return encerra a função; se não for, o Python segue para a linha seguinte e devolve 0.1. Agora cada função tem uma responsabilidade só: uma decide a taxa, a outra soma os impostos. Se a regra das taxas mudar, você mexe apenas na primeira.

Diferencie variáveis locais e globais

Variáveis criadas dentro de uma função são locais: só existem enquanto a função está rodando. Variáveis criadas fora de qualquer função são globais e podem ser lidas em todo o arquivo.

taxa_padrao = 0.1  # variável global

def minha_funcao():
    x = 10  # variável local
    print(x, taxa_padrao)

minha_funcao()
print(taxa_padrao)
print(x)  # gera erro

Resultado:

10 0.1
0.1
NameError: name 'x' is not defined

A última linha gera o mesmo NameError da Aula 1, porque x deixou de existir quando a função terminou. Se precisar de um valor calculado dentro da função, a forma certa de levá-lo para fora é o return.

Saiba quando transformar código em função

Não existe regra fixa, mas alguns sinais ajudam a perceber que um trecho merece virar função:

• Você copiou e colou o mesmo trecho mais de uma vez.
• O bloco faz uma tarefa que dá para descrever com um verbo, como calcular, validar ou formatar.
• O trecho ficou tão longo que precisa de um comentário para explicar o que faz.

Na hora de criar, mantenha cada função simples e com um único propósito. Em projetos maiores, as funções costumam ficar em arquivos separados, uma ideia que você vai começar a entender na Aula 9. E, quando dominar o básico, vale conhecer os parâmetros flexíveis args e *kwargs.

Nesta aula você aprendeu a criar funções com e sem parâmetros, a diferença entre return e print e o escopo das variáveis. Na próxima, vai fazer funções devolverem mais de um resultado.

Voltar ao índice do curso

Aula 8: Retorne vários resultados com tuplas

Algumas funções precisam devolver mais de um resultado, e alguns dados nunca deveriam ser alterados por engano. Nesta aula você conhece as tuplas, que resolvem as duas situações.

Entenda o que são tuplas e quando preferi-las às listas

Uma tupla é parecida com uma lista: guarda vários valores em ordem, aceita tipos diferentes e tem os itens acessados pela posição. A diferença é que a tupla é escrita entre parênteses e é imutável: depois de criada, não dá para alterar, adicionar ou remover itens.

tela = (1920, 1080)

print(tela[0])  # 1920
print(tela[1])  # 1080

tela[0] = 1280  # gera erro

Resultado:

1920
1080
TypeError: 'tuple' object does not support item assignment

Essa limitação é justamente a vantagem: a tupla protege dados que não devem mudar durante o programa, como coordenadas, dimensões de tela ou configurações fixas.

Um detalhe curioso: para criar uma tupla com um único item, é preciso colocar uma vírgula, como em (5,). Sem ela, (5) é apenas o número 5 entre parênteses. Para comparar as estruturas com mais profundidade, veja a aula sobre listas, tuplas e conjuntos e a aula dedicada às tuplas no Python.

Retorne múltiplos valores de uma função

Imagine um sistema com dois tipos de bônus para vendedores:

• Bônus 1: R$ 2 por venda realizada.
• Bônus 2: 1% do valor total vendido.

Uma única função pode calcular os dois e devolvê-los juntos, separados por vírgula no return:

def calcular_bonus(lista_vendas):
    bonus1 = len(lista_vendas) * 2
    bonus2 = sum(lista_vendas) * 0.01
    return bonus1, bonus2

vendas = [100, 250, 400, 100]
resultado = calcular_bonus(vendas)

print(resultado)  # (8, 8.5)

Foram 4 vendas, que valem R$ 8 de bônus 1, somando R$ 850, que valem R$ 8,50 de bônus 2. Repare nos parênteses da saída: quando uma função retorna vários valores, o Python os agrupa automaticamente em uma tupla.

Desempacote tuplas em variáveis

Em vez de acessar cada item com resultado[0] e resultado[1], você pode distribuir os valores da tupla direto em variáveis. Isso se chama desempacotamento, ou unpacking:

bonus1, bonus2 = calcular_bonus(vendas)

print(bonus1)  # 8
print(bonus2)  # 8.5

O primeiro valor vai para a primeira variável, e o segundo, para a segunda. A quantidade de variáveis precisa ser igual à de valores; se não for, o Python gera um ValueError.

O desempacotamento também funciona no for, e é exatamente o que acontecia com o .items() na Aula 6. Com uma lista de resoluções de tela:

lista_telas = [(1920, 1080), (2560, 1440), (3840, 2160)]

for largura, altura in lista_telas:
    print(f"Largura: {largura}, Altura: {altura}")

Resultado:

Largura: 1920, Altura: 1080
Largura: 2560, Altura: 1440
Largura: 3840, Altura: 2160

A cada iteração, o for pega uma tupla da lista e já distribui seus dois valores entre largura e altura.

Exercício: calcule o bônus de cada vendedor

Considere as vendas de cada vendedor no dicionário abaixo. Usando a função calcular_bonus, com as regras desta aula (R$ 2 por venda e 1% do total vendido), calcule:

1. Os dois bônus de cada vendedor.
2. O total de bônus 1 pago pela empresa.
3. O total de bônus 2 pago pela empresa.

vendas = {
    "André": [1000, 500, 300, 5000, 1500, 80, 3000],
    "Andressa": [1500, 9000, 300, 150, 1500, 120, 130, 55, 500, 8500],
    "Alan": [800, 100],
    "Ana": [800, 900, 950, 1200, 1600, 130, 50, 50, 50, 50, 65, 60, 70, 70, 70, 200, 180, 100, 120, 110, 130, 140],
}

Solução: percorra o dicionário com .items(), calcule os bônus de cada vendedor com a função, desempacote o resultado e acumule cada tipo de bônus em sua própria variável. Manter os totais separados é essencial, porque o exercício pede os dois de forma independente.

def calcular_bonus(lista_vendas):
    bonus1 = len(lista_vendas) * 2
    bonus2 = sum(lista_vendas) * 0.01
    return bonus1, bonus2

total_bonus1 = 0
total_bonus2 = 0

for vendedor, lista_vendas in vendas.items():
    bonus1, bonus2 = calcular_bonus(lista_vendas)
    print(f"{vendedor}: Bônus 1 = R$ {bonus1:.2f} | Bônus 2 = R$ {bonus2:.2f}")
    total_bonus1 += bonus1
    total_bonus2 += bonus2

print(f"Total de Bônus 1: R$ {total_bonus1:.2f}")
print(f"Total de Bônus 2: R$ {total_bonus2:.2f}")
print(f"Total geral: R$ {total_bonus1 + total_bonus2:.2f}")

Resultado:

André: Bônus 1 = R$ 14.00 | Bônus 2 = R$ 113.80
Andressa: Bônus 1 = R$ 20.00 | Bônus 2 = R$ 217.55
Alan: Bônus 1 = R$ 4.00 | Bônus 2 = R$ 9.00
Ana: Bônus 1 = R$ 44.00 | Bônus 2 = R$ 70.95
Total de Bônus 1: R$ 82.00
Total de Bônus 2: R$ 411.30
Total geral: R$ 493.30

Repare que a Ana fez muitas vendas pequenas e ganhou o maior bônus 1, enquanto a Andressa, com vendas maiores, ficou com o maior bônus 2. É o tipo de análise que fica simples quando os dois valores estão separados.

Nesta aula você aprendeu a usar tuplas, a retornar vários valores de uma função e a desempacotá-los. Na próxima e última aula, vai dar novas habilidades ao Python com bibliotecas.

Voltar ao índice do curso

Aula 9: Amplie o Python com módulos e bibliotecas

Chegou a última aula, e é aqui que o Python mostra de onde vem boa parte do seu poder. Você vai aprender a usar módulos e bibliotecas, códigos prontos que dão ao Python novas habilidades, como mexer em arquivos do computador e buscar dados na internet.

Entenda módulos, bibliotecas e pacotes

Os três termos aparecem muito e costumam ser usados quase como sinônimos. A diferença, de forma simples:

Na prática, o que mais importa é saber de onde cada uma vem. A biblioteca padrão já vem instalada com o Python e inclui módulos como o os. As bibliotecas externas, como o requests, são criadas pela comunidade e precisam ser instaladas antes de usar. Como o Python é open source, existe biblioteca para praticamente tudo: automação, análise de dados, sites, jogos e inteligência artificial. Para ter uma visão geral, veja o guia das principais bibliotecas Python.

Importe módulos com import

Para usar um módulo, você precisa importá-lo, normalmente no início do arquivo. Existem três formas comuns:

import os                        # importa o módulo inteiro
from statistics import mean      # importa só uma função do módulo
import statistics as st          # importa o módulo com um apelido

print(mean([100, 50, 1000, 800, 35]))       # 397
print(st.median([100, 50, 1000, 800, 35]))  # 100

Com import os, você usa as funções com o nome do módulo na frente, como os.getcwd(). Com from ... import, a função é usada direto pelo nome. E o as cria um apelido, muito usado com bibliotecas de nome longo. Repare que a média é a mesma que você calculou na mão na Aula 3.

Manipule arquivos e pastas com a biblioteca os

O os faz parte da biblioteca padrão e permite interagir com o sistema operacional: navegar entre pastas, listar, criar, renomear e mover arquivos. Ele é a base de muitas automações do dia a dia.

Descubra a pasta atual e liste arquivos

O os.getcwd() mostra a pasta onde o programa está rodando:

import os

diretorio_atual = os.getcwd()
print(diretorio_atual)

Resultado:

C:\Users\seu_usuario\Desktop\Curso Python

Já o os.listdir() devolve uma lista com os arquivos e pastas de um diretório. Considere esta pasta:

lista_arquivos = os.listdir()
print(lista_arquivos)

Resultado:

['arquivos', 'aula 9 - modulos e bibliotecas.py', 'listdir.py']

Sem argumentos, ele lista a pasta atual. Para listar outra pasta, passe o caminho, como em os.listdir("arquivos"). Repare que o resultado é uma lista comum, então tudo o que você aprendeu na Aula 3 vale aqui. Para conhecer outras funções, veja os métodos da biblioteca os.

Organize arquivos por ano automaticamente

Agora um exemplo real de automação. Dentro da pasta arquivos há relatórios de 2022 e 2023 misturados, com nomes como relatorio_vendas_22.txt e relatorio_vendas_23.txt. O objetivo é mover cada um para a pasta do seu ano:

import os

pasta = "arquivos"
os.makedirs(f"{pasta}/22", exist_ok=True)
os.makedirs(f"{pasta}/23", exist_ok=True)

for nome_arquivo in os.listdir(pasta):
    if nome_arquivo.endswith(".txt"):
        if "22" in nome_arquivo:
            os.rename(f"{pasta}/{nome_arquivo}", f"{pasta}/22/{nome_arquivo}")
        elif "23" in nome_arquivo:
            os.rename(f"{pasta}/{nome_arquivo}", f"{pasta}/23/{nome_arquivo}")

Entenda o passo a passo:

1. O os.makedirs() cria as pastas 22 e 23. O exist_ok=True evita erro se elas já existirem, o que permite rodar o script quantas vezes quiser.
2. O for percorre a lista de itens da pasta.
3. O .endswith(".txt") confere se o nome termina com .txt, o que é mais seguro do que procurar "txt" em qualquer parte do nome.
4. O if e o elif verificam o ano presente no nome do arquivo.
5. O os.rename(origem, destino) troca o caminho do arquivo, o que na prática o move para a outra pasta.

As próprias pastas 22 e 23 aparecem no listdir, mas são ignoradas porque não terminam com .txt. Um cuidado: a verificação "22" in nome_arquivo funciona para esse padrão de nomes, mas um arquivo como relatorio_2023_v22.txt cairia na pasta errada. Em projetos reais, vale definir bem o padrão de nomes dos arquivos.

Instale bibliotecas externas com pip

Bibliotecas externas são instaladas com o pip, o gerenciador de pacotes que já vem junto com o Python. O comando é digitado no terminal, e não dentro do arquivo .py. No VS Code, abra o terminal pelo menu Terminal > New Terminal e digite:

pip install requests

Se o terminal não reconhecer o pip, use a forma que chama o pip pelo próprio Python, mais confiável em qualquer sistema:

python -m pip install requests

No Windows, se o comando python não funcionar, troque por py -m pip install requests; no macOS e no Linux, por python3 -m pip install requests. As bibliotecas ficam publicadas no PyPI, o repositório oficial de pacotes do Python.

Consulte cotações de moedas com requests

O requests é a biblioteca mais usada para fazer requisições HTTP, ou seja, para o Python conversar com sites e APIs. Uma API é um canal que um sistema oferece para que outros sistemas busquem dados nele; se o conceito é novo para você, entenda melhor o que é uma API e como consumir no Python. No exemplo, você vai usar a AwesomeAPI, um serviço brasileiro de cotações de moedas.

Faça a requisição e confira o status

import requests

link = "https://economia.awesomeapi.com.br/last/USD-BRL,EUR-BRL,BTC-BRL"
resposta = requests.get(link)

print(resposta)
print(resposta.status_code)

Resultado:

<Response [200]>
200

O requests.get() faz a requisição e guarda a resposta. Ao imprimir a resposta inteira, o Python mostra <Response [200]>; para pegar só o número, use o .status_code. O código 200 significa sucesso. Outros códigos comuns são o 404, de endereço não encontrado, e o 429, de excesso de requisições.

Uma observação sobre essa API: sem cadastro, as respostas ficam em cache por cerca de 1 minuto, então a cotação pode não mudar a cada execução. Com uma API Key gratuita, criada no site da AwesomeAPI, é possível fazer até 100 mil requisições por mês com dados em tempo real. Os detalhes estão na documentação da AwesomeAPI.

Leia a resposta em JSON

Os dados chegam no formato JSON, muito usado na troca de informações entre sistemas e bem parecido com um dicionário do Python. O método .json() faz essa conversão:

dic_resposta = resposta.json()
print(dic_resposta)

O resultado segue esta estrutura. Os valores abaixo são ilustrativos, e a resposta real traz ainda mais campos:

{
  "USDBRL": {
    "code": "USD",
    "codein": "BRL",
    "name": "Dólar Americano/Real Brasileiro",
    "high": "5.4502",
    "low": "5.4108",
    "bid": "5.4321"
  },
  "EURBRL": {
    "code": "EUR",
    "codein": "BRL",
    "name": "Euro/Real Brasileiro",
    "high": "6.3710",
    "low": "6.3289",
    "bid": "6.3456"
  },
  "BTCBRL": {
    "code": "BTC",
    "codein": "BRL",
    "name": "Bitcoin/Real Brasileiro",
    "high": "618900",
    "low": "605120",
    "bid": "612345"
  }
}

É um dicionário de dicionários: cada chave (USDBRL, EURBRL, BTCBRL) guarda outro dicionário com os dados daquela moeda. O campo bid é o valor de compra.

Extraia a cotação de cada moeda

Agora é só juntar o que você já sabe: percorrer o dicionário com for e acessar as chaves. Como o bid vem como texto, ele é convertido com float() para permitir cálculos e formatação:

for moeda, dados in dic_resposta.items():
    cotacao = float(dados["bid"])
    print(f"{moeda}: R$ {cotacao:,.2f}")

Resultado:

USDBRL: R$ 5.43
EURBRL: R$ 6.35
BTCBRL: R$ 612,345.00

Com a cotação convertida em número, calcular quanto custa em reais uma compra de 250 dólares vira uma simples multiplicação. Repare como esta aula reaproveitou quase tudo o que você aprendeu: listas, dicionários, for, if, f-strings e conversão de tipos. É assim que a programação funciona: cada novo desafio combina os mesmos fundamentos.

Voltar ao índice do curso

Continue praticando: exercícios e projetos em Python

Terminar as 10 aulas é o começo. O que transforma conhecimento em habilidade é a prática, e a boa notícia é que você já tem base para criar programas úteis. O desafio agora é sair do aprendizado guiado e ganhar autonomia.

Siga uma rotina de estudo que gera autonomia

Para cada conceito, siga este ciclo:

1. Revise o conceito na aula correspondente.
2. Reproduza o exemplo digitando o código, sem copiar e colar.
3. Altere o código de propósito: troque valores, condições e nomes e observe o que acontece.
4. Crie um exercício seu, a partir de um problema do seu dia a dia.
5. Avance para um mini projeto que junte vários conceitos.

Encare os erros como parte do método. Quando algo quebrar, leia a mensagem com calma, porque a última linha diz o tipo de erro e a causa. Tente entender o motivo, ajuste e teste de novo. Se ficar difícil encontrar o problema, aprenda a debugar Python no VS Code, recurso que executa o código linha por linha. O tutorial oficial do Python em português também é gratuito e complementa bem o curso.

Resolva exercícios de Python para fixar a base

Exercícios curtos, repetidos com variações, fixam a sintaxe e o raciocínio. Comece por estes, cada um ligado à aula que ensina o necessário:

Depois de resolver, mude as regras: acrescente condições, troque os dados, peça mais informações ao usuário. Para uma lista completa com soluções comentadas, veja os nossos exercícios de Python para iniciantes.

Construa projetos em Python para iniciantes

Projetos são o próximo nível, porque juntam vários conceitos em uma aplicação só. Eles não precisam ser complexos e podem crescer aos poucos, conforme você aprende coisas novas.

Dois bons pontos de partida, com passo a passo, são o organizador de arquivos com Python e o conversor de moedas com Python. E, se você trabalha com vendas, dados ou atendimento, simule situações do seu próprio trabalho: projetos em Python ligados à sua realidade ensinam mais e ainda viram portfólio.

Aprofunde com conteúdos gratuitos da Hashtag

Quando se sentir confortável com os fundamentos, escolha uma área e aprofunde uma de cada vez. Estes conteúdos gratuitos são continuações naturais do curso:

• Curso básico de análise de dados: para trabalhar com bases de dados e gerar indicadores com Python.
• Automação web com Python e Selenium: para controlar o navegador e automatizar tarefas em sites.
• Curso de FastAPI: para criar suas próprias APIs, o outro lado do que você fez com o requests.
• PyAutoGUI: para automatizar cliques e digitação em qualquer sistema do computador.

Conclusão

Parabéns por chegar até aqui! Neste Curso Básico de Python gratuito, você saiu do zero: preparou o ambiente, aprendeu a trabalhar com variáveis, textos, listas, dicionários e tuplas, fez o código tomar decisões com condicionais, automatizou repetições com o for, organizou tudo em funções e terminou usando bibliotecas para mover arquivos e buscar cotações reais na internet. São os mesmos fundamentos que sustentam automações, análises de dados e sistemas profissionais.

O próximo passo é praticar com constância e escolher uma área para se aprofundar. Se você quer acelerar esse caminho com um método estruturado, projetos completos e suporte, conheça o Python Impressionador, o curso completo de Python da Hashtag Treinamentos, que leva você do básico a automações, análise de dados, ciência de dados e inteligência artificial.

Caso prefira esse conteúdo no formato de videoaula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

FAQ - Perguntas Frequentes sobre Curso Básico de Python

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Posts mais recentes de Python

• 
  Curso Básico de Python: Saia do Zero em 10 Aulas Grátis18 de setembro de 2026
  Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.
• 
  Agentes RAG com Python: como criar um assistente de IA17 de setembro de 2026
  Aprenda a criar Agentes RAG com Python do zero: LangChain, FAISS e OpenAI para montar um assistente de IA que responde com base nos seus documentos.
• 
  25 Tipos de Gráficos em Python: Guia Completo com Código26 de agosto de 2026
  Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Posts mais recentes da Hashtag Treinamentos

• 
  Como liderar a Geração Z: mitos, fatos e o que funciona15 de outubro de 2026
  Como liderar a Geração Z: veja o que é mito, o que é fato e quais práticas de liderança os dados mostram que funcionam na rotina da equipe.
• 
  Nova atualização do ChatGPT: simuladores dentro da resposta14 de outubro de 2026
  Entenda a nova atualização do ChatGPT com GPT-6 e Intelligent UI: respostas com simuladores e diagramas, quem tem acesso e 5 usos no trabalho.
• 
  Melhor plataforma de IA: como escolher e quanto economizar9 de outubro de 2026
  Veja como escolher a melhor plataforma de IA, quando vale reunir ChatGPT, Claude e Gemini em uma assinatura só e quanto isso pode economizar por mês.