What does double star asterisk and star asterisk do for parameters

Question

In the following method definitions  what does the   and    do for param2   def foo param1   param2   def bar param1    param2

User · Answer

It s also worth noting that you can use   and    when calling functions as well  This is a shortcut that allows you to pass multiple arguments to a function directly using either a list tuple or a dictionary  For example  if you have the following function   def foo x y z       print  x     str x       print  y     str y       print  z     str z     You can do things like    gt  gt  gt  mylist    1 2 3   gt  gt  gt  foo  mylist  x 1 y 2 z 3   gt  gt  gt  mydict     x  1  y  2  z  3   gt  gt  gt  foo   mydict  x 1 y 2 z 3   gt  gt  gt  mytuple    1  2  3   gt  gt  gt  foo  mytuple  x 1 y 2 z 3   Note  The keys in mydict have to be named exactly like the parameters of function foo  Otherwise it will throw a TypeError    gt  gt  gt  mydict     x  1  y  2  z  3  badnews  9   gt  gt  gt  foo   mydict  Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  TypeError  foo   got an unexpected keyword argument  badnews

User · Answer

and    have special usage in the function argument list    implies that the argument is a list and    implies that the argument is a dictionary  This allows functions to take arbitrary number of arguments

User · Answer

means receive variable arguments as tuple     means receive variable arguments as dictionary  Used like the following   1  single    def foo  args       for arg in args          print arg   foo  two   3    Output   two 3   2  Now     def bar   kwargs       for key in kwargs          print key  kwargs key    bar dic1  two   dic2 3    Output   dic1 two dic2 3

User · Answer

Given a function that has 3 items as argument  sum   lambda x  y  z  x   y   z sum 1 2 3    sum 3 items  sum  1 2 3     error  needs 3 items  not 1 list  x    1 2 3  0  y    1 2 3  1  z    1 2 3  2  sum x y z    ok  sum   1 2 3     ok  1 list becomes 3 items   Imagine this toy with a bag of a triangle  a circle and a rectangle item  That bag does not directly fit  You need to unpack the bag to take those 3 items and now they fit  The Python   operator does this unpack process

User · Answer

def foo param1   param2   is a method can accept arbitrary number of values for  param2  def bar param1    param2   is a method can accept arbitrary number of values with keys for  param2 param1 is a simple parameter    For example  the syntax for implementing varargs in Java as follows   accessModifier methodName datatype    arg           method body

User · Answer

The  args and   kwargs is a common idiom to allow arbitrary number of arguments to functions as described in the section more on defining functions in the Python documentation   The  args will give you all function parameters as a tuple   def foo  args       for a in args          print a           foo 1    1  foo 1 2 3    1   2   3   The   kwargs will give you all  keyword arguments except for those corresponding to a formal parameter as a dictionary   def bar   kwargs       for a in kwargs          print a  kwargs a      bar name  one   age 27    age 27   name one   Both idioms can be mixed with normal arguments to allow a set of fixed and some variable arguments   def foo kind   args    kwargs      pass   It is also possible to use this the other way around   def foo a  b  c       print a  b  c   obj     b  10   c   lee    foo 100   obj    100 10 lee   Another usage of the  l idiom is to unpack argument lists when calling a function   def foo bar  lee       print bar  lee   l    1 2   foo  l    1 2   In Python 3 it is possible to use  l on the left side of an assignment  Extended Iterable Unpacking   though it gives a list instead of a tuple in this context   first   rest    1 2 3 4  first   l  last    1 2 3 4    Also Python 3 adds new semantic  refer PEP 3102    def func arg1  arg2  arg3     kwarg1  kwarg2       pass   Such function accepts only 3 positional arguments  and everything after   can only be passed as keyword arguments

User · Answer

