Automatización

Formulario

Páginas Web | WhatsApp | Emails

Excel | Google Sheets | Archivos & Carpetas

Frank Andrade
Archivos & Regex
Usamos regex para crear patrones que nos
Otros Metacaracteres
\b

Carpetas
Límite de palabra
ayuden a encontrar un texto.

Metacaracteres

\B No límite de palabra

Podemos crear carpetas y manipular archivos en Python usando Path.

\d Dígitos (0-9)
\1 Referencia

Path
Importar Path:
\D No dígitos (0-9)

Extracción de Tabla
\w Caracter de palabra (a-z, A-Z, 0-9, _) Podemos usar camelot para extraer tablas de PDFs
from pathlib import Path

y pandas para extraer tablas de páginas web.

\W No caracter de palabra
Obtener directorio actual:
>>> Path.cwd()

Espacio en blanco (tab, nueva linea, etc)

PDF
'/Users/frank/Projects/DataScience'
\s

Importar librería:

import camelot
Listar contenido en directorio: \S No espacio en blanco
>>> list(Path().iterdir())

[PosixPath('script1.py'), PosixPath('script2.py')] . Cualquier caracter excepto nueva linea Leer PDF:

tables=camelot.read_pdf('foo.pdf',
Listar contenido en directorio dentro de una carpeta: \ Ignora cualquier caracter especial
>>> list(Path('Dataset').iterdir())
pages='1',

flavor='lattice')
Unir rutas: ^ Inicio de una cadena de texto
>>> from pathlib import Path, PurePath
Exportar tablas:
>>> PurePath.joinpath(Path.cwd(), 'Dataset') $ Fin de una cadena de texto tables.export('foo.csv',
'/Users/frank/Projects/DataScience/Dataset' f='csv',

Cuantificadores & Grupos

Crear un directorio:
compress=True)
>>> Path('Dataset2').mkdir() * 0 o más (codiciosa)
>>> Path('Dataset2').mkdir(exist_ok=True)

Exportar primera tabla a un archivo CSV:

Renombrar un archivo: + 1 o más (codiciosa) tables[0].to_csv('foo.csv')
>>> current_path = Path('Data')

>>> target_path = Path('Dataset') ? 0 or 1

>>> Path.rename(current_path, target_path)
Imprimir un dataframe:

{3} Número exacto print(tables[0].df)

Revisar archivo existente:

>>> check_path = Path('Dataset')

>>> check_path.exists() # True/False {n,} Más de n caracteres

Páginas Web

Importar librería:
Metadata: {3,4} Rango de números (Min, Max)
>>> path = Path('test/expenses.csv')
import pandas as pd
>>> path.parts ( ) Grupo
('test', 'expenses.csv')

>>> path.name Leer tablas:

expenses.csv [ ] Encontrar caracteres dentro de [ ] tables=pd.read_html('https://xyz.com')
>>> path.stem

expenses [^ ] Encontrar caracteres que no estén en [ ]

>>> path.suffix
Imprimir tablas:
.csv | O print(tables[0])

Enviar Email & Crear Reportes

Mensajes
Podemos crear reportes de Excel en Python usando openpyxl.

Excel
Con Python podemos enviar emails (correos) y mensajes en WhatsApp. Crear hoja de trabajo (workbook):
from openpyxl import Workbook
Email
wb = Workbook() # crear workbook
Importar librerías: ws = wb.active # seleccionar hoja activa
import smtplib ws['C1'] = 10 # asignar data a una celda
import ssl wb.save("report.xlsx") # guardar workbook
from email.message import EmailMessage
Trabajar con workbook existente:
Fijar variables: from openpyxl import load_workbook
email_sender = 'escribe-emisor-aqui'
email_password = 'escribe-contraseña-aqui' wb = load_workbook('pivot_table.xlsx')
email_receiver = 'escribe-receptor-aqui' sheet = wb['Report'] # seleccionar hoja "Report"

subject = 'Revisa este video' Referencia de celdas:

body = """ min_column = wb.active.min_column
Acabo de publicar un nuevo video en YouTube max_column = wb.active.max_column
""" min_row = wb.active.min_row
Enviar email: max_row = wb.active.max_row
em = EmailMessage()
em['From'] = email_sender Crear Barchart:
em['To'] = email_receiver from openpyxl.chart import BarChart, Reference
em['Subject'] = subject barchart = BarChart()
em.set_content(body)
context = ssl.create_default_context() Localizar data:
data = Reference(sheet,
with smtplib.SMTP_SSL('smtp.gmail.com', 465, context=context) as smtp: min_col=min_column+1,
smtp.login(email_sender, email_password) max_col=max_column,
smtp.sendmail(email_sender, email_receiver, em.as_string()) min_row=min_row,
max_row=max_row)
WhatsApp Localizar categorías:
Importar librerías: categories = Reference(sheet,
min_col=min_column,
import pywhatkit max_col=min_column,
min_row=min_row+1,
Enviar mensaje a un contacto: max_row=max_row)
# sintaxis: numero con codigo, mensaje, hora y minutos
pywhatkit.sendwhatmsg('+1xxxxxxxx', 'Mensaje 1', 18, 52) Agregar data y categorías:

