Répondez à ces questions Python pour réussir votre entretien d'embauche en science des données

Si vous souhaitez faire carrière dans la science des données, il est indispensable de connaître Python. Python est le langage de programmation le plus populaire en science des données, en particulier en ce qui concerne l'apprentissage automatique et l'intelligence artificielle.

Pour vous aider dans votre carrière en science des données, j'ai préparé les principaux concepts Python testés dans l'entretien en science des données. Plus tard, je discuterai de deux principaux types de questions d'entretien qui couvrent les concepts que vous devez connaître en tant que data scientist. Je vais également vous montrer plusieurs exemples de questions et vous donner des solutions pour vous pousser dans la bonne direction.

Concepts techniques des questions d'entretien Python

Ce guide n'est pas spécifique à l'entreprise. Donc, si vous avez prévu des entretiens en science des données, je vous conseille fortement d'utiliser ce guide comme point de départ de ce qui pourrait survenir lors de l'entretien. De plus, vous devriez également essayer de trouver des questions spécifiques à l'entreprise et essayer de les résoudre également. Connaître des concepts généraux et les pratiquer sur des questions réelles est une combinaison gagnante.

Je ne vous ennuierai pas avec des questions théoriques. Ils peuvent apparaître lors de l'entretien, mais ils couvrent également les concepts techniques trouvés dans les questions de codage. Après tout, si vous savez utiliser les concepts dont je vais parler, vous savez probablement aussi les expliquer.

Les concepts techniques Python testés lors des entretiens d'embauche en science des données sont :

Types de données

Construit -dans les structures de données

Structures de données définies par l'utilisateur

Fonctions intégrées

Boucles et conditions

Bibliothèques externes (Pandas)

1. Types de données

Les types de données sont le concept avec lequel vous devez être familier. Cela signifie que vous devez connaître les types de données les plus couramment utilisés en Python, la différence entre eux, quand et comment les utiliser. Ce sont des types de données tels que des entiers (int), des flottants (float), des complexes (complexes), des chaînes (str), des booléens (bool), des valeurs nulles (None).

2. Structures de données intégrées

Ce sont des listes, des dictionnaires, des tuples et des ensembles. Connaître ces quatre structures de données intégrées vous aidera à organiser et à stocker les données d'une manière qui permettra un accès et des modifications plus faciles.

3. Structures de données définies par l'utilisateur

En plus d'utiliser les structures de données intégrées, vous devriez également pouvoir définir et utiliser certaines des structures de données définies par l'utilisateur. Ce sont des tableaux, des piles, des files d'attente, des arbres, des listes chaînées, des graphiques, des HashMaps.

4. Fonctions intégrées

Python possède plus de 60 fonctions intégrées. Vous n'avez pas besoin de tous les connaître alors, bien sûr, il vaut mieux en savoir le plus possible. Les fonctions intégrées que vous ne pouvez pas éviter sont abs(), isinstance(), len(), list(), min(), max(), pow(), range(), round(), split() , trié(), type().

5. Boucles et conditions

Les boucles sont utilisées dans des tâches répétitives lorsqu'elles exécutent un morceau de code encore et encore. Ils le font jusqu'à ce que les conditions (tests vrai/faux) leur disent d'arrêter.

6. Bibliothèques externes (Pandas)

Bien qu'il existe plusieurs bibliothèques externes utilisées, Pandas est probablement la plus populaire. Il est conçu pour l'analyse de données pratiques dans les domaines de la finance, des sciences sociales, des statistiques et de l'ingénierie. Ce sont :

Manipulation et analyse de données

Algorithmes

Regardons chacun d'eux de plus près.

1. Manipulation et analyse des données

Ces questions sont conçues pour tester le concept technique ci-dessus en résolvant les problèmes ETL (extraction, transformation et chargement de données) et en effectuant une analyse de données.

Voici un exemple de Facebook :

