Cómo practicar SQL y Python juntos con problemas realistas

Inicio » Python » Cómo practicar SQL y Python juntos con problemas realistas

Si estás intentando retomar SQL y Python después de unos años de ausencia, es completamente normal sentirse perdido. —sobre todo si en tu último trabajo usaste herramientas propietarias y cómodos cuadernos de Databricks que ya no tienes. Las ofertas de trabajo modernas que exigen Python, SQL e incluso PySpark pueden parecer intimidantes cuando cada guía empieza con algo como «carga tu conjunto de datos de reclamaciones en tu almacén de datos» y piensas: «Eso es precisamente lo que no tengo».

La buena noticia es que puedes recrear la mayor parte de esa experiencia de aprendizaje en tu propio ordenador portátil. Utilizando herramientas gratuitas, pequeños conjuntos de datos de muestra y un conjunto estructurado de problemas prácticos, en esta guía explicaremos, en lenguaje sencillo, cómo crear un entorno local realista, cómo funciona SQL (desde consultas básicas hasta JOINs y agregaciones) y cómo integrar esas consultas SQL en Python para que puedas practicar exactamente el tipo de tareas que encontrarás en los trabajos de análisis de datos actuales.

Creación de un entorno de práctica local sencillo con SQLite y Python.

No necesitas un almacén de datos completo ni un clúster de Spark para practicar SQL y Python.Para el aprendizaje y la preparación de entrevistas, una base de datos integrada ligera como SQLite es más que suficiente. SQLite almacena todos sus datos en un único archivo en el disco, lo que la hace perfecta para proyectos sencillos, prototipos y ejercicios educativos.

Conceptualmente, una base de datos SQLite se parece mucho a una hoja de cálculo con varias hojas.: cada hoja es una mesa, cada fila es una grabary cada columna es una campoEn la jerga de las bases de datos relacionales, a veces se denomina a las tablas "relaciones", a las filas "tuplas" y a las columnas "atributos", pero para el trabajo práctico se pueden utilizar sin problema los términos cotidianos tabla, fila y columna.

Python incluye un controlador SQLite integrado llamado sqlite3., lo que significa que no necesita instalar un servidor de base de datos separado. Su script de Python abrirá una conexión a un .sqlite archivo (creándolo si no existe), obtener un cursor objeto (muy similar a un manejador de archivos) y luego enviar comandos SQL a través de ese cursor usando execute(). Vea nuestra SQLite SELECT y WHERE Guía con ejemplos prácticos de lectura y filtrado de datos.

Si bien este artículo se centra en cómo controlar SQLite desde Python, también existe una práctica herramienta con interfaz gráfica de usuario llamada "Database Browser for SQLite". (A veces se distribuye como DB Browser para SQLite). Con él puedes inspeccionar visualmente las tablas, insertar o editar algunas filas manualmente y ejecutar sentencias SQL sencillas. Es como un editor de texto para archivos de base de datos: los ajustes manuales rápidos son más fáciles en la interfaz gráfica, pero cualquier tarea repetitiva o compleja se realiza mejor mediante scripts de Python.

Las bases de datos relacionales son más rígidas que las listas o diccionarios de Python: insisten en un esquema definido.Al crear una tabla, debe declarar los nombres de las columnas y los tipos de datos que espera (texto, entero, fecha/hora, etc.). SQLite almacenará e indexará los datos de forma que las búsquedas sean eficientes, incluso cuando el conjunto de datos crezca más allá de lo que cabe cómodamente en la memoria. Para obtener rutas de aprendizaje prácticas y ejemplos prácticos, consulte análisis de datos con SQL.

Creación de tablas e inserción de datos con SQL y Python.

Para empezar a practicar, primero necesitas una tabla; piénsalo como si estuvieras diseñando la forma de tus datos.. Supongamos que quieres una pequeña tabla de biblioteca musical. Usando Python sqlite3 Este módulo permite conectarse a un archivo de base de datos, eliminar cualquier versión antigua de la tabla, si existe, y luego crear una nueva tabla con columnas claramente tipificadas.