barchart.add_data(data, titles_from_data=True)
Enviar mensaje a un contacto y cerrar tab luego de 2 segundos: barchart.set_categories(categories)
# sintaxis: mismos parámetros y wait_time, tab_close and close_time
pywhatkit.sendwhatmsg(“+1xxxxxxx”, “Mensaje 2”, 18, 55, 15, True, 2) Agregar chart:

sheet.add_chart(barchart, "B12")
Enviar mensaje a un grupo:
# sintaxis: id de grupo, mensaje, hora y minutos Guardar workbook existente:
pywhatkit.sendwhatmsg_to_group("escribe-id-aqui", "Mensaje 3", 19, 2) wb.save('report_2021.xlsx')
Automatización Web HTML básico para automatizar webs
Analicemos el siguiente elemento HTML.
La automatización web es el proceso de automatizar acciones
realizadas en la web como el hacer click en botones, Tag Nombre Valor Tag
apertura Atributo Atributo cierre
seleccionar elementos de listas desplegables, etc.

Selenium 4 <h1 class="title"> Titanic (1997) </h1>

Ten en cuenta que hay algunos cambios entre las versiones de Selenium 3.x
y Selenium 4. Atributo Contenido Afectado

Importar librerías Elemento HTML

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
Este es solo un elemento HTML, pero el documento HTML detrás de
web="www.google.com" una página web tiene varios elmentos como este.
path='introduce ruta del chromedriver'
service = Service(executable_path=path) Código HTML ejemplo
driver = webdriver.Chrome(service=service) <article class="main-article">
driver.get(web) <h1> Titanic (1997) </h1>

Encontrar un elemento <p class="plot"> 84 years later ... </p>

driver.find_element(by="id", value="...") <div class="full-script"> 13 meters. You ... </div>

</article>
Encontrar elements
driver.find_elements(by="xpath", value="...") # devuelve una lista

El documento HTML está estructurado con "nodos". Cada rectángulo
Cerrar driver debajo representa un nodo (elemento, atributo o texto)
driver.quit()

Elemento Raíz Nodo Padre
Obtener el texto <article>
data = elemento.text

Espera Implícita Elemento Atributo Elemento Elemento

import time <h1> class="main-article" <p> <div>
Hermanos
time.sleep(2)

Texto Texto Texto
Atributo Atributo
Espera Explícita Titanic (1997) class="plot" 84 years later ... class="full-script"" 13 meters. You ...
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

El “nodo raíz” es el primer nodo. En nuestro ejemplo,
WebDriverWait(driver,5).until(EC.element_to_be_clickable((By.ID, <article> es la raíz
'id_name'))) #esperar 5 segundos hasta poder encontrar elemento Cada nodo tiene exactamente un nodo “padre”,

excepto por la raíz. El padre del nodo <h1> es el nodo
Opciones: Headless mode, cambiar tamaño de ventana <article>.
from selenium.webdriver.chrome.options import Options “Hermanos” son los nodos con el mismo padre
opciones = Options() Una de las mejores formas de encontrar elementos
opciones.headless = True es construyendo su XPath
opciones.add_argument('window-size=1920x1080')
driver = webdriver.Chrome(path,options=opciones)

XPath
Necesitamos aprender XPath para hacer web
Google Sheets
scraping con Selenium. Google Sheets es una hoja de calculo (spreadsheet) en la nube que puede guardar data como la mayoría de

bases de datos. Podemos conectar Google Sheets con Python activando el API y descargando nuestras
XPath Sintaxis credenciales.
Un XPath usualmente contiene un tag, nombre de Importar librerías:
atributo y valor de atributo. from gspread
from oauth2client.service_account import ServiceAccountCredentials

//tag[@Atributo="Valor"] Conectar a Google Sheets:

scope = ['https://www.googleapis.com/auth/spreadsheets',
Veamos algunos ejemplos de como localizar el "https://www.googleapis.com/auth/drive"]
elemento article, el titulo de la película y transcript

del código HTML que vimos antes. credentials=ServiceAccountCredentials.from_json_keyfile_name("credentials.json",

scope)

client = gspread.authorize(credentials)
//article[@class="main-article"]

Crear una hoja de calculo en blanco:

//h1 sheet = client.create("FirstSheet")
//div[@class="full-script"]