QUESTION : Facebook envoie des SMS lorsque les utilisateurs tentent de se connecter à 2FA (authentification à 2 facteurs) sur la plate-forme pour se connecter. Pour réussir 2FA, ils doivent confirmer qu'ils ont reçu le SMS. Les SMS de confirmation ne sont valables qu'à la date de leur envoi. Malheureusement, il y a eu un problème ETL avec la base de données où les demandes d'amis et les enregistrements de confirmation non valides ont été insérés dans les journaux, qui sont stockés dans la table 'fb_sms_sends'. Ces types de messages ne doivent pas figurer dans le tableau. Heureusement, la table 'fb_confirmers' contient des enregistrements de confirmation valides. Vous pouvez donc utiliser cette table pour identifier les SMS confirmés par l'utilisateur.

Calculez le pourcentage de SMS confirmés pour le 4 août 2020.

REPONSE :

importer des pandas en tant que pd
importer numpy en tant que np
df = fb_sms_sends[["ds","type","phone_number"]]
df1 = df[df["type"].isin(['confirmation','friend_request']) == Faux]
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']
résultat = (float(df3_grouped_0804['confirmed_count'])/df1_grouped_0804['count'])*100

L'une des questions posées pour tester vos compétences en analyse de données est celle-ci de Dropbox :

QUESTION : Ecrivez une requête qui calcule la différence entre les salaires les plus élevés trouvés dans les départements marketing et ingénierie. Sortez juste la différence de salaires.

REPONSE :

importer les pandas en tant que pd
importer numpy en tant que np
df = pd.merge(db_employee, db_dept, how = 'left',left_on = ['department_id']right_on=['id'])
df1=df[df["department"]=='ingénierie']
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')
résultat = pd.DataFrame(df_mkt['mkt_salary'] - df_eng['eng_salary'])
résultat.colonnes = ['salary_difference']
résultat

2. Algorithmes

En ce qui concerne les questions d'entretien de l'algorithme Python, ils testent votre résolution de problèmes à l'aide des algorithmes. Étant donné que les algorithmes ne sont pas limités à un seul langage de programmation, ces questions testent votre logique et votre réflexion, ainsi que le codage en Python.

Par exemple, vous pouvez obtenir cette question :

QUESTION : Étant donné une chaîne contenant des chiffres de 2 à 9 inclus, renvoie toutes les combinaisons de lettres possibles que le nombre pourrait représenter. Renvoyez la réponse dans n'importe quel ordre.

Un mappage de chiffres en lettres (comme sur les boutons du téléphone) est donné ci-dessous. Notez que 1 ne correspond à aucune lettre.

ANSWER :

class Solution :
def letterCombinations(self, digits: str) -> List[str] :
# Si l'entrée est vide, renvoie immédiatement un tableau de réponses vide
si len(chiffres) == 0 :
retour []

# Faites correspondre tous les chiffres à leurs lettres correspondantes
lettres = {"2": "abc", "3": "def", "4": "ghi", "5": "jkl",
"6": "mno", "7": "pqrs", "8": "tuv", "9": "wxyz"}

def backtrack (index, chemin):
# Si le chemin a la même longueur que les chiffres, nous avons une combinaison complète
si len(chemin) == len(chiffres) :
combinaisons.append("".join(chemin))
retour # Retour arrière
# Obtenez les lettres auxquelles correspond le chiffre actuel et parcourez-les
lettres_possibles = lettres[digits[index]]
pour la lettre dans possible_letters :
# Ajouter la lettre à notre chemin actuel
chemin.append(lettre)
# Passer au chiffre suivant
backtrack(index + 1, chemin)
# Revenir en arrière en supprimant la lettre avant de passer à la suivante
chemin.pop()
# Lancer un retour en arrière avec un chemin vide et un indice de départ de 0
combinaisons = []
retour en arrière (0, [])
combinaisons de retour

Ou cela pourrait devenir encore plus difficile avec la question suivante :