Así es como se ve ese flujo conceptualmente en Python.: tú llamas sqlite3.connect('music.sqlite') para abrir o crear el archivo de base de datos, luego llame conn.cursor() para obtener un cursor. A través de ese cursor puedes ejecutar comandos SQL como DROP TABLE IF EXISTS Songs para borrar cualquier esquema anterior, seguido de CREATE TABLE Songs (title TEXT, plays INTEGER) para definir una nueva tabla con dos columnas.

Una vez que la tabla existe, cambia de DDL (Lenguaje de Definición de Datos) a DML (Lenguaje de Manipulación de Datos) con INSERT declaracionesEn Python siempre debes usar consultas parametrizadas: escribe INSERT INTO Songs (title, plays) VALUES (?, ?) y pasar una tupla como ('Thunderstruck', 20) como el segundo argumento a execute()Los signos de interrogación son marcadores de posición que Python sustituirá de forma segura, lo que le ayudará a evitar problemas de inyección SQL y errores de comillas.

Después de realizar inserciones o actualizaciones, debe llamar conn.commit() para guardar los cambios en el discoHasta que no se confirme la transacción, las operaciones solo existen en un búfer de transacciones. Esto es diferente de las simples escrituras de archivos, y es uno de los hábitos clave que se deben inculcar desde el principio: consultar, modificar y luego confirmar.

Para leer sus datos, utilice un SELECT instrucción e iterar sobre el cursor. Por ejemplo, SELECT title, plays FROM Songs transmitirá cada fila como una tupla de Python, como por ejemplo: ('Thunderstruck', 20)El cursor no carga todos los resultados a la vez; en su lugar, obtiene las filas de forma diferida, lo cual resulta útil cuando se trabaja con conjuntos de datos más grandes.

Elementos básicos de las consultas SQL y filtrado con WHERE

Cada consulta SQL se basa en un pequeño conjunto de cláusulas que aparecen en un orden estándar.: SELECT, FROM, WHERE, GROUP BY, HAVING, y ORDER BY. Como mínimo, debes especificar qué columnas deseas (SELECT) y de qué tabla (FROM). Las cláusulas opcionales luego refinan, agregan, filtran los resultados agregados y ordenan la salida.

El WHERE La cláusula filtra las filas antes de que se realice cualquier agrupación o agregación.Para columnas numéricas puede utilizar operadores de comparación como =, != (o <>), >, <, >=, <=Las columnas de texto admiten estas funciones, además de la coincidencia de patrones mediante LIKE y comprobaciones de membresía a través de INLos valores de fecha/hora admiten las mismas comparaciones relacionales, y a menudo se ven rangos expresados ​​con BETWEEN.

El manejo de valores nulos en SQL es lo suficientemente peculiar como para merecer una atención explícita.. Comparaciones regulares como = y != no se comporten como cabría esperar con NULL, por lo que SQL proporciona IS NULL y IS NOT NULL para comprobar si faltan valores. Las columnas booleanas suelen funcionar con = y !=pero aún necesitas IS NULL cuando el propio valor booleano puede faltar.

Cuando combines varias condiciones, recuerda que AND y OR seguir las reglas de precedenciaSi escribes age < 5 OR age > 10 AND breed = 'Ragdoll', SQL evaluará el AND Primero, para expresar “gatos Ragdoll menores de 5 años o mayores de 10”, debe usar paréntesis: (age < 5 OR age > 10) AND breed = 'Ragdoll'Familiarizarse con estas combinaciones lógicas es crucial para el trabajo analítico en el mundo real.

