Python function overloading

Question

I know that Python does not support method overloading  but I ve run into a problem that I can t seem to solve in a nice Pythonic way   I am making a game where a character needs to shoot a variety of bullets  but how do I write different functions for creating these bullets  For example suppose I have a function that creates a bullet travelling from point A to B with a given speed  I would write a function like this       def add bullet sprite  start  headto  speed               Code       But I want to write other functions for creating bullets like       def add bullet sprite  start  direction  speed       def add bullet sprite  start  headto  spead  acceleration       def add bullet sprite  script     For bullets that are controlled by a script     def add bullet sprite  curve  speed     for bullets with curved paths         And so on       And so on with many variations  Is there a better way to do it without using so many keyword arguments cause its getting kinda ugly fast  Renaming each function is pretty bad too because you get either add bullet1  add bullet2  or add bullet with really long name   To address some answers    No I can t create a Bullet class hierarchy because thats too slow  The actual code for managing bullets is in C and my functions are wrappers around C API  I know about the keyword arguments but checking for all sorts of combinations of parameters is getting annoying  but default arguments help allot like acceleration 0

User · Answer

A possible option is to use the multipledispatch module as detailed here: http://matthewrocklin.com/blog/work/2014/02/25/Multiple-Dispatch

Instead of doing this:

def add(self, other):
    if isinstance(other, Foo):
        ...
    elif isinstance(other, Bar):
        ...
    else:
        raise NotImplementedError()

You can do this:

from multipledispatch import dispatch
@dispatch(int, int)
def add(x, y):
    return x + y    

@dispatch(object, object)
def add(x, y):
    return "%s + %s" % (x, y)

With the resulting usage:

>>> add(1, 2)
3

>>> add(1, 'hello')
'1 + hello'

User · Answer

Python does support  method overloading  as you present it  In fact  what you just describe is trivial to implement in Python  in so many different ways  but I would go with   class Character object         your character   init   and other methods go here      def add bullet self  sprite default  start default                    direction default  speed default  accel default                     curve default             do stuff with your arguments   In the above code  default is a plausible default value for those arguments  or None  You can then call the method with only the arguments you are interested in  and Python will use the default values    You could also do something like this   class Character object         your character   init   and other methods go here      def add bullet self    kwargs             here you can unpack kwargs as  key  values  and           do stuff with them  and use some global dictionary           to provide default values and ensure that   key             is a valid argument               do stuff with your arguments   Another alternative is to directly hook the desired function directly to the class or instance   def some implementation self  arg1  arg2  arg3       implementation my class add bullet   some implementation of add bullet   Yet another way is to use an abstract factory pattern   class Character object      def   init   self  bfactory   args    kwargs          self bfactory   bfactory    def add bullet self          sprite   self bfactory sprite          speed   self bfactory speed            do stuff with your sprite and speed  class pretty and fast factory object       def sprite self          return pretty sprite     def speed self          return 10000000000 0  my character   Character pretty and fast factory    a1  a2  kw1 v1  kw2 v2  my character add bullet     uses pretty and fast factory    now  if you have another factory called  ugly and slow factory     you can change it at runtime in python by issuing my character bfactory   ugly and slow factory      In the last example you can see abstract factory and  method   overloading   as you call it  in action

User · Answer

Just a simple decorator  class overload      def   init   self  f           self cases           def args self   args           def store function f               self cases tuple args     f             return self         return store function      def   call   self   args           function   self cases tuple type arg  for arg in args           return function  args    You can use it like this   overload def f        pass   f args int  int  def f x  y       print  two integers     f args float  def f x       print  one float     f 5 5  f 1  2    Modify it to adapt it to your use case      A clarification of concepts    function dispatch  there are multiple functions with the same name  Which one should be called  two strategies static compile-time dispatch  aka   overloading    decide which function to call based on the compile-time type of the arguments  In all dynamic languages  there is no compile-time type  so overloading is impossible by definition dynamic run-time dispatch  decide which function to call based on the runtime type of the arguments  This is what all OOP languages do  multiple classes have the same methods  and the language decides which one to call based on the type of self this argument  However  most languages only do it for the this argument only  The above decorator extends the idea to multiple parameters    To clear up  assume a static language  and define the functions  void f Integer x       print  integer called    void f Float x       print  float called    void f Number x       print  number called     Number x   new Integer  5   f x  x   new Number  3 14   f x    With static dispatch  overloading  you will see  number called  twice  because x has been declared as Number  and that s all overloading cares about  With dynamic dispatch you will see  integer called  float called   because those are the actual types of x at the time the function is called

User · Answer

Use keyword arguments with defaults  E g   def add bullet sprite  start default  direction default  script default  speed default     In the case of a straight bullet versus a curved bullet  I d add two functions  add bullet straight and add bullet curved

