Les 23 meilleures questions et réponses d'entretien en Python pour 2024

Python continue de dominer l'industrie technologique en tant que l'un des langages de programmation les plus polyvalents et les plus demandés. Que vous vous prépariez à un entretien technique ou que vous cherchiez à améliorer vos compétences en matière de codage, la maîtrise de Python est essentielle. Les entretiens consistent souvent à résoudre des problèmes et à expliquer des fonctionnalités complexes en Python.

Ce guide fournit une liste complète des questions d'entretien les plus courantes et les plus avancées concernant Python. En s'entraînant à répondre à ces questions, les professionnels des données, les développeurs et les ingénieurs logiciels acquerront les compétences nécessaires pour exceller dans les entretiens techniques et faire progresser leur carrière.

Questions d'entretien de base sur Python

Voici quelques-unes des questions que vous pourriez rencontrer lors d'un entretien avec un débutant en Python. 

Les listes et les tuples sont des structures de données fondamentales de Python qui présentent des caractéristiques et des cas d'utilisation distincts.

Liste :

• Mutable : Les éléments peuvent être modifiés après leur création.
• Utilisation de la mémoire : Consomme plus de mémoire.
• Performance : Itération plus lente que pour les tuples, mais meilleure pour les opérations d'insertion et de suppression.
• Méthodes : Offre diverses méthodes intégrées de manipulation.

Exemple :

a_list = ["Data", "Camp", "Tutorial"]
a_list.append("Session")
print(a_list)  # Output: ['Data', 'Camp', 'Tutorial', 'Session']

Tuple :

• Immuable : Les éléments ne peuvent pas être modifiés après leur création.
• Utilisation de la mémoire : Consomme moins de mémoire.
• Performance : Itération plus rapide que les listes, mais manque de flexibilité.
• Méthodes : Méthodes intégrées limitées.

Exemple :

a_tuple = ("Data", "Camp", "Tutorial")
print(a_tuple)  # Output: ('Data', 'Camp', 'Tutorial')

Pour en savoir plus, consultez notre tutoriel sur les listes en Python.

2. Qu'est-ce que __init__() en Python ?

La méthode __init__() est connue sous le nom de constructeur dans la terminologie de la programmation orientée objet (POO). Il est utilisé pour initialiser l'état d'un objet lors de sa création. Cette méthode est automatiquement appelée lors de l'instanciation d'une nouvelle instance d'une classe.

Objet :

• Attribuer des valeurs aux propriétés de l'objet.
• Effectuez toutes les opérations d'initialisation.

Exemple: 

Nous avons créé une classe `book_shop` et ajouté le constructeur et la fonction `book()`. Le constructeur enregistre le titre du livre et la fonction `book()` affiche le nom du livre.

Pour tester notre code, nous avons initialisé l'objet `b` avec "Sandman" et exécuté la fonction `book()`. 

class book_shop:

    # constructor
    def __init__(self, title):
        self.title = title

    # Sample method
    def book(self):
        print('The tile of the book is', self.title)


b = book_shop('Sandman')
b.book()
# The tile of the book is Sandman

3. Quelle est la différence entre un type de données mutable et un type de données immuable ?

Types de données mutables :

• Définition : Les types de données mutables sont ceux qui peuvent être modifiés après leur création.
• Exemples : Liste, Dictionnaire, Ensemble.
• Caractéristiques : Des éléments peuvent être ajoutés, supprimés ou modifiés.
• Cas d'utilisation : Convient aux collections d'articles nécessitant des mises à jour fréquentes.

Exemple :

# List Example
a_list = [1, 2, 3]
a_list.append(4)
print(a_list)  # Output: [1, 2, 3, 4]

# Dictionary Example
a_dict = {'a': 1, 'b': 2}
a_dict['c'] = 3
print(a_dict)  # Output: {'a': 1, 'b': 2, 'c': 3}

Types de données immuables :

• Définition : Les types de données immuables sont ceux qui ne peuvent pas être modifiés après leur création.
• Exemples : Numérique (int, float), Chaîne, Tuple.
• Caractéristiques : Les éléments ne peuvent pas être modifiés une fois qu'ils ont été définis ; toute opération qui semble modifier un objet immuable créera un nouvel objet.

Exemple :

# Numeric Example
a_num = 10
a_num = 20  # Creates a new integer object
print(a_num)  # Output: 20

# String Example
a_str = "hello"
a_str = "world"  # Creates a new string object
print(a_str)  # Output: world

