Primeira coisa a fazer SEMPRE

- Escrever o que eu quero fazer no projeto (passo a passo)

- Transformar cada passo em linguagem python

Bibliotecas:

pyautogui (pacote de codigos para automatizar o uso do mouse, teclado)

pandas (pacote de codigos para trabalhar combase de dados)

PYAUTOGUI

!pip install pyautogui (para instalar)

import pyautogui (importar)

Funções pyautogui

pyautogui.click (clica)

pyautogui.press (aperta 1 tecla)

pyautogui.hotkey (atalho)

pyautogui.write (escreve texto)

pyautogui.PAUSE = 1 (dará 1s de pausa entre as ações

Quando envolver link ou itens com caracteres especiais

import pyperclip

copiar com ele - pyperclip.copy ('link') e pyautogui.hotkey (“ctrl”, “v”)

Para inserir tempo de espera após alguma ação:

import time

time.sleep (5)

Código para descobrir a posição exata do mouse

time.sleep (5)

pyautogui.position ( )

ex.:
import time

time.sleep(5)

pyautogui.position (x=1408, y=342, clicks=2) (button='right' quando quiser clique com direito)

PANDAS

import pandas as pd (as pd = poderá chamar ele só por pd)

variável = pd.ação_tipo (local do arquivo)

EX.:

tabela = tabela = pd.read_excel(r'C:\Users\rcdsc\Downloads\Vendas - Dez.xlsx')

OBS1: se tiver mais de uma planilha colocar

tabela = tabela = pd.read_excel(r'C:\Users\rcdsc\Downloads\Vendas - Dez.xlsx,

sheet_name=’planilha10’’)

OBS2: o ‘r’ antes significa que o python vai ler exatamente como está escrito

display (tabela) – mostra a tabela formatada

#Passo 5: calcular indicadores da empresa

Nova variável = tabela existente [coluna existente entre colchetes].sum

.sum SOMA

.mean MEDIA

.count CONTAR

Exemplo:

faturamento = tabela ['Valor Final'].sum()

quantidade = tabela ['Quantidade'].sum()

#Escrever e enviar email

Sempre que tiver caracteres especiais (tipo acentos), ao invés de usar o pyautogui.write

Utilizar o pyperclip.copy (“texto”) e depois pyautogui.hotkey (‘ctrl’, ‘v’)

Texto com linhas e parágrafos

Abrir e fechar três aspas

Exemplo:

texto =f'''Prezados

Segue o relatório de vendas.

Faturamento: R${faturamento:,.2f}

Quantidade de produtos vendidos: {quantidade:,}

Qualquer dúvida estou à disposição

'''

OBS1: ”f” é para formatar. Ele permite colocar variáveis entre { }

OBS2: ”:” após a variável indica ao python que você irá formatar o número

OBS3:”,” após “:” é o separador de milhar

Obs4:”2f” indica que são duas casas decimais

Automatizando anexo em e-mails

arquivo = r'C:\Users\rcdsc\Downloads\Vendas - Dez.xlsx'

pyautogui.click (x=1383, y=912)

time.sleep (2)

pyperclip.copy (arquivo)

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

pyautogui.press ('enter')

time.sleep (4)

Imagem referência para espera do pyautogui

Instalar Open cv-python: (ferramenta de reconhecimento de imagem no python)

!pip install opencv-python

Usar imagem que você sabe que irá aparecer após toda a tela ser carregada,
independentemente do tempo que demorar.

Exemplo: no caso, logo do Google Drive dentro do Drive

Usar a ferramenta Ferramenta de captura e salvar como png

(e colocar a imagem onde está o código) e colocar confiança de 90%

while not pyautogui.locateOnScreen(‘drive.png’, confidence = 0.9):

time.sleep (1)

Significa: Enquanto não achar a imagem referida, esperar 1 segundo

AULA 2

Excluindo informação inútil de tabela

Nome da tabela = nomedatabela.drop (“nome da coluna ou nº da linha”, eixo 0 ou 1)

tabela = tabela.drop("Unnamed: 0", axis=1)axis=0 > linha / axis=1 > coluna

Informações de uma tabela

Função: print(tabela.info())

Mostra informações da tabela (tipo, qnt. De valores nulos, etc)

Trocar o tipo de uma coluna (texto para nº)

Nome da tebela [“coluna desejada”] = pandas.função(tabela[“coluna desejada”]

errors="coerce")

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

errors="coerce" – significa que caso encontre algum erro, force a transforma em nº, caso
tenha algum texto na coluna que deveria ser apenas nº

[colchetes] – para selecionar uma coluna da tabela

# VALORES VAZIOS

# colunas completamente vazias

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

# linhas com pelo menos 1 valor vazio

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

dropna – permite deletar linha ou coluna vazia automaticamente

how – critério [all= todas vazias / any= alguma linha vazia

Contar valores de uma coluna específica - Indicará quantos são SIM e quantos são NÃO

(tabela['Churn'].value_counts())

value_counts – contar valores

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

normalize=True – indica a porcentagem

.map("{:.1%}".format) – formata para mostrar em porcentagem no python

se fosse {:.1f} indicaria o formato com uma casa decimal

GRÁFICOS

Obs: para gráficos sãos sempre duas etapas: criar e exibir

Exibir é nome do gráfico.show() ex.: figura1.show()

Para edição de gráficos - https://plotly.com/python/histograms/

Ferramentas (bibliotecas) de criar gráficos

# matplotlib

# seaborn

# plotly

!pip install plotly – pra instalar o plotly

Import plotly.express as px

Fazer o gráfico

fig = px.histogram(tabela, x="Casado", title = 'Histogramas da condição de matrimônio',

opacity = 0.5, color="Churn", text_auto=True)

Histograma, indica a tabela, qual coluna é o eixo x

Color = “coluna determinada” cria uma relação entre as duas com cores diferentes

Opacity – opacidade

Title – Título

Text_auto = True - exibe os valores de cada parte no gráfico mesmo

color_discrete_sequence= [ 'indianred' ] SE QUISESSE ATRIBUIR OUTRA COR PRA TODO O

GRÁFICO
Criar vários gráficos de uma vez

for coluna in tabela.columns:

fig = px.histogram(tabela, x=coluna, color="Churn", text_auto=True)

fig.show()

Significa:

Para cada coluna das colunas da tabela, irá criar um gráfico e exibi-lo

AULA 3

# Importar selenium – para exportar apenas o que vai ser utilizado e não toda a biblioteca

from selenium import webdriver

from selenium.webdriver.common.keys import Keys #permite escrever no navegador

from selenium.webdriver.common.by import By #permite selecionar itens no navegador

# para rodar o chrome em 2º plano

# from selenium.webdriver.chrome.options import Options

# chrome_options = Options()

# chrome_options.headless = True

# navegador = webdriver.Chrome(options=chrome_options)

# abrir o chrome

navegador = webdriver.Chrome()

# PASSO 2: COTAÇÃO DO DÓLAR

# pesquisar no google a cotação do dólar

# o que irá fazer: navegador, encontra a caixa de texto e escreve nela

# botão direito na caixa de texto > inspecionar

# ao abrir uma caixa, clica na seta no canto superior esquerdo

# permitira selecionar qualquer elemento da tela

# selecionar a caixa de texto e irá destacar um texto na caixa

# botão direito > copiar > xpath (XPATH é código único do item)

# entrar no google

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

# navegador_o que quero editar_o que quero escrever nele

navegador.find_element("xpath",
'/html/body/div[1]/div[3]/form/div[1]/div[1]/div[1]/div/div[2]/input').send_keys('cotação
dolar')

# pressionar enter

navegador.find_element("xpath",
'/html/body/div[1]/div[3]/form/div[1]/div[1]/div[1]/div/div[2]/input').send_keys(Keys.ENTER)

# pegar a cotação do google # xpath do valor que aparece no google

cotacao_dolar = navegador.find_element('xpath', '//*[@id="knowledge-currency__updatable-

data-column"]/div[1]/div[2]/span[1]').get_attribute('data-value')

print(cotacao_dolar)

# PASSO 2: COTAÇÃO DO EURO

# entrar no google

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

# navegador_o que quero editar_o que quero escrever nele

navegador.find_element("xpath",
'/html/body/div[1]/div[3]/form/div[1]/div[1]/div[1]/div/div[2]/input').send_keys('cotação
euro')
 # pressionar enter

navegador.find_element("xpath",
'/html/body/div[1]/div[3]/form/div[1]/div[1]/div[1]/div/div[2]/input').send_keys(Keys.ENTER)

# pegar a cotação do google # xpath do valor que aparece no google

cotacao_euro = navegador.find_element('xpath', '//*[@id="knowledge-currency__updatable-

data-column"]/div[1]/div[2]/span[1]').get_attribute('data-value')

print(cotacao_euro)

# PASSO 3: COTAÇÃO DO OURO

# entrar no google

navegador.get('https://www.melhorcambio.com/ouro-hoje')

# pegar cotação do ouro

cotacao_ouro = navegador.find_element("xpath",
'//*[@id="comercial"]').get_attribute('value')

print (cotacao_ouro)

# navegador.quin () #para fechar o navegador após rodar

# PASSO 4: ATUALIZAR BASE DE PREÇO (DE COMPRA E VENDA)

import pandas as pd

tabela = pd.read_excel('Produtos.xlsx')

display(tabela)

# ATUALIZAR A COLUNA DE EXPORTAÇÃO

# editar coluna COTAÇÃO onde a moeda é dólar

# tabela.loc[linha, coluna]

#(tabela['Moeda'] == 'Dólar') - localiza na coluna moeda os itens dólar

# um igual (=) modifica / dois iguais (==) verifica/compara se é igual

# se quisesse editar em todas as coluna serio > tabela.loc[(tabela['Moeda'] == 'Dólar'), : ]

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)

# ATUALIZAR A COLUNA DE PREÇO DE COMPRA (preço original x cotação)

# coluna se seleciona entre colchetes

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

# ATUALIZAR A COLUNA DE PREÇO DE VENDA (preço original x margem)

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

#FORMATAÇÃO

#valor em reais com duas casas decimais

# tabela['Preço de Compra'] = tabela['Preço de Compra'].map('R${:.2f}'.format)

tabela['Preço Original'] = tabela['Preço Original'].map('R${:.2f}'.format)

tabela['Cotação'] = tabela['Cotação'].map('R${:.3f}'.format)

tabela['Preço de Compra'] = tabela['Preço de Compra'].map('R${:.2f}'.format)

tabela['Preço de Venda'] = tabela['Preço de Venda'].map('R${:.2f}'.format)

display (tabela)

# PASSO 5: EXPORTAR A BASE DE PREÇOS ATUALIZADOS

tabela.to_excel('Produtos_novo.xlsx', index=False)

# se colocar o mesmo nome, ele substitui

# index=False > retira a coluna de indice (os números a esquerda)

AULA 4

# ESSE PASSO A PASSO SERVE PARA TODO PROJETO DE CIÊNCIA DE DADOS

# Passo 1: Entendimento do Desafio

#prever as vendas baseado nos dadosde investimento em tv/radio/jornal

# Passo 2: Entendimento da Área/Empresa

# Passo 3: Extração/Obtenção de Dados

import pandas as pd

tabela = pd.read_csv('advertising.csv')

display (tabela)

# Passo 4: Ajuste de Dados (Tratamento/Limpeza)

# Verificar sempre atravé do > print(tabela.info())

!pip install matplotlib

!pip install seaborn

!pip install scikit-learn

# Passo 5: Análise Exploratória

#correlação

display(tabela.corr())

# Gráficos (instalar eles > !pip install matplotlib / !pip install seaborn)

# matplotlib # seabord
import seaborn as sns

import matplotlib.pyplot as plt

# criar gráficos

# cmap = 'escala de cores" do seaborn

# annot = True coloca os nºs dentro do gráfico

sns.heatmap(tabela.corr(), cmap='Blues', annot=True)

# se quisesse correlacionar apenas colunas especificas seria: sns.heatmap(tabela[['TV',

'VENDAS']].corr(), cmap='Blues', annot=True)

# exibir gráficos

plt.show()

# Passo 6: Modelagem + Algoritmos (Aqui que entra a Inteligência Artificial, se necessário)

# Instalador da IA (!pip install scikit-learn)

# O que preciso pra criar uma IA: uma base de dados para a IA aprender

# Separar essa base em duas partes: X e Y

# Y é quem eu quero prever

# X é quem vou usar pra prever o Y - o resto da tabela

# No exemplo: Y = Vendas / X = o restante da tabela

# Um colchetes [] para selecionar uma coluna / Dois colchetes [[]] quando quero selecioanr
mais de uma

y = tabela["Vendas"]

x = tabela[['TV', 'Radio', 'Jornal']]

# Dividir a base de dados em 2 (Dados de treino [maior parte] e Dados de teste)

# Para que a IA tenha onde testar, após treinar

# Modelo de seleção e separação para treino e teste

from sklearn.model_selection import train_test_split

# test_size=0.3 é você determinando que 30% dos dados são para teste

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

# CRIAR IA

# importar ela

from sklearn.linear_model import LinearRegression

from sklearn.ensemble import RandomForestRegressor

# criar ela

modelo_regressaolinear = LinearRegression()

modelo_arvoredecisao = RandomForestRegressor()

# treinar ela

modelo_regressaolinear.fit(x_treino, y_treino)

modelo_arvoredecisao.fit(x_treino, y_treino)

# Passo 7: Interpretação de Resultados

# importar ferramante para calcular o r² que dirá qual modelo é melhor ou seja, mais próximo
da realidade

from sklearn.metrics import r2_score

# fazer as previsões

previsao_arvoredecisao = modelo_arvoredecisao.predict (x_teste)

previsao_regressaolinear = modelo_regressaolinear.predict (x_teste)

# comparar a previsão com y_teste

print(r2_score(y_teste, previsao_arvoredecisao))

print(r2_score(y_teste, previsao_regressaolinear))

# criar uma tabela vazia

# DataFrame é o nome que o pandas dá pras suas tabelas

# e atribui os iten que vão existir nela e o que eles representam

tabela_auxiliar = pd.DataFrame()

tabela_auxiliar['y_teste'] = y_teste

tabela_auxiliar['Previsão Regressão Linear'] = previsao_regressaolinear

tabela_auxiliar['Previsão Árvore de Decisão'] = previsao_arvoredecisao

# criar um grafico de linha

# para alterar o tamanho do gráfico

# largura por altura

plt.figure (figsize=(15, 5))

sns.lineplot(data=tabela_auxiliar)

plt.show()

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

display(tabela_nova)

previsao = modelo_arvoredecisao.predict(tabela_nova)

print(previsao)

# Com dados de publicidade, quanto venderiamos?

# Utilizar o modelo já treinado e confiavel

# Importar a nova tabela

# E pedir a previsão