Get best of the week

Introduction à Python Functools

Bonjour, Habrovsk. Nous avons préparé une traduction d'un autre élément utile avant le début du cours de développeur Python .



Python est un langage de programmation orienté objet de haut niveau. L'un des plus grands avantages de Python est qu'il possède une fonctionnalité spéciale qui vous permet d'écrire du code réutilisable à l'aide des outils de langage intégrés.

Functools est une bibliothèque Python conçue pour fonctionner avec des fonctions d'ordre supérieur. Ces fonctions peuvent prendre d'autres fonctions et renvoyer des fonctions. Ils aident le développeur à écrire du code qui peut être réutilisé. Les fonctions peuvent être utilisées ou étendues sans les réécrire complètement. Le module functools en Python fournit divers outils qui vous permettent d'obtenir l'effet décrit. Par exemple, les éléments suivants:

  • Partiel
  • Commande complète;
  • update_wrapperpour partiel .

La fonction partielle est l'un des principaux outils fournis par functools . Voyons cela avec des exemples.

Fonctionnalité partielle en Python


Dans le module functools , la fonction partielle est considérée comme l'un des outils les plus importants. À l'aide d'une fonction partielle , vous pouvez remplacer une fonction existante qui a déjà reçu des arguments. De plus, nous pouvons également créer une nouvelle version de la fonction en ajoutant une documentation de qualité.

Nous pouvons créer de nouvelles fonctions en passant des arguments partiels. Nous pouvons également geler certains arguments de fonction, ce qui entraînera l'apparition d'un nouvel objet. Une autre façon de représenter partielle est qu'avec son aide, nous pouvons créer une fonction avec des valeurs par défaut. Partiel prend en charge les mots clés et les arguments positionnels comme fixes.
Regardons des exemples.

Comment créer une fonction partielle ?


Pour créer une fonction partielle , utilisez functoolspartial() de la bibliothèque . Il est écrit comme suit:

partial(func, /, *args, ** kwargs)

Vous créez donc une fonction partielle qui appelle func , en lui passant des mots-clés fixes et des arguments positionnels. Ici, quelques arguments nécessaires sont généralement passés pour appeler la fonction func . Les arguments restants sont passés dans * args et ** kwargs .

Supposons que la fonction ci-dessous ajoute deux nombres:

def multiply(x, y):
 
    return x * y

Considérons maintenant le cas où nous devions doubler ou tripler un nombre donné. Dans ce cas, nous définissons de nouvelles fonctions comme indiqué ci-dessous:

def multiply(x, y):
        return x * y
 
def doubleNum(x):
       return multiply(x, 2)
 
def tripleNum(x):
       return multiply(x, 3)

Lorsque le script de la fonction n'est que de 2-3, bien sûr, il est plus logique de le faire, comme indiqué ci-dessus. Mais lorsque vous devez écrire 100 autres fonctions de ce type, cela n'a aucun sens de réécrire autant de fois le même code. C'est là que les fonctions partielles sont utiles . Pour les utiliser, nous devons tout d'abord importer des partiels depuis Functools .

from functools import partial
 
def multiply(x, y):
       return x * y
 
doubleNum = partial(multiply, 2)
   tripleNum = partial(multiply, 3)
 
Print(doubleNum(10))
 
Output: 20

Comme vous pouvez le voir dans l'exemple, les valeurs par défaut seront remplacées par les variables à gauche. Au lieu de x, il y en aura 2, et au lieu de y, il y en aura 10 lors de l'appel à doubleNum (10) . Dans cet exemple, l'ordre n'a pas d'importance, mais dans d'autres utilisations, il peut être important. Regardons un exemple pour ce cas pour comprendre l'ordre de substitution des variables.

from functools import partial
def orderFunc(a,b,c,d):
      return a*4 + b*3 + c*2 + d
 
result = partial(orderFunc,5,6,7)
print(result(8))
 
Output: 60

Commande complète


Nous avons une fonction orderFunc()dans laquelle nous multiplions apar 4, bpar 3, cpar 2 et ajoutons des dvaleurs à la somme.

Nous avons créé une fonction partielleresult() qui appelle orderFunc()avec les valeurs 5, 6 et 7. Maintenant, les valeurs 5, 6 et 7 remplaceront les variables a, bet en cconséquence. La variable dsera remplacée par 8, car elle est transmise lorsqu'elle est appelée result(). Le résultat est (4 * 5 + 6 * 3 + 7 * 2 + 8) = 60.

