Responda estas preguntas de Python para una entrevista de trabajo exitosa en ciencia de datos

Responda estas preguntas de Python para una entrevista de trabajo exitosa en ciencia de datos

noviembre 8, 2021 0 Por RenzoC



Si desea seguir una carrera en ciencia de datos, conocer Python es imprescindible. Python es el lenguaje de programación más popular en ciencia de datos, especialmente cuando se trata de aprendizaje automático e inteligencia artificial.

Para ayudarlo en su carrera en ciencia de datos, he preparado los principales conceptos de Python probados en la entrevista de ciencia de datos. Más adelante, discutiré dos tipos principales de preguntas de entrevista que cubren los conceptos que necesita saber como científico de datos. También le mostraré varios ejemplos de preguntas y le daré soluciones para empujarlo en la dirección correcta.

Conceptos técnicos de las preguntas de la entrevista de Python

Esta guía no es específica de la empresa. Por lo tanto, si ha estado planeando una entrevista de ciencia de datos, le recomiendo usar esta guía como punto de partida para lo que podría surgir durante la entrevista. Además, también debe intentar encontrar preguntas específicas de la empresa y tratar de resolverlas también. Conocer los conceptos generales y practicarlos en temas de la vida real es una combinación ganadora.

No los voy a molestar con preguntas teóricas. Pueden aparecer durante la entrevista, pero también cubren conceptos técnicos que se encuentran en las preguntas de codificación. Después de todo, si sabe cómo utilizar los conceptos de los que estoy a punto de hablar, probablemente también sepa cómo explicarlos.

Los conceptos técnicos de Python probados en entrevistas de trabajo de ciencia de datos son:

Tipos de datos

Estructuras de datos integradas

Estructuras de datos definidas por el usuario

Funciones integradas

Bucles y condiciones

Bibliotecas externas (Pandas)

1. Tipos de datos

Los tipos de datos son el concepto con el que debe estar familiarizado. Esto significa que necesita conocer los tipos de datos más utilizados en Python, la diferencia entre ellos, cuándo y cómo usarlos. Estos son tipos de datos como enteros (int), flotantes (flotantes), complejos (complejos), cadenas (str), booleanos (bool), valores nulos (Ninguno).

2. Estructuras de datos integradas

Estos son la lista, el diccionario, la tupla y los conjuntos. Conocer estas cuatro estructuras de datos integradas lo ayudará a organizar y almacenar datos de una manera que permitirá un acceso y modificación más fáciles.

3. Estructuras de datos definidas por el usuario

Además de utilizar las estructuras de datos integradas, también debería poder definir y utilizar algunas de las estructuras de datos definidas por el usuario. Estos son tablas, pilas, colas, árboles, listas enlazadas, gráficos, mapas hash.

4. Funciones integradas

Python tiene más de 60 funciones integradas. No es necesario que los conozca todos, así que, por supuesto, es mejor saber tanto como sea posible. Las funciones integradas que no puede evitar son abs (), isinstance (), len (), list (), min (), max (), pow (), range (), round (), split (), sorted (), escriba ().

5. Bucles y condiciones

Los bucles se utilizan en tareas repetitivas cuando ejecutan un fragmento de código una y otra vez. Hacen esto hasta que las condiciones (pruebas de verdadero / falso) les dicen que se detengan.

6. Bibliotecas externas (Pandas)

Aunque hay varias bibliotecas externas en uso, Pandas es probablemente la más popular. Está diseñado para el análisis práctico de datos en los campos de las finanzas, las ciencias sociales, la estadística y la ingeniería.

Tipos de preguntas de la entrevista con Python

Todos estos seis conceptos técnicos se prueban principalmente con solo dos tipos de preguntas de entrevista. Son:

Manipulación y análisis de datos

Algoritmos

Echemos un vistazo más de cerca a cada uno de ellos.

1. Manipulación y análisis de datos

Estas preguntas están diseñadas para probar el concepto técnico anterior al resolver problemas ETL (extraer, transformar y cargar datos) y realizar análisis de datos.