# Tuple Example
a_tuple = (1, 2, 3)
# a_tuple[0] = 4  # This will raise a TypeError
print(a_tuple)  # Output: (1, 2, 3)

4. Expliquez la compréhension des listes, des dictionnaires et des tuple à l'aide d'un exemple.

Liste

La compréhension de liste offre une syntaxe simple pour créer une nouvelle liste basée sur les valeurs de la liste existante. Vous pouvez utiliser une boucle "for" pour reproduire la même chose, mais cela vous obligera à écrire plusieurs lignes, et cela peut parfois devenir complexe. 

La compréhension de liste facilite la création d'une liste basée sur un itérable existant. 

my_list = [i for i in range(1, 10)]
my_list
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Dictionnaire

À l'instar de la compréhension d'une liste, vous pouvez créer un dictionnaire basé sur une table existante en une seule ligne de code. Vous devez entourer l'opération de crochets `{}`.

my_dict = {i for i in range(1, 10)}
my_dict
# {1, 2, 3, 4, 5, 6, 7, 8, 9}

Tuple

La situation est un peu différente pour les tuples. Vous pouvez créer une compréhension de tuple en utilisant les crochets ronds `()`, mais cela renverra un objet générateur, et non une compréhension de tuple.

Vous pouvez exécuter la boucle pour extraire les éléments ou les convertir en liste.

my_tuple = (i for i in range(1, 10))
my_tuple
# <generator object <genexpr> at 0x7fb91b151430>

Pour en savoir plus, consultez notre tutoriel Python Tuples. 

Questions d'entretien avancées sur Python

Ces questions d'entretien s'adressent à des praticiens Python plus expérimentés. 

5. Qu'est-ce que le "monkey patching" en Python ?

Le Monkey Patching en Python est une technique dynamique qui permet de modifier le comportement du code au moment de l'exécution. En bref, vous pouvez modifier une classe ou un module au moment de l'exécution.

Exemple:

Apprenons le patching du singe à l'aide d'un exemple. 

1. Nous avons créé une classe `monkey` avec une fonction `patch()`. Nous avons également créé une fonction `monk_p` en dehors de la classe. 
2. Nous allons maintenant remplacer la fonction `patch` par la fonction `monk_p` en assignant `monkey.patch` à `monk_p`.
3. Enfin, nous testerons la modification en créant l'objet à l'aide de la classe `monkey` et en exécutant la fonction `patch()`. 

Au lieu d'afficher "patch() is being called", il a affiché "monk_p() is being called". 

class monkey:
    def patch(self):
          print ("patch() is being called")

def monk_p(self):
    print ("monk_p() is being called")

# replacing address of "patch" with "monk_p"
monkey.patch = monk_p

obj = monkey()

obj.patch()
# monk_p() is being called

6. À quoi sert l'instruction Python "with" ?

L'instruction `with` est utilisée pour la gestion des exceptions afin de rendre le code plus propre et plus simple. Il est généralement utilisé pour la gestion des ressources communes telles que la création, l'édition et l'enregistrement d'un fichier. 

Exemple:

Au lieu d'écrire plusieurs lignes de open, try, finally et close, vous pouvez créer et écrire un fichier texte en utilisant l'instruction `with`. C'est simple.

# using with statement
with open('myfile.txt', 'w') as file:
    file.write('DataCamp Black Friday Sale!!!')

7. Pourquoi utiliser else dans la construction try/except en Python ?

`try:` et `except:` sont généralement connus pour la gestion des exceptions en Python, alors où est-ce que `else:` est utile ? `else:` sera déclenché si aucune exception n'est levée. 

Exemple:

Nous allons en apprendre davantage sur `else:` à l'aide de quelques exemples.

1. Au premier essai, nous avons saisi 2 comme numérateur et "d" comme dénominateur. Ce qui est incorrect, et `except:` a été déclenché avec "Invalid input !". 
2. Au deuxième essai, nous avons entré 2 comme numérateur et 1 comme dénominateur et nous avons obtenu le résultat 2. Aucune exception n'a été soulevée, ce qui a déclenché l'option `else:` qui affiche le message "La division est réussie". 

try:
    num1 = int(input('Enter Numerator: '))
    num2 = int(input('Enter Denominator: '))
    division = num1/num2
    print(f'Result is: {division}')
except:
    print('Invalid input!')
else:
    print('Division is successful.')


## Try 1 ##
# Enter Numerator: 2
# Enter Denominator: d
# Invalid input!