TL DR  Below are 6 different use cases for   and    in python programming    To accept any number of positional arguments using  args  def foo  args   pass  here foo accepts any number of positional arguments  i  e   the following calls are valid foo 1   foo 1   bar   To accept any number of keyword arguments using   kwargs  def foo   kwargs   pass  here  foo  accepts any number of keyword arguments  i  e   the following calls are valid foo name  Tom    foo name  Tom   age 33  To accept any number of positional and keyword arguments using  args    kwargs  def foo  args    kwargs   pass  here foo accepts any number of positional and keyword arguments  i  e   the following calls are valid foo 1 name  Tom    foo 1   bar   name  Tom   age 33  To enforce keyword only arguments using    def foo pos1  pos2     kwarg1   pass  here   means that foo only accept keyword arguments after pos2  hence foo 1  2  3  raises TypeError but foo 1  2  kwarg1 3  is ok  To express no further interest in more positional arguments using     Note  this is a convention only   def foo bar  baz       pass means  by convention  foo only uses bar and baz arguments in its working and will ignore others  To express no further interest in more keyword arguments using       Note  this is a convention only   def foo bar  baz        pass means  by convention  foo only uses bar and baz arguments in its working and will ignore others    BONUS  From python 3 8 onward  one can use   in function definition to enforce  positional only parameters  In the following example  parameters a and b are positional-only  while c or d can be positional or keyword  and e or f are required to be keywords   def f a  b     c  d     e  f       pass

User · Answer

From the Python documentation      If there are more positional arguments than there are formal parameter slots  a TypeError exception is raised  unless a formal parameter using the syntax   identifier  is present  in this case  that formal parameter receives a tuple containing the excess positional arguments  or an empty tuple if there were no excess positional arguments         If any keyword argument does not correspond to a formal parameter name  a TypeError exception is raised  unless a formal parameter using the syntax    identifier  is present  in this case  that formal parameter receives a dictionary containing the excess keyword arguments  using the keywords as keys and the argument values as corresponding values   or a  new  empty dictionary if there were no excess keyword arguments

User · Answer

The single   means that there can be any number of extra positional arguments  foo   can be invoked like foo 1 2 3 4 5   In the body of foo   param2 is a sequence containing 2-5   The double    means there can be any number of extra named parameters  bar   can be invoked like bar 1  a 2  b 3   In the body of bar   param2 is a dictionary containing   a  2   b  3    With the following code   def foo param1   param2       print param1      print param2   def bar param1    param2       print param1      print param2   foo 1 2 3 4 5  bar 1 a 2 b 3    the output is  1  2  3  4  5  1   a   2   b   3

User · Answer

This table is handy for using   and    in function construction and function call               In function construction         In function call                                                                                      def f  args                      def f a  b    args            for arg in args                  return a   b                      print arg                args    1  2               f 1  2                           f  args  ---------- -------------------------------- ---------------------------              def f a  b                       def f a  b     kwargs         return a   b                     return a   b              def g   kwargs                   kwargs   dict a 1  b 2                   return f   kwargs            f   kwargs               g a 1  b 2                      -----------------------------------------------------------------------   This really just serves to summarize Lorin Hochstein s answer but I find it helpful   Relatedly  uses for the star splat operators have been expanded in Python 3

User · Answer

Building on nickd s answer     def foo param1   param2       print param1      print param2    def bar param1    param2       print param1      print param2    def three params param1   param2    param3       print param1      print param2      print param3    foo 1  2  3  4  5  print   n   bar 1  a 2  b 3  print   n   three params 1  2  3  4  s 5    Output   1  2  3  4  5   1   a   2   b   3   1  2  3  4    s   5    Basically  any number of positional arguments can use  args and any named arguments  or kwargs aka keyword arguments  can use   kwargs

User · Answer

I want to give an example which others haven t  mentioned    can also unpack a generator  An example from Python3 Document  x    1  2  3  y    4  5  6   unzip x  unzip y   zip  zip x  y     unzip x will be  1  2  3   unzip y will be  4  5  6   The zip   receives multiple iretable args  and return a generator    zip  zip x y   - gt  zip  1  4    2  5    3  6

