Pandas
Libraries
16 Métodos Infravalorados de Pandas y Cuándo Utilizarlos
En este artículo, vamos a explorar algunos métodos de pandas menos conocidos pero muy útiles para manipular objetos de tipo Series. Algunos de estos métodos están relacionados sólo con Series, los otros - tanto con Series como con DataFrames, teniendo, sin embargo, características específicas cuando se utilizan con ambos tipos de estructura.1. is_uniqueComo su nombre indica, este método comprueba si todos los valores de una serie son únicos:import pandas as pd
print(pd.Series([1, 2, 3, 4]).is_unique)
print(pd.Series([1, 2, 3, 1]).is_unique)
Output:
True
False
2 & 3. is_monotonic y is_monotonic_decreasingCon estos 2 métodos, podemos comprobar si los valores de una Serie están en orden ascendente/descendente:print(pd.Series([1, 2, 3, 8]).is_monotonic)
print(pd.Series([1, 2, 3, 1]).is_monotonic)
print(pd.Series([9, 8, 4, 0]).is_monotonic_decreasing)
Output:
True
False
TrueAmbos métodos funcionan también para una Serie con valores de cadena. En este caso, Python utiliza un ordenamiento lexicográfico bajo el capó, comparando dos cadenas posteriores carácter por carácter. No es lo mismo que un ordenamiento alfabético, y de hecho, el ejemplo con los datos numéricos de arriba es un caso particular de dicho ordenamiento. Como dice la documentación de PythonEl ordenamiento lexicográfico para cadenas utiliza el número de punto de código Unicode para ordenar los caracteres individuales.Leer También: 4 Funciones de Python Pandas Imprescindibles Para el Análisis de Series TemporalesEn la práctica, significa principalmente que también se tienen en cuenta las mayúsculas y minúsculas y los símbolos especiales:print(pd.Series(['fox', 'koala', 'panda']).is_monotonic)
print(pd.Series(['FOX', 'Fox', 'fox']).is_monotonic)
print(pd.Series(['*', '&', '_']).is_monotonic)
Output:
True
True
FalseUna curiosa excepción ocurre cuando todos los valores de una Serie son iguales. En este caso, ambos métodos devuelven True:print(pd.Series([1, 1, 1, 1, 1]).is_monotonic)
print(pd.Series(['fish', 'fish']).is_monotonic_decreasing)
Output:
True
True
4. hasnansEste método comprueba si una Serie contiene valores NaN:import numpy as np
print(pd.Series([1, 2, 3, np.nan]).hasnans)
print(pd.Series([1, 2, 3, 10, 20]).hasnans)
Output:
True
False
5. emptyA veces, podemos querer saber si una Serie está completamente vacía, sin contener ni siquiera valores NaN:print(pd.Series().empty)
print(pd.Series(np.nan).empty)
Output:
True
FalseUna Serie puede quedar vacía después de algunas manipulaciones con ella, por ejemplo, el filtrado:s = pd.Series([1, 2, 3])
s[s > 3].empty
Output:
TrueLeer También: Una Mejor Forma De Preprocesar Datos: Pandas Pipe6 & 7. first_valid_index() y last_valid_index()Estos 2 métodos devuelven el índice del primer/último valor no NaN y son particularmente útiles para los objetos de la Serie con muchos NaNs:print(pd.Series([np.nan, np.nan, 1, 2, 3, np.nan]).first_valid_index())
print(pd.Series([np.nan, np.nan, 1, 2, 3, np.nan]).last_valid_index())
Output:
2
4Si todos los valores de una serie son NaN, ambos métodos devuelven None:print(pd.Series([np.nan, np.nan, np.nan]).first_valid_index())
print(pd.Series([np.nan, np.nan, np.nan]).last_valid_index())
Output:
None
None
8. truncate()Este método permite truncar una Serie antes y después de algún valor del índice. Vamos a truncar la Serie de la sección anterior dejando sólo los valores que no son NaN:s = pd.Series([np.nan, np.nan, 1, 2, 3, np.nan])
s.truncate(before=2, after=4)
Output:
2 1.0
3 2.0
4 3.0
dtype: float64El índice original de la Serie se ha conservado. Podemos querer restablecerlo y también asignar la Serie truncada a una variable:s_truncated = s.truncate(before=2, after=4).reset_index(drop=True)
print(s_truncated)
Output:
0 1.0
1 2.0
2 3.0
dtype: float64
9. convert_dtypes()Como dice la documentación de pandas, este método se utiliza paraConvertir columnas a los mejores dtypes posibles usando dtypes que soportan pd.NA.Si se consideran sólo los objetos Series y no los DataFrames, la única aplicación de este método es convertir todos los enteros anulables (es decir, los números float con una parte decimal igual a 0, como 1.0, 2.0, etc.) de nuevo en enteros "normales". Estos números flotantes aparecen cuando la serie original contiene tanto enteros como valores NaN. Dado que NaN es un float en numpy y pandas, hace que toda la Serie con cualquier valor que falte pase a ser también de tipo float.Veamos el ejemplo de la sección anterior para ver cómo funciona:print(pd.Series([np.nan, np.nan, 1, 2, 3, np.nan]))
print('\n')
print(pd.Series([np.nan, np.nan, 1, 2, 3, np.nan]).convert_dtypes())
Output:
0 NaN
1 NaN
2 1.0
3 2.0
4 3.0
5 NaN
dtype: float64
0 <NA>
1 <NA>
2 1
3 2
4 3
5 <NA>
dtype: Int64
10. clip()We can clip all the values of a Series at input thresholds (lower and upper parameters):s = pd.Series(range(1, 11))
print(s)
s_clipped = s.clip(lower=2, upper=7)
print(s_clipped)
Output:
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
dtype: int64
0 2
1 2
2 3
3 4
4 5
5 6
6 7
7 7
8 7
9 7
dtype: int64
11. rename_axis()En el caso de un objeto Serie, este método establece el nombre del índice:s = pd.Series({'flour': '300 g', 'butter': '150 g', 'sugar': '100 g'})
print(s)
s=s.rename_axis('ingredients')
print(s)
Output:
flour 300 g
butter 150 g
sugar 100 g
dtype: object
ingredients
flour 300 g
butter 150 g
sugar 100 g
dtype: objectLeer También: Pandas vs SQL. ¿Cuándo Los Científicos de Datos Deben Usar Uno Sobre el Otro?12 & 13. nsmallest() y nlargest()Estos 2 métodos devuelven los elementos más pequeños/grandes de una Serie. Por defecto, devuelven 5 valores, en orden ascendente para nsmallest() y en descendente - para nlargest().s = pd.Series([3, 2, 1, 100, 200, 300, 4, 5, 6])
s.nsmallest()
Output:
2 1
1 2
0 3
6 4
7 5
dtype: int64Es posible especificar otro número de los valores más pequeños/más grandes a devolver. Además, es posible que queramos restablecer el índice y asignar el resultado a una variable:largest_3 = s.nlargest(3).reset_index(drop=True)
print(largest_3)
Output:
0 300
1 200
2 100
dtype: int64
14. pct_change()Para un objeto Serie, podemos calcular el cambio porcentual (o, más precisamente, el cambio de fracción) entre el elemento actual y uno anterior. Este enfoque puede ser útil, por ejemplo, cuando se trabaja con series temporales, o para crear un gráfico de cascada en % o fracciones.s = pd.Series([20, 33, 14, 97, 19])
s.pct_change()
Output:
0 NaN
1 0.650000
2 -0.575758
3 5.928571
4 -0.804124
dtype: float64Para que la serie resultante sea más legible, vamos a redondearla:s.pct_change().round(2)
Output:
0 NaN
1 0.65
2 -0.58
3 5.93
4 -0.80
dtype: float64
15. explode()Este método transforma cada elemento tipo lista de una Serie (listas, tuplas, conjuntos, Series, ndarrays) en una fila. Los elementos tipo lista vacíos se transformarán en una fila con NaN. Para evitar índices repetidos en la Serie resultante, es mejor restablecer el índice:s = pd.Series([[np.nan], {1, 2}, 3, (4, 5)])
print(s)
s_exploded = s.explode().reset_index(drop=True)
print(s_exploded)
Output:
0 [nan]
1 {1, 2}
2 3
3 (4, 5)
dtype: object
0 NaN
1 1
2 2
3 3
4 4
5 5
dtype: object
16. repeat()Este método se utiliza para repetir consecutivamente cada elemento de una Serie un número definido de veces. También en este caso, tiene sentido restablecer el índice:s = pd.Series([1, 2, 3])
print(s)
s_repeated = s.repeat(2).reset_index(drop=True)
print(s_repeated)
Output:
0 1
1 2
2 3
dtype: int64
0 1
1 1
2 2
3 2
4 3
5 3
dtype: int64Si el número de repeticiones se asigna a 0, se devolverá una Serie vacía:s.repeat(0)
Output:
Series([], dtype: int64)
ConclusiónEn resumen, hemos investigado 16 métodos de pandas poco utilizados para trabajar con Series y algunos de sus casos de aplicación. Si conoces otras formas interesantes de manipular Series en pandas, eres bienvenido a compartirlas en los comentarios.¡Gracias por leer!Leer También: Usando Python y Pandas Datareader Para Analizar Datos Financieros
Libraries
Pandas
4 Funciones de Python Pandas Imprescindibles Para el Análisis de Series Temporales
Los datos de series temporales consisten en puntos de datos unidos a marcas de tiempo secuenciales. Las ventas diarias, los valores de temperatura por hora y las mediciones de segundo nivel en un proceso químico son algunos ejemplos de datos de series temporales.
Los datos de series temporales tienen características diferentes a los datos tabulares ordinarios. Por ello, el análisis de series temporales tiene su propia dinámica y puede considerarse un campo aparte. Existen libros de más de 500 páginas que tratan en profundidad los conceptos y técnicas del análisis de series temporales.
Pandas fue creado por Wes Mckinney para proporcionar una herramienta eficiente y flexible para trabajar con datos financieros que son una especie de serie temporal. En este artículo, repasaremos 4 funciones de Pandas que se pueden utilizar para el análisis de series temporales.
Necesitamos datos para los ejemplos. Empecemos por crear nuestros propios datos de series temporales.import numpy as np
import pandas as pd
df = pd.DataFrame({
"date": pd.date_range(start="2020-05-01", periods=100, freq="D"),
"temperature": np.random.randint(18, 30, size=100) +
np.random.random(100).round(1)
})
df.head()(image by author)Hemos creado un marco de datos que contiene mediciones de temperatura durante un periodo de 100 días. La función date_range de Pandas puede utilizarse para generar un rango de fechas con una frecuencia personalizada. Los valores de temperatura se generan de forma aleatoria utilizando las funciones Numpy.
Ahora podemos empezar con las funciones.1. ShiftEs una operación habitual para desplazar los datos de las series temporales. Podemos necesitar hacer una comparación entre características retardadas o principales. En nuestro marco de datos, podemos crear una nueva característica que contenga la temperatura del día anterior.df["temperature_lag_1"] = df["temperature"].shift(1)
df.head()(image by author)El valor escalar que se pasa a la función de desplazamiento indica el número de períodos a desplazar. La primera fila de la nueva columna se rellena con NaN porque no hay ningún valor anterior para la primera fila.
El parámetro fill_value puede utilizarse para rellenar los valores que faltan con un escalar. Sustituyamos el NaN por el valor medio de la columna de temperatura.df["temperature_lag_1"] = df["temperature"]\
.shift(1, fill_value = df.temperature.mean())
df.head()(image by author)Si le interesan los valores futuros, puede desplazarse hacia atrás pasando valores negativos a la función de desplazamiento. Por ejemplo, "-1" lleva la temperatura al día siguiente.2. ResampleOtra operación habitual que se realiza con los datos de las series temporales es el remuestreo. Consiste en cambiar la frecuencia de los periodos. Por ejemplo, podemos estar interesados en los datos de temperatura semanales en lugar de las mediciones diarias.
La función de remuestreo crea grupos (o bins) de un interno especificado. A continuación, podemos aplicar funciones de agregación a los grupos para calcular el valor basado en la frecuencia remuestreada.
Calculemos las temperaturas medias semanales. El primer paso es remuestrear los datos a nivel de semana. A continuación, aplicaremos la función de media para calcular el promedio.df_weekly = df.resample("W", on="date").mean()
df_weekly.head()(image by author)El primer parámetro especifica la frecuencia de remuestreo. "W" significa semana, sorprendentemente. Si el marco de datos no tiene un índice fecha-hora, la columna que contiene la información relacionada con la fecha o la hora debe pasarse al parámetro on.3. AsfreqLa función asfreq proporciona una técnica diferente para el remuestreo. Devuelve el valor al final del intervalo especificado. Por ejemplo, asfreq("W")devuelve el valor del último día de cada semana.
Para utilizar la función asfreq, debemos establecer la columna de la fecha como índice del marco de datos.df.set_index("date").asfreq("W").head()(image by author)Como estamos obteniendo un valor en un día concreto, no es necesario aplicar una función de agregación.4. RollingLa función rolling puede utilizarse para calcular la media móvil, que es una operación muy común para los datos de las series temporales. Crea una ventana de un tamaño determinado. A continuación, podemos utilizar esta ventana para realizar cálculos a medida que se desplaza por los puntos de datos.
La figura siguiente explica el concepto de balanceo.(image by author)Vamos a crear una ventana móvil de 3 y utilizarla para calcular la media móvil.df.set_index("date").rolling(3).mean().head()(image by author)Para cualquier día, los valores muestran la media del día y de los 2 días anteriores. Los valores de los 3 primeros días son 18,9, 23,8 y 19,9. Por tanto, la media móvil del tercer día es la media de estos valores, que es de 20,7.
Los 2 primeros valores son NaN porque no tienen los 2 valores anteriores. También podemos utilizar esta ventana móvil para cubrir el día anterior y el siguiente para cualquier día. Se puede hacer estableciendo el parámetro de centro como verdadero.df.set_index("date").rolling(3, center=True).mean().head()(image by author)Los valores de los 3 primeros días son 18,9, 23,8 y 19,9. Así, la media móvil del segundo día es la media de estos 3 valores. En esta configuración, sólo el primer valor es NaN porque sólo necesitamos 1 valor anterior.ConclusiónHemos cubierto 4 funciones de Pandas que se utilizan habitualmente en el análisis de series temporales. El análisis predictivo es una parte esencial de la ciencia de datos. El análisis de series temporales es el núcleo de muchos problemas que el análisis predictivo pretende resolver. Por lo tanto, si usted planea trabajar en el análisis predictivo, definitivamente debe aprender a manejar los datos de series temporales.
Gracias por leer este artículo. Por favor, hazme saber si tienes algún comentario.Soner Yıldırım
Libraries
Deployment
Científicos de Datos Sin Conocimientos de Ingeniería de Datos Se Enfrentarán A La Cruda Realidad
OPINION.Probablemente haya leído algún artículo sobre la diferencia entre un científico de datos y un ingeniero de datos. Siempre he pensado que la distinción es clara. Los ingenieros de datos preparan los datos para su uso y luego los científicos de datos trabajan con esos datos.Sin embargo, mi opinión sobre esta distinción ha cambiado drásticamente después de empezar a trabajar como científico de datos.Photo by Ben White on UnsplashTodo en la ciencia de datos comienza con los datos. Tu modelo de aprendizaje automático es tan bueno como los datos que se introducen en él. Si entra basura, sale basura. Un científico de datos no puede hacer magia para crear un producto valioso sin los datos adecuados.Los datos adecuados no siempre están disponibles para los científicos de datos. En la mayoría de los casos, será responsabilidad del científico de datos convertir los datos en bruto a un formato adecuado.A menos que trabaje en una gran empresa tecnológica que tenga equipos separados de ingenieros de datos y científicos de datos, debe poseer la capacidad y las habilidades para manejar algunas tareas de ingeniería de datos. Estas tareas cubren una amplia gama de operaciones y me explayaré sobre ello en la parte restante del artículo.En cualquier caso, ¿cuál es la diferencia?Me gustaría exponer mi opinión sobre la relación entre el trabajo de un ingeniero de datos y un científico de datos.Un ingeniero de datos es un ingeniero de datos. Un científico de datos debería ser tanto un científico de datos como un ingeniero de datos.Puede parecer una afirmación discutible. Sin embargo, me gustaría destacar que mi opinión era diferente antes de empezar a trabajar como científico de datos. Solía pensar en los ingenieros de datos y en los científicos de datos como entidades separadas.Por ejemplo, los ingenieros de datos realizan un conjunto de operaciones conocido como ETL (extracción, transformación y carga). Abarca los procedimientos para recopilar datos de una o más fuentes, aplicar algunas transformaciones y luego cargarlos en una fuente diferente.Definitivamente, no me sorprendería que se esperara que un científico de datos realizara operaciones ETL. La ciencia de los datos sigue evolucionando y la mayoría de las empresas no tienen claramente separadas las funciones de ingeniero de datos y de científico de datos. Como resultado, un científico de datos debería ser capaz de realizar algunas tareas de ingeniería de datos.Si espera trabajar únicamente en la ejecución de algoritmos de aprendizaje automático con datos listos para su uso, se enfrentará a la cruda realidad poco después de empezar a trabajar como científico de datos.Es posible que tengas que escribir algunos procedimientos almacenados en SQL para preprocesar los datos del cliente. También es posible que recibas los datos del cliente de varias fuentes diferentes. Su trabajo consistirá en extraerlos y combinarlos. A continuación, tendrá que cargarlos en una única fuente. Para escribir procedimientos almacenados eficientes, se necesitan amplios conocimientos de SQL.La parte de transformación de los procedimientos ETL implica muchos pasos de limpieza y manipulación de datos. SQL puede no ser la mejor opción si se trabaja con datos a gran escala. La informática distribuida es una mejor alternativa en estos casos. Por lo tanto, un científico de datos también debería estar familiarizado con la computación distribuida.Su mejor amigo en la computación distribuida puede ser Spark. Es un motor de análisis utilizado para el procesamiento de datos a gran escala. Podemos distribuir tanto los datos como los cálculos en clústeres para conseguir un aumento sustancial del rendimiento.Si estás familiarizado con Python y SQL, no te será difícil acostumbrarte a Spark. Puedes utilizar las características de Spark con PySpark, que es una API de Python para Spark.Lea También: Una Guía Para Principiantes - Apache SparkCuando se trata de trabajar con clusters, el entorno óptimo es la nube. Hay varios proveedores de la nube, pero AWS, Azure y Google Cloud Platform (GCP) están a la cabeza.Aunque el código de PySpark es el mismo para todos los proveedores de la nube, la forma de configurar el entorno y crear clusters cambia entre ellos. Permiten crear clusters utilizando tanto scripts como la interfaz de usuario.La computación distribuida en clústeres es un mundo completamente diferente. No se parece en nada a hacer análisis en tu ordenador. Tiene una dinámica muy diferente. Evaluar el rendimiento del clúster y elegir el número óptimo de trabajadores para un clúster serán sus preocupaciones predominantes.Lea También: * El Data Scientist "Full Stack"* Todo Lo Que un Científico de Datos Debe Saber Sobre la Gestión de Datos (Pero Tiene Miedo de Preguntar)
Libraries
Personaliza Tus Jupyter Notebooks
IntroducciónJupyter Notebook es un gran entorno de programación y a menudo la opción más popular para los científicos de datos o analistas de datos que están codificando en python. Desafortunadamente, su configuración por defecto no permite el nivel de personalización que tienes con entornos de programación estándar como PyCharm o herramientas similares.Los themes (de ahora en adelante temas) de Jupyter Notebooks están tratando de disminuir esta brecha y te permiten hacer el notebook un poco más bonito y también más funcional usando los temas. En este artículo, te guiaré a través del proceso de instalación de los temas de Jupyter Notebook y te mostraré algunas de sus características más importantes.InstalaciónLos temas de Jupyter Notebook son una biblioteca de código abierto y se pueden instalar con pip install. Sólo tienes que escribir el siguiente código en una línea de comandos:pip install jupyterthemesEsto debería activar la instalación de la última versión. Una vez hecho esto, deberías poder cambiar de tema, ajustar las fuentes utilizadas en los cuadernos o personalizar el estilo de los gráficos. En las próximas secciones veremos estas características en detalle.Cambio de temasDespués de la instalación, puedes lanzar Jupyter Notebooks de forma normal e inspeccionar los temas desde el propio notebook.Para listar todos los temas posibles, puedes utilizar el siguiente código:!jt -lComo puede ver, actualmente hay nueve temas disponibles. Para cambiar de tema puede utilizar este comando:!jt -t <theme_name>Elijamos el tema de onedork. !jt -t onedorkVerás que el tema no cambia inmediatamente. Algunas personas informan que pueden recargar la página y ver el efecto después de eso. Desde mi experiencia personal, tengo que reiniciar Jupyter Notebook para que el tema cambie. Basta con detener el notebook y volver a iniciarlo. Así es como debería verse con el tema onedork cuando se carga.Ahora, puedes jugar con diferentes temas y elegir tu favorito. Lo que notarás es que algunas partes de la interfaz gráfica de usuario estándar no son visibles por defecto en la configuración del tema. Me refiero a la parte que se muestra a continuación.Para cambiar el tema pero manteniendo el aspecto estándar de la GUI, puede utilizar la siguiente variación del código.!jt -t <theme_name> -T -N -klCon el tema de onedork, a estos les gustaría eso. !jt -t onedork -T -N -klAl reiniciar Jupyter Notebooks debería obtener un resultado similar al de la captura de pantalla siguiente.Para restablecer la configuración predeterminada del notebook, puede utilizar este código.!jt -rTen en cuenta que he mostrado los comandos ejecutándose en el propio Jupyter, pero puedes utilizarlos sin el signo de exclamación también en la ventana de la terminal.Configurar el estilo de los gráficosUna vez que estés utilizando los temas te darás cuenta de que los gráficos creados con la librería Matplotlib no tienen el mejor aspecto. Por ejemplo, este es un código simple para crear un gráfico de líneas.import matplotlib.pyplot as plt
%matplotlib inline
bp_x = np.linspace(0, 2*np.pi, num=40, endpoint=True)
bp_y = np.sin(bp_x)
# Make the plot
plt.plot(bp_x, bp_y, linewidth=3, linestyle="--",
color="blue", label=r"Legend label $\sin(x)$")
plt.xlabel(r"Description of $x$ coordinate (units)")
plt.ylabel(r"Description of $y$ coordinate (units)")
plt.title(r"Title here (remove for papers)")
plt.xlim(0, 2*np.pi)
plt.ylim(-1.1, 1.1)
plt.legend(loc="lower left")
plt.show()Y esta es la captura de pantalla de la trama que se crea en el cuaderno como se ve usando el tema onedork sin personalización.Esto definitivamente no coincide con el tema que has elegido. Resulta que para personalizar Matplotlib para que coincida con el tema tendrá que añadir dos líneas de código adicionales en la parte superior de su notebook.from jupyterthemes import jtplot
jtplot.style()Una vez que ejecute el mismo código del gráfico (con las dos líneas de código de arriba añadidas en la parte superior del cuaderno) debería ver que el gráfico ahora coincide con el estilo actual del tema.¡Eso se ve mucho mejor! De hecho, puedes cambiar el estilo del gráfico para que coincida con cualquier tema que quieras.from jupyterthemes import jtplot
jtplot.style(<theme_name>)Si no se da un parámetro de tema para la función de estilo, se utilizará el tema que esté cargado actualmente en el notebook. Tenga en cuenta que, a diferencia de la configuración del tema, no es necesario reiniciar el notebook al cambiar el estilo gráfico de Matplotlib. Cambio de fuentes Los temas de Jupyter Notebook no sólo permiten cambiar los temas, sino que también permiten una personalización adicional de las fuentes utilizadas en el cuaderno. Puedes cambiar las fuentes al cargar un tema con el comando jt y añadir algunos parámetros adicionales. Puedes personalizar... - la fuente utilizada para el código (-f) y su tamaño (-fs), - la fuente utilizada para el cuaderno (-nf) y su tamaño (-nfs) , - la fuente utilizada para el texto/marcado (-ft) y su tamaño (-fts). Resumen En este artículo, has aprendido a personalizar tu Jupyter Notebook estándar con los temas de Jupyter Notebook. Hemos repasado los detalles de la instalación de la biblioteca y hemos configurado los temas, incluyendo la personalización de los gráficos y las fuentes. Ahora deberías poder probarlo tú mismo. ¡Feliz personalización! Publicado originalmente en aboutdatablog.com:Customize your Jupyter Notebooks with Jupyter Notebooks Themes, on January 20, 2021.
Machine Learning
Libraries
Analizando conversión de clientes con Machine Learning y árboles de decisión
Analizando conversión de clientes con Machine Learning y árboles de decisión
Visualization
Pandas
Libraries
Usando Predictive Power Score Para Identificar Correlaciones Lineales
Usando Predictive Power Score Para Identificar Correlaciones Lineales
Business
Libraries
Pandas
Usando Python y Pandas Datareader Para Analizar Datos Financieros
Las finanzas y la economía son cada vez más interesantes para todo tipo de personas, independientemente de su carrera o profesión. Esto se debe a que a todos nos afectan los datos económicos, o al menos nos interesa cada vez más estar al día, y tenemos mucha información a la mano.Cada día se envían miles de millones de bytes de datos financieros a través de Internet. Ya sea el precio de una acción, una transacción de comercio electrónico o incluso información sobre el PIB de un país. Todos estos datos, cuando se organizan y gestionan adecuadamente, pueden utilizarse para construir algunas aplicaciones de software sorprendentes y perspicaces.
Pandas
Libraries
Usando Pandas Profiling Para Acelerar Nuestra Exploración de Datos
Pandas Profiling es una librería que genera informes desde un DataFrame de pandas. La función pandas df.describe() que usamos normalmente en Pandas es genial pero es un poco básica para un análisis exploratorio de datos más serio y detallado. pandas_profiling extiende el pandas DataFrame con df.profile_report() para un análisis de datos rápido.
Libraries
Python
Programming
Entendiendo El Módulo Collections de Python
El módulo collections de Python tiene diferentes tipos de datos especializados que funcionando como contenedores y que pueden utilizarse para reemplazar los contenedores de propósito general de Python (`dict`, `tuple`, `list` y `set`). Estudiaremos las siguientes partes de este módulo:- `ChainMap`- `defaultdict`- `deque`Existe un submódulo de colecciones llamado abc o Abstract Base Classes. Estas no serán tratadas en este post. ¡Empecemos con el contenedor ChainMap!ChainMapUn ChainMap es una clase que proporciona la capacidad de enlazar múltiples mapeos juntos de tal manera que terminan siendo una sola unidad. Si miras la documentación, te darás cuenta de que acepta `**maps*`, lo que significa que un ChainMap aceptará cualquier número de mapeos o diccionarios y los convertirá en una única vista que podrás actualizar. Veamos un ejemplo para que puedas ver cómo funciona:from collections import ChainMap
car_parts = {'hood': 500, 'engine': 5000, 'front_door': 750}
car_options = {'A/C': 1000, 'Turbo': 2500, 'rollbar': 300}
car_accessories = {'cover': 100, 'hood_ornament': 150, 'seat_cover': 99}
car_pricing = ChainMap(car_accessories, car_options, car_parts)car_pricing
>> ChainMap({'cover': 100, 'hood_ornament': 150, 'seat_cover': 99}, {'A/C': 1000, 'Turbo': 2500, 'rollbar': 300}, {'hood': 500, 'engine': 5000, 'front_door': 750})
car_pricing['hood']
>> 500Aquí importamos ChainMap de nuestro módulo de colecciones. A continuación creamos tres diccionarios. Luego creamos una instancia de nuestro ChainMap pasándole los tres diccionarios que acabamos de crear.Por último, intentamos acceder a una de las claves de nuestro ChainMap. Cuando hacemos esto, el ChainMap recorrerá cada mapa para ver si esa clave existe y tiene un valor. Si lo tiene, entonces el ChainMap devolverá el primer valor que encuentre que coincida con esa clave.Esto es especialmente útil si quiere establecer valores por defecto. Supongamos que queremos crear una aplicación que tiene algunos valores por defecto. La aplicación también conocerá las variables de entorno del sistema operativo. Si hay una variable de entorno que coincide con una de las claves que tenemos por defecto en nuestra aplicación, el entorno anulará nuestro valor por defecto. Además, vamos a suponer que podemos pasar argumentos a nuestra aplicación. Estos argumentos tienen prioridad sobre el entorno y los valores por defecto. Este es un lugar donde un ChainMap puede realmente ser útil. Veamos un ejemplo sencillo que está basado en uno de la documentación de Python:Nota: no ejecutes este código desde Jupyter Notebook, sino desde tu IDE favorito y llamandolo desde una terminal. de esta mandera `python chain_map.py -u daniel`import argparse
import os
from collections import ChainMap
def main():
app_defaults = {'username':'admin', 'password':'admin'}
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--username')
parser.add_argument('-p', '--password')
args = parser.parse_args()
command_line_arguments = {key:value for key, value in vars(args).items() if value}
chain = ChainMap(command_line_arguments, os.environ, app_defaults)
print(chain['username'])
if __name__ == '__main__':
main()
os.environ['username'] = 'test'
main()➜ python python3 post.py -u daniel
daniel
daniel
Vamos a desglosar esto un poco. Aquí importamos el módulo `argparse` de Python junto con el módulo `os`. También importamos `ChainMap`.A continuación tenemos una función simple que tiene algunos valores predeterminados. He visto estos valores por defecto utilizados para algunos enrutadores populares. Luego configuramos nuestro analizador de argumentos y le decimos cómo manejar ciertas opciones de la línea de comandos. Notarás que argparse no proporciona una forma de obtener un objeto diccionario de sus argumentos, así que usamos un dict comprehension para extraer lo que necesitamos. La otra pieza interesante aquí es el uso de las vars incorporadas de Python. Si lo llamaras sin un argumento vars se comportaría como los locales incorporados de Python. Pero si le pasas un objeto, entonces vars es el equivalente a la propiedad `__dict__` de object. En otras palabras, vars(args) es igual a `args.__dict__`. Finalmente creamos nuestro ChainMap pasando nuestros argumentos de la línea de comandos (si hay alguno), luego las variables de entorno y finalmente los valores por defecto.Al final del código, intentamos llamar a nuestra función, luego establecer una variable de entorno y llamarla de nuevo. Pruébalo y verás que imprime admin y luego prueba como se esperaba. Ahora vamos a intentar llamar al script con un argumento de línea de comandos:python chain_map.py -u danielCuando yo ejecuto esto en mi maquina, me retorna el daniel dos veces. Esto se debe a que nuestro argumento de línea de comandos anula todo lo demás. No importa que establezcamos el entorno porque nuestro ChainMap mirará primero los argumentos de la línea de comandos antes que cualquier otra cosa. Si lo intentas sin el `-u daniel` correrán los argumentos reales, en mi caso `"admin" "test"`Ahora que sabes cómo usar ChainMaps, ¡podemos pasar al Counter!Contador (`Counter`)El módulo de colecciones también nos proporciona una pequeña herramienta que permite realizar cómodos y rápidos recuentos. Esta herramienta se llama `Counter`. Puedes ejecutarla con la mayoría de los iterables. Vamos a probarlo con un stringfrom collections import Counter
Counter('superfluous')
>> Counter({'s': 2, 'u': 3, 'p': 1, 'e': 1, 'r': 1, 'f': 1, 'l': 1, 'o': 1})counter = Counter('superfluous')
counter['u']
>> 3En este ejemplo, importamos `Counter` de `collections` y le pasamos una cadena. Esto devuelve un objeto Counter que es una subclase del diccionario de Python. Luego ejecutamos el mismo comando pero lo asignamos a la variable counter para que podamos acceder al diccionario más fácilmente. En este caso, hemos visto que la letra `"u"` aparece tres veces en la cadena de ejemplo.El contador proporciona algunos métodos que pueden interesarle. Por ejemplo, puede llamar a elementos que obtendrá un iterador sobre los elementos que están en el diccionario, pero en un orden arbitrario. Esta función se puede considerar como un "codificador", ya que la salida en este caso es una versión codificada de la cadena.list(counter.elements())
>> ['s', 's', 'u', 'u', 'u', 'p', 'e', 'r', 'f', 'l', 'o']Otro método útil es most_common. Puede preguntarle al Contador cuáles son los elementos más comunes pasando un número que represente cuáles son los elementos `"n"` más recurrentes:counter.most_common(2)
[('u', 3), ('s', 2)]Aquí sólo preguntamos a nuestro Counter cuáles fueron los dos elementos más recurrentes. Como puedes ver, se produjo una lista de tuplas que nos dice que `"u"` ocurrió 3 veces y `"s"` ocurrió dos veces.El otro método que quiero cubrir es el método de sustracción. El método `subtract` acepta un iterable o un mapeo y utiliza ese argumento para restar. Es un poco más fácil de explicar si ves algo de código:counter_one = Counter('superfluous')
counter_one
>> Counter({'s': 2, 'u': 3, 'p': 1, 'e': 1, 'r': 1, 'f': 1, 'l': 1, 'o': 1})
counter_two = Counter('super')
counter_one.subtract(counter_two)
counter_one
>> Counter({'s': 1, 'u': 2, 'p': 0, 'e': 0, 'r': 0, 'f': 1, 'l': 1, 'o': 1})Así que aquí recreamos nuestro primer contador y lo imprimimos para saber qué hay en él. Así creamos nuestro segundo objeto Contador. Finalmente restamos el segundo contador del primero. Si miras con atención en la salida al final, notará que el número de letras de cinco de los elementos ha sido disminuido en uno.Como mencioné al principio de esta sección, puedes usar el Contador contra cualquier iterable o mapeo, por lo que no tienes que usar sólo cadenas. También puedes pasarle tuplas, diccionarios y listas.Pruébalo por tu cuenta para ver cómo funciona con esos otros tipos de datos. ¡Ahora estamos listos para pasar al `defaultdict`!`defaultdict`El módulo de colecciones tiene una práctica herramienta llamada `defaultdict`. El `defaultdict` es una subclase del dict de Python que acepta un `default_factory` como argumento principal. El `default_factory` suele ser un tipo de datos de Python, como int o una lista, pero también puedes usar una función o un lambda. Empecemos por crear un diccionario regular de Python que cuenta el número de veces que se utiliza cada palabra en una frase:sentence = "The red for jumped over the fence and ran to the zoo for food"
words = sentence.split(' ')
words
>> ['The',
'red',
'for',
'jumped',
'over',
'the',
'fence',
'and',
'ran',
'to',
'the',
'zoo',
'for',
'food']
reg_dict = {}
for word in words:
if word in reg_dict:
reg_dict[word] += 1
else:
reg_dict[word] = 1
print(reg_dict)
>> {'The': 1, 'red': 1, 'for': 2, 'jumped': 1, 'over': 1, 'the': 2, 'fence': 1, 'and': 1, 'ran': 1, 'to': 1, 'zoo': 1, 'food': 1}¡Ahora vamos a intentar hacer lo mismo con defaultdict!from collections import defaultdict
sentence = "The red for jumped over the fence and ran to the zoo for food"
words = sentence.split(' ')
d = defaultdict(int)
for word in words:
d[word] += 1
print(d)
>> defaultdict(<class 'int'>, {'The': 1, 'red': 1, 'for': 2, 'jumped': 1, 'over': 1, 'the': 2, 'fence': 1, 'and': 1, 'ran': 1, 'to': 1, 'zoo': 1, 'food': 1})Notarás enseguida que el código es mucho más sencillo. El defaultdict asignará automáticamente cero como valor a cualquier clave que no tenga ya en él. Nosotros añadimos uno para que tenga más sentido y también se incrementará si la palabra aparece varias veces en la frase.Ahora vamos a intentar utilizar un tipo de lista de Python como nuestro `default_factory`. Empezaremos con un diccionario regular, como antes.my_list = [(1234, 100.23), (345, 10.45), (1234, 75.00), (345, 222.66), (678, 300.25), (1234, 35.67)]
reg_dict = {}
for acct_num, value in my_list:
if acct_num in reg_dict:
reg_dict[acct_num].append(value)
else:
reg_dict[acct_num] = [value]Si ejecuta este código, debería obtener una salida similar a la siguiente:print(reg_dict)
>> {1234: [100.23, 75.0, 35.67], 345: [10.45, 222.66], 678: [300.25]}Ahora vamos a reimplementar este código usando defaultdict:from collections import defaultdict
my_list = [(1234, 100.23), (345, 10.45), (1234, 75.00), (345, 222.66), (678, 300.25), (1234, 35.67)]
d = defaultdict(list)
for acct_num, value in my_list:
d[acct_num].append(value)Una vez más, esto elimina la lógica condicional if/else y hace que el código sea más fácil de seguir. Aquí está la salida del código anterior:print(d)
>> defaultdict(<class 'list'>, {1234: [100.23, 75.0, 35.67], 345: [10.45, 222.66], 678: [300.25]})¡Esto es algo muy bueno! ¡Vamos a probar a usar un `lambda` también como nuestra `default_factory`!from collections import defaultdict
animal = defaultdict(lambda: "Monkey")
animal
>> defaultdict(<function __main__.<lambda>()>, {})
animal['Sam'] = 'Tiger'
print (animal['Nick'])
>> Monkey
animal
>> defaultdict(<function __main__.<lambda>()>, {'Sam': 'Tiger', 'Nick': 'Monkey'})Aquí creamos un `defaultdict` que asignará 'Monkey' como valor por defecto a cualquier clave. La primera llave la ponemos como 'Tiger', y la siguiente no la ponemos. Si imprimes la segunda llave, verás que tiene asignado 'Monkey'. En caso de que no lo hayas notado aún, es básicamente imposible causar un KeyError siempre y cuando establezcas el `default_factory` a algo que tenga sentido. La documentación menciona que si usted establece el `default_factory` a `None`, entonces recibirá un KeyError.Veamos cómo funciona eso:from collections import defaultdict
x = defaultdict(None)
x['Mike']
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-30-d21c3702d01d> in <module>
1 from collections import defaultdict
2 x = defaultdict(None)
----> 3 x['Mike']
KeyError: 'Mike'En este caso, acabamos de crear un `defaultdict` con un error. Ya no puede asignar un valor por defecto a nuestra llave, así que lanza un `KeyError` en su lugar. Por supuesto, ya que es una subclase de `dict`, podemos simplemente establecer la llave con algún valor y funcionará. Pero eso anula el propósito de `defaultdict`.`deque`Según la documentación de Python, los deques "son una generalización de las pilas y colas (stacks y queues)". Se pronuncia "deck", que es la abreviatura de "double-ended queue". Son un contenedor de reemplazo para la lista de Python. Los deques son seguros para los hilos (threads) y permiten añadir y sacar datos de la memoria de forma eficiente desde cualquier lado del deque. Una lista está optimizada para operaciones rápidas de longitud fija. Puede obtener todos los detalles detalles en la documentación de Python. Un deque acepta un argumento `maxlen` que establece los límites para el deque. En caso contrario, el deque crecerá hasta un tamaño arbitrario. Cuando un deque acotado está lleno, cualquier nuevo elemento que se añada provocará que el mismo número de elementos salga del otro extremo.Como regla general, si necesitas añadir o sacar elementos rápidamente, utiliza un deque. Si necesitas un acceso aleatorio rápido usa una lista. Tomemos un momento para ver cómo se puede crear y utilizar un deque.from collections import deque
import string
d = deque(string.ascii_lowercase)
for letter in d:
print(letter)
>> a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
zAquí importamos el deque de nuestro módulo de colecciones y también importamos el módulo de strings. Para crear una instancia de un deque, necesitamos pasarle un iterable. En este caso, le pasamos `string.ascii_lowercase`, que devuelve una lista de todas las letras minúsculas del alfabeto. Finalmente, hacemos un bucle sobre nuestro deque e imprimimos cada elemento. Ahora veamos algunos de los métodos que posee deque.d.append('bye')
d
>> deque(['a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z',
'bye'])
d.appendleft('hello')
d
>> deque(['hello',
'a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z',
'bye'])
d.rotate(1)
d
>> deque(['bye',
'hello',
'a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z'])Vamos a desglosar esto un poco. Primero añadimos una cadena al extremo derecho del deque. Luego añadimos otra cadena al lado izquierdo del deque. Por último, llamamos a `rotate` en nuestro deque y le pasamos un uno, lo que hace que rote una vez a la derecha. En otras palabras, hace que un elemento gire desde el extremo derecho y en la parte delantera. Puedes pasarle un número negativo para que el deque rote hacia la izquierda en su lugar. Terminemos esta sección con un ejemplo basado en algo de la documentación de Pythonfrom collections import deque
def get_last(filename, n=5):
"""
Returns the last n lines from the file
"""
try:
with open(filename) as f:
return deque(f, n)
except OSError:
print("Error opening file: {}".format(filename))
raiseEste código funciona de forma muy parecida a como lo hace el programa tail de Linux. Aquí pasamos un `filename` a nuestro script junto con el número `n` de líneas que queremos que nos retorne. El deque está limitado a cualquier número que pasemos como `n`. Esto significa que una vez que el deque está lleno, cuando se leen nuevas líneas y se añaden al deque, las líneas más viejas son sacadas del otro extremo y descartadas. También he envuelto la apertura del archivo con un simple manejador de excepciones porque es muy fácil pasar una ruta malformada. Esto atrapará archivos que no existen.ConclusiónHemos cubierto mucho terreno en este post. Has aprendido a utilizar un defaultdict y un Count. También aprendimos sobre una subclase de la lista de Python, el deque. Por último, hemos visto cómo utilizarlas para realizar varias actividades. Espero que hayas encontrado cada una de estas colecciones interesantes. Pueden ser de gran utilidad para ti en tu dia a dia
Deployment
Libraries
Flask
Machine Learning
Creando Todo El Pipeline De Machine Learning Con PyCaret y Python
Este tutorial cubre todo el proceso de Machine Learning, desde la ingestión de datos, el preprocesamiento, el entrenamiento del modelo, el ajuste de hiperparámetros, la predicción y el almacenamiento del modelo para su uso posterior.Completaremos todos estos pasos en menos de 10 comandos de construcción natural y muy intuitivos de recordar, como por ejemplo:create_model(),
tune_model(),
compare_models()
plot_model()
evaluate_model()
predict_model()