## Try 2 ##
# Enter Numerator: 2
# Enter Denominator: 1
# Result is: 2.0
# Division is successful.

Suivez le parcours de compétences Python Fundamentals pour acquérir les compétences fondamentales dont vous avez besoin pour devenir un programmeur Python. 

8. Que sont les décorateurs en Python ? 

Les décorateurs en Python sont un modèle de conception qui vous permet d'ajouter de nouvelles fonctionnalités à un objet existant sans modifier sa structure. Ils sont généralement utilisés pour étendre le comportement des fonctions ou des méthodes.

Exemple :

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# Output:
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.

9. Que sont les gestionnaires de contexte en Python et comment sont-ils mis en œuvre ?

Les gestionnaires de contexte en Python sont utilisés pour gérer les ressources, en veillant à ce qu'elles soient correctement acquises et libérées. L'utilisation la plus courante des gestionnaires de contexte est la déclaration with.

Exemple :

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
    
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    
    def __exit__(self, exc_type, exc_value, traceback):
        self.file.close()

with FileManager('test.txt', 'w') as f:
    f.write('Hello, world!')

Dans cet exemple, la classe FileManager est un gestionnaire de contexte qui veille à ce que le fichier soit correctement fermé après avoir été utilisé dans la déclaration with.

Questions d'entretien sur la science des données en Python

Pour ceux qui se concentrent davantage sur les applications de Python dans le domaine de la science des données, voici quelques questions que vous pourriez rencontrer. 

10. Quels sont les avantages de NumPy par rapport aux listes classiques de Python ?

Mémoire 

Les tableaux Numpy consomment moins de mémoire. 

Par exemple, si vous créez une liste et un tableau Numpy de mille éléments. La liste consommera 48K octets, et le tableau Numpy consommera 8k octets de mémoire.  

Vitesse

Les tableaux Numpy prennent moins de temps à effectuer les opérations sur les tableaux que sur les listes. 

Par exemple, si nous multiplions deux listes et deux tableaux Numpy de 1 million d'éléments ensemble. Il a fallu 0,15 seconde à la liste et 0,0059 seconde au tableau pour fonctionner. 

Vesititly 

Les tableaux Numpy sont pratiques à utiliser car ils offrent des fonctions simples de multiple de tableau, d'addition et bien d'autres fonctionnalités intégrées. Alors que les listes Python sont incapables d'exécuter des opérations de base. 

11. Quelle est la différence entre fusionner, joindre et concaténer ?

Merge

Fusionner deux DataFrames nommés objets séries en utilisant l'identifiant unique de la colonne. 

Il faut deux DataFrame, une colonne commune dans les deux DataFrame, et "comment" vous voulez les joindre. Vous pouvez joindre deux DataFrames à gauche, à droite, à l'extérieur, à l'intérieur et en croix. Par défaut, il s'agit d'une jointure interne. 

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

Join

Joindre les DataFrames à l'aide de l'index unique. Elle nécessite un argument optionnel `on` qui peut être une colonne ou plusieurs noms de colonnes. Par défaut, la fonction de jointure effectue une jointure à gauche. 

df1.join(df2)

Concaténer

Concatenate joint deux ou plusieurs DataFrames le long d'un axe particulier (lignes ou colonnes). Elle ne nécessite pas d'argument `on`. 

pd.concat(df1,df2)

• join(): combine deux DataFrames par index.
• merge(): elle combine deux DataFrames en fonction de la ou des colonnes que vous avez spécifiées.
• concat(): combine deux ou plusieurs DataFrames verticalement ou horizontalement.

12. Comment identifier et traiter les valeurs manquantes ?

Identifier les valeurs manquantes 

Nous pouvons identifier les valeurs manquantes dans le DataFrame en utilisant la fonction `isnull()` et en appliquant ensuite `sum()`. `Isnull()` renverra des valeurs booléennes, et la somme vous donnera le nombre de valeurs manquantes dans chaque colonne. 

Dans l'exemple, nous avons créé un dictionnaire de listes et l'avons converti en un DataFrame pandas. Ensuite, nous avons utilisé isnull().sum() pour obtenir le nombre de valeurs manquantes dans chaque colonne.  

import pandas as pd
import numpy as np

# dictionary of lists
dict = {'id':[1, 4, np.nan, 9],
        'Age': [30, 45, np.nan, np.nan],
        'Score':[np.nan, 140, 180, 198]}

# creating a DataFrame
df = pd.DataFrame(dict)

df.isnull().sum()
# id       1
# Age      2
# Score    1

