Instance Methods - CS50P Shorts

Key Takeaways

Well, hello one and all and welcome to our short on instance methods. Now, we've seen in prior shorts on defining classes and instance variables ways to define some template for some object and ways to instantiate individual instances of those templates to refer to in code and access their various instance variables or traits of each of those individual in this case packages. So, we have here again a class called package that encapsulates some information about packages in general. We say that every package we'll create will have a number like an ID, a sender, a recipient, and a weight to it. And we then define here the various instance variables whenever we create a new instance of this class. Down below on lines 11 and 12, we actually create these instances. We have here on line 11 a package whose number is one, whose sender is Alice, whose recipient is Bob, and whose weight is 10. And then finally down below on line 14, we have some code here that actually accesses the instance variables to print out in a more pretty format um the package information itself. So, let's try running this and see the output down below once more. I'll run python of packages.py and we'll see thanks to the code that we all have here, uh we're able to print information on these packages while still encapsulating and combining the information in a more organized way. Now, it turns out that I can use classes to not just encapsulate or combine pieces of information, but to also encapsulate functionality that I want to be common across all individual packages. I can do so by defining in this case what I might call an instance method. A method that can be run on any instance of this particular class. Now, when I say method here, I'm really referring to particular kind of function that is part of a class. And I'm going to show you one that you might find handy. One called dunder str, dunder stir. So, similar to dunder init, dunder stir is a special instance method that can be called when I when I were to print some package. Now, down below here on line 15, this is a long line of code, but wouldn't it be nice let's say if I could simply print a package like this. Print package and get let's say the same format I have down below. Right now, this will not be the case. If I run python of packages.py, I'll see this. Just not very pretty at all. But I could add an instance method called dunder str to actually improve the output of in this case what I see when I call print on any given instance of my package class. So, let's go back up here and to define some new instance method, well I can simply drop down a line and define some new function that's part of my class. And because this one is a special method defined as some special functionality by Python itself, I'll use these double underscores and then str. In fact, the double underscores which passes as dunder they tend to refer to these special methods that Python attaches a special meaning to. In this case, dunder stir is actually called every time I print every time I call print on an instance of my individual package. So, by convention dunder stir takes as input in this case the in this case the instance of the class itself that we refer to as self. And within dunder stir, I can return some string that will be printed every time I call print on an instance of the package. So, just as a test here, why don't I say um why don't I say this is a package. This is a package. So, every time I call print on a package, hopefully I'll see this is a package. I'll go ahead and run. Go ahead and run python of packages.py and for both of those within my list here this package and this package, we'll see this is a package. Which is helpful, but only a little bit. Like ideally, I'd show some information on the actual instance of the package I'm talking about. So, to do so, I can again access these instance variables and return let's say something like an f-string. It's in the same format we had down below. I could say package again and then self.number colon maybe uh self.sender to self.recipient and then uh comma self.weight uh kg just like this. So, this is the same f-string we had in that for loop, but now I've encapsulated that same f-string inside of my package class within this instance method called dunder stir. Now, ideally when I run python of packages.py, we'll see some more information on this package, but much more simply now we can simply call print package. I'll run this and we'll see that same information now part of some instance method called dunder stir. So, pretty handy here. Now, what else could we actually use instance methods for? We want to maybe attach functionality that seems pretty core to the idea of being a package. Maybe one thing we want packages to be able to do is calculate the cost of shipping them. So, I can imagine here defining another instance method, maybe one called calculate cost that allows a package to figure out how much it cost itself to ship. So, I could here define here maybe a new method called calculate cost. And these instance methods by default again take as input as the first argument the instance itself that we refer to as this variable this argument called self. Now, as another input to calculate cost, maybe the cost changes and maybe a cost per kilogram that I can specify as input to this particular method here. I'll type a colon and within this particular function body, I can then define this instance method called calculate cost. Hm. Let's first see how to use this instance method though. Maybe instead of going down here and just printing the package, I could do something a little more fancy. I could say, why don't we print the package itself as part of this f-string, but then also say that it costs it costs some amount. Now that I have this function called calculate cost that is yet unimplemented, I could use it as follows. For each instance in this case we're calling package in this for loop, I could call calculate cost by typing a dot and then function the actual method name. So, calculate cost. And now as input to calculate cost, could actually type in the input I'm expecting cost per kg. So, I'll say cost per kg and now what we say it's about two US dollars per kilogram to ship some given package. This is how we want to use calculate cost, but now let's implement it up on line 11. Well, I want to make sure to return here the total cost the package. I actually know the cost per kilogram. So, to do that, I think I need to do some simple multiplication. I could maybe find the weight in kilograms and multiply it by the cost per kilogram. So, I could say maybe self self.weight again accessing some instance variable and multiply that by the cost per kilogram. And we'll make the assumption here the user knows that weight should be in kilograms. So, we'll go ahead and say this is calculate cost. It takes the weight in kilograms, multiplies it by the cost per kilogram, and that is the cost of shipping this particular package. So, let's try it down below. Why don't I go ahead and run python of packages.py and now we'll see package one Alice to Bob 10 kg costs 20 and package two costs 10. Probably improve this a little bit. We could simply add a dollar sign here to say this is in US dollars. Run packages.py again and now we'll see some pretty good formatting here. So, this was our brief foray into instance methods. There are some special ones like dunder stir that allows us to say how a instance should be printed as as we saw down below. We can also add some functionality, encapsulate functionality in this case like one to calculate the cost of shipping some given package. This then was our short on instance methods and we'll see you next time.