Intensivão de Python

Status do Projeto: ✔️ Concluído

Tópicos

🔹 Descrição do projeto

🔹 Funcionalidades

🔹 Objetivos

🔹 Pré-requisitos

🔹 Como rodar a aplicação

🔹 Desafio 01

🔹 Desafio 01 Funcionando

🔹 Desafio 02

🔹 Desafio 02 Funcionando

🔹 Desafio 03

🔹 Desafio 03 Funcionando

🔹 Desafio 04

🔹 Desafio 04 Funcionando

🔹 Desenvolvedores

🔹 Contribuintes

Descrição do projeto

Meu primeiro projeto utilizando o Jupyter Notebook e minha primeira experiência abordando temas como Automação De Sistemas e Processos, Análise De Dados, Automação Web, Busca de Informações e a Utilização de Inteligência Artificial para uma Previsão de Vendas.

Funcionalidades

✔️ Aula 01 - Automação de Sistemas e Processos com Python.

✔️ Aula 02 - Análise de dados com Python.

✔️ Aula 03 - Automação Web e Busca de Informações com Python.

✔️ Aula 04 - Projeto Ciência de Dados - Previsão de Vendas

Objetivos

• Aula 01

Na primeira aula do Intensivão do Python você vai aprender a criar um código de automação de análise de dados e elaboração de relatórios do absoluto zero. Para isso, vamos passar por conceitos como:

• Jupyter Notebook
• Variáveis, métodos
• Importação de bibliotecas
• Uso de bibliotecas (pyautogui, time, pandas e pyperclip)
• Enviar e-mails automaticamente

Após todos esses conhecimentos, seremos capazes de transformar uma tabela cheia de informações, nem um pouco fáceis de serem interpretadas, em uma ferramenta automatizada de geração e envio automático de relatórios para um destinatário pré-definido.

• Aula 02

Na segunda aula do Intensivão do Python você vai aprender a criar um código de análise de dados. No dia a dia das empresas, é muito comum dúvidas sobre os resultados da empresa. Um conceito que cada dia mais cresce nas empresas é o data driven. Basicamente, é dizer que ações são tomadas com base nos dados e não em achismos. Aprenda como fazer uma super análise do zero com os conceitos abaixo:

• Importando dados de bases .csv
• Tratar dados usando a biblioteca Pandas
• Importação de bibliotecas
• Criação de gráficos usando o plotly

Após todos esses conhecimentos, seremos capazes de transformar uma tabela cheia de informações, nem um pouco fáceis de serem interpretadas em uma análise super aprofundada que servirão de base para tomada de decisão da gerência. Tudo graças a você! ☺

• Aula 03

Na terceira aula do Intensivão Python, você vai aprender a criar um código para automação de processos. No dia a dia das empresas, é muito comum que existam operações manuais que além de extremamente repetitivas (chatas) são suscetíveis a erro visto que são feitas manualmente. Vamos aprender como criar um código com o qual você possa resolver esse problema sem nem tocar no mouse ☺. Aprenda como fazer uma automação com integração web com os conceitos abaixo:

• Importando bases de dados do Excel
• Jupyter Notebook
• Importando bibliotecas
• Webdriver
• Usando Selenium

Após todos esse aprendizado, seremos capazes de transformar um processo extremamente repetitivo em processo automático e sem erros! Tudo graças a você! ☺

• Aula 04

Na quarta aula do Intensivão Python você vai aprender a criar um código de ciência de dados para criação de um modelo de previsão do absoluto zero. Para isso, vamos passar por conceitos como:

• Jupyter Notebook
• Etapas de um projeto de Ciência de Dados
• Gráficos usando Python
• Uso de bibliotecas
• Modelos de Inteligência Artificial

Após todos esses conhecimentos, seremos capazes detransformar uma tabela cheia de informações, nem um pouco fáceis de serem interpretadas em um modelo de previsão de Vendas utilizando Inteligência Artificial.

Pré-requisitos

• ⚠️ Anaconda
• ⚠️ Jupyter Notebook
• ⚠️ Pandas
• ⚠️ Pyperclip
• ⚠️ Selenium
• ⚠️ Webdriver
• ⚠️ Plotly
• ⚠️ Matplotlib
• ⚠️ Seaborn
• ⚠️ Scikit-learn

Como rodar a aplicação ▶️

