Skip to content

Instantly share code, notes, and snippets.

@RodolfoFerro

RodolfoFerro/introducci-n-a-polars.ipynb

Created August 17, 2023 21:16
Show Gist options
  • Save RodolfoFerro/0bf26c2a3b7c052e31cff83474b6458e to your computer and use it in GitHub Desktop.
Save RodolfoFerro/0bf26c2a3b7c052e31cff83474b6458e to your computer and use it in GitHub Desktop.
Download ZIP
Introducción a Polars
Display the source blob
Display the rendered blob
Raw
introducci-n-a-polars.ipynb
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"private_outputs": true,
"provenance": [],
"toc_visible": true,
"authorship_tag": "ABX9TyNSZtdl7CEVFkWmuBr6NLAX",
"include_colab_link": true
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"<a href=\"https://colab.research.google.com/gist/RodolfoFerro/0bf26c2a3b7c052e31cff83474b6458e/introducci-n-a-polars.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
]
},
{
"cell_type": "markdown",
"source": [
"# Introducción a Polars 🐻‍❄️\n",
"\n",
"> **Descripción:** Cuaderno de contenidos sobre introducción a Polars para el Bootcamp de Ciencia de Datos en Código Facilito, 2023. <br>\n",
"> **Autor:** [Rodolfo Ferro](https://github.com/RodolfoFerro) <br>\n",
"> **Contacto:** [Twitter](https://twitter.com/rodo_ferro) / [Instagram](https://www.instagram.com/rodo_ferro/)\n",
"\n",
"\n",
"## Contenido\n",
"\n",
"### **Sección I**\n",
"- ¿Qué es Polars?\n",
"- Polars vs. Pandas\n",
"- El crecimiento de Polars\n",
"\n",
"### **Sección II**\n",
"- Tipos y estructuras de datos\n",
"- Contextos y expresiones\n",
"- Lazy / Eager API\n",
"\n",
"### **Sección III – Ejercicios**\n",
"- Ejemplos con expresiones y transformaciones\n",
"- SQL context\n",
"- Ejercicios de tarea\n"
],
"metadata": {
"id": "FQknCGesuK91"
}
},
{
"cell_type": "markdown",
"metadata": {
"id": "xNVG2PnSEtQN"
},
"source": [
"## **Sección I**\n",
"\n",
"Para más detalles, te recomiendo revisar la presentación que puedes encontrar [aquí](https://rodolfoferro.xyz/polars-facilito/)."
]
},
{
"cell_type": "markdown",
"source": [
"### **¿Qué es Polars?**\n",
"\n",
"<center>\n",
" <img src=\"https://raw.githubusercontent.com/pola-rs/polars-static/master/logos/polars_github_logo_rect_dark_name.svg\" width=\"70%\">\n",
"</center>\n",
"\n",
"**Polars** es una _**DataFrame** library_ de código abierto y de alto rendimiento para manipular datos estructurados. Su core está escrito en Rust, pero la biblioteca está disponible en Python, Rust y NodeJS."
],
"metadata": {
"id": "BKK_WJFdurLB"
}
},
{
"cell_type": "markdown",
"source": [
"### **Polars vs Pandas**\n",
"\n",
"Si bien, **Pandas** es una de las bibliotecas más utilizadas para trabajar con datos, una ventaja de **Polars**, al estar hecho con un lenguaje compilado, es que le permite tener un alto rendimiento para manipular datos estructurados.\n",
"\n",
"Hay un benchmark realizado por el equipo de Polars, el cual puedes revisar aquí: https://www.pola.rs/benchmarks.html\n",
"\n",
"En el link anterior podrás encontrar gráficos como estos:\n",
"\n",
"<center>\n",
" <img src=\"https://raw.githubusercontent.com/pola-rs/polars-static/master/benchmarks/tpch/sf_10_and_io.png\" width=\"70%\">\n",
" <img src=\"https://raw.githubusercontent.com/pola-rs/polars-static/master/benchmarks/tpch/sf_10.png\" width=\"70%\">\n",
"</center>\n",
"\n",
"Estos gráficos muestran resultados de pruebas de rendimiento al trabajar Polars y en contraste con otras herremientas (en elleas incluido Pandas). Dichos benchmarks son básicamente pruebas de memoria y carga de datos.\n",
"\n",
"Puedes obtener más detalles de dicho benchmark en el link ya meniconado."
],
"metadata": {
"id": "1VBY5EtDu2uF"
}
},
{
"cell_type": "markdown",
"metadata": {
"id": "nKOUbHduvTzC"
},
"source": [
"## **Sección II**\n",
"\n",
"Comenzamos con la instalación de `polars`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "m7PxZrxvtzsZ"
},
"outputs": [],
"source": [
"!pip install polars"
]
},
{
"cell_type": "markdown",
"source": [
"### **Tipos y estructuras de datos**\n",
"\n",
"En esta sección, exploraremos en detalle los tipos y estructuras de datos que Polars ofrece como alternativa a Pandas. Una comprensión sólida de estos elementos es esencial para aprovechar al máximo las capacidades de Polars y tomar decisiones informadas sobre cuándo y cómo usar esta librería en lugar de otras opciones como Pandas.\n",
"\n",
"Todos los tipos y las estructuras de datos están basadas en `Arrow`, una implementación completa, segura y nativa de Rust de [_Apache Arrow_](https://arrow.apache.org/), que es una plataforma de desarrollo multilenguaje para datos en memoria."
],
"metadata": {
"id": "d8pg5CFkwdzY"
}
},
{
"cell_type": "markdown",
"source": [
"#### Tipos de Datos en Polars\n",
"\n",
"\n",
"\n",
"Polars introduce una gama de tipos de datos optimizados que permiten un mejor rendimiento y uso eficiente de la memoria en comparación con Pandas. Algunos de los tipos de datos clave en Polars incluyen:\n",
"\n",
"- **Integer:** Polars ofrece varios tipos de enteros con diferentes tamaños, como `Int8`, `Int16`, `Int32` y `Int64`. Asimismo, números enteros sin signo, como `UInt8`, `UInt16`, `UInt32` y `UInt64`. Estos tipos permiten un control más preciso sobre la cantidad de memoria utilizada.\n",
"\n",
"- **Floating-Point:** Al igual que Pandas, Polars ofrece tipos de punto flotante como `Float32` y `Float64` para manejar números decimales con diferentes niveles de precisión.\n",
"\n",
"- **Boolean:** Polars utiliza el tipo `Boolean` para representar valores booleanos (verdadero/falso) de manera eficiente.\n",
"\n",
"- **Temporal:** Polars proporciona tipos de datos para manejar fechas y horas, como `Date` y `Datetime`, lo que facilita el trabajo con datos temporales."
],
"metadata": {
"id": "OgM2-u0fxD9u"
}
},
{
"cell_type": "markdown",
"source": [
"#### Estructuras de Datos en Polars\n",
"\n",
"Polars introduce dos estructuras de datos principales: `DataFrame` y `Series`, que son equivalentes a las estructuras homónimas en Pandas:\n",
"\n",
"- **DataFrame:** El equivalente a un DataFrame en Polars es una estructura tabular que organiza los datos en filas y columnas. Polars ofrece una forma de crear y manipular DataFrames, lo que permite realizar operaciones complejas de manera eficiente.\n",
"\n",
"- **Series:** Las Series son equivalentes a columnas en un DataFrame. Pueden contener un solo tipo de dato y se utilizan para realizar operaciones vectorizadas en los datos.\n",
"\n",
"> **Nota:** Polars introduce los LazyFrames. Esencialmente, un `LazyFrame` es una forma más eficiente de trabajar con un conjunto de datos que usar DataFrame. Si reemplazas tu DataFrame con LazyFrame en tu código con Polars, puedes obtener un tiempo de ejecución más rápido."
],
"metadata": {
"id": "EgK3qfl_yfkU"
}
},
{
"cell_type": "code",
"source": [
"import polars as pl\n",
"\n",
"s = pl.Series(\"a\", [1, 2, 3, 4, 5])\n",
"print(s)"
],
"metadata": {
"id": "fcL8SyQA4dja"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"from datetime import datetime\n",
"\n",
"df = pl.DataFrame(\n",
" {\n",
" \"integer\": [1, 2, 3, 4, 5],\n",
" \"date\": [\n",
" datetime(2022, 1, 1),\n",
" datetime(2022, 1, 2),\n",
" datetime(2022, 1, 3),\n",
" datetime(2022, 1, 4),\n",
" datetime(2022, 1, 5),\n",
" ],\n",
" \"float\": [4.0, 5.0, 6.0, 7.0, 8.0],\n",
" }\n",
")\n",
"\n",
"print(df)"
],
"metadata": {
"id": "9Cmy3lnowddo"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"### **Contextos y expresiones**\n",
"\n",
"Polars ha desarrollado su propio lenguaje específico de dominio (DSL) para transformar datos. El lenguaje es muy fácil de usar y permite consultas complejas que siguen siendo legibles por humanos. Los dos componentes centrales del lenguaje son \"Contextos\" y \"Expresiones\"."
],
"metadata": {
"id": "Dzc0hdAV4-sr"
}
},
{
"cell_type": "markdown",
"source": [
"#### Contextos\n",
"\n",
"Un contexto, como lo implica el nombre, se refiere al contexto en el que se debe evaluar una expresión. Hay tres contextos principales:\n",
"\n",
"- Selección: `df.select([..])`, `df.with_columns([..])`\n",
"- Filtrado: `df.filter()`\n",
"- Agrupaciones y agregaciones: `df.groupby(..).agg([..])`\n",
"\n",
"Revisemos algunos ejemplos.\n"
],
"metadata": {
"id": "2j3OShyO5GhF"
}
},
{
"cell_type": "markdown",
"source": [
"Comenzemos creando un nuevo dataframe con algo de información."
],
"metadata": {
"id": "xhUMLd6q6Z-s"
}
},
{
"cell_type": "code",
"source": [
"import numpy as np\n",
"\n",
"# Creamos un dataframe para trabajar con él\n",
"df = pl.DataFrame(\n",
" {\n",
" \"nid\": [1, 2, 3, None, 5],\n",
" \"names\": [\"Rodo\", \"Hiram\", \"Josué\", \"David\", None],\n",
" \"random\": np.random.rand(5),\n",
" \"groups\": [\"A\", \"A\", \"C\", \"B\", \"B\"],\n",
" }\n",
")\n",
"print(df)"
],
"metadata": {
"id": "FFHD9m495bmb"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"##### Contexto `select`\n",
"\n",
"En este contexto, la selección aplica expresiones sobre columnas. Las expresiones en este contexto deben producir series que tengan la misma longitud o una longitud de 1.\n",
"\n",
"Una selección puede producir nuevas columnas que son agregaciones, combinaciones de expresiones o literales."
],
"metadata": {
"id": "wGwkN76w60qw"
}
},
{
"cell_type": "code",
"source": [
"out = df.select(\n",
" pl.sum(\"nid\"),\n",
" #pl.col(\"names\").sort(),\n",
" #pl.col(\"names\").first().alias(\"first name\"),\n",
" #(pl.mean(\"nid\") * 10).alias(\"10xnid\"),\n",
")\n",
"print(out)"
],
"metadata": {
"id": "aHreLwpx5nzW"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"El contexto de selección es muy poderoso y nos permite realizar expresiones arbitrarias independientes (y en paralelo) entre sí.\n",
"\n",
"De manera similar a `select`, existe la sentencia `with_columns` que también es una entrada al contexto de selección. La principal diferencia es que `with_columns` conserva las columnas originales y agrega otras nuevas, mientras que `select` elimina las columnas originales."
],
"metadata": {
"id": "ZX9oQzVh7OBI"
}
},
{
"cell_type": "code",
"source": [
"df = df.with_columns(\n",
" pl.sum(\"nid\").alias(\"nid_sum\"),\n",
" #pl.col(\"random\").count().alias(\"count\"),\n",
")\n",
"print(df)"
],
"metadata": {
"id": "B6ZS4ASD6-Ks"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"##### Contexto `filter`\n",
"\n",
"En este contexto, se filtra el marco de datos existente en función de la expresión arbitraria que se evalúa como el tipo de datos booleano."
],
"metadata": {
"id": "ke7EnCCa66De"
}
},
{
"cell_type": "code",
"source": [
"out = df.filter(pl.col(\"random\") > 0.5)\n",
"print(out)"
],
"metadata": {
"id": "rAmLwda88BTz"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"##### Contexto `groupby` / `aggregation`\n",
"\n",
"En este contexto, las expresiones funcionan en grupos, por lo que pueden producir resultados de cualquier longitud (un grupo puede tener muchos miembros)."
],
"metadata": {
"id": "wJzJSoUB8Lyz"
}
},
{
"cell_type": "code",
"source": [
"out = df.groupby(\"groups\").agg(\n",
" pl.sum(\"nid\"), # Suma los nid por groupos\n",
" #pl.col(\"random\").count().alias(\"count\"), # Cuenta miembros de grupo\n",
" # Suma random cuando name != null\n",
" #pl.col(\"random\").filter(pl.col(\"names\").is_not_null()).sum().suffix(\"_sum\"),\n",
" #pl.col(\"names\").reverse().alias(\"reversed names\"),\n",
")\n",
"print(out)\n"
],
"metadata": {
"id": "GA4jxg2T8eKx"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"#### Expresiones\n",
"\n",
"Polars cuenta con expresiones. Las expresiones son el núcleo de muchas operaciones de ciencia de datos y son el concepto fundamental de Polars para su rendimiento muy rápido.\n",
"\n",
"Algunas de estas operaciones importantes en la ciencia de datos son:\n",
"\n",
"- tomar una muestra de filas de una columna\n",
"- multiplicar valores en una columna\n",
"- extraer una columna de años a partir de fechas\n",
"- convertir una columna de cadenas a minúsculas\n",
"- ¡y más!\n",
"\n",
"Sin embargo, las expresiones también se utilizan dentro de otras operaciones:\n",
"\n",
"- tomar la media de un grupo en una operación `groupby`\n",
"- calcular el tamaño de los grupos en una operación `groupby`\n",
"- tomando la suma horizontalmente a través de las columnas\n",
"\n",
"Polars realiza estas transformaciones de datos centrales muy rápidamente con:\n",
"\n",
"- optimización automática de consultas en cada expresión\n",
"- paralelización automática de expresiones en muchas columnas\n",
"\n",
"**Analicemos.** ¿Qué hace la siguiente sentencia?"
],
"metadata": {
"id": "vAO33O5o9vAk"
}
},
{
"cell_type": "code",
"source": [
"out = (pl.col(\"random\").sort() > 0.5).suffix(\"_condition\")\n",
"print(out)"
],
"metadata": {
"id": "0d68GFWm-dDS"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Notemos que al ejecutar no obtenemos un resultado, esto es porque es necesario ejecutar estas sentencias dentro de un contexto. **Veamos.**"
],
"metadata": {
"id": "ZSMeAj0K-9An"
}
},
{
"cell_type": "code",
"source": [
"out = df.select((pl.col(\"random\").sort() > 0.5).suffix(\"_condition\"))\n",
"print(out)"
],
"metadata": {
"id": "FsOcx4Ee_0Yo"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"out = df.with_columns((pl.col(\"random\").sort() > 0.5).suffix(\"_condition\"))\n",
"print(out)"
],
"metadata": {
"id": "HOf5epFC_C5q"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"**Observación:** ¿Por qué si ejecutamos un sort, los datos no están ordenados?"
],
"metadata": {
"id": "GlhsHRAVAQgo"
}
},
{
"cell_type": "markdown",
"source": [
"### **Operaciones \"Lazy\" y \"Eager\"**\n",
"\n",
"Una característica única de Polars es su enfoque en las operaciones \"Lazy\" y \"Eager\". Las operaciones \"Lazy\" permiten construir una secuencia de operaciones en un DataFrame sin ejecutarlas de inmediato. Esto puede ser útil para optimizar el rendimiento y evitar cálculos innecesarios. Por otro lado, las operaciones \"Eager\" ejecutan inmediatamente las operaciones en el DataFrame y devuelven los resultados.\n",
"\n",
"**Analicemos.** ¿Qué sucede en el siguiente ejemplo?"
],
"metadata": {
"id": "Uz7UQe0F4pna"
}
},
{
"cell_type": "code",
"source": [
"%time\n",
"df = pl.read_csv(\"https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv\")\n",
"df_small = df.filter(pl.col(\"sepal_length\") > 5)\n",
"df_agg = df_small.groupby(\"species\").agg(pl.col(\"sepal_width\").mean())\n",
"print(df_agg)"
],
"metadata": {
"id": "mTnbPhzw4wjQ"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"En este ejemplo, usamos la API \"Eager\" para:\n",
"\n",
"- Leer el conjunto de datos del iris.\n",
"- Filtrar el conjunto de datos según la longitud del sépalo\n",
"- Calcular la media del ancho del sépalo por especie\n",
"\n",
"Cada paso se ejecuta inmediatamente devolviendo los resultados intermedios. Esto puede ser un fallo a la eficiencia, ya que podríamos trabajar o cargar datos adicionales que no se están utilizando."
],
"metadata": {
"id": "vMvlXTCIBE0A"
}
},
{
"cell_type": "code",
"source": [
"!wget https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
],
"metadata": {
"id": "smoExF38BoSA"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"%time\n",
"q = (\n",
" pl.scan_csv(\"iris.csv\")\n",
" #.filter(pl.col(\"sepal_length\") > 5)\n",
" #.groupby(\"species\")\n",
" #.agg(pl.col(\"sepal_width\").mean())\n",
")\n",
"\n",
"df = q.collect()"
],
"metadata": {
"id": "lWOrXZoyBBeM"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"print(df)"
],
"metadata": {
"id": "pu-fXyS3Br36"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "--NiTEC3CwrU"
},
"source": [
"## **Sección III**\n",
"\n",
"Estaremos poniendo en práctica lo aprendido con algunos ejercicios de [101 Pandas Exercises for Data Analysis](https://www.machinelearningplus.com/python/101-pandas-exercises-python/)."
]
},
{
"cell_type": "markdown",
"source": [
"### **Ejemplos con expresiones y transformaciones**"
],
"metadata": {
"id": "rNcBnJ1kC8UW"
}
},
{
"cell_type": "markdown",
"source": [
"#### 4. ¿Cómo combinar múltiples dfs en un DataFrame?"
],
"metadata": {
"id": "rcQ6tv6xPDot"
}
},
{
"cell_type": "code",
"source": [
"# 4. ¿Cómo combinar múltiples dfs en un DataFrame?\n",
"df1 = pl.DataFrame({\"letras\": list(\"abcedfghijklmnopqrstuvwxyz\")})\n",
"df2 = pl.DataFrame({\"nums\": np.arange(len(df1))})\n",
"\n",
"print(df1, df2)"
],
"metadata": {
"id": "il7rfC2lC-SO"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"### Solución\n"
],
"metadata": {
"id": "9QpTxpkZGDbx"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"#### 14. ¿Cómo extraer items de un DataFrame dadas las posiciones a través de enteros?"
],
"metadata": {
"id": "vAuCiAKBPqah"
}
},
{
"cell_type": "code",
"source": [
"# 14. ¿Cómo extraer items de un DataFrame dadas las posiciones a través de enteros?\n",
"df = pl.DataFrame(list('abcdefghijklmnopqrstuvwxyz'))\n",
"pos = [0, 4, 8, 14, 20]\n",
"\n",
"print(df)"
],
"metadata": {
"id": "_61CU5qDP2Bs"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"### Solución\n"
],
"metadata": {
"id": "d7BjnoRUP_48"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"#### 19. ¿Cómo calcular el número de caracteres de cada palabra en un DataFrame?"
],
"metadata": {
"id": "nLHfSqbdPGOJ"
}
},
{
"cell_type": "code",
"source": [
"# 19. ¿Cómo calcular el número de caracteres de cada palabra en un DataFrame?\n",
"df = pl.DataFrame({\"palabras\": [\"esta\", \"es\", \"una\", \"palabra\"]})\n",
"print(df)"
],
"metadata": {
"id": "DtY52y06EXHQ"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"### Solución\n"
],
"metadata": {
"id": "pX9uPtnfGtXF"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"#### 23. ¿Cómo convertir una cadena año-mes a fechas que comiencen en el 11 de cada mes?"
],
"metadata": {
"id": "8OesttF2ReGl"
}
},
{
"cell_type": "code",
"source": [
"# 23. ¿Cómo convertir una cadena año-mes a fechas que comiencen en el 11 de cada mes?\n",
"df = pl.DataFrame(['Jan 2010', 'Feb 2011', 'Mar 2012'])\n",
"print(df)"
],
"metadata": {
"id": "aYeBcJP1Ro0a"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"### Solución\n",
"from dateutil.parser import parse\n"
],
"metadata": {
"id": "MxI5e49QRyFY"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"#### 40. ¿Cómo revisar si un DataFrame tiene valores faltantes?"
],
"metadata": {
"id": "Ekm_Y4IbPJ88"
}
},
{
"cell_type": "code",
"source": [
"# 40. ¿Cómo revisar si un DataFrame tiene valores faltantes?\n",
"df = pl.read_csv(\"https://raw.githubusercontent.com/selva86/datasets/master/Cars93_miss.csv\")\n",
"print(df.head(5))"
],
"metadata": {
"id": "0yLzlOn3JYCb"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"### Solución\n",
"print(df.columns)\n"
],
"metadata": {
"id": "1FkZZsE-KaZf"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"#### 49. ¿Cómo filtrar cada n-ésima fila en un DataFrame?"
],
"metadata": {
"id": "6Cc2BDuFPLsc"
}
},
{
"cell_type": "code",
"source": [
"# 49. ¿Cómo filtrar cada n-ésima fila en un DataFrame?\n",
"df = pl.read_csv(\"https://raw.githubusercontent.com/selva86/datasets/master/Cars93_miss.csv\")\n",
"print(df.head(8))"
],
"metadata": {
"id": "EB5eludRN8-a"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"### Solución\n"
],
"metadata": {
"id": "VGG2FyD8OFzz"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"### **SQL context**\n",
"\n",
"Aunque Polars admite la escritura de consultas en SQL, se recomienda que las y los usuarios se familiaricen con la sintaxis nativa para obtener un código más legible y expresivo.\n",
"\n",
"Sin embargo, si ya cuentas con una base de código SQL existente o prefieres usar SQL, Polars también te ofrece soporte para consultas SQL.\n",
"\n",
"Polars utiliza el `SQLContext` para administrar consultas SQL. El contexto contiene un diccionario que asigna nombres de DataFrames y LazyFrames a sus correspondientes conjuntos de datos."
],
"metadata": {
"id": "XWBwC4prSgs9"
}
},
{
"cell_type": "code",
"source": [
"# For local files use scan_csv instead\n",
"pokemon = pl.read_csv(\n",
" \"https://gist.githubusercontent.com/ritchie46/cac6b337ea52281aa23c049250a4ff03/raw/89a957ff3919d90e6ef2d34235e6bf22304f3366/pokemon.csv\"\n",
")\n",
"\n",
"ctx = pl.SQLContext(register_globals=True, eager_execution=True)\n",
"df_small = ctx.execute(\"SELECT * from pokemon LIMIT 5\")\n",
"print(df_small)"
],
"metadata": {
"id": "dwQu8WbpTIXY"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"> **Para resolver la tarea, el reto es:** Poner en práctica los conocimientos adquiridos a través de ejercicios y retos.\n",
"\n",
"**Puedes explorar:**\n",
"- [Polars API Reference](https://pola-rs.github.io/polars/py-polars/html/reference/index.html)\n",
"- [101 Pandas Exercises for Data Analysis](https://www.machinelearningplus.com/python/101-pandas-exercises-python/)"
],
"metadata": {
"id": "QKp_PZ_NDqbS"
}
},
{
"cell_type": "markdown",
"source": [
"--------\n",
"\n",
"> Contenido creado por **Rodolfo Ferro**, 2023. <br>\n",
"> Puedes contactarme a través de Insta ([@rodo_ferro](https://www.instagram.com/rodo_ferro/)) o Twitter ([@rodo_ferro](https://twitter.com/rodo_ferro))."
],
"metadata": {
"id": "hSdbQU3e6-Ky"
}
}
]
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment