Python call special method practical example

Question

I know that   call   method in a class is triggered when the instance of a class is called  However  I have no idea when I can use this special method  because one can simply create a new method and perform the same operation done in   call   method and instead of calling the instance  you can call the method   I would really appreciate it if someone gives me a practical usage of this special method

User · Answer

The function call operator    class Foo      def   call   self  a  b  c             do something  x   Foo   x 1  2  3      The   call   method  can be used to redefined re-initialize the same object  It also facilitates the use of instances objects of a class as functions by passing arguments to the objects

User · Answer

I find it useful because it allows me to create APIs that are easy to use  you have some callable object that requires some specific arguments   and are easy to implement because you can use Object Oriented practices   The following is code I wrote yesterday that makes a version of the hashlib foo methods that hash entire files rather than strings     filehash py import hashlib   class Hasher object               A wrapper around the hashlib hash algorithms that allows an entire file to     be hashed in a chunked manner              def   init   self  algorithm           self algorithm   algorithm      def   call   self  file           hash   self algorithm           with open file   rb   as f              for chunk in iter lambda  f read 4096                        hash update chunk          return hash hexdigest     md5      Hasher hashlib md5  sha1     Hasher hashlib sha1  sha224   Hasher hashlib sha224  sha256   Hasher hashlib sha256  sha384   Hasher hashlib sha384  sha512   Hasher hashlib sha512    This implementation allows me to use the functions in a similar fashion to the hashlib foo functions   from filehash import sha1 print sha1  somefile txt     Of course I could have implemented it a different way  but in this case it seemed like a simple approach

User · Answer

call   is also used to implement decorator classes in python  In this case the instance of the class is called when the method with the decorator is called  class EnterExitParam object        def   init   self  p1           self p1   p1      def   call   self  f           def new f                print  quot Entering quot   f   name                print  quot p1  quot   self p1              f               print  quot Leaving quot   f   name            return new f    EnterExitParam  quot foo bar quot   def hello        print  quot Hello quot     if   name       quot   main   quot       hello    program output  Entering hello p1  foo bar Hello Leaving hello

User · Answer

IMHO   call   method and closures give us a natural way to create STRATEGY design pattern in Python  We define a family of algorithms  encapsulate each one  make them interchangeable and in the end we can execute a common set of steps and  for example  calculate a hash for a file

User · Answer

This is too late but I m giving an example  Imagine you have a Vector class and a Point class  Both take x  y as positional args  Let s imagine you want to create a function that moves the point to be put on the vector    4 Solutions   put point on vec point  vec  Make it a method on the vector class  e g my vec put point point  Make it a method on the Point class  my point put on vec vec  Vector implements   call    So you can use it like my vec instance point    This is actually part of some examples I m working on for a guide for dunder methods explained with Maths that I m gonna release sooner or later    I left the logic of moving the point itself because this is not what this question is about

User · Answer

I find a good place to use callable objects  those that define   call      is when using the functional programming capabilities in Python  such as map    filter    reduce       The best time to use a callable object over a plain function or a lambda function is when the logic is complex and needs to retain some state or uses other info that in not passed to the   call     function   Here s some code that filters file names based upon their filename extension using a callable object and filter     Callable   import os  class FileAcceptor object       def   init   self  accepted extensions           self accepted extensions   accepted extensions      def   call   self  filename           base  ext   os path splitext filename          return ext in self accepted extensions  class ImageFileAcceptor FileAcceptor       def   init   self           image extensions      jpg     jpeg     gif     bmp           super ImageFileAcceptor  self    init   image extensions    Usage   filenames          me jpg        me txt        friend1 jpg        friend2 bmp        you jpeg        you xml    acceptor   ImageFileAcceptor   image filenames   filter acceptor  filenames  print image filenames   Output     me jpg    friend1 jpg    friend2 bmp    you jpeg

User · Answer

I just stumbled upon a usage of   call     in concert with   getattr     which I think is beautiful  It allows you to hide multiple levels of a JSON HTTP  however serialized  API inside an object   The   getattr     part takes care of iteratively returning a modified instance of the same class  filling in one more attribute at a time  Then  after all information has been exhausted    call     takes over with whatever arguments you passed in   Using this model  you can for example make a call like api v2 volumes ssd update size 20   which ends up in a PUT request to https   some tld api v2 volumes ssd update   The particular code is a block storage driver for a certain volume backend in OpenStack  you can check it out here  https   github com openstack cinder blob master cinder volume drivers nexenta jsonrpc py  EDIT  Updated the link to point to master revision

