Obtenga estas preguntas de Python correctas para superar su entrevista de trabajo de ciencia de datos



Si desea tener 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 de ciencia de datos, preparé los principales conceptos de Python probados en la entrevista de ciencia de datos. Más adelante, analizaré dos tipos principales de preguntas de entrevista que cubren los conceptos que debe conocer 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 una empresa. Entonces, si tiene algunas entrevistas de ciencia de datos programadas, le recomiendo encarecidamente que use esta guía como punto de partida de lo que podría surgir en la entrevista. Además, también debe intentar encontrar algunas preguntas específicas de la empresa y tratar de resolverlas también. Conocer conceptos generales y practicarlos en preguntas de la vida real es una combinación ganadora.

No los molestaré con preguntas teóricas. Pueden aparecer en la entrevista, pero también cubren los 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 hablaré, probablemente también sepa explicarlos.

Los conceptos técnicos de Python probados en las 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 condicionales

Bibliotecas externas (Pandas)

1. Tipos de datos

Los tipos de datos son el concepto con el que debe estar familiarizado. Esto significa que debe conocer los tipos de datos más utilizados en Python, la diferencia entre ellos, cuándo y cómo usarlos. Esos 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 lista, diccionario, tupla y conjuntos. Conocer estas cuatro estructuras de datos integradas lo ayudará a organizar y almacenar datos de una manera que permitirá un acceso y modificaciones 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 arreglos, pila, cola, árboles, listas vinculadas, gráficos, HashMaps.

4. Funciones integradas

Python tiene más de 60 funciones integradas. No es necesario que los conozca todos, aunque, por supuesto, es mejor conocer tantos como sea posible. Las funciones integradas que no puede evitar son abs (), isinstance (), len (), list (), min (), max (), pow (), range (), round (), split () , ordenado (), tipo ().

5. Bucles y condicionales

Los bucles se utilizan en tareas repetitivas cuando realizan una pieza de código una y otra vez. Lo hacen hasta que los condicionales (pruebas de verdadero / falso) les dicen que se detengan.

6. Bibliotecas externas (Pandas)

Si bien se utilizan varias bibliotecas externas, Pandas es probablemente la más popular. Está diseñado para el análisis práctico de datos en finanzas, ciencias sociales, estadísticas e ingeniería.

Tipos de preguntas de la entrevista de Python

Todos esos seis conceptos técnicos se prueban principalmente mediante solo dos tipos de preguntas de entrevista. Esos 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 resolviendo los problemas de ETL (extracción, transformación y carga de datos) y realizando algunos análisis de datos.

Aquí hay uno de esos ejemplo de Facebook:

PREGUNTA: Facebook envía mensajes de texto SMS cuando los usuarios intentan 2FA (autenticación de 2 factores) en la plataforma para iniciar sesión. Para tener éxito en 2FA, deben confirmar que recibieron el mensaje de texto SMS. Los textos de confirmación solo son válidos en la fecha en que se enviaron. Desafortunadamente, hubo un problema de ETL con la base de datos donde se insertaron solicitudes de amistad y registros de confirmación no válidos en los registros, que se almacenan en la tabla «fb_sms_sends». Estos tipos de mensajes no deben estar 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 fueron confirmados por el usuario.

Calcule el porcentaje de mensajes SMS 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 poner a prueba sus habilidades de análisis de datos es este de Dropbox:

PREGUNTA: Escribe una consulta que calcule la diferencia entre los salarios más altos encontrados en los departamentos de marketing e ingeniería. Salida solo la diferencia de salarios.

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

Cuando se trata de preguntas de entrevistas sobre el algoritmo de 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, podría obtener esta pregunta:

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

A continuación se muestra un mapeo de dígitos a letras (como en los botones del teléfono). Tenga en cuenta que 1 no se asigna a 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 satisfacer todas las siguientes reglas:

Cada uno de los dígitos del 1 al 9 debe aparecer exactamente una vez en cada fila.

Cada uno de los dígitos del 1 al 9 debe aparecer exactamente una vez en cada columna.

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

El 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()

¡Este sería un algoritmo bastante complejo y bueno para usted si supiera cómo resolverlo!

Conclusión

Para una entrevista de ciencia de datos, los seis conceptos técnicos que he mencionado son imprescindibles. Por supuesto, se recomienda que profundice aún más en Python y amplíe sus conocimientos. No solo teóricamente, sino también practicando resolviendo tantas preguntas como sea posible, tanto de manipulación y análisis de datos como de 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.



Fuente: TNW

Compartir:

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para fines de afiliación y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Ver Política de cookies
Privacidad