Traitement des valeurs manquantes

Il existe plusieurs façons de traiter les valeurs manquantes. 

1. Supprimez la ligne entière ou les colonnes si elles sont constituées de valeurs manquantes en utilisant `dropna()`. Cette méthode n'est pas recommandée, car vous perdrez des informations importantes.
2. Remplissez les valeurs manquantes avec la constante, la moyenne, le remplissage arrière et le remplissage avant à l'aide de la fonction `fillna()`.
3. Remplacez les valeurs manquantes par une chaîne constante, un entier ou un flottant à l'aide de la fonction `replace()`.
4. Complétez les valeurs manquantes à l'aide d'une méthode d'interpolation.   

Remarque: assurez-vous que vous travaillez avec un ensemble de données plus important lorsque vous utilisez la fonction `dropna()`. 

# drop missing values
df.dropna(axis = 0, how ='any')

#fillna
df.fillna(method ='bfill')

#replace null values with -999
df.replace(to_replace = np.nan, value = -999)

# Interpolate
df.interpolate(method ='linear', limit_direction ='forward')

Devenez un data scientist professionnel en suivant le parcours Data Scientist with Python. Il comprend 25 cours et six projets pour vous aider à apprendre tous les fondamentaux de la science des données à l'aide des bibliothèques Python. 

13. Quelles sont les bibliothèques Python que vous avez utilisées pour la visualisation ? 

La visualisation des données est la partie la plus importante de l'analyse des données. Vous voyez vos données en action et cela vous aide à trouver des modèles cachés.

Les bibliothèques de visualisation de données Python les plus populaires sont les suivantes :

1. Matplotlib
2. Seaborn
3. Plotly
4. Bokeh

En Python, nous utilisons généralement Matplotlib et seaborn pour afficher tous les types de visualisation de données. Avec quelques lignes de code, vous pouvez l'utiliser pour afficher des diagrammes de dispersion, des diagrammes linéaires, des diagrammes en boîte, des diagrammes à barres, et bien d'autres encore. 

Pour les applications interactives et plus complexes, nous utilisons Plotly. Vous pouvez l'utiliser pour créer des graphiques interactifs colorés avec quelques lignes de code. Vous pouvez zoomer, appliquer des animations et même ajouter des fonctions de contrôle. Plotly propose plus de 40 types de graphiques uniques, et nous pouvons même les utiliser pour créer une application web ou un tableau de bord. 

Bokeh est utilisé pour des graphiques détaillés avec un haut niveau d'interactivité sur de grands ensembles de données. 

Questions d'entretien sur le codage Python

Si vous avez un entretien de codage Python à venir, préparer des questions similaires à celles-ci peut vous aider à impressionner l'intervieweur. 

14. Comment remplacer l'espace d'une chaîne de caractères par un caractère donné en Python ?

Il s'agit d'un simple défi de manipulation de chaînes de caractères. Vous devez remplacer l'espace par un caractère spécifique.  

Exemple 1: un utilisateur a fourni la chaîne "l vey u" et le caractère "o", et le résultat sera "loveyou".

Exemple 2: un utilisateur a fourni la chaîne "D t C mpBl ckFrid yS le" et le caractère "a", et le résultat sera "DataCampBlackFridaySale".

Dans la fonction `str_replace()`, nous passons en revue chaque lettre de la chaîne et vérifions s'il s'agit d'un espace ou non. S'il s'agit d'un espace, nous le remplacerons par le caractère spécifique fourni par l'utilisateur. Enfin, nous renverrons la chaîne modifiée. 

def str_replace(text,ch):
    result = ''
    for i in text: 
            if i == ' ': 
                i = ch  
            result += i 
    return result

text = "D t C mpBl ckFrid yS le"
ch = "a"

str_replace(text,ch)
# 'DataCampBlackFridaySale'

15. Etant donné un entier positif num, écrivez une fonction qui renvoie True si num est un carré parfait sinon False.

La solution est relativement simple. Vous pouvez vérifier si le nombre a une racine carrée parfaite en :

1. Trouver la racine carrée du nombre et la convertir en un nombre entier.
2. Appliquer le carré au nombre de racines carrées et vérifier s'il s'agit d'une racine carrée parfaite.
3. Renvoie le résultat sous la forme d'un booléen. 

Test 1  

Nous avons donné le numéro 10 à la fonction `valid_square()`. 

