Fonctions, fermetures et lambda
Définissez des fonctions auxiliaires réutilisables, utilisez des arguments par défaut et appliquez des expressions lambda au tri et aux schémas fonctionnels des problèmes d’entretien.
Fonctions, fermetures et lambda est une leçon DSA Interview Prep gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage DSA Interview Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours DSA Interview Prep comprend 4 leçons au total.
Définir des fonctions en Python
Les fonctions sont des objets de première classe en Python : vous pouvez les transmettre, les renvoyer et les stocker. Des fonctions auxiliaires bien nommées rendent le code d’entretien lisible. Traitez d’abord les cas limites.
def is_palindrome(s: str) -> bool:
'''Return True if s reads the same forwards and backwards.'''
s = s.lower()
return s == s[::-1]
print(is_palindrome('Racecar')) # True
print(is_palindrome('hello')) # False
# Functions as values
checks = [is_palindrome]
print(checks[0]('level')) # TrueArguments par défaut et nommés
Les valeurs par défaut permettent aux appelants d’omettre certains arguments. Mais n’utilisez jamais une valeur par défaut mutable, comme une liste : tous les appelants la partageraient. La solution consiste à utiliser None par défaut et à créer la liste à l’intérieur de la fonction. Consultez le code.
# WRONG: shared mutable default
def bad_append(val, lst=[]):
lst.append(val)
return lst
print(bad_append(1)) # [1]
print(bad_append(2)) # [1, 2] surprise!
# CORRECT: use None sentinel
def good_append(val, lst=None):
if lst is None:
lst = []
lst.append(val)
return lst
print(good_append(1)) # [1]
print(good_append(2)) # [2]*args et **kwargs
*args rassemble les arguments positionnels supplémentaires dans un tuple ; **kwargs rassemble les arguments nommés supplémentaires dans un dictionnaire. L’astérisque permet également de dépaqueter une séquence lors de l’appel d’une fonction.
def total(*args):
return sum(args)
print(total(1, 2, 3)) # 6
print(total(1, 2, 3, 4)) # 10
# Unpack a list as positional args
point = [3, 7]
print(max(*point)) # 7
# **kwargs
def greet(**kwargs):
name = kwargs.get('name', 'World')
return f'Hello, {name}!'
print(greet(name='Alice')) # Hello, Alice!Expressions lambda
Une lambda est une petite fonction écrite sur une seule ligne : lambda params: expression. Elle est parfaite comme key rapide dans sorted ou max. Pour tout ce qui est plus complexe, une définition def nommée est plus claire.
# Lambda as sort key
pairs = [(1, 3), (2, 1), (3, 2)]
sorted_by_second = sorted(pairs, key=lambda p: p[1])
print(sorted_by_second) # [(2,1),(3,2),(1,3)]
# Lambda with map
double = list(map(lambda n: n * 2, [1, 2, 3]))
print(double) # [2, 4, 6]
# Named function is clearer for complex logic
def sort_key(p):
return (p[1], -p[0]) # secondary sort
print(sorted(pairs, key=sort_key))Fonctions imbriquées et fermetures
Une fermeture est une fonction qui mémorise les variables de la fonction qui l’entoure. Définissez une fonction auxiliaire à l’intérieur d’une autre fonction : elle pourra utiliser les variables externes, ce qui est pratique pour DFS.
def make_counter(start=0):
count = [start] # list to allow mutation
def increment():
count[0] += 1
return count[0]
return increment
counter = make_counter()
print(counter()) # 1
print(counter()) # 2
# Alternative: nonlocal keyword
def make_counter2():
count = 0
def increment():
nonlocal count
count += 1
return count
return incrementFermetures dans un DFS récursif
Voici un schéma courant : définissez une fonction auxiliaire dfs à l’intérieur de la fonction principale et laissez-la accumuler les résultats dans une variable externe. La fonction interne est une fermeture qui capture cette portée.
def max_depth(root):
'''Closure pattern for tree DFS.'''
max_d = [0] # mutable container for closure
def dfs(node, depth):
if node is None:
return
max_d[0] = max(max_d[0], depth)
dfs(node.left, depth + 1)
dfs(node.right, depth + 1)
dfs(root, 1)
return max_d[0]
# This pattern avoids a class or global state.functools.lru_cache pour la mémoïsation
lru_cache (ou @cache à partir de la version 3.9) mémorise les résultats d’une fonction en fonction de ses arguments, transformant le calcul naïf de Fibonacci de O(2^n) en O(n). Les arguments doivent être hachables : utilisez donc des tuples.
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
print(fib(40)) # 102334155 fast!
print(fib.cache_info()) # hits, misses, sizeFonctions d’ordre supérieur
Une fonction d’ordre supérieur reçoit une fonction ou en renvoie une. sorted, map et filter en sont toutes trois. Écrire vos propres fonctions de ce type vous permet d’abstraire les schémas répétitifs. Le code montre la composition.
def apply_twice(f, x):
return f(f(x))
print(apply_twice(lambda n: n * 2, 3)) # 12 (3*2*2)
# Composing transformations
def compose(f, g):
return lambda x: f(g(x))
double = lambda n: n * 2
add_one = lambda n: n + 1
double_then_add = compose(add_one, double)
print(double_then_add(5)) # 11 ((5*2)+1)Récursivité avec des fonctions auxiliaires
De nombreuses solutions associent une fonction externe qui gère l’initialisation et les cas limites à une fonction auxiliaire interne qui effectue la récursivité. L’interface publique reste claire et la logique est isolée. Consultez le code.
def flatten(nested):
'''Flatten an arbitrarily nested list.'''
result = []
def _flatten(lst):
for item in lst:
if isinstance(item, list):
_flatten(item)
else:
result.append(item)
_flatten(nested)
return result
print(flatten([1, [2, [3, 4], 5], 6]))
# [1, 2, 3, 4, 5, 6]Fonctions partielles avec functools.partial
functools.partial préremplit certains arguments et renvoie un nouvel objet appelable. C’est utile lorsqu’une interface attend une fonction sans argument, mais que vous devez lui fournir un paramètre fixe.
from functools import partial
def power(base, exp):
return base ** exp
square = partial(power, exp=2)
cube = partial(power, exp=3)
print(square(5)) # 25
print(cube(3)) # 27
print(list(map(square, [1, 2, 3, 4]))) # [1, 4, 9, 16]Lambda pour des comparateurs personnalisés
Python 3 a supprimé les comparateurs à deux arguments, mais cmp_to_key les rétablit pour les ordres complexes, par exemple pour arranger des nombres afin que leur concaténation soit la plus grande possible. Consultez le code.
from functools import cmp_to_key
def largest_number(nums):
def compare(a, b):
if a + b > b + a: return -1
if a + b < b + a: return 1
return 0
strs = list(map(str, nums))
strs.sort(key=cmp_to_key(compare))
result = ''.join(strs)
return '0' if result[0] == '0' else result
print(largest_number([3, 30, 34, 5, 9])) # '9534330'Vérification rapide
Vérification rapide : montrez ce que vous avez appris sur les fonctions, les fermetures et les lambdas. Respirez un bon coup, puis commencez. 🚀
Récapitulatif de la leçon
Récapitulatif : n’utilisez jamais de valeurs par défaut mutables (utilisez None), les fermetures permettent aux fonctions auxiliaires internes d’accéder aux variables externes pour DFS, et les outils de functools comme lru_cache accélèrent les solutions.
Questions Fréquemment Posées
La leçon « Fonctions, fermetures et lambda » est-elle gratuite ?
Oui — le texte complet de « Fonctions, fermetures et lambda » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours DSA Interview Prep, passe à CoddyKit PRO. Le cours DSA Interview Prep comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Fonctions, fermetures et lambda » ?
Définissez des fonctions auxiliaires réutilisables, utilisez des arguments par défaut et appliquez des expressions lambda au tri et aux schémas fonctionnels des problèmes d’entretien. Tu pratiques DSA Interview Prep avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer DSA Interview Prep ?
Aucune expérience préalable n'est requise. DSA Interview Prep sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Fonctions, fermetures et lambda » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon DSA Interview Prep ?
Oui. Chaque leçon DSA Interview Prep inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Listes, tuples et tranches
- Dictionnaires et ensembles en Python
- Compréhensions et fonctions intégrées
- Fonctions, fermetures et lambda