Coincidencia de patrones con LIKE te permite buscar cadenas que comiencen, terminen o contengan ciertos fragmentos.El signo de porcentaje % es un comodín para cualquier secuencia de caracteres, por lo que breed LIKE 'R%' encuentra razas que empiezan con “R”, fav_toy LIKE 'ball%' encuentra juguetes cuyos nombres comienzan con “pelota”, y coloration LIKE '%m' encuentra patrones de color que terminan en “m”. Combinado con AND/OREsto se convierte en un potente conjunto de herramientas para el filtrado de texto.

Practicando consultas de una sola tabla con un conjunto de datos de ejemplo.

Una forma útil de desarrollar la memoria muscular es fijar un pequeño esquema en tu cabeza y resolver muchas consultas sobre él.. Imagina un cat tabla con columnas como id, name, breed, coloration, age, sex, y fav_toyEsto te proporciona suficiente variedad (texto, números, categorías simples) para practicar la mayoría de los patrones de consulta básicos.

Para las comprobaciones de tipo booleano, normalmente se filtra por una columna y luego se añaden condiciones adicionales.Para enumerar los gatos machos “aburridos” que no tienen registrado ningún juguete favorito, seleccionarías el name dónde sex = 'M' y fav_toy IS NULLEsto ilustra cómo las comprobaciones de valores nulos se combinan con comparaciones sencillas para aislar un subconjunto específico de filas.

Para seleccionar razas específicas o excluirlas, se combina la igualdad con la negación lógica.. Seleccionar solo gatos Ragdoll de ciertas edades utiliza breed = 'Ragdoll'; excluyendo a los persas y siameses, podrían verse como breed NOT LIKE 'Persian' AND breed NOT LIKE 'Siamese'Si bien algunas bases de datos admiten NOT IN ('Persian', 'Siamese'), practicar el patrón explícito ayuda a consolidar tu comprensión de NOT y LIKE.

Ejercicios como “gatas que adoran los juguetes de estimulación y no son persas ni siamesas” te obligan a combinar filtros de texto, igualdad y operadores lógicos.. Seleccionarías id, name, breed, coloration y restringir las filas usando sex = 'F', fav_toy = 'teaser'y una condición compuesta que excluye las razas no deseadas. Prestar atención a los paréntesis garantiza que todas las subcondiciones se apliquen en la combinación prevista.

Una vez que te sientas cómodo con estos ejemplos sencillos en SQL puro, vuelve a implementarlos mediante Python utilizando consultas parametrizadas.. Escribe guiones cortos que pidan raza, edad mínima o tipo de juguete de input(), conéctalos a WHERE cláusulas, e imprimir los resultados. Este es precisamente el puente entre la escritura de consultas y el código de aplicación real que muchos puestos de datos junior esperan.

Comprender y practicar las uniones SQL (JOIN)

En cuanto superes los problemas con los juguetes, te unirás a varias mesas constantemente.Las operaciones JOIN se utilizan para conectar conjuntos de datos relacionados: clientes con pedidos, artistas con obras de arte, juegos con empresas, etc. En SQL, se especifica qué columnas deben coincidir entre las tablas, y el motor de la base de datos combina las filas en un conjunto de resultados combinado.

Existen cuatro tipos principales de incorporación que encontrarás en entrevistas y proyectos reales.: INNER JOIN (a menudo escrito simplemente JOIN), LEFT JOIN, RIGHT JOIN, y FULL OUTER JOINUna unión interna devuelve solo las filas donde ambas tablas tienen claves coincidentes; una unión izquierda conserva todas las filas de la tabla izquierda, completando NULLs cuando la tabla derecha no tiene coincidencia; una unión derecha hace lo simétrico; y una unión externa completa devuelve todas las filas de ambos lados, haciendo coincidir donde sea posible y usando NULL donde no.

Piensa en LEFT JOIN y RIGHT JOIN como operaciones de “confía más en este lado”En una unión izquierda, la tabla izquierda es la fuente principal de información: cada fila de esta tabla aparece al menos una vez en el resultado, incluso cuando la tabla derecha no aporta nada. En una unión completa, ninguna de las tablas tiene privilegios; simplemente se unen todas las claves de ambas tablas y se alinean donde se superponen.

