106 preguntas de entrevista sobre Pandas para contratar a los mejores ingenieros

Pandas es una biblioteca de análisis y manipulación de datos y se utiliza en varios roles laborales. Por lo tanto, identificar a los candidatos con las habilidades adecuadas en Pandas es fundamental para los reclutadores y gerentes de contratación que buscan formar equipos de datos competentes.

Esta publicación de blog proporciona una colección de preguntas de entrevista de Pandas categorizadas por nivel de dificultad, que van desde básico hasta experto, incluida una sección sobre preguntas de opción múltiple. Las preguntas están diseñadas para ayudarlo a evaluar la profundidad de conocimiento y las habilidades prácticas de un candidato en Pandas.

Al usar estas preguntas, puede asegurarse de que su próxima contratación tenga las habilidades para sobresalir; para la validación objetiva de habilidades, considere usar una prueba en línea de Python Pandas para evaluar a los candidatos antes de la entrevista.

Tabla de contenidos

Preguntas básicas de la entrevista de Pandas

Preguntas intermedias de la entrevista de Pandas

Preguntas avanzadas de la entrevista de Pandas

Preguntas de la entrevista de expertos de Pandas

Preguntas de opción múltiple de Pandas

¿Qué habilidades de Pandas debe evaluar durante la fase de la entrevista?

3 consejos para usar las preguntas de la entrevista de Pandas

Contrate a los mejores talentos de Pandas con pruebas de habilidades

Descarga la plantilla de preguntas de entrevista de Pandas en múltiples formatos

1. ¿Qué es Pandas? Explícalo como si tuviera cinco años.

Imagina que tienes una caja de juguetes llena de cosas diferentes, como coches, muñecas y bloques. Pandas es como una caja especial que te ayuda a organizar esos juguetes. Es como una hoja de cálculo, pero mucho más potente.

Pandas te ayuda a poner etiquetas a tus juguetes (columnas), como "Color" o "Tamaño", y a hacerles un seguimiento en filas. Es genial para contar cuántos coches rojos tienes o para encontrar el bloque más grande. Si los juguetes son datos, ¡Pandas es como magia para jugar con esos juguetes de una manera útil! Por ejemplo, digamos que tienes una lista de edades:

import pandas as pd ages = [5, 6, 5, 7, 6] age_series = pd.Series(ages) #Pandas al rescate print(age_series.mean())

Aquí pd.Series es un uso simple que convierte una lista básica de números en algo que Pandas puede usar. El .mean() calcula la edad promedio.

2. ¿Puedes describir la diferencia entre una Serie de Pandas y un DataFrame de Pandas?

Una Serie de Pandas es una matriz etiquetada unidimensional capaz de contener cualquier tipo de datos (enteros, cadenas, flotantes, objetos de Python, etc.). Piénsalo como una sola columna en una hoja de cálculo. Tiene un índice, que puede definirse explícitamente o, por defecto, es un índice numérico. Un DataFrame, por otro lado, es una estructura de datos etiquetada bidimensional con columnas de tipos potencialmente diferentes. Puedes pensarlo como una hoja de cálculo o una tabla SQL, o un dict de objetos Series. Tiene un índice de fila y de columna.

En esencia, un DataFrame es un contenedor de objetos Series. Cada columna en un DataFrame es una Serie. Por lo tanto, mientras que una Serie representa una sola columna de datos con un índice, un DataFrame representa una tabla de datos compuesta por múltiples Series que comparten el mismo índice.

3. ¿Cómo se crea un DataFrame en Pandas?

Puedes crear un DataFrame de Pandas de varias maneras:

• Desde un diccionario: Donde las claves se convierten en nombres de columnas y los valores (listas, arrays de NumPy, Series) se convierten en datos de columnas.

import pandas as pd data = {'col1': [1, 2], 'col2': [3, 4]} df = pd.DataFrame(data)

• Desde una lista de listas/tuplas: Especifica explícitamente los nombres de las columnas.

data = [[1, 3], [2, 4]] df = pd.DataFrame(data, columns=['col1', 'col2'])

• Desde un array de NumPy: Similar a las listas de listas, especifica los nombres de las columnas.

• Desde un archivo CSV: Usando pd.read_csv()

• Desde otras fuentes: como bases de datos SQL, archivos JSON, etc.

4. ¿Cómo se puede leer un archivo CSV en un DataFrame de Pandas?

Puedes leer un archivo CSV en un DataFrame de Pandas utilizando la función pd.read_csv(). Esta función es parte de la biblioteca Pandas y está diseñada específicamente para analizar archivos CSV.

Para usarla, simplemente pasa la ruta del archivo (o un objeto similar a un archivo) a la función de la siguiente manera:

import pandas as pd df = pd.read_csv('your_file.csv') print(df)

Puedes especificar varios parámetros opcionales dentro de pd.read_csv() para manejar diferentes delimitadores, encabezados, codificaciones y otras características del archivo, como:

• delimitador (o sep): Especifica el carácter usado para separar los campos (por ejemplo, ',', '\t', ';')
• encabezado: Indica el número de fila a usar como nombres de columna (por ejemplo, 0 para la primera fila, None si no hay fila de encabezado).
• codificación: Especifica la codificación del archivo (por ejemplo, 'utf-8', 'latin-1')
• index_col: Especifica qué columna usar como índice.

5. ¿Cómo se ven las primeras 5 filas de un DataFrame?

Para ver las primeras 5 filas de un DataFrame de Pandas, puedes usar el método .head(). Este método, por defecto, devuelve las primeras 5 filas.

df.head()

Si quieres ver un número diferente de filas, puedes pasar un argumento entero al método .head(), así:

df.head(10) # Ver las primeras 10 filas

6. ¿Cómo se inspeccionarían las últimas filas de un DataFrame?

Para inspeccionar las últimas filas de un DataFrame de Pandas, puedes usar el método .tail(). Por defecto, .tail() devuelve las últimas 5 filas. Puedes especificar el número de filas que quieres ver pasando un argumento entero al método.

Por ejemplo:

import pandas as pd # Asumiendo que 'df' es tu DataFrame last_10_rows = df.tail(10) print(last_10_rows)

7. ¿Cómo se obtiene el número de filas y columnas en un DataFrame?

Para obtener el número de filas y columnas en un DataFrame de Pandas, puedes usar el atributo .shape. Devuelve una tupla donde el primer elemento es el número de filas y el segundo elemento es el número de columnas.

Por ejemplo:

import pandas as pd datos = {'col1': [1, 2], 'col2': [3, 4]} df = pd.DataFrame(datos) filas, columnas = df.shape print(f"Filas: {filas}, Columnas: {columnas}")

8. ¿Cómo se pueden obtener los nombres de las columnas de un DataFrame?

Puede recuperar los nombres de las columnas de un DataFrame utilizando el atributo .columns. Este atributo devuelve un objeto Index que contiene los nombres de las columnas. Por ejemplo, en pandas, usaría df.columns para acceder a los nombres de las columnas del DataFrame df.

Para convertir los nombres de las columnas en una lista, puede usar df.columns.tolist(). Esto es útil si necesita iterar sobre los nombres de las columnas o realizar otras operaciones que requieran una estructura de datos de lista. La sintaxis se ve así:

nombres_columnas = df.columns.tolist() print(nombres_columnas)

9. ¿Cómo se selecciona una sola columna de un DataFrame?

Para seleccionar una sola columna de un DataFrame, puedes usar la notación de corchetes con el nombre de la columna como una cadena, así: df['nombre_columna']. Esto devuelve una Serie de pandas que contiene los datos de esa columna. Alternativamente, puedes usar la notación de punto si el nombre de la columna es un identificador de Python válido (es decir, sin espacios ni caracteres especiales), así: df.nombre_columna. Sin embargo, generalmente se prefiere usar la notación de corchetes, ya que funciona en todos los casos y es menos propensa a errores cuando los nombres de las columnas son complejos.

10. ¿Cómo se seleccionan múltiples columnas de un DataFrame?

Para seleccionar múltiples columnas de un DataFrame, puedes usar varios métodos. El enfoque más común es pasar una lista de nombres de columna dentro de corchetes [] al objeto DataFrame. Esto devolverá un nuevo DataFrame que contiene solo las columnas especificadas. Por ejemplo, si tienes un DataFrame llamado df y quieres seleccionar las columnas 'col1', 'col2' y 'col3', usarías df[['col1', 'col2', 'col3']].

Alternativamente, puedes usar el acceso .loc con una lista de nombres de columna. Por ejemplo: df.loc[:, ['col1', 'col2', 'col3']]. Los : indican que quieres seleccionar todas las filas. Este método es particularmente útil cuando necesitas combinar la selección de filas y columnas basada en etiquetas. Usar .iloc también es una opción si prefieres usar la posición del índice de las columnas: df.iloc[:, [0, 1, 2]].

11. ¿Cómo se filtran filas basadas en una condición en Pandas? ¿Puedes dar un ejemplo?

Para filtrar filas basadas en una condición en Pandas, puedes usar la indexación booleana. Esto implica crear una Serie booleana que tenga la misma longitud que el DataFrame, donde cada elemento indica si la fila correspondiente satisface la condición. Luego, usas esta Serie booleana para seleccionar las filas donde el valor es True.

Por ejemplo, si tiene un DataFrame df y desea seleccionar filas donde 'nombre_columna' es mayor que 10, haría lo siguiente:

filtered_df = df[df['nombre_columna'] > 10]

Esto crea un nuevo DataFrame, filtered_df, que contiene solo las filas que cumplen la condición especificada. Puede usar varios operadores de comparación (>, <, ==, !=, >=, <=) y operadores lógicos (&, |, ~) para crear condiciones más complejas.

12. ¿Cómo puede ordenar un DataFrame por una columna específica?

Puede ordenar un DataFrame por una columna específica usando el método sort_values() en pandas. Simplemente pase el nombre de la columna (o una lista de nombres de columna para la clasificación de varios niveles) al argumento by.

Por ejemplo:

df.sort_values(by='nombre_columna')

Esto ordena el DataFrame en orden ascendente basado en los valores de 'nombre_columna'. Para ordenar en orden descendente, establezca ascending=False:

df.sort_values(by='nombre_columna', ascending=False)

13. ¿Cómo se agrupan los datos en un DataFrame usando Pandas? ¿Cuáles son algunas funciones de agregación comunes?

En Pandas, puedes agrupar datos en un DataFrame usando el método groupby(). Este método divide el DataFrame en grupos basados en una o más columnas. Después de agrupar, puedes aplicar funciones de agregación a cada grupo.

Algunas funciones de agregación comunes incluyen:

• sum(): Calcula la suma de los valores en cada grupo.
• mean(): Calcula la media de los valores en cada grupo.
• median(): Calcula la mediana de los valores en cada grupo.
• count(): Cuenta el número de valores en cada grupo.
• min(): Encuentra el valor mínimo en cada grupo.
• max(): Encuentra el valor máximo en cada grupo.
• std(): Calcula la desviación estándar de los valores en cada grupo.
• agg(): Te permite aplicar múltiples funciones de agregación a la vez, usando código como:

df.groupby('nombre_columna').agg(['sum', 'mean', 'count'])

14. ¿Cómo manejas los valores faltantes en Pandas? ¿Cuáles son las técnicas comunes?

Pandas ofrece varias formas de manejar los valores faltantes, típicamente representados como NaN (Not a Number - No es un Número). Las técnicas comunes incluyen:

• Identificación de Valores Faltantes:
  • isna() o isnull(): Detecta valores faltantes y devuelve una máscara booleana.
  • notna() o notnull(): Inverso de isna() e isnull().
• Manejo de Valores Faltantes:
  • dropna(): Elimina filas o columnas que contienen valores faltantes. Puedes controlar el comportamiento con parámetros como axis (filas o columnas) y how ('any' o 'all').
  • fillna(): Rellena los valores faltantes con un valor especificado (por ejemplo, media, mediana, constante) o utilizando métodos como relleno hacia adelante (ffill) o relleno hacia atrás (bfill).
• Imputación: Se pueden usar métodos más sofisticados para imputar valores faltantes, a menudo involucrando técnicas estadísticas o modelos de aprendizaje automático. Bibliotecas como scikit-learn proporcionan herramientas para este propósito. Por ejemplo, SimpleImputer puede reemplazar los valores faltantes con la media, la mediana o el valor más frecuente de la columna.

Por ejemplo:

df.dropna(axis=0) # Eliminar filas con cualquier valor NaN df['nombre_columna'].fillna(df['nombre_columna'].mean(), inplace=True) # Rellenar valores NaN en 'nombre_columna' con la media

15. ¿Cómo se renombran las columnas en un DataFrame de Pandas?

Puedes renombrar las columnas en un DataFrame de Pandas usando varios métodos:

• df.rename(): Este es el método más versátil. Se pasa un diccionario donde las claves son los nombres de columna antiguos y los valores son los nombres de columna nuevos al argumento columns. df = df.rename(columns={'nombre_antiguo': 'nombre_nuevo', 'otro_nombre_antiguo': 'otro_nombre_nuevo'}). Para modificar el DataFrame en su lugar, usa inplace=True.
• df.columns: Puedes asignar directamente una nueva lista de nombres de columna al atributo df.columns. df.columns = ['nueva_col1', 'nueva_col2', 'nueva_col3']. Este método requiere que proporciones una lista con la misma longitud que el número de columnas.
• df.set_axis(): Similar a df.columns, pero más general. Permite renombrar tanto filas como columnas usando el parámetro axis. Para renombrar columnas: df = df.set_axis(['nueva_col1', 'nueva_col2'], axis='columns'). El parámetro inplace también se puede usar aquí.

16. ¿Cómo se agrega una nueva columna a un DataFrame?

Puedes agregar una nueva columna a un DataFrame de varias maneras. La más común es usando la notación de corchetes, similar a cómo agregarías una clave a un diccionario. Por ejemplo, en pandas, puedes asignar directamente una Serie (o un único valor) a un nuevo nombre de columna. Otra forma es usando el método assign(), que crea un nuevo DataFrame con la(s) columna(s) agregada(s) o modificada(s), dejando el DataFrame original intacto.

Por ejemplo, en pandas:

import pandas as pd # DataFrame de ejemplo data = {'col1': [1, 2], 'col2': [3, 4]} df = pd.DataFrame(data) # Agregar una nueva columna usando notación de corchetes df['new_col'] = [5, 6] # Agregar una nueva columna usando assign df = df.assign(another_col = [7,8])

17. ¿Cómo se elimina una columna de un DataFrame?

Puedes eliminar una columna de un DataFrame de Pandas de varias maneras. Los métodos principales son usar la palabra clave del, el método drop(), o reasignando el DataFrame sin la columna.

Aquí hay una breve descripción general:

• Palabra clave del: del df['nombre_de_la_columna'] - Esto modifica el DataFrame en su lugar.
• Método drop(): df.drop('nombre_de_la_columna', axis=1) o df.drop(columns=['nombre_de_la_columna']) - Esto devuelve un nuevo DataFrame con la columna eliminada. Usa inplace=True para modificar el DataFrame original.
• Reasignación: df = df.drop('nombre_de_la_columna', axis=1) - Asigna el resultado de df.drop al dataframe original. Es lo mismo que arriba, excepto que sobrescribe de forma más explícita el dataframe inicial.

Ejemplo usando drop():

import pandas as pd data = {'col1': [1, 2], 'col2': [3, 4]} df = pd.DataFrame(data) df = df.drop('col1', axis=1) # o df.drop(columns=['col1']) print(df)

18. ¿Cómo se puede iterar sobre las filas en un DataFrame? ¿Es generalmente recomendable?

Puedes iterar sobre filas en un DataFrame de Pandas utilizando métodos como iterrows(), itertuples(), o accediendo directamente al array NumPy subyacente con .values. Sin embargo, iterar sobre las filas generalmente no se recomienda por razones de rendimiento, especialmente para DataFrames grandes.

Estos métodos son lentos en comparación con las operaciones vectorizadas usando funciones integradas de Pandas o NumPy. Para la mayoría de las tareas, debes tratar de usar operaciones vectorizadas, funciones apply, u otros métodos de Pandas/NumPy que operan en columnas o DataFrames completos a la vez. Por ejemplo:

• Operaciones vectorizadas: df['nueva_columna'] = df['columna_a'] + df['columna_b']
• Función apply(): df['nueva_columna'] = df.apply(lambda fila: some_function(fila['columna_a'], fila['columna_b']), axis=1)

19. ¿Cómo se aplica una función a cada elemento de una Serie o DataFrame de Pandas?

Para aplicar una función a cada elemento de una Serie o DataFrame de Pandas, puedes usar los métodos apply() o map(). Para una Serie, map() está diseñado específicamente para transformaciones elemento por elemento usando una función o un objeto similar a un diccionario. apply() también se puede usar en Series y DataFrames para operaciones más complejas.

Para DataFrames, apply() se puede usar para aplicar una función a lo largo de un eje (filas o columnas). Para la aplicación elemento por elemento en un DataFrame, use applymap(). Aquí hay ejemplos:

• Series:

import pandas as pd s = pd.Series([1, 2, 3]) s_transformed = s.map(lambda x: x * 2) print(s_transformed)

• DataFrame:

import pandas as pd df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}) df_transformed = df.applymap(lambda x: x + 1) print(df_transformed)

20. Explique cómo fusionar dos DataFrames en Pandas. ¿Cuáles son los diferentes tipos de fusiones?

En Pandas, puede fusionar dos DataFrames usando la función pd.merge(). Combina DataFrames basándose en una columna o índice común, de forma similar a las uniones SQL. La sintaxis básica es pd.merge(left, right, how='inner', on='key'), donde left y right son los DataFrames, how especifica el tipo de fusión y on especifica la columna en la que fusionar. Si los nombres de las columnas son diferentes en los dos DataFrames, se pueden especificar left_on y right_on.