User · Answer

Either use multiple keyword arguments in the definition  or create a Bullet hierarchy whose instances are passed to the function

User · Answer

You can use  quot roll-your-own quot  solution for function overloading  This one is copied from Guido van Rossum s article about multimethods  because there is little difference between multimethods and overloading in Python   registry       class MultiMethod object       def   init   self  name           self name   name         self typemap          def   call   self   args           types   tuple arg   class   for arg in args    a generator expression          function   self typemap get types          if function is None              raise TypeError  quot no match quot           return function  args      def register self  types  function           if types in self typemap              raise TypeError  quot duplicate registration quot           self typemap types    function   def multimethod  types       def register function           name   function   name           mm   registry get name          if mm is None              mm   registry name    MultiMethod name          mm register types  function          return mm     return register  The usage would be from multimethods import multimethod import unittest     overload  makes more sense in this case overload   multimethod  class Sprite object       pass  class Point object       pass  class Curve object       pass   overload Sprite  Point  Direction  int  def add bullet sprite  start  direction  speed               overload Sprite  Point  Point  int  int  def add bullet sprite  start  headto  speed  acceleration               overload Sprite  str  def add bullet sprite  script               overload Sprite  Curve  speed  def add bullet sprite  curve  speed              Most restrictive limitations at the moment are   methods are not supported  only functions that are not class members  inheritance is not handled  kwargs are not supported  registering new functions should be done at import time thing is not thread-safe

User · Answer

I think your basic requirement is to have a C C  -like syntax in Python with the least headache possible  Although I liked Alexander Poluektov s answer it doesn t work for classes  The following should work for classes   It works by distinguishing by the number of non-keyword arguments  but it doesn t support distinguishing by type   class TestOverloading object       def overloaded function self   args    kwargs             Call the function that has the same number of non-keyword arguments          getattr self   quot  overloaded function impl  quot    str len args     args    kwargs       def  overloaded function impl 3 self  sprite  start  direction    kwargs           print  quot This is overload 3 quot          print  quot Sprite   s quot    str sprite          print  quot Start   s quot    str start          print  quot Direction   s quot    str direction       def  overloaded function impl 2 self  sprite  script           print  quot This is overload 2 quot          print  quot Sprite   s quot    str sprite          print  quot Script   quot          print script  And it can be used simply like this  test   TestOverloading    test overloaded function  quot I m a Sprite quot   0   quot Right quot   print test overloaded function  quot I m another Sprite quot    quot while x    True  print  hi  quot    Output   This is overload 3  Sprite  I m a Sprite  Start  0  Direction  Right  This is overload 2  Sprite  I m another Sprite  Script   while x    True  print  hi

User · Answer

In Python 3 4 PEP-0443  Single-dispatch generic functions was added  Here is a short API description from PEP  To define a generic function  decorate it with the  singledispatch decorator  Note that the dispatch happens on the type of the first argument  Create your function accordingly  from functools import singledispatch  singledispatch def fun arg  verbose False       if verbose          print  quot Let me just say  quot   end  quot   quot       print arg   To add overloaded implementations to the function  use the register   attribute of the generic function  This is a decorator  taking a type parameter and decorating a function implementing the operation for that type   fun register int  def   arg  verbose False       if verbose          print  quot Strength in numbers  eh  quot   end  quot   quot       print arg    fun register list  def   arg  verbose False       if verbose          print  quot Enumerate this  quot       for i  elem in enumerate arg           print i  elem

User · Answer

The  overload decorator was added with type hints  PEP 484   While this doesn t change the behaviour of Python  it does make it easier to understand what is going on  and for mypy to detect errors  See  Type hints and PEP 484

User · Answer

Python 3 8 added functools singledispatchmethod     Transform a method into a single-dispatch generic function       To define a generic method  decorate it with the  singledispatchmethod   decorator  Note that the dispatch happens on the type of the first   non-self or non-cls argument  create your function accordingly    from functools import singledispatchmethod   class Negator       singledispatchmethod     def neg self  arg           raise NotImplementedError  Cannot negate a         neg register     def   self  arg  int           return -arg       neg register     def   self  arg  bool           return not arg   negator   Negator   for v in  42  True   Overloading        neg   negator neg v      print f  v     neg       Output  v 42  neg -42 v True  neg False NotImplementedError  Cannot negate a       singledispatchmethod supports nesting with other decorators such as    classmethod  Note that to allow for dispatcher register    singledispatchmethod must be the outer most decorator  Here is the   Negator class with the neg methods being class bound    from functools import singledispatchmethod   class Negator       singledispatchmethod      staticmethod     def neg arg           raise NotImplementedError  Cannot negate a         neg register     def   arg  int  - gt  int          return -arg       neg register     def   arg  bool  - gt  bool          return not arg   for v in  42  True   Overloading        neg   Negator neg v      print f  v     neg       Output   v 42  neg -42 v True  neg False NotImplementedError  Cannot negate a      The same pattern can be used for other similar decorators    staticmethod  abstractmethod  and others