QUESTION : « Écrivez un programme pour résoudre un puzzle Sudoku en remplissant le champ vide cellules. Une solution de sudoku doit satisfaire à toutes les règles suivantes :

Chacun des chiffres 1-9 doit apparaître exactement une fois dans chaque ligne.

Chacun des chiffres 1-9 doit apparaître exactement une fois dans chaque colonne.

Chacun des chiffres 1 à 9 doit apparaître exactement une fois dans chacune des 9 sous-boîtes 3×3 de la grille. à partir des collections importer defaultdict
classe Solution :
def solveSudoku(self, board):
"""
:tableau de type : Liste[Liste[str]]
:rtype: void Ne retourne rien, modifie la carte en place à la place.
"""
def could_place(d, row, col):
"""
Vérifiez si l'on pouvait placer un nombre d dans la cellule (ligne, colonne)
"""
ne renvoie pas (d en lignes[row] ou d en colonnes[col] ou
d dans les boîtes[box_index(row, col)])
def place_number(d, row, col):
"""
Placer un nombre d dans la cellule (ligne, col)
"""
lignes[row][d] += 1
colonnes[col][d] += 1
boîtes[box_index(row, col)][d] += 1
planche[row][col] = str(d)
def remove_number(d, row, col):
"""
Supprimer un numéro qui ne menait pas
à une solution
"""
del rows[row][d]
del column[col][d]
del boxes[box_index(row, col)][d]
board[row][col] = '.'
def place_next_numbers(ligne, col):
"""
Fonction de backtrack d'appel en récursivité
continuer à placer des nombres
jusqu'au moment où nous avons une solution
"""
# si nous sommes dans la dernière cellule
# cela signifie que nous avons la solution
si col == N – 1 et rang == N – 1 :
sudoku_résolu non local
sudoku_solved = Vrai
#si pas encore
autre:
# si nous sommes à la fin de la rangée
# passer à la ligne suivante
si col == N – 1 :
retour en arrière (ligne + 1, 0)
# passer à la colonne suivante
autre:
backtrack(ligne, col + 1)
def backtrack (ligne = 0, col = 0):
"""
Retour en arrière
"""
# si la cellule est vide
si carte[row][col] == '.' :
# itérer sur tous les nombres de 1 à 9
pour d dans la plage (1, 10) :
if could_place(d, row, col):
place_number(d, ligne, col)
place_next_numbers(ligne, col)
# si le sudoku est résolu, il n'est pas nécessaire de revenir en arrière
# puisque la solution unique unique est promise
sinon sudoku_solved :
remove_number(d, ligne, col)
autre:
place_next_numbers(ligne, col)
# Taille de boîte
n = 3
# taille de ligne
N = n * n
# fonction lambda pour calculer l'index de la boîte
box_index = ligne lambda, col: (ligne // n ) * n + col // n
# init lignes, colonnes et boîtes
lignes = [defaultdict(int) for i in range(N)]
colonnes = [defaultdict(int) for i in range(N)]
cases = [defaultdict(int) for i in range(N)]
pour i dans la plage (N):
pour j dans la plage (N) :
si carte[i][j] != '.' :
d = int(planche[i][j])
place_number(d, i, j)
sudoku_solved = Faux
backtrack()

Ce serait un algorithme assez complexe et bon pour vous si vous saviez comment le résoudre !

Conclusion

Pour un entretien en science des données, les six concepts techniques que j'ai mentionnés sont un indispensable. Bien sûr, il est recommandé de plonger encore plus profondément dans Python et d'élargir vos connaissances. Non seulement théoriquement, mais aussi en s'exerçant en résolvant autant que possible les questions de manipulation et d'analyse de données et d'algorithmes.

Pour le premier, il existe de nombreux exemples sur StrataScratch. Vous pourriez probablement trouver les questions de l'entreprise où vous avez postulé pour un emploi. Et LeetCode est un bon choix lorsque vous décidez de vous entraîner à écrire des algorithmes Python avant vos entretiens.