Los diferentes tipos de fusiones incluyen:

• Inner: (predeterminado) Devuelve solo las filas con claves coincidentes en ambos DataFrames.
• Outer: Devuelve todas las filas de ambos DataFrames, rellenando los valores faltantes con NaN.
• Left: Devuelve todas las filas del DataFrame izquierdo y las filas coincidentes del DataFrame derecho. Los valores faltantes del DataFrame derecho se rellenan con NaN.
• Right: Devuelve todas las filas del DataFrame derecho y las filas coincidentes del DataFrame izquierdo. Los valores faltantes del DataFrame izquierdo se rellenan con NaN.
• Cross: Realiza un producto cartesiano de las filas de ambos DataFrames, devolviendo todas las combinaciones. Ejemplo: pd.merge(df1, df2, how='cross')

21. ¿Cómo se concatenan dos DataFrames en Pandas?

Se pueden concatenar dos DataFrames en Pandas usando la función pd.concat(). Esta función permite combinar DataFrames a lo largo de filas (verticalmente) o columnas (horizontalmente). La sintaxis básica es pd.concat([df1, df2]), que concatena df1 y df2 verticalmente.

Los parámetros clave incluyen:

• objs: Una secuencia o mapeo de objetos Pandas como DataFrames o Series.
• axis: Especifica el eje a concatenar (0 para filas, 1 para columnas).
• join: Especifica cómo manejar los índices en otro eje (inner, outer).
• ignore_index: Si es verdadero, no use los valores de índice a lo largo del eje de concatenación. El eje resultante se etiquetará 0, ..., n - 1.

Por ejemplo:

import pandas as pd df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}) df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]}) df_concatenated = pd.concat([df1, df2], ignore_index=True) print(df_concatenated)

22. ¿Cómo se calculan las estadísticas descriptivas (como la media, la mediana, la desviación estándar) para un DataFrame?

Para calcular las estadísticas descriptivas para un DataFrame (asumiendo que estamos usando pandas en Python), puedes usar varios métodos integrados. El más común es .describe(), que proporciona un resumen de las estadísticas para las columnas numéricas, incluyendo la cuenta, la media, la desviación estándar, el mínimo, el máximo y los cuartiles. Para estadísticas individuales:

• Media: Usa .mean() en un DataFrame o Serie (columna). df['nombre_columna'].mean()
• Mediana: Usa .median(). df['nombre_columna'].median()
• Desviación Estándar: Usa .std(). df['nombre_columna'].std()
• Otras funciones como .min(), .max(), .count() y .quantile() también están disponibles para estadísticas específicas.

23. ¿Cómo se escribe un DataFrame en un archivo CSV?

Para escribir un DataFrame en un archivo CSV, normalmente usas un método proporcionado por la biblioteca DataFrame que estás utilizando (por ejemplo, Pandas en Python). Así es como lo harías con Pandas:

import pandas as pd data = {'col1': [1, 2], 'col2': [3, 4]} df = pd.DataFrame(data) df.to_csv('output.csv', index=False)

Puntos clave:

• to_csv() es el método usado para escribir el DataFrame en un archivo CSV.
• El primer argumento (por ejemplo, 'output.csv') especifica el nombre del archivo.
• index=False evita escribir el índice del DataFrame en el CSV.

24. ¿Cuáles son algunas formas de manejar eficientemente conjuntos de datos grandes en Pandas, considerando las limitaciones de memoria?

Para manejar eficientemente conjuntos de datos grandes en Pandas bajo restricciones de memoria, considere estas estrategias:

• Use chunksize al leer datos: Lea los datos en fragmentos más pequeños y manejables usando el parámetro chunksize en funciones como pd.read_csv. Procese cada fragmento iterativamente, realizando agregaciones o transformaciones según sea necesario, y luego libere la memoria. Por ejemplo:

for chunk in pd.read_csv('archivo_grande.csv', chunksize=10000): # Procesa el fragmento procesar_fragmento(chunk)

• Especifique dtype: Defina explícitamente los tipos de datos para las columnas usando el parámetro dtype en pd.read_csv. El uso de tipos de datos más pequeños (por ejemplo, int16 en lugar de int64) puede reducir significativamente el uso de memoria.

• Seleccione solo las columnas necesarias: Lea solo las columnas necesarias para su análisis usando el parámetro usecols en pd.read_csv.

• Optimice los tipos de datos después de la lectura: Convierta las columnas a tipos de datos más eficientes en memoria utilizando funciones como pd.to_numeric(downcast='integer') o pd.to_datetime. También convierta los tipos de datos object a category cuando sea apropiado para ahorrar espacio.

• Elimine datos innecesarios: Elimine los DataFrames o columnas intermedias que ya no son necesarios utilizando del o DataFrame.drop() para liberar memoria.

• Use inplace=True: Cuando sea posible, use el argumento inplace=True en las operaciones de Pandas (por ejemplo, fillna, drop) para modificar el DataFrame directamente en lugar de crear una copia.

• Considerar bibliotecas alternativas: Para conjuntos de datos extremadamente grandes que exceden la memoria disponible, explore bibliotecas de computación fuera del núcleo como Dask o Vaex, que le permiten trabajar con datos que no caben completamente en la memoria.

Preguntas de entrevista intermedias de Pandas

1. ¿Cómo se combinan eficientemente los datos de múltiples DataFrames de Pandas cuando comparten una columna común, pero los nombres de las columnas son diferentes?

Para combinar eficientemente los datos de múltiples DataFrames de Pandas cuando comparten una columna común pero los nombres de las columnas son diferentes, primero debe renombrar las columnas comunes a un nombre consistente en todos los DataFrames. Puede lograr esto usando el método .rename() en Pandas. Después de renombrar, puede usar funciones como pd.concat(), pd.merge() o .join() para combinar los DataFrames. pd.concat() es útil para agregar DataFrames vertical u horizontalmente. pd.merge() se utiliza para uniones estilo base de datos basadas en la columna común. .join() es a menudo más rápido que pd.merge() al unir en índices o en una columna común.

Por ejemplo, si tienes df1 con la columna 'ID' y df2 con la columna 'CustomerID' que representan los mismos datos, harías df2 = df2.rename(columns={'CustomerID': 'ID'}) antes de fusionar. Luego, merged_df = pd.merge(df1, df2, on='ID', how='inner') para realizar una unión interna. El uso del argumento how apropiado asegura que solo se incluyan los registros requeridos en el resultado.

2. ¿Puedes explicar cómo usar el método `.pipe()` en Pandas para encadenar múltiples operaciones juntas para la transformación de datos?

El método .pipe() en Pandas te permite encadenar múltiples transformaciones de datos juntas de una manera más legible y organizada. En lugar de anidar múltiples llamadas a funciones o asignar resultados intermedios a variables, puedes pasar funciones (o objetos invocables) a .pipe() secuencialmente. Cada función recibe el DataFrame como entrada y devuelve un DataFrame transformado, que luego se pasa a la siguiente función en la cadena.

Por ejemplo, si tienes las funciones clean_data, feature_engineer y analyze_data, puedes encadenarlas usando .pipe() así: df.pipe(clean_data).pipe(feature_engineer).pipe(analyze_data). Esto mejora la legibilidad y el mantenimiento del código. También puedes reescribir las funciones como cadenas de métodos, lo que puede ser un mejor patrón para la reutilización. El código puede reescribirse como def clean_data(df): return df[...], donde la función clean_data ahora se puede aplicar al objeto dataframe a través de df.pipe(clean_data).

3. Describe cómo manejarías los datos faltantes en un DataFrame de Pandas, incluyendo estrategias de imputación y consideraciones para diferentes tipos de datos.

Manejar los datos faltantes en Pandas implica identificar y abordar los valores NaN. Primero, verificaría los datos faltantes usando df.isnull().sum() para entender la magnitud del problema. Consideraría eliminar filas o columnas con valores faltantes excesivos usando df.dropna(), teniendo en cuenta la posible pérdida de datos. Si los valores faltantes no son demasiados, consideraría estrategias de imputación que dependen del tipo de datos y el contexto.

Para datos numéricos, consideraría usar df.fillna(df.mean()) o df.fillna(df.median()) para la imputación de la media o la mediana, respectivamente. Para datos categóricos, df.fillna(df['columna'].mode()[0]) es apropiado para rellenar con el valor más frecuente. Técnicas de imputación más avanzadas, como el uso de sklearn.impute.SimpleImputer o modelos predictivos basados en otras columnas, podrían ser adecuadas en escenarios más complejos. Otra opción sería usar relleno hacia adelante o hacia atrás - df.fillna(method='ffill') o df.fillna(method='bfill'). Es esencial evaluar el impacto de la imputación en la distribución de los datos y cualquier análisis posterior.

4. ¿Cómo se puede crear una tabla dinámica en Pandas para resumir datos basados en múltiples columnas de índice y valor, y cómo se manejan los valores faltantes en la tabla resultante?

Puede crear una tabla dinámica en Pandas usando la función pivot_table(). Para resumir datos basados en múltiples columnas de índice, pase una lista de nombres de columna al parámetro index. De manera similar, para múltiples columnas de valor, pase una lista al parámetro values. Aquí hay un ejemplo:

import pandas as pd pivot_table = pd.pivot_table(data, values=['valor1', 'valor2'], index=['índice1', 'índice2'], aggfunc='sum')

Para manejar los valores faltantes en la tabla resultante, puedes usar el parámetro fill_value en pivot_table(). Esto reemplaza los valores NaN con un valor especificado (por ejemplo, 0). También puedes usar .fillna() en la tabla pivot resultante después de la creación para imputar valores faltantes usando varias estrategias (por ejemplo, media, mediana).

pivot_table = pd.pivot_table(data, values=['valor1', 'valor2'], index=['índice1', 'índice2'], aggfunc='sum', fill_value=0)

5. Explica cómo usar el objeto pd.Grouper en Pandas para agrupar datos por intervalos de tiempo, y proporciona un ejemplo de caso de uso.

El objeto pd.Grouper en Pandas proporciona una forma flexible de especificar la operación de agrupación, especialmente cuando se trata de datos de series temporales. Es particularmente útil cuando necesitas agrupar datos por intervalos de tiempo (por ejemplo, cada 5 minutos, diariamente, semanalmente). Normalmente lo usas dentro del método groupby() de un DataFrame o Serie de Pandas. Especificas la key (la columna por la que agrupar), la freq (la frecuencia de la agrupación), y opcionalmente axis (a lo largo de qué eje agrupar).

Por ejemplo, considera un DataFrame df con un DateTimeIndex. df.groupby(pd.Grouper(freq='D')).sum() agruparía los datos por día y calcularía la suma para cada grupo. freq puede ser cualquier cadena de frecuencia válida de Pandas (por ejemplo, 'D' para día, 'H' para hora, '5min' para 5 minutos, 'M' para mes). Alternativamente, puedes usar df.groupby(pd.Grouper(key='columna_fecha', freq='W')).mean() para agrupar por una columna de fecha específica llamada columna_fecha semanalmente.

6. ¿Cómo optimizarías el rendimiento de una operación de Pandas en un conjunto de datos grande, considerando técnicas como la división en fragmentos o el uso de tipos de datos más eficientes?

Para optimizar el rendimiento de Pandas en conjuntos de datos grandes, considere la segmentación. Lea los datos en piezas más pequeñas y manejables usando pd.read_csv(nombre_archivo, chunksize=...). Procese cada segmento de forma independiente y luego combine los resultados. Además, usar los tipos de datos correctos es crucial. Por ejemplo, convierta las cadenas a datos categóricos usando astype('category') si es apropiado, y use tipos enteros más pequeños como int16 o int8 en lugar de int64 cuando el rango de valores lo permita. Esto reduce el uso de memoria y acelera las operaciones. La vectorización es clave: evite los bucles y aplique operaciones en columnas/Series completas a la vez utilizando las funciones integradas de Pandas.

7. Describa cómo realizar un cálculo de ventana móvil en una Serie de Pandas y explique los diferentes tipos de ventana y funciones de agregación.

Para realizar un cálculo de ventana móvil en una Serie de Pandas, puede usar el método rolling(). Este método crea un objeto Rolling que le permite especificar el tamaño de la ventana. Después de crear el objeto Rolling, puede aplicar una función de agregación como mean(), sum(), min(), max() o std() para calcular la estadística móvil.

Los diferentes tipos de ventana incluyen:

• Ventana fija: Una ventana de tamaño constante que se desliza sobre los datos. s.rolling(window=3).mean()
• Ventana variable: Una ventana que cambia su tamaño según algún criterio, a menudo relacionado con el tiempo. Esto se puede lograr usando groupby con una función personalizada.

Las diferentes funciones de agregación incluyen:

• mean(): Calcula la media de los valores dentro de la ventana.
• sum(): Calcula la suma de los valores dentro de la ventana.
• min(): Encuentra el valor mínimo dentro de la ventana.
• max(): Encuentra el valor máximo dentro de la ventana.
• std(): Calcula la desviación estándar de los valores dentro de la ventana.
• apply(func): Aplica una función personalizada a los valores dentro de la ventana. Por ejemplo:

import pandas as pd s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) media_móvil = s.rolling(window=3).mean() print(media_móvil)

8. ¿Cómo se aplica una función personalizada a cada elemento en un DataFrame de Pandas y cuáles son las implicaciones de rendimiento en comparación con las operaciones vectorizadas?

Puedes aplicar una función personalizada a cada elemento en un DataFrame de Pandas usando el método .applymap(). Por ejemplo:

def funcion_personalizada(x): return x * 2 df.applymap(funcion_personalizada)

Si bien .applymap() es flexible, generalmente es más lento que las operaciones vectorizadas (por ejemplo, usar operadores como *, +, -, / directamente en las columnas/filas del DataFrame). Las operaciones vectorizadas están optimizadas para trabajar en matrices enteras a la vez, aprovechando los cálculos eficientes de NumPy. .applymap() itera elemento por elemento, lo que genera una sobrecarga. Para tareas críticas de rendimiento, favorece las operaciones vectorizadas cuando sea posible. Si tu función personalizada no se puede vectorizar (por ejemplo, implica una lógica condicional compleja o procesamiento de cadenas que NumPy no puede manejar directamente), applymap() es una opción viable, pero ten en cuenta la compensación de rendimiento.

9. Explica cómo crear un índice de varios niveles en Pandas y cómo acceder y manipular datos utilizando los diferentes niveles del índice.

Para crear un índice de varios niveles (también conocido como índice jerárquico) en Pandas, puedes usar los métodos pd.MultiIndex.from_tuples() o pd.MultiIndex.from_arrays(). También puedes establecer múltiples columnas como el índice usando df.set_index(['col1', 'col2']). Una vez creado, el acceso a los datos implica el uso de .loc[] con tuplas que representan los niveles. Por ejemplo, df.loc[('valor_nivel1', 'valor_nivel2')] accederá a los datos en valores de índice específicos. El slicing también se puede realizar dentro de los niveles usando slice(None) para seleccionar todo dentro de un nivel, por ejemplo, df.loc[(slice(None), 'valor_nivel2'), :].

Manipular datos en niveles específicos a menudo implica usar el método swaplevel() para cambiar el orden de los niveles, y luego ordenar con sort_index() si es necesario. Luego puede usar el accesorio .loc[] como antes para asignar nuevos valores a porciones, o realizar cálculos usando funciones agregadas como groupby(level='level_name').sum(). Por ejemplo:

import pandas as pd import numpy as np index = pd.MultiIndex.from_tuples([('A', 1), ('A', 2), ('B', 1), ('B', 2)], names=['Categoría', 'Valor']) df = pd.DataFrame({'Datos': np.random.randn(4)}, index=index) # Accediendo a datos print(df.loc[('A', 1)]) # Manipulando datos df = df.swaplevel(0, 1) df = df.sort_index() print(df.loc[(1, 'A')])

10. ¿Cómo puede convertir un DataFrame de Pandas a un formato de matriz dispersa, y cuáles son los beneficios de hacerlo para el uso de memoria y la velocidad de cálculo?

Puede convertir un DataFrame de Pandas a una matriz dispersa utilizando matrices scipy.sparse en conjunto con métodos de DataFrame como to_numpy(). Por ejemplo, podría usar scipy.sparse.csc_matrix(df.to_numpy()) para crear una matriz de Columna Dispersa Comprimida (CSC). Se pueden elegir diferentes formatos dispersos como CSR (Fila Dispersa Comprimida), CSC, COO (Lista de Coordenadas), etc., basándose en la estructura de los datos y las operaciones que se realizarán.

Los beneficios de usar matrices dispersas incluyen el uso reducido de memoria al tratar con dataframes que contienen una gran cantidad de valores cero o faltantes. Almacenar solo los elementos distintos de cero y sus índices puede disminuir significativamente la huella de memoria. Además, ciertos cálculos, especialmente aquellos que involucran álgebra lineal, se pueden realizar de manera más eficiente en matrices dispersas, ya que los algoritmos se pueden optimizar para evitar operaciones que involucran elementos cero, lo que lleva a velocidades de cálculo más rápidas.

11. Describe cómo realizar una fusión difusa en Pandas, donde se emparejan filas basadas en la coincidencia aproximada de cadenas en lugar de la igualdad exacta.

La fusión difusa en Pandas implica emparejar filas de dos DataFrames basadas en coincidencias aproximadas de cadenas en una o más columnas, en lugar de la igualdad exacta. Esto suele ser necesario cuando se trata de datos del mundo real donde los campos de cadena pueden contener ligeras variaciones, errores tipográficos o inconsistencias.

