Saia do zero em Python com nosso curso básico de Python 2024 e dê seus primeiros passos nessa linguagem de programação tão versátil.
Ao longo desse curso, você aprenderá do básico até a construção de um projeto completo em Python. O objetivo é que você consiga dar seus primeiros passos, escrevendo seus primeiros códigos e finalizar o curso criando um sistema de backup feito em Python.
Vamos dar início ao Curso Básico de Python 2024 para que você possa sair do zero em Python e dar seus primeiros passos!
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na primeira aula do nosso curso básico de Python, quero te apresentar ao Python, demonstrar como fazer a instalação dele e do VS Code (editor de códigos), e te orientar sobre como dar seus primeiros passos nessa linguagem de programação.
Vamos explorar e entender as estruturas, variáveis, operações e comandos básicos do Python para que você possa sair dessa aula já sabendo escrever seus primeiros códigos.
E aí, animado para aprender Python? Então, faça o download do material disponível e vem comigo que eu vou te ensinar tudo o que você precisa saber para começar a programar em Python nesse curso básico de Python 2024!
O Python é uma linguagem de programação que foi projetada para ser multiplataforma e multifuncional. Isso significa que pode ser executada em diferentes sistemas operacionais sem a necessidade de modificações significativas e oferece uma grande variedade e versatilidade de aplicações.
Desenvolvido para ser uma linguagem mais simples e versátil, o Python é amplamente utilizado em diversas áreas e se tornou uma escolha popular no mercado de trabalho.
Você pode encontrar o Python sendo utilizado em campos como análise de dados, inteligência artificial, desenvolvimento web, automação de tarefas, criação de sistemas e aplicativos, entre outros.
Essa versatilidade e popularidade do Python o tornaram uma linguagem de programação adotada por muitas empresas, mesmo aquelas que não são do ramo de tecnologia, devido à sua capacidade de resolver problemas em diferentes áreas.
Você pode se perguntar por que aprender Python e não outra linguagem de programação. Claro, essa escolha dependerá da vaga e da área em que você deseja atuar; em alguns casos, pode ser recomendada outra linguagem de programação.
No entanto, devido à popularidade e versatilidade do Python, bem como à facilidade inicial no aprendizado dessa linguagem, ela se torna uma ótima escolha para quem está iniciando na área de programação.
Sendo assim, Python é uma ótima opção tanto pensando no mercado de trabalho quanto no aprendizado e crescimento com a linguagem.
Para começarmos, o primeiro passo é instalar o Python no seu computador. Vá até o Google, busque por “Python Download” e acesse a página correspondente, geralmente é o primeiro link.
Acessando essa página, basta você clicar no botão de Download. A versão do Python pode variar, dependendo de quando você estiver vendo essa aula, mas independente da versão, basta você fazer o download que funcionará corretamente.
Geralmente o site identificará seu sistema operacional e disponibilizará a versão correspondente para ele. Mas caso isso não aconteça, basta você selecionar logo abaixo do botão de download para qual sistema você quer baixar.
Feito o download, execute o arquivo e inicie a instalação. A única sugestão nessa etapa é marcar a opção Add python.exe to PATH.
Com isso, basta clicar em Install Now e ir seguindo as próximas etapas até a instalação ser concluída.
Com o Python instalado, agora é necessário termos alguma ferramenta para criar e testar nossos códigos. Para isso, existem algumas IDEs (Ambientes de Desenvolvimento Integrado) e editores de código que podem ser utilizados.
O programa que eu vou recomendar e que utilizarei ao longo desse curso é o VS Code, por ser leve e bastante versátil. Você pode utilizá-lo em diferentes sistemas operacionais e programar para diferentes linguagens.
Assim como o Python, basta que você busque no Google por “VS Code Download”, acesse a página do programa, faça o download e a instalação dele. É um procedimento simples, mas caso queira, temos uma aula completa aqui ensinando a instalá-lo.
Com o VS Code instalado, vamos criar uma pasta no nosso computador, onde iremos construir e salvar nossos códigos. No meu caso, irei criar uma pasta na área de trabalho chamada Curso Python.
Em seguida, podemos abrir o VS Code, ir em File, Open Folder e selecionar a pasta que acabamos de criar.
Por enquanto, ela estará vazia, mas já vamos criar um novo arquivo dentro dela. Basta clicar no ícone de New File, chamado de codigo.py.
Quando você cria um arquivo com a extensão .py, o Visual Studio Code já reconhece automaticamente como um arquivo Python. E no canto inferior direito, ele até exibe a sua versão do Python.
Caso sua versão do Python não esteja sendo reconhecida, reinicie o VS Code ou clique nessa opção e selecione manualmente onde está instalado o Python no seu computador.
Existem algumas extensões importantes que podemos adicionar dentro do VS Code para nos auxiliar a identificar as etapas do código, identificar erros, personalizar a visualização e assim por diante.
Para instalar uma extensão, basta selecionar o menu de extensões ao lado esquerdo da janela do VS Code.
A primeira extensão que vamos buscar e instalar é a extensão do Python.
Essa extensão permite ao Visual Studio Code identificar que seu código é um código Python e ajuda a otimizá-lo.
A segunda extensão que vamos instalar é a do Dracula.
Essa extensão é utilizada para aplicar um tema ao seu VS Code, que vai colorir seu código, facilitando a visualização e a identificação das partes dele.
Feito isso, podemos voltar para o nosso código e começar a construção dele. Basta clicar no ícone do Explorer.
O primeiro código que eu quero apresentar para vocês é um dos códigos mais comuns que você irá ver, que é a função print().
Essa função é utilizada para exibir as informações na tela do console, no terminal do seu editor de códigos. O termo print vem de imprimir em inglês, então com esse comando você consegue exibir textos, números, listas e assim por diante.
Vamos exibir uma primeira mensagem na tela. Como queremos exibir um texto, ele precisa ser colocado entre aspas, sejam aspas simples ou aspas duplas.
print("Meu primeiro programa em Python")
Atente-se à forma como estou escrevendo, pois, quando estamos trabalhando com uma linguagem de programação, é muito importante seguir as regras de formatação e sintaxe daquela linguagem.
Para executar esse código, basta clicar no ícone de Run, no canto superior direito.
Feito isso, a mensagem será exibida no terminal do VS Code.
Além de textos, podemos printar números.
print("Meu primeiro programa em Python")
print(30)
Observe que valores numéricos não precisam ser colocados entre aspas.
Além disso, podemos perceber que o Python executa os comandos sequencialmente, de cima para baixo. E isso é muito importante para a lógica da construção dos nossos códigos Python.
Vamos apagar essas duas linhas de código e começar a desenvolver um exemplo mais próximo de um cenário real de mercado de trabalho.
Imagine que você esteja trabalhando em uma empresa e precisa calcular o lucro da empresa, onde o faturamento foi 1000 e o custo foi 700.
Podemos exibir essas informações através de um print, em que vamos definir primeiro um texto e depois, separado por vírgula, vamos adicionar uma segunda informação. Isso porque a função print permite a entrada de mais de um argumento para ela.
print("O faturamento foi de ", 1000)
print("O custo foi de ", 700)
Você poderia adicionar os números dentro do texto e printar diretamente na mensagem.
print("O faturamento foi de 1000")
print("O custo foi de 700")E o resultado seria o mesmo.
A diferença entre um modelo e o outro é que, passando os números como um argumento à parte para a função, você pode utilizá-los para fazer contas, e diretamente dentro do texto, isso não é possível. Por exemplo:
print("O lucro foi de ", 1000 - 700)
print("O lucro foi de 1000 - 700")
Repare que para o primeiro comando, o Python retornou o resultado da subtração, enquanto no segundo exemplo, ele apenas printou o texto como estava escrito.
Então a melhor forma de representar essas 3 informações seria com o texto primeiro, seguido dos números à parte.
print("O faturamento foi de ", 1000)
print("O custo foi de ", 700)
print("O lucro foi de ", 1000 - 700)
Mas essa ainda não é a forma ideal de lidar com valores dentro do Python. Para isso, veremos como utilizar as variáveis.
Imagine que o faturamento da empresa foi de 1000 para 1200. Você teria de passar por cada linha que está com 1000 e alterar para 1200. Como nosso código é curto, isso não seria um problema.
No entanto, quando estamos trabalhando com códigos reais, teríamos diversas linhas de código que precisariam ser alteradas. Isso não seria nem um pouco fácil ou eficiente.
Para isso, podemos utilizar as variáveis. As variáveis são uma forma eficiente de armazenar informações e valores dentro do Python que podem ser facilmente atualizadas.
Você define as variáveis no início do código, e depois pode chamá-las ao longo dele.
faturamento = 1000
custo = 700
lucro = faturamento - custo
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)Perceba que as variáveis não ficam entre aspas, porque elas não são um texto, mas sim essa “caixinha” que armazena os valores e informações que desejamos.
Dessa forma, se quisermos atualizar o valor do faturamento, só precisamos modificar na variável inicial.
faturamento = 1200
custo = 700
lucro = faturamento - custo
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)
Variável é um conceito muito importante e eficiente que utilizaremos bastante daqui pra frente.
Existem diferentes tipos de variáveis em Python. O tipo da variável está relacionado com o tipo de dado que ela armazena.
Por exemplo, a variável faturamento é uma variável do tipo int, referente aos números inteiros.
faturamento = 1200 # tipo: int -> número inteiro
custo = 700
lucro = faturamento - custo
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)Observe que para fazer a anotação de que a variável faturamento é do tipo inteiro, iniciei o texto com uma hashtag (#). Quando você inicia uma parte do seu código com uma hashtag, isso representa um comentário.
Os comentários são formas de você fazer anotações dentro do seu código. O Python não irá executar as linhas ou partes do código iniciadas por #.
Além do número inteiro, temos os números com casas decimais, que são chamados de float, derivado de ponto flutuante. Por exemplo, podemos transformar nosso custo em uma variável do tipo float, atribuindo a ela o valor de 750.32.
faturamento = 1200 # tipo: int -> número inteiro
custo = 750.32 # tipo: float -> ponto flutuante
lucro = faturamento - custoAs linguagens de programação seguem o padrão do idioma inglês, então repare que o separador de casa decimal é o ponto e não a vírgula.
As variáveis também podem ser do tipo string, são variáveis de texto que armazenam mensagens ou informações textuais.
email = "[email protected]" # tipo: string -> textoE também temos as variáveis booleanas, do tipo bool, que representam verdadeiro (True) ou falso (False). Essas variáveis são muito úteis para construção de decisões lógicas dentro do código.
teve_lucro = True # tipo: bool -> booleanExistem outros tipos de variáveis, mas essas são as principais e mais básicas para você começar a aprender.
Como vimos com o cálculo do Lucro, é possível realizar operações matemáticas com Python. Podemos realizar todas as operações básicas utilizando os valores diretamente ou mesmo as variáveis definidas.
Por exemplo, vamos calcular a margem de lucro da empresa. Essa margem é obtida dividindo o lucro pelo faturamento.
faturamento = 1200 # tipo: int -> número inteiro
custo = 750.32 # tipo: float -> ponto flutuante
lucro = faturamento - custo
margem_lucro = lucro / faturamento
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)
print("A margem de lucro foi de ", margem_lucro)
Você pode estranhar os resultados do lucro e da margem de lucro, com todas essas casas depois da vírgula. Isso pode ser tratado e corrigido, mas é a forma como os computadores fazem as contas e deixam o arredondamento para última casa decimal, mesmo sendo uma conta simples.
Por enquanto, para evitar isso, vamos apenas alterar o custo para 750.0. Ele ainda será um número float, porém os resultados ficarão mais simples.
faturamento = 1200 # tipo: int -> número inteiro
custo = 750.0 # tipo: float -> ponto flutuante
lucro = faturamento - custo
margem_lucro = lucro / faturamento
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)
print("A margem de lucro foi de ", margem_lucro)
Vamos adicionar mais um cálculo agora que será o valor do imposto. Como o imposto vai impactar o valor do lucro, iremos adicioná-lo antes da variável lucro.
Considerando um imposto de 10% em cima do faturamento, vamos calcular esse valor pegando a variável faturamento e multiplicando por 0.1 (o mesmo que 10/100 ou 10%).
Sempre que quisermos trabalhar com porcentagem em Python e linguagens de programação como um todo, vamos utilizar o decimal referente.
Como o imposto impacta o lucro, além de subtrair do faturamento os custos, também iremos subtrair o imposto que acabamos de calcular.
faturamento = 1200 # tipo: int -> número inteiro
custo = 750.0 # tipo: float -> ponto flutuante
imposto = faturamento * 0.1
lucro = faturamento - custo - imposto
margem_lucro = lucro / faturamento
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)
print("A margem de lucro foi de ", margem_lucro)
Se tivéssemos calculado o imposto depois do cálculo do lucro, o Python nos retornaria um erro.
faturamento = 1200 # tipo: int -> número inteiro
custo = 750.0 # tipo: float -> ponto flutuante
lucro = faturamento - custo - imposto
imposto = faturamento * 0.1
margem_lucro = lucro / faturamento
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)
print("A margem de lucro foi de ", margem_lucro)
Repare que o sistema sinaliza a linha do erro e fornece uma mensagem especificando o que ocorreu de errado. Nesse caso, ele sinaliza que a variável imposto não está definida.
Isso porque como definimos a variável imposto após a variável lucro, e o Python executa os comandos de cima para baixo, ao tentar calcular o valor do lucro é como se o imposto não existisse ainda.
As variáveis recebem esse nome porque elas podem ser alteradas ao longo do código, permitindo que novos valores sejam atribuídos a elas.
Por exemplo, vamos supor que novas vendas foram feitas na empresa. Dessa forma, o faturamento da empresa não será mais apenas os 1200, mas sim os 1200 mais o valor das novas vendas, e podemos fazer essa atribuição ao longo do código.
faturamento = 1200 # tipo: int -> número inteiro
custo = 750.0 # tipo: float -> ponto flutuante
novas_vendas = 100
faturamento = faturamento + novas_vendas
imposto = faturamento * 0.1
lucro = faturamento - custo - imposto
margem_lucro = lucro / faturamento
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)
print("A margem de lucro foi de ", margem_lucro)Dessa forma, estamos definindo que a variável faturamento irá receber o antigo valor da variável faturamento mais o valor da variável novas_vendas. E isso irá impactar todos os cálculos posteriores que envolvem a variável faturamento.
Para finalizarmos essa primeira aula, vamos ver algumas operações menos comuns em Python, como o arredondamento de valores e o mod (resto da divisão).
Essas são operações menos comuns, mas que são essenciais e vão te ajudar a ampliar as possibilidades do que você pode fazer com Python.
Começando pelo arredondamento, podemos arredondar o valor da margem de lucro. Se observarmos nosso último exemplo, veremos que o resultado possui diversas casas decimais.
Para deixar esse valor com apenas duas casas decimais, podemos utilizar a função round, passando a variável margem_lucro e quantas casas decimais nós queremos.
faturamento = 1200 # tipo: int -> número inteiro
custo = 750.0 # tipo: float -> ponto flutuante
novas_vendas = 100
faturamento = faturamento + novas_vendas
imposto = faturamento * 0.1
lucro = faturamento - custo - imposto
margem_lucro = lucro / faturamento
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)
print("A margem de lucro foi de ", round(margem_lucro, 3))Você pode aplicar a função round dentro do print, como no exemplo acima, ou alterando a variável antes de printá-la.
faturamento = 1200 # tipo: int -> número inteiro
custo = 750.0 # tipo: float -> ponto flutuante
novas_vendas = 100
faturamento = faturamento + novas_vendas
imposto = faturamento * 0.1
lucro = faturamento - custo - imposto
margem_lucro = lucro / faturamento
margem_lucro = round(margem_lucro, 3)
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)
print("A margem de lucro foi de ", margem_lucro)Ambas as formas retornarão o mesmo resultado.
Vimos que para trabalhar com porcentagem devemos utilizar os números em decimais, ao invés de utilizar o símbolo de porcentagem %. E isso ocorre porque esse símbolo no Python é atribuído ao operador de Mod.
O mod é utilizado para calcular o resto de uma divisão. Por exemplo, o resto da divisão de 10 por 3, será 1. Para calcular isso com o mod, faremos 10 % 3.
print(10 % 3)
Em uma aplicação mais prática, por exemplo, podemos utilizá-lo para calcular o tempo de um contrato em anos e meses.
Vamos supor que temos um contrato de 170 meses e queremos saber quanto isso corresponde em anos e meses.
Para calcular o tempo em anos, podemos dividir o tempo total do contrato por 12. Como queremos apenas os anos inteiros, podemos colocar a variável tempo_anos dentro da função int, que transforma um valor em um número inteiro.
E usando o operador mod, podemos obter a quantidade de meses restantes.
tempo_contrato = 170
tempo_anos = tempo_contrato/12
tempo_meses = tempo_contrato % 12
print("Tempo em anos", int(tempo_anos))
print("Tempo em meses", tempo_meses)Executando esse código, teremos que o tempo de contrato é de 14 anos e 2 meses.
Apesar de ter sido um exemplo mais específico, o operador mod pode ser muito útil para resolução de determinados problemas práticos que você possa encontrar.
Na segunda aula do nosso Curso Básico de Python 2024, veremos como trabalhar com strings e funções de texto no Python.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Nesta aula do Curso Básico de Python, veremos como utilizar strings e funções de texto no Python.
As strings são dados do tipo texto dentro do Python e é muito importante que você saiba como tratar essas informações e utilizá-las corretamente dentro do seu código para que exibam a informação final corretamente.
Você verá como fazer a manipulação de textos no Python, utilizando operações de string, como encontrar elementos dentro de um texto, como pegar o tamanho dele, substituir um pedaço, pegar um caractere e assim por diante.
Então, faça o download do material disponível e vamos começar a segunda aula do nosso Curso de Python 2024.
A habilidade de trabalhar com textos em Python é fundamental para diversas tarefas dentro do Python e da programação em geral.
Muitas informações utilizadas dentro dessa área são baseadas em texto, exigindo que saibamos como tratar, lidar e trabalhar com esse tipo de dado.
Manipular textos de forma eficiente é crucial para exibir mensagens ao usuário e lidar com dados formatados textualmente.
Para começar, vamos dentro da pasta onde fizemos a aula 1 e criaremos um segundo arquivo para a aula 2.
Na aula passada, vimos como exibir um texto e, em seguida, os valores das variáveis correspondentes.
faturamento = 1000
custo = 700
lucro = faturamento - custo
print("O faturamento foi de ", faturamento)
print("O custo foi de ", custo)
print("O lucro foi de ", lucro)Mas e se quiséssemos exibir essas informações ao longo do texto? Como poderíamos fazer isso?
Existem duas formas de utilizarmos variáveis dinâmicas dentro de um texto, a f-string e a função format.
A função format é usada para formatar uma string substituindo os campos marcados por chaves {} pelos valores fornecidos a ela como argumentos.
faturamento = 1000
custo = 700
lucro = faturamento - custo
print('O faturamento da empresa: {}, Custo: {}, Lucro: {}'.format(faturamento, custo, lucro))
Observe que a função .format() fica fora das aspas da string, e os argumentos são passados na ordem que eles devem aparecer.
Outra abordagem possível para utilizarmos variáveis dinâmicas dentro do texto é através da f-string. Essa funcionalidade permite a formatação das strings de uma forma mais simples e direta que a função format().
Com as f-strings, você só precisa definir a letra f antes de iniciar a string e dentro dela informar as variáveis dentro de chaves onde elas deveriam ser exibidas.
faturamento = 1000
custo = 700
lucro = faturamento - custo
print(f'O faturamento da empresa: {faturamento}, Custo: {custo}, Lucro: {lucro}')Receba que o resultado é o mesmo, porém essa abordagem é mais direta.
Agora vamos partir para a manipulação de textos em Python. Existem algumas transformações básicas que podemos começar aplicando a um texto. A primeira delas é tornar todas as letras maiúsculas através do método upper.
email_cliente = '[email protected]'
email_cliente = email_cliente.upper()
print(email_cliente)
Podemos fazer o mesmo, só que para letra minúscula, nesse caso utilizamos o lower.
email_cliente = '[email protected]'
#Maiúscula:
email_cliente = email_cliente.upper()
print(email_cliente)
#Minúscula:
email_cliente = email_cliente.lower()
print(email_cliente)
Repare que primeiro ele printou o texto em letra maiúscula, depois transformou e exibiu novamente o e-mail todo em letra minúscula. Isso ocorre porque, como vimos, o Python é executado de forma sequencial de cima para baixo.
Outra ação muito comum quando estamos trabalhando com texto é a de localizar um elemento específico dentro dele. Por exemplo, podemos querer verificar se existe um @ dentro do e-mail para saber se o usuário preencheu o e-mail corretamente.
Para descobrir a posição que um elemento se encontra no texto, podemos utilizar o método find, que retorna a posição de um caractere dentro de uma string. O primeiro caractere será considerado de valor 0, o segundo terá o valor 1 e assim sucessivamente.
email_cliente = '[email protected]'
#Encontrar @
print(email_cliente.find('@'))
Caso você não tenha o elemento solicitado dentro do texto, o Python retornará como resposta o valor de -1. Essa é uma boa maneira de descobrir se um determinado caractere se encontra presente ou não em uma string.
email_cliente = 'qualquercoisaaleatoriogmail.com'
#Encontrar @
print(email_cliente.find('@'))
É possível determinar o tamanho de um texto dentro do Python, o comprimento dele em número de caracteres. Para isso, podemos usar a função len.
email_cliente = '[email protected]'
#Tamanho
print(len(email_cliente))
Isso é útil, por exemplo, em casos em que queremos pegar algum caractere dentro do texto, mas não conhecemos o tamanho dele.
Por exemplo, quando desejamos pegar algum caractere, utilizamos o nome da variável que armazena a string, seguida de colchetes e o número correspondente ao índice do caractere desejado.
email_cliente = '[email protected]'
#Tamanho
print(len(email_cliente))
#Pegar Caractere
print(email_cliente[22])
Isso acontece porque em Python, um texto é tratado como uma lista de caracteres, permitindo-nos acessar caracteres individuais através dos índices.
Se passarmos o valor do índice como sendo negativo, o Python começará a contar de trás para frente os caracteres.
email_cliente = '[email protected]'
#Tamanho
print(len(email_cliente))
#Pegar Caractere
print(email_cliente[22])
print(email_cliente[-1])
Nas próximas aulas, abordaremos mais a fundo o conceito de listas em Python.
Além de acessar caracteres isolados, é possível extrair pedaços maiores do texto utilizando índices e definindo um intervalo entre esses índices através dos dois pontos.
email_cliente = '[email protected]'
#Tamanho
print(len(email_cliente))
#Pegar Caractere
print(email_cliente[22])
print(email_cliente[-1])
#Pegar parte do Texto:
print(email_cliente[:22])Observe que ele pegou todo o texto até o @, mas não incluindo o @. Isso acontece porque ao usar uma fatia do índice, o Python não considera o valor final; ele pega do primeiro valor definido até o caractere anterior ao valor final.
Como não definimos um valor inicial para a fatia, ele pega a partir do caractere inicial. Mas poderíamos passar um valor para iniciarmos a fatia do nosso texto.
email_cliente = '[email protected]'
#Tamanho
print(len(email_cliente))
#Pegar Caractere
print(email_cliente[22])
print(email_cliente[-1])
#Pegar parte do Texto:
print(email_cliente[:22])
print(email_cliente[12:22])
E caso você queira pegar o texto de um determinado ponto até o final dele, você pode passar o índice inicial e deixar o índice final em branco.
email_cliente = '[email protected]'
#Tamanho
print(len(email_cliente))
#Pegar Caractere
print(email_cliente[22])
print(email_cliente[-1])
#Pegar parte do Texto:
print(email_cliente[:22])
print(email_cliente[12:22])
print(email_cliente[22:])
Além de todas essas modificações que aprendemos, é possível também substituir um trecho específico do texto por outro. Vamos supor que queremos trocar o servidor do nosso e-mail.
Para fazer isso, podemos utilizar o método replace passando como primeiro argumento o trecho a ser substituído e em seguida o novo valor que o substituirá.
email_cliente = '[email protected]'
novo_email = email_cliente.replace('gmail.com', 'hotmail.com')
print(email_cliente)
print(novo_email)
Observe que o email_cliente que nós criamos continua como foi definido, mas o novo_email que criamos em sequência tem o servidor de e-mail alterado para Hotmail.
Se quiséssemos alterar o email_cliente, teríamos que, em vez de definir novo_email, atualizar o próprio email_cliente, dessa forma:
email_cliente = email_cliente.replace('gmail.com', 'hotmail.com')Além dos métodos convencionais, como upper e lower, existem funções muito úteis para formatação especial de textos no Python, como o capitalize e o title.
A função capitalize torna a primeira letra maiúscula e mantém as demais minúsculas, enquanto o title deixa a primeira letra de cada palavra maiúscula e as demais em minúscula.
nome = 'joão lira'
print(nome.capitalize())
print(nome.title())
Agora que já vimos algumas das principais formas de trabalharmos e manipularmos textos com Python, vamos resolver alguns exercícios práticos. Você pode tentar resolver primeiro sozinho e depois comparar a sua resolução com a minha.
Primeiro Exercício:
Dada a variável abaixo:
email_cliente = '[email protected]'Extraia o servidor do e-mail do cliente e separe o primeiro nome do sobrenome.
Solução:
Para extrair o servidor do e-mail, usamos o método find() para identificar a posição do caractere “@” na variável email_cliente.
Em seguida, armazenamos essa posição em uma variável para usá-la como índice inicial em uma fatia da string.
email_cliente = '[email protected]'
#Servidor do E-mail
posicao_arroba = email_cliente.find('@')
servidor = email_cliente[posicao_arroba:]
print(servidor)Dessa forma, teremos como resultado o servidor do e-mail.
Caso quiséssemos excluir o @ da exibição, bastaria passar como posição inicial da string a variável posicao_arroba + 1.
#Servidor do E-mail
posicao_arroba = email_cliente.find('@')
servidor = email_cliente[posicao_arroba + 1:]
print(servidor)
Segundo Exercício:
A partir da variável nome, extraia o primeiro nome e o sobrenome do usuário.
nome = 'João Lira'Solução:
Para extrair o primeiro nome e sobrenome do usuário, identificamos a posição do espaço na string usando o método find().
Com a posição do espaço determinada, o primeiro nome pode ser obtido do início da string até a posição do espaço.
O sobrenome pode ser obtido da posição após o espaço (a posição do espaço +1) até o final da string.
nome = 'João Lira'
#Pegar posição do espaço:
posicao_espaco = nome.find(' ')
#Exibir o primeiro nome:
primeiro_nome = nome[:posicao_espaco]
print(primeiro_nome)
#Exibir o sobrenome:
sobrenome = nome[posicao_espaco + 1:]
print(sobrenome)
Para finalizar essa aula, vamos falar dos casos especiais envolvendo a formatação numérica dentro do texto.
Na aula passada, aprendemos a calcular a margem de lucro de uma empresa. Vamos visualizar essa variável dentro de uma string.
faturamento = 1200
custo = 700
lucro = faturamento - custo
margem = lucro/faturamento
margem = round(margem, 2)
print(f'O faturamento da empresa: {faturamento}, Custo: {custo}, Lucro: {lucro}, Margem: {margem}')
Ela está sendo exibida corretamente como 0.42 porque fizemos o arredondamento dela antes do print. Porém, imagine que você queira apresentá-la como uma porcentagem, e não como um número decimal.
Para isso, podemos formatar essa variável numérica. Como já estamos utilizando a f-string, basta adicionarmos dois pontos após o nome da variável e definir o código de formatação que queremos.
Nesse caso, como queremos exibir esse valor como porcentagem e com 0 casas decimais, utilizamos o seguinte código de formatação :.0%
faturamento = 1200
custo = 700
lucro = faturamento - custo
margem = lucro/faturamento
margem = round(margem, 2)
print(f'O faturamento da empresa: {faturamento}, Custo: {custo}, Lucro: {lucro}, Margem: {margem:.0%}')Os dois pontos é o que indica que iremos formatar essa variável, o ponto seguido de um número indica a quantidade de casas decimais, e o símbolo de porcentagem indica que queremos exibir esse valor como um número percentual.
O mesmo poderia ser feito se quiséssemos exibir o restante dos valores como moedas. Para isso, adicionaríamos o R$ como texto fora da variável, e formataríamos o restante das variáveis com o código :.2f
faturamento = 1200
custo = 700
lucro = faturamento - custo
margem = lucro/faturamento
margem = round(margem, 2)
print(f'O faturamento da empresa: R${faturamento:.2f}, Custo: R${custo:.2f}, Lucro: R${lucro:.2f}, Margem: {margem:.0%}')Nesse caso, estamos definindo que queremos formatar o valor dessas variáveis com duas casas decimais e como um número float, por isso utilizamos o f.
A princípio, essa formatação especial pode parecer um pouco confusa, mas você não precisa decorar esses códigos de formatação. O importante é compreender o que está sendo feito, e com a prática e o tempo você acabará decorando e compreendendo essas etapas de forma mais fácil e fluida.
Chegamos à terceira aula do Curso Básico de Python 2024! Nessa aula, iremos falar sobre inputs e listas no Python!
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Você sabe o que são inputs no Python? Sabe como funcionam as listas e quais métodos podemos utilizar com elas?
Então, nesta aula, eu vou te mostrar o que são os inputs, como utilizá-los para enviar informações para o seu código e armazená-las em variáveis.
Além disso, veremos como funcionam as listas Python e como trabalhar com elas, utilizando os métodos adequados para pegar valores, adicionar ou remover itens, verificar o tamanho da lista e muito mais.
Então, faça o download do material disponível e vamos começar a terceira aula do curso básico de Python 2024.
Para começar, na mesma pasta onde fizemos as aulas 1 e 2, vamos criar um arquivo para a aula 3.
Os inputs são o que permitem que o seu código solicite informações ao usuário. Existem algumas formas de interagir com o usuário e solicitar alguma entrada por parte dele, mas a forma mais simples e direta é através da função input().
Quando utilizamos essa função em um programa, o código pausa sua execução e aguarda até que o usuário insira algum valor.
Ao utilizar essa função, podemos passar como parâmetro um texto que serve como orientação ao usuário sobre que tipo de dado ele deve inserir. Por exemplo, podemos pedir para o usuário inserir o e-mail.
input("Escreva seu e-mail")Executando esse código, no terminal do editor de códigos, irá aparecer a mensagem e permitir que o usuário digite o e-mail dele.
No entanto, repare que a frase e o e-mail ficaram grudados porque o Python não insere um espaço automaticamente. Então, para evitar que fique assim, eu prefiro, ao passar um input, deixar um espaço ao final.
input("Escreva seu e-mail: ")
Assim, na hora de visualizar as informações, temos a mensagem do input separada da entrada do usuário.
Além de apenas visualizar ali, no momento que o usuário insere essa informação no terminal, as respostas dos inputs podem ser armazenadas em variáveis, permitindo a manipulação delas.
email = input("Escreva seu e-mail: ")
nome = input("Seu primeiro nome: ")
print(nome, email)Executando esse código, teremos de primeiro preencher o e-mail, depois o nome, e por fim, o Python irá imprimir o nome e o e-mail.
Também podemos utilizar essas variáveis de forma dinâmica como aprendemos na aula passada:
email = input("Escreva seu e-mail: ")
nome = input("Seu primeiro nome: ")
print(f'{nome}, verifique seu e-mail: {email} que enviamos um link de confirmação')
Um cuidado que precisamos tomar quando estamos trabalhando com input é que o resultado de um input sempre será do tipo texto.
Logo, se você quiser pegar uma informação inserida através de um input do usuário para realizar cálculos matemáticos dentro do seu código, é necessário que antes você converta esse valor para um formato numérico.
Caso você tente usar o valor do input sem nenhuma conversão antes, você cairá em um erro.
faturamento = input("Escreva o faturamento: ")
imposto = faturamento * 0.1
print(imposto)
Caso o input que você deseja receber do usuário seja um número, você precisa passar todo o input ou a variável que armazenará esse input dentro de uma função float() ou int() para converter a entrada do usuário do formato de texto para número.
faturamento = float(input("Escreva o faturamento: "))
imposto = faturamento * 0.1
print(imposto)
Agora que já vimos como funcionam os inputs no Python, vamos falar um pouco sobre as listas. As listas são estruturas de dados no Python que nos permitem armazenar uma coleção ordenada de itens.
Os itens em uma lista podem ser de diferentes tipos, como números inteiros, ponto flutuante, strings, e assim por diante. Eles podem ser acessados e manipulados de diversas formas.
As listas em Python são definidas utilizando colchetes [], e os itens da lista são separados por vírgulas. Por exemplo, podemos armazenar as vendas de uma loja.
vendas = [100, 50, 14, 20, 30, 700]
print(vendas)
As listas são estruturas mutáveis dentro do Python, o que significa que podemos adicionar, remover ou mesmo modificar os itens dentro dela após a criação.
Além disso, podemos utilizar algumas funções e métodos combinados com as listas, que tornam certas tarefas muito mais práticas. Vamos ver algumas delas!
Mantendo esse exemplo das vendas, podemos utilizar a função sum() para calcular a soma de todas as vendas presentes na lista.
vendas = [100, 50, 14, 20, 30, 700]
total_vendas = sum(vendas)
print(total_vendas)
Outra função que podemos aplicar em uma lista é a função len() que vimos na aula passada.
Podemos utilizá-la para determinar o tamanho de uma lista, ou seja, quantos elementos estão presentes nela. Por exemplo, podemos verificar quantas vendas foram cadastradas.
vendas = [100, 50, 14, 20, 30, 700]
quantidade_vendas = len(vendas)
print(quantidade_vendas)
Outras funções que podemos utilizar com listas são as funções max() e min(), que retornam o maior e o menor valor de uma lista, respectivamente.
vendas = [100, 50, 14, 20, 30, 700]
print(max(vendas))
print(min(vendas))
Outra funcionalidade das listas que é bastante intuitiva e já vimos como funciona na aula anterior, sobre textos no Python, são os índices.
Assim como com strings, podemos utilizar os índices em Python para acessar elementos individuais da lista. Começando com o índice 0 que acessa o primeiro elemento da lista e aumentando em 1 para cada elemento presente.
vendas = [100, 50, 14, 20, 30, 700]
print(vendas[0])
print(vendas[-1])
E da mesma forma, podemos utilizar o fatiamento de listas, passando intervalos de índices.
vendas = [100, 50, 14, 20, 30, 700]
print(vendas[1:3])
print(vendas[4:])
Além de acessar os elementos de uma lista através do índice, podemos verificar se um determinado elemento existe em uma lista.
Por exemplo, vamos definir uma lista de produtos Apple e queremos determinar se um determinado produto existe nessa lista.
Para isso, podemos utilizar o operador in. Esse operador é usado quando queremos verificar se um determinado elemento está presente em uma sequência.
O resultado dessa operação é True, caso o elemento esteja presente, ou False, caso não esteja.
lista_produtos = ["iphone", "airpod", "ipad","macbook"]
print("iphone" in lista_produtos)
print("apple watch" in lista_produtos)
Aqui podemos combinar alguns conhecimentos que vimos nas aulas passadas com o desta aula para resolver uma questão. Imagine que o usuário precisa inserir o produto procurado e informa o nome dele todo em letra maiúscula.
lista_produtos = ["iphone", "airpod", "ipad","macbook"]
produto_procurado = input('Pesquise pelo nome do produto: ')
print(produto_procurado in lista_produtos)
Perceba que ao digitar “IPHONE”, o resultado retornado foi False. Isso ocorre porque para o Python existe diferença entre maiúsculas e minúsculas. Por isso, mesmo com o produto existindo na lista, o resultado retornado foi False.
Para solucionar esse problema, podemos utilizar o método lower() para converter a entrada do usuário (o input) para letra minúscula. Dessa forma, tanto o produto_procurado quanto a lista_produtos estarão em minúsculas.
Isso garante a consistência das comparações e evita receber um resultado incorreto.
lista_produtos = ["iphone", "airpod", "ipad","macbook"]
produto_procurado = input('Pesquise pelo nome do produto: ')
print(produto_procurado.lower() in lista_produtos)
Para adicionar um item a uma lista em Python, você pode usar o método append(), que adiciona o item especificado ao final da lista.
É importante notar que a lista é modificada in-place, o que significa que a alteração ocorre diretamente na lista original, sem a necessidade de atribuir uma cópia dela mesma, como fazemos com os textos.
Por exemplo, para adicionar o apple watch à nossa lista, podemos fazer da seguinte forma:
lista_produtos = ["iphone", "airpod", "ipad","macbook"]
lista_produtos.append("apple watch")
print(lista_produtos)
Para remover um item da lista, é muito semelhante ao processo de adicionar, mas ao invés de utilizar o método append(), utilizamos o remove().
lista_produtos = ["iphone", "airpod", "ipad","macbook", "apple watch"]
lista_produtos.remove("apple watch")
print(lista_produtos)
Outra forma de remover um elemento da sua lista é utilizando o método pop(), porém para ele, ao invés de passar o nome do item, você informa o índice correspondente.
lista_produtos = ["iphone", "airpod", "ipad","macbook", "apple watch"]
lista_produtos.pop(-1)
print(lista_produtos)
Além de adicionar e remover o item de uma lista, nós podemos também editar o elemento de uma lista, atribuindo um novo valor ao índice desejado.
precos = [1000, 1500, 3000]
precos[0] = 6000
print(precos)
Outro método muito útil quando estamos trabalhando com listas é o count(). Ele permite contar quantas vezes um determinado item aparece na lista.
lista_produtos = ["iphone", "airpod", "ipad","macbook", "iphone", "ipad", "iphone"]
print(lista_produtos.count("iphone"))
Perceba que só precisamos passar qual o item procurado e ele retorna quantas vezes esse item se encontra na nossa lista de produtos.
Para finalizar, vamos aprender como ordenar os elementos dentro de uma lista. Para isso, utilizaremos o método sort(). Esse método te permite organizar os itens de uma lista em ordem crescente.
lista_produtos = ["iphone", "airpod", "ipad","macbook", "iphone", "ipad", "iphone"]
lista_produtos.sort()
print(lista_produtos)
Ou em ordem decrescente com o parâmetro reverse=True.
lista_produtos = ["iphone", "airpod", "ipad","macbook", "iphone", "ipad", "iphone"]
lista_produtos.sort(reverse=True)
print(lista_produtos)
Na quarta aula do curso básico de Python 2024, vamos abordar as condições em Python. Isto é, vamos explorar a estrutura if no Python, compreendendo seu funcionamento e a lógica por trás de sua utilização.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na aula de hoje, quero mostrar como trabalhar com condições no Python. Vamos aprender a utilizar a estrutura condicional If, entender a lógica por trás dela e como aplicá-la em seus códigos.
Essa é uma estrutura fundamental, presente na maioria dos seus programas. Vamos explorar como usá-la para lidar com uma única condição, múltiplas condições e até mesmo condições simultâneas.
Então, faça o download do material disponível e vamos começar a quarta aula do nosso curso básico de Python 2024.
A estrutura if no Python permite que partes específicas do código sejam executadas somente quando uma determinada condição for avaliada como verdadeira. A sintaxe básica do if é a seguinte:
if condição/comparação:
#Código que será executado se a condição for verdadeiraEm conjunto com o if, podemos utilizar a estrutura else (senão). O else é utilizado para determinar o que deve acontecer caso a condição determinada pelo if não seja atendida.
if condição/comparação:
#Código que será executado se a condição for verdadeira
else:
#Código que deve ser executado caso a condição seja falsaVamos ver alguns exemplos de aplicação dessa estrutura para que você possa compreender melhor. Para isso, crie um arquivo Python para a aula 4 na mesma pasta em que você tem trabalhado com os arquivos anteriores.
Ao trabalharmos com condições no Python, é muito comum utilizarmos os operadores de comparação. Esses operadores são empregados para comparar dois valores e determinar se a relação entre eles é verdadeira ou falsa.
Entre os principais comparadores, vamos encontrar os seguintes:
Para visualizarmos como essa estrutura funciona, vamos ver um exemplo prático. Digamos que queremos calcular o bônus de um funcionário. Caso o funcionário tenha atingido a meta desejada, ele deve receber um bônus; caso contrário, não.
vendas = 1500
meta = 1300
if vendas >= meta:
print("Vendedor ganha bônus")
Observe que o bloco de código que será executado caso a condição determinada no if seja verdadeira precisa estar indentado corretamente. Perceba que o print fica dentro do nosso if com 4 espaços ou 1 tab de espaçamento.
Caso a meta não tenha sido atingida, não teríamos nenhuma mensagem sendo exibida.
vendas = 1500
meta = 2000
if vendas >= meta:
print("Vendedor ganha bônus")
Mas não é muito interessante apenas não exibirmos nada nesse caso. Podemos utilizar a estrutura else para imprimir uma mensagem caso o vendedor não tenha atingido o bônus.
O else deve ficar alinhado com o if, e o bloco de código que deve ser executado caso a condição do if não seja atendida deve ficar indentado dentro do else.
Então, caso o vendedor tenha batido a meta, teremos uma parte do código sendo executada:
vendas = 1500
meta = 1300
if vendas >= meta:
print("Vendedor ganha bônus")
print("Bateu a meta de vendas")
bonus = 0.1 * vendas
print(f"Bônus do vendedor: {bonus}")
else:
print("Vendedor não ganha bônus")
print("Não bateu a meta de vendas")
E caso contrário, teremos outra parte:
vendas = 1500
meta = 2000
if vendas >= meta:
print("Vendedor ganha bônus")
print("Bateu a meta de vendas")
bonus = 0.1 * vendas
print(f"Bônus do vendedor: {bonus}")
else:
print("Vendedor não ganha bônus")
print("Não bateu a meta de vendas")
Se após o if e o else definíssemos outra linha de código alinhada a eles, essa linha seria executada independentemente da situação:
vendas = 1500
meta = 1300
if vendas >= meta:
print("Vendedor ganha bônus")
print("Bateu a meta de vendas")
bonus = 0.1 * vendas
print(f"Bônus do vendedor: {bonus}")
else:
print("Vendedor não ganha bônus")
print("Não bateu a meta de vendas")
print("Acabou o programa")
Ou seja, quando o Python encontrar uma linha de código que não está mais indentada dentro do if ou do else, ele entenderá que aquela parte deve ser executada independentemente da condição e continuará normalmente.
É possível utilizar a estrutura if para lidar com várias condições. Por exemplo, podemos considerar um cenário em que para cada faixa de bônus há uma meta de vendas específica que precisa ser atingida.
Para realizarmos o cálculo desse bônus para o funcionário, podemos adaptar a nossa estrutura if-else.
vendas = 1500
meta1 = 1300 #Ganha 10% de bônus
meta2 = 2000 #Ganha 13% de bônus
if vendas >= 2000:
bonus = vendas * 0.13
else:
if vendas >= 1300:
bonus = vendas * 0.1
else:
bonus = 0
print("Bônus: ", bonus)Como o Python executa o código de cima para baixo, neste caso, primeiro verificamos se as vendas são maiores ou iguais a 2000. Se sim, o vendedor recebe 13% de bônus (vendas * 0.13).
Caso contrário, o código verifica se as vendas são maiores ou iguais a 1300. Em caso positivo, o vendedor ganha 10% de bônus (vendas * 0.1); caso contrário, não recebe nenhum bônus.
Executando o código, teremos como resultado:
Perceba que isso só é possível pela forma como o Python executa os códigos e pela indentação correta. O segundo if e else estão indentados dentro do primeiro else.
Outra estrutura condicional no Python que podemos utilizar junto com o if é o elif. O elif é uma abreviação de “else if”. Sua função é semelhante à de usar um else com um if dentro, como fizemos anteriormente.
Utilizamos o elif para verificar uma segunda condição caso a condição estabelecida no if não seja atingida.
Podemos ter quantos elifs quisermos dentro de um código, e quando a condição em um elif for atingida, o Python executará o bloco de código correspondente.
vendas = 1500
meta1 = 1300 #Ganha 10% de bônus
meta2 = 2000 #Ganha 13% de bônus
if vendas >= 2000:
bonus = vendas * 0.13
elif vendas >= 1300:
bonus = vendas * 0.1
else:
bonus = 0
print("Bônus: ", bonus)
Visto isso, podemos aprimorar o exercício que vimos na aula passada de verificar se um produto estava presente no estoque da empresa.
lista_produtos = ["airpod", "ipad", "iphone", "macbook"]
produto_procurado = input("Procure um produto: ")
produto_procurado = produto_procurado.lower()
if produto_procurado in lista_produtos:
print("Produto no estoque")
else:
print("Não temos esse produto")Observe que dentro do if podemos utilizar quaisquer operadores de condição ou comparação, desde que a análise criada retorne True (Verdadeiro) ou False (Falso).
Podemos executar esse código e teremos o resultado esperado:
Por fim, é possível verificarmos mais de uma condição ao mesmo tempo. Por exemplo, conceder o bônus ao funcionário apenas se ele e a empresa tiverem batido a meta.
Para esse caso, utilizaremos o operador lógico and. O and é utilizado para combinar duas verificações, sendo lido como “e”:
If condição1 and condição2Nesse caso, para verificar se o vendedor e a empresa bateram a meta, poderíamos fazer o seguinte:
vendas = 2100
vendas_empresa = 10000
meta_empresa = 20000
meta1 = 1300 #Ganha 10% de bônus
meta2 = 2000 #Ganha 13% de bônus
if vendas >= 2000 and vendas_empresa >= meta_empresa:
bonus = vendas * 0.13
elif vendas >= 1300 and vendas_empresa >= meta_empresa:
bonus = vendas * 0.1
else:
bonus = 0
print("Bônus: ", bonus)
Observe que esse funcionário não recebeu bônus. Isso ocorre porque, apesar de ele ter vendido acima da meta, as vendas da empresa não foram atingidas. A condição só retornará verdadeira quando as vendas forem maiores do que a meta e as vendas da empresa também forem maiores do que a meta da empresa.
Outro operador lógico que pode ser utilizado é o or. Nesse caso, ele considera se uma ou outra condição foi atingida.
vendas = 2100
vendas_empresa = 10000
meta_empresa = 20000
meta1 = 1300 #Ganha 10% de bônus
meta2 = 2000 #Ganha 13% de bônus
if vendas >= 2000 or vendas_empresa >= meta_empresa:
bonus = vendas * 0.13
elif vendas >= 1300 or vendas_empresa >= meta_empresa:
bonus = vendas * 0.1
else:
bonus = 0
print("Bônus: ", bonus)
Vamos para a quinta aula do curso básico de Python 2024! Nessa aula, veremos como funciona a estrutura de repetição For no Python. É uma estrutura importante que pode ser aplicada quando precisamos repetir um bloco de código.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na nossa quinta aula, vou te ensinar como funciona a estrutura de repetição For no Python, uma ferramenta muito útil para diversas situações.
A ideia por trás dessa estrutura é nos auxiliar sempre que precisarmos repetir um bloco de código. Em vez de fazer isso manualmente, repetindo linhas e linhas de código, podemos utilizar o loop For.
Portanto, faça o download do material desta aula e vamos ver na prática como essa estrutura de repetição é simples e pode te ajudar muito nos seus códigos!
O for no Python é utilizado para realizar repetições de códigos, sendo uma estrutura essencial para automatizar tarefas que precisam ser executadas diversas vezes em loop.
Essa estrutura de repetição nos permite iterar sobre uma sequência de elementos, como listas, tuplas, strings ou qualquer outro objeto iterável, permitindo realizar operações para cada elemento presente.
Basicamente, existem duas formas principais de utilizarmos o for: for i in range e for item in lista, sendo esta última a mais comum na prática.
O for i in range nos permite especificar quantas vezes um código deve ser executado. O i funcionará como um contador que irá armazenar cada valor da sequência gerada pela função range.
A função range é responsável por gerar uma sequência de números que, por padrão, começa no 0 e vai até o número especificado.
Portanto, quando definimos algo como for i in range(10), estamos criando um loop que irá iterar 10 vezes. Ou seja, repetirá o código contido dentro dele por 10 vezes.
for i in range(10):
print("Se inscreve no canal")
Essa abordagem acaba sendo mais utilizada quando você já sabe quantas vezes o código precisa ser executado.
O for item in lista acaba sendo a abordagem mais comum e mais utilizada da estrutura for.
Isso ocorre porque, nesse caso, o código será repetido de acordo com a quantidade de elementos presentes no objeto iterável (lista, tupla, string, dicionário, etc.), em que cada item representa um desses elementos.
Dessa forma, você não precisa conhecer previamente a quantidade de vezes que irá executar o código, apenas definir qual ação você deseja realizar para cada elemento presente.
lista_vendas = [1000, 500, 800, 1500, 2000, 2300]
meta = 1200
percentual_bonus = 0.1
for item in lista_vendas:
print(item)
Repare que o código printou cada um dos valores presentes na lista_vendas. Isso ocorre porque a variável item armazena cada um dos valores presentes a cada iteração feita.
Essa variável pode receber o nome que quisermos, mas geralmente optamos por um nome que seja intuitivo de acordo com o que estivermos trabalhando. Por exemplo, nesse caso, poderíamos chamar de venda.
E dentro desse loop for, podemos definir quantas linhas de código quisermos que sejam repetidas.
lista_vendas = [1000, 500, 800, 1500, 2000, 2300]
meta = 1200
percentual_bonus = 0.1
for venda in lista_vendas:
print(f"Valor da venda: {venda}")
print("Próximo item")
Agora vamos resolver um exercício prático utilizando a estrutura do For. Dada a lista de vendas anterior, precisamos calcular o bônus para cada uma delas, de acordo com a meta estabelecida.
Antes de já pensar como incluir as operações e cálculos dentro do for, podemos primeiro realizar isso para um único item e depois adaptar para a estrutura de repetição.
Então vamos fazer esse cálculo de bônus para o primeiro valor. Para isso, precisamos verificar se o valor da venda é igual ou maior que a meta estabelecida. Se for, o bônus será o percentual_bonus vezes o valor da venda. Caso contrário, será 0.
venda = 1000
if venda >= meta:
bonus = percentual_bonus * venda
else:
bonus = 0
print(bonus)Perceba que aqui, aplicamos a estrutura do if-else, vista na aula anterior. Executando esse código, teremos o valor do bônus sendo exibido.
Com o código funcionando corretamente para um item, podemos adaptá-lo para o for.
lista_vendas = [1000, 500, 800, 1500, 2000, 2300]
meta = 1200
percentual_bonus = 0.1
for venda in lista_vendas:
if venda >= meta:
bonus = percentual_bonus * venda
else:
bonus = 0
print(bonus)Executando esse código, teremos o bônus sendo exibido para cada uma das vendas.
Perceba como já estamos integrando os conhecimentos aprendidos nas aulas anteriores para ir construindo códigos cada vez mais completos.
Na sexta aula do nosso curso básico de Python de 2024, vamos abordar os dicionários e estruturas de dados no Python.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Nesta aula, vou explicar o conceito dos dicionários e das estruturas de dados no Python. Vamos entender como os dicionários funcionam, qual sua finalidade e quando devemos utilizá-los em nossos códigos.
Você aprenderá como acessar informações nos dicionários, como editar elementos dentro deles, calcular a quantidade de itens presentes e muito mais.
Faça o download do material disponível e vamos começar a sexta aula do nosso curso básico de Python de 2024.
Um dicionário em Python é uma estrutura de dados composta por chaves e valores. Os dicionários são coleções não ordenadas, ou seja, cada vez que são criados, os dados neles podem se apresentar em outra ordem.
Para acessar um elemento de um dicionário, utilizamos o par chave-valor, em que cada chave é única e usada para recuperar o valor correspondente.
Os dicionários no Python são muito úteis para armazenar dados de forma associativa, em que cada valor corresponde a um elemento específico. Isso nos permite acessar informações rapidamente através de uma chave específica.
Vamos ver o exemplo de uma loja que possui uma lista de produtos e seus respectivos preços. Se trabalhássemos apenas com listas, teríamos uma lista de produtos e uma lista de preços.
lista_produtos = ["airpod", "ipad", "iphone", "macbook"]
precos = [2000, 9000, 6000, 11000]Para associar cada produto com seu preço correspondente, não podemos alterar a ordem de nenhuma das duas listas, pois a única coisa que relaciona um produto com seu valor é o índice pelo qual estão organizados em ambas as listas.
lista_produtos = ["airpod", "ipad", "iphone", "macbook"]
precos = [2000, 9000, 6000, 11000]
print(f"Produto: {lista_produtos[1]} - Preço: {precos[1]}")
Se em algum momento ordenarmos a lista de preços ou de produtos de outra forma, essa associação pelo índice não será mais efetiva.
lista_produtos = ["airpod", "ipad", "iphone", "macbook"]
precos = [2000, 9000, 6000, 11000]
precos.sort()
print(f"Produto: {lista_produtos[1]} - Preço: {precos[1]}")
Ao ordenar os preços com o método sort(), o valor referente ao índice 1 da lista de preços passou a ser o de 6000 e não o de 9000. Com isso, a lista de produtos precisaria ser reordenada para que a correspondência fosse mantida.
Nesse caso, o ideal seria utilizarmos a estrutura de um dicionário. O dicionário não utiliza índices numéricos para acessar os elementos, mas sim os pares chaves-valor. Ou seja, dentro do dicionário, podemos relacionar cada produto com seu preço correspondente.
Para criar um dicionário, iremos declará-lo entre chaves, com a sintaxe de “chave”: valor, separando cada chave-valor por vírgula.
dicionario_python = {"chave": valor, "chave2": valor2}Ou seja, poderíamos criar nosso dicionário tendo os produtos como chaves e os preços como valores.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}Dessa forma, em uma única estrutura temos todas as informações desejadas, e sem correr o risco de o valor não ser associado corretamente ao seu produto, pois as informações são armazenadas em pares correspondentes.
E uma chave pode ter como valor associado uma lista de informações. Por exemplo, ao invés de apenas ter o preço, nosso dicionário pode armazenar uma lista com o preço e a capacidade do aparelho.
dic_produtos = {"airpod": [2000, 0], "ipad": [9000, 128], "iphone": [6000, 256], "macbook": [11000, 500]}No nosso caso, vamos continuar apenas com o nome e o preço do produto.
Para acessar um valor específico em um dicionário, basta passar o nome da chave desejada entre colchetes. Por exemplo, se quisermos verificar o preço do iPad.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
print(dic_produtos["ipad"])
Só precisamos alterar a chave de acordo com o produto que queremos verificar o valor.
Para editar o elemento em um dicionário, basta passar o nome da chave que você deseja modificar e atribuir um novo valor a ela. Vamos aumentar o preço do iPhone em 30%, ou seja, multiplicaremos o valor antigo por 1.3.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
dic_produtos["iphone"] = dic_produtos["iphone"] * 1.3
print(dic_produtos)
Observe que agora o valor contido para o iPhone é de 7800 ao invés de 6000.
Alguns métodos que já aprendemos anteriormente também podem ser aplicados aos dicionários, como o método len(). Com ele, podemos saber quantos elementos estão presentes no dicionário.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
print(len(dic_produtos))
Perceba que são considerados elementos o conjunto de chave e valor, então temos 4 elementos dentro desse dicionário.
Para remover um elemento do dicionário, iremos utilizar o método pop(), semelhante ao que fazíamos com as listas. Nesse caso, ao invés de passar o índice do elemento que desejamos remover, passamos a chave correspondente.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
dic_produtos.pop("airpod")
print(dic_produtos)
Já para adicionarmos um elemento, utilizaremos um método similar ao de editar, definimos o nome da chave do dicionário que queremos adicionar e o valor correspondente.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
dic_produtos["apple watch"] = 2500
print(dic_produtos)
Ou seja, se dentro do nosso dicionário já existisse uma chave referente ao “apple watch”, ele atualizaria o valor. Como a chave ainda não existe, ela é criada com o valor atribuído.
Isso ocorre porque, diferente das listas, os dicionários não permitem elementos duplicados, cada chave deve ser única.
Dentro do nosso dicionário, podemos verificar se um item existe buscando pela chave dele.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
if "iphone" in dic_produtos:
print("Existe o produto")
else:
print("Não existe")
Se tentarmos realizar a mesma busca passando o valor no lugar da chave, o Python não irá encontrar o elemento desejado.
if 2000 in dic_produtos:
print("Existe o produto")
else:
print("Não existe")
Para verificar se um determinado valor está presente no dicionário, podemos utilizar o método .values(). Este método retorna uma lista com todos os valores contidos dentro do dicionário. Então, faríamos a verificação dessa forma:
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
if 2000 in dic_produtos.values():
print("Existe")
else:
print("Não existe")
Vamos fazer alguns exercícios utilizando os dicionários e outros conceitos aprendidos anteriormente.
1º Exercício – Cadastro de Produtos
Para o primeiro exercício, vamos criar um cadastro de produtos. Utilizaremos o nosso dicionário de produtos existente:
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}O programa deve solicitar ao usuário o nome e o preço do produto. Caso o produto não exista, ele deve registrar esse produto no dicionário de produtos. Caso contrário, ou seja, caso o produto exista, ele deve atualizar os preços.
Você pode tentar construir esse programa sozinho, para praticar os conceitos aprendidos até o momento, e depois verificar a resolução abaixo.
Resolução Exercício 1:
Para cadastrar um novo produto e seu preço, começaremos solicitando dois inputs ao usuário: um para o nome do produto e outro para o preço.
Como nosso dicionário registra todos os produtos em letra minúscula, vamos garantir que a entrada do usuário seja convertida para minúsculas usando o método lower(). Além disso, converteremos o valor inserido para o preço do produto em um tipo float.
Por fim, registraremos esse produto no nosso dicionário, utilizando o nome do produto como chave e o preço do produto como valor. Assim, as informações serão referentes aos dados preenchidos pelo usuário.
Ao final, podemos printar o resultado do dicionário.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
#Inserindo as informações:
nome_produto = input("Nome do produto: ")
preco_produto = input("Preço do produto: ")
#Deixando o nome do produto em letra minúscula:
nome_produto = nome_produto.lower()
#Convertendo o preço para float:
preco_produto = float(preco_produto)
#Registrando o Produto:
dic_produtos[nome_produto] = preco_produto
print(dic_produtos)Vamos registrar o AirPod Max como exemplo, com o valor de 3500.
Se tentássemos cadastrar um produto já existente, como o AirPod, o programa apenas o editaria. Vamos registrar o AirPod no valor de 2500.
2º Exercício – Realizar Reajuste nos Valores
Para o nosso segundo exercício, vamos criar um programa que percorra todos os produtos presentes no dicionário e faça um reajuste de 10% a mais nos valores de cada produto.
Resolução Exercício 2:
Primeiro, podemos calcular o reajuste para um único produto. Como vimos, para editar o valor de um item no dicionário, basta passar o nome da chave que queremos editar e atribuir o novo valor a ela.
Nesse caso, como queremos aumentar o preço do produto em 10%, só precisamos multiplicar o valor antigo do produto por 1.1 e atribuir o resultado dessa operação como o novo valor.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
#Fazendo o reajuste de um único produto:
produto = "airpod"
novo_preco = dic_produtos[produto] * 1.1
dic_produtos[produto] = novo_preco
print(dic_produtos)
Agora podemos criar uma estrutura de repetição utilizando um loop for para percorrer cada um dos itens do dicionário e fazer a alteração dos valores. Quando iteramos sobre um dicionário, o Python considera cada item como sendo a chave do dicionário.
dic_produtos = {"airpod": 2000, "ipad": 9000, "iphone": 6000, "macbook": 11000}
for produto in dic_produtos:
novo_preco = dic_produtos[produto] * 1.1
dic_produtos[produto] = novo_preco
print(dic_produtos)
Vamos para a sétima aula do nosso Curso Básico de Python 2024! Nela, veremos para que servem as funções no Python, como usar e muito mais!
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na sétima aula do nosso curso básico de Python 2024, vamos falar sobre as funções no Python! Vou te mostrar para que servem as funções, como usar, exemplos e qual o objetivo delas.
Dentro do código, a função tem um papel muito importante: ela nos permite criar um bloco de código que pode ser executado sempre que for chamado.
Dessa forma, não é necessário ficar escrevendo várias e várias vezes o mesmo código, otimizando a escrita e a manutenção do seu código.
Além disso, ainda vou te mostrar detalhes importantes das funções e quando você deve adaptar algo para uma função, pois nem sempre elas serão úteis dentro do seu projeto, principalmente se for algo pequeno e direto.
As funções são estruturas fundamentais no Python, permitindo a criação de blocos de códigos que podemos reutilizar para executar tarefas específicas repetidas vezes.
Elas ajudam a organizar o código de forma eficiente, evitando repetições e facilitando a execução de procedimentos complexos mais de uma vez.
Ao criarmos funções, é possível manter o código organizado, separando diferentes partes do programa em blocos específicos. Isso é importante tanto para a leitura do código quanto para a manutenção dele, conforme ele cresce.
Vamos ver um exemplo prático de cálculo de impostos sobre uma lista de preços de produtos usando diferentes alíquotas (20%, 15% e 5%).
lista_precos = [1500, 1000, 800, 3000]
# imposto
# aliquota1 - IR = 0.2
# aliquota2 - ISS = 0.15
# aliquota3 - CSLL = 0.05Ou seja, o imposto total do produto será a soma de cada uma dessas alíquotas. Vamos fazer o cálculo individual de cada um desses impostos para o primeiro produto e depois transformar esse cálculo em um loop for para todos os produtos da lista.
preco = 1500
imposto_ir = 0.2 * preco
imposto_iss = 0.15 * preco
imposto_csll = 0.05 * preco
imposto_total = imposto_ir + imposto_iss + imposto_csll
print(f"Imposto total sobre o produto de R${preco}: R${imposto_total}")Executando esse código, teremos o resultado de R$600,00 para o imposto total.
Agora vamos adaptar esse código para todos os preços da nossa lista utilizando a estrutura for.
for preco in lista_precos:
imposto_ir = 0.2 * preco
imposto_iss = 0.15 * preco
imposto_csll = 0.05 * preco
imposto_total = imposto_ir + imposto_iss + imposto_csll
print(f"Imposto total sobre o produto de R${preco}: R${imposto_total}")
Nosso código funcionou corretamente e conseguiu calcular os impostos para cada um dos produtos.
Agora vamos fazer uma pequena modificação que será a seguinte: a alíquota do imposto de renda será 0.2, se o preço do produto for até 2000, acima disso será de 0.3.
# imposto
# aliquota1 - IR = 0.2, se o preço do produto for até 2000, acima disso a aliquota é 0.3
# aliquota2 - ISS = 0.15
# aliquota3 - CSLL = 0.05Agora precisamos aplicar uma lógica específica para calcular o imposto de renda, e podemos fazer isso utilizando a estrutura if-else.
for preco in lista_precos:
if preco <= 2000:
imposto_ir = 0.2 * preco
else:
imposto_ir = 0.3 * preco
imposto_iss = 0.15 * preco
imposto_csll = 0.05 * preco
imposto_total = imposto_ir + imposto_iss + imposto_csll
print(f"Imposto total sobre o produto de R${preco}: R${imposto_total}")
Repare que para o produto de R$3000 tivemos uma alteração no valor final do imposto total, porque o imposto de renda dele passou a ser maior, já que esse é um produto que custa mais de 2000 reais.
Nosso código está funcionando perfeitamente, mas repare que nesse caso, a modificação foi rápida pois só tínhamos essa estrutura sendo utilizada uma vez.
Agora imagine que você tenha várias listas de produtos ao longo do seu código. Você teria de repetir essa estrutura toda para cada uma delas, e cada vez que precisasse fazer uma modificação como essa que fizemos, teria de alterar em todas elas.
É por isso que utilizamos as funções em Python, para separarmos a lógica do código, do cálculo feito, do restante do código, da aplicação dele. Dessa forma é possível modificar apenas a função quando precisarmos de alguma alteração.
Vamos ver na prática como a função pode otimizar nosso código e facilitar o trabalho de manutenção do código.
Para criar a função, vamos utilizar a palavra-chave def, que indica a definição de uma função. Nossa função será chamada de calcula_imposto_total e receberá como parâmetro o preço do produto.
Os parâmetros de uma função são os valores que a função espera receber para poder realizar suas operações. Como queremos calcular os impostos dos preços dos produtos, nossa função receberá como parâmetro os preços dos produtos.
Dentro dela, iremos definir toda a lógica que construímos anteriormente para o cálculo do imposto total e ao final adicionaremos a instrução return. A palavra-chave return indica qual valor a função deve retornar quando for chamada.
Quando a função atinge uma instrução return, ela imediatamente retorna o valor especificado. Nesse caso, retornaremos o valor do imposto total.
def calcula_imposto_total(preco):
if preco <= 2000:
imposto_ir = 0.2 * preco
else:
imposto_ir = 0.3 * preco
imposto_iss = 0.15 * preco
imposto_csll = 0.05 * preco
imposto_total = imposto_ir + imposto_iss + imposto_csll
return imposto_totalFeito isso, nossa função está criada e pronta para ser aplicada ao nosso código. Ou seja, ao invés de mantermos toda essa lógica dentro do loop for, podemos apenas adaptar essa estrutura para chamar a função calcula_imposto_total a cada iteração.
def calcula_imposto_total(preco):
if preco <= 2000:
imposto_ir = 0.2 * preco
else:
imposto_ir = 0.3 * preco
imposto_iss = 0.15 * preco
imposto_csll = 0.05 * preco
imposto_total = imposto_ir + imposto_iss + imposto_csll
return imposto_total
lista_precos = [1500, 1000, 800, 3000]
for preco in lista_precos:
imposto_total = calcula_imposto_total(preco)
print(f"Imposto total sobre o produto de R${preco}: R${imposto_total}")
Agora, se tivermos uma nova lista para aplicar o cálculo de imposto total, não precisaremos definir toda a lógica do cálculo de novo. Basta chamar novamente a função, aplicando-a para a nova lista.
nova_lista_produtos = [3000, 5000, 6000, 7000]
for preco in nova_lista_produtos:
imposto_total = calcula_imposto_total(preco)
print(f"Imposto total sobre o produto de R${preco}: R${imposto_total}")
Perceba como isso torna a reutilização do código muito mais simples e prática. Além disso, separar a lógica do cálculo do restante do código facilita futuras edições e alterações dentro dele.
Por exemplo, se a alíquota de algum imposto fosse modificada, você não precisaria alterar isso em cada trecho do seu código, apenas na função em que você está utilizando.
Inicialmente, pode não ser essencial utilizar muitas funções, principalmente em códigos mais simples, mas essa é uma estrutura fundamental para compreender e que irá auxiliar e muito em seus futuros códigos.
Alguns pontos importantes sobre as funções que você precisa saber são:
Na oitava aula do nosso curso básico de Python 2024, veremos como utilizar os módulos e bibliotecas do Python!
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Hoje estamos na oitava aula do nosso curso básico de Python 2024, onde você vai sair do zero em Python!
Nesta aula, vou te ensinar sobre os módulos e as bibliotecas do Python, que são fundamentais para a construção dos códigos!
Vamos entender como as bibliotecas são conjuntos de códigos prontos disponibilizados para uso direto no nosso código, sem a necessidade de criar um código completo para obter o mesmo resultado.
Além disso, nesta aula, vou te mostrar como instalar e utilizar as bibliotecas OS e PyAutoGUI. Então, faça o download do material disponível e vem comigo.
Após baixar o material disponível para esta aula, é importante que você descompacte a pasta “arquivos” dentro da pasta que contém os arquivos das aulas.
Dessa forma, ao abrir a pasta da aula com o VS Code, você terá tanto os arquivos Python quanto a pasta arquivos, que contém mais algumas pastas e alguns arquivos de texto.
Os módulos no Python são arquivos de código prontos e já estruturados, geralmente contendo variáveis, funções e classes. Eles podem ser importados e reutilizados em outros códigos e programas Python.
Os módulos são utilizados para organizar o código em partes menores, facilitando o gerenciamento e a manutenção. Eles fornecem funcionalidades específicas quando importados.
Por outro lado, as bibliotecas no Python são coleções de módulos relacionados que oferecem um conjunto de funcionalidades específicas. Elas permitem a execução de uma grande variedade de tarefas, como trabalhar com datas, ler dados de PDF, modificar arquivos, entre outras.
Dentro do Python, temos as bibliotecas padrão, que já vêm instaladas com ele, e as bibliotecas de terceiros, também chamadas de pacotes, que podemos instalar através do comando pip.
Os módulos e bibliotecas são essenciais para a programação em Python, pois nos permitem acessar funcionalidades pré-desenvolvidas por outros programadores ao redor do mundo.
Isso amplia as funcionalidades e capacidades disponíveis no Python e otimiza nosso processo de desenvolvimento, pois podemos acessar funções específicas para nossos projetos sem a necessidade de criar um código inteiro para isso.
A biblioteca os é uma ferramenta importante e poderosa do Python. Essa biblioteca, que vem instalada por padrão, nos permite manipular e interagir com os arquivos e pastas do computador.
Para utilizar essa ou qualquer outra biblioteca ou módulo no Python, é importante importar o pacote no início do seu código, o que fazemos através do comando import.
import osAo importar a biblioteca, podemos utilizar suas funcionalidades dentro do código. Por exemplo, podemos usar a função listdir() para listar os arquivos presentes em um diretório específico do computador.
Vamos utilizar a função listdir para listar os arquivos presentes na pasta arquivos que descompactamos para dentro da pasta do curso. Como a pasta e o arquivo Python estão no mesmo local, só precisamos passar o nome da pasta, e não o caminho completo dela.
import os
print(os.listdir("arquivos"))
Perceba que ao executar essa função e imprimir o resultado dela na tela, obtemos uma lista Python com o nome de todos os arquivos e pastas contidos dentro da pasta arquivos.
Outra biblioteca muito importante que vem instalada por padrão com o Python é a biblioteca Datetime. Esse módulo nos permite trabalhar com datas e horas de forma eficiente no Python.
Podemos, por exemplo, usar o método today para retornar a data atual.
import datetime
print(datetime.date.today())
Esse é apenas um dos métodos disponíveis para essa biblioteca. Dentro dela, teremos diversas outras funcionalidades referentes à data e hora que podem ser exploradas e aplicadas aos seus projetos e códigos, dependendo da sua necessidade.
Como mencionei, existem diversas bibliotecas em Python para uma ampla gama de situações e funcionalidades. Por exemplo, para trabalhar com Excel, podemos utilizar a biblioteca Pandas ou a OpenPyXL. Para manipulação de PDF, temos a biblioteca PyPDF.
O número de bibliotecas disponíveis é muito grande, portanto, não é necessário memorizar todas as bibliotecas e suas funcionalidades. É mais eficiente você pesquisar e utilizar conforme a sua necessidade.
A escolha das bibliotecas sempre dependerá do seu objetivo, projeto e trabalho em questão. Com o tempo e a prática, você se familiarizará mais com essas bibliotecas e compreenderá melhor suas capacidades.
O ponto principal que você precisa compreender é que as bibliotecas em Python são ferramentas poderosas capazes de ajudar a resolver uma variedade de problemas e desafios na programação. Basta pesquisar e encontrar a biblioteca adequada para o seu caso.
Depois de encontrar a biblioteca desejada, é muito importante compreender como ela funciona lendo e estudando sua documentação.
Encontrar a documentação de uma biblioteca é fácil: basta pesquisar pelo nome da biblioteca seguido de “Python” no Google.
Os primeiros resultados geralmente são a documentação da biblioteca em Python.
Essas páginas contêm informações importantes sobre como instalar as bibliotecas, suas principais funcionalidades e módulos, como utilizá-las em diferentes casos, e muito mais.
Até agora, vimos bibliotecas que já vêm instaladas por padrão no Python. No entanto, para utilizar muitas outras bibliotecas, é necessário instalá-las primeiro usando o comando pip install nome_da_biblioteca.
Algumas bibliotecas podem ter variações no nome durante a instalação, então é sempre importante verificar a documentação da biblioteca desejada antes de prosseguir com a instalação.
O comando pip precisa ser executado dentro do terminal do seu editor de códigos. Por exemplo, para instalar a biblioteca PyAutoGUI, basta abrir o terminal do VS Code e digitar: pip install pyautogui
Ao executar esse comando, o Python fará o download e a instalação da biblioteca. Portanto, é necessário estar conectado à internet para que o processo funcione corretamente.
Após instalar uma biblioteca, você poderá importá-la e utilizá-la em seu código. Por exemplo, vamos importar a biblioteca PyAutoGUI e demonstrar uma de suas funcionalidades.
Essa biblioteca nos permite criar automações de tarefas no computador, controlando o mouse e o teclado para realizar ações específicas, como clicar, mover o cursor e pressionar teclas.
Apenas para demonstrar que a instalação foi feita corretamente e exemplificar as funcionalidades dessa biblioteca, vamos importá-la, utilizar o método press para pressionar a tecla do Windows e o método write para escrever chrome.
import pyautogui
pyautogui.press("win")
pyautogui.write("chrome")Ao executar esse código, seu computador abrirá automaticamente o menu principal do Windows e buscará pelo Chrome.
Para finalizar a aula, vamos realizar um exercício prático que combina os conhecimentos de Python que você adquiriu até agora com a aplicação das bibliotecas Python.
O objetivo deste exercício é criar uma automação em Python para organizar os arquivos presentes na pasta arquivos de acordo com os anos deles.
Dentro dessa pasta, temos arquivos de texto referentes aos anos de 2022 e 2023. Nosso objetivo será mover os arquivos de 2022 para a pasta 22 e os de 2023 para a pasta 23.
Resolução do Exercício:
O primeiro passo para solucionar este exercício é utilizar a biblioteca os para listar todos os arquivos presentes na pasta arquivos através da função listdir.
import os
lista_arquivos = os.listdir("arquivos")Feito isso, precisamos percorrer todos os itens presentes nessa lista e identificar corretamente os arquivos TXT, já que serão eles que serão movidos para as pastas.
Para percorrer cada um dos itens presentes na lista, podemos criar uma estrutura for. Dentro desse loop for, vamos verificar se a string “.txt” está dentro do nome dos arquivos. Isso nos permitirá selecionar apenas os arquivos, sem modificar as pastas.
import os
lista_arquivos = os.listdir("arquivos")
for arquivo in lista_arquivos:
if ".txt" in arquivo:Dentro dessa estrutura if, e houver “.txt” no nome do arquivo, precisamos fazer uma segunda verificação, que será usada para identificar se o arquivo é referente ao ano de 2022 ou de 2023.
A lógica será a seguinte: se no nome do arquivo tiver a string “22”, ele deve ser movido para a pasta 22; caso contrário, se o nome do arquivo tiver a string “23”, vamos movê-lo para a pasta 23.
Para verificar se a nossa lógica está funcionando corretamente, vamos criar esse código e exibir um print para cada uma das condições.
import os
lista_arquivos = os.listdir("arquivos")
for arquivo in lista_arquivos:
if ".txt" in arquivo:
if "22" in arquivo:
print("Movimentar para a pasta 22: ", arquivo)
elif "23" in arquivo:
print("Movimentar para a pasta 23: ", arquivo)Perceba que ao invés de utilizar uma estrutura de if e else, eu utilizei um if e elif. Isso porque, se houvessem mais arquivos dentro da pasta além dos correspondentes ao ano de 2022 e 2023, esses arquivos não seriam movidos. Garantindo assim que somente os arquivos correspondentes serão movidos para as suas pastas.
Executando esse código, teremos:
Observe que de acordo com o nosso print, a lógica desenvolvida está funcionando corretamente. O próximo passo agora será movimentar de fato cada um desses arquivos para a pasta correta.
Para isso, vamos utilizar a função rename da biblioteca os. Essa função nos permite renomear um arquivo, passando como argumentos para ela o nome atual do arquivo e o novo nome dele.
Tanto o nome atual quanto o novo nome são o caminho para o arquivo desejado. Ou seja, você não irá alterar apenas o nome daquele arquivo, mas sim o diretório onde ele está localizado.
Para isso, é importante passar o caminho completo para o arquivo, ou o caminho relativo. O caminho relativo toma como ponto de partida o local onde seu código está sendo executado, e só pode ser utilizado quando a pasta ou os arquivos estão dentro da mesma pasta que o arquivo Python que você está executando.
Por exemplo, o caminho para o arquivo abr22.txt é arquivos/abr22.txt. Como queremos movê-lo para a pasta 22, o novo caminho será arquivos/22/abr22.txt.
Para não ter de fazer isso manualmente para cada um dos arquivos, podemos implementar essa função dentro do loop for que criamos e utilizar a f-string para alterar o nome do arquivo de acordo com a variável arquivo.
import os
lista_arquivos = os.listdir("arquivos")
for arquivo in lista_arquivos:
if ".txt" in arquivo:
if "22" in arquivo:
os.rename(f"arquivos/{arquivo}", f"arquivos/22/{arquivo}")
elif "23" in arquivo:
os.rename(f"arquivos/{arquivo}", f"arquivos/23/{arquivo}")Executando esse código, teremos os nossos arquivos organizados corretamente cada um em sua pasta específica.
Chegamos à nona e última aula do Curso Básico de Python 2024! Nesta aula, vamos criar o projeto final do curso: um gerenciador de backup usando Python.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na nossa última aula do Curso Básico de Python 2024, vamos construir um gerenciador de backup em Python, para que você saia do zero em Python.
Durante este projeto, vamos utilizar tudo o que aprendemos ao longo do curso, além de aprender a utilizar algumas bibliotecas importantes do Python, como Tkinter, Shutil e Datetime.
Com isso, vamos desenvolver um programa capaz de copiar todos os arquivos de uma pasta e realizar automaticamente o backup desses arquivos em poucos segundos.
E aí curtiu? Quer construir seu próprio gerenciador de backup em Python? Então faça o download do material disponível e vem comigo!
Durante esta aula, iremos desenvolver um gerenciador de backup utilizando Python. Este programa será capaz de selecionar uma pasta em nosso computador e realizar automaticamente o backup dos arquivos contidos nela.
Para que você possa praticar sem medo de cometer erros, em vez de utilizar uma pasta diretamente do seu computador, disponibilizei uma pasta com alguns arquivos como exemplo no material para download.
Basta baixar os arquivos desta aula e descompactar a pasta codigos em qualquer local do seu computador. Eu vou descompactá-la na pasta Downloads.
Dessa forma, quando o seu programa estiver funcionando corretamente, você poderá utilizá-lo para fazer backup de qualquer pasta do seu computador. No entanto, durante o processo de construção, é importante utilizar uma pasta de teste.
Nosso projeto será dividido em duas etapas principais:
Para isso, utilizaremos os conceitos aprendidos ao longo do nosso curso básico de Python 2024. Esta será uma excelente oportunidade para você praticar e consolidar seus conhecimentos, além de desenvolver um projeto do zero.
Para construir este projeto, faremos uso de 4 bibliotecas do Python:
Basta, no início do código, importarmos essas bibliotecas da seguinte forma:
import os
from tkinter.filedialog import askdirectory
import shutil
import datetimeObserve que, como da biblioteca Tkinter queremos apenas a função askdirectory, podemos importá-la individualmente, especificando de qual módulo faremos essa importação.
O primeiro passo do nosso projeto é criar a janela que nos permitirá selecionar qual pasta do nosso computador gostaríamos de fazer o backup.
Para isso, vamos criar a variável nome_pasta_selecionada, que irá receber a resposta da função askdirectory(). Ou seja, o usuário irá selecionar a pasta desejada através da função, e o caminho dessa pasta ficará salvo na variável para que possamos utilizá-lo.
# janela para selecionar a pasta do nosso computador
import os
from tkinter.filedialog import askdirectory
import shutil
import datetime
nome_pasta_selecionada = askdirectory()Apenas para visualizar o que obtemos como resposta, podemos imprimir essa variável.
# janela para selecionar a pasta do nosso computador
import os
from tkinter.filedialog import askdirectory
import shutil
import datetime
nome_pasta_selecionada = askdirectory()
print(nome_pasta_selecionada)
Com isso, conseguimos utilizar a função listdir() da biblioteca os para listar os arquivos dentro da pasta selecionada.
# janela para selecionar a pasta do nosso computador
import os
from tkinter.filedialog import askdirectory
import shutil
import datetime
nome_pasta_selecionada = askdirectory()
lista_arquivos = os.listdir(nome_pasta_selecionada)Podemos imprimir novamente essa informação apenas para garantir que todos os arquivos e pastas estão sendo reconhecidos e adicionados na lista.
# janela para selecionar a pasta do nosso computador
import os
from tkinter.filedialog import askdirectory
import shutil
import datetime
nome_pasta_selecionada = askdirectory()
lista_arquivos = os.listdir(nome_pasta_selecionada)
print(lista_arquivos)
Confirmando que os arquivos estão listados corretamente, podemos remover esse print e prosseguir para o processo de criação do nosso gerenciador de backup.
O primeiro passo para criar nosso gerenciador de backups é definir a pasta onde os arquivos serão salvos. Optarei por criar essa pasta dentro da própria pasta codigos.
Para que o Python possa localizar corretamente os arquivos e as pastas do nosso computador nesse processo de backup, é importante passarmos para ele os caminhos completos dos arquivos e pastas.
Faremos isso criando uma variável que receberá uma string com esse caminho. Como queremos que esse processo seja feito de forma dinâmica, utilizaremos f-strings, concatenando assim o caminho da pasta com o nome dos arquivos.
Para a nossa pasta de backup, vamos definir uma variável para o nome da pasta de backup.
# fazer o backup dos arquivos que estão nessa pasta
nome_pasta_backup = "backup"E para criar o caminho completo dela dentro da pasta codigos, vamos utilizar uma f-string com a variável nome_pasta_selecionada, obtida ao escolher uma pasta com a função askdirectory(), uma barra (/) porque é esse o padrão dos caminhos de arquivos no computador, e a variável nome_pasta_backup que acabamos de criar.
# fazer o backup dos arquivos que estão nessa pasta
nome_pasta_backup = "backup"
nome_completo_pasta_backup = f"{nome_pasta_selecionada}/{nome_pasta_backup}"Com isso, temos o caminho para a nossa pasta de backup definido, porém ela ainda não existe no nosso computador. Para criar essa pasta, utilizaremos a biblioteca os.
O primeiro passo será verificar se a pasta backup já existe em nosso computador através de um if not (se não) e da função os.path.exists(), passando como argumento o nome da pasta desejada.
Caso a pasta não exista, iremos criá-la utilizando a função os.mkdir() e passando como argumento o caminho para a pasta de backup. Caso contrário, se a pasta já existir, não faremos nada.
# fazer o backup dos arquivos que estão nessa pasta
nome_pasta_backup = "backup"
nome_completo_pasta_backup = f"{nome_pasta_selecionada}/{nome_pasta_backup}"
if not os.path.exists(nome_completo_pasta_backup):
os.mkdir(nome_completo_pasta_backup)Feita a verificação e a criação da pasta de backup, o próximo passo será percorrer toda nossa lista de arquivos e, para cada arquivo, definir o caminho completo atual dele (nome_completo_arquivo) e o caminho final, ou seja, o caminho que ele terá dentro da pasta de backup (nome_final_arquivo).
# fazer o backup dos arquivos que estão nessa pasta
nome_pasta_backup = "backup"
nome_completo_pasta_backup = f"{nome_pasta_selecionada}/{nome_pasta_backup}"
if not os.path.exists(nome_completo_pasta_backup):
os.mkdir(nome_completo_pasta_backup)
for arquivo in lista_arquivos:
nome_completo_arquivo = f"{nome_pasta_selecionada}/{arquivo}"
nome_final_arquivo = f"{nome_completo_pasta_backup}/{arquivo}"Com os caminhos definidos, o próximo passo será utilizar a biblioteca shutil para copiar os arquivos atuais para dentro da pasta de backup.
No entanto, dentro da pasta codigos, temos arquivos regulares (.py e .txt) e também uma pasta chamada arquivos.
A biblioteca shutil nos possibilita copiar tanto pastas quanto arquivos do nosso computador. No entanto, para cada tipo, ela utiliza uma função diferente. Para copiarmos arquivos, utilizaremos a função copy2(), enquanto para as pastas usaremos a copytree().
Portanto, dentro do nosso loop for, precisamos criar um if que verificará se o nome do arquivo possui um ponto. Essa é uma forma comum de identificar se o arquivo possui uma extensão e, por consequência, é um arquivo regular e não uma pasta.
Caso o nome do arquivo tenha um ponto, aplicaremos a função copy2(), passando como argumentos o caminho atual do arquivo e o caminho final.
Caso contrário, ou seja, caso o arquivo não tenha uma extensão, iremos verificar se o nome do arquivo é diferente de backup. Faremos isso para evitar a tentativa de fazer uma cópia da própria pasta de backup dentro dela mesma, o que causaria um problema de loop infinito.
Dessa forma, se o nome da pasta for diferente de backup, iremos utilizar a função copytree(), passando como argumento o caminho atual e o caminho final. Essa função copiará todas as pastas presentes e todo o conteúdo dentro delas, como no caso da pasta arquivos.
# fazer o backup dos arquivos que estão nessa pasta
nome_pasta_backup = "backup"
nome_completo_pasta_backup = f"{nome_pasta_selecionada}/{nome_pasta_backup}"
if not os.path.exists(nome_completo_pasta_backup):
os.mkdir(nome_completo_pasta_backup)
for arquivo in lista_arquivos:
nome_completo_arquivo = f"{nome_pasta_selecionada}/{arquivo}"
nome_final_arquivo = f"{nome_completo_pasta_backup}/{arquivo}"
if "." in arquivo:
shutil.copy2(nome_completo_arquivo, nome_final_arquivo)
elif "backup" != arquivo:
shutil.copytree(nome_completo_arquivo, nome_final_arquivo)Executando nosso código completo, teremos o nosso gerenciador de backups funcionando.
No entanto, se tentarmos executar novamente esse código, obteremos um erro.
Esse erro ocorre porque a nossa pasta com o backup já existe no diretório selecionado. Para solucionarmos esse erro e ainda termos um maior controle do nosso backup, vamos utilizar a biblioteca Datetime.
Com a biblioteca Datetime, iremos criar uma subpasta dentro da nossa pasta de backup, com a data e a hora em que o backup foi feito.
Dessa forma, você conseguirá ter várias pastas de backups no mesmo diretório, sabendo qual o dia e a hora que aquele backup foi realizado, permitindo um maior controle e segurança dos seus arquivos.
O primeiro passo será obter a data e a hora atual através do método today() da biblioteca datetime. Esse método retorna um objeto datetime com a data e o horário atual, conforme determinado pelo relógio do sistema.
Feito isso, vamos utilizar o método .strftime() para formatar o objeto datetime como uma string de acordo com o formato desejado. Em que %Y representa o ano com quatro dígitos, %m o mês com dois dígitos, %d o dia com dois dígitos, %H a hora em formato de 24 horas, %M o minuto com dois dígitos e %S os segundos com dois dígitos.
# fazer o backup dos arquivos que estão nessa pasta
nome_pasta_backup = "backup"
nome_completo_pasta_backup = f"{nome_pasta_selecionada}/{nome_pasta_backup}"
if not os.path.exists(nome_completo_pasta_backup):
os.mkdir(nome_completo_pasta_backup)
data_atual = datetime.datetime.today().strftime("%Y-%m-%d %H%M%S")
for arquivo in lista_arquivos:
nome_completo_arquivo = f"{nome_pasta_selecionada}/{arquivo}"
nome_final_arquivo = f"{nome_completo_pasta_backup}/{arquivo}"
if "." in arquivo:
shutil.copy2(nome_completo_arquivo, nome_final_arquivo)
elif "backup" != arquivo:
shutil.copytree(nome_completo_arquivo, nome_final_arquivo)Com isso, vamos modificar o diretório final dos nossos arquivos (nome_final_arquivo) para que, além da pasta backup, inclua uma subpasta com o nome da data e hora atual.
# fazer o backup dos arquivos que estão nessa pasta
nome_pasta_backup = "backup"
nome_completo_pasta_backup = f"{nome_pasta_selecionada}/{nome_pasta_backup}"
if not os.path.exists(nome_completo_pasta_backup):
os.mkdir(nome_completo_pasta_backup)
for arquivo in lista_arquivos:
nome_completo_arquivo = f"{nome_pasta_selecionada}/{arquivo}"
nome_final_arquivo = f"{nome_completo_pasta_backup}/{data_atual}/{arquivo}"
if "." in arquivo:
shutil.copy2(nome_completo_arquivo, nome_final_arquivo)
elif "backup" != arquivo:
shutil.copytree(nome_completo_arquivo, nome_final_arquivo)Além disso, vamos adicionar um if com a função os.path.exists para verificar se a pasta de backup com o nome completo existe e, caso não exista, criá-la.
# fazer o backup dos arquivos que estão nessa pasta
nome_pasta_backup = "backup"
nome_completo_pasta_backup = f"{nome_pasta_selecionada}/{nome_pasta_backup}"
if not os.path.exists(nome_completo_pasta_backup):
os.mkdir(nome_completo_pasta_backup)
data_atual = datetime.datetime.today().strftime("%Y-%m-%d %H%M%S")
for arquivo in lista_arquivos:
nome_completo_arquivo = f"{nome_pasta_selecionada}/{arquivo}"
nome_final_arquivo = f"{nome_completo_pasta_backup}/{data_atual}/{arquivo}"
if not os.path.exists(f"{nome_completo_pasta_backup}/{data_atual}"):
os.mkdir(f"{nome_completo_pasta_backup}/{data_atual}")
if "." in arquivo:
shutil.copy2(nome_completo_arquivo, nome_final_arquivo)
elif "backup" != arquivo:
shutil.copytree(nome_completo_arquivo, nome_final_arquivo)Dessa forma, ao executar o nosso código, teremos a criação de uma pasta com a data e hora atual, onde os arquivos de backup serão salvos.
# janela para selecionar a pasta do nosso computador
import os
from tkinter.filedialog import askdirectory
import shutil
import datetime
nome_pasta_selecionada = askdirectory()
lista_arquivos = os.listdir(nome_pasta_selecionada)
# fazer o backup dos arquivos que estão nessa pasta
nome_pasta_backup = "backup"
nome_completo_pasta_backup = f"{nome_pasta_selecionada}/{nome_pasta_backup}"
if not os.path.exists(nome_completo_pasta_backup):
os.mkdir(nome_completo_pasta_backup)
data_atual = datetime.datetime.today().strftime("%Y-%m-%d %H%M%S")
for arquivo in lista_arquivos:
nome_completo_arquivo = f"{nome_pasta_selecionada}/{arquivo}"
nome_final_arquivo = f"{nome_completo_pasta_backup}/{data_atual}/{arquivo}"
if not os.path.exists(f"{nome_completo_pasta_backup}/{data_atual}"):
os.mkdir(f"{nome_completo_pasta_backup}/{data_atual}")
if "." in arquivo:
shutil.copy2(nome_completo_arquivo, nome_final_arquivo)
elif "backup" != arquivo:
shutil.copytree(nome_completo_arquivo, nome_final_arquivo)O objetivo deste curso básico de Python foi apresentar a você todo o potencial desta linguagem de programação, para que você possa dar seus primeiros passos.
Ao longo do curso, você aprendeu desde o básico, como instalar e construir seus primeiros códigos em Python, até o projeto final, no qual foi capaz de criar um sistema de backup feito inteiramente com Python.
Com isso, você pôde conhecer um pouco das diversas aplicações e possibilidades que o Python oferece. Com essa base, você estará pronto para avançar na área da programação e se tornar um profissional impressionador em Python!
Para acessar outras publicações de Python, clique aqui!
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.
Quer sair do zero no Power BI e virar uma referência na sua empresa? Inscreva-se agora mesmo no Power BI Impressionador