1. En prenant la racine carrée du nombre, on obtient 3.1622776601683795.
2. En le convertissant en un nombre entier, nous obtenons 3.
3. Ensuite, prenez le carré de 3 et vous obtenez 9.
4. 9 n'est pas égal au nombre, la fonction renvoie donc False. 

a

Test 2

Nous avons fourni le numéro 36 à la fonction `valid_square()`. 

1. En prenant la racine carrée du nombre, on obtient 6.
2. En le convertissant en un nombre entier, nous obtenons 6.
3. Prenez ensuite le carré de 6 et obtenez 36.
4. 36 est égal au nombre, la fonction renvoie donc True. 

def valid_square(num):
    square = int(num**0.5)
    check = square**2==num
    return check

valid_square(10)
# False
valid_square(36)
# True

16. Étant donné un entier n, retournez le nombre de zéros de fin dans n factoriel n !

Pour réussir ce défi, vous devez d'abord calculer la factorielle n (n !) et ensuite calculer le nombre de zéros d'entraînement. 

Recherche de la factorielle 

Dans la première étape, nous utiliserons une boucle while pour itérer sur la factorielle n et nous arrêterons lorsque n sera égal à 1. 

Calcul des zéros de fin

Dans la deuxième étape, nous calculerons le zéro de fin, et non le nombre total de zéros. La différence est énorme. 

7! = 5040

Les sept factorielles ont un total de deux zéros et un seul zéro à la fin, notre solution devrait donc donner 1. 

1. Convertit le nombre factoriel en chaîne de caractères.
2. Relisez-le et demandez une boucle.
3. Si le nombre est 0, ajoutez +1 au résultat, sinon interrompez la boucle.
4. Renvoie le résultat.

La solution est élégante mais nécessite une attention particulière aux détails. 

def factorial_trailing_zeros(n):

    fact = n
    while n > 1:
        fact *= n - 1
        n -= 1

    result = 0

    for i in str(fact)[::-1]:
        if i == "0":
            result += 1
        else:
            break

    return result


factorial_trailing_zeros(10)
# 2
factorial_trailing_zeros(18)
# 3

Suivez le cours essentiel de pratique des questions d'entretien de codage pour vous préparer à vos prochains entretiens de codage en Python.

Question d'entretien FAANG Python

Vous trouverez ci-dessous quelques-unes des questions auxquelles vous pouvez vous attendre pour les postes les plus recherchés dans ces secteurs, à savoir ceux de Meta, Amazon, Google, etc. 

Questions d'entretien sur Facebook/Meta Python

Les questions exactes que vous rencontrerez chez Meta dépendent en grande partie du rôle. Toutefois, vous pouvez vous attendre à certains des éléments suivants : 

17. Segmentation des cordes

Vous disposez d'une grande ficelle et d'un dictionnaire de mots. Vous devez déterminer si la chaîne d'entrée peut être segmentée en mots à l'aide du dictionnaire ou non.  

Image par l'auteur

La solution est relativement simple. Vous devez segmenter une grande chaîne en chaque point et vérifier si la chaîne peut être segmentée en fonction des mots du dictionnaire.

1. Exécutez la boucle en utilisant la longueur de la grande ficelle.
2. Nous allons créer deux sous-chaînes. 
3. La première sous-chaîne vérifiera chaque point de la grande chaîne à partir de s[0:i]
4. Si la première chaîne de caractères ne se trouve pas dans le dictionnaire, le système renvoie False.
5. Si la première chaîne de caractères se trouve dans le dictionnaire, il créera la deuxième chaîne de caractères en utilisant s[i:0].
6. Si la deuxième sous-chaîne se trouve dans le dictionnaire ou si la deuxième sous-chaîne est de longueur nulle, la réponse est True. Appelez récursivement `can_segment_str()` avec la seconde sous-chaîne et renvoyez True si elle peut être segmentée. 

def can_segment_str(s, dictionary):
    for i in range(1, len(s) + 1):
        first_str = s[0:i]
        if first_str in dictionary:
            second_str = s[i:]
            if (
                not second_str
                or second_str in dictionary
                or can_segment_str(second_str, dictionary)
            ):
                return True
    return False


s = "datacamp"
dictionary = ["data", "camp", "cam", "lack"]
can_segment_string(s, dictionary)
# True

18. Supprimer les doublons d'un tableau trié

Dans un tableau de nombres entiers triés par ordre croissant, supprimez les doublons de façon à ce que chaque élément unique n'apparaisse qu'une seule fois. Veillez à ce que l'ordre final du tableau reste le même.

