what constitutes a member of a class? What constitutes a method?

Question

It seems that an acceptable answer to the question

What is a method?

is

A method is a function that's a member of a class.

I disagree with this.

class Foo(object):
    pass

def func():
    pass

Foo.func = func

f = Foo()

print "fine so far"
try:
    f.func()
except TypeError:
    print "whoops! func must not be a method after all"

1. Is func a member of Foo?
2. Is func a method of Foo?

I am well aware that this would work if func had a self argument. That's obvious. I'm interested in if it's a member of foo and in if it's a method as presented.

Answer 1

You're just testing it wrong:

>>> class Foo(object): pass
... 
>>> def func(self): pass
... 
>>> Foo.func = func
>>> f = Foo()
>>> f.func()
>>> 

You error of forgetting to have in the def the self argument has absolutely nothing to do with f.func "not being a method", of course. The peculiar conceit of having the def outside the class instead of inside it (perfectly legal Python of course, but, as I say, peculiar) has nothing to do with the case either: if you forget to have a first argument (conventionally named self) in your def statements for methods, you'll get errors in calling them, of course (a TypeError is what you get, among other cases, whenever the actual arguments specified in the call can't match the formal arguments accepted by the def, of course).

Answer 2

f.func() will throw an error as written in the question. Since it won't find the attribute in 'Foo' namespace with name 'func'.

So my understanding is that method is an attribute in object namespace that is callable.

So if you did

f.func = func

Then attribute 'func' can be found in namespace of f , i.e. dir(f) and is callable and becomes a method of the object and not class Foo.

If we did Foo.func = func, it would become class method or callable.

The example code can be edited to see what is happening:

class Foo(object):
    pass

def func(t):
    print "XXXX"
    pass


class FoowithFunc(object):
    pass

    def func(self):
        pass

Foo.func = func

f = Foo()
t = FoowithFunc()
print dir(f)
print dir(t)
f.func()
print dir(f)
print dir(Foo)

Answer 3

The type error wouldn't be thrown if func had a self argument, like any other instance method.

That's because when you evaluate f.func, you're actually binding f to the first argument of the function -- it then becomes a partial application which you can provide further arguments to.

If you want it to be a static method, then you need the staticmethod decorator which just throws away the first parameter and passes the rest into the original function.

So 2 ways of making it work:

def func(self): pass

-- or --

Foo.func = staticmethod(func)

depending on what you're aiming for.

Answer 4

As written, func is a member of Foo and a method of Foo instances such as your f. However, it can't be successfully called because it doesn't accept at least one argument.

func is in f's namespace and has a _call_() method. In other words, it is enough of a method that Python tries to call it like one when you invoke it like one. If it quacks like a duck, in other words...

That this call doesn't succeed is neither here nor there, in my opinion.

But perhaps a proper response to "But Doctor! When I don't accept any arguments in a function defined in a class, I get confused about whether it's really a method or not!" is simply "Don't do that." :-)