Python

Formulario

Pandas | Numpy | Sklearn

Matplotlib | Seaborn
BS4 | Selenium | Scrapy
Escrito por Frank Andrade
Pandas Seleccionar filas y columnas Unir múltiples dataframes horizontalmente:
df3 = pd.DataFrame([[1, 7],[8,9]],

Formulario
Seleccionar una columna: index=['B', 'D'],
df['col1'] columns=['col1', 'col3'])
#df3: nuevo dataframe
Seleccionar más de una columna: Unir solo filas completas (INNER JOIN):
Pandas proporciona herramientas para análisis de datos df[['col1', 'col2']] df.merge(df3)
en Python. Los siguientes ejemplos con código están
relacionados con el dataframe debajo. Mostrar primeras n filas: Columna de la izquierda completa (LEFT OUTER JOIN):
df.head(2) df.merge(df3, how='left')
axis 1 (eje 1)
col1 col2 Mostrar últimas n filas: Columna de la derecha completa (RIGHT OUTER JOIN):
df.tail(2) df.merge(df3, how='right')
A 1 4
Seleccionar filas por valores del índice (index): Preservar todos los valores (OUTER JOIN):
axis 0 (eje 0)
df = B 2 5 df.loc['A'] df.loc[['A', 'B']] df.merge(df3, how='outer')

C 3 6 Seleccionar filas por posición: Unir filas por indice (index):

df.loc[1] df.loc[1:] df.merge(df3,left_index=True,
right_index=True)

Introducción Manejo de Datos Completar valor NaN:

df.fillna(0)
Importando pandas: Filtro por valor:
import pandas as pd df[df['col1'] > 1] Aplicar propia función:
def func(x):
Ordenar por columnas: return 2**x
Creando una serie: df.sort_values(['col2', 'col2'], df.apply(func)
s = pd.Series([1, 2, 3], ascending=[False, True])
index=['A', 'B', 'C'], Identificar filas duplicadas: Aritmética y estadística
name='col1') df.duplicated()
Agregar valor a todos los valores:
Creando un dataframe:
Identificar filas únicas: df + 10
data = [[1, 4], [2, 5], [3, 6]] df['col1'].unique()
index = ['A', 'B', 'C'] Suma en columnas:
df = pd.DataFrame(data, index=index, Intercambiar filas y columnas: df.sum()
df = df.transpose()
columns=['col1', 'col2']) df = df.T Suma acumulada sobre columnas:
Cargar dataframe: df.cumsum()
df = pd.read_csv('nombre_archivo.csv',sep=',', Eliminar una columna:
df = df.drop('col1', axis=1) Promedio en columnas:
names=['col1', 'col2'], df.mean()
index_col=0, Clonar un dataframe:
encoding='utf-8', clon = df.copy() Desviación estándar sobre columnas:
df.std()
nrows=3) Conectar múltiples dataframes verticalmente:
df2 = df + 5 #nuevo dataframe Contar valores únicos:
pd.concat([df,df2]) df['col1'].value_counts()

Resumir valores estadísticos:

df.describe()
Indexación jerárquica Exportar Data Gráfoco de cajas (Box-and-whisker plot):
df.plot.box()
Crear índice jerárquico: Data como NumPy array:
df.stack() df.values Histograma sobre una columna:
df['col1'].plot.hist(bins=3)
Disolver índice jerárquico: Guardar data como archivo CSV:
df.unstack() df.to_csv('output.csv', sep=",") Histograma sobre todas las columnas:
df.plot.hist(bins=3, alpha=0.5)
Dar formato a dataframe como cadena
Agrupación tabular:
df.to_string()
Establecer tick marks:
labels = ['A', 'B', 'C', 'D']
Crear grupo (objeto): posicion = [1, 2, 3, 4]
g = df.groupby('col1') Convertir un dataframe a diccionario: plt.xticks(posicion, labels)
df.to_dict() plt.yticks(posicion, labels)
Iterar sobre grupos:
for i, grupo in g: Guardar un dataframe como una tabla Excel : Seleccionar área para trazar:
print(i, grupo) df.to_excel('output.xlsx') plt.axis([0, 2.5, 0, 10]) #[desde x,
hasta x, desde y, hasta y]
Operaciones en grupos:
g.sum() Etiquetar gráfico y ejes:
g.prod()
g.mean()
Visualización plt.title('Correlation')
plt.xlabel('Nunstück')
g.std() Importar matplotlib: plt.ylabel('Slotermeyer')
g.describe() import matplotlib.pyplot as plt
Guardar gráfico reciente:
Seleccionar columnas de grupos: Empezar un nuevo diagrama: plt.savefig('plot.png')
g['col2'].sum() plt.figure() plt.savefig('plot.png',dpi=300)
g[['col2', 'col3']].sum() plt.savefig('plot.svg')
Gráfico de dispersión (Scatter plot):
Transformar valores: df.plot.scatter('col1', 'col2',
import math style='ro')
g.transform(math.log)
Gráfico de barras (Bar plot):
Aplicar una lista función en cada grupo: df.plot.bar(x='col1', y='col2',
def strsum(grupo): width=0.7)
return ''.join([str(x) for x in grupo.value])
Gráfico de áreas (Area plot):
g['col2'].apply(strsum) df.plot.area(stacked=True,
alpha=1.0)