Il est impossible de modifier la longueur du tableau en Python, nous placerons donc le résultat dans la première partie du tableau. Après avoir supprimé les doublons, nous aurons k éléments, et les k premiers éléments du tableau devraient contenir les résultats. 

Image de LeetCode

Exemple 1: le tableau d'entrée est [1,1,2,2], la fonction doit renvoyer 2. 

Exemple 2: le tableau d'entrée est [1,1,2,3,3], la fonction doit renvoyer 3.

Solution:

1. Exécutez la boucle pour la plage de 1 à la taille du tableau.
2. Vérifiez si le numéro précédent est unique ou non. Nous comparons les éléments précédents avec l'élément actuel.  
3. S'il est unique, mettez à jour le tableau en utilisant insertIndex, qui vaut 1 au départ, et ajoutez +1 à insertIndex. 
4. Renvoyer insertIndex car c'est le k. 

Cette question est relativement simple une fois que vous savez comment procéder. Si vous consacrez plus de temps à la compréhension de l'énoncé, vous pourrez facilement trouver une solution. 

def removeDuplicates(array):
    size = len(array)
    insertIndex = 1
    for i in range(1, size):
        if array[i - 1] != array[i]:
            # Updating insertIndex in our main array
            array[insertIndex] = array[i]
            # Incrementing insertIndex count by 1
            insertIndex = insertIndex + 1
    return insertIndex

array_1 = [1,2,2,3,3,4]
removeDuplicates(array_1)
# 4


array_2 = [1,1,3,4,5,6,6]
removeDuplicates(array_2)
# 5

19. Déterminez le bénéfice maximal d'une vente unique

La liste des cours des actions vous est fournie et vous devez indiquer le prix d'achat et le prix de vente pour réaliser le bénéfice le plus élevé. 

Note: Nous devons réaliser le maximum de bénéfices à partir d'un seul achat ou d'une seule vente, et si nous ne pouvons pas réaliser de bénéfices, nous devons réduire nos pertes. 

Exemple 1: stock_price = [8, 4, 12, 9, 20, 1], buy = 4, et sell = 20. Maximiser le profit. 

Exemple 2: stock_price = [8, 6, 5, 4, 3, 2, 1], buy = 6, et sell = 5. Minimiser la perte.

Solution:

1. Nous calculerons le bénéfice global en soustrayant la vente globale (le premier élément de la liste) de l'achat courant (le deuxième élément de la liste). 
2. Exécutez la boucle pour la plage de 1 à la longueur de la liste. 
3. Dans la boucle, calculez le bénéfice actuel en utilisant les éléments de la liste et la valeur d'achat actuelle. 
4. Si le bénéfice actuel est supérieur au bénéfice global, remplacez le bénéfice global par le bénéfice actuel et la vente globale par l'élément i de la liste.
5. Si l'achat actuel est supérieur à l'élément actuel de la liste, remplacez l'achat actuel par l'élément actuel de la liste. 
6. En fin de compte, nous reviendrons à la valeur globale d'achat et de vente. Pour obtenir la valeur d'achat globale, nous soustrayons la valeur de vente globale du bénéfice global.

La question est un peu délicate et vous pouvez trouver votre propre algorithme pour résoudre les problèmes. 

def buy_sell_stock_prices(stock_prices):
    current_buy = stock_prices[0]
    global_sell = stock_prices[1]
    global_profit = global_sell - current_buy

    for i in range(1, len(stock_prices)):
        current_profit = stock_prices[i] - current_buy

        if current_profit > global_profit:
            global_profit = current_profit
            global_sell = stock_prices[i]

        if current_buy > stock_prices[i]:
            current_buy = stock_prices[i]

    return global_sell - global_profit, global_sell

stock_prices_1 = [10,9,16,17,19,23]
buy_sell_stock_prices(stock_prices_1)
# (9, 23)


stock_prices_2 = [8, 6, 5, 4, 3, 2, 1]
buy_sell_stock_prices(stock_prices_2)
# (6, 5)

Questions d'entretien Amazon Python

Les questions de l'entretien Amazon Python peuvent varier considérablement, mais peuvent inclure : 

20. Trouvez le nombre manquant dans le tableau

On vous a fourni la liste des entiers positifs de 1 à n. Tous les nombres de 1 à n sont présents sauf x, et vous devez trouver x. 

Exemple:

• n = 8 
• nombre manquant = 7

Cette question est un simple problème mathématique.

