Comment utilisez-vous le module Functools dans Python?

Comment utilisez-vous le module Functools dans Python?

Le module functools dans Python est utilisé pour améliorer la fonctionnalité des fonctions et d'autres objets appelés sans modifier leur code source. Il fournit diverses fonctions d'ordre supérieur qui fonctionnent ou renvoient d'autres fonctions. Voici comment vous pouvez utiliser certains des outils les plus courants du module functools :

1. Décorateurs : functools propose des décorateurs comme wraps , qui est couramment utilisé pour préserver les métadonnées (comme le nom et le docstring) de la fonction originale lors de la création d'un décorateur.

    <code class="python">from functools import wraps def my_decorator(func): @wraps(func) def wrapper(*args, **kwargs): print("Something is happening before the function is called.") func(*args, **kwargs) print("Something is happening after the function is called.") return wrapper @my_decorator def say_hello(): """Say hello function""" print("Hello!") say_hello()</code>

2. partial : cette fonction est utilisée pour créer une nouvelle version d'une fonction avec certains arguments pré-remplis.

    <code class="python">from functools import partial def multiply(x, y): return x * y # Create a new function that multiplies by 2 doubled = partial(multiply, 2) print(doubled(4)) # Output: 8</code>

3. reduce : Cette fonction applique une fonction de deux arguments cumulativement aux éléments d'une séquence, de gauche à droite, afin de réduire la séquence à une seule valeur.

    <code class="python">from functools import reduce numbers = [1, 2, 3, 4] result = reduce(lambda x, y: xy, numbers) print(result) # Output: 10</code>

4. lru_cache : Il s'agit d'un décorateur qui ajoute des capacités de mémoire (de mise en cache) à une fonction, qui peut être utile pour accélérer des fonctions ou des fonctions récursives avec des calculs coûteux.

    <code class="python">from functools import lru_cache @lru_cache(maxsize=None) def fibonacci(n): if n </code>

Quels sont les exemples pratiques d'utiliser des décorateurs de Functools à Python?

Les décorateurs de Functools offrent un moyen puissant d'améliorer le comportement des fonctions dans Python. Voici quelques exemples pratiques:

1. Résultats de mise en cache : à l'aide de @lru_cache pour mémoriser les résultats de la fonction pour les appels ultérieurs plus rapides.

    <code class="python">from functools import lru_cache @lru_cache(maxsize=None) def expensive_function(n): # Simulate an expensive computation return n ** n print(expensive_function(10)) # First call is slow print(expensive_function(10)) # Second call is fast due to caching</code>

2. Préserver les métadonnées de la fonction : utiliser @wraps pour préserver les noms de fonction et les docstrings lors de l'écriture de décorateurs.

    <code class="python">from functools import wraps def timer_decorator(func): @wraps(func) def wrapper(*args, **kwargs): import time start_time = time.time() result = func(*args, **kwargs) end_time = time.time() print(f"{func.__name__} took {end_time - start_time} seconds to run.") return result return wrapper @timer_decorator def slow_function(): """A function that simulates a slow operation.""" import time time.sleep(2) return "Done" print(slow_function.__name__) # Output: slow_function print(slow_function.__doc__) # Output: A function that simulates a slow operation.</code>

3. Appels de la fonction de journalisation : un décorateur pour enregistrer les appels de la fonction et leurs arguments.

    <code class="python">from functools import wraps def log_calls(func): @wraps(func) def wrapper(*args, **kwargs): print(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}") return func(*args, **kwargs) return wrapper @log_calls def add(a, b): return ab print(add(2, 3)) # Output: Calling add with args: (2, 3), kwargs: {}</code>

Comment functools.lru_cache peut-il améliorer les performances de votre code Python?

functools.lru_cache est un décorateur qui met en œuvre la mémorisation, qui peut améliorer considérablement les performances des fonctions avec des appels répétitifs, en particulier ceux qui ont des calculs récursifs ou coûteux. Voici comment cela fonctionne et ses avantages:

1. Résultats de la mise en cache : lru_cache stocke les résultats des appels de fonction et renvoie le résultat mis en cache lorsque les mêmes entrées se reproduisent. Cela réduit le nombre d'appels de fonction réels, ce qui peut entraîner des améliorations de vitesse spectaculaires.

    <code class="python">from functools import lru_cache @lru_cache(maxsize=None) def fibonacci(n): if n </code>

2. Efficacité de la mémoire : le paramètre maxsize vous permet de contrôler la taille du cache. Une valeur None signifie que le cache peut croître sans lié, tandis que la spécification d'un nombre limite la taille du cache, qui peut être utile pour gérer l'utilisation de la mémoire.
3. Sécurité du thread : lru_cache est en filetage, ce qui le rend adapté à une utilisation dans des applications multi-thread.
4. Facilité d'utilisation : l'application du décorateur est simple et ne nécessite pas de modification du code source de la fonction.

5. Analyse des performances : vous pouvez mesurer l'efficacité du cache en comparant le temps d'exécution de la fonction avec et sans le décorateur.

    <code class="python">import time @lru_cache(maxsize=None) def expensive_function(n): time.sleep(1) # Simulate an expensive computation return n ** n start_time = time.time() result = expensive_function(10) end_time = time.time() print(f"First call took {end_time - start_time} seconds") start_time = time.time() result = expensive_function(10) end_time = time.time() print(f"Second call took {end_time - start_time} seconds")</code>

Quels sont les avantages de l'utilisation de Functools.Partial pour la personnalisation des fonctions dans Python?

functools.partial est un outil utile pour créer de nouveaux objets appelés avec certains arguments de la fonction d'origine pré-remplie. Voici les avantages de l'utilisation functools.partial :

1. Simplifier les appels de fonction : en pré-remplissant certains arguments, vous pouvez créer des versions plus simples de fonctions plus faciles à utiliser dans des contextes spécifiques.

    <code class="python">from functools import partial def multiply(x, y): return x * y # Create a new function that multiplies by 2 doubled = partial(multiply, 2) print(doubled(4)) # Output: 8</code>

2. Fonctions de personnalisation : vous pouvez créer des versions personnalisées des fonctions sans modifier la fonction d'origine, qui est utile pour la réutilisation du code et la modularité.

    <code class="python">from functools import partial def greet(greeting, name): return f"{greeting}, {name}!" hello_greet = partial(greet, "Hello") print(hello_greet("Alice")) # Output: Hello, Alice!</code>

3. Amélioration de la lisibilité : en créant des versions spécialisées de fonctions, vous pouvez rendre votre code plus lisible et explicite.

    <code class="python">from functools import partial def power(base, exponent): return base ** exponent square = partial(power, exponent=2) cube = partial(power, exponent=3) print(square(3)) # Output: 9 print(cube(3)) # Output: 27</code>

4. Faciliter les tests : partial peut être utilisé pour créer des versions spécifiques aux tests des fonctions, ce qui facilite l'écriture et la maintenance des tests unitaires.

    <code class="python">from functools import partial def divide(a, b): return a / b # Create a test-specific version of divide divide_by_two = partial(divide, b=2) # Use in a test case assert divide_by_two(10) == 5</code>

5. Intégration avec d'autres outils : partial peut être combiné avec d'autres outils functools , tels que lru_cache , pour créer des personnalisations de fonctions puissantes et efficaces.

    <code class="python">from functools import partial, lru_cache @lru_cache(maxsize=None) def power(base, exponent): return base ** exponent square = partial(power, exponent=2) cube = partial(power, exponent=3) print(square(3)) # Output: 9 print(cube(3)) # Output: 27</code>

En tirant parti functools.partial , vous pouvez améliorer la flexibilité et la maintenabilité de votre code Python, ce qui facilite l'adaptation des fonctions à différents cas d'utilisation sans modifier leurs définitions d'origine.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!