User · Answer

This type of behaviour is typically solved  in OOP languages  using polymorphism  Each type of bullet would be responsible for knowing how it travels  For instance  class Bullet object       def   init   self           self curve   None         self speed   None         self acceleration   None         self sprite image   None  class RegularBullet Bullet       def   init   self           super RegularBullet  self    init             self speed   10  class Grenade Bullet       def   init   self           super Grenade  self    init             self speed   4         self curve   3 5  add bullet Grendade     def add bullet bullet       c function bullet speed  bullet curve  bullet acceleration  bullet sprite  bullet x  bullet y    void c function double speed  double curve  double accel  char   sprite             if  speed    null  amp  amp       regular bullet          else if       curved bullet              etc      Pass as many arguments to the c function that exist  and then do the job of determining which c function to call based on the values in the initial c function  So  Python should only ever be calling the one c function  That one c function looks at the arguments  and then can delegate to other c functions appropriately  You re essentially just using each subclass as a different data container  but by defining all the potential arguments on the base class  the subclasses are free to ignore the ones they do nothing with  When a new type of bullet comes along  you can simply define one more property on the base  change the one python function so that it passes the extra property  and the one c function that examines the arguments and delegates appropriately  It doesn t sound too bad I guess

User · Answer

By passing keyword args   def add bullet   kwargs        check for the arguments listed above and do the proper things

User · Answer

Overloading methods is tricky in Python  However  there could be usage of passing the dict  list or primitive variables  I have tried something for my use cases  and this could help here to understand people to overload the methods  Let s take your example  A class overload method with call the methods from different class  def add bullet sprite None  start None  headto None  spead None  acceleration None    Pass the arguments from the remote class  add bullet sprite    test   start Yes headto   lat  10 6666  long  10 6666  accelaration 10 6   Or add bullet sprite    test   start Yes  headto   lat  10 6666  long  10 6666  speed   10   20  30     So  handling is being achieved for list  Dictionary or primitive variables from method overloading  Try it out for your code

User · Answer

I think a Bullet class hierarchy with the associated polymorphism is the way to go  You can effectively overload the base class constructor by using a metaclass so that calling the base class results in the creation of the appropriate subclass object  Below is some sample code to illustrate the essence of what I mean   Updated  The code has been modified to run under both Python 2 and 3 to keep it relevant  This was done in a way that avoids the use Python s explicit metaclass syntax  which varies between the two versions    To accomplish that objective  a BulletMetaBase instance of the BulletMeta class is created by explicitly calling the metaclass when creating the Bullet baseclass  rather than using the   metaclass    class attribute or via a metaclass keyword argument depending on the Python version    class BulletMeta type       def   new   cls  classname  bases  classdict               Create Bullet class or a subclass of it              classobj   type   new   cls  classname  bases  classdict          if classname     BulletMetaBase               if classname     Bullet      Base class definition                  classobj registry         Initialize subclass registry              else                  try                      alias   classdict  alias                   except KeyError                      raise TypeError  Bullet subclass  s has no  alias                                         classname                  if alias in Bullet registry    unique                      raise TypeError  Bullet subclass  s s alias attribute                                         r already in use     classname  alias                     Register subclass under the specified alias                  classobj registry alias    classobj          return classobj      def   call   cls  alias   args    kwargs               Bullet subclasses instance factory               Subclasses should only be instantiated by calls to the base             class with their subclass  alias as the first arg                      if cls    Bullet              raise TypeError  Bullet subclass  r objects should not to                                be explicitly constructed     cls   name            elif alias not in cls registry    Bullet subclass              raise NotImplementedError  Unknown Bullet subclass  r                                          str alias             Create designated subclass object  call its   init   method           subclass   cls registry alias          return type   call   subclass   args    kwargs    class Bullet BulletMeta  BulletMetaBase    object                Presumably you d define some abstract methods that all here       that would be supported by all subclasses        These definitions could just raise NotImplementedError   or       implement the functionality is some sub-optimal generic way        For example      def fire self   args    kwargs           raise NotImplementedError self   class     name       fire   method          Abstract base class s   init   should never be called        If subclasses need to call super class s   init     for some       reason then it would need to be implemented      def   init   self   args    kwargs           raise NotImplementedError  Bullet is an abstract base class       Subclass definitions  class Bullet1 Bullet       alias    B1      def   init   self  sprite  start  direction  speed           print  creating  s object    self   class     name        def fire self  trajectory           print  Bullet1 object fired with  s trajectory    trajectory    class Bullet2 Bullet       alias    B2      def   init   self  sprite  start  headto  spead  acceleration           print  creating  s object    self   class     name      class Bullet3 Bullet       alias    B3      def   init   self  sprite  script     script controlled bullets         print  creating  s object    self   class     name      class Bullet4 Bullet       alias    B4      def   init   self  sprite  curve  speed     for bullets with curved paths         print  creating  s object    self   class     name      class Sprite  pass class Curve  pass  b1   Bullet  B1   Sprite     10 20 30   90  600  b2   Bullet  B2   Sprite     -30 17 94    1 -1 -1   600  10  b3   Bullet  B3   Sprite     bullet42 script   b4   Bullet  B4   Sprite    Curve    720  b1 fire  uniform gravity   b2 fire  uniform gravity     Output   creating Bullet1 object creating Bullet2 object creating Bullet3 object creating Bullet4 object Bullet1 object fired with uniform gravity trajectory Traceback  most recent call last     File  python-function-overloading py   line 93  in  lt module gt      b2 fire  uniform gravity     NotImplementedError  Bullet2 fire   method   File  python-function-overloading py   line 49  in fire     raise NotImplementedError self   class     name       fire   method   NotImplementedError  Bullet2 fire   method