1. Trouvez la somme de tous les éléments de la liste.
2. En utilisant la formule de la somme des séries arithmétiques, nous trouverons la somme attendue des n premiers nombres. 
3. Renvoie la différence entre la somme attendue et la somme des éléments.  

def find_missing(input_list):

  sum_of_elements = sum(input_list)
 
  # There is exactly 1 number missing
  n = len(input_list) + 1
  actual_sum = (n * ( n + 1 ) ) / 2
 
  return int(actual_sum - sum_of_elements)
list_1 = [1,5,6,3,4]


find_missing(list_1)
# 2

21. Triplet pythagoricien dans un tableau

Ecrivez une fonction qui renvoie True s'il existe un triplet pythagoricien qui satisfait a2+ b2 = c2

Exemple:

Solution:

1. Placez au carré tous les éléments du tableau.
2. Triez le tableau par ordre croissant.
3. Effectuez deux boucles. La boucle externe commence à partir du dernier index du tableau jusqu'à 1 et la boucle interne commence à partir de (outer_loop_index -1) jusqu'au début.
4. Créez set() pour stocker les éléments entre l'index de la boucle extérieure et l'index de la boucle intérieure.
5. Vérifier s'il existe un nombre dans l'ensemble qui est égal à (array[outerLoopIndex] - array[innerLoopIndex]). Si oui, renvoyez True, sinon False. 

def checkTriplet(array):
    n = len(array)
    for i in range(n):
        array[i] = array[i]**2

    array.sort()

    for i in range(n - 1, 1, -1):
        s = set()
        for j in range(i - 1, -1, -1):
            if (array[i] - array[j]) in s:
                return True
            s.add(array[j])
    return False


arr = [3, 2, 4, 6, 5]
checkTriplet(arr)
# True

22. De combien de façons pouvez-vous rendre la monnaie avec des pièces et un montant total ?

Nous devons créer une fonction qui prend une liste de dénominations de pièces et de montants totaux et qui renvoie le nombre de façons dont nous pouvons effectuer la monnaie. 

Dans l'exemple, nous avons indiqué les dénominations des pièces [1, 2, 5] et le montant total de 5. En retour, nous avons reçu cinq façons de changer les choses. 

Image par l'auteur

Solution:

1. Nous allons créer une liste de taille montant + 1. Des espaces supplémentaires sont ajoutés pour stocker la solution pour un montant nul.
2. Nous établirons une liste de solutions avec 1.
3. Nous effectuerons deux boucles. La boucle externe renvoie le nombre de coupures et la boucle interne s'étend de l'indice de la boucle externe au montant +1.
4. Les résultats des différentes coupures sont stockés dans le tableau solution. solution[i] = solution[i] + solution[i - den]
5. Le processus sera répété pour tous les éléments de la liste des dénominations, et au dernier élément de la liste des solutions, nous aurons notre numéro.

def solve_coin_change(denominations, amount):
    solution = [0] * (amount + 1)
    solution[0] = 1
    for den in denominations:
        for i in range(den, amount + 1):
            solution[i] += solution[i - den]

    return solution[len(solution) - 1]

denominations = [1,2,5]
amount = 5

solve_coin_change(denominations,amount)
# 4

Questions d'entretien Google Python

Comme pour les autres entreprises mentionnées, les questions posées lors des entretiens avec Google Python dépendent du rôle et du niveau d'expérience. Cependant, les questions les plus fréquentes sont les suivantes :

23. Définissez une fonction lambda, un itérateur et un générateur en Python.

La fonction Lambda est également connue sous le nom de fonction anonyme. Vous pouvez ajouter autant de paramètres que vous le souhaitez, mais avec une seule déclaration. 

Un itérateur est un objet que l'on peut utiliser pour itérer sur des objets itérables tels que des listes, des dictionnaires, des tuples et des ensembles.

Le générateur est une fonction similaire à une fonction normale, mais il génère une valeur en utilisant le mot-clé yield au lieu de return. Si le corps de la fonction contient un rendement, il devient automatiquement un générateur.  

Pour en savoir plus sur les itérateurs et les générateurs Python, consultez notre tutoriel complet. 

24. Étant donné un tableau arr[], trouvez le maximum j - i tel que arr[j] > arr[i]

Cette question est assez simple mais nécessite une attention particulière aux détails. Nous disposons d'un tableau d'entiers positifs. Nous devons trouver la différence maximale entre j-i où array[j] > array[i].

Exemples :

