Object Methods: Actions and Interactions

1. From Data to Behavior: What is a Method?

If attributes are the nouns that describe an object (like name, age, color), then methods are the verbs that describe what an object can do (like bark(), drive(), calculate_email()).

A method is simply a function that is defined inside a class. Because it's part of the class, it can access and use the object's instance attributes.

Let's continue with the Employee class example from the previous lesson's videos. The Employee objects have first, last, and pay attributes. A useful action would be to get the employee's full name. We can create a method for that.

As you saw, defining a method is straightforward. Here's a textual summary to reinforce the concept, using a Dog class as an example.

2. Calling a Method

Once a method is defined in the class, you can "call" it on any instance of that class. The syntax is instance_name.method_name().

It's crucial to include the parentheses () at the end.

• my_dog.name accesses the name attribute (data).
• my_dog.speak() calls the speak method (executes an action).

Let's see this in action.

3. Why self is Essential

You might wonder why we need to write self as the first parameter in every method definition, even though we don't seem to pass it when we call the method (e.g., employee1.full_name()).

This is a bit of Python magic. When you write employee1.full_name(), Python automatically transforms it behind the scenes into Employee.full_name(employee1). It passes the instance (employee1) as the first argument to the method. That's what self becomes.

Forgetting self in your method definition is one of the most common errors for beginners. The following clip explains this TypeError and clarifies what's happening.

4. Methods That Change an Object's State

The full_name() method we've seen so far uses instance attributes to return a new value. But methods can also change an object's attributes. This means an object can have a state that its methods can modify.

For example, a Microwave object could have an attribute is_on. A turn_on() method could change this attribute from False to True.

This concept of state is central to object-oriented programming. Each object maintains its own state (self.turned_on can be True for one microwave and False for another), and its methods operate on that state.

5. Practice: Build a LibraryBook Class

Now it's time to put all these concepts together. You will create a LibraryBook class that has both data and behavior.

Your Task:

1. Open your code editor and create a new file.
2. Define a class named LibraryBook.
3. Implement the __init__ constructor. It should accept two arguments: title and author. It should initialize three attributes:
   • self.title
   • self.author
   • self.is_checked_out (This should be set to False by default inside __init__).
4. Define a method check_out(). This method should change the is_checked_out attribute to True.
5. Define another method check_in(). This method should change is_checked_out to False.
6. Define a method status(). This method should check the value of self.is_checked_out and print a message indicating if the book is "available" or "on loan".
7. Create an instance of your LibraryBook class (e.g., my_book = LibraryBook("The Hobbit", "J.R.R. Tolkien")).
8. Test your methods:
   • Call the status() method to see its initial state.
   • Call the check_out() method.
   • Call status() again to confirm the state has changed.
   • Call the check_in() method.
   • Call status() one last time.

# 1. Define the LibraryBook class
class LibraryBook:



    # 2. Implement the __init__ constructor
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.is_checked_out = False # Default state is available




    # 3. Define the check_out method
    def check_out(self):
        print(f"Checking out '{self.title}'...")
        self.is_checked_out = True




    # 4. Define the check_in method
    def check_in(self):
        print(f"Checking in '{self.title}'...")
        self.is_checked_out = False




    # 5. Define the status method
    def status(self):
        if self.is_checked_out:
            print(f"'{self.title}' by {self.author} is currently on loan.")
        else:
            print(f"'{self.title}' by {self.author} is available.")




# 6. Create an instance
my_book = LibraryBook("The Hobbit", "J.R.R. Tolkien")




# 7. Test the methods
my_book.status()      # Should print "is available"
my_book.check_out()   # Checks the book out
my_book.status()      # Should print "is currently on loan"
my_book.check_in()    # Checks the book back in
my_book.status()      # Should print "is available"

Conclusion

Fantastic work today! You have now learned how to give your objects behavior by defining and calling methods. This bridges the gap between just storing data and creating dynamic components that can perform actions and manage their own state.

Key Takeaways:

• Methods are functions defined inside a class that give objects behavior.
• Methods are called using dot notation with parentheses: my_object.my_method().
• The first parameter of every instance method is self, which refers to the object instance the method is being called on. Python passes this argument automatically.
• Methods can access instance attributes (self.attribute) to read data.
• Methods can also modify instance attributes, changing the object's internal state.

In the next lesson, we will focus on creating multiple instances of a class and managing their individual state. This will reinforce everything we've learned about __init__ and methods by showing how you can create and manage many independent objects from a single class blueprint.