Compartir hoja:
sheet.share('escribe-tu-email-aqui', perm_type='user', role='writer')
XPath Funciones y Operadores

XPath funciones Guardar hoja de calculo a una carpeta especifica (primero compartir la carpeta con el correo de cliente)
client.create("SecondSheet", folder_id='escribir-id-aqui')
//tag[contains(@Atributo, "Valor")]

Abrir hoja de calculo:

XPath Operadores: and, or sheet = client.open("SecondSheet").sheet1

//tag[(expresion 1) and (expresion 2)] Leer csv con Pandas y exportar df a una hoja:
df = pd.read_csv('football_news.csv')
sheet.update([df.columns.values.tolist()] + df.values.tolist())
XPath Caracteres Especiales

Imprimir toda la data:

Selecciona los hijos del nodo ubicado a la sheet.get_all_records()
/
izquiera de este caracter
Especifica que el nodo a emparejar puede Agregar una nueva fila:
// new_row = ['0', 'titulo0', 'subtitulo0', 'link0']
estar en cualquier nivel del documento sheet.append_row(new_row)
Especifica que el contexto actual debería

. ser usado (el nodo referencia) Insertar una nueva fila en el index 2:
sheet.insert_row(new_row, index=2)
.. Selecciona a un nodo padre

Caracter comodín que selecciona todos los Actualizar una celda usando notación "A1":
* elementos sin importar el nombre sheet.update('A54', 'Hello World')

@ Selecciona un atributo Actualizar un rango:

Indica una agrupación dentro de un XPath sheet.update('A54:D54', [['51', 'titulo51', 'subtitulo51', 'link51']])
Indica que un nodo con index "n" debe ser

[n] Actualizar celda usando coordenadas de fila y columna:

seleccionado sheet.update_cell(54, 1, 'Data Actualizada')
Pandas Seleccionar filas y columnas Exportar Data

Formulario
Seleccionar una columna: Data como NumPy array:
df['col1'] df.values

Seleccionar más de una columna: Guardar data como archivo CSV:

Pandas proporciona herramientas para análisis de datos df[['col1', 'col2']] df.to_csv('output.csv', sep=",")
en Python. Los siguientes ejemplos con código están

relacionados con el dataframe debajo. Mostrar primeras n filas: Dar formato a dataframe como cadena
df.head(2) tabular:
axis 1 (eje 1)
df.to_string()
col1 col2 Mostrar últimas n filas:

df.tail(2) Convertir un dataframe a diccionario:

A 1 4
df.to_dict()
Seleccionar filas por valores del índice (index):

axis 0 (eje 0)
df = B 2 5

df.loc['A'] df.loc[['A', 'B']] Guardar un dataframe como una tabla Excel :

df.to_excel('output.xlsx')
C 3 6 Seleccionar filas por posición:
df.iloc[1] df.iloc[1:]

Tablas Pivote
Introducción Manejo de Datos Leer archivo CSV:
df_sales=pd.read_excel(
Importando pandas: Filtro por valor: 'supermarket_sales.xlsx')
df[df['col1'] > 1]

import pandas as pd Hacer tabla pivote:

Ordenar por una columna: df_sales.pivot_table(index='Gender',

Creando una serie: df.sort_values('col1') aggfunc='sum')

s = pd.Series([1, 2, 3], Hacer una tabla pivote que diga cuanta gastan
Ordenar por columnas:
index=['A', 'B', 'C'], df.sort_values(['col2', 'col2'], hombres y mujeres en cada categoría:
name='col1') ascending=[False, True])

df_sales.pivot_table(index='Gender',
Creando un dataframe: columns='Product line',
Identificar filas duplicadas:
data = [[1, 4], [2, 5], [3, 6]] df.duplicated() values='Total',
index = ['A', 'B', 'C'] aggfunc='sum')
df = pd.DataFrame(data, index=index, Eliminar duplicados:
df = df.drop_duplicates(['col1'])
columns=['col1', 'col2'])

Clonar un dataframe:
Leer archivo CSV con pandas: clon = df.copy()

Estas son mis tutoriales y cursos
df = pd.read_csv('nombre-archivo.csv') Unir múltiples dataframes verticalmente:
df2 = df + 5 #nuevo dataframe - Guías de Medium
Parametros avanzados: pd.concat([df,df2]) - Videos de YouTube

- Curso de Web Scraping
df = pd.read_csv('nombre_archivo.csv',sep=',', Unir múltiples dataframes horizontalmente:
names=['col1', 'col2'], df3 = pd.DataFrame([[7],[8],[9]], - Curso de Data Science
index_col=0, index=['A','B','C'], - Curso de Automatización
columns=['col3'])
encoding='utf-8',

nrows=3) pd.concat([df,df3], axis=1) Frank Andrade: www.youtube.com/andradefrank