Encuentra ejemplos prácticos en

estos videos/guías que hice:
- Pandas para usuarios Excel(link)
- Limpieza de Datos con Pandas(link)
- Expresiones Regulares (link)
Frank Andrade www.youtube.com/andradefrank
NumPy Guardar & Cargar Archivos de Texto Operaciones:
np.loadtxt('mi_archivo.txt') a.sum()
np.genfromtxt('mi_archivo.csv', a.min()

Formulario delimiter=',') b.max(axis= 0)

np.savetxt('mi_array.txt', a, b.cumsum(axis= 1) #Suma acumulada
delimiter= ' ') a.mean() #Promedio
NumPy proporciona herramientas para trabajar con arrays. Los Inspeccionar Array b.median() #Mediana
a.shape #forma array a.corrcoef() #Coeficiente Correlacion
ejemplos con código están relacionados al array debajo. np.std(b) #Deviacion estandar
len(a) #tamaño
NumPy Arrays b.ndim #dimensión
e.size #tamaño Copiar arrays:
axis 1 (eje 1) b.dtype #tipo de data h = a.view() #Crear vista
1D Array 2D Array np.copy(a)
b.dtype.name
1 2 3 1.5 2 3 b.astype(int) #cambiar tipo de data h = a.copy() #Crear copia total
axis 0 (eje 0)
Tipos de Data Ordenar arrays:
4 5 6 a.sort() #Ordenar array
np.int64
np.float32 c.sort(axis=0)
Introducción np.complex
np.bool Manipulación de Array
Importar numpy: np.object
np.string_ Transposición de Array:
import numpy as np
np.unicode_ i = np.transpose(b)
i.T
Crear arrays:
a = np.array([1,2,3]) Matemáticas con Arrays Cambiar Forma de Array:
b.ravel()
b = np.array([(1.5,2,3), (4,5,6)], dtype=float) Operaciones g.reshape(3,-2)
c = np.array([[(1.5,2,3), (4,5,6)], >>> g = a-b
[(3,2,1), (4,5,6)]], array([[-0.5, 0. , 0. ], Agregar/eliminar elementos:
[-3. , 3. , 3. ]]) h.resize((2,6))
dtype = float) >>> np.subtract(a,b) np.append(h,g)
Marcadores de posición iniciales: np.insert(a, 1, 5)
np.zeros((3,4)) #Crear un array de ceros >>> b+a np.delete(a,[1])
array([[2.5, 4. , 6. ],
np.ones((2,3,4),dtype=np.int16) [ 5. , 7. , 9. ]]) Combinar arrays:
d = np.arange(10,25,5) >>> np.add(b,a) np.concatenate((a,d),axis=0)
np.linspace( 0,2, 9) np.vstack((a,b))#apilar verticalmente
>>> a/b np.hstack((e,f))#apilar horizontalmente
e = np.full((2,2), 7) array([[ 0.66666667, 1. , 1. ],
f = np.eye(2) [ 0.2 5 , 0.4 , 0 . 5 ]]) Dividir arrays:
np.random.random((2,2)) >>> np.divide(a,b) np.hsplit(a,3) #Dividir horizontalmente
np.vsplit(c,2) #Dividir verticalmente
np.empty((3,2)) >>> a*b
array([[ 1 . 5, 4. , 9. ], Subconjunto 1.5 2 3

Guardar & Cargar En Disco: [ 4. , 10. , 18. ]]) b[1,2] 4 5 6