La biblioteca fuzzywuzzy, junto con Pandas, se usa comúnmente para lograr esto. Primero, calcularía una puntuación de similitud entre las cadenas en las columnas de fusión usando fuzzywuzzy.fuzz.ratio u otras funciones relevantes como partial_ratio, token_sort_ratio, etc. Luego, filtre las posibles coincidencias basadas en una puntuación de umbral definida. Finalmente, puede fusionar los DataFrames basándose en estos índices de coincidencia difusa o crear un nuevo DataFrame que contenga las mejores coincidencias para cada fila. Por ejemplo:

import pandas as pd from fuzzywuzzy import fuzz def fuzzy_merge(df_left, df_right, left_on, right_on, threshold=90): merged_rows = [] for i, row_left in df_left.iterrows(): best_match_index = None best_score = 0 for j, row_right in df_right.iterrows(): score = fuzz.ratio(row_left[left_on], row_right[right_on]) if score > threshold and score > best_score: best_score = score best_match_index = j if best_match_index is not None: merged_row = pd.concat([row_left, df_right.loc[best_match_index]]) merged_rows.append(merged_row) return pd.DataFrame(merged_rows)

12. ¿Cómo se usa la función `eval()` de Pandas para realizar operaciones aritméticas en columnas, y cuáles son las ventajas de usarla sobre los operadores estándar?

La función pandas.eval() evalúa una cadena que describe operaciones en DataFrames y Series de Pandas. Se utiliza principalmente para operaciones aritméticas que involucran columnas. Por ejemplo, df.eval('A + B * C') calcula 'A + B * C' para cada fila, donde A, B y C son nombres de columnas en el DataFrame df. También puede asignar el resultado a una columna nueva o existente: df.eval('D = A + B * C', inplace=True).

Las ventajas sobre los operadores estándar incluyen:

• Rendimiento: eval() puede ser más rápido, especialmente para DataFrames más grandes, porque evita la creación de matrices intermedias temporales, aprovechando NumExpr en segundo plano (si está instalado) para realizar operaciones vectorizadas.
• Legibilidad: Las expresiones complejas pueden ser más legibles cuando se escriben como una sola cadena dentro de eval() en comparación con la concatenación de múltiples operaciones de Pandas. La representación de cadena a menudo puede reflejar la expresión matemática más de cerca.
• Uso de memoria: eval reduce el uso de memoria para operaciones más grandes al optimizar los pasos. Usando operaciones estándar, se crean matrices temporales para cada paso en el cálculo, lo que aumenta la sobrecarga de memoria.

Considere este ejemplo:

import pandas as pd import numpy as np # DataFrame de muestra df = pd.DataFrame({'A': np.random.rand(1000), 'B': np.random.rand(1000), 'C': np.random.rand(1000)}) # Usando eval() df['D'] = df.eval('A + B * C') # Usando operadores estándar df['E'] = df['A'] + df['B'] * df['C'] # ambas columnas D y E tendrán el mismo resultado, pero eval() es más rápido y usa menos memoria

13. Explique cómo leer y escribir datos en una base de datos SQL utilizando Pandas, incluyendo el manejo de diferentes tipos de datos y la ejecución de consultas SQL.

Pandas puede interactuar con bases de datos SQL utilizando la biblioteca sqlalchemy (para conexiones a bases de datos) y las funciones pandas.read_sql y pandas.to_sql. Para leer datos, primero establece una conexión a la base de datos utilizando sqlalchemy. Luego, utiliza pandas.read_sql para ejecutar consultas SQL y cargar los resultados en un DataFrame de Pandas. pandas.read_sql infiere automáticamente los tipos de datos del esquema de la base de datos SQL. Ejemplo:

import pandas as pd from sqlalchemy import create_engine engine = create_engine('sqlite:///:memory:') # Conectar a una base de datos (por ejemplo, SQLite en memoria) df = pd.DataFrame({'col1': [1, 2], 'col2': ['a', 'b']}) df.to_sql('test_table', engine, if_exists='replace', index=False) # Escribir DataFrame a SQL df_read = pd.read_sql('SELECT * FROM test_table', engine) # Leer datos de SQL print(df_read)

Para escribir datos, crea un DataFrame de Pandas y utiliza la función pandas.to_sql. Especifica el nombre de la tabla, el motor y cómo manejar las tablas existentes (if_exists='replace' para sobrescribir, if_exists='append' para agregar). Pandas gestiona las conversiones de tipos de datos de los tipos de Pandas a los tipos de SQL. Si necesitas más control, puedes especificar el argumento dtype en to_sql con un diccionario que mapee los nombres de las columnas a los tipos de datos de SQLAlchemy. Para consultas SQL directas, se puede utilizar engine.execute().

14. ¿Cómo puedes crear una función de agregación personalizada en Pandas para calcular una estadística que no está disponible en las funciones de agregación integradas?

Puedes crear una función de agregación personalizada en Pandas utilizando el método agg() junto con una función definida por el usuario. Esta función debe tomar una Serie como entrada y devolver un único valor agregado. Por ejemplo, para calcular el rango (máximo - mínimo) de una columna, puedes definir una función range_func(x): return x.max() - x.min() y luego aplicarla usando df['nombre_columna'].agg(range_func).

Alternativamente, puedes usar una función lambda para un enfoque más conciso si la lógica es simple. Por ejemplo: df['nombre_de_la_columna'].agg(lambda x: x.max() - x.min()). La clave es que la función pasada reduce la Serie a un único valor escalar, que representa la estadística agregada. Esto permite cálculos flexibles más allá de las funciones incorporadas de Pandas.

15. Describe cómo realizar una operación de remuestreo de series temporales en Pandas, incluyendo diferentes frecuencias de remuestreo y métodos de interpolación.

En Pandas, el remuestreo de series temporales se realiza utilizando el método resample() en un DataFrame o Serie con un DateTimeIndex. La funcionalidad principal implica especificar una nueva frecuencia (por ejemplo, 'D' para diario, 'W' para semanal, 'M' para mensual). Por ejemplo, df.resample('W').mean() remuestrea el DataFrame df a frecuencia semanal y calcula la media para cada semana. Diferentes funciones de agregación como sum(), min(), max(), count() se pueden aplicar después de resample().

Los valores faltantes introducidos durante el upsampling (aumentando la frecuencia) se pueden manejar usando la interpolación. Los métodos comunes incluyen:

• ffill(): Relleno hacia adelante (propaga la última observación válida hacia adelante).
• bfill(): Relleno hacia atrás (usa la siguiente observación válida para llenar el hueco).
• interpolate(): Usa varias técnicas de interpolación, como la interpolación lineal (method='linear') o la interpolación polinómica (method='polynomial', order=2). Por ejemplo, df.resample('H').interpolate() remuestrea a frecuencia horaria y rellena los valores faltantes usando interpolación lineal. Ejemplo de código: df.resample('D').asfreq().fillna(method='ffill')

16. ¿Cómo se manejan los datos categóricos en Pandas, incluyendo la codificación de variables categóricas y su uso en modelos de aprendizaje automático?

Pandas ofrece varias formas de manejar datos categóricos. Para empezar, puedes convertir una columna a un tipo categórico usando astype('category'). Esto es eficiente en memoria, especialmente para columnas con muchos valores repetidos. Para la codificación, puedes usar técnicas como:

• Codificación One-Hot: pd.get_dummies(df, columns=['nombre_columna']) crea nuevas columnas para cada categoría. Esto es adecuado para datos nominales.
• Codificación de Etiqueta: df['nombre_columna'].astype('category').cat.codes asigna un valor numérico único a cada categoría. También se puede usar LabelEncoder de Scikit-learn. Tenga cuidado al aplicarlo a datos nominales, ya que podría implicar una relación ordinal donde no existe.
• Codificación Ordinal: Si la variable categórica tiene un orden significativo, asigne enteros basados en ese orden. Puede usar un mapeo de diccionario y la función map().

Para usar datos categóricos en modelos de aprendizaje automático, muchos algoritmos requieren entrada numérica. Por lo tanto, la codificación es crucial. La codificación one-hot se usa comúnmente con modelos lineales, mientras que los modelos basados en árboles a veces pueden manejar características con codificación de etiqueta directamente o beneficiarse de la codificación ordinal si las categorías tienen un orden lógico. Considere los requisitos del algoritmo y la naturaleza de sus datos al elegir un método de codificación.

17. Explique cómo usar el objeto Pandas `Styler` para formatear y dar estilo a DataFrames para su presentación, incluyendo formato condicional y estilos CSS personalizados.

El objeto Pandas Styler le permite personalizar visualmente los DataFrames. Puede acceder al objeto Styler usando df.style. Admite el formato condicional usando métodos como applymap (elemento por elemento) y apply (columna/fila/tabla por tabla). Estos métodos toman funciones que devuelven estilos CSS basados en los valores de los datos.

Para aplicar CSS personalizado, puedes usar set_properties o set_table_styles. set_properties aplica estilos en línea a celdas individuales, mientras que set_table_styles te permite establecer estilos usando selectores CSS. Ejemplo:

def color_negative_red(val): color = 'red' if val < 0 else 'black' return 'color: %s' % color s = df.style.applymap(color_negative_red).set_properties(**{'font-weight': 'bold'}) s

Este fragmento de código demuestra el formateo condicional para colorear los valores negativos en rojo y establecer la negrita para todas las celdas. s es el dataframe con estilo que se puede renderizar en varios formatos de salida.

18. ¿Cómo se puede crear una visualización de mapa de calor de un DataFrame de Pandas usando Seaborn o Matplotlib, y cómo se interpreta el mapa de calor?

Para crear una visualización de mapa de calor de un DataFrame de Pandas, puedes usar la función heatmap() de Seaborn o la función imshow() de Matplotlib junto con la asignación de color apropiada. Con Seaborn, es sencillo: sns.heatmap(dataframe.corr(), annot=True, cmap='viridis') donde dataframe es tu DataFrame de Pandas, annot=True muestra los valores de correlación en cada celda, y cmap establece el esquema de color. Matplotlib requiere un poco más de configuración. Puedes usar plt.imshow(dataframe.corr(), cmap='viridis') seguido de la configuración de marcas y etiquetas para los ejes.

Interpretar el mapa de calor implica observar la intensidad del color. Cada celda representa la correlación (o cualquier otra métrica) entre dos variables. Los colores más oscuros o brillantes (dependiendo del mapa de color) indican correlaciones positivas o negativas más fuertes. annot=True ayuda a ver los valores directamente. Por ejemplo, una celda brillante podría sugerir una fuerte correlación positiva, mientras que una celda oscura sugiere una fuerte correlación negativa. Los valores cercanos a cero indican poca o ninguna correlación.

19. Describe cómo realizar un análisis de red usando Pandas y NetworkX, incluyendo la creación de un grafo a partir de un DataFrame y el cálculo de métricas de red.

Para realizar un análisis de red usando Pandas y NetworkX, normalmente se comienza con datos que representan las conexiones entre nodos, a menudo almacenados en un DataFrame de Pandas. Se puede crear un grafo usando networkx.from_pandas_edgelist(df, source='columna_que_contiene_el_nodo_fuente', target='columna_que_contiene_el_nodo_destino', edge_attr='columna_que_contiene_atributos_de_arista'). Después de crear el grafo, se pueden calcular varias métricas de red como la centralidad de grado (usando networkx.degree_centrality(grafo)), la centralidad de intermediación (usando networkx.betweenness_centrality(grafo)), y los caminos más cortos (usando networkx.shortest_path(grafo, source='nodo1', target='nodo2')).

Por ejemplo:

import pandas as pd import networkx as nx # DataFrame de ejemplo data = {'source': ['A', 'A', 'B', 'C'], 'target': ['B', 'C', 'C', 'D'], 'weight': [1, 2, 3, 4]} df = pd.DataFrame(data) # Crear grafo desde DataFrame G = nx.from_pandas_edgelist(df, source='source', target='target', edge_attr='weight') # Calcular centralidad de grado degree_centrality = nx.degree_centrality(G) print(f"Centralidad de Grado: {degree_centrality}")

20. ¿Cómo se usa la función Pandas qcut() para discretizar una variable continua en cuantiles y cómo se manejan los casos extremos con valores duplicados?

La función Pandas qcut() discretiza una variable continua en cubos de igual tamaño basados en el rango o cuantiles de la muestra. Toma los datos de la serie o de tipo array y el número de cuantiles (q) como entrada. qcut() devuelve un objeto categórico o una serie cuyos valores son nombres/intervalos de categorías.

Manejar valores duplicados es importante. Por defecto, qcut() genera un DuplicateBoundError si los límites de los bins no son únicos. Para manejar esto, se usa el parámetro duplicates: 'raise' (por defecto) genera el error; 'drop' elimina los duplicados resultando en tamaños de bin desiguales. Por ejemplo:

import pandas as pd data = [1, 2, 2, 3, 4, 5] q = 4 # número deseado de cuantiles #Si duplicates='raise' y existen duplicados, generará un error #pd.qcut(data, q, duplicates='raise') #Si duplicates='drop', los límites duplicados serán eliminados. pd.qcut(data, q, duplicates='drop')

21. Explique cómo realizar un análisis geográfico usando Pandas y GeoPandas, incluyendo la lectura y escritura de datos geoespaciales y la realización de operaciones espaciales.

Pandas maneja datos tabulares, mientras que GeoPandas lo extiende para manejar datos geoespaciales. Primero, instálalos: pip install pandas geopandas. Para leer datos geoespaciales (por ejemplo, Shapefile, GeoJSON), use geopandas.read_file('ruta/al/archivo.shp'). Esto crea un GeoDataFrame, similar a un DataFrame de Pandas pero con una columna 'geometry' que contiene datos espaciales (puntos, líneas, polígonos). La escritura es similar: gdf.to_file('ruta/al/salida.geojson', driver='GeoJSON').

Las operaciones espaciales incluyen:

• Uniones espaciales: geopandas.sjoin(gdf1, gdf2, how='inner', op='intersects') combina datos basados en relaciones espaciales.
• Análisis de proximidad: Use gdf.distance(other_geometry) para encontrar distancias entre geometrías. Es posible que deba reproyectar los datos a un sistema de referencia de coordenadas (CRS) apropiado utilizando gdf.to_crs('EPSG:4326') antes de realizar operaciones espaciales para garantizar la precisión, particularmente para los cálculos de distancia.

22. ¿Cómo se puede crear un panel de control usando Pandas y Plotly o Bokeh, incluyendo widgets interactivos y actualizaciones de datos?

Para crear un panel de control con Pandas, Plotly/Bokeh y widgets interactivos, normalmente usaría un framework como Dash (para Plotly) o el servidor Bokeh. Comenzaría cargando y procesando sus datos con Pandas. Luego, use Plotly o Bokeh para crear gráficos iniciales. A continuación, integre widgets interactivos (desplegables, deslizadores, etc.) utilizando los componentes del framework elegido. Estos widgets activarían retrollamadas que actualizan los gráficos en función de las selecciones del usuario.

Por ejemplo, usando Dash:

1. Crear un DataFrame de Pandas.
2. Crear una figura de Plotly a partir del DataFrame.
3. Definir el diseño de Dash con dcc.Graph (para el gráfico) y dcc.Dropdown (para el widget).
4. Escribir una función de callback que actualice la propiedad figure de dcc.Graph basada en la propiedad value de dcc.Dropdown. Esto implica filtrar/transformar el DataFrame de Pandas basado en la selección del dropdown y recrear la figura de Plotly.

23. Describa cómo realizar un análisis de texto usando Pandas y NLTK o SpaCy, incluyendo tokenización, stemming y análisis de sentimiento.

El análisis de texto con Pandas, NLTK/SpaCy implica varios pasos. Primero, cargar los datos de texto en un DataFrame de Pandas. Luego, limpiar el texto eliminando la puntuación y convirtiéndolo a minúsculas. A continuación, realizar la tokenización utilizando word_tokenize de NLTK o el tokenizer de SpaCy. Para el stemming, usar PorterStemmer o LancasterStemmer de NLTK para reducir las palabras a su forma raíz. Para el análisis de sentimiento, usar VADER (Valence Aware Dictionary and sEntiment Reasoner) de NLTK o la integración de SpaCy con bibliotecas como TextBlob. Las puntuaciones del análisis de sentimiento se pueden agregar como nuevas columnas en el DataFrame de Pandas.

Ejemplo:

import pandas as pd import nltk from nltk.sentiment.vader import SentimentIntensityAnalyzer nltk.download('vader_lexicon') data = {'text': ['¡Esta es una gran película!', 'Odio este producto.']} df = pd.DataFrame(data) sid = SentimentIntensityAnalyzer() df['sentiment_scores'] = df['text'].apply(lambda text: sid.polarity_scores(text)) print(df)

24. ¿Cómo se utiliza el tipo de datos Categorical de Pandas para representar datos ordinales o nominales, y en qué se diferencia de una columna de objeto estándar?

El tipo de datos Categorical de Pandas se utiliza para representar datos que tienen un número fijo de valores posibles (categorías). Almacena eficientemente cadenas (u otros objetos) asignándolos a códigos enteros, especialmente útil para columnas con muchos valores repetidos.

Para datos ordinales, puedes especificar el parámetro ordered=True, lo que le indica a Pandas que las categorías tienen un orden significativo. Esto permite comparaciones como data['columna'] > 'categoría_a' si las categorías están ordenadas. Para datos nominales, ordered=False (el valor predeterminado), lo que implica que no hay un orden inherente. Las columnas Categorical difieren de las columnas de objeto estándar principalmente en el uso de memoria y las operaciones admitidas. Categorical usa menos memoria y operaciones como .describe() están optimizadas. Las columnas de objeto almacenan cada valor de cadena individualmente, consumiendo más memoria, particularmente cuando hay valores repetidos presentes. Usar Categorical puede mejorar el rendimiento y reducir el uso de memoria cuando se trata de datos con un conjunto limitado de valores.

