Entretien technique Python

## Questions théoriques fréquentes
- **Q: Quelle est la différence entre list et tuple en Python?**
  Un tuple est immutable, tandis qu'une liste est mutable.

- **Q: Expliquez ce que sont les context managers en Python.**
  Ils gèrent automatiquement l'acquisition et le libération des ressources, comme les fichiers ouverts.

- **Q: Qu'est-ce que la GIL (Global Interpreter Lock) et comment affecte-t-il les performances de Python?**
  La GIL permet d'exécuter un seul thread à la fois dans un processus Python, ce qui peut limiter les performances sur des tâches parallèles.

- **Q: Expliquez le principe fondamental du débogage en Python.**
  Le débogage implique de suivre l'exécution d'un programme pour identifier et corriger les erreurs.

- **Q: Quel est le but principal des décorateurs en Python?**
  Les décorateurs sont utilisés pour modifier ou étendre la fonctionnalité d'une fonction ou d'une classe sans modifier son code source.

## Exercices de code classiques
- **Exo 1 : Inverser une chaîne de caractères**
  ```python
  def inverser_chaine(chaine):
      return chaine[::-1]

• Exo 2 : Trouver les éléments communs entre deux listes

  def elements_communs(liste1, liste2):
      return set(liste1) & set(liste2)
  

• Exo 3 : Calculer la factorielle d'un nombre

  import math
  
  def factorielle(n):
      return math.factorial(n)
  

• Exo 4 : Vérifier si une chaîne est un palindrome

  def est_palindrome(chaine):
      return chaine == chaine[::-1]
  

• Exo 5 : Implémenter un tri fusion (Merge Sort)

  def fusionner(liste_gauche, liste_droite):
      result = []
      i = j = 0
  
      while i < len(liste_gauche) and j < len(liste_droite):
          if liste_gauche[i] < liste_droite[j]:
              result.append(liste_gauche[i])
              i += 1
          else:
              result.append(liste_droite[j])
              j += 1
  
      result.extend(liste_gauche[i:])
      result.extend(liste_droite[j:])
      return result
  
  def tri_fusion(liste):
      if len(liste) <= 1:
          return liste
      milieu = len(liste) // 2
      gauche = tri_fusion(liste[:milieu])
      droite = tri_fusion(liste[milieu:])
      return fusionner(gauche, droite)
  

Pièges courants en entretien

• Piège 1 : Utiliser une variable globale inutilement

  def modifier_variable():
      global ma_variable
      ma_variable = 10  # Erreur si 'ma_variable' n'est pas définie globalement
  

• Piège 2 : Ne pas utiliser les fonctionnalités built-in Python

  def somme_liste(liste):
      total = 0
      for element in liste:
          total += element  # Redondant avec la fonction sum()
      return total
  

• Piège 3 : Utiliser des comparaisons trop complexes

  if x > y and x < z or y < x and y > z:  # Complexe et peu clair
      print("Condition vérifiée")
  

• Piège 4 : Ne pas utiliser les générateurs pour des itérations importantes

  def somme_cubes(n):
      return sum(x**3 for x in range(1, n+1))  # Utilisation efficace de la syntaxe du générateur
  

• Piège 5 : Ne pas utiliser les list comprehensions pour des listes simples

  result = []
  for i in range(10):
      if i % 2 == 0:
          result.append(i)  # Redondant avec une compréhension de liste
  

Complexité algorithmique

• O(n) : Boucle simple, parcourt tous les éléments.
• O(n log n) : Algos comme le tri fusion (Merge Sort).
• O(n^2) : Algorithmes quadratiques comme le tri à bulles.
• O(1) : Opérations constantes.

Concepts avancés à connaître

• Méthodes spéciales en Python (__init__, __str__ etc.)
• Decorateurs de classe et méthodes statiques
• Générateurs et expressions génératrices
• Modules et paquets
• Threads et multiprocessing

Conseils pratiques

• Pratiquer régulièrement sur des problèmes de code open-source.
• Faire des exercices sur des plateformes comme LeetCode ou HackerRank.
• Se familiariser avec les outils de débogage Python comme pdb.
• Apprendre à utiliser des environnements virtuels (virtualenv).
• Comprendre la différence entre les threads et les processes en Python.