42 questions et réponses d'entrevue Python en temps réel [2022]
Vous vous préparez activement pour des entretiens d'embauche axés sur Python ? Ou peut-être êtes-vous simplement curieux de mesurer votre niveau de maîtrise de ce langage ? Pas de souci ! Cet article répondra à vos interrogations grâce à une série de questions et de réponses ciblées.
Ce contenu vous aidera à anticiper les types de questions que vous pourriez rencontrer lors de vos entretiens. Il vous permettra également d'auto-évaluer vos compétences en Python. Pour une évaluation précise, prenez le temps de répondre aux questions avant de consulter les solutions. Sans plus attendre, plongeons au cœur des questions !
Les questions sont structurées en différentes sections, chacune dédiée à un thème particulier. Chaque section comprend des questions ainsi que les réponses correspondantes. N'hésitez pas à reformuler les réponses avec vos propres mots, tout en conservant le même sens. Ainsi, l'examinateur n'aura pas l'impression que vous vous contentez de lire une réponse pré-écrite.
Fondamentaux de Python
#1. Qu'est-ce que Python ?
Python est un langage de programmation interprété de haut niveau et polyvalent. Il offre la possibilité de créer une grande variété d'applications grâce à l'utilisation de bibliothèques et de frameworks tiers. Python se positionne comme l'un des langages les plus plébiscités dans des domaines technologiques de pointe comme l'intelligence artificielle et la science des données.
#2. Quelle est la distinction fondamentale entre un interpréteur et un compilateur ?
Un interpréteur effectue une traduction instruction par instruction en code machine, tandis qu'un compilateur convertit l'ensemble du code source en une seule opération en code machine.
#3. Python est-il un langage à typage statique ou dynamique ?
Python est un langage qui utilise le typage dynamique.
#4. Que signifie l'expression "langage à typage dynamique" ?
Les langages à typage dynamique procèdent à la vérification des types de variables lors de l'exécution du programme. Parmi les exemples de langages à typage dynamique, on retrouve Python, JavaScript et Ruby.
Information supplémentaire : Les langages à typage statique réalisent cette vérification au moment de la compilation. C'est le cas de C++, C et Java.
#5. Citez quelques exemples d'applications développées avec Python.
La syntaxe de Python se distingue par sa simplicité et sa facilité d'apprentissage, avec une approche qui se rapproche de l'anglais courant. La communauté de développeurs Python est extrêmement vaste. Il existe une multitude de modules tiers permettant de répondre à divers besoins en matière de développement d'applications. Ainsi, on peut créer des applications web, des interfaces graphiques, des outils en ligne de commande, etc.
L'automatisation constitue l'une des applications les plus populaires de Python. Il est simple de créer des scripts Python pour automatiser des tâches répétitives telles que le nettoyage de disque, l'envoi d'emails ou la récupération de données sur les prix de produits.
Python est également un des langages de prédilection dans le domaine de la science des données.
#6. Quelles applications avez-vous développées en utilisant Python ?
J'ai conçu plusieurs scripts d'automatisation pour éliminer les tâches répétitives et ennuyeuses, ainsi que des scripts pour collecter des informations sur les prix et la disponibilité des produits.
J'ai également utilisé des frameworks tels que Django et Flask pour développer des applications web. Mon expérience inclut la création d'applications web à la fois avec Django et Flask.
Note importante : La réponse ci-dessus est un exemple. Votre réponse peut être complètement différente. Expliquez les différents domaines dans lesquels vous avez travaillé avec Python et, si possible, présentez des exemples d'applications que vous avez réalisées.
Types de données
#7. Quels sont les types de données natifs de Python ?
Python propose plusieurs types de données intégrés. On peut citer `int`, `float`, `complex`, `bool`, `list`, `tuple`, `set`, `dict` et `str`.
Note : Il n'est pas nécessaire d'énumérer tous les types de données disponibles en Python. Mentionnez simplement ceux que vous utilisez le plus souvent. L'examinateur pourra ensuite approfondir en fonction de vos réponses.
#8. Quelle est la différence entre une liste et un tuple ?
Les listes et les tuples sont utilisés pour stocker des collections d'objets. La principale différence réside dans le fait qu'une liste est un objet mutable, tandis qu'un tuple est un objet immuable.
#9. Que sont les types de données mutables et immuables ?
Les types de données mutables peuvent être modifiés après leur création. Les listes, les ensembles et les dictionnaires sont des exemples d'objets mutables en Python.
Les types de données immuables ne peuvent pas être modifiés une fois créés. Les chaînes de caractères et les tuples sont des exemples d'objets immuables en Python.
#10. Décrivez quelques méthodes associées aux listes.
1. `append` - Cette méthode permet d'ajouter un élément à la fin de la liste.
>>> a = [1, 2] >>> a.append(3) >>> a [1, 2, 3]
2. `pop` - Cette méthode sert à retirer un élément d'une liste. Elle supprimera le dernier élément si aucun index n'est spécifié, ou l'élément correspondant à l'index fourni.
>>> a = [1, 2, 3, 4, 5] >>> a.pop() 5 >>> a [1, 2, 3, 4] >>> a.pop(1) 2 >>> a [1, 3, 4]
3. `remove` - Cette méthode est utilisée pour supprimer un élément spécifique de la liste. Il faut fournir la valeur de l'élément à supprimer en tant qu'argument. Seule la première occurrence de l'élément sera retirée.
>>> a = [1, 2, 2, 3, 4] >>> a = [1, 2, 3, 2, 4] >>> a.remove(1) >>> a [2, 3, 2, 4] >>> a.remove(2) >>> a [3, 2, 4]
4. `sort` - Cette méthode permet de trier les éléments d'une liste, soit par ordre croissant, soit par ordre décroissant.
>>> a = [3, 2, 4, 1] >>> a.sort() >>> a [1, 2, 3, 4] >>> a.sort(reverse=True) >>> a [4, 3, 2, 1]
5. `reverse` - Cette méthode inverse l'ordre des éléments dans la liste.
>>> a = [3, 2, 4, 1] >>> a.reverse() >>> a [1, 4, 2, 3]
Note : D'autres méthodes existent telles que `clear`, `insert`, `count`, etc. Il n'est pas nécessaire de détailler chaque méthode à l'examinateur. Contentez-vous de décrire deux ou trois des méthodes que vous utilisez le plus souvent.
#11. Décrivez quelques méthodes associées aux chaînes de caractères.
1. `split` - Cette méthode permet de découper une chaîne en plusieurs morceaux en utilisant un délimiteur. Elle renvoie une liste de chaînes. Par défaut, la chaîne est divisée aux espaces. On peut également fournir un délimiteur spécifique comme argument.
>>> a = "Ceci est un exemple"
>>> a.split()
['Ceci', 'est', 'un', 'exemple']
>>> a = "1, 2, 3, 4, 5, 6"
>>> a.split(", ")
['1', '2', '3', '4', '5', '6']
2. `join` - Cette méthode permet de combiner une liste de chaînes en une seule chaîne, en utilisant un délimiteur spécifique.
>>> a = ['Ceci', 'est', 'un', 'exemple'] >>> ' '.join(a) 'Ceci est un exemple' >>> ', '.join(a) 'Ceci, est, un, exemple'
Note : Il existe d'autres méthodes de chaînes telles que `capitalize`, `isalnum`, `isalpha`, `isdigit`, `lower`, `upper`, `center`, etc.
#12. Qu'est-ce que l'indexation négative dans les listes ?
L'index est utilisé pour accéder aux éléments dans une liste. L'indexation classique commence à 0.
L'indexation négative, à l'instar de l'indexation classique, permet d'accéder aux éléments d'une liste. Cependant, l'indexation négative permet d'accéder aux éléments en partant de la fin de la liste. Le premier indice négatif est -1, puis -2, -3, et ainsi de suite jusqu'à la longueur de la liste.
>>> a = [1, 2, 3, 4, 5] >>> a[-1] 5 >>> a[-3] 3 >>> a[-5] 1
#13. Décrivez quelques méthodes associées aux dictionnaires.
1. `items` - Cette méthode retourne une vue des paires clé-valeur du dictionnaire sous la forme d'une liste de tuples.
>>> a = {1: 'valeur1', 2: 'valeur2', 3: 'valeur3'}
>>> a.items()
dict_items([(1, 'valeur1'), (2, 'valeur2'), (3, 'valeur3')])
2. `pop` - Cette méthode est utilisée pour supprimer une paire clé-valeur du dictionnaire. Elle prend en argument la clé à supprimer.
>>> a = {1: 2, 2: 3}
>>> a.pop(2)
3
>>> a
{1: 2}
Note : D'autres méthodes existent telles que `get`, `keys`, `values`, `clear`, etc.
#14. Qu'est-ce que le découpage (slicing) en Python ?
Le découpage est utilisé pour extraire une sous-partie d'une séquence de données. Il renvoie une nouvelle séquence du même type que la source, en fonction des indices fournis.
Le découpage prend jusqu'à trois arguments : l'indice de début, l'indice de fin et le pas. La syntaxe est `variable[start:end:step]`. Les arguments sont facultatifs. On peut spécifier une séquence vide (:) pour extraire l'intégralité des données.
>>> a = [1, 2, 3, 4, 5] >>> a[:] [1, 2, 3, 4, 5] >>> a[:3] [1, 2, 3] >>> a[3:] [4, 5] >>> a[0:5:2] [1, 3, 5]
#15. Sur quels types de données le découpage est-il applicable ?
Le découpage peut être utilisé sur les listes, les tuples et les chaînes de caractères.
#16. Que sont les opérateurs de déballage en Python et comment les utiliser ?
Les opérateurs `*` et `**` sont des opérateurs de déballage en Python.
L'opérateur de déballage `*` est utilisé pour affecter plusieurs valeurs simultanément à des variables, à partir de séquences de données.
>>> items = [1, 2, 3] >>> a, b, c = items >>> a 1 >>> b 2 >>> c 3 >>> a, *b = items >>> a 1 >>> b [2, 3]
L'opérateur de déballage `**` est utilisé avec les dictionnaires. Le déballage avec les dictionnaires fonctionne différemment de celui des séquences.
Le déballage des dictionnaires est principalement utilisé pour copier des paires clé-valeur d'un dictionnaire dans un autre.
>>> a = {1:2, 3:4}
>>> b = {**a}
>>> b
{1: 2, 3: 4}
>>> c = {3:5, 5:6}
>>> b = {**a, **c}
>>> b
{1: 2, 3: 5, 5: 6}
Note : Vous pouvez consulter des ressources complémentaires pour approfondir le sujet de ces opérateurs.
Conditions et boucles
#17. Python possède-t-il des instructions `switch` ?
Non, Python ne possède pas d'instruction `switch`.
#18. Comment peut-on implémenter la logique d'une instruction `switch` en Python ?
On peut utiliser des instructions `if` et `elif` pour implémenter la logique d'une instruction `switch`.
>>> if a == 1: ... print(...) ... elif a == 2: ... print(....)
#19. Que sont les instructions `break` et `continue` ?
`break` - L'instruction `break` permet d'interrompre l'exécution de la boucle en cours. Le flux d'exécution reprendra après la boucle.
>>> for i in range(5): ... if i == 3: ... break ... print(i) ... 0 1 2
`continue` - L'instruction `continue` permet d'interrompre l'exécution de l'itération actuelle de la boucle. Le flux d'exécution passera à l'itération suivante.
>>> for i in range(5): ... if i == 3: ... continue ... print(i) ... 0 1 2 4
#20. Quand le code contenu dans le bloc `else` est-il exécuté avec les boucles `while` et `for` ?
Le code du bloc `else` est exécuté après l'achèvement de toutes les itérations des boucles `while` et `for`, à condition que la boucle n'ait pas été interrompue par une instruction `break`.
#21. Que sont les compréhensions de listes et de dictionnaires ?
Les compréhensions de listes et de dictionnaires sont des raccourcis syntaxiques qui permettent de créer des listes et des dictionnaires de manière concise, en se basant sur des boucles `for`.
>>> a = [i for i in range(10)]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a = {i: i + 1 for i in range(10)}
>>> a
{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}
>>>
#22. Comment fonctionne la fonction `range` ?
La fonction `range` génère une séquence de nombres comprise entre une borne inférieure (incluse) et une borne supérieure (exclue), avec un pas d'incrément. La syntaxe est `range(start, stop[, step])`.
L'argument `stop` est obligatoire, tandis que `start` et `step` sont facultatifs. La valeur par défaut de `start` est 0 et celle de `step` est 1.
>>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(1, 10)) [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(1, 10, 2)) [1, 3, 5, 7, 9] >>>
Fonctions
#23. Quelle est la distinction entre paramètres et arguments ?
Les paramètres sont les noms de variables listés dans la définition d'une fonction.
Les arguments sont les valeurs que l'on passe à une fonction lors de son appel.
#24. Quels sont les différents types d'arguments en Python ?
Il existe principalement quatre types d'arguments : les arguments positionnels, les arguments par défaut, les arguments par mot-clé et les arguments arbitraires.
Arguments positionnels : Les arguments définis de manière classique dans une fonction sont considérés comme des arguments positionnels. Ils doivent être fournis dans l'ordre lors de l'appel de la fonction.
>>> def add(a, b): ... return a + b ... >>> add(1, 2) 3 >>> add(1) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: add() missing 1 required positional argument: 'b' >>>
Arguments par défaut : On peut affecter une valeur par défaut aux arguments dans la définition de la fonction. Si l'utilisateur ne fournit pas de valeur lors de l'appel, la valeur par défaut sera utilisée.
>>> def add(a, b=3): ... return a + b ... >>> add(1, 2) 3 >>> add(1) 4
Arguments par mot-clé : On peut spécifier le nom des arguments lors de l'appel de la fonction, en leur affectant des valeurs. L'ordre des arguments n'a alors plus d'importance.
>>> def add(a, b):
... print("a ", a)
... print("b ", b)
... return a + b
...
>>> add(b=4, a=2)
a 2
b 4
6
Arguments arbitraires : On utilise des arguments arbitraires pour collecter un nombre variable de valeurs que la fonction va recevoir. On utilise les opérateurs `*` et `**` dans la définition de la fonction pour collecter ces arguments.
>>> def add(*args):
... return sum(args)
...
>>> add(1, 2, 3, 4, 5)
15
>>> def dict_args(**kwargs):
... print(kwargs)
...
>>> dict_args(a="valeur1", b='valeur2', c="valeur3")
{'a': 'valeur1', 'b': 'valeur2', 'c': 'valeur3'}
#25. Qu'est-ce qu'une fonction lambda ?
Les fonctions lambda sont de petites fonctions anonymes en Python. Elles sont composées d'une seule expression et peuvent prendre plusieurs arguments.
>>> add = lambda a, b: a + b >>> add(1, 3) 4
#26. Quelle est la différence entre une fonction normale et une fonction lambda ?
Les fonctions normales et les fonctions lambda sont similaires dans leur fonctionnalité, mais les fonctions normales nécessitent un code plus volumineux que les fonctions lambda pour une même action.
Les fonctions lambda sont particulièrement utiles lorsqu'il s'agit d'exprimer une seule expression.
#27. À quoi sert le mot-clé `pass` ?
Le mot-clé `pass` permet d'indiquer un bloc de code vide. Python ne permet pas de laisser un bloc sans aucun code. L'instruction `pass` permet de définir des blocs vides (lorsque l'on prévoit d'y insérer du code ultérieurement).
>>> def add(*args):
...
...
File "<stdin>", line 3
^
IndentationError: expected an indented block
>>> def add(*args):
... pass
...
>>>
#28. Qu'est-ce qu'une fonction récursive ?
Une fonction récursive est une fonction qui s'appelle elle-même.
Que sont les opérateurs de conditionnement en Python ? Comment les utiliser ?
Les opérateurs de conditionnement sont utilisés pour collecter plusieurs arguments dans les fonctions. On parle également d'arguments arbitraires.
Note : Vous pouvez consulter des ressources complémentaires pour approfondir le sujet de ces opérateurs.
#29. Programmation Orientée Objet (POO) en Python
Quel mot-clé est utilisé pour créer des classes en Python ?
Le mot-clé `class` est utilisé pour créer des classes en Python. Il est recommandé de suivre la convention du "PascalCase" pour nommer les classes.
>>> class Voiture: ... pass ...
#30. Comment instancier une classe en Python ?
On crée une instance d'une classe en l'appelant comme une fonction. On peut passer les attributs de l'objet de la même manière qu'on passe les arguments d'une fonction.
>>> class Voiture:
... def __init__(self, couleur):
... self.couleur = couleur
...
>>> voiture_rouge = Voiture('rouge')
>>> voiture_rouge.couleur
'rouge'
>>> voiture_verte = Voiture('vert')
>>> voiture_verte.couleur
'vert'
>>>
#31. Que représente le mot-clé `self` en Python ?
`self` représente l'objet de la classe. Il est utilisé pour accéder aux attributs et méthodes de l'objet depuis l'intérieur de la classe.
#32. Qu'est-ce que la méthode `__init__` ?
La méthode `__init__` est le constructeur de la classe. Elle est exécutée immédiatement lors de la création d'un objet. Elle est utilisée pour initialiser les données de l'instance.
#33. Qu'est-ce qu'une docstring en Python ?
Les docstrings (chaînes de documentation) sont utilisées pour documenter des blocs de code. Elles sont également utilisées pour les commentaires multilignes.
Les docstrings dans les méthodes d'une classe décrivent ce que fait une méthode spécifique. On peut consulter la docstring d'une méthode en utilisant la fonction `help`.
>>> class Voiture:
... def __init__(self, couleur):
... self.couleur = couleur
...
... def changer_couleur(self, nouvelle_couleur):
... """Cette méthode modifie la couleur de la voiture"""
... self.couleur = nouvelle_couleur
...
>>> voiture = Voiture('rouge')
>>> help(voiture.changer_couleur)
Help on method changer_couleur in module __main__:
changer_couleur(nouvelle_couleur) method of __main__.Voiture instance
Cette méthode modifie la couleur de la voiture
>>>
#34. Que sont les méthodes magiques ou "dunder" ?
Les méthodes qui commencent et finissent par deux underscores (`__`) sont appelées méthodes "dunder" ou méthodes magiques. Elles sont principalement utilisées pour surcharger des comportements par défaut. Exemples : `__str__`, `__len__`, `__setitem__`, `__getitem__`, etc.
>>> class Voiture: ... def __str__(self): ... return "Ceci est une classe Voiture" ... >>> voiture = Voiture() >>> print(voiture) Ceci est une classe Voiture >>>
Note : Il existe de nombreuses autres méthodes "dunder" que vous pouvez surcharger. Elles sont utiles pour personnaliser finement le comportement de vos objets. N'hésitez pas à consulter la documentation pour en savoir plus.
#35. Comment implémenter l'héritage en Python ?
On peut spécifier la classe parent comme argument de la classe enfant. On peut aussi invoquer la méthode `__init__` de la classe parent depuis la méthode `__init__` de la classe enfant.
>>> class Animal:
... def __init__(self, nom):
... self.nom = nom
...
>>> class Animal:
... def __init__(self, nom):
... self.nom = nom
...
... def afficher(self):
... print(self.nom)
>>> class Chien(Animal):
... def __init__(self, nom):
... super().__init__(nom)
...
>>> chien = Chien('Tommy')
>>> chien.afficher()
Tommy
>>>
#36. Comment accéder à la classe parent depuis l'intérieur de la classe enfant en Python ?
On utilise `super()` pour faire référence à la classe parent depuis la classe enfant. On peut ensuite accéder aux attributs et aux méthodes de la classe parent en utilisant cet objet.
Divers
#37. Comment utiliser les commentaires sur une seule ligne et sur plusieurs lignes en Python ?
On utilise le symbole dièse (`#`) pour les commentaires sur une seule ligne. Et les triples guillemets simples (`'''commentaire'''`) ou triples guillemets doubles (`"""commentaire"""`) pour les commentaires multilignes.
#38. Qu'est-ce qu'un objet en Python ?
En Python, tout est objet. Les types de données, les fonctions et les classes sont tous des objets.
#39. Quelle est la différence entre `is` et `==` ?
L'opérateur `==` est utilisé pour vérifier si deux objets ont la même valeur. L'opérateur `is` est utilisé pour vérifier si deux objets font référence au même emplacement mémoire.
>>> a = [] >>> b = [] >>> c = a >>> a == b True >>> a is b False >>> a is c True >>>
#40. Qu'est-ce qu'une copie superficielle et une copie profonde ?
Copie superficielle : Elle crée une copie de l'objet sans modifier les références aux objets imbriqués. Les objets copiés et originaux partagent les mêmes références aux objets imbriqués. Toute modification sur un objet imbriqué se répercutera sur l'autre.
On utilise la méthode `copy()` du module `copy` pour effectuer une copie superficielle.
>>> from copy import copy >>> a = [1, [2, 3]] >>> b = copy(a) >>> a[1].append(4) >>> a [1, [2, 3, 4]] >>> b [1, [2, 3, 4]]
Copie profonde : Elle copie les valeurs de l'objet original de manière récursive dans un nouvel objet. On utilise la fonction `deepcopy()` du module `copy` pour effectuer une copie profonde.
>>> from copy import deepcopy >>> a = [1, [2, 3]] >>> b = deepcopy(a) >>> a[1].append(4) >>> a [1, [2, 3, 4]] >>> b [1, [2, 3]] >>> b[1].append(5) >>> a [1, [2, 3, 4]] >>> b [1, [2, 3, 5]] >>>
#41. Que sont les itérateurs ?
Les itérateurs sont des objets qui mémorisent leur état d'itération. Ils initialisent les données avec la méthode `__iter__` et renvoient l'élément suivant en utilisant la méthode `__next__`.
On appelle la fonction `next(itérateur)` pour obtenir l'élément suivant de l'itérateur. On peut convertir une séquence de données en un itérateur grâce à la fonction `iter()`.
>>> a = [1, 2] >>> iterator = iter(a) >>> next(iterator) 1 >>> next(iterator) 2 >>> next(iterator) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>>
#42. Que sont les générateurs ?
Les générateurs sont des fonctions qui renvoient un itérateur. Ils utilisent l'instruction `yield` pour produire des données.
>>> def nombres(n): ... for i in range(1, n + 1): ... yield i ... >>> _10 = nombres(10) >>> next(_10) 1 >>> next(_10) 2 >>> next(_10) 3 >>> next(_10) 4
Conclusion 👨💻
Les questions sont loin d'être limitées à celles présentées ici. Cet article offre un aperçu des différents types de questions qui peuvent être posées lors d'un entretien axé sur Python. Cependant, le champ des possibles est plus vaste.
Pour bien se préparer, il est conseillé de se poser régulièrement des questions sur les différents concepts. Essayez de formuler vous-même des questions sur un sujet précis, et répondez-y. Vous serez ainsi moins susceptible d'être pris au dépourvu lors d'un entretien. N'hésitez pas non plus à utiliser un compilateur Python en ligne pour mettre en pratique votre code.
Bon courage pour votre prochain entretien Python ! 👍