Analisis de Negocios - Practicum

Teoria about:srcdoc
Sprint Anterior
Indexacion
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
Sprint 6 SQL
1 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Solicitud GET
In [ ]: import requests # Se debe importar la libreria para enviar solicitudes HTTP
# Agregamos en enlace y lo guardamos en URL

URL = 'https://practicum-content.s3.us-west-1.amazonaws.com/new-markets/Data_sprint_6/web-sites/most_famous_shipwrecks_es_1.html?etag=87662
# llamamos get de la libreria requests que actua como navegador
req = requests.get(URL) # guardando el objeto de respuesta como variable requerida
"""Un objeto response contiene la respuesta del servidor:

el código de estado, el contenido de la solicitud y el código de la propia página HTML.
Los atributos de los objetos response posibilitan obtener solo los datos relevantes del servidor.
Por ejemplo, un objeto response con el atributo text solo devolverá el contenido de texto de la solicitud:"""
print(req.text) # el nombre del atributo se coloca después del objeto de respuesta y se divide por un punto
print(req.status_code) # el atributo status_code te dice si el servidor respondio o si ocurrio un error
Este código en Python importa la librería 'requests' para hacer solicitudes HTTP y obtener datos de una página web. Luego se define una
variable 'URL' que contiene la dirección de la página web que se quiere obtener. Se usa la función 'get' de la librería requests para enviar una
solicitud HTTP al servidor de la página web. El objeto de respuesta se almacena en la variable 'req'.
El comentario explica que el objeto response contiene información del servidor, como el código de estado, el contenido y el código de la
página HTML. Luego, se usa la función 'print' para imprimir el contenido de texto de la respuesta (req.text) y el código de estado
(req.status_code).
En resumen, este código permite obtener el contenido de una página web y su código de estado.
Codigos de error: Código de error Nombre implicaciones 200 OK Todo está bien 302 Found La página ha sido movida 400 Bad Request Error en la sintaxis de la
solicitud 404 Not Found No se puede encontrar la página 500 Internal Server Error Error por parte del servidor 502 Bad Gateway Error en el intercambio de datos
entre servidores 503 Server Unvailable El servidor no puede procesar solicitudes temporalmente
Expresiones regulares
Es una herramienta que te ayuda a buscar cadenas en textos grandes
In [2]: #primera etapa

"""creamos el patrón de la expresión regular.
Este es un algoritmo que describe lo que debe buscarse dentro del texto (por ejemplo, todas las letras mayúsculas)."""
#Segunda Etapa
"""Luego, este patrón se pasa a los métodos específicos de re. Estos métodos buscan, reemplazan y eliminan símbolos.
En otras palabras, el patrón identifica qué buscar y cómo, mientras que el método define qué hacer con las coincidencias que se encuentran"
Out[2]: 'Luego, este patrón se pasa a los métodos específicos de re. Estos métodos buscan, reemplazan y eliminan símbolos. \nEn otras
palabras, el patrón identifica qué buscar y cómo, mientras que el método define qué hacer con las coincidencias que se encuent
ran'
In [ ]: Expresión regular Descripción Ejemplo Explicación

[] _ Caracter único contenido entre paréntesis [a-] a o -
[^…] Negación [^a] cualquier caracter excepto "a"
- Rango [0-9] rango: cualquier dígito del 0 al 9
. Cualquier caracter único excepto una nueva línea a. as, a1, a_
\d (see [0-9]) Cualquier dígito a\d a[0-9] a1, a2, a3
\w Cualquier letra, dígito o _ a\w a_, a1, ab
[A-z] Cualquier letra a[A-z] ab
? 0 o 1 instancia a? a o nada
+ 1 o más instancias a+ a o aa, o aaa
* 0 o más instancias a* nada o a, o aa
^ Comienzo de cadena ^a a1234, abcd
$ Fin de cadena a$ 1a, ba
\+ expresiones literales que muestre el mas
Creaciones de expresiones regulares
[0-9]: este patrón coincide con cualquier dígito del 0 al 9 (¡solo uno a la vez!). Aplicado a la cadena 155 plus 33, coincidirá con
[0-9]+: este patrón coincide con secuencias continuas de dígitos, es decir, números. Aplicado a la cadena 155 plus 33, coincidirá
^[0-9]+: ^ coincide con el comienzo de una cadena. Dado que una cadena dada solo puede tener un comienzo, este patrón siempre producirá
2 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [3]: #Search busca un patrón en una cadena

import re
string = '"General Slocum" 15 June 1904 East River human factor'
print(re.search('\w+', string))
#Si no necesitamos información sobre el intervalo, podemos devolver solo la subcadena utilizando el método group():
print(re.search('\w+', string).group())
<re.Match object; span=(1, 8), match='General'>

General
• [A-z] : este patrón coincide con cualquier letra, ya sea mayúscula o minúscula. Este patrón coincide con cada letra de la cadena, pero como
letras separadas, no como palabras.
• [A-z ] : (¡ten en cuenta el espacio al final!): este patrón indica que los espacios también son bienvenidos, pero aún coincide con un solo
caracter a la vez, ya sea una letra o un espacio.
• [A-z ]+: este patrón coincide con una secuencia de estos caracteres hasta que se encuentra algún otro caracter o se alcanza el final de la
cadena. Entonces, todos los caracteres que no están en la lista (como dígitos o signos de puntuación) se convierten esencialmente en
separadores. Si aplicamos este patrón a nuestra cadena, obtendremos tres coincidencias: General Slocum, un espacio, junio (observa los
espacios que rodean la palabra) y Río Este factor humano.
• "[A-z ]+": este patrón coincide con una comilla doble, seguida de una secuencia de letras y espacios (1 o más, sin límite superior), seguida
de otra comilla doble. Eso nos deja con "General Slocum" (contando las comillas esta vez), justo lo que estábamos buscando
In [5]: import re

print(re.search('"[A-z ]+"', string).group())
"General Slocum"
In [5]: #split(patrón, cadena) divide una cadena en los puntos donde aparece el patrón.
import re

print(re.split('\d+', string))
#El parámetro maxsplit del método split() limita el número de veces que se divide la cadena.
import re

print(re.split('\d+', string, maxsplit = 1))
['"General Slocum" ', ' June ', ' East River human factor']
['"General Slocum" ', ' June 1904 East River human factor']
In [6]: #sub(patrón, repl, cadena) busca el patrón de subcadena dentro de una cadena y lo reemplaza con la subcadena repl (replace).
import re

print(
re.sub('\d+', '', string) # REEMPLAZA LOS VALORES POR UN CAMPO VACIO ' '
) # buscamos secuencias de 1 o más dígitos
# y las eliminamos
"General Slocum" June East River human factor
3 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [7]: # findall(patrón, cadena) devuelve una lista de todas las subcadenas en una cadena que coinciden con el patrón.
#Compáralo con el método search() que solo devuelve la primera subcadena coincidente. Intentemos encontrar todas las palabras que terminen
import re
tion = "Arrived at the station in total frustration"

print(re.findall('[A-z]+tion', tion))
print('Palabras con guion')
#Palabras con guion
string = 'sixty-seven drops of rain'

print(re.findall('\w+-\w+', string))
#len(), te permite determinar cuántas veces se repite una subcadena:

print(len(re.findall('\w+', string)))
#Agreguemos '-' a la expresión regular y contemos "sixty-seven" como una sola palabra.

print(len(re.findall('[\w-]+', string)))
['station', 'frustration']
Palabras con guion
['sixty-seven']
5
4
https://regexone.com (lecciones cortas y práctica)

https://docs.python.org/3/howto/regex.html#regex-howto (introducción a regex, sin práctica)
https://github.com/ziishaned/learn-regex (otra introducción)
https://regexr.com (una herramienta para probar expresiones regulares y ver cómo funcionan)
https://www.debuggex.com/cheatsheet/regex/python (una referencia útil)
In [8]: #Ejericio
"""Luego escribe una expresión regular para encontrar las etiquetas <title> </title> y su contenido.
Muestra el resultado de la siguiente manera: <title>. Texto de la etiqueta.</title>."""
URL = 'https://practicum-com.github.io/simple-shop_es/'
req_text = requests.get(URL).text
print(re.search('<title>[A-ü ]+</title>', req_text).group())
"""Escribe una expresión regular que genere todos los nombres de productos que incluyan la palabra "Mantequilla"
(ten en cuenta la letra mayúscula). "Mantequilla" puede aparecer en medio del nombre.
Así que podría haber 0 o más letras o espacios antes de "Mantequilla" y podría haber algunas letras o espacios después.
No necesitamos incluir el peso neto en nuestros nombres, así que no incluyas una coma en tu expresión regular """
print(re.findall('[A-ü ]*Mantequilla[A-ü ]*', req_text))
""" Indica que la búsqueda de subcadenas que coincidan con el patrón debe realizarse en la cadena req_text.
Luego usa la función len() para encontrar la cantidad de productos que cumplan las condiciones."""
found_products = re.findall('Horizon[ \w\-%]+', req_text)

print(len(found_products))
print(found_products)
<title>Tierra de lácteos Tienda</title>

['Kerrygold Mantequilla irlandesa con aceite de canola', 'Danish Creamery Mantequilla sin sal', 'Kelapo Ghee Mantequilla clari
ficada', 'Land O Lakes Mantequilla baja en sodio con aceite de canola']
4
['Horizon Organic Leche chocolatada baja en grasa enriquecida con omega-3 DHA', 'Horizon Organic Leche Entera', 'Horizon Organ
ic Leche de vainilla baja en grasa enriquecida con omega-3 DHA', 'Horizon Organic Leche reducida en grasa al 2% enriquecida co
n omega-3 DHA']
Analisis sintactico HTTML
Los métodos de BeautifulSoup convierten un archivo HTML en una estructura de árbol
4 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [9]: #importamos la libreria

from bs4 import BeautifulSoup
#Con esto lo convertimos en arbol

soup=BeautifulSoup(req.text, 'lxml') #lxml es el mas rapido analisador
#Llamamos al metodo find()
heading_2=soup.find("h2")
print(heading_2) # ntentemos encontrar el primer encabezado de segundo nivel
heading_2.text # para que nos devuelva una cadena y no un texto
#Hay otro metodo que encuenrta todos los elementos
paragraph = soup.find_all(
'p'
) # recordatorio: p significa párrafo, el texto entre las etiquetas <p> y </p>
print(paragraph)
#Usamos el metodo texto para extrar solo el contenido
for paragraph in soup.find_all('p'):

print(paragraph.text)
#Usamos el metodo attrs (atributos) qe busca clases e identificadores
soup.find("table",attrs={"id": "ten_years_first"})
#vamos a extrar cierta informacion y la convertiremos en un df
table = soup.find('table',attrs={"id": "ten_years_first"})

# aplicando el método de búsqueda a la etiqueta de la tabla
# especificando el atributo de la primera tabla: ten_years_first
print(table)
<h2>Los mayores naufragios del siglo XX</h2>

[<p>
Gracias a Hollywood, solemos asociar todos los naufragios con el Titanic,
pero a principios del siglo XX tambiÃ©n se presenciaron varios desastres
marÃtimos.
</p>, <p>Y aquÃ tenemos tres naufragios de 1910, incluyendo al Titanic.</p>]
Gracias a Hollywood, solemos asociar todos los naufragios con el Titanic,

pero a principios del siglo XX tambiÃ©n se presenciaron varios desastres
marÃtimos.
Y aquÃ tenemos tres naufragios de 1910, incluyendo al Titanic.

<table border="1" cellpadding="5" id="ten_years_first" width="100%">
<tr>
<th>Nombre del barco</th>
<th>Fecha del naufragio</th>
<th>Lugar del naufragio</th>
<th>Causa</th>
</tr>
<tr>
<td>General Slocum</td>
<td>15 de junio de 1904</td>
<td>RÃo Este</td>
<td>Factor humano</td>
</tr>
<tr>
<td>Camorta</td>
<td>6 de mayo de 1902</td>
<td>BahÃa de Bengala</td>
<td>Fuerza de la naturaleza</td>
</tr>
<tr>
<td>Norge</td>
<td>28 de junio de 1904</td>
<td>OcÃ©ano AtlÃ¡ntico</td>
<td>Factor humano</td>
</tr>
</table>
5 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [10]: # Vamos a crear una lista vacia y guardar los encabezados ahi
heading_table = [] # Lista donde se almacenarán los nombres de las columnas

for row in table.find_all(
'th'
): # Los nombres de las columnas están dentro de los elementos <th>,
# así que encontraremos todos los elementos <th> en la tabla y los ejecutaremos en un bucle
heading_table.append(
row.text
) # Agrega el contenido de la etiqueta <th> a la lista heading_table usando append()
print(heading_table)
['Nombre del barco', 'Fecha del naufragio', 'Lugar del naufragio', 'Causa']
In [11]: # Ahora crearemos una lista vacia
content = [] # lista donde se almacenarán los datos de la tabla

for row in table.find_all('tr'):
# Cada fila está envuelta en una etiqueta <tr>, necesitamos recorrer todas las filas
if not row.find_all('th'):
# Necesitamos esta condición para ignorar la primera fila de la tabla, con encabezados
content.append([element.text for element in row.find_all('td')])
# Dentro de cada fila, el contenido de la celda está envuelto en etiquetas <td> </td>
# Necesitamos recorrer todos los elementos <td>, extraer el contenido de las celdas y agregarlo a la lista
# Luego agregamos cada una de las listas a la lista de contenido
print(content)
[['General Slocum', '15 de junio de 1904', 'RÃ\xado Este', 'Factor humano'], ['Camorta', '6 de mayo de 1902', 'BahÃ\xada de Be
ngala', 'Fuerza de la naturaleza'], ['Norge', '28 de junio de 1904', 'OcÃ©ano AtlÃ¡ntico', 'Factor humano']]
In [12]: """Terminamos con dos listas.

Almacenamos los nombres de las columnas en la lista heading_table, mientras que la lista content lleva el contenido de la tabla en forma de
import pandas as pd
shipwrecks = pd.DataFrame(content, columns=heading_table)