User · Answer

For those of you who learn by examples    The purpose of    is to give you the ability to define a function that can take an arbitrary number of arguments provided as a list  e g  f  myList     The purpose of    is to give you the ability to feed a function s arguments by providing a dictionary  e g  f     x    1   y    2        Let us show this by defining a function that takes two normal variables x  y  and can accept more arguments as myArgs  and can accept even more arguments as myKW  Later  we will show how to feed y using myArgDict   def f x  y   myArgs    myKW       print    x            format x       print    y            format y       print    myArgs       format myArgs       print    myKW         format myKW       print    ----------------------------------------------------------------------      Define a list for demonstration purposes myList        Left    Right    Up    Down     Define a dictionary for demonstration purposes myDict        Wubba    lubba    Dub    dub     Define a dictionary to feed y myArgDict     y    Why     y0    Why not     q    Here is a cue       The 1st elem of myList feeds y f  myEx    myList    myDict    x        myEx   y        Left   myArgs     Right    Up    Down     myKW       Wubba    lubba    Dub    dub     ----------------------------------------------------------------------    y is matched and fed first   The rest of myArgDict becomes additional arguments feeding myKW f  myEx     myArgDict    x        myEx   y        Why    myArgs        myKW       y0    Why not     q    Here is a cue      ----------------------------------------------------------------------    The rest of myArgDict becomes additional arguments feeding myArgs f  myEx    myArgDict    x        myEx   y        y   myArgs     y0    q     myKW          ----------------------------------------------------------------------    Feed extra arguments manually and append even more from my list f  myEx   4  42  420   myList   myDict    myDict    x        myEx   y        4   myArgs    42  420   Left    Right    Up    Down    Wubba    Dub     myKW       Wubba    lubba    Dub    dub     ----------------------------------------------------------------------    Without the stars  the entire provided list and dict become x  and y  f myList  myDict    x          Left    Right    Up    Down     y          Wubba    lubba    Dub    dub     myArgs        myKW          ----------------------------------------------------------------------   Caveats      is exclusively reserved for dictionaries  Non-optional argument assignment happens first  You cannot use a non-optional argument twice  If applicable     must come after    always

User · Answer

args and   kwargs  allow you to pass a variable number of arguments to a function     args  is used to send a non-keyworded variable length argument list to the function   def args normal arg   argv       print  normal argument    normal arg       for arg in argv          print  Argument in list of arguments from  argv    arg   args  animals    fish    duck    bird     Will produce   normal argument  animals Argument in list of arguments from  argv  fish Argument in list of arguments from  argv  duck Argument in list of arguments from  argv  bird     kwargs     kwargs allows you to pass keyworded variable length of arguments to a function  You should use   kwargs if you want to handle named arguments in a function    def who   kwargs       if kwargs is not None          for key  value in kwargs items                print  Your  s is  s      key  value    who name  Nikola   last name  Tesla   birthday  7 10 1856   birthplace  Croatia       Will produce   Your name is Nikola  Your last name is Tesla  Your birthday is 7 10 1856  Your birthplace is Croatia

User · Answer