25. Explique cómo realizar un análisis de supervivencia utilizando Pandas y Lifelines, incluyendo la estimación de curvas de supervivencia y la comparación de diferentes grupos.

El análisis de supervivencia examina el tiempo hasta que ocurre un evento. Usando Pandas y Lifelines en Python, puedes realizar este análisis de manera efectiva. Primero, carga tus datos en un DataFrame de Pandas, asegurándote de tener columnas para 'tiempo' (tiempo hasta el evento o censura) y 'evento' (1 si el evento ocurrió, 0 si está censurado). Usa KaplanMeierFitter de Lifelines para estimar la función de supervivencia. Ajusta el modelo con kmf.fit(durations = df['tiempo'], event_observed = df['evento']). Para trazar la curva de supervivencia, usa kmf.plot_survival_function().

Para comparar diferentes grupos, como tratamiento vs. control, crea ajustes de Kaplan-Meier separados para cada grupo. Por ejemplo, filtra el DataFrame para cada grupo, ajusta un KaplanMeierFitter a cada uno, y luego traza sus funciones de supervivencia en los mismos ejes para comparar visualmente. Estadísticamente, puedes comparar los grupos usando una prueba log-rank proporcionada en Lifelines utilizando logrank_test(durations_A, durations_B, event_observed_A, event_observed_B). Esta prueba evalúa si existe una diferencia estadísticamente significativa entre las curvas de supervivencia de los dos grupos. El valor p indicará la significancia, es decir, si p < 0.05 (generalmente) las curvas de supervivencia de los grupos son estadísticamente diferentes.

26. ¿Cómo puedes crear un sistema de recomendación usando Pandas y scikit-learn, incluyendo filtrado colaborativo y filtrado basado en contenido?

Puedes construir un sistema de recomendación básico usando Pandas y scikit-learn combinando filtrado colaborativo y basado en contenido. Para el filtrado colaborativo, usarías Pandas para crear una matriz de interacción usuario-ítem (por ejemplo, calificaciones de usuarios para ítems). pairwise_distances de Scikit-learn puede entonces calcular similitudes de usuarios o ítems basadas en esta matriz. Las recomendaciones se generan encontrando usuarios o ítems similares. Aquí hay un ejemplo:

import pandas as pd from sklearn.metrics.pairwise import cosine_similarity # matriz usuario-elemento (usuarios x elementos) calificaciones = pd.DataFrame({'user_id': [1, 1, 2, 2, 3, 3], 'item_id': [1, 2, 1, 3, 2, 3], 'rating': [5, 3, 4, 2, 1, 5]}) matriz_usuario_elemento = calificaciones.pivot_table(index='user_id', columns='item_id', values='rating').fillna(0) similitud_usuario = cosine_similarity(matriz_usuario_elemento) similitud_usuario_df = pd.DataFrame(similitud_usuario, index=matriz_usuario_elemento.index, columns=matriz_usuario_elemento.index) # Para obtener la similitud de elementos similitud_elemento = cosine_similarity(matriz_usuario_elemento.T) similitud_elemento_df = pd.DataFrame(similitud_elemento, index=matriz_usuario_elemento.columns, columns=matriz_usuario_elemento.columns)

Para el filtrado basado en contenido, Pandas ayuda a gestionar las características de los elementos (por ejemplo, género, descripción). TfidfVectorizer de Scikit-learn convierte las características de texto en representaciones numéricas. cosine_similarity luego determina las similitudes de los elementos basadas en los vectores de características. Las recomendaciones son elementos similares a los que el usuario ha gustado. Un sistema híbrido combina ambos enfoques. También puede usar los modelos de regresión de scikit-learn para predecir las calificaciones de los elementos basándose en las características del usuario y del elemento, ofreciendo otro enfoque para las recomendaciones.

27. Describa cómo realizar una previsión de series temporales utilizando Pandas y Prophet o ARIMA, incluyendo el ajuste y la evaluación del modelo.

Pronóstico de series temporales con Pandas y Prophet o ARIMA implica la preparación de datos, el ajuste del modelo y la evaluación. Primero, cargue sus datos de series temporales en un DataFrame de Pandas, asegurándose de que la columna de tiempo se establezca como el índice. Con Prophet, el DataFrame necesita dos columnas llamadas 'ds' (fecha y hora) e 'y' (el valor de la serie temporal). Para ARIMA, probablemente necesitará asegurar la estacionariedad mediante la diferenciación o transformaciones. Luego, cree una instancia y ajuste el modelo. Para Prophet: model = Prophet(); model.fit(df). Para ARIMA (después de determinar los órdenes p, d, q): model = ARIMA(df['value'], order=(p,d,q)); model_fit = model.fit().

A continuación, genere pronósticos. Con Prophet, cree un DataFrame futuro usando model.make_future_dataframe(periods=n) y prediga usando forecast = model.predict(future). Para ARIMA, use model_fit.forecast(steps=n). Finalmente, evalúe el modelo. Para ambos, calcule métricas de error como el Error Absoluto Medio (MAE), el Error Cuadrático Medio (MSE) o la Raíz del Error Cuadrático Medio (RMSE) comparando los valores predichos con los valores reales de un conjunto de validación reservado. También puede visualizar el pronóstico contra los datos reales para evaluar el rendimiento. Por ejemplo, from sklearn.metrics import mean_squared_error; mse = mean_squared_error(actual, predicted).

28. ¿Cómo se utiliza el objeto Index de Pandas para optimizar el acceso y filtrado de datos, y en qué se diferencia de una columna estándar?

El objeto Index de Pandas es crucial para optimizar el acceso a los datos porque permite búsquedas rápidas basadas en etiquetas. A diferencia de las columnas estándar, el Index está diseñado para una búsqueda y recuperación eficientes; Pandas lo utiliza para alinear datos durante las operaciones y seleccionar rápidamente subconjuntos de datos. Al filtrar, el uso del Index puede ser significativamente más rápido que filtrar en una columna normal, especialmente para conjuntos de datos grandes, ya que el Index a menudo se implementa utilizando estructuras de datos optimizadas como tablas hash o árboles B.

Las diferencias clave incluyen:

• Unicidad e Inmutabilidad: Los valores del Index suelen ser (aunque no siempre) únicos e inmutables, lo que garantiza búsquedas fiables.
• Alineación de datos: Se utiliza para la alineación automática de datos durante las operaciones (por ejemplo, uniones de DataFrame).
• Búsquedas rápidas: Permite la recuperación de datos altamente optimizada por etiqueta en comparación con la iteración a través de una columna. Por ejemplo, acceder a df.loc[index_label] es mucho más rápido que df[df['columna'] == valor] cuando index_label está en el Index.

29. Explique cómo realizar la detección de anomalías utilizando Pandas e isolation forest o one-class SVM, incluyendo el entrenamiento del modelo y la selección del umbral.

La detección de anomalías utilizando Pandas e Isolation Forest (o One-Class SVM) implica varios pasos. Primero, cargue sus datos en un DataFrame de Pandas. Luego, preprocese los datos escalando las características numéricas utilizando StandardScaler o MinMaxScaler de sklearn.preprocessing. A continuación, entrene su modelo de detección de anomalías, por ejemplo, IsolationForest de sklearn.ensemble o OneClassSVM de sklearn.svm, utilizando los datos preprocesados. Para Isolation Forest: model = IsolationForest(contamination=0.05); model.fit(data). Para One-Class SVM: model = OneClassSVM(nu=0.05); model.fit(data). El parámetro contamination (para Isolation Forest) y el parámetro nu (para One-Class SVM) estiman la proporción de valores atípicos en el conjunto de datos.

Para determinar el umbral de anomalía, prediga las puntuaciones de anomalía (Isolation Forest) o los valores de la función de decisión (One-Class SVM) para sus datos de entrenamiento. Para Isolation Forest, las anomalías tienen puntuaciones más bajas. Para One-Class SVM, las anomalías tienen valores de función de decisión más bajos. Luego, decida un umbral para separar los puntos de datos normales y anómalos. Un enfoque común es seleccionar un percentil de las puntuaciones de anomalía como umbral. Por ejemplo, podría usar el percentil 5 de las puntuaciones de anomalía como su umbral, clasificando cualquier punto de datos con una puntuación de anomalía por debajo de este umbral como una anomalía. Específicamente, scores = model.decision_function(data); threshold = np.percentile(scores, 5). Finalmente, use el modelo entrenado y el umbral seleccionado para clasificar los nuevos puntos de datos como normales o anómalos.

30. ¿Cómo se puede crear una tubería de datos utilizando Pandas y Dask o Spark, incluyendo la carga, transformación y almacenamiento de datos?

Una tubería de datos que utiliza Pandas, Dask y Spark implica varias etapas: cargar, transformar y almacenar datos. Pandas es adecuado para conjuntos de datos más pequeños y análisis exploratorios. Para conjuntos de datos más grandes, se puede usar Dask o Spark para el procesamiento paralelo. Aquí hay un esquema conceptual:

• Carga de datos: Cargar datos de diversas fuentes (CSV, bases de datos, etc.) usando Pandas (por ejemplo, pd.read_csv()). Para conjuntos de datos más grandes, usar dd.read_csv() de Dask o spark.read.csv() de Spark. Dask y Spark pueden leer datos en paralelo.
• Transformación de datos:
  • Pandas: Usar DataFrames de Pandas para limpiar, filtrar y diseñar características (por ejemplo, df.dropna(), df['new_column'] = ...).
  • Dask: Usar DataFrames de Dask (creados con dd.from_pandas()) para operaciones similares en conjuntos de datos mayores que la memoria. Dask paralelizará estas operaciones.
  • Spark: Usar DataFrames de Spark y transformaciones tipo SQL (por ejemplo, df.select(), df.filter(), df.withColumn()). Spark usa evaluación perezosa y ejecución de consultas optimizada.
• Almacenamiento de datos: Almacenar los datos transformados en una ubicación de destino (por ejemplo, CSV, Parquet, base de datos). Usar df.to_csv() para Pandas. Para Dask, usar dd.to_parquet(). Para Spark usar df.write.parquet(). Parquet es a menudo una buena opción para conjuntos de datos grandes debido a su formato de almacenamiento columnar.

Por ejemplo, usando Dask:

import pandas as pd import dask.dataframe as dd

Cargar datos usando pandas

df_pandas = pd.read_csv('large_data.csv')

Crear DataFrame Dask desde DataFrame Pandas

df_dask = dd.from_pandas(df_pandas, npartitions=4) # Determinar tamaño de partición razonable

Transformar los datos (ejemplo: filtrado)

df_transformed = df_dask[df_dask['nombre_columna'] > 10]

Guardar los datos transformados

df_transformed.to_parquet('transformed_data.parquet', single_file=True)

Recuerde elegir Dask o Spark dependiendo de sus requerimientos de escala e infraestructura. Dask es a menudo más fácil de integrar con los flujos de trabajo existentes de Pandas, mientras que Spark está diseñado para la computación distribuida a gran escala.

Preguntas de entrevista avanzadas sobre Pandas

1. ¿Cómo puede optimizar el código de Pandas para la velocidad y el uso de memoria cuando se trata de conjuntos de datos grandes?

Al optimizar el código de Pandas para conjuntos de datos grandes, considere estas estrategias:

• Usa tipos de datos apropiados: Emplea tipos numéricos más pequeños (por ejemplo, int16 en lugar de int64) y el tipo de datos category para columnas con pocos valores únicos. df['columna'] = df['columna'].astype('category')
• Fragmentación: Lee los datos en fragmentos más pequeños usando pd.read_csv(..., chunksize=...) para procesar los datos iterativamente.
• Vectorización: Utiliza las operaciones vectorizadas integradas de Pandas en lugar de iterar a través de las filas. df['nueva_columna'] = df['columna1'] + df['columna2'] es mucho más rápido que iterar.
• Evita copias innecesarias: Usa inplace=True donde sea apropiado para modificar los DataFrames directamente. Ten en cuenta la indexación encadenada que a menudo crea copias. En su lugar, usa .loc para la asignación directa. df.loc[row_indexer, col_indexer] = valor
• Estructuras de datos dispersas: Cuando los datos contienen muchos ceros, considera el uso de estructuras de datos dispersas para reducir el consumo de memoria.
• Formatos de archivo optimizados: Utiliza formatos de archivo que sean más eficientes que CSV como Parquet o Feather.
• Numba/Cython: Para operaciones computacionalmente intensivas, usa Numba o Cython para compilar código Python a código de máquina para mejoras significativas de velocidad.

2. Explique la diferencia entre .loc e .iloc en Pandas, y cuándo usar cada uno.

.loc e .iloc se utilizan ambos para seleccionar datos en DataFrames de Pandas, pero difieren en cómo hacen referencia a los datos.

.loc utiliza la indexación basada en etiquetas, lo que significa que se seleccionan datos basándose en las etiquetas (nombres) de las filas y columnas. .iloc utiliza la indexación basada en enteros, lo que significa que se seleccionan datos basándose en las posiciones enteras de las filas y columnas. Por ejemplo, df.loc['etiqueta_fila', 'etiqueta_columna'] selecciona el elemento en la etiqueta especificada, mientras que df.iloc[posición_fila, posición_columna] selecciona el elemento en la posición entera especificada. Use .loc cuando conoce las etiquetas y desea seleccionar en función de ellas. Use .iloc cuando desee seleccionar por índice numérico independientemente de las etiquetas, lo cual es útil para iterar a través de los datos sin tener en cuenta los nombres de filas/columnas.

3. Describa cómo manejar los datos faltantes en Pandas, incluyendo las técnicas de imputación.

Manejar los datos faltantes en Pandas a menudo implica identificar y luego eliminar o imputar los valores faltantes, representados como NaN. df.isnull() y df.notnull() ayudan a identificar los valores faltantes. df.dropna() elimina filas o columnas con datos faltantes. El parámetro axis controla si se eliminan filas (axis=0) o columnas (axis=1), y how='any' (predeterminado) elimina si falta algún valor, mientras que how='all' elimina solo si faltan todos los valores. thresh puede especificar el número mínimo de valores no faltantes para mantener una fila/columna. Para la imputación, df.fillna() reemplaza los valores faltantes. Las técnicas de imputación comunes incluyen rellenar con un valor constante, la media, la mediana o la moda de la columna. Ejemplo: df['nombre_columna'].fillna(df['nombre_columna'].mean(), inplace=True) reemplaza los valores NaN en nombre_columna con la media de la columna.

4. ¿Cómo realizaría una ordenación multi-índice en Pandas y por qué podría usarla?

Para realizar una ordenación multi-índice en Pandas, usaría el método sort_index() en un DataFrame o Serie que tenga un MultiIndex. Puede especificar los niveles por los que desea ordenar utilizando el parámetro level, que acepta un nombre o número de nivel (o una lista de ellos). El parámetro ascending controla el orden de clasificación para cada nivel; puede proporcionar un booleano o una lista de booleanos correspondientes a cada nivel que está ordenando.

Puede utilizar una ordenación multi-índice cuando sus datos tienen una estructura jerárquica. Por ejemplo, podría tener datos de ventas indexados por región y luego por categoría de producto. Ordenar por región y luego por categoría de producto le permite analizar fácilmente el rendimiento de las ventas dentro de cada región y comparar las ventas de productos en diferentes regiones. Facilita tareas como la agrupación, la agregación y la creación de visualizaciones significativas.

5. Explique cómo usar `pd.Grouper` para la agregación personalizada basada en el tiempo.

`pd.Grouper` permite la agrupación flexible basada en el tiempo en pandas, particularmente útil cuando el remuestreo no es suficiente. En lugar de depender de una frecuencia fija como 'D' (diaria), `pd.Grouper` le permite definir intervalos de agrupación personalizados o basar los grupos en columnas específicas. Normalmente, lo utiliza dentro de `groupby()` para definir cómo deben agregarse las filas.

Por ejemplo, puede agrupar datos cada 5 días usando pd.Grouper(key='columna_fecha', freq='5D') o agrupar por semanas a partir del miércoles usando pd.Grouper(key='columna_fecha', freq='W-WED'). El argumento key especifica la columna por la que agrupar, y freq establece la frecuencia de agrupación. También puede agrupar por los valores de una columna específica con pd.Grouper(column='columna_categoría') que agrupará por los valores únicos encontrados en columna_categoría en lugar del índice de fecha y hora. Luego, seguiría esto con una función de agregación como sum(), mean(), etc.

6. ¿Cómo se combinan eficientemente múltiples DataFrames de Pandas con diferentes estructuras?

La combinación eficiente de DataFrames de Pandas con diferentes estructuras a menudo implica comprender los requisitos específicos y elegir el método apropiado.

Para una concatenación simple, pd.concat() es un buen punto de partida. Puede manejar DataFrames con diferentes columnas y estructuras de índice usando los parámetros join y axis. Para manejar uniones basadas en columnas comunes, la función pd.merge() (o df.merge()) es útil. Los parámetros clave son how (especificando el tipo de unión - 'inner', 'outer', 'left', 'right'), on (especificando la(s) columna(s) para unir), left_on y right_on (cuando las columnas de unión tienen nombres diferentes). Cuando las columnas no coinciden exactamente, considere renombrar usando df.rename() antes de fusionar. Combinar pd.concat() y pd.merge() puede resolver escenarios complejos.

7. Explica cómo aplicar una función personalizada a un DataFrame de Pandas que depende de múltiples columnas usando apply.

Para aplicar una función personalizada a un DataFrame de Pandas que depende de múltiples columnas usando apply, necesitas pasar axis=1 al método apply. Esto asegura que la función se aplique por filas, permitiendo el acceso a múltiples columnas dentro de cada fila. Dentro de la función personalizada, puedes acceder a los valores de diferentes columnas referenciando los nombres de las columnas como atributos de la fila.

Por ejemplo:

def mi_funcion_personalizada(fila): columna1 = fila['nombre_columna_1'] columna2 = fila['nombre_columna_2'] # Tu lógica aquí usando columna1 y columna2 return columna1 + columna2 df['nueva_columna'] = df.apply(mi_funcion_personalizada, axis=1)

En este ejemplo, mi_funcion_personalizada toma una fila como entrada, accede a 'nombre_columna_1' y 'nombre_columna_2', realiza alguna operación y devuelve un valor que luego se almacena en 'nueva_columna'.

8. Describe cómo realizar un cálculo de ventana móvil en una Serie o DataFrame de Pandas.

Para realizar un cálculo de ventana móvil en una Serie o DataFrame de Pandas, se utiliza el método .rolling(). Este método crea un objeto Rolling, que luego se puede usar para aplicar varias funciones de agregación.

Por ejemplo:

import pandas as pd # Ejemplo de Serie s = pd.Series([1, 2, 3, 4, 5]) # Ventana móvil de tamaño 3, calculando la media rolling_mean = s.rolling(window=3).mean() print(rolling_mean)

Los parámetros clave incluyen window (el tamaño de la ventana móvil), min_periods (el número mínimo de observaciones requeridas para tener un valor) y center (si la ventana está centrada). Las funciones de agregación comunes utilizadas después de .rolling() son .mean(), .sum(), .std() y .apply() para funciones personalizadas.

9. ¿Cómo se pueden crear tablas dinámicas y tabulaciones cruzadas utilizando Pandas y cuáles son sus diferencias?

Pandas ofrece pivot_table() y crosstab() para crear tablas dinámicas y tabulaciones cruzadas. pivot_table() es una función de propósito general que agrega datos basados en el índice, columnas y valores especificados, utilizando una función de agregación dada (como media, suma, etc.). Puede manejar datos numéricos y categóricos, y los valores faltantes pueden ser gestionados.

crosstab() está específicamente diseñado para calcular una tabla de frecuencia (tabulación cruzada) entre dos o más variables categóricas. Muestra la distribución de frecuencia de diferentes combinaciones de categorías. Si bien pivot_table necesita una función de agregación explícita para sus 'valores', crosstab esencialmente calcula los conteos (frecuencias) por defecto. Por ejemplo:

import pandas as pd data = {'A': ['foo', 'foo', 'bar', 'bar', 'foo', 'bar'], 'B': ['one', 'one', 'two', 'one', 'two', 'two'], 'C': [1, 2, 3, 4, 5, 6]} df = pd.DataFrame(data) pivot_table = pd.pivot_table(df, values='C', index='A', columns='B', aggfunc='sum') crosstab = pd.crosstab(df['A'], df['B']) print(pivot_table) print(crosstab)

10. Explique cómo usar Pandas con pipelines de scikit-learn para el preprocesamiento y modelado de datos.

Los DataFrames de Pandas se pueden integrar directamente en los pipelines de scikit-learn. Esto es útil porque los transformadores y estimadores de scikit-learn están diseñados para funcionar con arrays de NumPy. Pandas proporciona estructuras de datos y operaciones que a menudo son necesarias durante el preprocesamiento de datos. Puede usar ColumnTransformer para aplicar diferentes pasos de preprocesamiento a diferentes columnas de su DataFrame y luego pasar el resultado a un modelo de scikit-learn.

Aquí hay un ejemplo básico:

import pandas as pd from sklearn.compose import ColumnTransformer from sklearn.preprocessing import StandardScaler, OneHotEncoder from sklearn.linear_model import LogisticRegression from sklearn.pipeline import Pipeline # DataFrame de ejemplo data = {'numerical': [1, 2, 3, 4, 5], 'categorical': ['A', 'B', 'A', 'C', 'B'], 'target': [0, 1, 0, 1, 0]} df = pd.DataFrame(data) # Definir pasos de preprocesamiento para características numéricas y categóricas características_numéricas = ['numerical'] transformador_numérico = Pipeline(steps=[('scaler', StandardScaler())]) características_categóricas = ['categorical'] transformador_categórico = Pipeline(steps=[('onehot', OneHotEncoder(handle_unknown='ignore'))]) # Crear un ColumnTransformer preprocesador = ColumnTransformer(transformers=[('num', transformador_numérico, características_numéricas),('cat', transformador_categórico, características_categóricas)]) # Crear la tubería modelo = Pipeline(steps=[('preprocessor', preprocesador),('classifier', LogisticRegression())]) # Ajustar el modelo X = df.drop('target', axis=1) y = df['target'] modelo.fit(X, y) # Hacer predicciones predicciones = model.predict(X) print(predicciones)

11. ¿Cómo convertirías un DataFrame de Pandas a un formato de matriz dispersa y cuándo es esto útil?

Puedes convertir un DataFrame de Pandas a un formato de matriz dispersa utilizando la biblioteca scipy.sparse en conjunto con los métodos de DataFrame. El enfoque común implica primero convertir el DataFrame a un array de NumPy y luego usar un constructor de matriz dispersa como csc_matrix (Columna Dispersa Comprimida) o csr_matrix (Fila Dispersa Comprimida). Por ejemplo:

import pandas as pd import scipy.sparse as sparse data = {'col1': [1, 0, 0, 2, 0], 'col2': [0, 0, 3, 0, 0], 'col3': [0, 4, 0, 0, 5]} df = pd.DataFrame(data) sparse_matrix = sparse.csc_matrix(df.values)

Esta conversión es particularmente útil cuando se trata de DataFrames que contienen un gran número de valores cero o faltantes. Las matrices dispersas almacenan eficientemente solo los elementos distintos de cero, lo que reduce significativamente el uso de memoria y el costo computacional para operaciones como la multiplicación de matrices o la resolución de sistemas lineales. Esto es común en escenarios como sistemas de recomendación (interacciones usuario-elemento), análisis de texto (matrices término-documento) o análisis de redes donde la mayoría de las entradas son cero.

12. Describe cómo escribir un DataFrame de Pandas en una base de datos usando SQLAlchemy y manejar problemas potenciales.

Para escribir un DataFrame de Pandas en una base de datos usando SQLAlchemy, puedes usar el método to_sql() proporcionado por Pandas. Este método requiere un objeto de motor SQLAlchemy para establecer la conexión. Por ejemplo:

import pandas as pd from sqlalchemy import create_engine # Crea un motor SQLAlchemy engine = create_engine('dialect+driver://user:password@host:port/database') # Ejemplo DataFrame data = {'col1': [1, 2], 'col2': [3, 4]} df = pd.DataFrame(data) # Escribe el DataFrame en la base de datos df.to_sql('nombre_tabla', engine, if_exists='replace', index=False)

Los problemas y soluciones potenciales incluyen:

• La tabla ya existe: Use el parámetro if_exists ('fail', 'replace' o 'append') para manejar casos donde la tabla ya existe.
• Inconsistencias de tipos de datos: Asegúrese de que los tipos de datos en el DataFrame coincidan con el esquema de la tabla de la base de datos. Puede que necesite convertir columnas usando .astype() antes de escribir.
• Inyección SQL: Use consultas parametrizadas (manejadas automáticamente por SQLAlchemy) para evitar vulnerabilidades de inyección SQL.
• DataFrames grandes: Para DataFrames muy grandes, considere escribir en fragmentos usando el parámetro chunksize en to_sql() para evitar problemas de memoria. También, usar method='multi' puede mejorar el rendimiento.
• Errores de conexión: Maneje posibles errores de conexión a la base de datos usando bloques try...except.

13. ¿Cómo puede usar Pandas para leer y procesar datos de diferentes formatos de archivo (por ejemplo, JSON, CSV, Excel) con análisis personalizado?

Pandas ofrece varias funciones para leer datos de varios formatos de archivo, incluyendo read_csv, read_excel y read_json. Para el análisis personalizado, puede utilizar parámetros dentro de estas funciones o realizar un post-procesamiento.

• CSV: Use read_csv con argumentos como delimiter, header, names, dtype, parse_dates, y un date_parser personalizado. Por ejemplo:

import pandas as pd df = pd.read_csv('data.csv', delimiter=';', header=0, dtype={'col1': str, 'col2': int})

• Excel: Usa read_excel y especifica sheet_name, header, names, y dtype. También puedes usar converters para aplicar funciones de análisis personalizadas a columnas específicas.
• JSON: Para JSON, read_json ofrece opciones como orient (que especifica la estructura JSON), dtype, y convert_dates. Es posible que también necesites pre-procesar los datos JSON antes de cargarlos en Pandas si están muy anidados o tienen una estructura compleja.

Después de leer los datos, puedes aplicar un procesamiento personalizado adicional usando funciones de Pandas como apply, map, o crear funciones personalizadas para limpiar o transformar los datos según sea necesario.

14. Explica cómo usar pd.merge para realizar diferentes tipos de joins (inner, outer, left, right) con ejemplos detallados.

pd.merge en pandas es una función poderosa para combinar DataFrames basados en columnas comunes. El argumento how controla el tipo de join:

• Inner Join (how='inner'): Retorna solo las filas donde la clave de join existe en ambos DataFrames. Es el comportamiento predeterminado. Ejemplo:

import pandas as pd df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value1': [1, 2, 3, 4]}) df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value2': [5, 6, 7, 8]}) merged_df = pd.merge(df1, df2, on='key', how='inner') # El resultado contiene filas con la clave B y D.

• Outer Join (how='outer'): Retorna todas las filas de ambos DataFrames, rellenando los valores faltantes (NaN) donde la clave no existe en uno de los DataFrames.

merged_df = pd.merge(df1, df2, on='key', how='outer') # El resultado contiene filas de A a F; los valores faltantes son NaN

• Left Join (how='left'): Retorna todas las filas del DataFrame izquierdo (df1 en este caso), y las filas coincidentes del DataFrame derecho (df2). Si no hay coincidencia en el DataFrame derecho, los valores faltantes se rellenan con NaN.

merged_df = pd.merge(df1, df2, on='key', how='left') #Se incluyen todas las filas de df1

• Unión Derecha (how='right'): Devuelve todas las filas del DataFrame de la derecha (df2), y las filas coincidentes del DataFrame de la izquierda (df1). Si no hay coincidencia en el DataFrame de la izquierda, los valores faltantes se rellenan con NaN.

merged_df = pd.merge(df1, df2, on='key', how='right') #Se incluyen todas las filas de df2

El argumento on especifica la columna para la unión. También puedes usar left_on y right_on si las columnas de unión tienen nombres diferentes en los dos DataFrames.

15. Describe cómo implementar una función de agregación personalizada usando groupby y agg en Pandas.

Para implementar una función de agregación personalizada con groupby y agg en Pandas, primero defines tu función personalizada. Esta función debe tomar una Serie de Pandas como entrada (que representa un grupo de datos) y devolver un único valor agregado. Luego, usas el método groupby() para agrupar tu DataFrame por las columnas deseadas. Finalmente, aplicas el método agg(), pasando tu función personalizada como argumento. Pandas luego aplicará tu función a cada grupo y devolverá un DataFrame con los resultados agregados.

16. ¿Cómo se manejan los datos categóricos en Pandas, incluyendo la codificación one-hot y mapeos personalizados?

Pandas proporciona varias formas de manejar datos categóricos. Puedes convertir una columna al tipo de dato category usando astype('category'). Esto es eficiente en memoria y permite operaciones categóricas. Para la codificación one-hot, se usa comúnmente pd.get_dummies(). Transforma las columnas categóricas en columnas numéricas, donde cada categoría se convierte en una nueva columna con valores binarios (0 o 1). Ejemplo: pd.get_dummies(df, columns=['columna_categorica']).

Para mapeos personalizados, puedes usar los métodos .map() o .replace(). .map() aplica un diccionario o función para mapear valores. .replace() puede sustituir directamente valores categóricos específicos con representaciones numéricas o de cadena deseadas. Por ejemplo: df['columna_categorica'].map({'categoria1': 1, 'categoria2': 2}) o df['columna_categorica'].replace({'categoria1': 'nuevo_valor'}). Estos métodos te permiten codificar variables categóricas basándote en el conocimiento del dominio o en requisitos específicos.

17. Explica cómo usar `pd.cut` y `pd.qcut` para agrupar variables continuas.

pd.cut y pd.qcut se usan ambos para agrupar variables continuas en pandas, pero difieren en cómo definen los grupos.

pd.cut define intervalos basados en anchos iguales. Usted proporciona el número de bins o los bordes de los bins, y esto divide el rango de datos en los intervalos especificados. Por ejemplo, pd.cut(datos, bins=4) creará 4 bins de ancho igual a lo largo del rango de sus datos. pd.qcut, por otro lado, define los bins basados en cuantiles. Esto significa que cada bin contendrá aproximadamente el mismo número de puntos de datos. Usted especifica el número de cuantiles (bins), y pd.qcut determina los bordes de los bins de tal manera que cada bin tenga (aproximadamente) una frecuencia igual. Por ejemplo, pd.qcut(datos, q=4) dividirá los datos en cuartiles, con cada cuartil que contenga aproximadamente el 25% de los datos. Use pd.cut cuando quiera bins de igual tamaño y pd.qcut cuando quiera que cada bin contenga un número similar de observaciones incluso si los tamaños de los bins varían.

18. ¿Cómo depurarías problemas de rendimiento en el código de Pandas?

Para depurar problemas de rendimiento en el código de Pandas, comenzaría por la creación de perfiles. Usaría herramientas como cProfile o %prun en los cuadernos de Jupyter para identificar las partes más lentas del código. Luego, me centraría en optimizar esas secciones específicas.

Aquí hay algunas técnicas comunes de optimización:

• Vectorización: Utilice las funciones integradas de Pandas y evite los bucles explícitos (for, while) siempre que sea posible. Las funciones de Pandas están optimizadas para operaciones vectorizadas.
• Tipos de datos: Asegúrese de utilizar los tipos de datos más eficientes (por ejemplo, int32 en lugar de int64 si el rango lo permite, tipo category para columnas de cadena repetitivas).
• Evite apply: apply puede ser lento. Intente utilizar operaciones vectorizadas o np.vectorize como alternativas.
• Indexación: Utilice la indexación adecuada para una selección y filtrado de datos eficientes. Considere establecer un índice si realiza búsquedas frecuentes en una columna específica.
• Fragmentación: Para conjuntos de datos grandes, procese los datos en fragmentos más pequeños utilizando el parámetro chunksize en read_csv.
• Consulta/Evaluar: Utilice query() y eval() para un filtrado booleano y cálculos más rápidos, especialmente con conjuntos de datos más grandes.
• Inspeccionar DataFrames: Busque problemas de uso de memoria utilizando df.info(memory_usage='deep'). Mire los dtypes.

También usaría timeit para medir el tiempo de ejecución de diferentes enfoques para ver cuál funciona mejor.

import pandas as pd import timeit def slow_method(df): return df['A'].apply(lambda x: x * 2) def fast_method(df): return df['A'] * 2 df = pd.DataFrame({'A': range(100000)}) print("Método lento:", timeit.timeit(lambda: slow_method(df), number=10)) print("Método rápido:", timeit.timeit(lambda: fast_method(df), number=10))

19. Describa cómo implementar un análisis de series temporales utilizando Pandas, incluyendo el remuestreo y el desplazamiento.

Pandas sobresale en el análisis de series temporales. Primero, asegúrese de que sus datos tengan un DatetimeIndex. Luego, el remuestreo le permite cambiar la frecuencia de sus datos (por ejemplo, diario a mensual). Use .resample('M') para el remuestreo mensual, seguido de una función de agregación como .mean() o .sum(). Por ejemplo, df.resample('M')['value'].mean() calcula el promedio mensual de la columna 'valor'. Para desplazar datos, use .shift(periods=n). Esto mueve los datos hacia adelante o hacia atrás en el tiempo por n períodos. Por ejemplo, df['value'].shift(1) desplaza la columna 'valor' un período hacia adelante, creando un rezago. Esto es útil para calcular diferencias o cambios porcentuales a lo largo del tiempo.

Específicamente:

• Remuestreo: df.resample('D')['value'].sum() (suma diaria)
• Desplazamiento: df['shifted_value'] = df['value'].shift(7) (desplazar por 7 períodos).

El remuestreo y el desplazamiento combinados se utilizan en muchos análisis financieros, como la creación de promedios móviles. Por ejemplo, el remuestreo a frecuencia semanal, la búsqueda del precio semanal promedio de un activo y luego el desplazamiento de esos datos para comparar los precios semanales actuales con las semanas pasadas.

20. ¿Cómo se puede crear una nueva columna en un DataFrame de Pandas en función de condiciones complejas aplicadas a otras columnas?

Puede crear una nueva columna en un DataFrame de Pandas en función de condiciones complejas utilizando varios métodos. El enfoque más común y flexible es utilizar el método apply() combinado con una función lambda o una función definida. Esto le permite iterar sobre cada fila y aplicar lógica personalizada basada en los valores de otras columnas.

Alternativamente, puede usar np.select() para múltiples condiciones. np.select() toma una lista de condiciones y una lista correspondiente de valores. Cuando se cumple una condición, se asigna el valor correspondiente. Esto es a menudo más legible que las sentencias if-else anidadas dentro de apply() para escenarios complejos. Aquí hay un ejemplo:

import pandas as pd import numpy as np data = {'col1': [1, 2, 3, 4, 5], 'col2': [5, 4, 3, 2, 1]} df = pd.DataFrame(data) conditions = [ df['col1'] > df['col2'], df['col1'] == df['col2'], df['col1'] < df['col2'] ] values = ['mayor', 'igual', 'menor'] df['new_col'] = np.select(conditions, values, default='desconocido') print(df)

Preguntas de entrevista de Pandas para expertos

1. ¿Cómo optimizaría una operación de Pandas que es lenta debido a la iteración sobre filas?