# pasa la lista de contenido bidimensional como datos y heading_table como encabezados
shipwrecks.head()
Out[12]: Nombre del barco Fecha del naufragio Lugar del naufragio Causa
0 General Slocum 15 de junio de 1904 RÃo Este Factor humano
1 Camorta 6 de mayo de 1902 BahÃa de Bengala Fuerza de la naturaleza
2 Norge 28 de junio de 1904 OcÃ©ano AtlÃ¡ntico Factor humano
In [13]: #Ejercicio
#Paso 1_ importamos las librerias

import pandas as pd
import requests # Importa la librería para enviar solicitudes al servidor
from bs4 import BeautifulSoup # Importa la librería para analizar la página web
URL = 'https://practicum-com.github.io/simple-shop_es/'
req = requests.get(URL) # solicitud GET
soup = BeautifulSoup(req.text, 'lxml')
#Paso_2 creamos una lista vacia que alcamene los nombres de los productos usando find_all
name_products = []
for row in soup.find_all(
'p', attrs={'class': 't754__title t-name t-name_md js-product-name'}
):
name_products.append(row.text)
#Paso_3 Creamos una lista vacia donde almacene los precios

price = [] # Lista donde se almacenan los precios de los productos
for row in soup.find_all(
'p', attrs={'class': 't754__price-value js-product-price'}
):
price.append(row.text)
#Paso 4: Creamos un dataframe de las dos variables anteriores
products_data = (
pd.DataFrame()
) # DataFrame con los datos de nombres de productos y precios
products_data['name'] = name_products
products_data['price'] = price
print(products_data.head(5))
6 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
name price
0 Leche de vaca entera, 1 galón $4.23
1 Fairlife Leche entera, 52 onzas $3.11
2 Nestle Nesquik Leche chocolatada baja en grasa... $11.54
3 Moo-Moo Leche desnatada con ingredientes selec... $0.92
4 Moo-Moo Leche desnatada con ingredientes selec... $2.3
API:
permiten acceder a datos de diferentes fuentes y automatizar el proceso de recolección de datos, lo que puede acelerar el proceso de análisis
y mejorar la calidad de la información obtenida.
• En caso que sea una pagina privada, primero se debe inciar sesion
In [ ]: # Acceso por numero de pagina
URL = 'https://yandex.com/'
PARAM={"page": "4"} #USAMOS UN PARAMETRO
req = requests.get(url = URL, params = PARAM)
In [ ]: import requests
BASE_URL = "https://weather.data-analyst.praktikum-services.ru/v1/forecast"
#APLICAMOS UN PARAMETRO
params = { # diccionario con parámetros de solicitud
"city" : "Moscow", # indicamos la ciudad
"hour" : True # especificamos la necesidad de un pronóstico por hora
}
# Llamamos a la funcion get con los parametros que necesitamos
response = requests.get(BASE_URL, params=params)
print(response.text)
Ejericicio
import requests
• Aplicar un parametro de ciudad moscu y que aplique solo 5 dias
params = { # diccionario con parámetros de solicitud "city" : "Moscow", "limit": 5 } response = requests.get(BASE_URL, params=params)
print(response.text)
*no incluyas el pronóstico por hora; simplemente pasa a esta clave de diccionario el valor False.
params = { "city" : "Moscow", "limit" : 5, "hours" : False, "extra" : True } response = requests.get(BASE_URL, params=params) print(response.text)
JSON
Se utiliza a menudo para intercambiar datos estructurados entre diferentes sistemas y herramientas de análisis, como bases de datos,
aplicaciones de visualización de datos, herramientas de aprendizaje automático y otros sistemas.
• Parece un diccioanrio
• recopilas datos dentro de un objeto (una lista de pares clave : valor) y luego creas una cadena para pasarla en una solicitud. El receptor
vuelve a convertir esta cadena en un objeto.
• Libreria : import json
In [16]: import json
7 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [19]: #Convierte cadenas

x = '{"Nombre": "General Slocum", "fecha": "Junio 15, 1904"}'
y = json.loads(x)
print('Nombre : {0}, fecha : {1}'.format(y['Nombre'], y['fecha']))
#Creamos un cuble para eso
x = '[{"Nombre": "General Slocum", "fecha": "Junio 15, 1904"}, {"Nombre": "Camorta", "fecha": "6 de mayo, 1902"}]'
y = json.loads(x)
for i in y:
print('Nombre : {0}, fecha : {1}'.format(i['Nombre'], i['fecha']))
# El método json.dumps(), por el contrario, convierte los datos de Python al formato JSON.
out = json.dumps(y)
print(out)
Nombre : General Slocum, fecha : Junio 15, 1904

Nombre : General Slocum, fecha : Junio 15, 1904
Nombre : Camorta, fecha : 6 de mayo, 1902
[{"Nombre": "General Slocum", "fecha": "Junio 15, 1904"}, {"Nombre": "Camorta", "fecha": "6 de mayo, 1902"}]
EJERCICIO
1. En la lección anterior, analizaste datos de un sitio web meteorológico, pero fue difícil distinguir las claves individuales en el diccionario
porque había mucho texto. Por ejemplo, aquí tienes la llave info, con datos de la ciudad del pronóstico. Procesa el contenido de texto de
la respuesta (response.text) con el método json.loads() y guárdalo en la variable response_parsed. Recupera los datos con la clave 'info' y
muestra los resultados.
2. Procesa el contenido de texto de la respuesta (response.text) con el método json.loads() y guárdalo en la variable response_parsed.
Recupera los datos con la clave'fact' y muestra los resultados.
3. Procesa el contenido de texto de la respuesta (response.text) con el método json.loads() y guárdalo en la variable response_parsed.
Recupera los datos con la llave 'fact' y guarda el resultado en la variable fact_weather. Pasa esta variable a json.dumps()dentro del
argumento de la función print().
In [24]: import requests

import json
params = {
"city" : "Moscow"
}
response = requests.get(BASE_URL, params=params)

response_parsed = json.loads(response.text)
print(response_parsed['info'])
#Punto 2
print(response_parsed['fact'])
#Punto 3
fact_weather = response_parsed['fact']
print(json.dumps(fact_weather))
{'f': True, 'n': True, 'nr': True, 'ns': True, 'nsr': True, 'p': True, 'lat': 55.753215, 'lon': 37.622504, 'geoid': 213, 'slug
': 'moscow', 'zoom': 10, 'tzinfo': {'name': 'Europe/Moscow', 'abbr': 'MSK', 'offset': 10800, 'dst': False}, 'def_pressure_mm':
745, 'def_pressure_pa': 994, '_h': False, 'url': 'https://yandex.ru/pogoda/moscow'}
{'temp': 28, 'feels_like': 28, 'icon': 'bkn_d', 'condition': 'cloudy', 'wind_speed': 1, 'wind_gust': 6.9, 'wind_dir': 'w', 'pr
essure_mm': 752, 'pressure_pa': 1003, 'humidity': 39, 'uv_index': 2, 'soil_temp': 24, 'soil_moisture': 0.36, 'daytime': 'd', '
polar': False, 'season': 'summer', 'obs_time': 1566306726, 'accum_prec': {'1': 0, '3': 0, '7': 0}, 'source': 'station', '_mode
': 'nearest(16:tp)'}
{"temp": 28, "feels_like": 28, "icon": "bkn_d", "condition": "cloudy", "wind_speed": 1, "wind_gust": 6.9, "wind_dir": "w", "pr
essure_mm": 752, "pressure_pa": 1003, "humidity": 39, "uv_index": 2, "soil_temp": 24, "soil_moisture": 0.36, "daytime": "d", "
polar": false, "season": "summer", "obs_time": 1566306726, "accum_prec": {"1": 0, "3": 0, "7": 0}, "source": "station", "_mod
e": "nearest(16:tp)"}
SQL
# Sintaxis pricipal SELECT column_1, # En caso que queramos seleccionar toda la tabla se debe colocar * column_2, column_3, column_4 FROM table_name
WHERE column_1 = value_1 AND column_2 = value_2 AND column_4 = value_3;
8 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: Name Meaning
= igual a
<>, != diferente a
> mayor que
< menor que
>= mayor o igual que
<= menor o igual que
operator description
AND selecciona las filas para las que se cumplen ambas condiciones
OR selecciona las filas para las que se cumplen una o ambas condiciones
NOT selecciona las filas para las que la condición es falsa
BETWEN- ENTRE
In [1]: #Slices
SELECT
name,
author,
date_pub,
pages
FROM
books
WHERE
date_pub > '1995-12-31'
AND date_pub < '2001-01-01';
#Ejemplo between
WHERE
date_pub BETWEEN '1996-01-01'
AND '2000-12-31';
#Ejemplo in
WHERE
genre IN ('Humor', 'Fantasy', 'Young Adult');
IN ('yyyy-mm-dd','yyyy-mm-dd')
Ejercicio
1- Estudia qué artículos tienen en oferta las tiendas y cuáles son sus cifras de ventas para el 1 de junio. Puedes obtener información sobre las
actualizaciones diarias del catálogo de productos en la tabla products_data_all. Escribe una consulta para seleccionar los siguientes campos de
la tabla:
Nombre del producto (name)

Precio (price)
Nombre de la tienda (name_store)
Fecha (date_upd)
Crea un slice de datos basado en la categoría (category) y la fecha (date_upd). Te interesa la categoría milk y la fecha del Día Mundial de la
Leche — '2019-06-01'. Ten en cuenta que vamos a especificar las condiciones en el bloque WHERE, no en el bloque SELECT.
2- Descarga los campos name, price, name_store, date_upd (en ese orden) de la categoría milk para los sábados restantes de junio (8, 15, 22 y
29 de junio).
3- Descarga los campos name, price, name_store, date_upd (en ese orden) de la categoría milk para los sábados restantes de junio (8, 15, 22 y
29 de junio).
9 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [4]: # ejemplo 1
SELECT
name,
price,
name_store,
date_upd
FROM
products_data_all
WHERE
category = 'milk'
AND date_upd = '2019-06-01';
#ejemplo 2
SELECT
name,
price,
name_store,
date_upd
FROM
products_data_all
WHERE
category = 'milk'
AND date_upd IN ('2019-06-08', '2019-06-15', '2019-06-22', '2019-06-29');
Funciones de agregacion
• Se debe llamar al comnado con AS

• Se aplica a "SELECT"
• Funciones agregados: COUNT
In [ ]: SELECT
AGGREGATE_FUNCTION (field) AS here_you_are
--here_you_are - nombre de la columna donde se almacenará el resultado de la función
FROM
TABLE;
In [5]: #COUNT
SELECT
COUNT(*) AS cnt, #devuelve el número total de filas de la tabla
COUNT(publisher_id) AS publisher_id_cnt, #devuelve el número de valores en una columna
COUNT(DISTINCT publisher_id) AS publisher_id_uniq_cnt #devuelve el número de valores únicos en una columna
FROM
books;
#SUM
SELECT
SUM(pages) AS total_pages
FROM
books;
#AVEREGE
SELECT
AVG(rating) AS average # ESTO NO FUNCIONARA PORQUE HAY STRING Y SE NECESITA NUMEROS
FROM
books;
# OPCION 2
SELECT
AVG(pages) AS average_pages
FROM
books;
Conversion de cadenas
10 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Para convertir los tipos de datos se debe aplicar CAST

CAST (column_name AS data_type)
Tipos de datos
Tipos de datos numéricos
integer: un tipo de número entero similar a int en Python. En PostgreSQL los números enteros van desde -2147483648 hasta 2147483647. real:
un número de coma flotante, como float en Python. La precisión de los números en el tipo real es de hasta 6 puntos decimales.
Tipos de datos de string
'Practicum': es un ejemplo de un valor de tipo string. En las instrucciones SQL va entre comillas simples. varchar(n): un string de caracteres de
longitud variable donde n es el número máximo de caracteres. text: un string de cualquier longitud. Fecha y hora
Fechas y horas van entre comillas simples.
timestamp: fecha y hora. Similar a datetime en pandas. Este formato se usa con mayor frecuencia para almacenar eventos que ocurren varias
veces al día, como registros de usuarios de sitios web. date: una fecha
Lógico
bool: un tipo de datos lógico. Puede tener tres valores en PostgreSQL: TRUE, FALSE y NULL (desconocido). Estos son los tipos de datos más
comunes
Opcion 1 SELECT AVG(rating::real) AS average FROM books; Opcion 2 SELECT AVG(CAST(rating AS real)) AS average FROM books;
In [ ]: #Ejercicio
#1.Escribe una consulta para encontrar el peso máximo del producto en la categoría 'milk'. Utiliza el operador CAST AS y nombra la variable
SELECT
MAX(CAST(weight AS real)) AS max_weight
FROM
products_data_all
WHERE
Group by
Agrupacion de datos, por ejemplo si queremos que nos cuenta la cantidad de libros que tienen diferentes autores
11 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: #Sin agrupacion
SELECT
COUNT(name) AS cnt
FROM
books
WHERE
author = 'Stephen King';
#Con agrupacion de una solo columna
SELECT
author,
COUNT(name) AS cnt
FROM
books
GROUP BY
author;
#Agrupacion de mas de una columna
SELECT
author,
genre,
COUNT(name) AS cnt
FROM
books
GROUP BY
author,
genre;
# ademas de count se puede usar con otros mas
GROUP BY se puede usar con cualquier función de agregación: COUNT, AVG, SUM, MAX y MIN.
Ejercicios
1. Escribe una consulta para calcular el número total de productos y el número de productos únicos para cada tienda (name_store). Nombra
las variables name_cnt y name_uniq_cnt respectivamente. Imprime los nombres de las tiendas, el número total de productos y el número
de productos únicos. Las columnas deben aparecer en este orden:name_store, name_cnt, name_uniq_cnt.
2. Escribe una consulta para calcular el peso máximo de producto para cada categoría (category). Nombra la variable max_weight. Imprime la
categoría y el peso máximo.
3. Escribe una consulta para calcular el precio (price) promedio del producto, el precio mínimo y el máximo del producto para cada tienda
(name_store) de la tabla products_data_all. Nombra las variables average_price, max_price y min_price respectivamente. Imprime el
nombre de la tienda y los precios promedio, mínimo y máximo.
4. Escribe una consulta para calcular la diferencia entre los precios máximos y mínimos de cada uno de los productos de la categoría 'leche'
el 10 de junio de 2019. Nombra la variable max_min_diff. Convierte valores de fecha de strings al formato date. Luego imprime el nombre
del producto y la diferencia entre el precio máximo y mínimo. Estas son las columnas que utilizarás: Categoría: campo category Fecha:
campo date_upd Precio: campo price
12 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: # 1
SELECT
name_store,
COUNT(name) AS name_cnt,
COUNT(DISTINCT name) AS name_uniq_cnt
FROM
products_data_all
GROUP BY
name_store;
#2
SELECT
category,
MAX(weight::real) AS max_weight
FROM
products_data_all
GROUP BY
category;
#3
SELECT
name_store,
AVG(price) AS average_price,
MAX(price) AS max_price,
MIN(price) AS min_price
FROM
products_data_all
GROUP BY
name_store;
#4
SELECT
name,
MAX(price) - MIN(price) AS max_min_diff
FROM
products_data_all
WHERE
category = 'milk'
AND date_upd::date = '2019-06-10'
GROUP BY
name;
Order by : En SQL, puedes ordenar los datos de una tabla utilizando la cláusula ORDER BY.Esta cláusula se utiliza para especificar el orden en
que se deben mostrar los resultados de una consulta.
Puedes ordenar los datos en orden ascendente o descendente, y puedes especificar múltiples columnas de ordenación si lo deseas
In [ ]: *Ascendente*
SELECT *
FROM students
ORDER BY grade;
*Descendente*
SELECT *
FROM students
ORDER BY grade DESC;
Limit : para colocar un limite de filas que queremos mostras se coloca limit
13 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: SELECT *
FROM students
LIMIT 10;
y si el limite se encuentra en un intervalo se debe usar lo siguiente
SELECT *
FROM students
LIMIT 10 OFFSET 10;
**Ejercicio** Escribe una consulta para calcular la cantidad de productos únicos para cada categoría en la tienda 'T-E-B' para la fecha '2019-06-30'. Asigna un
nombre a la variable uniq_name_cnt y ordena los datos por este campo en orden descendente. Convierte la fecha al tipo date y llama el campo resultante
update_date. Después imprime la fecha, el nombre de la tienda, el nombre de la categoría y la cantidad de productos únicos. SELECT date_upd::date AS
update_date, name_store, category, COUNT(DISTINCT name) AS uniq_name_cnt FROM products_data_all WHERE name_store = 'T-E-B' AND date_upd::date =
'2019-06-30' GROUP BY update_date, name_store, ORDER BY uniq_name_cnt DESC;
Procesar datos dentro de una agrupación
• GROUP BY: Es una cláusula utilizada en SQL para agrupar filas en una tabla según los valores de una o varias columnas. Esto significa que
puedes agrupar los datos en función de los valores de una columna y, a continuación, realizar operaciones de agregación sobre los datos
dentro de cada grupo utilizando funciones como AVG, SUM, MAX, MIN, COUNT, etc.
• HAVING: Es una cláusula que se utiliza en combinación con GROUP BY en SQL para filtrar los grupos de filas según una condición de
agregación. Es similar a la cláusula WHERE, pero se aplica a los grupos de filas en lugar de a filas individuales.
• ORDER BY: Es una cláusula utilizada en SQL para ordenar los resultados de una consulta por una o varias columnas. Puedes ordenar los
resultados en orden ascendente (ASC) o descendente (DESC) y también puedes especificar varias columnas de ordenación en caso de
empate. La cláusula ORDER BY se coloca al final de la consulta, después de SELECT, FROM, WHERE, GROUP BY y HAVING
Ejemplo
Supongamos que tenemos una tabla llamada ventas que contiene datos de ventas de diferentes productos en diferentes ciudades, y queremos
obtener las ciudades con ventas totales superiores a 1000 unidades
SELECT ciudad, SUM(cantidad) as ventas_totales FROM ventas GROUP BY ciudad HAVING SUM(cantidad) > 1000 ORDER BY ventas_totales DESC; En esta
consulta, primero utilizamos GROUP BY para agrupar las filas de la tabla ventas por ciudad, de manera que tendremos un grupo de filas para cada ciudad
distinta en la tabla. A continuación, utilizamos la función de agregación SUM para calcular la cantidad total de ventas en cada ciudad y le asignamos un alias
ventas_totales. Luego utilizamos la cláusula HAVING para filtrar los grupos de filas y sólo mostrar las ciudades con ventas totales superiores a 1000 unidades.
Finalmente, utilizamos ORDER BY para ordenar los resultados en orden descendente según la cantidad de ventas totales, de manera que las ciudades con las
mayores ventas totales aparezcan primero en la lista.**Diferencia entre having y where** En otras palabras, WHERE se utiliza para aplicar condiciones a las filas
individuales de una tabla antes de que se agrupen y se realicen las operaciones de agregación. Por ejemplo, si queremos seleccionar todas las filas de una tabla
donde el valor de una columna es mayor que 10, podemos utilizar WHERE de la siguiente manera: SELECT * FROM tabla WHERE columna > 10; Por otro lado,
HAVING se utiliza para aplicar condiciones a los grupos de filas después de que se hayan creado mediante GROUP BY y se hayan realizado las operaciones de
agregación. Por ejemplo, si queremos seleccionar solo los grupos de filas que tengan una suma mayor a 100, podemos utilizar HAVING de la siguiente manera:
SELECT columna1, SUM(columna2) as suma FROM tabla GROUP BY columna1 HAVING SUM(columna2) > 100;
Operadores y funciones para trabajar con fechas
14 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: #función EXTRACT:
SELECT
EXTRACT(date_fragment FROM column_name) AS new_column_with_date
FROM
Table_with_all_dates;
#Lo que se puede extraer
Puedes recuperar:
century: siglo
day: día
doy: día del año, del 1 al 365/366
isodow: día de la semana según ISO 8601, el formato internacional de fecha y hora; El lunes es 1, el domingo es 7
hour: hora
milliseconds: milisegundos
minute: minutos
second: segundos
month: mes
quarter: trimestre
week: semana del año
year: año
#Ejemplo ;
SELECT
id_user,
EXTRACT(MONTH FROM log_on) AS month_activity,
EXTRACT(DAY FROM log_on) AS day_activity
FROM
user_activity;
In [ ]: # Funcion DATE_TRUNC: trunca la fecha cuando solo necesitas un cierto nivel de precisión. es decir reducirlo al valor que queremos
'microseconds': microsegundos
milliseconds: milisegundos
second: segundos
minute: minutos
hour: hora
'day': día
week: semana del año
month: mes
quarter: trimestre
'year': año
'decade': década century:
#Ejemplo
SELECT
DATE_TRUNC('hour', log_on) AS date_log_on
FROM
user_activity;
Subconsultas : Las subconsultas en SQL son como consultas dentro de otras consultas. Son útiles cuando necesitamos obtener datos de una
tabla que dependen de otra tabla, y no podemos obtenerlos con una sola consulta.
• Se pueden realizar en varias ubicaciones como en SELECT, WHERE. FROM

• Siempre se escriben entre parentisis
15 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: Ejemplo 1
SELECT
AVG(Sub.count_rating) AS avg_count_rating
FROM
(SELECT
COUNT(rating) as count_rating
FROM
books
GROUP BY genre) AS Sub;
Ejemplo 2
SELECT
column_name,
column_name_1
FROM
table_name
WHERE
column_name =
(SELECT
column_1
FROM
table_name_2
WHERE
column_1 = value);
Ejemplo 3
SELECT
column_name,
column_name_1
FROM
table_name
WHERE
column_name IN
(SELECT
column_1
FROM
table_name_2
WHERE
column_1 = value_1 OR column_1 = value_2);
Ejemplo 4
SELECT
name,
publisher_id
FROM
books
WHERE
publisher_id IN
(SELECT
publisher_id
FROM
publisher
WHERE
name IN ('Knopf', 'Collins', 'Crown'));
Funcion Ventana :
La función de ventana en SQL es una función que permite realizar cálculos en un conjunto de filas dentro de una consulta, sin tener que
agrupar las filas ni crear subconsultas. En otras palabras, la función de ventana es una forma de calcular valores que dependen de un conjunto
de filas, sin tener que agrupar o filtrar los datos.
In [ ]: #over
SELECT
author_id,
name,
price / SUM(price) OVER () AS ratio
FROM
books_price;
16 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Este código utiliza la función de ventana SUM() para calcular la suma total de precios en la tabla books_price. Luego, utiliza esta suma para
calcular el cociente de cada precio dividido por la suma total de precios, obteniendo así un ratio o porcentaje de cada precio en relación a la
suma total de precios.
La consulta devuelve tres columnas:
author_id: el ID del autor del libro.

name: el nombre del libro.
price / SUM(price) OVER (): el precio del libro dividido por la suma total de precios en la tabla. La
cláusula OVER () indica que se está calculando la suma total de precios sobre todas las filas de la tabla.
AS ratio: el alias o nombre de la columna resultante.
En resumen, este código utiliza la función de ventana SUM() para calcular la suma total de precios en la tabla, y luego calcula el cociente de
cada precio dividido por la suma total de precios, obteniendo así un ratio o porcentaje de cada precio en relación a la suma total de precios.
PARTITION BY: en excel seria como una sumasiconjunto, es decir, de acuerdo a dos condiciones entre dos columnas diferentes, se debe
realizar la suma
En SQL, PARTITION BY es una cláusula que se utiliza junto con las funciones de ventana (como SUM, AVG, COUNT, etc.) para dividir los
resultados de la función en grupos o particiones basados en los valores de una o más columnas.
Imagina que tienes una tabla de ventas con las columnas fecha, vendedor, producto y monto. Si quisieras calcular la suma de las ventas por
vendedor y producto, podrías utilizar la función de ventana SUM() junto con la cláusula PARTITION BY para agrupar las ventas por vendedor y
producto.
La consulta en SQL sería la siguiente:
In [ ]: SELECT
vendedor,
producto,
SUM(monto) OVER (PARTITION BY vendedor, producto) AS suma_ventas
FROM
ventas;
En esta consulta, la cláusula PARTITION BY se utiliza para agrupar las ventas por vendedor y producto. La función de ventana SUM() se aplica a cada grupo de
ventas por separado, y devuelve la suma de los montos de venta por cada vendedor y producto. El resultado de la consulta sería una tabla que muestra la suma
de ventas por vendedor y producto: vendedor producto suma_ventas Juan Zapatos 1000 Juan Camisas 500 Maria Zapatos 800 Maria Camisas 1200 En resumen,
la cláusula PARTITION BY se utiliza para dividir los resultados de una función de ventana en grupos o particiones basados en los valores de una o más columnas
Funciones de ventana en más detalle
Este código de SQL utiliza una función de ventana, que es una función analítica que calcula un valor basado en un conjunto de filas en una
tabla. En particular, la función de ventana utilizada aquí es la función SUM, que calcula la suma de una columna en un conjunto de filas.
• EN OVER () SE PUEDE INCLUIR VARIAS CONDICIONES, DE LAS CUALES PODEMOS INCLUIR
UNBOUNDED PRECEDING: todas las filas que están por encima de la actual
N PRECEDING: las n filas por encima de la actual
CURRENT ROW: la fila actual
N FOLLOWING: las n filas debajo de la actual
UNBOUNDED FOLLOWING: todas las filas debajo de la actual
In [6]: #Esto nos da el número acumulado de páginas para cada autor:
SELECT
author_id,
name,
pages,
SUM(pages) OVER (PARTITION BY author_id ORDER BY author_id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM
books_price;
Lo que hace es una suma acumlada de acuerdo a una condicion, es decir del autor 0, debe hacer una suma acumulada de hojas en una
solumna aparte, y luego del autor 1 hace lo mismo. asi apra cada uno. esto puede servir para las tablas de frecuencia
17 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Ademas de sum, count Y avg existen otras funciones especiales en donde uno puede trabajar en las ventanas
Funciones de clasificación: RANK : nos clasifica los datos mediante rangos, por ejemplo, tenemos en una columna los departamentos, y
una segunda columna los salarios, la funcion rang va agregando un rango de salarios de acuerdo al departamento. por ejemplo, del
departamento de cobranza, existeng 10 salarios distintos, la funcion rank identifica cual es el salario más alto y le asgina el valor 1 y el que le
sigue 2 y aí sucesivamente.
SELECT nombre,
salario,
departamento,
RANK() OVER (PARTITION BY departamento ORDER BY salario DESC) as rango_salario
FROM empleados;
Función de categorización: NTILE : se agrupa los datos en cuartiles que nosotros especificamos, por ejemplo, que en una columna,
detalle el rango de precio. y de acuerdo a eso que lo clasifique en un rango de 1 a 5
SELECT
author_id,
name,
price,
ntile(5) OVER (ORDER BY price)
FROM books_price;
Funciones de desplazamiento: LAG y LEAD : A menudo necesitarás comparar el valor actual con los anteriores o posteriores. Por eso
tienes las funciones LAG y LEAD respectivamente. Puedes pasar a la función el nombre del campo y el desplazamiento (el número de filas)
sobre el que se tomará el valor. Si no indicas el desplazamiento, será el valor predeterminado: 1. la nueva columa nos da la siguiente tabla
SELECT author_id,
name,
pages,
LAG(pages) OVER (PARTITION BY author_id ORDER BY date_pub)
FROM
books_price;
la condicion es que tiene que leccionar los mismos autores, y luego ir agregando el valor anterior en cada fila. siempre en la primera fila sera
un valor nulo porque no tendra con quien compararlo, y el valor de la segunda fila sera el de la primera fila
In [ ]: 1 Swan Song 956 NULL

1 Boy's Life 580 956
2 This Book Is Full of Spiders 406 NULL
3 The City of Mirrors 602 NULL
4 Red Dragon 348 NULL
4 The Silence of the Lambs 367 348
RELACION ENTRE TABLAS SQL
DIAGRAMA ER
• Clave primaria
• Clave Foranea
18 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Relacione entre tablas:
• continuación vemos una relación uno a muchos: Un autor puede tener varios libros pero cada libro tiene un solo autor.
Ejemplo de imagen
• Relacion uno a uno:
Ejemplo de imagen
• Relacion entre muchos a muchos: Como se mencionó anteriormente, a veces un libro puede tener varios autores, cada uno de los cuales, a
su vez, puede tener varios libros. Es una relación clásica de muchos a muchos:
Ejemplo de imagen
19 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: Pagina para modelar datos : https://drawsql.app/
Buscar Valores vacios
# Seleccionar valores NULL SELECT * FROM table_name WHERE column_name IS NULL; # Seleccionar todos los valores excepto los valores nulos, sin eliminarlos
SELECT name, publisher_id FROM books WHERE publisher_id IS NOT NULL; # Reemplazar los valores ausentes, es como cuando se usa el elif de python CASE
WHEN condition_1 THEN result_1 WHEN condition_2 THEN result_2 WHEN condition_3 THEN result_3 ELSE result_4 END; # Ejemplo SELECT name, CASE WHEN
publisher_id IS NULL THEN -1 -- si no se especifica la editorial, -- un publisher_id de -1 ELSE publisher_id END AS publisher_id_full FROM books; # Reemplazar
cualquier valor mediante la Funcion CASE
CASE
1. . Utiliza una consulta que contenga CASE para reemplazar manualmente NULL con los promedios que calculamos en la tarea anterior en
cada grupo de units. Llama el campo resultante weight_full. Los valores de la columna deben ser cadenas e ir en el siguiente orden: name,
weight_full. Necesitarás los resultados del ejercicio anterior:
• 23.0705263269575,oz
• 10.0,ct
• 12.0909090909091,pk
• 0.650793650793651,gal
• 1.0,%
• 1.0,pt
• 1.0,qt
In [ ]: SELECT
name,
CASE WHEN weight IS NULL
AND units = '%' THEN
'1.0'
WHEN weight IS NULL
AND units = 'pt' THEN
'1.0'
WHEN weight IS NULL
AND units = 'ct' THEN
'10.0'
WHEN weight IS NULL
AND units = 'qt' THEN
'1.0'
WHEN weight IS NULL
AND units = 'gal' THEN
'0.650793650793651'
WHEN weight IS NULL
AND units = 'pk' THEN
'12.0909090909091'
WHEN weight IS NULL
AND units = 'oz' THEN
'23.0705263269575'
ELSE
weight
END AS weight_full
FROM
products;
BUSCAR DATOS EN TABLAS
20 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
METODO LIKE : nos muestro todas las filas de una columna que tiene una palabra
SELECT * FROM books WHERE name LIKE '%Vampire%';
Se coloca entre % porque representa cualquier valor entre los caracteres, y la V en mayuscula porque es un titulo
Si no queremos que muestro todo excepto vampire, seria a la inversa
SELECT * FROM books WHERE name NOT LIKE '%Vampire%';
Metodo ESCAPE
Busca la cadena que tiene % en el campo de unidades. Imprime todas sus filas.
SELECT * FROM products WHERE units LIKE '!%' ESCAPE '!';
UNIR TABLAS
INNER JOIN : devuelve solo aquellas filas que tienen valores coincidentes de una tabla a otra (la intersección de las tablas
SELECT Ventas.IDVenta, Ventas.FechaVenta, Ventas.Cantidad, Ventas.TotalVenta, Productos.NombreProducto
FROM Ventas
INNER JOIN Productos ON Ventas.IDProducto = Productos.IDProducto;
outer join : OUTER JOIN recupera todos los datos de una tabla y agrega datos de la otra cuando hay filas coincidentes. Hay dos tipos de
OUTER JOIN, left (izquierda ) y right (derecha):
SELECT Clientes.IDCliente, Clientes.NombreCliente, Pedidos.FechaPedido, Pedidos.TotalPedido
FROM Clientes
LEFT OUTER JOIN Pedidos ON Clientes.IDCliente = Pedidos.IDCliente;
EJEMPLO DOS
SELECT books.name AS name, books.author_id AS books_author_id, author.author_id AS author_id, author.first_name AS first_name,

author.last_name AS last_name FROM books INNER JOIN author ON author.author_id = books.author_id LIMIT 3;
LEFT OUTER JOIN y RIGHT OUTER JOIN
UNIR VARIAS TABLAS
SELECT Clientes.NombreCliente, Pedidos.FechaPedido, Productos.NombreProducto
FROM Clientes
INNER JOIN Pedidos ON Clientes.IDCliente = Pedidos.IDCliente
INNER JOIN Productos ON Pedidos.IDProducto = Productos.IDProducto
WHERE Clientes.IDCliente = 1;
Agregación emparejada con JOIN
Vamos a encontrar el número de los libros en cada género agrupado por el autor.
In [ ]: SELECT
genre.name AS genre_name,
author.first_name AS author_first_name,
author.last_name AS author_last_name,
COUNT(books.name) AS name_cnt
FROM
books
INNER JOIN genre ON genre.genre_id = books.genre_id
INNER JOIN author ON author.author_id = books.author_id
GROUP BY
genre_name,
author_first_name,
author_last_name;
21 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Para aplicar reglas más estrictas y unir tablas solo en aquellas filas que comparten varios valores al mismo tiempo, simplemente combina todas
las declaraciones necesarias con AND:
In [ ]: #UNION : SE USA CUANDO SE QUIERE UNIR DOS TABLAS CON LAS MISMAS FILAS ,COLUMNAS Y ORDEN DE LOS CAMPOS. Y EN CASO QUE HAYA DUPLICADOS DEJA S
SELECT
year_tag,
name,
weight
FROM
cows_grandpa
UNION
SELECT
tag,
name,
weight
FROM
cows_grandma;
#UNION ALL : incluye duplicados en la selección resultante. Es útil cuando sabemos con certeza que
# no hay valores coincidentes en las tablas que se unirán o cuando realmente necesitamos los valores duplicados.
SELECT
year_tag,
name,
weight
FROM
cow
UNION ALL
SELECT
year_tag,
name,
weight
FROM
bulls;
Sprint 7 Analisis de Negocio
A. Metricas y embudos
• Beneficio bruto = facturación- costo primo.

• Margen bruto = beneficio bruto / ingreso.
• Margen bruto = (ingreso - costo primo) / ingreso.
• Beneficio operativo = beneficio bruto - gastos operativos (ALQUILER, SUELDOS)
El beneficio operativo da una idea del rendimiento general del negocio al indicar cuánto gana una empresa con sus actividades principales. Si
el beneficio operativo es negativo, hay una pérdida operativa. De vez en cuando, las empresas tienen una falta de rentabilidad planificada
para que puedan invertir todos sus ingresos en un rápido desarrollo y crecimiento. Amazon pasó muchos años registrando pérdidas, pero
luego su fundador, Jeff Bezos, se convirtió en el hombre más rico del mundo.
• Margen operativo = beneficio operativo / ingresos
sta es la parte de los ingresos que permanece en la empresa después de que se hayan pagado los costos principales, los salarios, el alquiler, el
marketing y otros gastos de la actividad principal.
• beneficio neto : es la cantidad de dinero que los propietarios de negocios pueden tomar para sí mismos o reinvertir para desarrollar la
empresa.
Beneficio neto = beneficio operativo - impuestos y préstamos
Un beneficio neto negativo se denomina pérdida neta.
22 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
En este ejemplo, supongamos que la empresa ha vendido 1000 unidades a un precio de $500 cada una, lo que resulta en ventas totales de
$500,000 dólares. El costo de ventas fue de $250,000 dólares, lo que resulta en un margen bruto de $250,000 dólares.
La empresa incurrió en gastos de ventas de $50,000 dólares y gastos generales y administrativos de $75,000 dólares, lo que resulta en un
EBITDA de $125,000 dólares. La depreciación y la amortización de la empresa fueron de $10,000 dólares, lo que da lugar a un EBIT de $115,000
dólares.
La empresa también tuvo intereses a pagar de $20,000 dólares, lo que resulta en un beneficio antes de impuestos de $95,000 dólares. Después
de pagar impuestos sobre los beneficios de $25,000 dólares, el beneficio neto de la empresa para el período en cuestión fue de $70,000
dólares.
Rentabilidad de la inversión
• ROI = rentabilidad de la inversión).
(beneficio neto− inversiones) / inversiones
El ROI actual de la inversión de John Smith es (200,000 - 1 000 000) / 1 000 000 =-80%. Esto significa que aún tiene que recuperar el 80% de su
inversión.
23 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Rentabilidad de la inversión en marketing
• ROMI de la campaña publicitaria = beneficio bruto de la campaña / gastos.
Si calculamos el ROMI de nuestra campaña publicitaria de esta manera, obtenemos el siguiente resultado: 150 000 / 100 000 = 150%. Los
gastos se recuperaron al 100 % y generaron un beneficio del 50%.
Conversion : La tasa de conversión es la proporción de personas que cambiaron su estado dentro de un proceso comercial.
Si 1000 personas visitaron una tienda y solo 10 de ellas compraron algo, la tasa de conversión es 10/1000 = 0.01, o 1%
Embudos : una forma de mostrar el camino que siguen los usuarios para comprar un producto y la proporción de usuarios que pasan a la
siguiente fase.
Embudos
una forma de mostrar el camino que siguen los usuarios para comprar un producto y la proporción de usuarios que pasan a la siguiente fase.
01. Embudo de Marketing
La tasa de clics (click-through rate o CTR) es la relación entre los clics y las impresiones. :
`CTR = (CLICK/ IMPRESIONES) * 101`

funnel['ctr, %'] = funnel['clicks'] / funnel['impressions'] * 100
La tasa de conversión (conversion rate o CR) es la relación entre registros y clic
CR = (REGISTROS/CLICK)* 100
funnel['cr, %'] = funnel['registrations'] / funnel['clicks'] * 100
Agrupacion por semanas o meses
Agrega la columna week al DataFrame

Agrupa el DataFrame por esta columna.
Suma el número de impresiones, clics y registros de cada semana.
Vuelve a calcular la tasa de conversión semanal media.
In [ ]: #Agrupacion por semana o mes

df['week'] = df['date'].dt.week
df_ = df.groupby('week')[['regs', 'clicks']].sum()
print(df_['regs'] / df_['clicks'] * 100)
24 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
EJERCICIO
Este ejercicio se parece mucho al anterior. Traza embudos diarios, semanales y mensuales. Lee los datos sobre los gastos de publicidad
(/datasets/ad_data_2.csv) y guárdalos en la variable ad_data. Guarda los datos sobre los registros (/datasets/site_data_2.csv) como site_data.
Utiliza el método merge() para unir ad_data y site_data en la columna 'date'. Guarda el DataFrame resultante con embudos diarios como
funnel_daily. Calcula la conversión de impressions a clicks, guardándola en la columna ctr, %, y de clicks a registrations, guardándola en la
columna cr, %. En funnel_daily crea las columnas 'week' y 'month'. Recupera los números de orden de las semanas y meses con los métodos
dt.week y dt.month, respectivamente. Almacena los resultados en las columnas mencionadas anteriormente.
Guarda el embudo semanal en funnel_weekly. Agrupa los datos funnel_daily por la columna 'week' utilizando el método groupby(). Suma los
datos de las columnas ['impressions', 'clicks', 'registrations'] dentro de la agrupación.
Haz un gráfico de embudo mensual usando el mismo enfoque. Guárdalo como funnel_monthly. Calcula el CTR y el CR para cada uno de los
tres embudos. Imprime el embudo mensual.
In [ ]: ad_data = pd.read_csv('/datasets/ad_data_2.csv')
site_data = pd.read_csv('/datasets/site_data_2.csv')
funnel_daily = pd.merge(ad_data, site_data, on='date')

funnel_daily['ctr, %'] = (
funnel_daily['clicks'] / funnel_daily['impressions'] * 100
)
funnel_daily['cr, %'] = (
funnel_daily['registrations'] / funnel_daily['clicks'] * 100
)
funnel_daily['date'] = pd.to_datetime(funnel_daily['date'])
funnel_daily['week'] = funnel_daily['date'].dt.week
funnel_daily['month'] = funnel_daily['date'].dt.month
funnel_weekly = funnel_daily.groupby('week')[
['impressions', 'clicks', 'registrations']
].sum()
funnel_weekly['ctr, %'] = (
funnel_weekly['clicks'] / funnel_weekly['impressions'] * 100
)
funnel_weekly['cr, %'] = (
funnel_weekly['registrations'] / funnel_weekly['clicks'] * 100
)
funnel_monthly = funnel_daily.groupby('month')[
['impressions', 'clicks', 'registrations']
].sum()
funnel_monthly['ctr, %'] = (
funnel_monthly['clicks'] / funnel_monthly['impressions'] * 100
)
funnel_monthly['cr, %'] = (
funnel_monthly['registrations'] / funnel_monthly['clicks'] * 100
)
print(funnel_monthly)
funcion para embudos
In [ ]: def analyze_funnel(funnel_daily, group_cols, agg_cols):
"""La función analyze_funnel primero realiza los cálculos de CTR y CR y agrega las columnas de semana y mes al DataFrame funnel_daily.
Luego, agrupa los datos por las columnas especificadas en group_cols y agrega las columnas especificadas en agg_cols.
Finalmente, realiza los cálculos de CTR y CR en el DataFrame agregado y retorna el resultado."""
funnel_daily['ctr, %'] = funnel_daily['clicks'] / funnel_daily['impressions'] * 100

funnel_daily['cr, %'] = funnel_daily['registrations'] / funnel_daily['clicks'] * 100
funnel_daily['date'] = pd.to_datetime(funnel_daily['date'])
funnel_daily['week'] = funnel_daily['date'].dt.week
funnel_daily['month'] = funnel_daily['date'].dt.month
funnel_agg = funnel_daily.groupby(group_cols)[agg_cols].sum()
funnel_agg['ctr, %'] = funnel_agg['clicks'] / funnel_agg['impressions'] * 100
funnel_agg['cr, %'] = funnel_agg['registrations'] / funnel_agg['clicks'] * 100
return funnel_agg
In [ ]: group_cols = ['month']
agg_cols = ['impressions', 'clicks', 'registrations']
funnel_monthly = analyze_funnel(funnel_daily, group_cols, agg_cols)
02. Embudos de productos
25 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Si tu objetivo es averiguar cuántos usuarios llegaron a una determinada etapa del embudo.
es una representación visual del proceso de conversión de los usuarios desde que conocen un producto o servicio hasta que realizan una
compra o acción específica que se busca obtener.
El embudo de producto se divide en diferentes etapas, que pueden variar según el tipo de negocio, pero que generalmente incluyen:
Adquisición: Etapa en la que el usuario toma conocimiento del producto o servicio. Clientes potenciales
visitan el sitio web;
Activación: Etapa en la que el usuario muestra interés por el producto o servicio y realiza alguna acción
que lo acerca más a la compra o conversión, como puede ser el registro en una plataforma o la descarga de
una demo. Agregan productos a sus carritos;
Retención: Etapa en la que el usuario ya ha utilizado el producto o servicio y se busca que lo vuelva a
utilizar o a realizar una acción que se busca obtener. Realizan pedidos;
Conversión: Etapa final en la que el usuario realiza la acción deseada, ya sea una compra, un registro, una
suscripción, entre otros. Pagan.
Para realizar el calculo debe tener si o si los siguientes cambos que figuran en el siguuiente df
In [1]: import pandas as pd

data = {
'event_name': ['pageview', 'pageview', 'pageview', 'pageview', 'pageview'],
'event_time': ['2019-02-27 10:16:38', '2019-01-24 07:20:10', '2019-05-16 06:23:10', '2019-07-23 08:29:40', '2019-03-11 21:47:56'
'uid': [99702298, 67118564, 87503951, 64675633, 73978848]
}
df = pd.DataFrame(data)
print(df)
event_name event_time uid

0 pageview 2019-02-27 10:16:38 99702298
1 pageview 2019-01-24 07:20:10 67118564
2 pageview 2019-05-16 06:23:10 87503951
3 pageview 2019-07-23 08:29:40 64675633
4 pageview 2019-03-11 21:47:56 73978848
In [2]: #Calculamos cuantas veces ocurrio el evento, agregar el unique para determinar el usuario unico
users_count = df.groupby('event_name').agg({'uid': 'nunique'})
print(users_count.sort_values(by = 'uid', ascending=False))
#En porcentaje
users_count = df.groupby('event_name').agg({'uid': 'nunique'})

users_count['percentage'] = users_count['uid'] / users_count['uid'].sum() * 100
print(users_count.sort_values(by='uid', ascending=False))
uid
event_name
pageview 5
uid percentage
event_name
pageview 5 100.0
Funcion embudo de pruducto
In [13]: def unique_users_embudo_producto(df, event_col='event_name', user_col='uid',

count_col='user_count', perc_col='user_perc'):
""" Calcula el embudo de usuarios unicos del producto

df: el dataframe que contiene los eventos y usuarios
event_col: el nombre de la columna de eventos
user_col: el nombre de la columna de usuarios
Resultado el numero de usuarios que lleagron a cada etapa"""
users_count = df.groupby(event_col).agg({user_col: 'nunique'}).rename(columns={user_col: count_col})

total_users = users_count[count_col].sum()
users_count[perc_col] = users_count[count_col] / total_users * 100
return users_count.sort_values(by=count_col, ascending=False)
26 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [12]: result = unique_users_embudo_producto(df, event_col='event_name', user_col='uid',

count_col='count', perc_col='perc')
print(result)
count perc
event_name
pageview 5 100.0
03. Embudo de producto complejo

estudiar detalles de la transición de una etapa a otra. En donde tomar una ruta determinada, es decir, entra a la pagina, agrega un producto y compra. por otro
lado, la simple no toma ninguna ruta, solo realiza el calculo
In [36]: data = {
'event_name': ['pageview', 'pageview', 'pageview', 'pageview', 'pageview'],
'event_time': ['2019-02-27 10:16:38', '2019-01-24 07:20:10', '2019-05-16 06:23:10', '2019-07-23 08:29:40', '2019-03-11 21:47:56'
'uid': [99702298, 67118564, 87503951, 64675633, 73978848]
}
df = pd.DataFrame(data)
print(df)
event_name event_time uid

0 pageview 2019-02-27 10:16:38 99702298
1 pageview 2019-01-24 07:20:10 67118564
2 pageview 2019-05-16 06:23:10 87503951
3 pageview 2019-07-23 08:29:40 64675633
4 pageview 2019-03-11 21:47:56 73978848
In [ ]: # Crear una tabla pivote que muestre para cada usuario si han realizado cada evento
users = df.pivot_table(
index='uid',
columns='event_name',
values='event_time',
aggfunc='min')
# Paso 1: identificar los usuarios que han visto al menos una página de producto
step_1 = ~users['pageview'].isna()
# Paso 2: identificar los usuarios que han visto al menos una página de producto y han agregado un producto al carrito
step_2 = step_1 & (users['add_to_cart'] > users['pageview'])
# Paso 3: identificar los usuarios que han visto al menos una página de producto, han agregado un producto al carrito, y han iniciado el pr
step_3 = step_2 & (users['checkout'] > users['add_to_cart'])
# Paso 4: identificar los usuarios que han visto al menos una página de producto, han agregado un producto al carrito, han iniciado el proc
step_4 = step_3 & (users['payment'] > users['checkout'])
# Contar el número de usuarios en cada etapa del embudo

n_pageview = users[step_1].shape[0]
n_add_to_cart = users[step_2].shape[0]
n_checkout = users[step_3].shape[0]
n_payment = users[step_4].shape[0]
# Imprimir los resultados

print('Visitantes:', n_pageview)
print('Se agregó un producto al carrito:', n_add_to_cart)
print('Pago iniciado:', n_checkout)
print('Pagado:', n_payment)
In [ ]: import inspect
comments = inspect.getdoc(unique_users_embudo_producto)
print(comments)
27 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: def calculate_funnel(df, event_names):

"""
Calcula el embudo de conversión para una lista de eventos dada.
Parámetros:
- df: DataFrame con los datos de eventos.
- event_names: lista de nombres de eventos en el orden del embudo.
Retorna:
- funnel: diccionario con el número de usuarios en cada etapa del embudo.
"""
# Crear una tabla pivote que muestre para cada usuario si han realizado cada evento.
users = df.pivot_table(
index='uid',
columns='event_name',
values='event_time',
aggfunc='min')
# Crear una lista para guardar los pasos del embudo.

steps = []
for i in range(len(event_names)-1):
# Crear un paso que identifique los usuarios que han completado el evento i y el evento i+1.
step = (users[event_names[i]].notna()) & (users[event_names[i+1]] > users[event_names[i]])
steps.append(step)
# Crear una lista para guardar el número de usuarios en cada etapa del embudo.
counts = []
for i in range(len(steps)):
# Contar el número de usuarios que han completado el paso correspondiente.
count = users[steps[i]].shape[0]
counts.append(count)
# Crear un diccionario con el número de usuarios en cada etapa del embudo.

funnel = dict(zip(event_names[:-1], counts))
# Añadir el número de visitantes (aquellos que realizaron el primer evento en la lista).
funnel['Visitors'] = users[event_names[0]].notna().sum()
# Retornar el diccionario con los conteos para cada etapa del embudo.
return funnel
# a aplicar
event_names= ['pageview', 'add_to_cart', 'checkout', 'payment']
funnel_counts = calculate_funnel(df, event_names)
print(funnel_counts)
B. Analisis de cohorto
28 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
agrupar a los usuarios y usuarias que realizaron una cierta acción y tienen el mismo interes durante el mismo período de tiempo.
Un análisis de cohortes es una técnica de análisis de datos que se utiliza para entender cómo los usuarios se comportan a lo largo del tiempo y
cómo los patrones de comportamiento pueden variar por diferentes grupos. Se trata de un análisis que divide a los usuarios en grupos de
acuerdo con alguna característica común, como la fecha en que se registraron o el comportamiento que tuvieron en sus primeras interacciones
con un producto o servicio.
El objetivo del análisis de cohortes es proporcionar una visión más detallada del comportamiento de los usuarios y, en última instancia, ayudar
a las empresas a mejorar la retención de usuarios y la fidelidad del cliente. Por ejemplo, un análisis de cohortes podría ayudar a una empresa a
entender si los usuarios que se registraron en un mes en particular tienden a ser más leales y comprometidos que los usuarios que se
registraron en otros meses. Esto puede llevar a cambios en la estrategia de marketing o en la forma en que se presentan los productos o
servicios.
En resumen, un análisis de cohortes es una herramienta valiosa para los analistas de datos que buscan entender mejor el comportamiento de
los usuarios y las tendencias a lo largo del tiempo.
solo entiende el pasado, no sirve para predecir
Supongamos que tienes una aplicación de compras en línea y quieres analizar la retención de usuarios. Para ello, decides hacer un análisis de
cohortes.
Primero, seleccionas una cohorte de usuarios que se unieron a la aplicación en un mes específico, por ejemplo, enero de 2021. Luego, estudias
su comportamiento a lo largo del tiempo, observando cuántos de ellos regresaron en febrero, marzo, abril y así sucesivamente.
Supongamos que tienes los siguientes datos para tu cohorte de enero de 2021:
En enero de 2021, 1000 usuarios se unieron a la aplicación

En febrero de 2021, 500 usuarios regresaron y realizaron una compra
En marzo de 2021, 250 usuarios regresaron y realizaron una compra
En abril de 2021, 100 usuarios regresaron y realizaron una compra
En este caso, podrías concluir que la retención de usuarios es buena en el primer mes, pero disminuye en los meses posteriores. También
podrías investigar más a fondo para determinar si hay algún problema específico que esté afectando la retención, como problemas de
usabilidad de la aplicación o una mala experiencia de compra.
In [43]: data = {'order_id': ['536365', '536366', '536367', '536368', '536369', '536370', '536371', '536372', '536373', '536374'],
'order_date': ['2010-12-01 08:26:00', '2010-12-01 08:28:00', '2010-12-01 08:34:00', '2010-12-01 08:34:00', '2010-12-01 08:35:00'
'customer_id': [17850, 17850, 13047, 13047, 13047, 12583, 13748, 17850, 17850, 15100],
'revenue': [139.12, 22.20, 278.73, 70.05, 17.85, 855.86, 204.00, 22.20, 259.86, 350.40]}
orders = pd.DataFrame(data)
In [55]: # Filtramos por la fecha mas antigua
first_order_date_by_customers = orders.groupby('customer_id')[
'order_date'
].min()
print(first_order_date_by_customers.head())
# la renombramos
first_order_date_by_customers.name = 'first_order_date'
# de esa tabla dinamica juntamos la tabla con la original
orders = orders.join(first_order_date_by_customers,on='customer_id', rsuffix='_first_order')
print(orders)
#El siguiente paso será separar los meses de las columnas first_order_date y order_date
orders['first_order_month'] = orders['first_order_date'].astype(
'datetime64[M]'
)
orders['order_month'] = orders['order_date'].astype('datetime64[M]')
print(orders.head(10))
print("Agrupacion por cohortos------------------------------------------------")
#La columna first_order_month se utilizará para formar cohortes. Vamos a agrupar los datos por esta columna y evaluemos las métricas para c
cohort_grouped = orders.groupby('first_order_month').agg(
{'order_id': 'nunique', 'customer_id': 'nunique', 'revenue': 'sum'}
)
print(cohort_grouped)
29 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
customer_id
12583 2010-12-01 08:45:00
13047 2010-12-01 08:34:00
13748 2010-12-01 09:00:00
15100 2010-12-01 09:09:00
17850 2010-12-01 08:26:00
Name: order_date, dtype: object
order_id order_date customer_id revenue first_order_date \
0 536365 2010-12-01 08:26:00 17850 139.12 2010-12-01 08:26:00
1 536366 2010-12-01 08:28:00 17850 22.20 2010-12-01 08:26:00
2 536367 2010-12-01 08:34:00 13047 278.73 2010-12-01 08:34:00
3 536368 2010-12-01 08:34:00 13047 70.05 2010-12-01 08:34:00
4 536369 2010-12-01 08:35:00 13047 17.85 2010-12-01 08:34:00
5 536370 2010-12-01 08:45:00 12583 855.86 2010-12-01 08:45:00
6 536371 2010-12-01 09:00:00 13748 204.00 2010-12-01 09:00:00
7 536372 2010-12-01 09:01:00 17850 22.20 2010-12-01 08:26:00
8 536373 2010-12-01 09:02:00 17850 259.86 2010-12-01 08:26:00
9 536374 2010-12-01 09:09:00 15100 350.40 2010-12-01 09:09:00
first_order_date_first_order first_order_date_first_order first_order_month \

0 2010-12-01 08:26:00 2010-12-01 08:26:00 2010-12-01
1 2010-12-01 08:26:00 2010-12-01 08:26:00 2010-12-01
2 2010-12-01 08:34:00 2010-12-01 08:34:00 2010-12-01
3 2010-12-01 08:34:00 2010-12-01 08:34:00 2010-12-01
4 2010-12-01 08:34:00 2010-12-01 08:34:00 2010-12-01
5 2010-12-01 08:45:00 2010-12-01 08:45:00 2010-12-01
6 2010-12-01 09:00:00 2010-12-01 09:00:00 2010-12-01
7 2010-12-01 08:26:00 2010-12-01 08:26:00 2010-12-01
8 2010-12-01 08:26:00 2010-12-01 08:26:00 2010-12-01
9 2010-12-01 09:09:00 2010-12-01 09:09:00 2010-12-01
order_month first_order_date_first_order first_order_date_first_order \

0 2010-12-01 2010-12-01 08:26:00 2010-12-01 08:26:00
1 2010-12-01 2010-12-01 08:26:00 2010-12-01 08:26:00
2 2010-12-01 2010-12-01 08:34:00 2010-12-01 08:34:00
3 2010-12-01 2010-12-01 08:34:00 2010-12-01 08:34:00
4 2010-12-01 2010-12-01 08:34:00 2010-12-01 08:34:00
5 2010-12-01 2010-12-01 08:45:00 2010-12-01 08:45:00
6 2010-12-01 2010-12-01 09:00:00 2010-12-01 09:00:00
7 2010-12-01 2010-12-01 08:26:00 2010-12-01 08:26:00
8 2010-12-01 2010-12-01 08:26:00 2010-12-01 08:26:00
9 2010-12-01 2010-12-01 09:09:00 2010-12-01 09:09:00
first_order_date_first_order first_order_date_first_order
0 2010-12-01 08:26:00 2010-12-01 08:26:00
1 2010-12-01 08:26:00 2010-12-01 08:26:00
2 2010-12-01 08:34:00 2010-12-01 08:34:00
3 2010-12-01 08:34:00 2010-12-01 08:34:00
4 2010-12-01 08:34:00 2010-12-01 08:34:00
5 2010-12-01 08:45:00 2010-12-01 08:45:00
6 2010-12-01 09:00:00 2010-12-01 09:00:00
7 2010-12-01 08:26:00 2010-12-01 08:26:00
8 2010-12-01 08:26:00 2010-12-01 08:26:00
9 2010-12-01 09:09:00 2010-12-01 09:09:00
order_id order_date customer_id revenue first_order_date \
0 536365 2010-12-01 08:26:00 17850 139.12 2010-12-01 08:26:00
1 536366 2010-12-01 08:28:00 17850 22.20 2010-12-01 08:26:00
2 536367 2010-12-01 08:34:00 13047 278.73 2010-12-01 08:34:00
3 536368 2010-12-01 08:34:00 13047 70.05 2010-12-01 08:34:00
4 536369 2010-12-01 08:35:00 13047 17.85 2010-12-01 08:34:00
5 536370 2010-12-01 08:45:00 12583 855.86 2010-12-01 08:45:00
6 536371 2010-12-01 09:00:00 13748 204.00 2010-12-01 09:00:00
7 536372 2010-12-01 09:01:00 17850 22.20 2010-12-01 08:26:00
8 536373 2010-12-01 09:02:00 17850 259.86 2010-12-01 08:26:00
9 536374 2010-12-01 09:09:00 15100 350.40 2010-12-01 09:09:00
first_order_date_first_order first_order_date_first_order first_order_month \

0 2010-12-01 08:26:00 2010-12-01 08:26:00 2010-12-01
1 2010-12-01 08:26:00 2010-12-01 08:26:00 2010-12-01
2 2010-12-01 08:34:00 2010-12-01 08:34:00 2010-12-01
3 2010-12-01 08:34:00 2010-12-01 08:34:00 2010-12-01
4 2010-12-01 08:34:00 2010-12-01 08:34:00 2010-12-01
5 2010-12-01 08:45:00 2010-12-01 08:45:00 2010-12-01
6 2010-12-01 09:00:00 2010-12-01 09:00:00 2010-12-01
7 2010-12-01 08:26:00 2010-12-01 08:26:00 2010-12-01
8 2010-12-01 08:26:00 2010-12-01 08:26:00 2010-12-01
9 2010-12-01 09:09:00 2010-12-01 09:09:00 2010-12-01
order_month first_order_date_first_order first_order_date_first_order \

0 2010-12-01 2010-12-01 08:26:00 2010-12-01 08:26:00
1 2010-12-01 2010-12-01 08:26:00 2010-12-01 08:26:00
2 2010-12-01 2010-12-01 08:34:00 2010-12-01 08:34:00
3 2010-12-01 2010-12-01 08:34:00 2010-12-01 08:34:00
4 2010-12-01 2010-12-01 08:34:00 2010-12-01 08:34:00
30 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
5 2010-12-01 2010-12-01 08:45:00 2010-12-01 08:45:00

6 2010-12-01 2010-12-01 09:00:00 2010-12-01 09:00:00
7 2010-12-01 2010-12-01 08:26:00 2010-12-01 08:26:00
8 2010-12-01 2010-12-01 08:26:00 2010-12-01 08:26:00
9 2010-12-01 2010-12-01 09:09:00 2010-12-01 09:09:00
first_order_date_first_order first_order_date_first_order
0 2010-12-01 08:26:00 2010-12-01 08:26:00
1 2010-12-01 08:26:00 2010-12-01 08:26:00
2 2010-12-01 08:34:00 2010-12-01 08:34:00
3 2010-12-01 08:34:00 2010-12-01 08:34:00
4 2010-12-01 08:34:00 2010-12-01 08:34:00
5 2010-12-01 08:45:00 2010-12-01 08:45:00
6 2010-12-01 09:00:00 2010-12-01 09:00:00
7 2010-12-01 08:26:00 2010-12-01 08:26:00
8 2010-12-01 08:26:00 2010-12-01 08:26:00
9 2010-12-01 09:09:00 2010-12-01 09:09:00
Agrupacion por cohortos------------------------------------------------
order_id customer_id revenue
first_order_month
2010-12-01 10 5 2220.27
02. Cohorto evaluacion de cambios
hora intentaremos encontrar cómo cambia el comportamiento de cada cohorte con el tiempo. Por ejemplo, vamos a determinar:
si el tamaño promedio de compra se está reduciendo;

si los clientes atraídos en diferentes momentos son igualmente rentables.
La primera tarea que se puede resolver con el uso del análisis de cohortes es realizar un seguimiento de los cambios en la cantidad de
compradores activos dentro de una sola cohorte.
In [57]: #Creamos una tabla dinamica

orders.pivot_table(
index='first_order_month', #Aqui va el cohorto, primeras compras del cliente
columns='order_month', # mes de compra
values='customer_id',
aggfunc='nunique',
)
Out[57]: order_month 2010-12-01
first_order_month
2010-12-01 5
03. Evaluar los cambios en valores relativos por ciclo de vida
ingreso promedio por usuario (ventas totales divididas por el número de clientes) con el tiempo. Esto nos dará una idea de si el ingreso
promedio de los usuarios que continúan haciendo pedidos está aumentando o no. Vamos a calcular métricas de cohorte adicionales por mes:
ingreso promedio por usuario para cada mes;

orden del pedido del mes en relación con el mes en que se realizó el primer pedido.
31 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [67]: #Primero, agruparemos los datos por cohortes first_order_month y por mes de compra (order_month):
orders_grouped_by_cohorts = orders.groupby(
['first_order_month', 'order_month']
).agg({'revenue': 'sum', 'customer_id': 'nunique'})
print(orders_grouped_by_cohorts.head())
# Vamos a buscar revenue_per_user. Tendremos que dividir revenue por la cantidad de valores customer_id:
orders_grouped_by_cohorts['revenue_per_user'] = (
orders_grouped_by_cohorts['revenue']
/ orders_grouped_by_cohorts['customer_id']
)
#Ahora trazaremos una tabla dinámica que muestre los cambios en los ingresos por usuario para las cohortes por mes de compra
# evaluaremos los cambios en los ingresos por usuario a lo largo del tiempo:
orders_grouped_by_cohorts.pivot_table(
index='first_order_month',
columns='order_month',
values='revenue_per_user',
aggfunc='mean',
)
# Vamos a encontrar el ciclo de vida de la cohorte. Restaremos el mes de la cohorte (first_order_month) del mes en que se realizaron las co
orders_grouped_by_cohorts = orders_grouped_by_cohorts.reset_index()
orders_grouped_by_cohorts['cohort_lifetime'] = (
orders_grouped_by_cohorts['order_month']
- orders_grouped_by_cohorts['first_order_month']
)
orders_grouped_by_cohorts['cohort_lifetime'].head()
"""Convertiremos este tipo al número de meses entre las dos fechas.

Hay que dividir cohort_lifetime entre el valor constante np.timedelta64(1, 'M') y averiguar cuántos valores iguales a un mes contiene cohor
import numpy as np
orders_grouped_by_cohorts['cohort_lifetime'] = orders_grouped_by_cohorts[
'cohort_lifetime'
] / np.timedelta64(1, 'M')
print(orders_grouped_by_cohorts['cohort_lifetime'].head())
#Vamos a redondear los valores de la columna cohort_lifetime usando el método round(), depués los convertiremos a números enteros con el mé
orders_grouped_by_cohorts['cohort_lifetime'] = (
orders_grouped_by_cohorts['cohort_lifetime'].round().astype('int')
)
print(
orders_grouped_by_cohorts[
['first_order_month', 'order_month', 'cohort_lifetime']
].head()
)
#dejamos solo el año y el mes en el identificador de la cohorte.
orders_grouped_by_cohorts['first_order_month'].dt.strftime('%d.%m.%Y')
# Dejemos solo el año y el mes en los datos del mes de la primera compra:
orders_grouped_by_cohorts['first_order_month'] = orders_grouped_by_cohorts[
'first_order_month'
].dt.strftime('%Y-%m')
#Ahora vamos a compilar una tabla dinámica de cambios en los ingresos promedio por usuario
#cuyas columnas contendrán el ciclo de vida y las filas serán cohortes:
revenue_per_user_pivot = orders_grouped_by_cohorts.pivot_table(
index='first_order_month',
columns='cohort_lifetime',
values='revenue_per_user',
aggfunc='mean',
)
print(revenue_per_user_pivot)
32 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
revenue customer_id
first_order_month order_month
2010-12-01 2010-12-01 2220.27 5
0 0.0
Name: cohort_lifetime, dtype: float64
first_order_month order_month cohort_lifetime
0 2010-12-01 2010-12-01 0
cohort_lifetime 0
first_order_month
2010-12 444.054
Esto seria el promedio de compra que hizo cada usuario desde que realizo la primera compra. el cohorto time toma en cuenta los meses
posteriores, por ejemplo su primera compra fue en 0, luego al mes, seria el 1 y asi sucesivamente. es decir, los usuarios que hicieron su primera
compra en diciembre del 2020, en enero en promedio compraron 825, luego en febrero(2) compraron 817 y asi...
Aquí vemos claramente para qué cohortes aumentaron los ingresos por usuario en el mes siguiente al mes de la primera compra. Para algunas
cohortes, los ingresos por usuario aumentaron rápidamente con el tiempo (por ejemplo, las cohortes de diciembre de 2010 y agosto de 2011).
04. Visualizacion de los Cohortos
Vamos a hacer un mapa de calor con el método heatmap(). Le pasaremos la tabla revenue_per_user_pivot junto con los siguientes parámetros:
annot=True (anotar), que significa que el valor se mostrará para cada celda;
fmt='.1f' (formato), que establece el formato de impresión (aquí, un decimal);
linewidths=1, que establece el ancho de la línea que separa las celdas del mapa de calor (1 píxel);
linecolor='gray', que establece el color de la línea en gris.
In [68]: import seaborn as sns

from matplotlib import pyplot as plt
plt.figure(figsize=(13, 9))
plt.title('Tamaño promedio de compra del cliente')
sns.heatmap(
revenue_per_user_pivot,
annot=True,
fmt='.1f',
linewidths=1,
linecolor='gray',
)
Out[68]: <AxesSubplot:title={'center':'Tamaño promedio de compra del cliente'}, xlabel='cohort_lifetime', ylabel='first_order_month'>
33 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
05. Tasa de retencion y cancelacion
La tasa de retencion : cuenta cuántos usuarios/as de una cohorte siguen activos respecto a su número inicial.
La tada de cancelacion : Te cuenta la proporción de usuarios que dejaron de usar el producto con el paso de tiempo. Siempre se calcula
con el mes anterior y asi sucesivamente
Es fácil encontrar la tasa de cancelación: solo necesitamos comparar el número de usuarios/as con el número en el período anterior. Podemos
usar el método pct_change() (cambio porcentual). Encuentra el cambio porcentual en una columna en comparación con el valor en la fila
anterior. Si aplicas este método junto con la agrupación, se ejecutará dentro del grupo.
In [ ]: cohorts['churn_rate'] = cohorts.groupby(['first_activity_week'])['user_id'].pct_change()
34 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: churn_pivot = cohorts.pivot_table(
index='first_activity_week',
columns='cohort_lifetime',
values='churn_rate',
aggfunc='sum',
)
sns.set(style='white')
plt.figure(figsize=(13, 9))
plt.title('Cohortes: tasa de cancelación')
sns.heatmap(churn_pivot, annot=True, fmt='.1%', linewidths=1, linecolor='gray')
06. Comportamiento
El objetivo es analizar como va variando el comportamiento de un cohorte de usuarios
In [ ]: import pandas as pd
# Se carga el archivo csv con los eventos

events = pd.read_csv('/datasets/coffee_home.csv')
# Se convierten las columnas de fechas a datetime

events['coffee_time'] = pd.to_datetime(events['coffee_time'])
events['first_coffee_datetime'] = pd.to_datetime(events['first_coffee_datetime'])
# Se calcula el tiempo que pasó entre el primer evento de café y cada evento de café posterior
events['time_to_event'] = events['coffee_time'] - events['first_coffee_datetime']
# Se filtran los eventos que ocurrieron en los primeros 30 días después del primer evento de café
filtered_events = events[events['time_to_event'] < '30 days']
# Se cuenta el número de eventos de café por usuario

count_events_by_users = filtered_events.groupby(['user_id']).agg({'coffee_time': 'count'}).reset_index()
# Se agrega una columna indicando si cada usuario tuvo más de 4 eventos de café (este es el comportamiento objetivo)
count_events_by_users['is_target_behavior'] = count_events_by_users['coffee_time'] > 4
# Se obtienen los IDs de usuarios con el comportamiento objetivo y los IDs de usuarios sin este comportamiento
user_ids_with_target_behavior = count_events_by_users.query('is_target_behavior == True')['user_id'].unique()
user_ids_without_target_behavior = count_events_by_users.query('is_target_behavior != True')['user_id'].unique()
# Se agrega una columna indicando si cada evento de café pertenece al grupo de usuarios con el comportamiento objetivo o no
events.loc[events['user_id'].isin(user_ids_with_target_behavior), 'is_in_behavioral_cohort'] = 'yes'
events.loc[events['user_id'].isin(user_ids_without_target_behavior), 'is_in_behavioral_cohort'] = 'no'
# Se define una función para imprimir la tasa de retención y graficarla

def printRetentionRate(df):
# Se agrupa por la semana en que ocurrió el primer evento de café y el tiempo desde este evento hasta cada evento de café posterior
cohorts = df.groupby(['first_coffee_week', 'cohort_lifetime'], as_index=False).agg({'user_id': 'nunique'}).sort_values(['first_coffee_w
# Se cuenta el número de usuarios en cada cohorte en el momento inicial

inital_users_count = cohorts[cohorts['cohort_lifetime'] == 0][['first_coffee_week', 'user_id']]
inital_users_count = inital_users_count.rename(columns={'user_id': 'cohort_users'})
# Se unen los conteos iniciales con la tabla de cohortes

cohorts = cohorts.merge(inital_users_count, on='first_coffee_week')
# Se calcula la tasa de retención en cada cohorte y tiempo

cohorts['retention'] = cohorts['user_id'] / cohorts['cohort_users']
# Se imprime la tasa de retención promedio para cada tiempo desde el primer evento de café y se grafica
print(cohorts.groupby(['cohort_lifetime'])['retention'].mean())
cohorts.groupby(['cohort_lifetime'])['retention'].mean().plot.bar()
# Se llama a la función printRetentionRate para el subconjunto de eventos que pertenecen al grupo de usuarios con el comportamiento objetiv
printRetentionRate(events[events['is_in_behavioral_cohort'] == 'yes'])
C. Economia unitaria
01. Economia unitaria por venta
35 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
El objetivo es buscar el punto de equilibrio de ventas.punto de equilibrio (no obtener beneficios ni pérdida
• ¿ Cuanto se debe vender para cubrir los gastos?

• ¿ Que costos variables hay que disminuir o auemntar?
Hay que detectar lo siguiente:
Encuentra el margen de beneficio del negocio por venta. Solo contabiliza los gastos variables.
Si el margen de beneficio es negativo, las finanzas de la empresa están mal. Es necesario reducir gastos o
aumentar ingresos. De lo contrario, el fin está cerca.
Si el margen de beneficio es positivo con respecto a los gastos variables, agrega los gastos fijos. Calcula
el volumen de ventas necesario para que el negocio sea rentable.
In [ ]: El objetivo es buscar el punto de equilibrio de ventas. ¿ Cuanto se debe vender para cubrir los gastos
In [ ]: n_users = 50000
revenue_per_user = 10
# Crear una serie para determinar los costos
var_costs = pd.Series({'marketing': 200000, 'servers': 200000})
fixed_costs = pd.Series({'salaries': 300000, 'rent': 150000})
# por unidad
ingreso_por_unidad= revenue / items_sold

costo_por_unidad= costo_variable / items_sold
# mostrar por unidad
print('Ingresos:', revenue_per_user) #Ganancia por unidad

print('Costos:', one_unit_var_costs.sum()) # costo por unidad
print('Beneficios:',revenue_per_user - one_unit_var_costs.sum() ) # Ganancia por unidad
In [ ]: def unit_economics(marketing):
""" Calcula el beneficio o perdida al invertir en Marketing"""
items_sold = marketing / one_unit_var_costs['marketing'] # cantidad vendida = marketing dividido costo variable por unidad de marketin
revenue = one_unit_revenue * items_sold #Ganancia = ganancua por unidad por cantidad vendida
var_costs = one_unit_var_costs * items_sold # costo variable = costo variable por unidad por cantidad vendida
# Devovler el ingreso - costo varibale - costo fijo

return revenue - sum(var_costs) - sum(fixed_costs)
#a función range se utiliza para crear una secuencia de valores que inicia en 0, termina en 1000 y va por 1000
#"El valor de x es {} y el valor de y es {}".format(x, y))
for m in range(0, 10000, 1000):
# Ejemplo #"El valor de x es {} y el valor de y es {}".format(x, y))

print('Beneficio/pérdida: {} con un presupuesto de {}'.format(unit_economics(m), m))
In [7]: #Ejemplo dos
import pandas as pd
n_users = 50000
revenue_per_user = 10
var_costs = pd.Series({'marketing': 200000, 'servers': 200000})
fixed_costs = pd.Series({'salaries': 300000, 'rent': 150000})
revenue = n_users * revenue_per_user

total_costs = var_costs.sum() + fixed_costs.sum()
one_unit_var_costs = var_costs / n_users
def unit_economics(marketing):
n_users = marketing / one_unit_var_costs['marketing']
revenue = revenue_per_user * n_users
var_costs = one_unit_var_costs * n_users
return revenue - sum(var_costs) - sum(fixed_costs)# escribe tu código aquí
for m in range(300000, 1500000, 100000):

print('Beneficio/pérdida: {} con un presupuesto de {}'.format(unit_economics(m), m))
36 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Beneficio/pérdida: -300000.0 con un presupuesto de 300000

Beneficio/pérdida: 0.0 con un presupuesto de 900000
02. Economía unitaria por cliente: LTV y CAC
El enfoque de la economía unitaria por venta tiene una gran desventaja, ya que no tiene en cuenta las compras repetidascontinuas. Cuando un
negocio está creciendo rápidamente, es esencial tener en cuenta las compras continuas en el análisis.
La Economía Unitaria por Cliente es una medida de rentabilidad que se enfoca en el valor de cada cliente para un negocio. La idea es que al
conocer el valor que genera cada cliente, se puede establecer cuánto se puede invertir para adquirir nuevos clientes, y de esta forma,
maximizar la rentabilidad del negocio.
Para calcular la Economía Unitaria por Cliente, es necesario conocer dos variables clave: el Lifetime Value (LTV) y el Costo de Adquisición del
Cliente (CAC).
• El LTV es el valor que se espera que genere un cliente durante el tiempo que este permanezca como cliente del negocio. Este valor incluye
tanto los ingresos generados por el cliente, como los costos asociados a su adquisición, retención y servicio.
• El CAC, por su parte, es el costo que se incurre para adquirir a un nuevo cliente. Este costo incluye los gastos en publicidad, marketing,
promociones, entre otros.
La relación entre el LTV y el CAC es clave para determinar la rentabilidad de un negocio. Idealmente, el LTV debería ser mayor que el CAC, lo
que significa que cada cliente genera más valor del que cuesta adquirirlo. Si el CAC es mayor que el LTV, entonces el negocio tendrá pérdidas a
largo plazo.
Es útil encontrar el LTV para diferentes cohortes. Repasemos lo que tenemos que hacer:
encontrar la fecha de la primera compra de cada cliente;

calcular el número de nuevos clientes para cada fecha (o rango de fechas, en este caso, para cada mes);
añadir el mes del primer pedido a la tabla de pedidos;
agrupar la tabla y calcular los ingresos
In [ ]: # Creamos cohortos mensuales
orders['order_month'] = orders['order_date'].astype('datetime64[M]')
costs['month'] = costs['date'].astype('datetime64[M]')
# el mes de la primera compra de cada cliente:

first_orders = orders.groupby('uid').agg({'order_month': 'min'}).reset_index()
first_orders.columns = ['uid', 'first_order_month']
first_orders.head()
# calculamos el numero de nuevos clientes
cohort_sizes = first_orders.groupby('first_order_month').agg({'uid': 'nunique'}).reset_index()

cohort_sizes.columns = ['first_order_month', 'n_buyers']
cohort_sizes.head()
#Vamos a agregar los meses de la primera compra de los clientes y clientas a la tabla de pedidos:
orders_ = pd.merge(orders,first_orders, on='uid')

orders_.head()
# agrupar la tabla de pedidos por mes de la primera compra y mes de la compra y totalizar los ingresos.
# Vamos a establecer el índice por defecto usando el método reset_index():
cohorts = orders_.groupby(['first_order_month','order_month']).agg({'revenue': 'sum'}).reset_index()

cohorts.head()
LTV = (Ingreso medio por cliente * Margen de beneficio bruto) / Tasa de abandono de clientes
37 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: # Agreguemos datos sobre cuántos usuarios realizaron sus primeras compras en cada mes a la tabla cohorts
report = pd.merge(cohort_sizes, cohorts, on='first_order_month')
# hagamos que las columnas muestren la edad de la cohorte en lugar del mes del pedido y calcularemos en beneficio bruto
margin_rate = 0.5
report['gp'] = report['revenue'] * margin_rate

report['age'] = (
report['order_month'] - report['first_order_month']
) / np.timedelta64(1, 'M')
#Dividimos por np.timedelta64(1, 'M') para convertir la resta en cantidad de meses en vez de dias
report['age'] = report['age'].round().astype('int')
report.head()
In [ ]: # Calcularesmoe el LTV Dividamos el beneficio bruto de la cohorte de cada mes por el número total de usuarios de cada cohorte
report['ltv'] = report['gp'] / report['n_buyers']
#Creamos una tabla dinamica
output = report.pivot_table(
index='first_order_month', columns='age', values='ltv', aggfunc='mean'
).round()
output.fillna('')
#Encontremos el LTV de la primera cohorte sumando el valor de cada mes:
ltv_201803 = output.loc['2018-03-01'].sum()
ltv_201803
In [ ]: En promedio, cada cliente de la primera cohorte generó $4 538 en ingresos durante su ciclo de vida de siete meses.
In [ ]: #Encontremos el LTV de la primera cohorte sumando el valor de cada mes:
# Calculemos el CAC para esta cohorte. Dividiremos los costos del mes de la cohorte por el número de personas:
# obtener la cohorte necesaria

cohort_201803 = report[report['first_order_month'] == '2018-03-01']
# calcular los costos para el mes de la cohorte

costs_201803 = costs[costs['month'] == '2018-03-01']['costs'].sum()
n_buyers_201803 = cohort_201803['n_buyers'][0]
cac_201803 = costs_201803 / n_buyers_201803
print('CAC =', cac_201803)

print('LTV =', ltv_201803)
Adquirir cada cliente le costó a la empresa un promedio de $3 145.70, mientras que cada cliente generó $4 538. Por lo tanto, la inversión en la
adquisición de clientes valió la pena e incluso generó beneficios.
Hagamos cálculos para calcular los costos por mesa las otras cohortes y determinemos la cantidad de meses que cada cohorte necesita para
cubrir los gastos de marketing.
In [ ]: # calcular los costos por mes

monthly_costs = costs.groupby('month').sum()
# Agreguemos los datos sobre los costos al informe y calculemos el CAC:
report_ = pd.merge(report, monthly_costs, left_on='first_order_month', right_on='month')

report_['cac'] = report_['costs'] / report_['n_buyers']
ahora busquemos el ROMI (retorno de la inversión en marketing, o return on marketing investment en inglés) dividiendo el LTV por el CAC.
Para calcular el ROMI acumulado, necesitaremos llamar al método cumsum() (suma acumulativa, o cumulative sum en inglés). Esto agrega cada
nuevo elemento a un conjunto. Por ejemplo, pd.Series([1, 2, 3]).cumsum() devolverá una serie de tres elementos: 1, 3 y 6.
38 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: report_['romi'] = report_['ltv'] / report_['cac']

output = report_.pivot_table(
index='first_order_month', columns='age', values='romi', aggfunc='mean'
)
output.cumsum(axis=1).round(2)
intentemos averiguar qué tan rápido empiezan a compensar las cohortes en promedio. Promediaremos los valores en cada columna y
convertiremos la tabla en un solo objeto Series con el método mean(axis=0)
In [ ]: output.cumsum(axis=1).mean(axis=0)
D. Metricas
01. Metrica por usuario
Hay tres métricas principales que describen el número de usuarios activos:
DAU: el número de usuarios activos diarios (únicos);

WAU: el número de usuarios activos semanales;
MAU: el número de usuarios activos mensuales.
In [ ]: Calcular la metrica MAU
In [ ]: users_data['session_start_ts'] = pd.to_datetime(
users_data['session_start_ts'], format="%Y-%m-%d %H:%M"
)
users_data['session_end_ts'] = pd.to_datetime(
users_data['session_end_ts'], format="%Y-%m-%d %H:%M"
)
users_data['session_year'] = users_data['session_start_ts'].dt.year
users_data['session_month'] = users_data['session_start_ts'].dt.month
users_data['session_week'] = users_data['session_start_ts'].dt.week
users_data['session_date'] = users_data['session_start_ts'].dt.date
mau_total = (
users_data.groupby(['session_year', 'session_month'])
.agg({'id': 'nunique'})
.mean()
)
print(int(mau_total))
#Mostrará la cantidad de usuarios activos mensuales
También existe el sticky factor (factor de adherencia). Esta métrica te dice qué tan leal es la audiencia, con qué frecuencia regresan a
la aplicación. La fórmula es simple: sticky factor = DAU/WAU o sticky factor = DAU/MAU
In [ ]: #Calculamos DAU
dau_total = users_data.groupby('session_date').agg({'id': 'nunique'}).mean()
#Calculamos wau
wau_total = (
users_data.groupby(['session_year', 'session_week'])
.agg({'id': 'nunique'})
.mean()
)
#Calculams STICKY
sticky_wau = dau_total / wau_total * 100
print(sticky_wau)
sticky_mau = dau_total / mau_total * 100
print(sticky_mau)
02. Sesion por usuarios
Es el conjunto de acciones del usuario que comienza cuando se abre la aplicación y finaliza cuando se cierra.Solo tenemos que dividir el
número de sesiones entre el número de usuarios para un período determinado:
39 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: sessions_df = pd.read_csv('/datasets/users_sessions_data.csv')
sessions_df['session_start_ts'] = pd.to_datetime(
sessions_df['session_start_ts']
)
sessions_df['session_end_ts'] = pd.to_datetime(sessions_df['session_end_ts'])
sessions_df['session_year'] = sessions_df['session_start_ts'].dt.year
sessions_df['session_month'] = sessions_df['session_start_ts'].dt.month
#Agrupamos los datos en año y mes De esta manera, se obtiene una tabla que muestra el número total de sesiones y el número de usuarios únic
# que las han realizado para cada mes y año, y que servirá para calcular la cantidad de sesiones por usuario en cada período.
sessions_per_user = sessions_df.groupby(['session_year', 'session_month']).agg(

{'client_id': ['count', 'nunique']}
)
#Cambiamos el nombre de columnas
sessions_per_user.columns = ['n_sessions', 'n_users']
#Realizamos el calculo de dividir sesisiones por usuarios

sessions_per_user['sessions_per_user'] = (
sessions_per_user['n_sessions'] / sessions_per_user['n_users']
)
print(sessions_per_user)
La duración media de la sesión, o ASL (Average session length), es la cantidad de tiempo que los usuarios y las usuarias pasan con un
producto en la sesión promedio.
In [ ]: # Encontremos el ASL calculando la duración de todas las sesiones y encontrando la media:
sessions_df['session_duration_sec'] = (sessions_df['session_end_ts'] - sessions_df['session_start_ts']).dt.seconds

print(sessions_df['session_duration_sec'].mean())
#Cuando la distribución es normal o casi normal, puedes tomar la media o la mediana. Pero en nuestro caso es imposible, entonces tenemos qu
print(sessions_df['session_duration_sec'].mode())
03. Framework de metricas
Un framework de métricas es un conjunto de medidas o indicadores utilizados para evaluar y medir el rendimiento de un sistema, proceso,
producto o servicio en relación con sus objetivos y metas. Estas métricas pueden ser cuantitativas o cualitativas, y pueden ser utilizadas para
medir diferentes aspectos del rendimiento, como la eficiencia, la efectividad, la calidad, la satisfacción del cliente, la rentabilidad, entre otros.
40 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Tipos de Framework:
1- el framework HEART
2- framework AARRR, a menudo llamado "métricas pirata" (pronuncia este nombre en voz alta). AARRR te ayuda
a entender el tráfico de usuarios y optimizar el embudo.
Adquisición: ¿De dónde viene cada cliente?

Activación ¿Los usuarios y las usuarias completaron una acción específica cuando comenzaron a
interactuar con el producto?
Retención (Retention): ¿Cuántos/as clientes siguen usando tu producto y por qué los demás dejan de
usarlo?
Referencia: Los usuarios están dispuestos a recomendar su producto?
Ingreso (Revenue): ¿Cómo se puede aumentar el ingreso?
41 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
5b23573f882.png)
04. Deteccion de anomalias
Este proceso tiene varias etapas:
1 Recopilar datos y calcular las métricas clave.

2 Visualizar datos.
3 Separar los datos con comportamiento anómalo (hacer un slice de datos y "aislarlo", como dirían los/las
analistas).
4 Estudiar los datos y buscar la razón:
- comparar la anomalía con otras anomalías;
- tener en cuenta los eventos externos;
- analizar los problemas de los competidores;
- recopilación de datos (cómo se hizo, qué pudo haber salido mal);
- tener en cuenta la estacionalidad, los lanzamientos futuros y las mejoras importantes.
5 Sacar conclusiones.
05. Y.Metrica
42 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
es una herramienta de análisis web que ayuda a rastrear las sesiones del sitio web, evaluar el comportamiento de usuario, evaluar el
rendimiento de los canales de promoción y realizar análisis de contenido.
¿Qué puede decirte Y.Metrica acerca de los usuarios y las usuarias?
Su edad y género;
sus intereses;
los países y ciudades de donde provienen y los idiomas que hablan;
los dispositivos o navegadores que utilizan;
qué tan leales son y cuánto dinero aportan.
https://metrica.yandex.com/dashboard?group=day&period=week&id=44147844
https://www.youtube.com/playlist?list=PLes02YtPKABmUNneqfc9DZuSEatPEbdVz
Y.Metrica te ayuda a solucionar múltiples tareas:
encontrar problemas en el sitio web;

recrear las trayectorias de los/las usuarios/as en el sitio web;
análisis de marketing;
analítica para tiendas en línea.
Consideremos un caso típico. ¿Qué preguntas tienes que responder cuando buscas problemas en el sitio web?
¿Funcionan bien las páginas de destino?

¿Qué hacen exactamente los usuarios y usuarias en el sitio web?
¿Cómo pasan por el embudo de conversión?
¿Qué elementos de la página son visibles y cuáles no?
¿Es compatible el sitio web con varios dispositivos?
06. Y.Metrica API
1. Introducción y obtención de un token de acceso
El token contiene datos de autorización. Pertenece únicamente a ti y no se puede proporcionar a nadie más, ya que es tu acceso a las
estadísticas de Y.Metrica. Recomendamos que guardes tu token en un archivo especial. Esto te permitirá compartir tu Jupyter Notebook con el
algoritmo de forma segura.
1. Evaluar la posibilidad de crear una solicitud
2. Creación de una solicitud de registros
3. Comprobar si los registros están listos
4. Descarga de registros
43 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
Ejercicios El archivo /datasets/yandex_metrika_logs.csv contiene datos sobre las visitas a la página de ayuda de Y.Metrica:
ym:s:visitID: identificador de visita;

ym:s:dateTime: hora de la visita;
ym:s:isNewUser: si es la primera visita o no;
ym:s:visitDuration: duración de la visita en segundos;
ym:s:startURL: URL de la página de acceso;
ym:s:clientID: identificador del usuario;
ym:s:lastTrafficSource: fuente de tráfico:
ad: tráfico de anuncios;
organic: tráfico del motor de búsqueda;
direct: tráfico directo;
referral: tráfico de referencia;
internal: tráfico interno;
social: tráfico de redes sociales;
email: tráfico de correo electrónico;
messenger: tráfico de mensajería;
saved: tráfico de páginas guardadas.
Traza dos histogramas en una sola visualización:

La distribución de la duración de la visita para el tráfico de anuncios: (ym:s:lastTrafficSource =
'ad')
La distribución de la duración de la visita para el tráfico del motor de búsqueda:
(ym:s:lastTrafficSource = 'organic')
Al trazar histogramas, ignora las visitas con una duración de 0 segundos.
Evalúa si la diferencia entre la duración promedio de las visitas provenientes de estas dos fuentes de
tráfico es estadísticamente significativa. Para hacerlo, prueba la hipótesis de que los dos promedios son
iguales. Al probar hipótesis, ignora las visitas con una duración de 0 segundos.
In [ ]: import pandas as pd
logs = pd.read_csv('/datasets/yandex_metrika_logs.csv')
# Crea un slice de datos logs_with_duration para almacenar todas las visitas de más de 0 segundos.
logs_with_duration = logs[logs['ym:s:visitDuration'] > 0]
#Un slice de datos ad_visits que contiene visitas que provienen del tráfico de anuncios (ym:s:lastTrafficSource == 'ad')
ad_visits = logs_with_duration[
logs_with_duration['ym:s:lastTrafficSource'] == 'ad'
]
#Un slice de datos organic_visits que contiene visitas "orgánicas" que provienen del tráfico del motor de búsqueda (ym:s:lastTrafficSource
organic_visits = logs_with_duration[
logs_with_duration['ym:s:lastTrafficSource'] == 'organic'
]
#Creacion de dos histogramas
ad_visits['ym:s:visitDuration'].hist(alpha=0.5, range=(0, 2000))

organic_visits['ym:s:visitDuration'].hist(alpha=0.5, range=(0, 2000))
#Pon a prueba la hipótesis de que los dos valores promedio son iguales
alpha = 0.05
results = st.ttest_ind(ad_visits_durations, organic_visits_durations)
if results.pvalue < alpha:

print("Rejecting the null hypothesis")
else:
print("Failed to reject the null hypothesis")
E. optimizar datos en pandas
44 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]: # Primer tips de archivos grandes, descargar solo una parte
df = pd.read_csv('data/prkt_metrics_data_afisha/visits.csv', nrows=500)
#Conocer la memoria usar deep
df.info(memory_usage='deep')
#deshacerte del tipo object ya que usan mucha memoria
# Analicemos las columnas una por una.
df['Device'].value_counts()
#modificamos object pr categorty que ocupa mucho menos espacio
df['Device'] = df['Device'].astype('category')
# modificas las columnas a formato fecha
df['Start Ts'] = pd.to_datetime(df['Start Ts'], format="%d.%m.%Y %H:%M")
# Descargar datos con los tipos de datos correctos, es más rapido
dd = pd.read_csv(
'data/prkt_metrics_data_afisha/visits.csv',
nrows=500,
dtype={'Device': 'category'}, # se soloca primero la columna y despues de los : el tipo de dato
parse_dates=['Start Ts', 'End Ts'], # convertir a formato fecha
)
In [3]: ! pip install missingno
import pandas as pd
import missingno as msno
# Crear un DataFrame de ejemplo con valores faltantes

df = pd.DataFrame({'A': [1, 2, 3, None, 5],
'B': [6, None, 8, 9, 10],
'C': [11, 12, 13, 14, None]})
# Visualizar los valores faltantes en el DataFrame

msno.matrix(df)
Collecting missingno
Downloading missingno-0.5.2-py3-none-any.whl (8.7 kB)
Requirement already satisfied: scipy in c:\users\clara\anaconda3\lib\site-packages (from missingno) (1.7.3)
Requirement already satisfied: numpy in c:\users\clara\anaconda3\lib\site-packages (from missingno) (1.21.5)
Requirement already satisfied: matplotlib in c:\users\clara\anaconda3\lib\site-packages (from missingno) (3.5.1)
Requirement already satisfied: seaborn in c:\users\clara\anaconda3\lib\site-packages (from missingno) (0.11.2)
Requirement already satisfied: pillow>=6.2.0 in c:\users\clara\anaconda3\lib\site-packages (from matplotlib->missingno) (9.0.
1)
Requirement already satisfied: pyparsing>=2.2.1 in c:\users\clara\anaconda3\lib\site-packages (from matplotlib->missingno) (3.
0.4)
Requirement already satisfied: python-dateutil>=2.7 in c:\users\clara\anaconda3\lib\site-packages (from matplotlib->missingno)
(2.8.2)
Requirement already satisfied: fonttools>=4.22.0 in c:\users\clara\anaconda3\lib\site-packages (from matplotlib->missingno)
(4.25.0)
Requirement already satisfied: kiwisolver>=1.0.1 in c:\users\clara\anaconda3\lib\site-packages (from matplotlib->missingno)
(1.3.2)
Requirement already satisfied: cycler>=0.10 in c:\users\clara\anaconda3\lib\site-packages (from matplotlib->missingno) (0.11.
0)
Requirement already satisfied: packaging>=20.0 in c:\users\clara\anaconda3\lib\site-packages (from matplotlib->missingno) (21.
3)
Requirement already satisfied: six>=1.5 in c:\users\clara\anaconda3\lib\site-packages (from python-dateutil>=2.7->matplotlib->
missingno) (1.16.0)
Requirement already satisfied: pandas>=0.23 in c:\users\clara\anaconda3\lib\site-packages (from seaborn->missingno) (1.4.2)
Requirement already satisfied: pytz>=2020.1 in c:\users\clara\anaconda3\lib\site-packages (from pandas>=0.23->seaborn->missing
no) (2021.3)
Installing collected packages: missingno
Successfully installed missingno-0.5.2
Out[3]: <AxesSubplot:>
45 of 46 4/21/2023, 7:15 PM
Teoria about:srcdoc
In [ ]:
46 of 46 4/21/2023, 7:15 PM

Analisis de Negocios - Practicum

Cargado por

Copyright:

Formatos disponibles

Analisis de Negocios - Practicum

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Analisis de Negocios - Practicum

Cargado por

Copyright:

Formatos disponibles

Teoria about:srcdoc

# Agregamos en enlace y lo guardamos en URL

# llamamos get de la libreria requests que actua como navegador

req = requests.get(URL) # guardando el objeto de respuesta como variable requerida

"""Un objeto response contiene la respuesta del servidor:

print(req.status_code) # el atributo status_code te dice si el servidor respondio o si ocurrio un error

Es una herramienta que te ayuda a buscar cadenas en textos grandes

In [2]: #primera etapa

In [ ]: Expresión regular Descripción Ejemplo Explicación

$ Fin de cadena a$ 1a, ba

\+ expresiones literales que muestre el mas

Creaciones de expresiones regulares

In [3]: #Search busca un patrón en una cadena

<re.Match object; span=(1, 8), match='General'>

string = '"General Slocum" 15 June 1904 East River human factor'

string = '"General Slocum" 15 June 1904 East River human factor'

string = '"General Slocum" 15 June 1904 East River human factor'

string = '"General Slocum" 15 June 1904 East River human factor'

"General Slocum" June East River human factor

tion = "Arrived at the station in total frustration"

print('Palabras con guion')

#Palabras con guion

string = 'sixty-seven drops of rain'

#len(), te permite determinar cuántas veces se repite una subcadena:

string = 'sixty-seven drops of rain'

string = 'sixty-seven drops of rain'

https://regexone.com (lecciones cortas y práctica)

print(re.findall('[A-ü ]*Mantequilla[A-ü ]*', req_text))

found_products = re.findall('Horizon[ \w\-%]+', req_text)

<title>Tierra de lácteos Tienda</title>

Analisis sintactico HTTML

Los métodos de BeautifulSoup convierten un archivo HTML en una estructura de árbol

In [9]: #importamos la libreria

#Con esto lo convertimos en arbol

#Llamamos al metodo find()

#Hay otro metodo que encuenrta todos los elementos

#Usamos el metodo texto para extrar solo el contenido

for paragraph in soup.find_all('p'):

#Usamos el metodo attrs (atributos) qe busca clases e identificadores

#vamos a extrar cierta informacion y la convertiremos en un df

table = soup.find('table',attrs={"id": "ten_years_first"})

<h2>Los mayores naufragios del siglo XX</h2>

Gracias a Hollywood, solemos asociar todos los naufragios con el Titanic,

Y aquÃ tenemos tres naufragios de 1910, incluyendo al Titanic.

heading_table = [] # Lista donde se almacenarán los nombres de las columnas

In [11]: # Ahora crearemos una lista vacia

content = [] # lista donde se almacenarán los datos de la tabla

In [12]: """Terminamos con dos listas.

shipwrecks = pd.DataFrame(content, columns=heading_table)

0 General Slocum 15 de junio de 1904 RÃo Este Factor humano

1 Camorta 6 de mayo de 1902 BahÃa de Bengala Fuerza de la naturaleza

2 Norge 28 de junio de 1904 OcÃ©ano AtlÃ¡ntico Factor humano

#Paso 1_ importamos las librerias

#Paso_3 Creamos una lista vacia donde almacene los precios

#Paso 4: Creamos un dataframe de las dos variables anteriores

In [ ]: # Acceso por numero de pagina

• Aplicar un parametro de ciudad moscu y que aplique solo 5 dias

In [16]: import json

In [19]: #Convierte cadenas

print(re.findall('[A-ü ]Mantequilla[A-ü ]', req_text))