>>> np.multiply(a,b)
np.save('mi_array', a) Slicing:
np.savez('array.npz', a, b) >>> np.exp(b) #exponencial a[0:2] 1 2 3

np.load('mi_array.npy') >>> np.sqrt(b) #raiz

>>> np.sin(a) #seno Indexación Booleana:
1 2 3
>>> np.log(a) #logaritmo a[a<2]
>>> e.dot(f) #producto escalar
Scikit-Learn Entrenando y Testeando la Data
from sklearn.model_selection import train_test_split

Formulario
X_train,X_test,y_train,y_test = train_test_split(X,y,
random_state = 0)#divide data en train y test set

Sklearn es un software gratuito y libreria de machine learning en Python. Cuenta

Pre-procesando la Data
Estandarización
con varios algoritmos de clasificación, regresión y agrupamiento. Estandariza "features" eliminando media y escalando a la varianza de la unidad.
from sklearn.preprocessing import StandardScaler
Introducción scaler = StandardScaler().fit(X_train)
standarized_X = scaler.transform(X_train)
El código abajo demuestra los pasos básicos al usar sklearn para crear y correr un standarized_X_test = scaler.transform(X_test)
modelo en un set de data.
Normalización
Los pasos en el código incluyen cargar (load) la data, dividir (split) la data en train y test Cada muestra con al menos un componente distinto de cero se reescala
sets, scalar los sets, crear el modelo, ajustar (fit) el modelo en la data usando el modelo independientemente de otras muestras para que su norma sea igual a uno.
entrenado para hacer predicciones en el test set, y finalmente evaluar el rendimiento del from sklearn.preprocessing import Normalizer
scaler = Normalizer().fit(X_train)
modelo. normalized_X = scaler.transform(X_train)
from sklearn import neighbors,datasets,preprocessing normalized_X_test = scaler.transform(X_test)
from sklearn.model_selection import train_test_split
Binarización
from sklearn.metrics import accuracy_score Binarizar datos (valores de "feature" en 0 o 1) de acuerdo con un umbral.
iris = datasets.load_iris() from sklearn.preprocessing import Binarizer
X,y = iris.data[:,:2], iris.target binarizer = Binarizer(threshold = 0.0).fit(X)
binary_X = binarizer.transform(X_test)
X_train, X_test, y_train, y_test=train_test_split(X,y)
scaler = preprocessing_StandardScaler().fit(X_train) Codificación de características (feature) categóricas
X_train = scaler.transform(X_train) Transformador de imputación para completar valores perdidos.
from sklearn import preprocessing
X_test = scaler.transform(X_test) le = preprocessing.LabelEncoder()
knn = neighbors.KNeighborsClassifier(n_neighbors = 5) le.fit_transform(X_train)
knn.fit(X_train, y_train)
Imputación de valores perdidos
y_pred = knn.predict(X_test) from sklearn.impute import SimpleImputer
accuracy_score(y_test, y_pred) imp = SimpleImputer(missing_values=0, strategy ='mean')
imp.fit_transform(X_train)

Cargar la Data Generación de características (feature) polinomiales