In addition to function calls   args and   kwargs are useful in class hierarchies and also avoid having to write   init   method in Python  Similar usage can seen in frameworks like Django code   For example   def   init   self   args    kwargs       for attribute name  value in zip self  expected attributes  args           setattr self  attribute name  value          if kwargs has key attribute name               kwargs pop attribute name       for attribute name in kwargs viewkeys            setattr self  attribute name  kwargs attribute name     A subclass can then be  class RetailItem Item        expected attributes   Item  expected attributes     name    price    category    country of origin    class FoodItem RetailItem        expected attributes   RetailItem  expected attributes      expiry date     The subclass then be instantiated as   food item   FoodItem name    Jam                         price   12 0                        category    Foods                         country of origin    US                         expiry date   datetime datetime now      Also  a subclass with a new attribute which makes sense only to that subclass instance can call the Base class   init   to offload the attributes setting  This is done through  args and   kwargs  kwargs mainly used so that code is readable using named arguments  For example   class ElectronicAccessories RetailItem        expected attributes   RetailItem  expected attributes      specifications         Depend on args and kwargs to populate the data as needed      def   init   self  specifications   None   args    kwargs           self specifications   specifications    Rest of attributes will make sense to parent class          super ElectronicAccessories  self    init    args    kwargs    which can be instatiated as  usb key   ElectronicAccessories name    Sandisk                                    price     6 00                                    category    Electronics                                   country of origin    CN                                   specifications    4GB USB 2 0 USB 3 0     The complete code is here

User · Answer

TL DR It packs arguments passed to the function into list and dict respectively inside the function body  When you define a function signature like this  def func  args    kwds         do stuff  it can be called with any number of arguments and keyword arguments  The non-keyword arguments get packed into a list called args inside the function body and the keyword arguments get packed into a dict called kwds inside the function body  func  quot this quot    quot is a list of quot    quot non-keyowrd quot    quot arguments quot   keyword  quot ligma quot   options  1 2 3    now inside the function body  when the function is called  there are two local variables  args which is a list having value   quot this quot    quot is a list of quot    quot non-keyword quot    quot arguments quot   and kwds which is a dict having value   quot keyword quot     quot ligma quot    quot options quot     1 2 3    This also works in reverse  i e  from the caller side  for example if you have a function defined as  def f a  b  c  d 1  e 10         do stuff  you can call it with by unpacking iterables or mappings you have in the calling scope  iterable    1  20  500  mapping     quot d quot    100   quot e quot   3  f  iterable    mapping    That call is equivalent to f 1  20  500  d 100  e 3

User · Answer

In Python 3 5  you can also use this syntax in list  dict  tuple  and set displays  also sometimes called literals   See PEP 488  Additional Unpacking Generalizations    gt  gt  gt   0   range 1  4   5   range 6  8    0  1  2  3  5  6  7   gt  gt  gt   0   range 1  4   5   range 6  8    0  1  2  3  5  6  7   gt  gt  gt   0   range 1  4   5   range 6  8    0  1  2  3  5  6  7   gt  gt  gt  d     one   1   two   2   three   3   gt  gt  gt  e     six   6   seven   7   gt  gt  gt    zero   0    d   five   5    e    five   5   seven   7   two   2   one   1   three   3   six   6   zero   0    It also allows multiple iterables to be unpacked in a single function call    gt  gt  gt  range   1  10     2   range 1  10  2     Thanks to mgilson for the PEP link

User · Answer

A good example of using both in a function is    gt  gt  gt  def foo  arg   kwargs           print arg         print kwargs  gt  gt  gt   gt  gt  gt  a    1  2  3   gt  gt  gt  b     aa   11   bb   22   gt  gt  gt   gt  gt  gt   gt  gt  gt  foo  a   b   1  2  3    aa   11   bb   22   gt  gt  gt   gt  gt  gt   gt  gt  gt  foo a   b     1  2  3      aa   11   bb   22   gt  gt  gt   gt  gt  gt   gt  gt  gt  foo a b     1  2  3     aa   11   bb   22       gt  gt  gt   gt  gt  gt   gt  gt  gt  foo a  b    1  2  3    aa    bb

User · Answer

