Questions Python Junior

1. Quelle est la différence entre une liste et un tuple en Python ?

Une liste est mutable (modifiable après création), tandis qu'un tuple est immutable (non modifiable). Les tuples sont plus rapides et peuvent servir de clés de dictionnaire.

ma_liste = [1, 2, 3]    # mutable
mon_tuple = (1, 2, 3)   # immutable

2. Comment fonctionne le GIL (Global Interpréter Lock) ?

Le GIL est un mécanisme de CPython qui empêche l'exécution simultanee de plusieurs threads Python. Cela signifie qu'un seul thread peut exécuter du bytecode Python a la fois, même sur un processeur multi-coeur.

Impact : Les tâches CPU-bound ne beneficient pas du multithreading. Utilisez multiprocessing ou asyncio pour le parallélisme.

3. Quelle différence entre == et is ?

• == compare les valeurs (egalite)
• is compare les identités (même objet en mémoire)

a = [1, 2, 3]
b = [1, 2, 3]
a == b  # True (meme valeur)
a is b  # False (objets differents)

4. Qu'est-ce qu'un décorateur en Python ?

Un décorateur est une fonction qui prend une autre fonction en argument et retourne une version modifiée de cette fonction. C'est un pattern de metaprogrammation.

def mon_decorateur(func):
    def wrapper(*args, **kwargs):
        print("Avant l'appel")
        result = func(*args, **kwargs)
        print("Apres l'appel")
        return result
    return wrapper

@mon_decorateur
def dire_bonjour():
    print("Bonjour !")

5. Comment gérer les exceptions en Python ?

Avec le bloc try/except/else/finally :

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Erreur : {e}")
else:
    print("Pas d'erreur")
finally:
    print("Toujours execute")

6. Quelle est la différence entre *args et **kwargs ?

• *args : arguments positionnels variables (tuple)
• **kwargs : arguments nommés variables (dictionnaire)

def ma_fonction(*args, **kwargs):
    print(args)    # (1, 2, 3)
    print(kwargs)  # {'nom': 'Alice'}

ma_fonction(1, 2, 3, nom='Alice')

7. Comment fonctionne une list compréhension ?

Syntaxe concise pour créer des listes :

carres = [x**2 for x in range(10) if x % 2 == 0]
# [0, 4, 16, 36, 64]

8. Qu'est-ce que __init__ et self ?

• __init__ est le constructeur de la classe, appele à la création d'un objet
• self est la référence à l'instance courante

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

9. Comment fonctionne le slicing en Python ?

Le slicing permet d'extraire des sous-sequences avec la syntaxe [start:stop:step] :

lst = [0, 1, 2, 3, 4, 5]
lst[1:4]    # [1, 2, 3]
lst[::2]    # [0, 2, 4]
lst[::-1]   # [5, 4, 3, 2, 1, 0]

10. Qu'est-ce qu'un générateur ?

Un générateur est une fonction qui utilise yield au lieu de return. Il produit des valeurs à la demande (lazy évaluation), economisant la mémoire.

def compteur(n):
    i = 0
    while i < n:
        yield i
        i += 1

for x in compteur(5):
    print(x)  # 0, 1, 2, 3, 4

11. Quelle est la différence entre une méthode de classe et une méthode statique ?

• @classmethod reçoit la classe comme premier argument (cls)
• @staticmethod ne reçoit ni l'instance ni la classe

12. Comment fonctionne la gestion de la mémoire en Python ?

Python utilise un compteur de références et un garbage collector cyclique. Quand le compteur de références d'un objet tombe a zéro, la mémoire est libérée.

13. Qu'est-ce qu'un context manager ?

Un context manager gere l'acquisition et la liberation de ressources avec with :

with open('fichier.txt', 'r') as f:
    contenu = f.read()
# Le fichier est automatiquement ferme

14. Comment copier une liste en Python ?

# Copie superficielle
copie1 = liste.copy()
copie2 = liste[:]
copie3 = list(liste)

# Copie profonde
import copy
copie_profonde = copy.deepcopy(liste)

15. Qu'est-ce que le duck typing ?

En Python, le type d'un objet est moins important que les méthodes qu'il définit. "Si ca marche comme un canard, c'est un canard."

def longueur(objet):
    return len(objet)  # fonctionne avec str, list, dict, etc.

16-30. Autres questions courantes

• Différence entre append() et extend()
• Comment fonctionne le module collections
• Les f-strings et le formatage de chaînes
• La différence entre import et from ... import
• Les virtual environments avec venv
• Les type hints en Python
• Lambda functions et map/filter/reduce
• La différence entre deepcopy et copy
• Les fichiers __init__.py
• Utilisation de enumerate() et zip()
• Les dictionnaires et leurs méthodes
• La gestion des modules et packages
• Les f-strings vs format() vs %
• Comment debugger en Python
• Les bonnes pratiques PEP 8