Para que las consultas de varias tablas sean legibles, siempre asigne alias a sus tablas.En lugar de escribir SELECT artist.name repetidamente, escribe FROM artist AS a y luego haga referencia a las columnas como a.name. Similar, piece_of_art puede llegar a ser poa, y museum puede ser mCuando tu consulta llega a tener tres o más uniones, usar buenos alias marca la diferencia entre la claridad y el caos.

Una configuración de entrenamiento clásica utiliza un trío de mesas: artist, museum, y piece_of_art. La función de artist la mesa podría contener id, name, birth_year, death_year y un campo principal como la acuarela o la escultura. museum tiendas de mesa id, name y country. La función de piece_of_art la mesa contiene id, name, artist_id y museum_idEsas dos últimas columnas son claves foráneas que vinculan cada obra de arte con su creador y ubicación.

Con ese esquema, puedes practicar uniones internas, uniones izquierdas y filtros condicionales.Por ejemplo, para enumerar a los artistas nacidos después de 1800 que vivieron más de 50 años, junto con los nombres de sus obras, se uniría artist y piece_of_art on artist.id = piece_of_art.artist_id y luego filtrar con death_year - birth_year > 50 y birth_year > 1800. Asigne un alias a las columnas seleccionadas como artist_name y piece_name para mayor claridad.

Para ver todas las obras de arte junto con los nombres de los museos y los países, incluidas las piezas "perdidas" sin museo. – usarías un LEFT JOIN desde piece_of_art a museum on museum_idDe esa forma, las obras de arte sin un museo asociado siguen apareciendo en el resultado, con NULL en las columnas del museo. Filtrar filas donde artist_id IS NULL Te permite descubrir obras de artistas desconocidos sin dejar de estar conectado con los museos que las albergan.

Los ejercicios más avanzados te piden que unas tres mesas simultáneamente.Para listar cada obra de arte con su artista y el nombre del museo, te unirías museum a piece_of_art on museum.id = piece_of_art.museum_id, luego únase artist on artist.id = piece_of_art.artist_id. Usando simple JOIN La unión interna (inner join) descarta intencionadamente las obras de arte que carecen de artista o museo, lo que permite comprender cómo el tipo de unión influye en el número de filas.

Agregación, GROUP BY y HAVING en la práctica

Una vez que puedas recuperar y combinar datos, la siguiente gran habilidad es resumirlos.. Funciones de agregación como SUM(), AVG(), COUNT(), MAX(), y MIN() Calcular métricas sobre conjuntos de filas. GROUP BY divide tu conjunto de datos en grupos y aplica esas funciones dentro de cada grupo; por ejemplo, un grupo por año, por empresa o por artista. Si prefieres cursos estructurados para practicar estos conceptos, consulta un Curso completo de SQL.

Imagina un sencillo sales_table con columnas year, month, y sales. Una llanura SELECT SUM(sales) AS total_sales FROM sales_table te da el total general de todas las filas. Sumando GROUP BY year Esto cambia la pregunta: ahora se pide el total de ventas anuales en lugar de una cifra global única.

La regla clave es que cada columna no agregada en su SELECT debe aparecer en GROUP BY. Si selecciona year y SUM(sales), usted agrupa por year. Si selecciona year y month junto con agregados, luego se agrupa por ambos year y monthConceptualmente, las distintas combinaciones de las columnas agrupadas definen los grupos.

WHERE y HAVING Ambos son filtros, pero actúan en diferentes etapas.. WHERE Filtra las filas sin procesar antes de que se produzca cualquier agrupación o agregación. HAVING Filtra los resultados agrupados usando expresiones de agregación. Por ejemplo, podrías WHERE production_year BETWEEN 2000 AND 2009 y luego en HAVING SUM(revenue) > 4000000 conservar únicamente a las empresas cuyos “buenos juegos” generaran más de cuatro millones en ingresos.