Para optimizar las operaciones lentas de Pandas causadas por la iteración de filas, evite los bucles explícitos (como los bucles for o iterrows()) siempre que sea posible. Pandas está optimizado para operaciones vectorizadas, que aplican funciones a columnas o DataFrames completos a la vez.

En su lugar, considere estos enfoques:

• Vectorización: Utilice las funciones integradas de Pandas o las funciones de NumPy que operan en columnas enteras (por ejemplo, df['columna'] + 1, df['columna'].apply(función)).
• apply() con axis=1: Si bien no es tan eficiente como la vectorización pura, se puede usar apply(función, axis=1) cuando necesite operar en cada fila, pero aún es más rápido que los bucles explícitos. Asegúrese de que la función sea lo más eficiente posible.
• pd.DataFrame.merge(): Si la operación lenta implica comparar datos entre filas o DataFrames, considere usar pd.DataFrame.merge() o pd.DataFrame.join() para combinar datos basados en columnas comunes y luego realizar cálculos vectorizados.
• pd.DataFrame.groupby(): Si la operación implica cálculos basados en grupos de filas, use pd.DataFrame.groupby() para agrupar los datos y luego aplicar funciones a cada grupo usando apply() o funciones de agregación como sum(), mean(), etc.
• pd.DataFrame.transform(): Para aplicar una función y devolver un resultado que tenga la misma forma que el DataFrame original (útil para la ingeniería de características), use pd.DataFrame.transform().
• NumPy: Convierta las columnas relevantes en arreglos NumPy usando .values y realice operaciones con NumPy. NumPy es muy eficiente y debería ser más rápido que los bucles en Python.

Elija el enfoque que mejor se adapte a la operación específica que está intentando realizar. La vectorización es generalmente la más eficiente, seguida de apply(axis=1), luego utilizando métodos adecuados de Pandas como merge(), groupby() y transform(). Los bucles explícitos suelen ser los más lentos.

2. Explique cómo manejaría un archivo CSV muy grande con Pandas que no cabe en la memoria.

Cuando manejo archivos CSV muy grandes con Pandas que no caben en la memoria, usaría el parámetro chunksize en la función pd.read_csv(). Esto permite leer el archivo en trozos más pequeños y manejables. Luego iteraría a través de estos trozos, realizaría cualquier operación necesaria (como limpieza de datos, transformación o agregación) y guardaría los resultados.

Por ejemplo, podría calcular la suma de una columna iterando a través de cada trozo y agregando la suma de ese trozo a un total acumulado. El proceso podría verse así:

import pandas as pd chunksize = 10000 # Ajuste el tamaño del chunk según la memoria disponible total_sum = 0 for chunk in pd.read_csv('large_file.csv', chunksize=chunksize): total_sum += chunk['nombre_columna'].sum() print(f"Suma total: {total_sum}")

Si se requieren operaciones más complejas, agregaría los resultados intermedios de cada trozo antes de realizar los cálculos finales. Este enfoque evita la sobrecarga de memoria a la vez que me permite procesar todo el conjunto de datos.

3. Describa un escenario en el que usaría el tipo de datos categóricos de Pandas y por qué.

Usaría el tipo de datos Categorical de Pandas cuando una columna contiene un número limitado de valores únicos, especialmente si esos valores se repiten con frecuencia. Por ejemplo, almacenar el género (Masculino, Femenino, Otro), el tipo de sangre (A+, B-, O+, etc.), o incluso los estados de EE. UU. como cadenas puede ser ineficiente en cuanto a memoria. Usar Categorical representa estos valores usando enteros, lo que ahorra memoria y mejora el rendimiento en operaciones como la agrupación o la clasificación.

Específicamente, podría usarlo cuando trabaje con datos de encuestas donde los encuestados eligen de un conjunto predefinido de opciones. Considere una columna que indica el nivel educativo: ["Bachillerato", "Licenciatura", "Maestría", "Doctorado"]. Convertir esto a un tipo categórico usando pandas.Categorical() o asignar el dtype='category' durante la creación del DataFrame (por ejemplo, pd.Series(data, dtype='category')) sería ideal. Esto no solo reduce el uso de memoria, sino que también me permite definir el orden de las categorías (por ejemplo, ["Bachillerato", "Licenciatura", "Maestría", "Doctorado"]) lo cual puede ser útil para graficar o analizar donde un orden específico es significativo.

4. ¿Cómo se manejan los datos faltantes en un DataFrame de Pandas y cuáles son las compensaciones de los diferentes enfoques?

El manejo de datos faltantes en Pandas involucra varios enfoques. Los métodos comunes incluyen: 1) Eliminación de valores faltantes: Usar dropna() elimina filas o columnas con NaN. Esto es simple pero puede llevar a una pérdida significativa de datos si la falta de datos es prevalente. 2) Imputación: Reemplazar los valores faltantes con valores estimados. Las estrategias comunes incluyen:

• Imputación de la media/mediana: Usar fillna() con la media o la mediana de la columna. Simple, pero puede distorsionar la distribución.
• Relleno hacia adelante/hacia atrás: Propagar la última observación válida hacia adelante o hacia atrás. Útil para datos de series temporales.
• Métodos más complejos: Usar algoritmos de aprendizaje automático para predecir valores faltantes. Estos métodos son más sofisticados, pero complejos.

Las compensaciones implican equilibrar la integridad de los datos con el posible sesgo introducido por la imputación. Eliminar datos es sencillo, pero reduce el tamaño de la muestra. Los métodos de imputación simples son fáciles de implementar, pero pueden distorsionar la distribución subyacente de los datos y reducir la varianza. Las estrategias de imputación complejas pueden producir mejores resultados, pero requieren una cuidadosa consideración y validación para evitar el sobreajuste o la introducción de relaciones espurias. La elección depende de la naturaleza y el alcance de los datos faltantes, así como de los objetivos específicos del análisis.

5. Explique cómo usar Pandas para realizar un análisis de series temporales, incluidas las operaciones de remuestreo y ventanas.

Pandas es excelente para el análisis de series temporales. Primero, asegúrese de que sus datos de series temporales estén en un DataFrame de Pandas y que el índice sea un DatetimeIndex. Luego, puede remuestrear sus datos a una frecuencia diferente usando .resample('frecuencia').función_de_agregación(). Por ejemplo, .resample('D').mean() remuestrea a frecuencia diaria y calcula la media. Las frecuencias comunes son 'D' (día), 'W' (semana), 'M' (mes), 'Q' (trimestre), 'A' (año).

Las operaciones de ventana calculan estadísticas sobre una ventana móvil. Use .rolling(window=window_size).aggregation_function() para aplicar una ventana móvil. Por ejemplo, .rolling(window=7).mean() calcula la media móvil de 7 días. Esto es útil para suavizar datos de series temporales e identificar tendencias. Las funciones de agregación comunes son .mean(), .sum(), .std() y .var(). Puede encadenar el remuestreo y el ventaneo. Por ejemplo, remuestree datos a diario, luego calcule una media móvil de 7 días: df.resample('D').mean().rolling(window=7).mean().

6. Describa cómo implementaría una función de agregación personalizada utilizando la funcionalidad groupby de Pandas.

Para implementar una función de agregación personalizada utilizando la funcionalidad groupby de Pandas, primero definiría su función personalizada. Esta función debe tomar una Serie como entrada (que representa un grupo de datos) y devolver un solo valor (el resultado agregado). Luego, puede usar el método .groupby() en su DataFrame para agrupar los datos por una o más columnas. Finalmente, aplique el método .agg() al objeto GroupBy, pasando su función personalizada como argumento. Pandas luego aplicará su función personalizada a cada grupo, produciendo un nuevo DataFrame con los resultados agregados.

Por ejemplo:

import pandas as pd import numpy as np def custom_range(series): return series.max() - series.min() df = pd.DataFrame({'Category': ['A', 'A', 'B', 'B', 'C'], 'Value': [1, 2, 3, 4, 5]}) result = df.groupby('Category')['Value'].agg(custom_range) print(result)

7. ¿Cómo puede usar Pandas para unir eficientemente múltiples DataFrames con diferentes estructuras de índice?

Pandas ofrece varias formas eficientes de unir múltiples DataFrames con diferentes estructuras de índice. La función pd.concat() es útil para apilar DataFrames vertical u horizontalmente. Al concatenar, puede controlar cómo se manejan los índices usando el parámetro ignore_index para restablecer el índice o especificar los tipos de unión ('inner', 'outer') para administrar las columnas superpuestas.

Para uniones más complejas, las funciones DataFrame.join() o pd.merge() son valiosas. DataFrame.join() es conveniente para unir DataFrames en un índice o una columna común. pd.merge() proporciona más flexibilidad, lo que le permite especificar diferentes tipos de unión (por ejemplo, 'left', 'right', 'inner', 'outer'), columnas para unir (on) y sufijos izquierdo/derecho para manejar los nombres de columna superpuestos. Al tratar con conjuntos de datos grandes, asegúrese de que las columnas de unión estén indexadas para búsquedas más rápidas.

8. Explique cómo depuraría los problemas de rendimiento en el código de Pandas.

Para depurar problemas de rendimiento en el código de Pandas, comenzaría por perfilar utilizando herramientas como cProfile o %prun en los cuadernos de Jupyter para identificar las partes más lentas del código. Luego, analizaría el código de Pandas en sí, buscando cuellos de botella de rendimiento comunes como:

• Iterar sobre filas: Evite usar iterrows() o apply() si es posible. Las operaciones vectorizadas son generalmente mucho más rápidas.
• Tipos de datos ineficientes: Asegúrese de usar los tipos de datos más apropiados (por ejemplo, category para datos categóricos, int32 en lugar de int64 si es posible).
• Copia de datos: Tenga en cuenta las operaciones que podrían crear copias innecesarias del DataFrame. Use inplace=True cuando sea apropiado (pero tenga en cuenta los posibles efectos secundarios).
• Cálculos innecesarios: Revise el código para eliminar operaciones redundantes o computacionalmente costosas. También busque oportunidades para usar numpy o numba para obtener ganancias de rendimiento.

Usar %%timeit dentro de Jupyter es útil para evaluar el rendimiento de operaciones individuales. Para conjuntos de datos grandes, considere usar fragmentación para procesar datos en lotes más pequeños.

9. Describa cómo usaría Pandas para crear una tabla dinámica y analizar los resultados.

Usaría la función pd.pivot_table() en Pandas para crear una tabla dinámica. Esta función toma datos, índice, columnas y valores como argumentos. Por ejemplo, pd.pivot_table(data, values='Sales', index='Region', columns='Product', aggfunc='sum') crea una tabla dinámica que muestra la suma de las ventas para cada región y producto. Luego analizaría la tabla dinámica resultante:

• Inspeccionando los datos: Busque tendencias, valores atípicos y valores faltantes utilizando .head(), .tail(), .describe() y .isnull().sum().
• Ordenamiento: Ordene la tabla dinámica en función de filas o columnas utilizando .sort_values() para identificar las regiones o productos con mejor rendimiento.
• Filtrado: Filtre los datos para enfocarse en regiones, productos o períodos de tiempo específicos utilizando la indexación booleana.
• Visualización: Cree gráficos (por ejemplo, gráficos de barras, mapas de calor) utilizando matplotlib o seaborn para visualizar los resultados e identificar patrones.
• Aplicando cálculos: obtenga información, como calcular cambios porcentuales o proporciones en filas o columnas.

10. ¿Cómo puede aprovechar el método .pipe() en Pandas para crear una canalización de procesamiento de datos legible y mantenible?

El método .pipe() en Pandas le permite encadenar múltiples transformaciones de datos juntas de una manera legible y mantenible. En lugar de anidar llamadas de función, pasa una función (o una lista de funciones) a .pipe(), que aplica cada función secuencialmente al DataFrame. Esto promueve una estructura de código más lineal y comprensible.

Por ejemplo, en lugar de f(g(h(df))), puede usar df.pipe(h).pipe(g).pipe(f). Esto es especialmente útil cuando se combina con funciones personalizadas que encapsulan pasos específicos de procesamiento de datos. Esto mejora la legibilidad y la capacidad de prueba. También puede usar pipe con una lista de tuplas, donde el primer elemento es una función y el segundo es un diccionario de argumentos de palabras clave para pasar a la función, lo que proporciona más flexibilidad.

11. Explique la diferencia entre `.apply()`, `.map()`, y `.applymap()` en Pandas, y cuándo usaría cada uno?

apply(), map(), y applymap() son funciones de Pandas utilizadas para aplicar una función a un DataFrame o Serie de Pandas, pero operan en diferentes niveles.

• map() se usa específicamente con Series de Pandas para sustituir cada valor de una Serie por otro valor. Toma una función, un diccionario o una Serie como entrada.
• apply() se puede usar en un DataFrame o Serie. Cuando se usa en una Serie, aplica una función a cada valor. Cuando se usa en un DataFrame, aplica una función a lo largo de un eje (filas o columnas). La función pasada a apply puede realizar operaciones más complejas, incluida la operación en filas o columnas enteras a la vez.
• applymap() se usa solo en DataFrames y aplica una función a cada elemento del DataFrame. applymap() es equivalente a usar apply() en un DataFrame después de convertir todas sus columnas a Series individualmente, si la función espera entradas escalares. applymap() debe usarse cuando se desean operaciones elemento por elemento en todo un dataframe.

12. ¿Cómo implementaría un algoritmo de coincidencia difusa de cadenas utilizando Pandas para limpiar datos inconsistentes?

Para implementar la coincidencia difusa de cadenas en Pandas para la limpieza de datos, aprovecharía la biblioteca fuzzywuzzy junto con las operaciones vectorizadas de Pandas. Primero, cargaría los datos en un DataFrame de Pandas. Luego, definiría una función que utiliza fuzzywuzzy.fuzz.ratio (u otra función de puntuación adecuada) para comparar cada cadena en la columna inconsistente con una lista de valores correctos conocidos. Utilizaría pandas.apply para aplicar esta función a cada fila del DataFrame. La función devolvería el valor correcto que mejor coincida. Finalmente, sobrescribiría la columna inconsistente con los valores limpios y consistentes. Esto proporciona una rutina de coincidencia y corrección difusa rápida, eficiente y vectorizada para el conjunto de datos.

Por ejemplo:

import pandas as pd from fuzzywuzzy import fuzz def fuzzy_match(row, correct_values, column_name): best_match = None best_score = 0 for val in correct_values: score = fuzz.ratio(row[column_name], val) if score > best_score: best_score = score best_match = val return best_match df['columna_a_limpiar'] = df.apply(fuzzy_match, correct_values=known_good_values, column_name='columna_a_limpiar', axis=1)

13. Describa cómo usar Pandas con otras bibliotecas como Scikit-learn para construir modelos de aprendizaje automático.

Pandas se usa comúnmente con Scikit-learn para optimizar el flujo de trabajo de aprendizaje automático. Los DataFrames de Pandas son excelentes para la carga, limpieza y preprocesamiento de datos. Puede cargar sus datos en un DataFrame utilizando pd.read_csv() o funciones similares. Después de limpiar y transformar sus datos dentro del DataFrame, puede extraer fácilmente las características y la variable objetivo como matrices NumPy utilizando .values. Estas matrices NumPy se pueden alimentar directamente a los modelos Scikit-learn para entrenamiento y predicción.

Por ejemplo, puede realizar el escalado de características usando sklearn.preprocessing.StandardScaler en columnas específicas de su DataFrame de Pandas. Posteriormente, puede dividir los datos procesados en conjuntos de entrenamiento y prueba usando sklearn.model_selection.train_test_split. Los arreglos NumPy resultantes se usan luego para entrenar su modelo Scikit-learn, como sklearn.linear_model.LogisticRegression. Pandas también se puede usar para almacenar y analizar las predicciones y métricas de evaluación del modelo, creando una integración perfecta entre la manipulación de datos y la construcción de modelos de aprendizaje automático.

14. ¿Cómo usaría Pandas para identificar y eliminar datos duplicados basados en múltiples columnas?

Para identificar y eliminar datos duplicados en Pandas basados en múltiples columnas, usaría los métodos duplicated() y drop_duplicates(). Primero, usaría duplicated(subset=[lista_de_columnas], keep=False) para identificar todas las filas donde los valores en las columnas especificadas son duplicados. Establecer keep=False marca todos los duplicados (incluida la primera ocurrencia) como True. Esto devuelve una serie booleana.

Luego, usaría drop_duplicates(subset=[lista_de_columnas], keep=False) para eliminar las filas duplicadas identificadas. Por ejemplo:

df.drop_duplicates(subset=['col1', 'col2'], keep=False, inplace=True)

Aquí, subset especifica las columnas a considerar para identificar duplicados, keep=False elimina todos los duplicados, y inplace=True modifica el DataFrame directamente.

15. Explique cómo puede crear un DataFrame multi-índice en Pandas y cómo consultar datos de él.

Un DataFrame de múltiples índices en Pandas se crea usando pd.MultiIndex.from_tuples() o pd.MultiIndex.from_product() (o métodos similares) para generar el índice y luego pasando esto al constructor del DataFrame. Alternativamente, puede usar DataFrame.set_index() para promover columnas existentes al índice, lo que resulta en un MultiIndex.

Para consultar, se usa .loc[] con tuplas que representan los niveles del MultiIndex. Por ejemplo, df.loc[('valor_nivel1', 'valor_nivel2')]. El slicing se puede usar con pd.IndexSlice para consultas más complejas. También puede acceder a niveles individuales usando .get_level_values() o intercambiar niveles usando .swaplevel() para reorganizar el índice y facilitar la consulta.

16. Describa cómo manejar las conversiones de zona horaria usando objetos de fecha y hora de Pandas.