Let us first understand what are positional arguments and keyword arguments  Below is an example of function definition with Positional arguments   def test a b c        print a       print b       print c   test 1 2 3   output  1 2 3   So this is a function definition with positional arguments  You can call it with keyword named arguments as well   def test a b c        print a       print b       print c   test a 1 b 2 c 3   output  1 2 3   Now let us study an example of function definition with keyword arguments   def test a 0 b 0 c 0        print a       print b       print c       print  -------------------------    test a 1 b 2 c 3   output   1 2 3 -------------------------   You can call this function with positional arguments as well   def test a 0 b 0 c 0       print a      print b      print c      print  -------------------------    test 1 2 3    output   1 2 3 ---------------------------------   So we now know function definitions with positional as well as keyword arguments   Now let us study the     operator and      operator   Please note these operators can be used in 2 areas   a  function call  b  function definition  The use of     operator and      operator in function call    Let us get straight to an example and then discuss it   def sum a b     receive args from function calls as sum 1 2  or sum a 1 b 2      print a b   my tuple    1 2  my list    1 2  my dict     a  1  b  2     Let us unpack data structure of list or tuple or dict into arguments with help of     operator sum  my tuple      becomes same as sum 1 2  after unpacking my tuple with     sum  my list       becomes same as sum 1 2  after unpacking my list with      sum   my dict      becomes same as sum a 1 b 2  after unpacking by          output is 3 in all three calls to sum function    So remember   when the     or      operator is used in a function call -      operator unpacks data structure such as a list or tuple  into arguments needed by function definition        operator unpacks a dictionary into arguments needed by function definition   Now let us study the     operator use in function definition  Example   def sum  args    pack the received positional args into data structure of tuple  after applying     - def sum  1 2 3 4       sum   0     for a in args          sum  a     print sum   sum 1 2 3 4    positional args sent to function sum  output  10   In function definition the     operator packs the received arguments into a tuple   Now let us see an example of      used in function definition   def sum   args    pack keyword args into datastructure of dict after applying      - def sum  a 1 b 2 c 3 d 4       sum 0     for k v in args items            sum  v     print sum   sum a 1 b 2 c 3 d 4   positional args sent to function sum   In function definition The      operator packs the received arguments into a dictionary   So remember   In a function call the     unpacks data structure of tuple or list into positional or keyword arguments to be received by function definition   In a function call the      unpacks data structure of dictionary into positional or keyword arguments to be received by function definition   In a function definition the     packs positional arguments into a tuple   In a function definition the      packs keyword arguments into a dictionary

User · Answer

Context   python 3 x unpacking with    use with string formatting   Use with string formatting  In addition to the answers in this thread  here is another detail that was not mentioned elsewhere  This expands on the answer by Brad Solomon  Unpacking with    is also useful when using python str format     This is somewhat similar to what you can do with python f-strings f-string but with the added overhead of declaring a dict to hold the variables  f-string does not require a dict    Quick Example       init vars   ddvars   dict     ddcalc   dict     pass   ddvars  fname          Huomer    ddvars  lname          Huimpson    ddvars  motto          I love donuts     ddvars  age           33   pass   ddcalc  ydiff         5   ddcalc  ycalc         ddvars  age     ddcalc  ydiff     pass   vdemo                                      single unpack supported in py 2 7   vdemo append       Hello  fname   lname      Today you are  age  years old     We love your motto   motto   and we agree with you        format   ddvars      pass                                 multiple unpack supported in py 3 x   vdemo append       Hello  fname   lname      In  ydiff  years you will be  ycalc  years old        format   ddvars   ddcalc      pass                              print vdemo -1

User · Answer

This example would help you remember  args    kwargs and even super and inheritance in Python at once   class base object       def   init   self  base param           self base param   base param   class child1 base     inherited from base class     def   init   self  child param   args     args for non-keyword args         self child param   child param         super child1  self    init    args    call   init   of the base class and initialize it with a NON-KEYWORD arg  class child2 base       def   init   self  child param    kwargs           self child param   child param         super child2  self    init     kwargs    call   init   of the base class and initialize it with a KEYWORD arg  c1   child1 1 0  c2   child2 1 base param 0  print c1 base param   0 print c1 child param   1 print c2 base param   0 print c2 child param   1

User · Answer

