Difference between methods and functions, in Python compared to C++


I’m doing Code Academy’s tutorials on Python, and I’m a bit confused about the definition of method and function. From the tutorial:

You already know about some of the built-in functions we’ve used on (or to create) strings, such as .upper(), .lower(), str(), and len().

Coming from C++, I would think .upper() and .lower() would be called methods and len() and str() functions. In the tutorial, the terms seem to be used interchangeably.

Does Python distinguish between methods and functions in the way C++ does?

Unlike Difference between a method and a function, I’m asking about the particulars of Python. The terms ‘method’ and ‘function’ do not seem to always follow the definition given in the accepted answer of the linked question.

Asked By: Q-bertsuit



Needs Attention: This answer seems to be outdated. Check this

A function is a callable object in Python, i.e. can be called using the call operator (though other objects can emulate a function by implementing __call__). For example:

>>> def a(): pass
>>> a
<function a at 0x107063aa0>
>>> type(a)
<type 'function'>

A method is a special class of function, one that can be bound or unbound.

>>> class A:
...   def a(self): pass
>>> A.a
<unbound method A.a>
>>> type(A.a)
<type 'instancemethod'>

>>> A().a
<bound method A.a of <__main__.A instance at 0x107070d88>>
>>> type(A().a)
<type 'instancemethod'>

Of course, an unbound method cannot be called (at least not directly without passing an instance as an argument):

>>> A.a()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method a() must be called with A instance as first argument (got nothing instead)

In Python, in most cases, you won’t notice the difference between a bound method, a function, or a callable object (i.e. an object that implements __call__), or a class constructor. They all look the same, they just have different naming conventions. Under the hood, the objects may look vastly different though.

This means that a bound method can be used as a function, this is one of the many small things that makes Python so powerful

>>> b = A().a
>>> b()

It also means that even though there is a fundamental difference between len(...) and str(...) (the latter is a type constructor), you won’t notice the difference until you dig a little deeper:

>>> len
<built-in function len>
>>> str
<type 'str'>
Answered By: Krumelur

Basically, yes, Python does distinguish them, but in Python it is common to view methods as a subset of functions. Methods are associated with a class or instance, and “standalone functions” are not. Something that is a method is also a function, but there can be functions that are not methods.

As Jon Clements mentioned in his comment, though, the distinction is not so ironclad as in C++. Standalone functions can be “converted” into methods at runtime, and methods can be assigned to variables in such a way that they effectively behave no differently than standalone functions. So the boundary between methods and functions is permeable.

Answered By: BrenBarn

If you still don’t understand how methods work, a look at the
implementation can perhaps clarify matters. When an instance attribute
is referenced that isn’t a data attribute, its class is searched. If
the name denotes a valid class attribute that is a function object, a
method object is created by packing (pointers to) the instance object
and the function object just found together in an abstract object:
this is the method object. When the method object is called with an
argument list, a new argument list is constructed from the instance
object and the argument list, and the function object is called with
this new argument list.


Read carefully this excerpt.

It means :

1) An instance doesn’t really hold an object being a method that would be its attribute.
In fact, there is not at all a “method” attribute in the __dict__ of an instance (__dict__ is the namespace of an object)

2) The fact that an instance seems to have a “method” when a “method” attribute is called, is due to a process, not the presence of a method object inside the namespace of an instance

3) Also, there doesn’t really exist a method object in the namespace of a class.

But there’s a difference with an instance, because there must be somewhere something that leads to a real method object when such a call is done, must not ?

What is called a “method” attribute of a class, for easiness of wording, is in reality a function object being attribute in the namespace of the class.
That is to say, a pair (identifier of the function, function) is a member of the __dict__ of a class, and this attribute allows the intepreter to construct a method object when a method call is performed.

4) Again, the fact that a class seems to have a “method” when a “method” attribute is called, is due to a process, not to the presence of a method object inside the namespace of a class

EDIT I’m no more sure of that; see at the end