Pandas simplifica las conversiones de zona horaria usando los métodos tz_localize() y tz_convert(). Primero, localice un objeto de fecha y hora o una columna de serie/dataframe de Pandas a una zona horaria específica usando tz_localize(). Si el objeto de fecha y hora no tiene zona horaria, esto asigna una zona horaria. Luego, conviértalo a otra zona horaria usando tz_convert(). Este método es esencial para asegurar un análisis de datos preciso cuando se trata de datos de diferentes zonas horarias.

Por ejemplo:

import pandas as pd ts = pd.Timestamp('2023-10-27 10:00:00') ts_utc = ts.tz_localize('UTC') ts_pacific = ts_utc.tz_convert('US/Pacific') print(ts_pacific)

Pandas también admite el trabajo con objetos de fecha y hora con reconocimiento de zona horaria directamente al leer datos usando funciones como pd.read_csv() especificando los argumentos parse_dates y date_parser apropiadamente.

17. ¿Cómo usaría Pandas para realizar un análisis de cohortes?

El análisis de cohortes utilizando Pandas implica agrupar a usuarios o clientes según características compartidas (por ejemplo, mes de registro) y rastrear su comportamiento a lo largo del tiempo. Primero, cree una columna 'cohorte' basada en el evento inicial (por ejemplo, fecha de registro). Luego, calcule el 'número de período' que representa el tiempo transcurrido desde la formación de la cohorte. Agrupe los datos por cohorte y período, y agregue métricas relevantes como el recuento de usuarios o los ingresos. Finalmente, visualice los resultados utilizando mapas de calor o gráficos de líneas para identificar tendencias y patrones dentro de cada cohorte.

Aquí hay un ejemplo básico:

import pandas as pd # Suponiendo que tiene un DataFrame 'df' con 'user_id', 'signup_date' y 'purchase_date' df['cohorte'] = df.groupby('user_id')['signup_date'].transform('min').dt.to_period('M') df['periodo'] = (df['purchase_date'].dt.to_period('M') - df['cohorte']).apply(lambda x: x.n) datos_de_cohorte = df.groupby(['cohorte', 'periodo'])['user_id'].nunique().reset_index() tabla_pivot_de_cohorte = datos_de_cohorte.pivot(index='cohorte', columns='periodo', values='user_id') print(tabla_pivot_de_cohorte)

18. Explique cómo usar Pandas para leer datos de una base de datos y escribir datos en ella.

Pandas puede interactuar con bases de datos usando la biblioteca sqlalchemy. Para leer datos, primero cree un motor de conexión usando sqlalchemy.create_engine, especificando la cadena de conexión de la base de datos. Luego, use pd.read_sql_query() o pd.read_sql_table() para ejecutar una consulta SQL o leer una tabla completa en un DataFrame de Pandas, respectivamente. Por ejemplo:

import pandas as pd from sqlalchemy import create_engine engine = create_engine('dialect+driver://user:password@host:port/database') df = pd.read_sql_query("SELECT * FROM my_table", engine)

Para escribir datos de vuelta a la base de datos, use el método df.to_sql(). Especifique el nombre de la tabla, el motor y el parámetro if_exists para controlar cómo manejar las tablas existentes (por ejemplo, 'replace', 'append', 'fail'). Por ejemplo:

df.to_sql('new_table', engine, if_exists='replace', index=False)

El argumento index=False evita escribir el índice del DataFrame como una columna en la tabla de la base de datos.

19. Describa cómo usaría Pandas para analizar datos de texto, incluyendo la tokenización y el análisis de sentimientos.

Para analizar datos de texto con Pandas, comenzaría cargando los datos de texto en un DataFrame de Pandas. Luego, realizaría la tokenización usando bibliotecas como NLTK o spaCy para dividir el texto en palabras o frases individuales. Esto podría implicar la eliminación de la puntuación y la conversión del texto a minúsculas. nltk.word_tokenize(text) es un ejemplo simple usando NLTK.

Para el análisis de sentimiento, puedo usar bibliotecas como VADER (Valence Aware Dictionary and sEntiment Reasoner), que está específicamente diseñada para el análisis de sentimiento en redes sociales. Puedo aplicar SentimentIntensityAnalyzer de VADER a cada texto tokenizado y obtener una puntuación de sentimiento (positivo, negativo, neutral, compuesto). Estas puntuaciones se pueden agregar como nuevas columnas al DataFrame de Pandas, lo que permite análisis como la agrupación por sentimiento, el cálculo de las puntuaciones de sentimiento promedio o la identificación de los textos más positivos/negativos.

20. ¿Cómo implementaría una función de ventana móvil personalizada usando Pandas?

Para implementar una función de ventana móvil personalizada en Pandas, puede usar el método .rolling() seguido de .apply(). El método .rolling() crea una vista móvil de sus datos, y .apply() le permite aplicar una función personalizada a cada ventana. Necesitará definir una función que tome una Serie de Pandas (la ventana) como entrada y devuelva un solo valor.

21. Explique cómo usar Pandas para crear visualizaciones interactivas utilizando bibliotecas como Plotly o Bokeh.

Pandas, combinado con bibliotecas como Plotly o Bokeh, permite la creación de visualizaciones interactivas. Primero, instala las bibliotecas necesarias (pip install pandas plotly o pip install pandas bokeh). Luego, carga tus datos en un DataFrame de Pandas. A continuación, usa las funciones de trazado de Plotly plotly.express o Bokeh, alimentándolas directamente con datos de las columnas de tu DataFrame. Por ejemplo, con Plotly, puedes crear un gráfico de dispersión interactivo usando plotly.express.scatter(df, x="columna1", y="columna2", color="columna3", hover_data=['columna4']), donde df es tu DataFrame. De manera similar, con Bokeh, creas una figura y luego agregas glifos (círculos, líneas, etc.) especificando la fuente de datos como un ColumnDataSource de Bokeh creado a partir de tu DataFrame de Pandas.

La clave es que ambas bibliotecas están diseñadas para funcionar sin problemas con los DataFrames de Pandas. Los elementos interactivos, como el zoom, el paneo y las información sobre herramientas (tooltips), son características integradas de estas bibliotecas. Puede personalizar estas características ampliamente ajustando los parámetros de las funciones de trazado o los glifos.

22. Describe un escenario donde usarías las estructuras de datos dispersos (Sparse) de Pandas y por qué.

Usaría las estructuras de datos dispersos de Pandas cuando se trata de conjuntos de datos que contienen una gran proporción de valores faltantes o cero. Un ejemplo común es una característica categórica codificada en un punto caliente (one-hot encoded) con muchas categorías. En este caso, la mayoría de las columnas para una fila dada serán cero. Otro escenario es una matriz documento-término en el procesamiento del lenguaje natural, donde cada fila representa un documento y cada columna representa una palabra; la mayoría de las entradas son a menudo cero, porque la mayoría de los documentos no contienen la mayoría de las palabras del vocabulario.

Las estructuras de datos dispersas son beneficiosas porque almacenan solo los valores no predeterminados (por ejemplo, valores distintos de cero). Esto reduce significativamente el uso de memoria y potencialmente mejora el rendimiento computacional para las operaciones que pueden aprovechar la representación dispersa. En lugar de almacenar cada entrada individual (incluso si la mayoría son 0 o NaN), solo almacena la ubicación (índice) y el valor de los elementos no dispersos, lo que conduce a un ahorro de memoria, especialmente para conjuntos de datos grandes.

23. ¿Cómo usaría Pandas para realizar un análisis de pruebas A/B?

Pandas se puede usar para realizar análisis de pruebas A/B cargando los datos de la prueba A/B en DataFrames de Pandas. Luego calculamos métricas clave como las tasas de conversión, las tasas de clics o los ingresos por usuario para cada grupo (A y B). Después de calcular las métricas, usamos pruebas estadísticas (por ejemplo, pruebas t o pruebas de chi-cuadrado) de scipy.stats para determinar si las diferencias entre los grupos son estadísticamente significativas. Los resultados, incluidos los valores p y los intervalos de confianza, se analizan para tomar decisiones informadas sobre qué variación funciona mejor.

Específicamente, el proceso implicaría cargar los datos en DataFrames usando pd.read_csv(), calcular estadísticas resumidas usando df.groupby() y df.mean(), y realizar pruebas estadísticas usando funciones como stats.ttest_ind(). Por ejemplo, podría calcular la tasa de conversión media para el grupo A y el grupo B y luego usar una prueba t para ver si la diferencia es estadísticamente significativa, lo que indica una diferencia real entre los grupos en lugar de una casualidad aleatoria. La visualización usando matplotlib o seaborn también puede ayudar a comprender los resultados.

24. Explique cómo usar Pandas para crear una matriz de correlación e interpretar los resultados.

Para crear una matriz de correlación en Pandas, primero carga sus datos en un DataFrame de Pandas. Luego, usa el método .corr() en el DataFrame. Este método calcula la correlación por pares entre todas las columnas en el DataFrame. Por defecto, calcula el coeficiente de correlación de Pearson, que mide la relación lineal entre dos variables. También se pueden especificar otros métodos de correlación como Kendall y Spearman.

Interpretación de los resultados: La matriz de correlación es una tabla cuadrada donde tanto las filas como las columnas representan las características (variables) en su conjunto de datos. Los valores oscilan entre -1 y 1. Un valor cercano a 1 indica una fuerte correlación positiva (a medida que una variable aumenta, la otra tiende a aumentar), -1 indica una fuerte correlación negativa (a medida que una variable aumenta, la otra tiende a disminuir), y 0 indica poca o ninguna correlación lineal. Por ejemplo:

import pandas as pd data = {'col1': [1, 2, 3, 4, 5], 'col2': [2, 4, 5, 4, 5], 'col3': [5, 4, 3, 2, 1]} df = pd.DataFrame(data) matriz_correlacion = df.corr(method='pearson') # o kendall, spearman print(matriz_correlacion)

25. Describa cómo usar la función 'pd.eval()' para acelerar ciertas operaciones de Pandas.

La función pd.eval() en Pandas puede acelerar significativamente ciertas operaciones al usar representaciones de cadena de expresiones de Pandas, permitiendo que se evalúen usando NumExpr. Esto evita la sobrecarga de la creación de objetos temporales en la que Pandas normalmente incurre. Específicamente, es beneficioso para operaciones aritméticas y booleanas en DataFrames o Series grandes. Por ejemplo:

import pandas as pd df = pd.DataFrame({'A': range(100000), 'B': range(100000)}) # Operación estándar de Pandas (más lenta) df['C'] = df['A'] + df['B'] # Usando pd.eval() (más rápido) df['C'] = pd.eval('df.A + df.B')

pd.eval() es efectivo cuando la expresión es relativamente simple (por ejemplo, que involucra solo operadores aritméticos o de comparación) y los datos son grandes. Analiza la expresión de cadena y optimiza el cálculo, lo que conduce a un mejor rendimiento en comparación con las operaciones estándar de Pandas en casos de uso adecuados. Tenga en cuenta que no todas las operaciones de Pandas son compatibles con pd.eval().

26. ¿Cómo manejaría la asimetría de datos al realizar cálculos con Pandas?

La asimetría de datos en Pandas puede afectar significativamente los cálculos, lo que lleva a resultados sesgados. Para manejar esto, se pueden emplear varias técnicas. Primero, considere aplicar transformaciones a los datos asimétricos. Las transformaciones comunes incluyen:

• Transformación logarítmica: Útil para datos con asimetría a la derecha.
• Transformación de raíz cuadrada: También efectiva para datos con asimetría a la derecha, pero menos extrema que el logaritmo.
• Transformación Box-Cox: Una transformación más general que puede manejar tanto la asimetría positiva como la negativa; requiere que los datos sean positivos. Se puede usar scipy.stats.boxcox().

Otro enfoque implica el uso de medidas estadísticas robustas que son menos sensibles a los valores atípicos causados por la asimetría. Por ejemplo, usar la mediana en lugar de la media, o calcular el rango intercuartílico (RIC) en lugar de la desviación estándar. Además, podría considerar técnicas de remuestreo para equilibrar el conjunto de datos antes de realizar cálculos, aunque esto es más aplicable en contextos de aprendizaje automático que en el análisis de datos general. Por ejemplo, para cálculos como agregaciones, podría considerar el uso de pesos para ajustar la asimetría.

27. Explique cómo usaría Pandas para crear un diccionario de datos que describa las columnas y los tipos de datos en un DataFrame.

Para crear un diccionario de datos que describa las columnas y los tipos de datos en un DataFrame de Pandas, iteraría a través de las columnas del DataFrame y almacenaría el nombre de la columna y el tipo de datos en un diccionario. Así es como:

import pandas as pd def create_data_dictionary(df): data_dictionary = {} for col in df.columns: data_dictionary[col] = df[col].dtype return data_dictionary #Ejemplo de uso data = {'col1': [1, 2], 'col2': ['a', 'b'], 'col3': [1.1, 2.2]} df = pd.DataFrame(data) dictionary = create_data_dictionary(df) print(dictionary)

Esto crea un diccionario donde cada clave es un nombre de columna y cada valor es el tipo de datos correspondiente a esa columna. Para diccionarios más complejos, se pueden agregar atributos adicionales como recuentos nulos, recuentos de valores únicos o estadísticas descriptivas dentro del bucle.

28. Describa estrategias para minimizar el uso de memoria al trabajar con DataFrames de Pandas grandes.

• Optimización del tipo de datos: Utilice tipos de datos numéricos más pequeños (por ejemplo, int16 en lugar de int64, float32 en lugar de float64) y category para columnas con valores de cadena de baja cardinalidad. Puede utilizar el método .astype() para esto.
• Fragmentación e iteración: Lea los datos en fragmentos más pequeños utilizando pd.read_csv con el parámetro chunksize, procese cada fragmento y luego combine los resultados si es necesario. Esto evita cargar todo el conjunto de datos en la memoria a la vez.
• Selección de columnas: Cargue solo las columnas necesarias utilizando el parámetro usecols en pd.read_csv. Descarte las columnas innecesarias lo antes posible.
• Estructuras de datos dispersas: Si el DataFrame contiene muchos valores faltantes (NaN), considere utilizar estructuras de datos dispersas.
• Recolección de basura: Elimine explícitamente los DataFrames o las variables que ya no se necesiten para liberar memoria utilizando del e invoque la recolección de basura utilizando gc.collect().
• Evite copias innecesarias: Modifique los DataFrames en su lugar cuando sea posible.

Ejemplo de optimización del tipo de datos:

df['nombre_columna'] = df['nombre_columna'].astype('int16')

Preguntas de opción múltiple de Pandas

Pregunta 1.

Dado un DataFrame de Pandas llamado df con las columnas 'A', 'B' y 'C', ¿cuál de los siguientes métodos seleccionará con éxito la columna 'B' y devolverá una serie de Pandas?

Opciones:

df[['B']]

df.loc['B']

df['B']

df.iloc['B']

Pregunta 2.

Considere un DataFrame de Pandas llamado df con las columnas 'A', 'B' y 'C'. ¿Cuál de las siguientes opciones selecciona correctamente todas las filas donde el valor de la columna 'A' es mayor que 5 Y asigna el valor de la columna 'C' a 10 para esas filas seleccionadas utilizando .loc?

Opciones:

df[df['A'] > 5]['C'] = 10

df.loc[df['A'] > 5]['C'] = 10

df.loc[df['A'] > 5, 'C'] = 10

df['C'].loc[df['A'] > 5] = 10

Pregunta 3.

Tiene un DataFrame de Pandas llamado df con una columna 'valores'. ¿Cuál de los siguientes fragmentos de código eliminará correctamente las filas donde la columna 'valores' es menor que 5?

Opciones:

Opciones:

df[df['valores'] < 5].drop()

df.drop(df[df['valores'] < 5].index)

df.remove(df['valores'] < 5)

df = df[df['valores'] > 5]

Pregunta 4.

Tiene dos DataFrames de Pandas, df1 y df2. df1 tiene las columnas ['ID', 'Nombre', 'Edad'] y df2 tiene las columnas ['ID', 'Ciudad', 'Salario']. Desea combinar estos DataFrames en función de la columna 'ID', incluyendo todas las filas de ambos DataFrames, incluso si no hay una 'ID' coincidente en el otro DataFrame. ¿Qué función de Pandas debería usar y qué argumento how lograría esto?

Opciones:

Opciones:

`pd.concat([df1, df2], axis=1)`

`pd.merge(df1, df2, on='ID', how='outer')`

`df1.join(df2, on='ID', how='left')`

`df1.append(df2)`

Pregunta 5.

Tienes un DataFrame de Pandas llamado df con las columnas 'A', 'B' y 'C'. Quieres renombrar la columna 'A' a 'X' y la columna 'C' a 'Z' modificando directamente el DataFrame original. ¿Cuál de los siguientes fragmentos de código lo logra?

Opciones:

```python df.rename(columns={'A': 'X', 'C': 'Z'}) ```

```python df.columns = ['X', 'B', 'Z'] ```

```python df.rename(columns={'A': 'X', 'C': 'Z'}, inplace=True) ```

```python df = df.rename(columns={'A': 'X', 'C': 'Z'}) ```

Pregunta 6.

Dado un DataFrame de Pandas df que contiene datos numéricos, ¿cuál de los siguientes métodos es el más apropiado para aplicar una función personalizada a cada elemento del DataFrame?

Opciones:

`df.apply(my_function)`

`df.map(my_function)`

`df.applymap(my_function)`

`df.transform(my_function)`

Pregunta 7.

Tienes un DataFrame de Pandas llamado df que contiene datos de ventas con las columnas 'Región', 'Producto' y 'Ventas'. Quieres encontrar las ventas totales para cada región. ¿Cuál de los siguientes fragmentos de código de Pandas logrará esto correctamente?

Opciones:

df.groupby('Región')['Ventas'].sum()

df.groupby('Ventas')['Región'].sum()

df.groupby('Región')['Producto'].sum()

df.pivot_table(index='Región', values='Ventas', aggfunc='sum')

