There’s no error here. You’re printing a function, and that’s what functions look like.
To actually call the function, you have to put parens after that. You’re already doing that above. If you want to print the result of calling the function, just have the function return the value, and put the print there. For example:
print test.sort_word_list()
On the other hand, if you want the function to mutate the object’s state, and then print the state some other way, that’s fine too.
Now, your code seems to work in some places, but not others; let’s look at why:
parsersets a variable calledword_list, and you laterprint test.word_list, so that works.sort_word_listsets a variable calledsorted_word_list, and you laterprint test.sort_word_list—that is, the function, not the variable. So, you see the bound method. (Also, as Jon Clements points out, even if you fix this, you’re going to printNone, because that’s whatsortreturns.)num_wordssets a variable callednum_words, and you again print the function—but in this case, the variable has the same name as the function, meaning that you’re actually replacing the function with its output, so it works. This is probably not what you want to do, however.
(There are cases where, at first glance, that seems like it might be a good idea—you only want to compute something once, and then access it over and over again without constantly recomputing that. But this isn’t the way to do it. Either use a @property, or use a memoization decorator.)
The bound method error in Python occurs when there is some problem with the function call in your code. Initially, there were two types of function calls in Python, bound and unbound. When Python was updated to Python 3, the unbound method was removed to make function calls smoother and easier to execute and to avoid unnecessary errors.
There is not much information about why this feature was changed during the evolution of Python, but there is a significant difference between the two function calls.
In this article, we will find out the possible causes of the “bound method” error and how we can fix it.
The ‘bound method’ error in Python generally occurs when a method call is missing parentheses. This error was more prevalent in Python 2, but Python 3, by default, assumes all functions as bound methods. Ensure to use parentheses when calling functions to prevent such errors.
Exploring Bound Methods in Python
When a class or method is associated with an object it is called a bound method. They are also called instance method because they have a instance associated with them. These classes need arguments when they are defined.
BY default, their first argument is self. They can be influenced by the state of the instance. When methods are called on instances, they have access to the data of the instance they are called on.
In Python 3, all functions are by default bound functions. Even when not mentioned, the self object is passed as the first argument to the __init__ method during the instance initialization in Python. To know more about initialization files, click here.
For example, let’s say we have a fruit class, the various attributes of the fruit are going to be its name, color, price etc.
Let’s take a look at how to create user defined classes in Python.
# defining a fruit class here
class fruit:
# initialization function
def __init__(self, name, price, color):
# three parameters name, color, price
self.name = name
self.price = price
self.color = color
# function for only displaying price
def pricefruit(self):
print("The price of ", self.name, "is= ", self.price)
# function for only displaying name
def namefruit(self):
print("The fruit you entered is= ", self.name)
# function for only displaying color
def colorfruit(self):
print("the color of ", self.name, "is= ", self.color)
# function for displaying everything
def displayall(self):
print("The fruit is=", self.name)
print("It's color is=", self.color)
print("It's price is= ", self.price)
# driver code
# taking user input
name, color, price = input(
"enter the name of the fruit, it's colour and it's price per kilo separated by a comma respectively= "
).split(",")
# calling our class instance
fruits = fruit(name, price, color)
# calling the display all function
fruits.displayall()
print("All the features individually are:")
# calling the price function only
fruits.pricefruit()
# calling the name function only
fruits.namefruit()
# calling the color function only
fruits.colorfruit()
This is our class fruit. It is an example of object oriented programming in Python since the object is defined by various features such as it’s color, price and name.
This is a very basic example of a user defined class, as you move ahead in your programming journey you’ll come across many such classes and will also create them! This is one of the biggest advantages of Python being an object oriented programming language with one of the most easiest syntax.
The output would be:
enter the name of the fruit, it's colour and it's price per kilo separated by a comma respectively= pomegranate,red,130 The fruit is= pomegranate It's color is= red It's price is= 130 All the features individually are: The price of pomegranate is= 130 The fruit you entered is= pomegranate the color of pomegranate is= red
Read more about Python Classes and Objects here!
Root Cause of Python’s ‘Bound Method’ Error
Since all of the functions in Python 3 are bound instances by default, you cannot declare unbound or static methods. The “bound method” error arises when you forget a pair of round brackets or a pair of parentheses at the end of the function name.
This was a very common error in Python2, but nowadays in some editors the function calls work with the missing parentheses. Nonetheless, it is a good practice to include the pair of round brackets after declaring a function call to keep unnecessary errors at bay.
In other languages which are much more rigid than python, a missing parentheses will definitely raise an error leading the program to go through their code over and over again wasting precious time.
Since it is not so obvious as a error, it might confuse you for a minute because it might just say something like the one shown below:
<bound method fruit.namefruit of <__main__.fruit object at 0x108534080>>
Proven Fixes for the ‘Bound Method’ Error
The easiest fix to this is to practice putting parentheses when calling function, since it mainly comes down to the syntax knowledge of the programmer and their code structure. Instead of writing, fruit.namefruit for calling the function, practice writing fruit.namefruit() .
Note: in some IDEs this error has been removed completely and function calls even work when the pair of round brackets in missing. But to be on the safe side and to inculcate a habit of good coding, use the parenthesis whenever you call a function.
It can be also fixed using the try and except block as we do with any other exception handling. But you should avoid doing this because this doesn’t in itself solve the problem but rather suppress it.
try:
fruit.namefruit
except AttributeError:
print("Please put parenthesis at the end of function name!")
Warning:- This try and except method might not be feasible on all systems and you might encounter the same thing over and over again or it might lead to more errors. Hence to avoid the error and to avoid writing extra, unnecessary code, just use parenthesis, the exception handling is not required at all. Practice writing clear and precise code with comments beside every line in order to easily debug it in the future.
In a Nutshell: Bound Methods in Python
Bound and unbound methods have long been merged into one after Python2 got upgraded to Python3. Nowadays, only bound methods exist in python which refers to a default object association when a function is defined in this programming language. It is usually done via the self parameter, most of the time invisible when the function is called. To avoid getting weird bound method addresses as mentioned in the above section, always use parentheses. It is good programming practice. What other minute syntactical details do you think can be considered as good programming practices?
class Point():
def __init__(self, name, weight):
self.name = name
self.weight = weight
self.lst = []
self.distance = []
def ggg(self):
return self.lst.append(1)
После запуска кода:
a = Point('Pnt', 3)
a.ggg
Вызывает следующее исключение:
<bound method Point.ggg of <__main__.Point object at 0x0000000009620198>>
В чем может быть ошибка?
There’s no error here. You’re printing a function, and that’s what functions look like.
To actually call the function, you have to put parens after that. You’re already doing that above. If you want to print the result of calling the function, just have the function return the value, and put the print there. For example:
print test.sort_word_list()
On the other hand, if you want the function to mutate the object’s state, and then print the state some other way, that’s fine too.
Now, your code seems to work in some places, but not others; let’s look at why:
parsersets a variable calledword_list, and you laterprint test.word_list, so that works.sort_word_listsets a variable calledsorted_word_list, and you laterprint test.sort_word_list—that is, the function, not the variable. So, you see the bound method. (Also, as Jon Clements points out, even if you fix this, you’re going to printNone, because that’s whatsortreturns.)num_wordssets a variable callednum_words, and you again print the function—but in this case, the variable has the same name as the function, meaning that you’re actually replacing the function with its output, so it works. This is probably not what you want to do, however.
(There are cases where, at first glance, that seems like it might be a good idea—you only want to compute something once, and then access it over and over again without constantly recomputing that. But this isn’t the way to do it. Either use a @property, or use a memoization decorator.)
There’s no error here. You’re printing a function, and that’s what functions look like.
To actually call the function, you have to put parens after that. You’re already doing that above. If you want to print the result of calling the function, just have the function return the value, and put the print there. For example:
print test.sort_word_list()
On the other hand, if you want the function to mutate the object’s state, and then print the state some other way, that’s fine too.
Now, your code seems to work in some places, but not others; let’s look at why:
parsersets a variable calledword_list, and you laterprint test.word_list, so that works.sort_word_listsets a variable calledsorted_word_list, and you laterprint test.sort_word_list—that is, the function, not the variable. So, you see the bound method. (Also, as Jon Clements points out, even if you fix this, you’re going to printNone, because that’s whatsortreturns.)num_wordssets a variable callednum_words, and you again print the function—but in this case, the variable has the same name as the function, meaning that you’re actually replacing the function with its output, so it works. This is probably not what you want to do, however.
(There are cases where, at first glance, that seems like it might be a good idea—you only want to compute something once, and then access it over and over again without constantly recomputing that. But this isn’t the way to do it. Either use a @property, or use a memoization decorator.)
Methods in Python are like functions except that it is attached to an object.The methods are called on objects and it possibly make changes to that object. These methods can be Bound, Unbound or Static method. The static methods are one of the types of Unbound method. These types are explained in detail below.
Bound methods
If a function is an attribute of class and it is accessed via the instances, they are called bound methods. A bound method is one that has ‘self‘ as its first argument. Since these are dependent on the instance of classes, these are also known as instance methods.
Need for these bound methods
The methods inside the classes would take at least one argument. To make them zero-argument methods, ‘decorators‘ has to be used. Different instances of a class have different values associated with them.
For example, if there is a class “Fruits”, and instances like apple, orange, mango are possible. Each instance may have different size, color, taste, and nutrients in it. Thus to alter any value for a specific instance, the method must have ‘self’ as an argument that allows it to alter only its property.
Example:
class sample(object):
objectNo = 0
def __init__(self, name1):
self.name = name1
sample.objectNo = sample.objectNo + 1
self.objNumber = sample.objectNo
def myFunc(self):
print("My name is ", self.name,
"from object ", self.objNumber)
def alterIt(self, newName):
self.name = newName
def myFunc2():
print("I am not a bound method !!!")
samp1 = sample("A")
samp1.myFunc()
samp2 = sample("B")
samp2.myFunc()
samp2.alterIt("C")
samp2.myFunc()
samp1.myFunc()
Output:
My name is A from object 1 My name is B from object 2 My name is C from object 2 My name is A from object 1
In the above example two instances namely samp1 and samp2 are created. Note that when the function alterIt() is applied to the second instance, only that particular instance’s value is changed. The line samp1.myFunc() will be expanded as sample.myFunc(samp1). For this method no explicit argument is required to be passed. The instance samp1 will be passed as argument to the myFunc(). The line samp1.myFunc2() will generate the error :
Traceback (most recent call last):
File "/home/4f130d34a1a72402e0d26bab554c2cf6.py", line 26, in
samp1.myFunc2() #----------> error line
TypeError: myFunc2() takes 0 positional arguments but 1 was given
It means that this method is unbound. It does not accept any instance as an argument. These functions are unbound functions.
Unbound methods and Static methods
Methods that do not have an instance of the class as the first argument are known as unbound methods. As of Python 3.0, the unbound methods have been removed from the language. They are not bounded with any specific object of the class. To make the method myFunc2() work in the above class it should be made into a static method
Static methods are similar to class methods but are bound completely to class instead of particular objects. They are accessed using class names.
Need for making a method static
Not all the methods need to alter the instances of a class. They might serve any common purpose. A method may be a utility function also.
For example, When we need to use certain mathematical functions, we use the built in class Math. The methods in this class are made static because they have nothing to do with specific objects. They do common actions. Thus each time it is not an optimized way to write as:
math=Math() math.ceil(5.23)
So they can be simply accessed using their class name as Math.ceil(5.23).
A method can be made static in two ways:
- Using staticmethod()
- Using decorator
Using staticmethod(): The staticmethod() function takes the function to be converted as its argument and returns the static version of that function. A static function knows nothing about the class, it just works with the parameters passed to it.
Example:
class sample():
def myFunc2(x):
print("I am", x, "from the static method")
sample.myFunc2 = staticmethod(sample.myFunc2)
sample.myFunc2("A")
Output:
I am A from the static method
Using decorators: These are features of Python used for modifying one part of the program using another part of the program at the time of compilation. The decorator that can be used to make a method static is
@staticmethod
This informs the built-in default metaclass not to create any bound methods for this method. Once this line is added before a function, the function can be called using the class name. Consider the example taken for the Bound method where we encountered an error. To overcome that, it can be written as:
class sample(object):
objectNo = 0
def __init__(self, name1):
self.name = name1
sample.objectNo = sample.objectNo + 1
self.objNumber = sample.objectNo
def myFunc(self):
print("My name is ", self.name,
"from object ", self.objNumber)
def alterIt(self, newName):
self.name = newName
@staticmethod
def myFunc2():
print("I am not a bound method !!!")
samp1 = sample("A")
samp1.myFunc()
sample.myFunc2()
samp2 = sample("B")
samp2.myFunc()
samp2.alterIt("C")
samp2.myFunc()
samp1.myFunc()
Output:
My name is A from object 1 I am not a bound method !!! My name is B from object 2 My name is C from object 2 My name is A from object 1
Here, the line sample.myFunc2() runs without any error and the print() within it works perfectly and gives the output I am not a bound method!!!
Methods in Python are like functions except that it is attached to an object.The methods are called on objects and it possibly make changes to that object. These methods can be Bound, Unbound or Static method. The static methods are one of the types of Unbound method. These types are explained in detail below.
Bound methods
If a function is an attribute of class and it is accessed via the instances, they are called bound methods. A bound method is one that has ‘self‘ as its first argument. Since these are dependent on the instance of classes, these are also known as instance methods.
Need for these bound methods
The methods inside the classes would take at least one argument. To make them zero-argument methods, ‘decorators‘ has to be used. Different instances of a class have different values associated with them.
For example, if there is a class “Fruits”, and instances like apple, orange, mango are possible. Each instance may have different size, color, taste, and nutrients in it. Thus to alter any value for a specific instance, the method must have ‘self’ as an argument that allows it to alter only its property.
Example:
class sample(object):
objectNo = 0
def __init__(self, name1):
self.name = name1
sample.objectNo = sample.objectNo + 1
self.objNumber = sample.objectNo
def myFunc(self):
print("My name is ", self.name,
"from object ", self.objNumber)
def alterIt(self, newName):
self.name = newName
def myFunc2():
print("I am not a bound method !!!")
samp1 = sample("A")
samp1.myFunc()
samp2 = sample("B")
samp2.myFunc()
samp2.alterIt("C")
samp2.myFunc()
samp1.myFunc()
Output:
My name is A from object 1 My name is B from object 2 My name is C from object 2 My name is A from object 1
In the above example two instances namely samp1 and samp2 are created. Note that when the function alterIt() is applied to the second instance, only that particular instance’s value is changed. The line samp1.myFunc() will be expanded as sample.myFunc(samp1). For this method no explicit argument is required to be passed. The instance samp1 will be passed as argument to the myFunc(). The line samp1.myFunc2() will generate the error :
Traceback (most recent call last):
File "/home/4f130d34a1a72402e0d26bab554c2cf6.py", line 26, in
samp1.myFunc2() #----------> error line
TypeError: myFunc2() takes 0 positional arguments but 1 was given
It means that this method is unbound. It does not accept any instance as an argument. These functions are unbound functions.
Unbound methods and Static methods
Methods that do not have an instance of the class as the first argument are known as unbound methods. As of Python 3.0, the unbound methods have been removed from the language. They are not bounded with any specific object of the class. To make the method myFunc2() work in the above class it should be made into a static method
Static methods are similar to class methods but are bound completely to class instead of particular objects. They are accessed using class names.
Need for making a method static
Not all the methods need to alter the instances of a class. They might serve any common purpose. A method may be a utility function also.
For example, When we need to use certain mathematical functions, we use the built in class Math. The methods in this class are made static because they have nothing to do with specific objects. They do common actions. Thus each time it is not an optimized way to write as:
math=Math() math.ceil(5.23)
So they can be simply accessed using their class name as Math.ceil(5.23).
A method can be made static in two ways:
- Using staticmethod()
- Using decorator
Using staticmethod(): The staticmethod() function takes the function to be converted as its argument and returns the static version of that function. A static function knows nothing about the class, it just works with the parameters passed to it.
Example:
class sample():
def myFunc2(x):
print("I am", x, "from the static method")
sample.myFunc2 = staticmethod(sample.myFunc2)
sample.myFunc2("A")
Output:
I am A from the static method
Using decorators: These are features of Python used for modifying one part of the program using another part of the program at the time of compilation. The decorator that can be used to make a method static is
@staticmethod
This informs the built-in default metaclass not to create any bound methods for this method. Once this line is added before a function, the function can be called using the class name. Consider the example taken for the Bound method where we encountered an error. To overcome that, it can be written as:
class sample(object):
objectNo = 0
def __init__(self, name1):
self.name = name1
sample.objectNo = sample.objectNo + 1
self.objNumber = sample.objectNo
def myFunc(self):
print("My name is ", self.name,
"from object ", self.objNumber)
def alterIt(self, newName):
self.name = newName
@staticmethod
def myFunc2():
print("I am not a bound method !!!")
samp1 = sample("A")
samp1.myFunc()
sample.myFunc2()
samp2 = sample("B")
samp2.myFunc()
samp2.alterIt("C")
samp2.myFunc()
samp1.myFunc()
Output:
My name is A from object 1 I am not a bound method !!! My name is B from object 2 My name is C from object 2 My name is A from object 1
Here, the line sample.myFunc2() runs without any error and the print() within it works perfectly and gives the output I am not a bound method!!!
Improve Article
Save Article
Improve Article
Save Article
A bound method is the one which is dependent on the instance of the class as the first argument. It passes the instance as the first argument which is used to access the variables and functions. In Python 3 and newer versions of python, all functions in the class are by default bound methods.
Let’s understand this concept with an example:
class A:
def func(self, arg):
self.arg = arg
print("Value of arg = ", arg)
obj = A()
print(obj.func)
Output:
< bound method A.func of <__main__.A object at 0x7fb81c5a09e8>>
Here,
obj.func(arg) is translated by python as A.func(obj, arg).
The instance obj is automatically passed as the first argument to the function called and hence the first parameter of the function will be used to access the variables/functions of the object.
Let’s see another example of the Bound method.
class Car:
gears = 5
@classmethod
def change_gears(cls, gears):
cls.gears = gears
Car1 = Car()
print("Car1 gears before calling change_gears() = ", Car1.gears)
Car1.change_gears(6)
print("Gears after calling change_gears() = ", Car1.gears)
print(Car1.change_gears)
Output:
Car1 gears before calling change_gears() = 5 Gears after calling change_gears() = 6 <bound method Car.change_gears of <class '__main__.Car'>>
The above code is an example of a classmethod. A class method is like a bound method except that the class of the instance is passed as an argument rather than the instance itself. Here in the above example when we call Car1.change_gears(6), the class ‘Car’ is passed as the first argument.
I am creating a word parsing class and I keep getting a
bound method Word_Parser.sort_word_list of <__main__.Word_Parser instance at 0x1037dd3b0>
error when I run this:
class Word_Parser:
"""docstring for Word_Parser"""
def __init__(self, sentences):
self.sentences = sentences
def parser(self):
self.word_list = self.sentences.split()
def sort_word_list(self):
self.sorted_word_list = self.word_list.sort()
def num_words(self):
self.num_words = len(self.word_list)
test = Word_Parser("mary had a little lamb")
test.parser()
test.sort_word_list()
test.num_words()
print test.word_list
print test.sort_word_list
print test.num_words