No terminal, clone o projeto:

git clone https://github.com/Leocbm/Intensivao-De-Python.git

• Vá até o seu terminal, caso não saiba basta pesquisar por 'git CMD' na barra de pesquisa:

• Navegue até a pasta desejada com o comando 'cd', exemplo se sua pasta estiver no Desktop:

cd Desktop/Pasta

• Na pasta, basta escrever o comando acima.

• Ou se preferir pode utilizar o terminal da própria IDE/Editor de códigos:
• Exemplo usando o terminal do Jupyter:

• Pronto! 😄
• Lembre-se de ter o git instalado.

Desafio 01

Para início, nos deparamos com o seguinte desafio:

• Desafio: Todos os dias, o nosso sistema atualiza as vendas do dia anterior. O seu trabalho diário, como analista, é enviar um e-mail para a diretoria, assim que começar a trabalhar, com o faturamento e a quantidade de produtos vendidos no dia anterior.

• E-mail da diretoria: seugmail+diretoria@gmail.com

• Local onde o sistema disponibiliza as vendas do dia anterior: https://drive.google.com/drive/folders/149xknr9JvrlEnhNWO49zPcw0PW5icxga?usp=sharing

Agora o próximo passo é pensar em como seria o processo necessário para chegar a solução, e chegamos a essa conclusão:

• Passo 1: Entrar no sistema (no nosso caso, entrar no link)
• Passo 2: Navegar até o local do relatório (entrar na pasta Exportar)
• Passo 3: Fazer o download do relatório
• Passo 4: Calcular os indicadores
• Passo 5: Entrar no email
• Passo 6: Enviar por e-mail o resultado

O Passo 1 possui três etapas necessárias:

• Abrir uma nova aba do navegador
• Escrever o link no navegador
• Apertar 'Enter'

Para resolver isso, vamos usar o pyautogui, uma biblioteca de automação de comandos do mouse e do teclado.

Comandos pyautogui: https://pyautogui.readthedocs.io/en/latest/quickstart.html

• Caso você já não tenha o pyautogui instalado em seu computador, basta ir até uma célula e escrever o comando:

!pip install pyautogui

• E em seguida basta importá-lo em seu projeto, mas como o pyautogui por si só não reproduz caracteres especiais, importaremos também o pyperclip que é instalado junto com o pyautogui para realizar as cópias de texto necessárias.

import pyautogui
import pyperclip

• Nosso código:

Agora podemos realizar os comandos necessários para concluir o Passo 1:

• Como o pyautogui realiza várias ações rapidamente, o navegador não consegue acompanhar os comandos, então o comando pyautogui.PAUSE = 1 faz com que seja realizado uma pausa de 1 segundo entre cada comando realizado.

pyautogui.PAUSE = 1

• Agora precisamos abrir uma nova aba do navegador, para isso usamos o atalho "ctrl", "t" dentro do comando pyautogui.hotkey().

pyautogui.hotkey("ctrl", "t")

• Realizamos a cópia do link fornecido utilizando o pyperclip.copy().

pyperclip.copy("https://drive.google.com/drive/folders/149xknr9JvrlEnhNWO49zPcw0PW5icxga?usp=sharing")

• Em seguida utilizamos novamente a função pyautogui.hotkey() mas dessa vez com o atalho "ctrl", "v" que é o atalho colar.

pyautogui.hotkey("ctrl", "v")

• Utilizamos o comando pyautogui.press() para pressionar a tecla "enter" e entrar no link.

pyautogui.press("enter")

• E por fim importaremos a biblioteca time para utilizar a função time.sleep() e colocar o tempo desejado para que a página carregue por completo.

import time

time.sleep(5)

• Nosso código:
• Consideramos que o seu navegador ja esteja aberto para os comandos acima, mas caso queira abrir o programa do zero basta acrescentar ao inicio do código:

# pyautogui.press("win")
# pyautogui.write("chrome")
# pyautogui.press("enter")

Para Passo 2 será necessário clicar nas pastas desejadas, então um macete para descobrir a localização do mouse são os seguintes comandos:

time.sleep(5)
pyautogui.position()

