TypeError with objects

Since methods are functions in an object I can assume that they have the same behavior as what I tested in the functions project.

preview

I have these tests by the end of the chapter

questions about TypeError with objects

How do methods behave when I call them with an object or an instance?
Is every object callable?

open the project

I open a terminal
I change directory to the type_error folder in the pumping_python folder
terminal
```
cd type_error
```
I open test_type_error.py from the tests folder

I use pytest-watcher to run the tests automatically

terminal

uv run pytest-watcher . --now --patterns "**/*.py"

the terminal shows

test_type_error.py ...                              [100%]

=================== 3 passed in G.HIs ====================

test_type_error_w_object_methods

RED: make it fail

I add a test with a call to AnObject.method from tests/test_type_error.py

    src.type_error.function_08(
        'positional',
        argument='keyword',
    )


def test_type_error_w_object_methods():
    src.type_error.AnObject.method_00()


# Exceptions seen

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.type_error'
                has no attribute 'AnObject'

because AnObject is not defined in src/type_error/__init__.py.

GREEN: make it pass

I open __init__.py from the type_error folder in the src folder
I add an object definition for AnObject to src/type_error/__init__.py

the terminal is my friend, and shows AttributeError
```
AttributeError: type object 'AnObject' has no attribute 'method_00'
```
because there is nothing named method_00 in AnObject.
I add the name to the object definition

the terminal is my friend, and shows NameError
```
NameError: name 'method_00' is not defined
```
I define method_00 by pointing it to None

the terminal is my friend, and shows TypeError
```
TypeError: 'NoneType' object is not callable
```
because method_00 points to None and I cannot call None like a function.
I change method_00 to a method

the test passes.

REFACTOR: make it better

I remove the commented lines from src/type_error/__init__.py

I add a call to src.type_error.AnObject().method_01 from tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: 'AnObject' object
                has no attribute 'method_01'.
                Did you mean: 'method_00'?

I add a method definition for method_01 to AnObject in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_01() takes
           0 positional arguments but 1 was given
```
because a method of an instance takes the instance of the class (self) it belongs to as the first argument.
I add @staticmethod to method_01
terminal
```
class AnObject(object):

    def method_00(): return None

    @staticmethod
    def method_01(): return None
```
the test passes because I can use the staticmethod decorator if I do not want to add self to the method definition when it does not use anything that belongs to the object.

Both methods look the same. The difference is in how I call them AnObject.method_00() vs AnObject().method_01().
- AnObject.method_00() calls method_00 of the AnObject object.
- AnObject().method_01() calls method_01 of an instance of the AnObject object.

I add a call to src.type_error.AnObject().method_02 from tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: 'AnObject' object
                has no attribute 'method_02'.
                Did you mean: 'method_00'?

I add a definition for method_02 to AnObject in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_02() takes
           0 positional arguments but 1 was given
```
because a method of an instance takes the instance of the class (self) it belongs to as the first argument.
I add @staticmethod to method_02

the terminal is my friend, and shows NameError
```
NameError: name 'self' is not defined
```

I add self to the parentheses of method_02

the terminal is my friend, and shows TypeError

TypeError: AnObject.method_02() missing
           1 required positional argument: 'self'

I comment out the staticmethod decorator

the test passes because a method of an instance takes the instance of the class (self) it belongs to as the first argument which allows it to use things that belong to the object.

I add a call to src.type_error.AnObject.method_03 from tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: type object 'AnObject'
                has no attribute 'method_03'.
                Did you mean: 'method_00'?

I add a definition for method_03 to AnObject in src/type_error/__init__.py

the terminal is my friend, and shows NameError
```
NameError: name 'method_02' is not defined
```
because there is nothing named method_02 inside method_03 or at the module level of src/type_error/__init__.py.
I add AnObject. before method_02

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_02() missing
           1 required positional argument: 'self'
```
because
- method_02 takes an instance of the object it belongs to as input.
- I called the method with the object not an instance of the class.
I use an instance of the class to call the method

the test passes. This is a silly example because I used AnObject() inside a method of AnObject. I could just use self. I would only need this if I was calling a method of a different object.

Here is another silly example. I add a call to src.type_error.AnObject.method_04 from tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: type object 'AnObject'
                has no attribute 'method_04'.
                Did you mean: 'method_00'?

I add a method definition for method_04 to AnObject in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_02() missing
           1 required positional argument: 'self'
```
because
- method_02 takes an instance of the object it belongs to as input.
- I called the method with the object not an instance of the class.
I pass AnObject as input in the call to method_02

the test passes. I called a method of AnObject and passed AnObject as input. I can use self.

I add a call to src.type_error.AnObject().method_05 from tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: 'AnObject' object
                has no attribute 'method_05'.
                Did you mean: 'method_00'?

I add a method definition for method_05 to AnObject in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_05() takes
           0 positional arguments but 1 was given
