Giving Your Classes Behavior With Methods

00:00 Your classes don’t have to be static data containers. You can customize their behavior through the use of methods. Methods are functions defined within a class.

00:09 Instance methods define behaviors for class instances. They can be called on class instances using the dot accessor, and they provide encapsulation by bundling functionality with data.

00:19 You define instance methods in the class body with the def keyword. You could take the Crew class defined before and add a method like this.

00:28 Within the class body after __init__(), you can add a description() method, def description: taking in the parameter self.

00:35 Return the f-string f"{self.name} is {self.age} years old." The resulting method can be called on Crew instances using the dot accessor, like crew_instance.description() and when called, self takes on the value of the instance calling the method just like with __init__().

00:52 Because self is an instance of Crew, you can access its instance attributes of name and age. And note how these are referred to as instance methods.

01:01 That’s because there’s actually a few different kinds of methods you can define in classes. They go beyond the scope of this course, but here’s a recommendation for your reading list: Python’s Instance, Class, and Static Methods Demystified.

01:14 Now open up the code editor of your choice and we’ll look at instance methods in more detail.

01:20 Here in VS Code, we’re starting with the Starship class you defined in the previous lesson. You’ll be adding two methods: description(), which will return a string describing the instance and set_destination(), which returns a string description of the action. def description: taking in the parameter self.

01:38 Return the f-string f"{self.ship_type} - {self.name}".

01:45 def set_destination taking in the parameter self and destination. Return the f-string f"{self.name} sets a course for {destination}."

01:59 Now save, open up the terminal, and open the REPL. Because this terminal is running in the same directory as starship.py, you can import classes directly, like so: from starship import Starship and create a ship: enterprise = Starship( "Enterprise", 430)

02:19 and try out that description() method. And remember, because self is the only parameter, you actually pass nothing when you call it. enterprise.description() returns 'Exploration vessel - Enterprise'.

02:30 Now try set_destination(). This takes an argument, the destination. Try

02:36 enterprise.set_destination("Earth"), 'Enterprise sets a course for Earth' Or another one, enterprise.set_destination("Vulcan") 'Enterprise sets a course for Vulcan'.

02:49 Okay, pretty cool, but there’s something not entirely Pythonic about that description() method. It’s useful for classes to provide a string description with info about the class, but as Python developers, normally we’d want to use the print() function to see it.

03:04 For example, if you have a list with some contents like a list of ships with the strings "Enterprise", "TARDIS" and "Millennium Falcon".

03:14 If you print that list, you should see its contents, right? print(ships) and the result is 'Enterprise', 'TARDIS' and 'Millennium Falcon'.

03:22 But right now, if you print our Starship enterprise, you get the default description: print(enterprise) <starship.Starship object> at some memory address.

03:32 Turns out this is also a behavior you can change in your class.

03:36 Exit the REPL for now, and edit starship.py. In fact, all you really need to do is change the name of description from description to __str__ for string.

03:48 This is another special method, and it controls what will be displayed when the class instances are passed to the print() function. The important thing is that it returns a string, which description() already did.

04:00 So save and go back to the REPL.

04:05 from starship import Starship enterprise = Starship( passing in "Enterprise", 430) and print(enterprise)

04:17 "Exploration Vessel - Enterprise", ta-da. You can see why it’s called a magic method, and this is also a great example of the principle of abstraction.

04:27 Users of the Starship class don’t need to know anything about Starship internals or the print() function’s internals to use them together to get a useful output.

04:36 Now that the Starship class has a little more going on, maybe you’re already thinking about other kinds of space vessels that could exist, that might share functionality with Starship, but perhaps be more specialized.

04:48 Yes? Then it’s the perfect time to talk about inheritance. See you in the next lesson.