from sklearn.preprocessing import PolynomialFeatures
La data necesita ser numérica y ser manipulada como NumPy array o SciPy spare matrix poly = PolynomialFeatures(5)
(arrays numericos como Pandas DataFrame’s también pueden ser usados) poly.fit_transform(X)
>>> import numpy as np
Encuentra ejemplos prácticos en
>>> X = np.random.random((10,5))
estos videos/guías que hice:
array([[0.21,0.33],
- Guía de Scikit-Learn (link)
[0.23, 0.60],
- Tokenización de textos (link)
[0.48, 0.62]])
- Predecir partidos de futbol (link)
>>> y = np.array(['A','B','A'])
array(['A', 'B', 'A']) Frank Andrade www.youtube.com/andradefrank
Crear Modelo Evaluar Rendimiento del Modelo
Modelos Supervisados Métricas de Clasificación
Regresión Lineal Accuracy Score
from sklearn.linear_model import LinearRegression knn.score(X_test,y_test)
from sklearn.metrics import accuracy_score
lr = LinearRegression(normalize = True) accuracy_score(y_test,y_pred)
Support Vector Machines (SVM)
from sklearn.svm import SVC Reporte de Clasificación
from sklearn.metrics import classification_report
svc = SVC(kernel = 'linear') print(classification_report(y_test,y_pred))
Naive Bayes
from sklearn.naive_bayes import GaussianNB Confusion Matrix
from sklearn .metrics import confusion_matrix
gnb = GaussianNB() print(confusion_matrix(y_test,y_pred))
KNN
from sklearn import neighbors Métricas de Regresión
Error Absoluto Medio
knn = neighbors.KNeighborsClassifier(n_neighbors = 5) from sklearn.metrics import mean_absolute_error
mean_absolute_error(y_test,y_pred)
Modelos No Supervisados
Error Medio Cuadrado
Principal Component Analysis (PCA) from sklearn.metrics import mean_squared_error
from sklearn.decomposition import PCA mean_squared_error(y_test,y_pred)
pca = PCA(n_components = 0.95)
R² Score
K means from sklearn.metrics import r2_score
from sklearn.cluster import KMeans r2_score(y_test, y_pred)
k_means = KMeans(n_clusters = 3, random_state = 0)
Métricas Clustering
Ajuste del modelo (Fitting) Indice Rand Adjustado
from sklearn.metrics import adjusted_rand_score
Ajustar modelos de aprendizaje supervisado y no supervisado a los datos. adjusted_rand_score(y_test,y_pred)
Aprendizaje Supervisado
Homogeneidad
lr.fit(X, y) #ajustar el modelo a la data from sklearn.metrics import homogeneity_score
knn.fit(X_train,y_train) homogeneity_score(y_test,y_pred)
svc.fit(X_train,y_train)
V-measure
Aprendizaje No Supervisado from sklearn.metrics import v_measure_score
k_means.fit(X_train) #ajustar el modelo a la data v_measure_score(y_test,y_pred)
pca_model = pca.fit_transform(X_train)#ajustar,luego transformar
Optimizar el Modelo
Predecir Grid Search
Predecir Labels from sklearn.model_selection import GridSearchCV
params = {'n_neighbors':np.arange(1,3),
y_pred = lr.predict(X_test) #Estimadores Supervisados 'metric':['euclidean','cityblock']}
y_pred = k_means.predict(X_test) #Estimadores No Supervisados grid = GridSearchCV(estimator = knn, param_grid = params)
Estimador de probabilidad de un label grid.fit(X_train, y_train)
print(grid.best_score_)
y_pred = knn.predict_proba(X_test) print(grid.best_estimator_.n_neighbors)
Visualización
Formulario
Matplotlib es una libreria de gráficos 2D de Python
que produce figuras en una variedad de formatos.
Figura
Y-axis
Matplotlib
Flujo de Trabajo
Los pasos básicos para crear una gráfica con matplotlib son Gráfico de Dispersión (Scatterplot)
Preparar Data, Graficar, Personalizar Gráfico, Guardar
Gráfico y Mostrar Gráfico.
import matplotlib.pyplot as plt
Ejemplo con Gráfico de linea
Preparar data
x = [2017, 2018, 2019, 2020, 2021]
y = [43, 45, 47, 48, 50]
Graficar & Personalizar
plt.plot(x,y,marker='o',linestyle='--',
color='g', label='Colombia')
plt.xlabel('Años')
plt.ylabel('Poblacion (M)')
plt.title('Años vs Poblacion')
plt.legend(loc='lower right')
plt.yticks([41, 45, 48, 51])
Guardar Gráfico
plt.savefig('ejemplo.png')
Mostrar Gráfico
plt.show()
Marcadores: '.', 'o', 'v', '<', '>'
Estilos de linea: '-', '--', '-.', ':'
Colores: 'b', 'g', 'r', 'y' #azul, verde, rojo, amarillo
Gráfico de Barras (Barplot)
x = ['Argentina', 'Colombia', 'Peru']
Seaborn
y = [40, 50, 33] Flujo de Trabajo
plt.bar(x, y)
plt.show() import seaborn as sns
import matplotlib.pyplot as plt
Piechart import pandas as pd
plt.pie(y, labels=x, autopct='%.0f %%') Gráfico de Lineas
plt.figure(figsize=(10, 5))
plt.show()
flights = sns.load_dataset("flights")
Histograma may_flights=flights.query("month=='May'")
ages = [15, 16, 17, 30, 31, 32, 35] ax = sns.lineplot(data=may_flights,
bins = [15, 20, 25, 30, 35] x="year",
plt.hist(ages, bins, edgecolor='black') y="passengers")
plt.show() ax.set(xlabel='x', ylabel='y',
title='my_title, xticks=[1,2,3])
Gráfico de Caja (Boxplots) ax.legend(title='my_legend,
ages = [15, 16, 17, 30, 31, 32, 35] title_fontsize=13)
X-axis
plt.boxplot(ages) plt.show()
plt.show()
Gráfico de Barras (Barplot)
tips = sns.load_dataset("tips")
a = [1, 2, 3, 4, 5, 4, 3 ,2, 5, 6, 7] ax = sns.barplot(x="day",
y="total_bill,
b = [7, 2, 3, 5, 5, 7, 3, 2, 6, 3, 2]
plt.scatter(a, b) data=tips)
plt.show() Histograma
penguins = sns.load_dataset("penguins")
sns.histplot(data=penguins,
Subplots x="flipper_length_mm")
Gráfico de Cajas (Boxplot)
Agrega el código debajo para hacer multples gráficos tips = sns.load_dataset("tips")
ax = sns.boxplot(x=tips["total_bill"])
con 'n' números de filas y columnas.
fig, ax = plt.subplots(nrows=1, Gráfico de Dispersión (Scatterplot)
ncols=2, tips = sns.load_dataset("tips")
sharey=True, sns.scatterplot(data=tips,
figsize=(12, 4)) x="total_bill",
Graficar & Personalizar Cada Gráfico y="tip")
ax[0].plot(x, y, color='g')
ax[0].legend()
Estética de la figura
ax[1].plot(a, b, color='r') sns.set_style('darkgrid') #estilos
sns.set_palette('husl', 3) #paletas
ax[1].legend()
plt.show() sns.color_palette('husl') #colores
Tamaño de letra de titulo de ejes, x e y labels, tick labels
Encuentra ejemplos prácticos en y leyendas:
estos videos/guías que hice: plt.rc('axes', titlesize=18)
plt.rc('axes', labelsize=14)
- Guía de Matplotlib (link) plt.rc('xtick', labelsize=13)
- Guía de Nube de Palabras (link) plt.rc('ytick', labelsize=13)
- Ejemplo Visualización Datos(link) plt.rc('legend', fontsize=13)
plt.rc('font', size=13)
Frank Andrade www.youtube.com/andradefrank
Web Scraping “Hermanos” son nodos con los mismos padres.
El hijo de un nodo y los hijos de sus hijos son
XPath

Formulario
llamados sus “descendientes”. Del mismo modo, el Necesitamos aprender XPath para hacer web
padre de un nodo y el padre de su padre son scraping con Selenium y Scrapy.
llamados “ancestros”.
Es recomendado buscar elementos en este orden
El web scraping nos permite extraer data de la web. Antes de a. ID XPath Sintaxis
aprender Beautiful Soup, Selenium o Scrapy, vamos a revisar b. Class name Un XPath usualmente contiene un tag, nombre de
c. Tag name
conceptos básicos de HTML. d. Xpath atributo y valor de atributo.

Beautiful Soup //tag[@Atributo="Valor"]

HTML básico para Web Scraping
Analicemos el siguiente elemento HTML. Flujo de Trabajo Veamos algunos ejemplos de como localizar el
Importar librerías elemento article, el titulo de la película y transcript
Tag Nombre Valor Tag from bs4 import BeautifulSoup del código HTML que vimos antes.
apertura Atributo Atributo cierre import requests

Obtener páginas //article[@class="main-article"]

<h1 class="title"> Titanic (1997) </h1> result=requests.get("www.google.com")
result.status_code #obtener status //h1
result.headers #obtener encabezados //div[@class="full-script"]
Atributo Contenido Afectado
Contenido de la página
Elemento HTML contenido = result.text XPath Funciones y Operadores
XPath funciones
Este es solo un elemento HTML, pero el documento HTML detrás Crear soup
soup=BeautifulSoup(contenido,"lxml") //tag[contains(@Atributo, "Valor")]
de una página web tiene varios elmentos como este.
HTML en formato legible XPath Operadores: and, or
Código HTML ejemplo
print(soup.prettify())
<article class="main-article">
//tag[(expresion 1) and (expresion 2)]
<h1> Titanic (1997) </h1> Encontrar un elemento
<p class="plot"> 84 years later ... </p> soup.find(id="mi_id")
XPath Caracteres Especiales
<div class="full-script"> 13 meters. You ... </div> Encontrar elementos
soup.find_all("a") Selecciona los hijos del nodo ubicado a la
</article> /
soup.find_all("a","css_class") izquiera de este caracter
El documento HTML está estructurado con "nodos". Cada soup.find_all("a",class_="mi_class") Especifica que el nodo a emparejar puede
soup.find_all("a",attrs={"class": //
rectángulo debajo representa un nodo (elemento, atributo o texto) "mi_class"}) estar en cualquier nivel del documento
Obtener texto Especifica que el contexto actual debería
Elemento Raíz
<article>
Nodo Padre ejemplo=elemento.get_text() . ser usado (el nodo referencia)
ejemplo=elemento.get_text(strip=True,
separator= ' ') .. Selecciona a un nodo padre
Obtener atributos Caracter comodín que selecciona todos los
Elemento Atributo Elemento Elemento ejemplo = elemento.get('href') * elementos sin importar el nombre
<h1> class="main-article" <p> <div>
Hermanos Selecciona un atributo
@
Texto Atributo Texto Atributo Texto () Indica una agrupación dentro de un XPath
Titanic (1997) class="plot" 84 years later ... class="full-script"" 13 meters. You ...
Indica que un nodo con index "n" debe ser
[n]
seleccionado
Selenium Scrapy
Flujo de Trabajo Scrapy es el framework más complete de web scraping en Python. Para
from selenium import webdriver configurarlo revisa la documentación de Scrapy.
web="www.google.com"
path='introduce ruta del chromedriver'
driver = webdriver.Chrome(path) Crear un Proyecto y Spider
driver.get(web) Para crear un nuevo proyecto, corre el siguiente comando en el terminal o cmd
scrapy startproject mi_primer_spider
Encontrar un elemento Para crear un nuevo spider, primero cambia el directorio
driver.find_element_by_id('nombre') cd mi_primer_spider
Crear un spider
Encontrar elementos scrapy genspider ejemplo ejemplo.com
driver.find_elements_by_class_name()
driver.find_elements_by_css_selector La plantilla básica
driver.find_elements_by_xpath() Cuando creamos un spider, obtenemos una plantilla con el siguiente contenido.
driver.find_elements_by_tag_name()
driver.find_elements_by_name() import scrapy
class ExampleSpider(scrapy.Spider):
Cerrar driver
driver.quit() name = 'ejemplo'
allowed_domains = ['ejemplo.com'] Clase
Obtener el texto start_urls = ['http://ejemplo.com/']
data = elemento.text
def parse(self, response):
Espera Implícita Método Parse
import time pass
time.sleep(2)
La clase es contruida con la data que introducimos en el comando previo, pero el
Espera Explícita método parse tenemos que construirlo nosotros.
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait Buscando elementos
from selenium.webdriver.support import expected_conditions as EC Para buscar elementos con Scrapy, usa el argumento "response" del método parse
response.xpath('//tag[@Atributo="Valor"]')
WebDriverWait(driver,5).until(EC.element_to_be_clickable((By.ID,
'id_name'))) #esperar 5 segundos hasta poder encontrar elemento Obtener texto
Para obtener el elemento texto usamos text() y luego .get() o .getall(). Por ejemplo:
Opciones: Headless mode, cambiar tamaño de ventana response.xpath(‘//h1/text()’).get()
from selenium.webdriver.chrome.options import Options response.xpath(‘//tag[@Atributo=”Valor”]/text()’).getall()
opciones = Options()
opciones.headless = True Devolver la data extraída
opciones.add_argument('window-size=1920x1080') Para ver la data extraída tenemos que usar la palabra clave yield
driver = webdriver.Chrome(path,options=opciones)
def parse(self, response):
Encuentra ejemplos prácticos en title = response.xpath(‘//h1/text()’).get()
estos videos/guías que hice: # Devolver data extraída
- Web Scraping con Selenium (link) yield {'titles': title}
- Web Scraping con BS4 (link)
Correr el spider y exportar data a CSV o JSON
- Web Scraping Guía Completa (link) scrapy crawl ejemplo
scrapy crawl ejemplo -o nombre_archivo.csv
Frank Andrade www.youtube.com/andradefrank scrapy crawl ejemplo -o nombre_archivo.json