Aquí hay un ejemplo de Facebook:

PREGUNTA: Facebook envía SMS cuando los usuarios intentan iniciar sesión en 2FA (autenticación de 2 factores) en la plataforma para iniciar sesión. Para aprobar 2FA, deben confirmar que han recibido el SMS. Los SMS de confirmación solo son válidos en la fecha de envío. Desafortunadamente, hubo un problema de ETL con la base de datos donde se insertaron solicitudes de amistad no válidas y registros de confirmación en los registros, que se almacenan en la tabla ‘fb_sms_sends’. Estos tipos de mensajes no deberían aparecer en la tabla. Afortunadamente, la tabla ‘fb_confirmers’ contiene registros de confirmación válidos, por lo que puede usar esta tabla para identificar los mensajes de texto SMS que han sido confirmados por el usuario.

Calcule el porcentaje de mensajes de texto confirmados para el 4 de agosto de 2020.

RESPUESTA:

import pandas as pd
import numpy as np
df = fb_sms_sends[["ds","type","phone_number"]]
df1 = df[df["type"].isin(['confirmation','friend_request']) == False]
df1_grouped = df1.groupby('ds')['phone_number'].count().reset_index(name="count")
df1_grouped_0804 = df1_grouped[df1_grouped['ds']=='08-04-2020']
df2 = fb_confirmers[["date","phone_number"]]
df3 = pd.merge(df1,df2, how ='left',left_on =["phone_number","ds"], right_on = ["phone_number","date"])
df3_grouped = df3.groupby('date')['phone_number'].count().reset_index(name="confirmed_count")
df3_grouped_0804 = df3_grouped[df3_grouped['date']=='08-04-2020']
result = (float(df3_grouped_0804['confirmed_count'])/df1_grouped_0804['count'])*100

Una de las preguntas que se hacen para probar sus habilidades de análisis de datos es la de Dropbox:

PREGUNTA: Escriba una consulta que calcule la diferencia entre los salarios más altos que se encuentran en los departamentos de marketing e ingeniería. Simplemente saque la diferencia de salario.

RESPUESTA:

import pandas as pd
import numpy as np
df = pd.merge(db_employee, db_dept, how = 'left',left_on = ['department_id'], right_on=['id'])
df1=df[df["department"]=='engineering']
df_eng = df1.groupby('department')['salary'].max().reset_index(name="eng_salary")
df2=df[df["department"]=='marketing']
df_mkt = df2.groupby('department')['salary'].max().reset_index(name="mkt_salary")
result = pd.DataFrame(df_mkt['mkt_salary'] - df_eng['eng_salary'])
result.columns = ['salary_difference']
result

2. Algoritmos

En cuanto a las preguntas de la entrevista del algoritmo Python, ponen a prueba su resolución de problemas utilizando los algoritmos. Dado que los algoritmos no se limitan a un solo lenguaje de programación, estas preguntas ponen a prueba su lógica y pensamiento, así como la codificación en Python.

Por ejemplo, puede obtener esta pregunta:

PREGUNTA: Dada una cadena que contiene los dígitos del 2 al 9 inclusive, devuelva todas las combinaciones de letras posibles que el número podría representar. Vuelva a enviar la respuesta en cualquier orden.

A continuación se muestra un mapeo de números a letras (como en los botones del teléfono). Tenga en cuenta que 1 no coincide con ninguna letra.

RESPUESTA:

class Solution:
def letterCombinations(self, digits: str) -> List[str]:
# If the input is empty, immediately return an empty answer array
if len(digits) == 0:
return []

# Map all the digits to their corresponding letters
letters = {"2": "abc", "3": "def", "4": "ghi", "5": "jkl",
"6": "mno", "7": "pqrs", "8": "tuv", "9": "wxyz"}