1. Entrée : [20, 70, 40, 50, 12, 38, 98], Sortie : 6  (j = 6, i = 0)
2. Entrée : [10, 3, 2, 4, 5, 6, 7, 8, 18, 0], Sortie : 8 ( j = 8, i = 0)

Solution: 

1. Calculez la longueur du tableau et initiez la différence maximale avec -1.
2. Effectuez deux boucles. La boucle extérieure sélectionne des éléments à partir de la gauche et la boucle intérieure compare les éléments sélectionnés avec les éléments commençant à partir de la droite. 
3. Arrêtez la boucle intérieure lorsque l'élément est plus grand que l'élément choisi et continuez à mettre à jour la différence maximale en utilisant j - I. 

def max_index_diff(array):
    n = len(array)
    max_diff = -1
    for i in range(0, n):
        j = n - 1
        while(j > i):
            if array[j] > array[i] and max_diff < (j - i):
                max_diff = j - i
            j -= 1

    return max_diff

array_1 = [20,70,40,50,12,38,98]

max_index_diff(array_1)
# 6

25. Comment utiliseriez-vous les opérateurs ternaires en Python ?

Les opérateurs ternaires sont également connus sous le nom d'expressions conditionnelles. Il s'agit d'opérateurs qui évaluent l'expression en fonction des conditions Vrai et Faux.

Vous pouvez écrire des expressions conditionnelles sur une seule ligne au lieu d'utiliser plusieurs lignes d'instructions if-else. Il vous permet d'écrire un code propre et compact. 

Par exemple, nous pouvons convertir des instructions if-else imbriquées en une seule ligne, comme indiqué ci-dessous. 

Instruction If-else

score = 75

if score < 70:
    if score < 50:
        print('Fail')
    else:
        print('Merit')
else:
    print('Distinction')
# Distinction

Opérateur ternaire imbriqué

print('Fail' if score < 50 else 'Merit' if score < 70 else 'Distinction')
# Distinction

Former votre équipe avec Python

Si la préparation aux entretiens Python est essentielle pour les demandeurs d'emploi et les responsables du recrutement, il est tout aussi important pour les entreprises d'investir dans une formation continue à Python pour leurs équipes. À une époque où l'automatisation, l'analyse des données et le développement de logiciels sont essentiels, s'assurer que vos employés possèdent de solides compétences en Python peut être un facteur de transformation pour le succès de votre entreprise.

Si vous êtes un chef d'équipe ou un propriétaire d'entreprise qui souhaite s'assurer que toute son équipe maîtrise Python, DataCamp for Business propose des programmes de formation sur mesure qui peuvent aider vos employés à maîtriser les compétences Python, depuis les bases jusqu'aux concepts avancés. Nous pouvons fournir :

• Des parcours d'apprentissage ciblés: Personnalisable en fonction du niveau de compétence actuel de votre équipe et des besoins spécifiques de votre entreprise.
• Pratique: Des projets du monde réel et des exercices de codage qui renforcent l'apprentissage et améliorent la rétention.
• Suivi des progrès: Des outils pour suivre et évaluer les progrès de votre équipe, en veillant à ce qu'elle atteigne ses objectifs d'apprentissage.

Investir dans le perfectionnement de Python par le biais de plateformes telles que DataCamp permet non seulement d'améliorer les capacités de votre équipe, mais aussi de donner à votre entreprise un avantage stratégique, vous permettant ainsi d'innover, de rester compétitif et de produire des résultats percutants. Contactez notre équipe et demandez une démonstration dès aujourd'hui.

Réflexions finales

La maîtrise de Python est essentielle pour tous ceux qui souhaitent exceller dans les entretiens techniques, qu'il s'agisse d'aspirants professionnels des données, de développeurs ou d'ingénieurs logiciels. Ce guide présente une vue d'ensemble des questions d'entretien les plus courantes en Python, allant du niveau de base au niveau avancé, ainsi que des défis de codage et des questions spécifiques posées par des entreprises technologiques de premier plan.

En vous exerçant à répondre à ces questions et à comprendre leurs solutions, vous pouvez améliorer considérablement vos compétences en matière de résolution de problèmes et vos connaissances techniques, ce qui vous permettra d'être bien préparé pour passer les étapes techniques et de codage de vos entretiens.

L'obtention de certifications Python de haut niveau et l'apprentissage continu par le biais de cours et de projets vous permettront de renforcer votre expertise et vos perspectives de carrière dans l'industrie technologique. Si vous avez besoin de rafraîchir vos compétences, assurez-vous de suivre notre parcours de carrière Associate Data Scientist in Python.