How does functools partial do what it does

Question

I am not able to get my head on how the partial works in functools  I have the following code from here    gt  gt  gt  sum   lambda x  y   x   y  gt  gt  gt  sum 1  2  3  gt  gt  gt  incr   lambda y   sum 1  y   gt  gt  gt  incr 2  3  gt  gt  gt  def sum2 x  y       return x   y   gt  gt  gt  incr2   functools partial sum2  1   gt  gt  gt  incr2 4  5   Now in the line  incr   lambda y   sum 1  y    I get that whatever argument I pass to incr it will be passed as y to lambda which will return sum 1  y  i e 1   y   I understand that  But I didn t understand this incr2 4    How does the 4 gets passed as x in partial function  To me  4 should replace the sum2  What is the relation between x and 4

User · Answer

Also worth to mention  that when partial function passed another function where we want to  hard code  some parameters  that should be rightmost parameter  def func a b       return a b prt   partial func  b 7      print prt 4    return 28   but if we do the same  but changing a parameter instead  def func a b       return a b  prt   partial func  a 7      print prt 4     it will throw error        TypeError  func   got multiple values for argument  a

User · Answer

Roughly  partial does something like this  apart from keyword args support etc    def partial func   part args       def wrapper  extra args           args   list part args          args extend extra args          return func  args       return wrapper   So  by calling partial sum2  4  you create a new function  a callable  to be precise  that behaves like sum2  but has one positional argument less  That missing argument is always substituted by 4  so that partial sum2  4  2     sum2 4  2   As for why it s needed  there s a variety of cases  Just for one  suppose you have to pass a function somewhere where it s expected to have 2 arguments   class EventNotifier object       def   init   self           self  listeners           def add listener self  callback               callback should accept two positional arguments  event and params             self  listeners append callback                     def notify self  event   params           for f in self  listeners              f event  params    But a function you already have needs access to some third context object to do its job   def log event context  event  params       context log event  Something happened  s   s   event  params    So  there are several solutions   A custom object   class Listener object      def   init   self  context          self  context   context     def   call   self  event  params          self  context log event  Something happened  s   s   event  params     notifier add listener Listener context     Lambda   log listener   lambda event  params  log event context  event  params  notifier add listener log listener    With partials   context   get context      whatever notifier add listener partial log event  context     Of those three  partial is the shortest and the fastest   For a more complex case you might want a custom object though

User · Answer

short answer  partial gives default values to the parameters of a function that would otherwise not have default values   from functools import partial  def foo a b       return a b  bar   partial foo  a 1    equivalent to  foo a 1  b  bar b 10   11   1 10 bar a 101  b 10   111 101 10

User · Answer

In my opinion  it s a way to implement currying in python   from functools import partial def add a b       return a   b  def add2number x y z       return x   y   z  if   name         main         add2   partial add 2      print  result of add2   add2 1       add3   partial partial add2number 1  2      print  result of add3  add3 1     The result is 3 and 4

User · Answer

Partials can be used to make new derived functions that have some input parameters pre-assigned  To see some real world usage of partials  refer to this really good blog post  http   chriskiehl com article Cleaner-coding-through-partially-applied-functions   A simple but neat beginner s example from the blog  covers how one might use partial on re search to make code more readable    re search method s signature is    search pattern  string  flags 0     By applying partial we can create multiple versions of the regular expression search to suit our requirements  so for example     is spaced apart   partial re search    a-zA-Z  s     is grouped together   partial re search    a-zA-Z        Now is spaced apart and is grouped together are two new functions derived from re search that have the pattern argument applied since pattern is the first argument in the re search method s signature     The signature of these two new functions callable  is   is spaced apart string  flags 0        pattern   a-zA-Z  s    applied is grouped together string  flags 0    pattern   a-zA-Z     applied   This is how you could then use these partial functions on some text   for text in lines      if is grouped together text           some action text      elif is spaced apart text           some other action text      else          some default action     You can refer the link above to get a more in depth understanding of the subject  as it covers this specific example and much more

User · Answer