• Com esse comando você terá 5 segundos para ficar com o mouse no local desejado e a posição será mostrada no comando pyautogui.position()
• Lembrando que a posição varia para cada tipo de resolução de tela, e também abas menores ou em tela cheia, então o comando utilizado nesse exemplo pode não funcionar em seu computador e será necessário atualizar as posições de acordo com a sua situação.
• Com a posição do local do click descoberta, vamos agora utilizar o comando pyautogui.click("posição descoberta", clicks=2) para clicar duas vezes na pasta e também o time.sleep(2) para o carregamento da página.

pyautogui.click(x=878, y=676, clicks=2)
time.sleep(2)

• Nosso código:

O Passo 3 agora é realizar o download do arquivo, para isso precisaremos descobrir:

• A posição do arquivo
• A posição do 'Mais Ações' (conhecido com 3 pontos)
• A opção de baixar (dentro dos 3 pontos)

E utilizar o pyautogui.click(x=, y=), junto a um .sleep() para dar tempo do arquivo baixar.

pyautogui.click(x=1000, y=919)
pyautogui.click(x=3323, y=406)
pyautogui.click(x=2748, y=1529)
time.sleep(5)

• Nosso código:

Agora o Passo 4 é calcular os indicadores, para isso precisaremos importar a biblioteca pandas que ja vem instalada com o Jupyter, e aproveitamos e usamos o 'as pd' para apelidar a biblioteca e facilitar o uso.

import pandas as pd

• E agora importaremos nossa tabela baixada do link
• Para isso armazenaremos ela dentro de uma variável com nome de sua escolha
• Utilizaremos o comando pd.read_excel(r" ") informando o local exato em que o arquivo está localizado em seu computador (Varia de caso para caso)
• E usaremos um display() com a variável criada para mostrar a tabela na tela

tabela = pd.read_excel(r"C://Users/joaol/Downloads/Vendas - Dez.xlsx")
display(tabela)

• Com a tabela na tela, analisaremos seus dados e pegaremos os dados que precisamos, para isso usaremos os comandos a seguir para somar as colunas desejadas.

faturamento = tabela["Valor Final"].sum()
quantidade = tabela["Quantidade"].sum()

• Nosso código:

Para o Passo 5 vamos repetir alguns comandos já utilizados, mas dessa vez para abrir uma nova aba e ir até o gmail

pyautogui.hotkey("ctrl", "t")
pyperclip.copy("https://mail.google.com/mail/u/0/#inbox")
pyautogui.hotkey("ctrl", "v")
pyautogui.press("enter")
time.sleep(5)

• Nosso código:

E enfim para o Passo 6 iremos enviar por e-mail o resultado da nossa análise, e para isso precisamos:

• Clicar no + para escrever nova mensagem.
• Escrever o email do destinatário.
• Precionar tab para selecionar o email.
• Precionar tab novamente para mudar para o bloco descrição.
• Copiar a mensagem desejada.
• Utilizar o comando de atalho para colar a mensagem.
• Pressionar tab novamente para mudar de bloco.

pyautogui.click(x=40, y=173)
pyautogui.write("seugmail+diretoria@gmail.com")
pyautogui.press("tab")
pyautogui.press("tab")
pyperclip.copy("Relatório De Vendas")
pyautogui.hotkey("ctrl", "v")
pyautogui.press("tab")

• Criar uma variavel texto formatada com os dados calculados no Passo 4

Prezados, bom dia

O faturamento de ontem foi de: R${faturamento:,.2f}
A quantidade de produtos foi de: {quantidade:,}

