method-missing

Possible Duplicate: Python equivalent of Ruby's 'method_missing' Is there any technique available in Python for intercepting messages (method calls) like the method_missing technique in Ruby? As others have mentioned, in Python, when you execute o.f(x) , it's really a two-step operation: First, get the f attribute of o , then call it with parameter x . It's the first step that fails because there is no attribute f , and it's that step that invokes the Python magic method __getattr__ . So you have to implement __getattr__ , and what it returns must be callable. Keep in mind, if you also try to

What is Python's equivalent of Ruby's method_missing method? I tried using __getattr__ but this hook applies to fields too. I only want to intercept the method invocations. What is the Python way to do it? There is no difference in Python between properties and methods. A method is just a property, whose type is just instancemethod , that happens to be callable (supports __call__ ). If you want to implement this, your __getattr__ method should return a function (a lambda or a regular def , whatever suite your needs) and maybe check something after the call. senderle Python doesn't distinguish

In Ruby, objects have a handy method called method_missing which allows one to handle method calls for methods that have not even been (explicitly) defined: Invoked by Ruby when obj is sent a message it cannot handle. symbol is the symbol for the method called, and args are any arguments that were passed to it. By default, the interpreter raises an error when this method is called. However, it is possible to override the method to provide more dynamic behavior. The example below creates a class Roman, which responds to methods with names consisting of roman numerals, returning the

I'm learning metaprogramming in Ruby and am just trying out defining missing methods via method_missing and define_method. I'm getting some unexpected behaviour and am wondering if anyone can explain this. Here is my class: class X def method_missing(m, *args, &block) puts "method #{m} not found. Defining it." self.class.send :define_method, m do puts "hi from method #{m}" end puts "defined method #{m}" end end Now, this code: x = X.new x.some_method puts x.some_method puts puts x Produces the output: method some_method not found. Defining it. defined method some_method hi from method some