Un esquema de práctica más realista es un games mesa con columnas como id, title, company, type, production_year, system, production_cost, revenue, y ratingCon esta única tabla puedes realizar cálculos de promedios, recuentos, sumas, agrupaciones y clasificaciones, la base del análisis SQL.

Por ejemplo, para calcular el costo promedio de producción de juegos lanzados entre 2010 y 2015 con una calificación superior a 7, seleccionarías AVG(production_cost) y restringir filas con WHERE production_year BETWEEN 2010 AND 2015 AND rating > 7Esa es una pregunta clásica de entrevista, y puedes incorporarla fácilmente a Python e imprimir el número resultante.

También puede generar estadísticas a nivel anual directamente desde el mismo games mesaAgrupar por production_year, luego calcular COUNT(*) AS count, AVG(production_cost) AS avg_cost, y AVG(revenue) AS avg_revenueEste tipo de consulta proporciona una vista compacta de series temporales, algo muy común en los paneles de control y las herramientas de generación de informes de inteligencia empresarial.

Para clasificar las empresas por beneficio bruto en todos los años, puede agregar en company. Un patrón práctico es SELECT company, SUM(revenue - production_cost) AS gross_profit_sum FROM games GROUP BY 1 ORDER BY 2 DESC. aquí GROUP BY 1 y ORDER BY 2 utilice las posiciones de columna en el SELECT Las listas pueden ser concisas, pero deben usarse con cuidado para no dañar las consultas al reordenar las columnas posteriormente.

Las indicaciones más complejas combinan filtros, agrupaciones y filtros posteriores a la agregación.Supongamos que defines "buenos juegos" como aquellos producidos entre 2000 y 2009, con una calificación superior a 6 y unos ingresos mayores que el coste de producción. Para cada empresa, quieres el número de dichos juegos más sus ingresos totales, pero solo para las empresas cuyos ingresos por buenos juegos superen los 4,000,000. Filtrarías las filas con WHERE on production_year, ratingy rentabilidad, agrupados por company, calcular COUNT(company) y SUM(revenue), luego aplica HAVING SUM(revenue) > 4000000Esta consulta resume la mayoría de los pasos mentales reales a los que te enfrentarás en las tareas de análisis.

Modelado de datos con múltiples tablas y claves

Los diseños de una sola tabla son bastante útiles, pero las bases de datos relacionales brillan cuando se normalizan los datos en varias tablas.La normalización consiste en eliminar el almacenamiento redundante y representar las relaciones mediante claves. Esto permite que la base de datos sea más pequeña, más rápida y menos propensa a errores.

Un ejemplo sencillo pero instructivo proviene del rastreo de gráficos sociales similares a los de Twitter.Supongamos que quieres hacer un seguimiento de las cuentas de usuario y las relaciones de "seguimiento" entre ellas. Un enfoque simplista sería usar una sola tabla donde cada fila duplique los nombres del seguidor y del seguido como texto. Esto genera rápidamente mucha repetición y errores ortográficos.

En cambio, divides las cosas en una People mesa y un Follows mesa. People podría tener un número entero id como clave primaria, un único name (el nombre de pantalla o identificador), y un retrieved Bandera que indica si ya has rastreado la lista de amigos de esa cuenta. Follows contiene pares de números enteros from_id y to_id, que representan conexiones dirigidas de un usuario a otro.

Este modelo se estructura en tres conceptos clave: claves lógicas, claves primarias y claves foráneas.. Una clave lógica es lo que el mundo exterior usa para referirse a un registro; aquí, el nombre de usuario de Twitter en name. Una clave primaria suele ser un número entero generado por la base de datos (id) que identifica de forma única cada fila y es económico de indexar y comparar. Una clave foránea es un número entero que apunta a una clave primaria en otra tabla. from_id y to_id en el Follows Las tablas son claves foráneas que hacen referencia a People.id.