User · Answer

This example uses memoization  basically storing values in a table  dictionary in this case  so you can look them up later instead of recalculating them   Here we use a simple class with a   call   method to calculate factorials  through a callable object  instead of a factorial function that contains a static variable  as that s not possible in Python    class Factorial      def   init   self           self cache          def   call   self  n           if n not in self cache              if n    0                  self cache n    1             else                  self cache n    n   self   call   n-1          return self cache n   fact   Factorial     Now you have a fact object which is callable  just like every other function  For example  for i in xrange 10                                                                    print            format i  fact i       output 0    1 1    1 2    2 3    6 4    24 5    120 6    720 7    5040 8    40320 9    362880   And it is also stateful

User · Answer

We can use   call   method to use other class methods as static methods       class  Callable          def   init   self  anycallable               self   call     anycallable      class Model           def get instance conn  table name                    do something             get instance    Callable get instance       provs fac   Model get instance connection   users

User · Answer

Django forms module uses   call   method nicely to implement a consistent API for form validation  You can write your own validator for a form in Django as a function   def custom validator value        your validation logic   Django has some default built-in validators such as email validators  url validators etc   which broadly fall under the umbrella of RegEx validators  To implement these cleanly  Django resorts to callable classes  instead of functions   It implements default Regex Validation logic in a RegexValidator and then extends these classes for other validations   class RegexValidator object       def   call   self  value             validation logic  class URLValidator RegexValidator       def   call   self  value           super URLValidator  self    call   value           additional logic  class EmailValidator RegexValidator         some logic   Now both your custom function and built-in EmailValidator can be called with the same syntax   for v in  custom validator  EmailValidator         v value     lt -----   As you can see  this implementation in Django is similar to what others have explained in their answers below  Can this be implemented in any other way  You could  but IMHO it will not be as readable or as easily extensible for a big framework like Django

User · Answer

One common example is the   call   in functools partial  here is a simplified version  with Python    3 5    class partial         New function with partial application of the given arguments and keywords          def   new   cls  func   args    kwargs           if not callable func               raise TypeError  the first argument must be callable           self   super     new   cls           self func   func         self args   args         self kwargs   kwargs         return self      def   call   self   args    kwargs           return self func  self args   args    self kwargs    kwargs    Usage   def add x  y       return x   y  inc   partial add  y 1  print inc 41      42

User · Answer

Class-based decorators use   call   to reference the wrapped function  E g    class Deco object       def   init   self f           self f   f     def   call   self   args    kwargs           print args         print kwargs         self f  args    kwargs    There is a good description of the various options here at Artima com

User · Answer

Yes  when you know you re dealing with objects  it s perfectly possible  and in many cases advisable  to use an explicit method call  However  sometimes you deal with code that expects callable objects - typically functions  but thanks to   call   you can build more complex objects  with instance data and more methods to delegate repetitive tasks  etc  that are still callable   Also  sometimes you re using both objects for complex tasks  where it makes sense to write a dedicated class  and objects for simple tasks  that already exist in functions  or are more easily written as functions   To have a common interface  you either have to write tiny classes wrapping those functions with the expected interface  or you keep the functions functions and make the more complex objects callable  Let s take threads as example  The Thread objects from the standard libary module threading want a callable as target argument  i e  as action to be done in the new thread   With a callable object  you are not restricted to functions  you can pass other objects as well  such as a relatively complex worker that gets tasks to do from other threads and executes them sequentially   class Worker object       def   init   self   args    kwargs           self queue   queue Queue           self args   args         self kwargs   kwargs      def add task self  task           self queue put task       def   call   self           while True              next action   self queue get               success   next action  self args    self kwargs              if not success                 self add task next action    This is just an example off the top of my head  but I think it is already complex enough to warrant the class  Doing this only with functions is hard  at least it requires returning two functions and that s slowly getting complex  One could rename   call   to something else and pass a bound method  but that makes the code creating the thread slightly less obvious  and doesn t add any value

User · Answer

Specify a   metaclass   and override the   call   method  and have the specified meta classes    new   method return an instance of the class  viola you have a  function  with methods

[python] Python call special method practical example

Examples related to python

Examples related to methods

Examples related to call

Examples related to magic-methods

[python] Python __call__ special method practical example

Examples related to python

Examples related to methods

Examples related to call

Examples related to magic-methods

[python] Python call special method practical example