Python class methods: when you don't need it yourself

What is it self

?

In Python, every normal method is forced to take a parameter, usually called self

. This is an instance of a class - an object. This is how Python methods interact with class state.

You are allowed to rename this parameter however you like. but will always have the same meaning:

>>> class Class:
    def method(foo): # 
        print(foo)


>>> cls = Class()
>>> cls.method()
<__main__.F object at 0x03E41D90>
>>> 

      

        
        
        
      

    

But then why does my example work?

However, what you are probably confusing is how this code works differently:

>>> class Class:
    def method(foo):
        print(foo)

    methods = {'method': method}

    def __init__(self):
        self.run = self.methods['method']


>>> cls = Class()
>>> cls.run(3)
3
>>> 

      

        
        
        
      

    

This is due to the difference between bound and unbound methods in Python.

When we do this in __init__()

:

self.run = self.methods['method']

      

        
        
        
      

    

We are referring to the unbound method method

. This means that our reference to is method

not associated with any particular instance Class

, and thus Python will not force it to method

accept an object instance. because he has nothing to give.

The above code will be the same as doing so:

>>> class Class:
    def method(foo):
        print(foo)


>>> Class.method(3)
3
>>> 

      

        
        
        
      

    

In both examples, we are calling a method method

of the class object Class

, not an instance of the object Class

.

We can see this difference by looking repr

for a bound and unbound method:

>>> class Class:
    def method(foo):
        print(foo)


>>> Class.method
<function Class.method at 0x03E43D68>
>>> cls = Class()
>>> cls.method
<bound method Class.method of <__main__.Class object at 0x03BD2FB0>>
>>> 

      

        
        
        
      

    

As you can see, in the first example, when we do Class.method

, Python shows: <function Class.method at 0x03E43D68>

. I lied to you a little. When we have an unbound class method, Python treats them as simple functions. Thus, method

it is just a function that is not tied to any instance of the class.

However, in the second example, when we create an instance Class

, and then turn to its object method

, we see printed: <bound method Class.method of <__main__.Class object at 0x03BD2FB0>>

.

The key point for notification is bound method Class.method

. This means it is method

bound to a cls

- specfic instance Class

.

General remarks

As @jonshapre mentioned, writing code like in your example leads to confusion (as proof on the matter) and errors. It would be better if you just define nonLinearBipolarStep()

outside Activation

and specify that from inside Activation.activation_functions

:

def nonLinearBipolarStep(self,x,string=None):
        if not string: return (-1 if x<0 else 1 )
        else: return ('-' if x<0 else '1')

class Activation:

    activation_functions = {
        'bipolar': nonLinearBipolarStep,
    }

    ...

      

        
        
        
      

    

I guess the more specific question is: what should I pay attention to this code to make it obvious what ag.run(x)

would be an unbound function call?

If you do want to nonLinearBipolarStep

be unrelated, I recommend just being careful. If you think your method will do for the cleanest code, then go for it, but make sure you know what you are doing and the behavior of your code will be.

If you still want users of your class to understand what is ag.run()

going to be static, you can document it in a docstring somewhere, but this is something that the user really doesn't even have to worry about.