Para garantizar la calidad de los datos, se declaran restricciones en las definiciones de las tablas.. Por ejemplo, name TEXT UNIQUE in People Garantiza que no puedas insertar accidentalmente dos filas con el mismo identificador. UNIQUE(from_id, to_id) restricción en Follows Evita que se almacene el mismo enlace de seguimiento más de una vez. Estas restricciones también funcionan como medidas de seguridad al escribir la lógica de inserción/actualización en Python.

En Python sqlite3 módulo, un patrón común es usar INSERT OR IGNORE respetar esas restricciones con elegancia. Si intenta insertar un name que ya existe, SQLite omitirá silenciosamente la operación en lugar de generar un error. Luego puede verificar cursor.rowcount para ver si realmente se agregó una fila y confiar en cursor.lastrowid para descubrir lo asignado id para usuarios recién incorporados.

Cuando tu código recibe un nuevo nombre de pantalla, primero debe intentar buscar el correspondiente id. Si un SELECT id FROM People WHERE name = ? devuelve una fila, reutilizas ese entero. Si no, insertas el nombre con retrieved = 0, confirmar y luego leer lastrowidEse patrón de "buscar o insertar" es la base de muchos scripts de ingesta de datos.

Una vez que se conocen los ID del seguidor y del seguido, se registra la relación en Follows es solo otro INSERT OR IGNORE. Su UNIQUE(from_id, to_id) La función constraint aborda los duplicados, y usted puede concentrarse en la lógica de nivel superior sobre qué perfiles rastrear a continuación, en lugar de gestionar minuciosamente la deduplicación de filas.

Uso de JOIN para reconstruir relaciones a partir de tablas normalizadas

Los esquemas normalizados intercambian redundancia por indirección: se almacenan números enteros en lugar de cadenas repetidas, pero ahora es necesario unir tablas para reconstruir la imagen completa.Esto es exactamente lo que SQL JOIN Fue diseñado para ello, y una vez que te acostumbras, las consultas con muchas cláusulas JOIN se sienten completamente naturales.

En el ejemplo del gráfico social, si quieres ver quién es el usuario con id = 2 está siguiendo, te unirías Follows a People en el lado objetivo. Conceptualmente, corres SELECT * FROM Follows JOIN People ON Follows.to_id = People.id WHERE Follows.from_id = 2Esto produce filas combinadas que contienen tanto el identificador numérico como el nombre legible para cada seguidor.

Cada fila de ese resultado es una "meta-fila" que combina columnas de ambas tablas.Las dos primeras columnas podrían ser (from_id, to_id) desde Follows, mientras que las columnas subsiguientes pertenecen a People - me gusta (id, name, retrieved). Porque el JOIN condición impone Follows.to_id = People.idPuedes ver esa relación explícitamente: la segunda columna y la tercera columna de cada fila coinciden.

Este mismo patrón se extiende naturalmente a más tablas.Ya lo viste con artist, piece_of_art, y museumy el rastreador de Twitter lo ilustra con People y FollowsEn flujos de trabajo analíticos más complejos, se pueden combinar tablas de hechos (eventos, pedidos) con varias tablas de dimensiones (usuarios, productos, campañas) para responder preguntas multifacéticas.

Al depurar el código o comprender cómo encaja el esquema, un flujo de trabajo de "ejecutar Python y luego inspeccionar con DB Browser para SQLite" resulta extremadamente eficaz.. Ejecute su script para llenar la base de datos, cierre cualquier instancia de GUI que mantenga el archivo bloqueado y luego abra el .sqlite archivo en el navegador. Desde allí puede inspeccionar el contenido de cada tabla y ejecutar ad-hoc SELECT consultas para verificar sus suposiciones.

Una advertencia: SQLite aplica bloqueos de archivos, por lo que si el Explorador de bases de datos tiene la base de datos abierta en modo de edición, es posible que su script de Python no pueda conectarse o confirmar los cambios.La solución consiste en cerrar la base de datos en la interfaz gráfica (o cerrar el navegador por completo) antes de volver a ejecutar el código Python. Acostumbrarse a cerrar las herramientas que bloquean el archivo de la base de datos evitará errores inexplicables como "la base de datos está bloqueada".