What does     double star  and    star  do for parameters   They allow for functions to be defined to accept and for users to pass any number of arguments  positional     and keyword        Defining Functions   args allows for any number of optional positional arguments  parameters   which will be assigned to a tuple named args      kwargs allows for any number of optional keyword arguments  parameters   which will be in a dict named kwargs   You can  and should  choose any appropriate name  but if the intention is for the arguments to be of non-specific semantics  args and kwargs are standard names   Expansion  Passing any number of arguments  You can also use  args and   kwargs to pass in parameters from lists  or any iterable  and dicts  or any mapping   respectively   The function recieving the parameters does not have to know that they are being expanded    For example  Python 2 s xrange does not explicitly expect  args  but since it takes 3 integers as arguments    gt  gt  gt  x   xrange 3    create our  args - an iterable of 3 integers  gt  gt  gt  xrange  x       expand here xrange 0  2  2    As another example  we can use dict expansion in str format    gt  gt  gt  foo    FOO   gt  gt  gt  bar    BAR   gt  gt  gt   this is foo   foo  and bar   bar   format   locals     this is foo  FOO and bar  BAR    New in Python 3  Defining functions with keyword only arguments  You can have keyword only arguments after the  args - for example  here  kwarg2 must be given as a keyword argument - not positionally   def foo arg  kwarg None   args  kwarg2 None    kwargs        return arg  kwarg  args  kwarg2  kwargs   Usage    gt  gt  gt  foo 1 2 3 4 5 kwarg2  kwarg2   bar  bar   baz  baz    1  2   3  4  5    kwarg2     bar    bar    baz    baz      Also    can be used by itself  to indicate that keyword only arguments follow  without allowing for unlimited positional arguments   def foo arg  kwarg None     kwarg2 None    kwargs        return arg  kwarg  kwarg2  kwargs   Here  kwarg2 again must be an explicitly named  keyword argument    gt  gt  gt  foo 1 2 kwarg2  kwarg2   foo  foo   bar  bar    1  2   kwarg2     foo    foo    bar    bar      And we can no longer accept unlimited positional arguments because we don t have  args     gt  gt  gt  foo 1 2 3 4 5  kwarg2  kwarg2   foo  foo   bar  bar   Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  TypeError  foo   takes from 1 to 2 positional arguments      but 5 positional arguments  and 1 keyword-only argument  were given   Again  more simply  here we require kwarg to be given by name  not positionally   def bar    kwarg None        return kwarg   In this example  we see that if we try to pass kwarg positionally  we get an error    gt  gt  gt  bar  kwarg   Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  TypeError  bar   takes 0 positional arguments but 1 was given   We must explicitly pass the kwarg parameter as a keyword argument    gt  gt  gt  bar kwarg  kwarg    kwarg    Python 2 compatible demos   args  typically said  star-args   and   kwargs  stars can be implied by saying  kwargs   but be explicit with  double-star kwargs   are common idioms of Python for using the   and    notation  These specific variable names aren t required  e g  you could use  foos and   bars   but a departure from convention is likely to enrage your fellow Python coders    We typically use these when we don t know what our function is going to receive or how many arguments we may be passing  and sometimes even when naming every variable separately would get very messy and redundant  but this is a case where usually explicit is better than implicit    Example 1  The following function describes how they can be used  and demonstrates behavior  Note the named b argument will be consumed by the second positional argument before    def foo a  b 10   args    kwargs               this function takes required argument a  not required keyword argument b     and any number of unknown positional arguments and keyword arguments after             print  a is a required argument  and its value is  0   format a       print  b not required  its default value is 10  actual value   0   format b         we can inspect the unknown arguments we were passed         - args      print  args is of type  0  and length  1   format type args   len args        for arg in args          print  unknown arg   0   format arg          - kwargs      print  kwargs is of type  0  and length  1   format type kwargs                                                           len kwargs        for kw  arg in kwargs items            print  unknown kwarg - kw   0   arg   1   format kw  arg         But we don t have to know anything about them        to pass them to other functions      print  Args or kwargs can be passed without knowing what they are          max can take two or more positional args  max a  b  c         print  e g  max a  b   args   n 0   format        max a  b   args         kweg    dict  0    format    named args same as unknown kwargs            join   k   v   format k k  v v                                for k  v in sorted kwargs items          print  e g  dict   kwargs   same as  kweg   returns   n 0   format        dict   kwargs   kweg kweg     We can check the online help for the function s signature  with help foo   which tells us   foo a  b 10   args    kwargs    Let s call this function with foo 1  2  3  4  e 5  f 6  g 7    which prints   a is a required argument  and its value is 1 b not required  its default value is 10  actual value  2 args is of type  lt type  tuple  gt  and length 2 unknown arg  3 unknown arg  4 kwargs is of type  lt type  dict  gt  and length 3 unknown kwarg - kw  e  arg  5 unknown kwarg - kw  g  arg  7 unknown kwarg - kw  f  arg  6 Args or kwargs can be passed without knowing what they are  e g  max a  b   args   4 e g  dict   kwargs   same as dict e 5  f 6  g 7   returns     e   5   g   7   f   6    Example 2  We can also call it using another function  into which we just provide a   def bar a       b  c  d  e  f   2  3  4  5  6       dumping every local variable into foo as a keyword argument        by expanding the locals dict      foo   locals       bar 100  prints   a is a required argument  and its value is 100 b not required  its default value is 10  actual value  2 args is of type  lt type  tuple  gt  and length 0 kwargs is of type  lt type  dict  gt  and length 4 unknown kwarg - kw  c  arg  3 unknown kwarg - kw  e  arg  5 unknown kwarg - kw  d  arg  4 unknown kwarg - kw  f  arg  6 Args or kwargs can be passed without knowing what they are  e g  max a  b   args   100 e g  dict   kwargs   same as dict c 3  d 4  e 5  f 6   returns     c   3   e   5   d   4   f   6    Example 3  practical usage in decorators  OK  so maybe we re not seeing the utility yet  So imagine you have several functions with redundant code before and or after the differentiating code  The following named functions are just pseudo-code for illustrative purposes   def foo a  b  c  d 0  e 100         imagine this is much more code than a simple function call     preprocess        differentiating process foo a b c d e        imagine this is much more code than a simple function call     postprocess    def bar a  b  c None  d 0  e 100  f None       preprocess       differentiating process bar a b c d e f      postprocess    def baz a  b  c  d  e  f           and so on   We might be able to handle this differently  but we can certainly extract the redundancy with a decorator  and so our below example demonstrates how  args and   kwargs can be very useful   def decorator function          function to wrap other functions with a pre- and postprocess         functools wraps function    applies module  name  and docstring to wrapper     def wrapper  args    kwargs             again  imagine this is complicated  but we only write it once          preprocess           function  args    kwargs          postprocess       return wrapper   And now every wrapped function can be written much more succinctly  as we ve factored out the redundancy    decorator def foo a  b  c  d 0  e 100       differentiating process foo a b c d e    decorator def bar a  b  c None  d 0  e 100  f None       differentiating process bar a b c d e f    decorator def baz a  b  c None  d 0  e 100  f None  g None       differentiating process baz a b c d e f  g    decorator def quux a  b  c None  d 0  e 100  f None  g None  h None       differentiating process quux a b c d e f g h    And by factoring out our code  which  args and   kwargs allows us to do  we reduce lines of code  improve readability and maintainability  and have sole canonical locations for the logic in our program  If we need to change any part of this structure  we have one place in which to make each change

[python] What does ** (double star/asterisk) and * (star/asterisk) do for parameters?

Examples related to python

Examples related to syntax

Examples related to parameter-passing

Examples related to variadic-functions

Examples related to argument-unpacking