Dans ce cas, l'ordre des valeurs transmises importera, car si l'ordre change, le résultat changera également. Pour corriger des variables, vous pouvez utiliser des mots clés au lieu d'arguments positionnels. Réécrivons le code ci-dessus en utilisant des mots clés comme arguments.

from functools import partial
def orderFunc(a,b,c,d):
       return a*4 + b*3 + c*2 + d
 
 result = partial(orderFunc,c=5,d=6)
print(result(8,4))
 
Output: 60

Ici, nous avons fixé la valeur 5 pour la variable cet 6 pour la variable d. Au lieu de variables a, les bvaleurs 8 et 4. apparaissent. Par conséquent, nous obtenons (8 * 4 + 4 * 3 + 5 * 2 + 6) = 60. La fonction

partielle peut être déterminée dans une boucle et utilisée pour des calculs répétés. Regardons un exemple:

from functools import partial
 
def add(x,y):
      return x + y
 
add_partials = []
for i in range (1, 10):
      function = partial(add, i)
      add_partials.append(function)
      print('Sum of {} and 2 is {}'.format(i,add_partials[i-1](2)))
 
  
Output:
 
Sum of 1 and 2 is 3
Sum of 2 and 2 is 4
Sum of 3 and 2 is 5
Sum of 4 and 2 is 6
Sum of 5 and 2 is 7
Sum of 6 and 2 is 8
Sum of 7 and 2 is 9
Sum of 8 and 2 is 10
Sum of 9 and 2 is 11

Dans cet exemple, nous résumerons une certaine plage de valeurs avec 2, en réutilisant la fonction existante. Nous pouvons appeler partial dans la boucle et utiliser sa fonctionnalité pour calculer les sommes. Comme vous pouvez le voir sur les valeurs en sortie, nous avons un cycle de 1 à 10 et toutes les valeurs de cet intervalle sont ajoutées à 2 à l'aide de la fonction partielle , qui appelle la fonction d'addition.

Métadonnées


Bien que les fonctions partielles soient indépendantes, elles conservent la mémoire (métadonnées) d'une fonction qu'elles étendent.

from functools import partial
 
def add(x,y):
      return x + y
 
# create a new function that multiplies by 2
result = partial(add,y=5)
print(result.func)
print(result.keywords)
 
Output:
<function add at 0x7f27b1aab620>
{'y': 5}

Le premier appel à func passera le nom de la fonction et son adresse en mémoire, et le deuxième appel avec des mots - clés passera les mots-clés à la fonction. Ainsi, les fonctions partielles peuvent être appelées auto-documentées à l'aide de métadonnées qu'elles reçoivent d'une fonction extensible. Nous pouvons mettre à jour les métadonnées de fonction en utilisant un autre outil de functools . Est un outil que vous pouvez utiliser pour mettre à jour les métadonnées des fonctionnalités. Voyons-le avec un exemple.

update_wrapper partial

Update_wrapper

def multiply(x, y):
 
    """Test string."""
 
    return x * y
 
 result = functools.partial(multiply, y=2)
 
 try:
 
    print ('Function Name:'+result.__name__)
 
except AttributeError:
 
    print('Function Name: __no name__')
 
 print ('Function Doc:'+result.__doc__)
 
 print('Updating wrapper:')
 
functools.update_wrapper(result, multiply)
 
 print ('Function Name:'+result.__name__)
 
print ('Function Doc:'+result.__doc__)
 
Output:
 
Function Name: __no name__
 
Function Doc:partial(func, *args, **keywords) - new function with partial application
 
    of the given arguments and keywords.
 
 
Updating wrapper:
 
Function Name: multiply
Function Doc: Test string.

Maintenant, comme vous pouvez le voir sur la sortie, avant d'utiliser le wrapper, la fonction n'avait pas de nom ou de document qui lui était attribué. Dès que nous avons mis à jour les fonctions name et doc avec update_wrapper, nous avons vu le résultat correspondant dans la sortie.

Conclusion


Avec functools, nous pouvons nous débarrasser du code redondant et augmenter les possibilités de réutilisation du code en Python. Plus vous utilisez souvent la fonction partielle , plus vous ouvrirez de cas d'utilisation. Expérimentez et profitez-en!


Prenez le cap.

More articles:


All Articles