This answer is more of an example code  All the above answers give good explanations regarding why one should use partial  I will give my observations and use cases about partial    from functools import partial  def adder a b c       print  a    b    c     format a b c       ans   a b c     print ans  partial adder   partial adder 1 2  partial adder 3      now partial adder is a callable that can take only one argument   Output of the above code should be   a 1 b 2 c 3 6   Notice that in the above example a new callable was returned that will take parameter  c  as it s argument  Note that it is also the last argument to the function   args    1 2  partial adder   partial adder  args  partial adder 3    Output of the above code is also   a 1 b 2 c 3 6   Notice that   was used to unpack the non-keyword arguments and the callable returned in terms of which argument it can take is same as above   Another observation is  Below example demonstrates that partial returns a callable which will take the  undeclared parameter  a  as an argument   def adder a b 1 c 2 d 3 e 4       print  a    b    c    d    e     format a b c d e       ans   a b c d e     print ans  partial adder   partial adder b 10 c 2  partial adder 20    Output of the above code should be   a 20 b 10 c 2 d 3 e 4 39   Similarly   kwargs     b  10  c  2  partial adder   partial adder   kwargs  partial adder 20    Above code prints  a 20 b 10 c 2 d 3 e 4 39   I had to use it when I was using Pool map async method from multiprocessing module  You can pass only one argument to the worker function so I had to use partial to make my worker function look like a callable with only one input argument but in reality my worker function had multiple input arguments

User · Answer

partials are incredibly useful   For instance  in a  pipe-lined  sequence of function calls  in which the returned value from one function is the argument passed to the next    Sometimes a function in such a pipeline requires a single argument  but the function immediately upstream from it returns two values   In this scenario  functools partial might allow you to keep this function pipeline intact   Here s a specific  isolated example  suppose you want to sort some data by each data point s distance from some target     create some data import random as RND fnx   lambda  RND randint 0  10  data      fnx    fnx    for c in range 10    target    2  4   import math def euclid dist v1  v2       x1  y1   v1     x2  y2   v2     return math sqrt  x2 - x1   2    y2 - y1   2    To sort this data by distance from the target  what you would like to do of course is this   data sort key euclid dist    but you can t--the sort method s key parameter only accepts functions that take a single argument   so re-write euclid dist as a function taking a single parameter   from functools import partial  p euclid dist   partial euclid dist  target    p euclid dist now accepts a single argument     gt  gt  gt  p euclid dist  3  3     1 4142135623730951   so now you can sort your data by passing in the partial function for the sort method s key argument   data sort key p euclid dist     verify that it works  for p in data      print round p euclid dist p   3        1 0     2 236     2 236     3 606     4 243     5 0     5 831     6 325     7 071     8 602   Or for instance  one of the function s arguments changes in an outer loop but is fixed during iteration in the inner loop  By using a partial  you don t have to pass in the additional parameter during iteration of the inner loop  because the modified  partial  function doesn t require it    gt  gt  gt  from functools import partial   gt  gt  gt  def fnx a  b  c         return a   b   c   gt  gt  gt  fnx 3  4  5        12   create a partial function  using keyword arg    gt  gt  gt  pfnx   partial fnx  a 12    gt  gt  gt  pfnx b 4  c 5       21   you can also create a partial function with a positional argument   gt  gt  gt  pfnx   partial fnx  12    gt  gt  gt  pfnx 4  5        21   but this will throw  e g   creating partial with keyword argument then calling using positional arguments    gt  gt  gt  pfnx   partial fnx  a 12    gt  gt  gt  pfnx 4  5        Traceback  most recent call last         File   lt pyshell 80 gt    line 1  in  lt module gt        pfnx 4  5        TypeError  fnx   got multiple values for keyword argument  a    another use case  writing distributed code using python s multiprocessing library  A pool of processes is created using the Pool method    gt  gt  gt  import multiprocessing as MP   gt  gt  gt    create a process pool   gt  gt  gt  ppool   MP Pool     Pool has a map method  but it only takes a single iterable  so if you need to pass in a function with a longer parameter list  re-define the function as a partial  to fix all but one    gt  gt  gt  ppool map pfnx   4  6  7  8

[python] How does functools partial do what it does?

Examples related to python

Examples related to functional-programming

Examples related to partial-application

Examples related to functools