Questions Python Junior

1. Quelle est la difference entre une liste et un tuple en Python ?

Une liste est mutable (modifiable apres creation), tandis qu'un tuple est immutable (non modifiable). Les tuples sont plus rapides et peuvent servir de cles de dictionnaire.

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

2. Comment fonctionne le GIL (Global Interpreter Lock) ?

Le GIL est un mecanisme de CPython qui empeche l'execution simultanee de plusieurs threads Python. Cela signifie qu'un seul thread peut executer du bytecode Python a la fois, meme sur un processeur multi-coeur.

Impact : Les taches CPU-bound ne beneficient pas du multithreading. Utilisez multiprocessing ou asyncio pour le parallelisme.

3. Quelle difference entre == et is ?

• == compare les valeurs (egalite)
• is compare les identites (meme objet en memoire)

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 decorateur en Python ?

Un decorateur est une fonction qui prend une autre fonction en argument et retourne une version modifiee 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 gerer 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 difference entre *args et **kwargs ?

• *args : arguments positionnels variables (tuple)
• **kwargs : arguments nommes 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 comprehension ?

Syntaxe concise pour creer 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 a la creation d'un objet
• self est la reference a 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 generateur ?

Un generateur est une fonction qui utilise yield au lieu de return. Il produit des valeurs a la demande (lazy evaluation), economisant la memoire.

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 difference entre une methode de classe et une methode statique ?

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

12. Comment fonctionne la gestion de la memoire en Python ?

Python utilise un compteur de references et un garbage collector cyclique. Quand le compteur de references d'un objet tombe a zero, la memoire est liberee.

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 methodes qu'il definit. "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

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