```
because a method of an instance takes the instance of the class (self) it belongs to as the first argument.
I add self to the parentheses of method_05

the terminal is my friend, and shows NameError
```
NameError: name 'method_02' is not defined
```
because there is no method_02 at the module level of src/type_error/__init__.py. It is inside AnObject in src/type_error/__init__.py, I have to be specific.
I add self. before method_02

the test passes.

I add a call to src.type_error.AnObject().method_06 from tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: 'AnObject' object
                has no attribute 'method_06'.
                Did you mean: 'method_00'?

I add a method definition for method_06 to AnObject in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_06() takes
           0 positional arguments but 1 was given
```
because a method of an instance takes the instance of the class (self) it belongs to as the first argument.
I add self to the parentheses of method_06

the test passes.

I add a call to src.type_error.AnObject().method_07 from tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: type object 'AnObject'
                has no attribute 'method_07'.
                Did you mean: 'method_00'?

I add a method definition for method_07 to AnObject in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_07() missing
           1 required positional argument: 'self'
```
because
- method_07 takes an instance of the object it belongs to as input.
- I called the method with the object not an instance of the class.
I use an instance of the class to call the method from tests/test_type_error.py

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_00() takes
           0 positional arguments but 1 was given
```
because
- method_00 takes no input (the parentheses are empty).
- I called it with an instance of the class (AnObject()) which passes the instance as input.
I add the staticmethod decorator to method_00 of AnObject in src/type_error/__init__.py

the test passes. I can use the staticmethod decorator if I do not want to add self to the method definition when it does not use anything that belongs to the object.

I add a call to src.type_error.AnObject.method_08() from tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: type object 'AnObject'
                has no attribute 'method_08'.
                Did you mean: 'method_00'?

I add a method definition for method_08 to AnObject in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_08() missing
           1 required positional argument: 'self'
```
because I called method_08 like a staticmethod and it is defined as an instance method (It expects self as input).
I use an instance of the class to call the method from tests/test_type_error.py

the terminal shows TypeError
```
TypeError: AnObject.method_04() takes
           0 positional arguments but 1 was given
```
because
- method_04 takes no input (the parentheses are empty).
- I called it with an instance of the class (AnObject()) which passes the instance as input.
I add the staticmethod decorator to method_04 of AnObject in src/type_error/__init__.py

the test passes.

I add a call to src.type_error.AnObject().method_09() from tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: 'AnObject' object
                has no attribute 'method_09'.
                Did you mean: 'method_00'?

I add a method definition for method_09 to AnObject in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: AnObject.method_03() takes
           0 positional arguments but 1 was given
```
because
- method_03 takes no input (the parentheses are empty).
- I called it with an instance of the class (AnObject()) which passes the instance as input.
I add the @staticmethod to method_03 of AnObject in src/type_error/__init__.py

the test passes.
I remove the commented lines from src/type_error/__init__.py
I remove the commented lines from tests/test_type_error.py
I open a new terminal then make sure I am in the type_error folder
terminal
```
cd type_error
```

I add a git commit message in the other terminal

terminal

git commit --all --message \
'add test_type_error_w_object_methods'

test_type_error_w_the_uncallables

Is every object callable?

RED: make it fail

I go back to the terminal that is running the tests.
I add a test to tests/test_type_error.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.type_error' has no attribute 'none'
```
there is nothing named none in src/type_error/__init__.py in the src folder, yet.

GREEN: make it pass

I add none and point it to None
```
1none = None
```
the terminal is my friend, and shows TypeError
```
TypeError: 'NoneType' object is not callable
```
- the () to the right of src.type_error.none makes it a call
- the name none points to None which is NOT callable. Using substitution
```
none = None   # point the name to the object
none()        # call the name
None()        # substitute the value for the name
```
  None() raises TypeError because I cannot call None like a function.

I make none a function in src/type_error/__init__.py to make it callable

# none = None
def none(): return None


def function_00(the_input):
    return None

the test passes.

I can call a function, I cannot call None.

REFACTOR: make it better

I add a call to false in tests/test_type_error.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.type_error'
                has no attribute 'false'
```
false is not in src/type_error/__init__.py.
I add false to src/type_error/__init__.py and point it to False
```
1# none = None
2def none(): return None
3false = False
4
5
6def function_00(the_input):
7    return None
```
the terminal is my friend, and shows TypeError
```
TypeError: 'bool' object is not callable
```
false points to False which is NOT callable. Using substitution
```
false = False
false()
False()
```
False() raises TypeError because I cannot call a boolean like a function.

I change false from a variable to a function to make it callable

# none = None
def none(): return None
# false = False
def false(): return False


def function_00(the_input):
    return None

the test is green again.

I add a call to the other boolean in tests/test_type_error.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.type_error'
                has no attribute 'true'
```
there is nothing named true in src/type_error/__init__.py.
I add true and point it to True in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: 'bool' object is not callable
```
I change true from a variable to a function to make it callable

the test passes. I can call a function, I cannot call a boolean or None.

I add a call to an integer, in tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.type_error'
                has no attribute 'an_integer'