User · Answer

What you are asking for is called multiple dispatch  See Julia language examples which demonstrates different types of dispatches  However  before looking at that  we ll first tackle why overloading is not really what you want in Python  Why Not Overloading  First  one needs to understand the concept of overloading and why it s not applicable to Python   When working with languages that can discriminate data types at compile-time  selecting among the alternatives can occur at compile-time  The act of creating such alternative functions for compile-time selection is usually referred to as overloading a function   Wikipedia   Python is a dynamically typed language  so the concept of overloading simply does not apply to it  However  all is not lost  since we can create such alternative functions at run-time   In programming languages that defer data type identification until run-time the selection among alternative functions must occur at run-time  based on the dynamically determined types of function arguments  Functions whose alternative implementations are selected in this manner are referred to most generally as multimethods   Wikipedia   So we should be able to do multimethods in Python   or  as it is alternatively called  multiple dispatch  Multiple dispatch The multimethods are also called multiple dispatch   Multiple dispatch or multimethods is the feature of some object-oriented programming languages in which a function or method can be dynamically dispatched based on the run time  dynamic  type of more than one of its arguments   Wikipedia   Python does not support this out of the box1  but  as it happens  there is an excellent Python package called multipledispatch that does exactly that  Solution Here is how we might use multipledispatch2 package to implement your methods   gt  gt  gt  from multipledispatch import dispatch  gt  gt  gt  from collections import namedtuple  gt  gt  gt  from types import      we can test for lambda type  e g    gt  gt  gt  type lambda a  1     LambdaType True   gt  gt  gt  Sprite   namedtuple  Sprite     name     gt  gt  gt  Point   namedtuple  Point     x    y     gt  gt  gt  Curve   namedtuple  Curve     x    y    z     gt  gt  gt  Vector   namedtuple  Vector     x   y   z      gt  gt  gt   dispatch Sprite  Point  Vector  int      def add bullet sprite  start  direction  speed           print  quot Called Version 1 quot        gt  gt  gt   dispatch Sprite  Point  Point  int  float      def add bullet sprite  start  headto  speed  acceleration           print  quot Called version 2 quot        gt  gt  gt   dispatch Sprite  LambdaType      def add bullet sprite  script           print  quot Called version 3 quot        gt  gt  gt   dispatch Sprite  Curve  int      def add bullet sprite  curve  speed           print  quot Called version 4 quot         gt  gt  gt  sprite   Sprite  Turtle    gt  gt  gt  start   Point 1 2   gt  gt  gt  direction   Vector 1 1 1   gt  gt  gt  speed   100  km h  gt  gt  gt  acceleration   5 0  m s  gt  gt  gt  script   lambda sprite  sprite x   2  gt  gt  gt  curve   Curve 3  1  4   gt  gt  gt  headto   Point 100  100    somewhere far away   gt  gt  gt  add bullet sprite  start  direction  speed  Called Version 1   gt  gt  gt  add bullet sprite  start  headto  speed  acceleration  Called version 2   gt  gt  gt  add bullet sprite  script  Called version 3   gt  gt  gt  add bullet sprite  curve  speed  Called version 4  1  Python 3 currently supports single dispatch 2  Take care not to use  multipledispatch in a multi-threaded environment or you will get weird behavior

[python] Python function overloading

Examples related to python

Examples related to class

Examples related to oop

Examples related to overloading

Examples related to multiple-dispatch