def backtrack(index, path):
# If the path is the same length as digits, we have a complete combination
if len(path) == len(digits):
combinations.append("".join(path))
return # Backtrack
# Get the letters that the current digit maps to, and loop through them
possible_letters = letters[digits[index]]
for letter in possible_letters:
# Add the letter to our current path
path.append(letter)
# Move on to the next digit
backtrack(index + 1, path)
# Backtrack by removing the letter before moving onto the next
path.pop()
# Initiate backtracking with an empty path and starting index of 0
combinations = []
backtrack(0, [])
return combinations

O podría volverse aún más difícil con la siguiente pregunta:

PREGUNTA: “Escribe un programa para resolver un Sudoku llenando las celdas vacías. Una solución de sudoku debe cumplir con todas las siguientes reglas:

Cada uno de los números del 1 al 9 debe aparecer exactamente una vez en cada fila.

Cada uno de los números del 1 al 9 debe aparecer exactamente una vez en cada columna.

Cada uno de los números del 1 al 9 debe aparecer exactamente una vez en cada uno de los 9 subcuadros de la cuadrícula de 3 × 3.

Los ‘.’ carácter indica celdas vacías.

RESPUESTA:

from collections import defaultdict
class Solution:
def solveSudoku(self, board):
"""
:type board: List[List[str]]
:rtype: void Do not return anything, modify board in-place instead.
"""
def could_place(d, row, col):
"""
Check if one could place a number d in (row, col) cell
"""
return not (d in rows[row] or d in columns[col] or 
d in boxes[box_index(row, col)])
def place_number(d, row, col):
"""
Place a number d in (row, col) cell
"""
rows[row][d] += 1
columns[col][d] += 1
boxes[box_index(row, col)][d] += 1
board[row][col] = str(d)
def remove_number(d, row, col):
"""
Remove a number which didn't lead
to a solution
"""
del rows[row][d]
del columns[col][d]
del boxes[box_index(row, col)][d]
board[row][col] = '.'
def place_next_numbers(row, col):
"""
Call backtrack function in recursion
to continue to place numbers
till the moment we have a solution
"""
# if we're in the last cell
# that means we have the solution
if col == N - 1 and row == N - 1:
nonlocal sudoku_solved
sudoku_solved = True
#if not yet
else:
# if we're in the end of the row
# go to the next row
if col == N - 1:
backtrack(row + 1, 0)
# go to the next column
else:
backtrack(row, col + 1)
def backtrack(row = 0, col = 0):
"""
Backtracking
"""
# if the cell is empty
if board[row][col] == '.':
# iterate over all numbers from 1 to 9
for d in range(1, 10):
if could_place(d, row, col):
place_number(d, row, col)
place_next_numbers(row, col)
# if sudoku is solved, there is no need to backtrack
# since the single unique solution is promised
if not sudoku_solved:
remove_number(d, row, col)
else:
place_next_numbers(row, col)
# box size
n = 3
# row size
N = n * n
# lambda function to compute box index
box_index = lambda row, col: (row // n ) * n + col // n
# init rows, columns and boxes
rows = [defaultdict(int) for i in range(N)]
columns = [defaultdict(int) for i in range(N)]
boxes = [defaultdict(int) for i in range(N)]
for i in range(N):
for j in range(N):
if board[i][j] != '.':
d = int(board[i][j])
place_number(d, i, j)
sudoku_solved = False
backtrack()

¡Sería un algoritmo bastante complejo y bueno para ti si supieras cómo resolverlo!

Conclusión

Para una entrevista de ciencia de datos, los seis conceptos técnicos que mencioné son imprescindibles. Por supuesto, se recomienda que se sumerja aún más en Python y amplíe sus conocimientos. No solo teóricamente, sino también practicando resolviendo en la medida de lo posible las cuestiones de manipulación y análisis de datos y algoritmos.

Para el primero, hay muchos ejemplos en StrataScratch. Probablemente pueda encontrar las preguntas de la empresa donde solicitó un trabajo. Y LeetCode es una buena opción cuando decide practicar la escritura de algoritmos Python antes de sus entrevistas.