I add an_integer and point it to 1234 in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: 'int' object is not callable
```
the name an_integer points to an integer (1234) which is NOT callable. Using substitution
```
an_integer = 1234  # point the name to the object
an_integer()       # call the name
1234()             # substitute the value for the name
```
1234() raises TypeError because I cannot call an integer like a function.
I change an_integer from a variable to a function to make it callable

the test passes. I can call a function, I cannot call an integer, a boolean or None.

I add a call to a float in tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.type_error'
                has no attribute 'a_float'

I add a_float and point it to 5.678 in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: 'float' object is not callable
```
a_float points to a float (5.678) which is NOT callable. Using substitution
```
a_float = 5.678
a_float()
5.678()
```
5.678() raises TypeError because I cannot call a float like a function.
I change a_float from a variable to a function to make it callable

the test passes. I can call a function, I cannot call a float, integer, boolean or None.
I add a call to a string (anything in quotes) in tests/test_type_error.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.type_error'
                has no attribute 'a_string'
```
I add a_string and point it to 'a string' in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: 'str' object is not callable
```
the name a_string points to a string ('a string') which is NOT callable. Using substitution
```
a_string = 'a string' # point the name to the object
a_string()            # call the name
'a string'()          # substitute the value for the name
```
'a string'() raises TypeError because I cannot call a string like a function.
I change a_string from a variable to a function to make it callable

the test passes. I can call a function, I cannot call a string, float, integer, boolean or None.
I add a call to a tuple (anything in parentheses (), separated by a comma) in tests/test_type_error.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.type_error'
                has no attribute 'a_tuple'
```
I add a_tuple and point it to (0, 1, 2, 'n') in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: 'tuple' object is not callable
```
the name a_tuple points to a tuple ((0, 1, 2, 'n')) which is NOT callable. Using substitution
```
a_tuple = (0, 1, 2, 'n')
a_tuple()
(0, 1, 2, 'n')()
```
(0, 1, 2, 'n')() raises TypeError because I cannot call a tuple like a function.
I change a_tuple from a variable to a function to make it callable

the test passes. I can call a function, I cannot call a tuple, string, float, integer, boolean or None.

I add a call to a list in tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.type_error'
                has no attribute 'a_list'

I add a_list and point it to [0, 1, 2, 'n'] in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: 'list' object is not callable
```
a_list points to a list ([0, 1, 2, 'n']) which is NOT callable. Using substitution
```
a_list = [0, 1, 2, 'n']
a_list()
[0, 1, 2, 'n']()
```
[0, 1, 2, 'n']() raises TypeError because I cannot call a list like a function.
I change a_list from a variable to a function to make it callable

the test passes. I can call a function, I cannot call a list, tuple, string, float, integer, boolean or None.

I add a call to a set in tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.type_error'
                has no attribute 'a_set'

I add a_set and point it to {0, 1, 2, 'n'} in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: 'set' object is not callable
```
a_set points to a set ({0, 1, 2, 'n'}) which is NOT callable. Using substitution
```
a_set = {0, 1, 2, 'n'}
a_set()
{0, 1, 2, 'n'}()
```
{0, 1, 2, 'n'}() raises TypeError because I cannot call a set like a function.
I change a_set from a variable to a function to make it callable

the test passes. I can call a function, I cannot call a set, list, tuple, string, float, integer, boolean or None.

I add a call to a dictionary in tests/test_type_error.py

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.type_error'
                has no attribute 'a_dictionary'

I add a_dictionary and point it to {'key': 'value'} in src/type_error/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: 'dict' object is not callable
```
a_dictionary points to a dictionary ({'key': 'value'}) which is NOT callable. Using substitution
```
a_dictionary = {'key': 'value'}
a_dictionary()
{'key': 'value'}()
```
{'key': 'value'}() raises TypeError because I cannot call a dictionary like a function.
I change a_dictionary from a variable to a function to make it callable

the test is green again. I can call a function, I cannot call a dictionary, set, list, tuple, string, float, integer, boolean or None.

I remove the commented lines from src/type_error/__init__.py

def none(): return None
def false(): return False
def true(): return True
def an_integer(): return 1234
def a_float(): return 5.678
def a_string(): return 'a string'
def a_tuple(): return (0, 1, 2, 'n')
def a_list(): return [0, 1, 2, 'n']
def a_set(): return {0, 1, 2, 'n'}
def a_dictionary(): return {'key': 'value'}


def function_00(the_input):
    return None

I add a git commit message in the other terminal

terminal

git commit --all --message \
'add test_type_error_w_the_uncallables'

close the project

I close tests/test_type_error.py and src/type_error/__init__.py
I click in the terminal where the tests are running
I use q on the keyboard to leave the tests. The terminal goes back to the command line.
I change directory to the parent of type_error
terminal
```
cd ..
```
the terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory.

review

The tests show that

If I call a method with an instance, it takes the instance as the first argument (self).
I can use the staticmethod decorator if the method does not use anything that belongs to the object it is part of.
There are objects that are not callable.

All the tests so far show that I get TypeError when I call an object in a way that is different from its definition.

How many questions can you answer about TypeError with objects?

code from the chapter

Do you want to see all the CODE I typed in this chapter?

what is next?

Would you like to see another way to write tests?

rate pumping python

If this has been a 7 star experience for you, please CLICK HERE to leave a 5 star review of pumping python. It helps other people get into the book too.