Pregunta 8.

Tienes un DataFrame de Pandas df con las columnas 'precio' y 'cantidad'. ¿Cuál de las siguientes opciones crea correctamente una nueva columna llamada 'costo_total' que es el producto de 'precio' y 'cantidad'?

Opciones:

Opciones:

df['costo_total'] = df['precio'].multiply(df['cantidad'])

df['costo_total'] = df['precio'] * df['cantidad'].apply(lambda x: int(x))

df.costo_total = df.precio * df.cantidad

df.assign(costo_total = df.precio * df.cantidad)

Pregunta 9.

Tienes dos DataFrames de Pandas, df1 y df2, ambos con un índice compartido. Deseas combinarlos en un único DataFrame, incluyendo todas las filas de ambos DataFrames, utilizando el índice como clave de unión. ¿Qué función de Pandas utilizarías?

Opciones:

Opciones:

`.concat()``

`.merge()` con `left_index=True` y `right_index=True`

`.join()``

`.append()``

Pregunta 10.

Considera un DataFrame de Pandas df con las columnas 'Edad', 'Ciudad' y 'Salario'. ¿Cuál de las siguientes expresiones filtra correctamente el DataFrame para seleccionar las filas donde 'Edad' es mayor que 25 Y 'Ciudad' es 'Nueva York'?

Opciones:

Opciones:

df[(df.Edad > 25) & (df.Ciudad == 'Nueva York')]

df[df.Edad > 25 and df.Ciudad == 'Nueva York']

df[(df.Edad > 25) or (df.Ciudad == 'Nueva York')]

df.loc[(df['Edad'] > 25) | (df['Ciudad'] == 'Nueva York')]

Pregunta 11.

Tienes un DataFrame de Pandas llamado df con columnas numéricas. Deseas aplicar una función que calcule la raíz cuadrada de cada valor en cada columna. ¿Cuál de los siguientes métodos de Pandas es el más adecuado para lograr esto?

Opciones:

`df.applymap(np.sqrt)`

`df.apply(np.sqrt, axis=0)`

`df.map(np.sqrt)`

`df.transform(np.sqrt)`

Pregunta 12.

¿Cuál es la forma más eficiente de agregar una nueva fila a un DataFrame de Pandas existente llamado `df` con datos almacenados en un diccionario `new_data`?

Opciones:

`df = df.append(new_data, ignore_index=True)`

`df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)`

`df.loc[len(df)] = new_data`

`df.add(new_data)`

Pregunta 13.

¿Qué devuelve la función `iterrows()` en Pandas durante la iteración?

Opciones:

El índice de la columna y la columna como una Serie.

El índice de la fila y la fila como una Serie.

Una tupla que contiene el número de fila y un diccionario de valores.

Solo el índice de la fila.

Pregunta 14.

Tienes dos DataFrames de Pandas, `df1` y `df2`, con las mismas columnas. Quieres combinarlos verticalmente, apilando `df2` debajo de `df1`. ¿Qué función de Pandas debes usar?

Opciones:

`.merge()`

`.concat()`

`.join()`

`.append()`

Pregunta 15.

Tienes un DataFrame de Pandas llamado df con las columnas 'Categoría', 'Producto' y 'Ventas'. ¿Cuál de las siguientes líneas de código crea correctamente una tabla dinámica que muestra las ventas totales de cada producto dentro de cada categoría?

Opciones:

df.pivot_table(index='Category', columns='Product', values='Sales', aggfunc='sum')

df.groupby(['Category', 'Product'])['Sales'].sum()

df.pivot(index='Category', columns='Product', values='Sales')

df.pivot_table(index='Product', columns='Category', values='Sales', aggfunc='mean')

Pregunta 16.

Considera un DataFrame de Pandas df con algunos valores faltantes (NaN). Deseas reemplazar todos los valores faltantes en el DataFrame con la media de cada columna respectiva. ¿Cuál de los siguientes fragmentos de código de Pandas logra esto?

Opciones:

```python df.fillna(df.mean(), inplace=True) ```

```python df.fillna(0, inplace=True) ```

```python df.dropna(inplace=True) ```

```python df.replace(np.nan, df.mean()) ```

Pregunta 17.

Tienes un DataFrame de Pandas llamado df y deseas aplicar una función personalizada process_row(row) a cada fila del DataFrame. La función process_row toma una fila como entrada (Serie de Pandas) y devuelve una Serie modificada. ¿Cuál de los siguientes métodos es la forma más eficiente de aplicar esta función y actualizar el DataFrame con los resultados?

Opciones:

```python for index, row in df.iterrows(): df.loc[index] = process_row(row) ```

```python for row in df.itertuples(): df.loc[row.Index] = process_row(pd.Series(row[1:])) ```

```python def apply_function(row): return process_row(row) df = df.apply(apply_function, axis=1) ```

```python for row in range(len(df)): df.iloc[row] = process_row(df.iloc[row]) ```

Pregunta 18.

Tienes un DataFrame de Pandas df con las columnas 'A', 'B' y 'C'. Deseas aplicar la función square a la columna 'A', la función cube a la columna 'B' y la función sqrt a la columna 'C'. ¿Cuál de los siguientes fragmentos de código lo logra correctamente?

Asume que las funciones square, cube y sqrt ya están definidas.

Opciones:

```python df[['A', 'B', 'C']] = df[['A', 'B', 'C']].apply([square, cube, sqrt]) ```

```python df = df.apply({'A': square, 'B': cube, 'C': sqrt}) ```

```python df = df.apply(lambda x: square(x['A']), axis=1) df = df.apply(lambda x: cube(x['B']), axis=1) df = df.apply(lambda x: sqrt(x['C']), axis=1) ```

```python df = df.apply({'A': square, 'B': cube, 'C': sqrt}, axis=0) ```

Pregunta 19.

Dado un DataFrame de Pandas df, ¿cuál de las siguientes opciones selecciona correctamente la primera fila del DataFrame?

Opciones:

df.iloc[1]

df.loc[0]

df.iloc[0]

df.head(1)

Pregunta 20.

Tienes una Serie de Pandas llamada temperaturas que contiene lecturas diarias de temperatura. Deseas categorizar estas temperaturas en 'Frío', 'Templado' y 'Caliente' según los siguientes rangos: 'Frío' (por debajo de 10°C), 'Templado' (10°C a 25°C) y 'Caliente' (por encima de 25°C). ¿Cuál de los siguientes fragmentos de código de Pandas usa correctamente pd.cut() para lograr esto?

Opciones:

```python temperaturas_categories = pd.cut(temperaturas, bins=[0, 10, 25, float('inf')], labels=['Frío', 'Templado', 'Caliente']) ```

```python temperaturas_categories = pd.cut(temperaturas, bins=[10, 25], labels=['Templado']) ```

```python temperaturas_categories = pd.cut(temperaturas, bins=[float('-inf'), 10, 25, float('inf')], labels=['Frío', 'Templado', 'Caliente']) ```

temperatures_categories = pd.qcut(temperaturas, q=3, labels=['Frío', 'Templado', 'Caliente'])

Pregunta 21.

Dado un DataFrame de Pandas df con una columna llamada 'Valores', ¿cuál de los siguientes fragmentos de código calcula y agrega correctamente una nueva columna llamada 'Suma_Acumulada' que contiene la suma acumulada de la columna 'Valores'?

Opciones:

df['Suma_Acumulada'] = df['Valores'].cumsum()

df['Suma_Acumulada'] = df['Valores'].sum()

df['Suma_Acumulada'] = df['Valores'].rolling().sum()

df['Suma_Acumulada'] = df['Valores'].aggregate(np.cumsum)

Pregunta 22.

Dado un DataFrame de Pandas df con las columnas 'A', 'B' y 'C', ¿cuál de las siguientes es la forma correcta de aplicar una función my_func a una celda específica en el índice de fila 2 y la columna 'B'? Asuma que my_func toma el valor de la celda como entrada y devuelve un valor transformado.

Opciones:

Opciones:

df.loc[2, 'B'].apply(my_func)

df.apply(my_func, axis=1)[2, 'B']

df.at[2, 'B'] = my_func(df.at[2, 'B'])

df['B'][2] = my_func(df['B'][2])

Pregunta 23.

Tienes un DataFrame de Pandas llamado df con las columnas 'A' y 'B'. ¿Cuál de los siguientes fragmentos de código calcula correctamente el coeficiente de correlación de Pearson entre las columnas 'A' y 'B'?

Opciones:

df['A'].corr(df['B'])

df.corr(['A', 'B'])

df[['A'], ['B']].corr()

df.corrwith(df[['A', 'B']])

Pregunta 24.

Tienes un DataFrame de Pandas llamado df con las columnas 'Categoría' y 'Valor'. ¿Cuál de los siguientes fragmentos de código calcula correctamente la media de la columna 'Valor' para cada 'Categoría' única usando groupby()?

Opciones:

```python df.groupby('Value')['Category'].mean() ```

```python df.groupby('Category')['Value'].mean() ```

```python df.groupby('Category').mean()['Value'] ```

```python df.groupby('Value').mean()['Category'] ```

Pregunta 25.

¿Cuál es la forma correcta de crear una Serie de Pandas a partir del siguiente diccionario de Python?

data = {'a': 1, 'b': 2, 'c': 3}

Opciones:

```python series = pd.Series(data) ```

```python series = pd.DataFrame(data) ```

```python series = data.to_series() ```

```python series = pd.Series.from_dict(data) ```

¿Qué habilidades de Pandas deberías evaluar durante la fase de entrevista?

Evaluar la experiencia de un candidato en Pandas en una sola entrevista puede ser complicado. No podrás cubrir todo, pero centrarse en las habilidades principales te ayudará a tomar una decisión informada. Estas son algunas habilidades clave de Pandas que deberías intentar evaluar.

Manipulación de datos

Puedes medir rápidamente la comodidad de un candidato con la manipulación de datos a través de preguntas de opción múltiple (MCQ) específicas. Una evaluación centrada en la manipulación de datos con Pandas puede proporcionar información valiosa.

Para evaluar aún más esta habilidad, plantea una pregunta práctica que requiera la manipulación de un DataFrame.

Tienes un DataFrame con datos de clientes, incluyendo 'CustomerID', 'PurchaseDate' y 'Amount'. ¿Cómo agruparías los datos por 'CustomerID' y calcularías el importe total de la compra para cada cliente?

Busca candidatos que puedan articular el uso de las funciones groupby() y sum(). Puntos extra si mencionan el manejo de posibles valores faltantes o conversiones de tipos de datos.

Selección e indexación de datos

Las preguntas de opción múltiple pueden probar eficazmente sus conocimientos de los diferentes métodos de indexación. Considera la posibilidad de utilizar una evaluación con MCQ sobre Pandas para filtrar rápidamente a los candidatos por sus habilidades de indexación.

Aquí tienes una pregunta de entrevista que puedes hacer para evaluar aún más sus habilidades de selección de datos.

Dado un DataFrame con datos de ventas, ¿cómo seleccionarías todas las filas donde la 'Región' es 'Este' y el importe de las 'Ventas' es superior a 1000 usando .loc?

La respuesta ideal demuestra la comprensión de la indexación booleana combinada con .loc. Los candidatos deben filtrar correctamente las filas en función de múltiples condiciones.

Agregación y agrupación de datos

Pruebas de habilidades con preguntas de opción múltiple (MCQ) relevantes centradas en Pandas pueden filtrar con precisión a los candidatos con buenas habilidades de agregación. Esta habilidad está presente en nuestra biblioteca como parte de la habilidad de Pandas.

Aquí hay una pregunta de entrevista que puede hacer para evaluar aún más sus habilidades de agregación de datos.

Supongamos que tiene un DataFrame que contiene información sobre los productos vendidos en diferentes tiendas, incluyendo 'StoreID', 'ProductID' y 'Sales'. ¿Cómo encontraría las ventas promedio de cada producto en todas las tiendas?

El candidato debe explicar el uso de la función groupby() junto con la función mean(). Un candidato ideal también puede discutir cómo lidiar con posibles valores NaN y posibles representaciones de tablas dinámicas.

3 Consejos para usar preguntas de entrevista de Pandas

Antes de comenzar a utilizar sus nuevos conocimientos de las preguntas de entrevista de Pandas, aquí hay algunos consejos. Estos conocimientos le ayudarán a refinar su proceso de entrevista y a tomar decisiones de contratación más informadas.

1. Aproveche las evaluaciones de habilidades para una evaluación objetiva

Para comenzar, considere usar evaluaciones de habilidades para medir objetivamente la competencia de los candidatos en Pandas. Estas pruebas brindan evaluaciones estandarizadas, lo que le ayuda a seleccionar a los candidatos de manera efectiva y justa.

Por ejemplo, puede usar la Prueba en línea de Python Pandas de Adaface para evaluar las habilidades prácticas de Pandas o la Prueba de ciencia de datos para una evaluación más amplia. Esto ayuda a garantizar que los candidatos posean las habilidades requeridas antes de sumergirse en entrevistas en profundidad.

Las evaluaciones de habilidades ahorran tiempo y recursos al filtrar a los candidatos que no cumplen con los requisitos mínimos. Use la evaluación de habilidades para filtrar e identificar las capacidades relevantes de Pandas. Esto le permite enfocar sus esfuerzos de entrevista en las personas más prometedoras.

2. Delinee estratégicamente las preguntas de la entrevista

El tiempo es esencial en las entrevistas, así que seleccione cuidadosamente un conjunto de preguntas enfocadas. Priorice las preguntas que revelen la profundidad de conocimiento y las habilidades prácticas de resolución de problemas de un candidato con Pandas.

Complemente sus preguntas de Pandas con consultas sobre habilidades relacionadas, como análisis de datos y SQL. Consulte nuestras preguntas de entrevista de SQL para formular preguntas específicas.

No olvides evaluar las habilidades sociales como la comunicación y el trabajo en equipo para asegurar un ajuste integral. Equilibrar las evaluaciones de habilidades técnicas y sociales dará los mejores resultados de contratación.

3. Domina el arte de las preguntas de seguimiento

Usar preguntas de entrevista preparadas es un buen comienzo, ¡pero no te detengas ahí! Hacer preguntas de seguimiento perspicaces es clave para evaluar la experiencia genuina y la profundidad de comprensión de un candidato.

Por ejemplo, si un candidato explica cómo fusionar DataFrames, pregúntale sobre las implicaciones de rendimiento de las diferentes estrategias de fusión. Esto puede revelar si realmente se siente cómodo con el tema y tiene experiencia práctica.

Contrata al mejor talento en Pandas con pruebas de habilidades

¿Buscas contratar a un científico o analista de datos con sólidas habilidades en Pandas? Evaluar con precisión estas habilidades es clave para tomar la decisión correcta de contratación. Usar una prueba de habilidades dedicada, como la Prueba en línea de Python Pandas, es la forma más efectiva de evaluar a los candidatos.

Una vez que haya identificado a los candidatos con habilidades probadas en Pandas a través de pruebas de habilidades, puede enfocar el tiempo de su entrevista en preguntas de comportamiento y situacionales. ¿Listo para empezar? ¡Regístrese para una prueba gratuita y descubra el mejor talento!

Prueba en línea de Python Pandas

30 minutos | 16 MCQs

La prueba en línea de Python Pandas evalúa la capacidad de un candidato para trabajar con datos utilizando la biblioteca Pandas en Python. Evalúa el conocimiento de lectura y escritura de datos, manipulación de datos, análisis, limpieza, visualización de datos, manejo de datos de series temporales, agrupación y agregación, fusión y unión de dataframes, manejo de datos faltantes, aplicación de funciones estadísticas y remodelación de datos.

[

Pruebe la prueba en línea de Python Pandas

](https://www.adaface.com/assessment-test/python-pandas-online-test)

Descargue la plantilla de preguntas de entrevista de Pandas en múltiples formatos

Preguntas frecuentes sobre la entrevista de Pandas

Las preguntas básicas de la entrevista de Pandas cubren conceptos fundamentales como Series, DataFrames, selección de datos y filtrado de datos. Evalúan la comprensión del candidato sobre las estructuras y operaciones de datos centrales de Pandas.

Las preguntas intermedias de la entrevista de Pandas exploran temas como la limpieza de datos, la agregación de datos, la fusión y unión de DataFrames y las técnicas básicas de análisis de datos. Estas preguntas evalúan la capacidad del candidato para manipular y analizar datos utilizando Pandas.

Las preguntas avanzadas de la entrevista de Pandas abordan temas más complejos como la indexación múltiple, el manejo de grandes conjuntos de datos, funciones personalizadas con apply y la optimización del rendimiento. Estas preguntas evalúan la experiencia del candidato en el manejo de escenarios desafiantes de análisis de datos.

Las preguntas de la entrevista de Pandas para expertos profundizan en áreas especializadas como el trabajo con datos de series temporales, la visualización avanzada de datos, la contribución a la biblioteca de Pandas y la comprensión de la arquitectura subyacente de Pandas. Estas preguntas identifican a los candidatos con habilidades excepcionales en Pandas y una comprensión profunda de las capacidades de la biblioteca.

Al evaluar las habilidades de Pandas, concéntrese en la comprensión del candidato sobre las estructuras de datos, las técnicas de manipulación de datos, las habilidades de análisis de datos y la capacidad de resolver problemas de datos del mundo real utilizando Pandas. Comprender su enfoque de resolución de problemas es clave.

Para utilizar las preguntas de la entrevista de Pandas de manera efectiva, adáptelas al puesto específico y al nivel de experiencia para el que está contratando. Combine preguntas teóricas con ejercicios prácticos de codificación para evaluar tanto el conocimiento conceptual como las habilidades prácticas. También considere complementar el proceso de entrevista con una prueba de habilidades para evaluar aún más las habilidades de Pandas.