La combinación de estas técnicas (diseño de esquemas, restricciones, consultas parametrizadas en Python, JOINs, GROUP BY y HAVING) proporciona un potente laboratorio local. Para practicar exactamente el tipo de trabajo con SQL y Python que realizarás en tu trabajo. Con solo SQLite y algunas tablas de ejemplo bien estructuradas, puedes ensayar preguntas tipo entrevista, crear prototipos de lógica analítica y recuperar la confianza en las herramientas de datos modernas.

Dónde encajan plataformas como DataLemur y los cursos interactivos

Además de tu práctica local, las plataformas interactivas pueden ofrecerte una experiencia más guiada con retroalimentación instantánea.Las herramientas surgidas de la experiencia real en la industria —por ejemplo, las plataformas creadas por antiguos ingenieros de datos de Facebook y Google que dedicaban sus días a escribir código SQL y Python y a realizar pruebas A/B— suelen centrar su contenido en preguntas de entrevistas reales y escenarios analíticos.

Los libros que abarcan estadística, aprendizaje automático e intuición empresarial para entrevistas de datos son excelentes para la teoría.Pero no siempre ofrecen el entorno práctico de SQL que muchos estudiantes anhelan. Esa brecha es precisamente lo que algunas herramientas modernas buscan llenar: reempaquetan cientos de preguntas tipo entrevista en un entorno de SQL y análisis en el navegador para que puedas ejecutar, modificar y volver a ejecutar tus consultas sin preocuparte por la configuración local. También puedes probar ejemplos aplicados como evaluación del riesgo de abandono de clientes Combinar SQL con flujos de trabajo básicos de aprendizaje automático.

También encontrarás cursos interactivos de SQL que reflejan los temas que hemos tratado aquí.: consultas de tabla única con SELECT y WHERECombinaciones entre dos o tres tablas, agregación y agrupación, subconsultas y más. Muchos de estos cursos se basan en conjuntos de datos realistas (por ejemplo, juegos, museos o ventas transaccionales), de modo que las preguntas se asemejan a problemas empresariales reales en lugar de acertijos artificiales.

Si te sientes abrumado por la documentación de herramientas como PySpark, DuckDB o dbt, es perfectamente razonable posponerlas hasta que tengas sólidos conocimientos básicos de SQL.Centrarse primero en SQLite y Python permite interiorizar los patrones de consulta básicos sin tener que lidiar con la configuración del clúster ni los permisos en la nube. Una vez que se dominan los fundamentos, aprender PySpark se centra más en la ejecución distribuida que en nuevos conceptos de consulta.

En definitiva, la combinación de una configuración local sencilla, problemas de práctica estructurados y el uso ocasional de plataformas interactivas Te ofrece lo mejor de ambos mundos: control total sobre tu entorno, una sólida base conceptual y la oportunidad de familiarizarte con el tipo de preguntas que buscan los mejores empleadores. Con práctica constante, la combinación, antes intimidante, de SQL, Python y herramientas de ingeniería de datos se convierte en un conjunto de herramientas familiar e incluso agradable que podrás utilizar con confianza en nuevos puestos.

En resumen, tu camino a seguir es claro: crea una base de datos SQLite con Python, diseña algunas tablas realistas, practica patrones SQL básicos e intermedios (filtros, uniones, agregación, agrupación, HAVING), encapsula esas consultas en scripts de Python y, opcionalmente, complementa tu aprendizaje con plataformas SQL interactivas creadas por profesionales que han estado exactamente en tu misma situación.Al hacerlo, reconstruirás tus instintos técnicos, reducirás la ansiedad en torno a las pilas de datos modernas y estarás preparado para afrontar las exigencias de SQL y Python de los puestos de datos actuales.