5) A method object (not “method” object; I mean the real object being really a method`, what is described in the excerpt) is created at the moment of the call, it doesn’t exists before.
It is a kind of wrapper : it packs pointers to the instance object and the function object on which the method is based.

So, a method is based on a function. This function is for me the real attribute of the class holding the said “method”, because this function really belongs to the namespace ( __dict__ ) of the class: this function is described as a <function ......> when the __dict__ is printed.
This function can be reached from the method object using the alias im_func or __func__ (see the below code)


I believe that these notions are not very commonly known and understood. But the following code proves what I said.

class A(object):
    def __init__(self,b=0):
        self.b = b
    print 'The __init__ object :n',__init__

    def addu(self):
        self.b = self.b + 10
    print 'nThe addu object :n',addu

print 'nThe A.__dict__  items :n',
print 'n'.join('  {0:{align}11}  :  {1}'.format(*it,align='^')
                for it in A.__dict__.items())
a1 = A(101)
a2 = A(2002)

print 'nThe a1.__dict__  items:'
print 'n'.join('  {0:{align}11}  :  {1}'.format(*it,align='^')
                for it in a1.__dict__.items())

print 'nThe a2.__dict__  items:'
print 'n'.join('  {0:{align}11}  :  {1}'.format(*it,align='^')
                for it in a2.__dict__.items())

print 'nA.addu.__func__ :',A.addu.__func__
print id(A.addu.__func__),'==',hex(id(A.addu.__func__))

print 'A.addu :n  ',
print A.addu,'n  ',id(A.addu),'==',hex(id(A.addu))

print 'a1.addu :n  ',
print a1.addu,'n  ',id(a1.addu),'==',hex(id(a1.addu))
print 'a2.addu :n  ',
print a2.addu,'n  ',id(a2.addu),'==',hex(id(a2.addu))

print 'na2.b ==',a2.b

print 'nThe A.__dict__  items :n',
print 'n'.join('  {0:{align}11}  :  {1}'.format(*it,align='^')
                for it in A.__dict__.items())


The __init__ object :
<function __init__ at 0x011E54B0>

The addu object :
<function addu at 0x011E54F0>

The A.__dict__  items :
  __module__   :  __main__
     addu      :  <function addu at 0x011E54F0>
   __dict__    :  <attribute '__dict__' of 'A' objects>
  __weakref__  :  <attribute '__weakref__' of 'A' objects>
    __doc__    :  None
   __init__    :  <function __init__ at 0x011E54B0>

The a1.__dict__  items:
       b       :  101

The a2.__dict__  items:
       b       :  2002

A.addu.__func__ : <function addu at 0x011E54F0>
18765040 == 0x11e54f0

A.addu :
   <unbound method A.addu> 
   18668040 == 0x11cda08
a1.addu :
   <bound method A.addu of <__main__.A object at 0x00CAA850>> 
   18668040 == 0x11cda08
a2.addu :
   <bound method A.addu of <__main__.A object at 0x011E2B90>> 
   18668040 == 0x11cda08

a2.b == 2012

The A.__dict__  items :
  __module__   :  __main__
     addu      :  <function addu at 0x011E54F0>
   __dict__    :  <attribute '__dict__' of 'A' objects>
  __weakref__  :  <attribute '__weakref__' of 'A' objects>
    __doc__    :  None
   __init__    :  <function __init__ at 0x011E54B0>



Something is troubling me and I don’t know the deep innards of the subject:

The above code shows that A.addu , a1.addu and a2.addu are all the same method object, with a unique identity.
However A.addu is said an unbound method because it doesn’t have any information concerning an particular instance,
and a1.addu and a2.addu are said bound methods because each one has information designating the instance that must be concerned by the operations of the method.
Logically, for me, that would mean that the method should be different for each of these 3 cases.

BUT the identity is the same for all three, and moreover this identity is different from the identity of the function on which the method is based.
It leads to the conclusion that the method is really an object living in the memory, and that it doesn’t change from one call from an instance to another cal from another instance.

HOWEVER , printing the namespace __dict__ of the class, even after the creation of instances and the call of the “method” addu(), this namespace doesn’t exposes a new object that could be identified to the method object different from the addu function.

What does it mean ?
It gives me the impression that as soon as a method object is created, it isn’t destroyed, it lives in the memory (RAM).
But it lives hidden and only the processes that form the interpeter’s functionning know how and where to find it.
This hidden object, the real method object, must have the ability to change the reference to the instance to which the function must be applied, or to reference None if it is called as an unbound method. That’s what it seems to me, but it’s only brain-storming hypothesis.

Does anybody know something on this interrogation ?

To answer to the question, it can be considered correct to call .upper and .lower functions , since in reality they are based on functionsas every method of a class.

However, the following result is special, probably because they are builtin methods/functions, not user’s methods/functions as in my code.

x = 'hello'
print x.upper.__func__


    print x.upper.__func__
AttributeError: 'builtin_function_or_method' object has no attribute '__func__'
Answered By: eyquem

In the following class definition:

class MyClass:
    """A simple example class"""
    def f(self):
        return 'hello world'
  • Class : MyClass
  • Function: f()
  • Method: None (Actually, not applicable)

Lets create an instance of the above class. We’ll do this by assigning class object, i.e. MyClass() to var x

  x = MyClass()


  • Function: None
  • Method: x.f()

And lets not forget that the function object MyClass.f was used to define (internally) the method object x.f when we assigned x to MyClass()

Answered By: ksha

Took snippet from this answer

Following are the changes

  • Unbound methods (methods bound to a class object) are no longer available.
  • unbound method -> function
  • type instancemethod are removed from Python 3

More about methods on this answer

About methods on Python docs

More about classes on Python docs

import sys
# 3.9.0rc2 (tags/v3.9.0rc2:2bd31b5, Sep 17 2020, 00:58:12) [MSC v.1927 64 bit (AMD64)]

class A:
  def a(self): pass

# <unbound method A.a>
# <function A.a at 0x00000200FBE121F0>

# <type 'instancemethod'>
# <class 'function'>

# <bound method A.a of <__main__.A instance at 0x107070d88>>
# <bound method A.a of <__main__.A object at 0x00000200FBB12640>>

# <type 'instancemethod'>
# <class 'method'>
Answered By: Smart Manoj

Short answer:
Methods are bounded functions. Functions become methods when function is bound to an object.

To understand the difference between function and method in python you need to understand

  1. Everything is an object in python. Even function is an object
    I searched python.org to find exact definition of object in python. But I could not find exact definition.

    In your python console define an integer

    my_int = 1


    <class 'int'>

    Define a lambda function

    my_lambda = lambda x:x+1


    <class 'function'>

    Define a function.

    def mycounter(x):
        return x+1


    <class 'function'>

    From this we can surmise that everything is an object in python. Even function is an object.

  2. Class object and instance object are different. When you define a class, class object is created. When you instantiate a class, instance object is created.

    In python console define a class.

    class MyClass:
        """A simple example class"""
        i = 12345
        def f(self):
            return 'hello world'

    In your python console you can check MyClass object is created



    <class 'type'>

    Create instance object of the class

    mc = MyClass()


    <class 'MyClass'>

    Check attribute i for instance object




    Check attribute i for class object




    Check attribute f for instance object.



    <bound method MyClass.f of <MyClass object at 0x7fbea6c18d00>>

    Check attribute f for class object.



    <function MyClass.f at 0x7f1730f9e1f0>

    We can see that for Class object f is a function object and for instance object, f is a bound method object.

    Call f() on instance object



    'hello world'

    Call f() on class object.



    Traceback (most recent call last):
      File "<console>", line 1, in <module>
    TypeError: f() missing 1 required positional argument: 'self'

    Pass an instance object when calling class object f function.



    'hello world'

From above examples we can say that –

  1. MyClass is a Class object and mc is an instance object and they are different from one another.
  2. Functions become methods when functions are bound to an object. These objects need not be just class instance object. They can any other python objects.


  1. As per python documentation for function

A method is a function that ‘belongs’ to an object and is named obj.methodname, where obj is some object (this may be an expression), and methodname is the name of a method that is defined by the object’s type. Different types define different methods. Methods of different types may have the same name without causing ambiguity.

  1. As per python documentation for class definition

When a class definition is entered, a new namespace is created, and used as the local scope — thus, all assignments to local variables go into this new namespace. In particular, function definitions bind the name of the new function here. When a class definition is left normally (via the end), a class object is created.

  1. As per python documentation for class objects

Class objects support two kinds of operations: attribute references and instantiation.

  1. As per python documentation for instance objects

The only operations understood by instance objects are attribute references. There are two kinds of valid attribute names: data attributes and methods.

A method is a function that “belongs to” an object. (In Python, the term method is not unique to class instances: other object types can have methods as well. For example, list objects have methods called append, insert, remove, sort, and so on. However, in the following discussion, we’ll use the term method exclusively to mean methods of class instance objects, unless explicitly stated otherwise.)

By definition, all attributes of a class that are function objects define corresponding methods of its instances. Valid method names of an instance object depend on its class. By definition, all attributes of a class that are function objects define corresponding methods of its instances. So in our example, x.f is a valid method reference, since MyClass.f is a function,
but x.i is not, since MyClass.i is not. But x.f is not the same thing as MyClass.f — it is a method object, not a function object.

Answered By: ABN
Categories: questions Tags: , , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.