Abs
Leo"""

• Copiar e colar o texto na mensagem do gmail e enviar para a diretoria.

pyperclip.copy(texto)
pyautogui.hotkey("ctrl", "v")
pyautogui.hotkey("ctrl", "enter")

• Nosso código:

• PRONTO! AGORA É SÓ IMPRESSIONAR O CHEFE 😁

Desafio 01 Funcionando

Desafio 02

Para início, nos deparamos com o seguinte desafio:

• Desafio: Você trabalha em uma empresa de telecom e tem clientes de vários serviços diferentes, entre os principais: internet e telefone. O problema é que, analisando o histórico dos clientes dos últimos anos, você percebeu que a empresa está com Churn de mais de 26% dos clientes. Isso representa uma perda de milhões para a empresa. O que a empresa precisa fazer para resolver isso?
• Base de Dados: https://drive.google.com/drive/folders/1T7D0BlWkNuy_MDpUHuBG44kT80EmRYIs?usp=sharing
• Link Original do Kaggle: https://www.kaggle.com/radmirzosimov/telecom-users-dataset

Agora o próximo passo é pensar em como seria o processo necessário para chegar a solução, e chegamos a essa conclusão:

• Passo 1: Importar a base de dados
• Passo 2: Visualizar a base de dados
• Passo 3: Tratamento de dados (resolver os problemas da base de dados)
• Passo 4: Análise inicial dos dados (entender os cancelamentos)
• Passo 5: Descobrir o motivo dos cancelamentos
• Passo 6: Conclusões e Ações

O Passo 1 possui apenas uma etapa necessária:

• Importar a base de dados

Para resolver isso, vamos usar o pandas, uma biblioteca para leitura e manipulação de dados.

Comandos pandas: https://pandas.pydata.org/docs/

• A biblioteca pandas já vem instalada junto ao Jupyter.

Agora podemos realizar os comandos necessários para concluir o Passo 1:

• Primeiramente importamos a biblioteca do pandas com o comando 'import pandas as pd'.
• Após importar a biblioteca basta armazenar a sua base de dados dentro de uma variável.
• Nessa etapa utilizamos o atalho para o arquivo sem o caminho completo "telecom_users.csv" pois o arquivo estava localizado na mesma pasta em que o projeto está.

import pandas as pd

tabela = pd.read_csv("telecom_users.csv")

• Nosso código:

Para Passo 2 teremos 4 etapas:

• Visualizar a base de dados.
• Entender as informações que você tem disponível.
• Descobrir o problema da base de dados.
• Excluir colunas inúteis (informações que não te ajudam, te atrapalham).

Para isso devemos dar um display na tabela e verificar as informações.

display(tabela)

Agora que analisamos a tabela, percebemos que a coluna 'Unnamed' não nos servirá para nada, então teremos q excluir ela.

• Para excluir uma informação de uma tabela, devemos utilizar o comando tabela.drop() e informar um "nome" e um eixo.
• Para isso devemos saber que o "nome" pode ser o nome ou a linha da tabela, e o eixo utilizamos axis=o -> para o eixo da linha e axis=1 -> para o eixo da coluna.

tabela = tabela.drop("Unnamed: 0", axis=1))

• Nosso código:

Para o Passo 3 precisaremos tratar os dados e isso possui 3 etapas:

• Resumir sua base de dados
• Verificar se as informações são tipo correto.
• Eliminar informações vazias, podem ser colunas ou linhas.

Para resumir a base de dados utilizamos o comando print(tabela.info())

print(tabela.info())

• Notamos que a coluta 'Total Gasto' está sendo reconhecida como object(texto) mas ela é do tipo float(com casas decimais)
• Precisaremos corrigi-la com o comando pd.to_numeric() para transformá-la em números e o metodo errors="coerce" para forçar o erro a virar número.

tabela["TotalGasto"] = pd.to_numeric(tabela["TotalGasto"], errors="coerce")

Após corrigir nosso erro deveremos eliminar qualquer informação vazia que não te prejudique em sua base de dados.

• O comando dropna() exclui informações vazias, para isso deveremos informar o how="" e o axis.
• O axis já vimos acima, o how="" pode ser "all" para excluir a linha/coluna se todas as informações dela estiverem vazias ou "any" para excluir a linha/coluna se qualquer informação dela estiver vazia.
• Excluindo tabelas completamentes vazias.

tabela = tabela.dropna(how="all", axis=1)

• Excluindo linhas com alguma coisa vazia.

tabela = tabela.dropna(how="any", axis=0)

• Nosso código:

Agora no Passo 4 teremos a análise inicial dos dados e nisso deveremos conferir os cancelamentos

• como estão os cancelamentos? 26%

Analizaremos a coluna 'Churn' que são os cancelamentos das pessoas e utilizaremos o comando .value_counts() para contar com precisão a ocorrencia de cancelamento.

• Também existem outras funções como .sum(soma) / .average(media) / mean(mediana) / value_counts(quantidade) mas utilizaremos apenas o counts.

print(tabela["Churn"].value_counts())

• E também podemos usar o método (normalize=True) para verificar a porcentagem (se for da sua preferência é possível utilizar o comando .map("{:.1%}".format) para formatar a porcentagem.

print(tabela["Churn"].value_counts(normalize=True).map("{:.1%}".format))

• E com isso confirmamos os 26% de cancelamento.
• Nosso código:

No Passo 5 precisaremos descobrir o motivo dos cancelamentos e para isso transformaremos cada uma das colunas em gráficos e analisaremos os dados.

• Para isso precisaremos instalar plotly, que é um biblioteca de gráficos.
• Caso você já não tenha o plotly instalado em seu computador, basta ir até uma célula e escrever o comando:

!pip install plotly

• E em seguida basta importá-lo em seu projeto, para isso vamos utilizar o comando:

import plotly.express as px

Para transformar todas as colunas de uma vez em gráfico, precisaremos utilizar o método 'for' e passar o seu parâmetro dentro do x= a seguir.

• Iremos utilizar o comando px.histogram() para criar um gráfico do tipo histograma, e passar nele (nossa tabela, x="a coluna(a nossa está no 'for')", e a color="que é a coluna em relação a outra")
• Existem outros tipos de gráfico como grafico de barra .bar / linha .line / histograma .histogram, mas só usaremos o histograma.
• Exemplo de gráficos: https://plotly.com/python/histograms/
• E iremos exibir o gráfico

for coluna in tabela.columns:
    grafico = px.histogram(tabela, x=coluna, color="Churn")
    grafico.show()

• Nosso código:

E por fim no Passo 6 basta análisar os dados e anotar suas Conclusões.

• Conclusões:

• Clientes que estão há pouco tempo estão cancelando muito

• Pode estar fazendo alguma promoção que dá o primeiro mês de graça

• O inicio do serviço pro cliente está sendo muito confuso

• A primeira experiencia pro cliente ta ruim

• Podemos criar incentivos nos primeiros mêses - primeiro ano mais barato

• Boleto Eletronico tem muito mais cancelamento que as outras formas de pagamento

• Oferecer desconto nas outras formas de pagamento

• Pessoas com contrato mensal tem muito mais chance de cancelar

• Desconto para pagar a anuídade

• Mais serviços o cliente tem (suporte) menos ele cancela

• Pode oferecer serviços extras quase de graça

• Clientes com familia maior tem menos chance de cancelar

• 2° linha de graça ou desconto

• Nosso código:

• PRONTO! AGORA É SÓ IMPRESSIONAR O CHEFE 😁

Desafio 02 Funcionando

Desafio 03

Para início, nos deparamos com o seguinte desafio:

• Desafio: Trabalhamos em uma importadora e o preço dos nossos produtos é vinculado a cotação de:
• Dólar
• Euro
• Ouro

Precisamos pegar na internet, de forma automática, a cotação desses 3 itens e saber quanto devemos cobrar pelos nossos produtos, considerando uma margem de contribuição que temos na nossa base de dados.

• Base de Dados: https://drive.google.com/drive/folders/1KmAdo593nD8J9QBaZxPOG1yxHZua4Rtv?usp=sharing

Agora o próximo passo é pensar em como seria o processo necessário para chegar a solução, e chegamos a essa conclusão:

• Passo 1: Pegar a cotação do dólar
• Passo 2: Pegar a cotação do euro
• Passo 3: Pegar a cotação do ouro
• Passo 4: Atualizar a base de dados
• Passo 5: Recalcular os preços
• Passo 6: Exportar a base de dados

O Passo 1 possui quatro etapas necessárias:

• Abrir o navegador
• Entrar no google
• Pesquisar a cotação do dólar no google
• Pegar a cotação do dólar

Para resolver isso, usaremos o selenium, uma biblioteca de automação de comandos web.

Comandos selenium: https://www.selenium.dev/documentation/

E iremos criar uma automação web:

• Importante: baixar o webdriver

• Cada navegador tem seu próprio drive, no meu caso estou utilizando o edge.

• Para instalar o webdriver, basta copiar o executável baixado e colar na pasta em que seu anaconda estiver instalado.

• Para saber o local basta pesquisar por Anaconda Prompt em sua barra de pesquisa e iniciar o prompt, na primeira linha informará o local da pasta, no meu caso aparece:

• Após isso basta localizar a pasta Anaconda3 em seu computador e colar o executável dentro.

• Caso você já não tenha o Selenium instalado em seu computador, basta ir até uma célula do seu jupyter e escrever o comando:

!pip install selenium

• E em seguida basta importá-lo em seu projeto
• Importaremos também a função keys para utilizar teclas de atalho na automação
• E importaremos a função By que é um mecanismo usado para localizar elementos dentro de um documento

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By

Agora podemos realizar os comandos necessários para concluir o Passo 1:

• Para abrir o navegador usaremos o comando 'navegador = webdriver.Edge()'

navegador = webdriver.Edge()

• Para entrar no google usaremos o comando 'navegador.get("") com o link do navegador'

navegador.get("https://www.google.com.br/")

• Para pesquisar a cotação do dólar, precisaremos primeiramente localizar a aba de escrever a pesquisa, para fazer isso precisaremos descobrir o 'xpath' que é a localização do item desejado na página.
• Para localizar o xpath do item (barra de pesquisa), precisaremos inspecionar a página com a tecla f12 e clicar na opção de selecionar um item especifico da tela e inspecioná-lo, ou usar o atalho 'ctrl'+'shift'+'c' para inspecionar direto.
• Após selecionar a barra de pesquisa, ficará marcado um código em azul no código da página.
• Após localizar, basta clicar com o botão direito e ir em cópia -> copiar Xpath.
• Em seguida usaremos o comando .find_element() informando o xpath, e também o comando send_keys() para enviar o texto desejado.

navegador.find_element(By.XPATH,'/html/body/div[1]/div[3]/form/div[1]/div[1]/div[1]/div/div[2]/input').send_keys("cotacao dolar")

• Agora pegaremos xpath do botão pesquisar e utilizar o comando send_keys(Keys.ENTER).

navegador.find_element(By.XPATH,'/html/body/div[1]/div[3]/form/div[1]/div[1]/div[3]/center/input[1]').send_keys(Keys.ENTER)

• E por fim basta achar o xpath da cotação do dólar, mas dessa vez procuraremos um elemento em específico no elemento.
• Basta inspecionar o valor da cotação do dólar e procurar o valor que precisamos, no nosso caso o 'data-value' e especificá-lo dentro do comando .get_attribute().

cotacao_dolar = navegador.find_element(By.XPATH,'//*[@id="knowledge-currency__updatable-data-column"]/div[1]/div[2]/span[1]').get_attribute('data-value')

• Caso queira que a automação rode em segundo plano, basta acrescentar ao inicio do código:

# from selenium.webdriver.edge.options import Options
# edge_options = Options()
# edge_options.headless = True 
# navegador = webdriver.Edge(options=edge_options)

• Nosso código:

Para Passo 2 basta repetir o Passo 1 mas dessa vez pesquisando a cotação do euro.

navegador.get("https://www.google.com.br/")
navegador.find_element(By.XPATH,'/html/body/div[1]/div[3]/form/div[1]/div[1]/div[1]/div/div[2]/input').send_keys("cotacao euro") # como e qual o codigo /
navegador.find_element(By.XPATH,'/html/body/div[1]/div[3]/form/div[1]/div[1]/div[3]/center/input[1]').send_keys(Keys.ENTER)
cotacao_euro = navegador.find_element(By.XPATH,'//*[@id="knowledge-currency__updatable-data-column"]/div[1]/div[2]/span[1]').get_attribute('data-value')

• Nosso código:

Para o Passo 3 precisaremos fazer quase o mesmo processo dos passos anteriores, mas dessa vez no site Melhor câmbio.

navegador.get("https://www.melhorcambio.com/ouro-hoje#:~:text=O%20valor%20do%20grama%20do,em%20R%24%20292%2C87.")
cotacao_ouro = navegador.find_element(By.XPATH,'//*[@id="comercial"]').get_attribute('value')

Mas dessa vez o valor do ouro veio com a formatação errada, então usaremos o .replace(",",".") para substituir a vírgula por ponto.

cotacao_ouro = cotacao_ouro.replace(",",".")

E usaremos o .quit() para após a análise, a aba de pesquisa fechar automaticamente.

navegador.quit()

• Nosso código:

Agora o Passo 4 basta importarmos nossa tabela com o pandas e analisar o que precisamos modificar e atualizar nela.

• Deixei o arquivo 'Produtos.xlsx' na mesma pasta do código para facilitar.

import pandas as pd

tabela = pd.read_excel("Produtos.xlsx")
display(tabela)

• Nosso código:

Para o Passo 5 teremos três passos:

• Atualizar as cotações com os dados obtidos.
• Atualizar o preço de compra.
• Atualizar o preço de venda.

Para atualizar as cotações teremos que verificar todas as linhas e trocar a cotação antiga pela nova cotação adiquirida pela automação.

• Usaremos o comando a seguir:

tabela.loc[tabela["Moeda"]=="Dólar", "Cotação"] = float(cotacao_dolar)
tabela.loc[tabela["Moeda"]=="Euro", "Cotação"] = float(cotacao_euro)
tabela.loc[tabela["Moeda"]=="Ouro", "Cotação"] = float(cotacao_ouro)

Atualizaremos o preço de compra, multiplicando a coluna "Preço original" com a coluna "Cotação":

tabela["Preço de Compra"] = tabela["Preço Original"] * tabela["Cotação"]

E atualizaremos o preço de venda, multiplicando a coluna "Preço de Compra" com a coluna "Margem":

tabela["Preço de Venda"] = tabela["Preço de Compra"] * tabela["Margem"]

• Nosso código:

E enfim para o Passo 6 iremos exportar nossa tabela.

• Nessa parte devemos ter cuidado, pois se exportar-mos a tabela com o mesmo nome da original a tabela original será perdida, então daremos um novo nome a ela.
• E colocaremos o parâmetro index=False para o arquivo não ir com o indice para a planilha.

tabela.to_excel("Produtos Novo.xlsx", index=False)

• Nosso código:

• PRONTO! AGORA É SÓ IMPRESSIONAR O CHEFE 😁

Desafio 03 Funcionando

Desafio 04

Para início, nos deparamos com o seguinte desafio:

• Desafio: Nosso desafio é conseguir prever as vendas que vamos ter em determinado período com base nos gastos em anúncios nas 3 grandes redes que a empresa Hashtag investe: TV, Jornal e Rádio.
• Base de Dados: https://drive.google.com/drive/folders/1o2lpxoi9heyQV1hIlsHXWSfDkBPtze-V?usp=sharing

Agora o próximo passo é pensar em como seria o processo necessário para chegar a solução, e chegamos a essa conclusão:

• Passo 1: Entendimento do Desafio
• Passo 2: Entendimento da Área/Empresa
• Passo 3: Extração/Obtenção de Dados
• Passo 4: Ajuste de Dados (Tratamento/Limpeza)
• Passo 5: Análise Exploratória
• Passo 6: Modelagem + Algoritmos (Aqui que entra a Inteligência Artificial, se necessário)
• Passo 7: Interpretação de Resultados

O Passo 1 e Passo 2 devemos refletir sobre onde queremos chegar ao longo do projeto, pois deveremos tomar varias decsões, se uma coisa ta boa ou ta ruim, se usa um recurso ou outro, etc.

• Imagine que voce faça uma precisão de vendas de 95% de precisão, parece bom, mas se fosse para a eficacia de um medicamento, talvez 95% não estejam tão bom.
• Então isso nos levará a tomar as melhores decisões no projeto.

Para o Passo 3 fazeremos a importação da base de dados.

• Para isso usaremos a biblioteca do pandas com o nosso arquivos 'advertising.csv' e daremos um display para exibi-la na tela.
• A biblioteca pandas já vem instalada junto ao Jupyter.
• Comandos pandas: https://pandas.pydata.org/docs/

import pandas as pd
tabela = pd.read_csv("advertising.csv")
display(tabela)

• Nosso código:

Agora o Passo 4, tratar a base de dados e deixar ela mais prática.

• Faremos o uso do método .info()

print(tabela.info())

• Analizamos a nossa tabela, porém ela já está correta e não necessita alterações.
• Nosso código:

Para o Passo 5 faremos a análise preliminar para tentar entender como as informações estão se comportando.

• Precisaremos fazer a utilização de três bibliotecas:
• matplotlib -> Gráficos
• seaborn -> Gráficos
• scikit-learn -> IA
• Caso você já não tenha as bibliotecas instaladas em seu computador, basta ir até uma célular e digitar o comando:

# !pip install matplotlib
# !pip install seaborn
# !pip install scikit-learn

Após isso importaremos nossas bibliotecas.

• Usaremos o comando a seguir:

import seaborn as sns
import matplotlib.pyplot as plt

Precisaremos descobrir a correlação de cada item da nossa tabela, para isso usaremos o comando tabela.corr():

• Mas para melhorar a visualização, transformaremos ela em um gráfico de mapa de calor utilizando o seaborn com o comando .heatmap.

sns.heatmap(tabela.corr(), cmap="Wistia", annot=True)

• Utilizamos também o "Wistia" para melhorar as cores do gráfico e também o annot=True para anotar os valores dentro do gráfico.
• Nosso código:

Para o Passo 6 criaremos nossas Inteligências Artificiais para realizar testes.

• Pegaremos nossa base de dados e dividiremos ela em dados de treino e em dados de teste.
• Ou seja, enviaremos dados de treino para a IA aprender, e dados de teste para testar se a IA aprendeu.
• Dividiremos em dados de x e de y.
• y -> quem você quer prever. (vendas)
• x -> é todo o resto. (quem você vai usar para fazer a previsão)

x = tabela[["TV", "Radio", "Jornal"]]
y = tabela["Vendas"]

• O próximo passo é dividir novamente nossa tabela em quatro partes para testar nossas IA's, separando em dois o x e y.
• x_treino, x_teste, y_treino, y_teste
• Na prática ficaria assim:

• Para fazer essa divisão utilizaremos um método do scikit-learn chamado train_test_split.

from sklearn.model_selection import train_test_split

x_treino, x_teste, y_treino, y_teste = train_test_split(x, y, test_size=0.3)

• O test_size-0.3 divide os dados de treino e os dados de teste em 30% teste e 70% treino.
• Nosso código:

Após isso precisaremos escolher os modelos de IA que vamos usar, neste projeto utilizaremos dois modelos:

• Regressão Linear
• RandomForest (Árvore de Decisão)

Para isso devemos:

• importar os modelos de IA

from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor

• Criar a IA

modelo_regressaoLinear = LinearRegression()
modelo_arvoreDecisao = RandomForestRegressor()

• Treinar a IA.

modelo_regressaoLinear.fit(x_treino, y_treino)
modelo_arvoreDecisao.fit(x_treino, y_treino)

• Nosso código:

Agora testaremos a previsão dos nossos modelos de IA, e decidiremos qual o melhor modelo.

• Vamos usar o R² que diz a % que o nosso modelo consegue explicar o que acontece.
• Fazer previsão dos testes

previsao_regressaoLiner = modelo_regressaoLinear.predict(x_teste)
previsao_arvoreDecisao = modelo_arvoreDecisao.predict(x_teste)

• Utilizar o R² para descobrir qual dos modelos teve a previsão mais próxima dos nossos testes.

from sklearn.metrics import r2_score

print(r2_score(y_teste, previsao_regressaoLiner))
print(r2_score(y_teste, previsao_arvoreDecisao))

E com isso descobrimos que o modelo arvoreDecisao se comportou melhor com o nosso teste, com 94%.

• Nosso código:

• para demonstrar melhor, podemos criar um gráfico para demonstrar visualmente como nossos modelos reagiram em relação aos nossos testes.

• Criação do gráfico

tabela_auxiliar = pd.DataFrame()
tabela_auxiliar["y_teste"] = y_teste
tabela_auxiliar["arvore decisao"] = previsao_arvoreDecisao
tabela_auxiliar["regressao linear"] = previsao_regressaoLiner

plt.figure(figsize=(15,6))
sns.lineplot(data=tabela_auxiliar)
plt.show()

• Nosso código:

E por fim, para o Passo 7 interpretaremos os resultados e aprenderemos a fazer as previsões.

• Para isso basta importar nossa tabela com valores que queremos testar as nossas vendas.

novos = pd.read_csv("novos.csv")
display(novos)

• E basta utilizar o modelo arvore de decisão com a função .predict(), na nossa nova tabela, e teremos o resultado de nossos testes.

print(modelo_arvoreDecisao.predict(novos))

• Vemos que o melhor resultado foi a Linha 2 -Nosso código:

• Qual a importância de cada variável para as vendas?

sns.barplot(x=x_treino.columns, y=modelo_arvoreDecisao.feature_importances_)
plt.show()

• PRONTO! AGORA É SÓ IMPRESSIONAR O CHEFE 😁

Desafio 04 Funcionando

Desenvolvedores

Leonardo Cunha	Leonardo Cunha	Leonardo Cunha

Contribuintes

Hashtag Treinamentos	João Paulo Rodrigues de Lira	Hashtag Treinamentos