Instance Variables - CS50P Shorts

Key Takeaways

Well, hello one and all and welcome to our short on instance variables. In a prior short on defining classes, we saw a way to create a class or a template for a package. One that we called in fact package and down below we created several instances of that class, of that template to represent individual packages here. So, notice on lines 11 and 12, I have here some code that defines for me two instances of this class that we called package. It's a bit like me creating a template for something called a package and down below creating two particular packages. Now, I did so as follows. I said down below that this first package has a number one, the sender was Alice, the recipient was Bob, and the weight here was 10. But, what actually happens as we call like a some code on line 11? Well, we said we'd come back to these lines three through six here. So, let's take a look at exactly what's happening. Well, when I run some line of code like on line 11, I again am creating some new instance of this class I've defined called package and along the way, thanks to Python, this method called dunder init is called. And we said here that it takes as input self, which refers to the new instance of the class that we are creating. And it seems like what I'm doing here is taking in various inputs like number, sender, recipient, and weight and assigning them to various attributes or properties of this class, of this instance of the class here. So, it turns out that each of these things, self.number, self.sender, and so on, are called instance variables. They're variables that belong to some instance of this class and they are defined for me whenever I call package down below. So, let's look at number for instance. Number equals one. Well, I'm now passing in to dunder init this argument number with the value one. And what happens to that number one? Well, it actually gets assigned as an instance variable within this instance of the class. So, this instance here has a variable called number. And so on for sender, recipient, and weight. But, let's see this in action here. I'll come down below. And let me try to actually access these instance variables that I claim I set up on lines three through six. Well, I could imagine, let's say, looping through every package that I have inside of this list of packages. Maybe printing them out along the way. Well, to do so, I could use a for loop. I want to print for each package I have. So, I'll say for package in the list of packages and then I'll throw this in a little later. Notice first that package will first refer to the package on line 11 and then on the next iteration the package on line 12. So, very simple here. Let's start off by printing something. We could print the package as a whole, but I don't think we'd get a very good output. What I could do instead is try printing, in this case, something like the instance variable that we called number just to start with. package.number So, if I want to access an instance variable, I can in this case refer to the individual instance of the class, package here, followed by dot, followed by the instance variable's name, just like we said up above. In this case, number. So, if I try this, I'll try python of packages.py, hit enter, we'll see one and two. But, just to hammer this home, let me try instead one and three and now I'll hopefully see one and three. So, it does seem as I defined in dunder init that the input to these variables various parameters of packages arguments here, they actually get assigned as instance variables of each instance of my class. Now, let's try accessing more and maybe printing these packages in a in a more in a prettier way. So, here I can do this. I can go back to the format I had before, but now use a Python f-string in the packages instance variables. I could say package and then package.number just like this. If I were to run this, I could see package one and package two. Pretty good. What if I tried maybe the same format from before? I could try colon and then I could enter in, let's say, the package's sender uh to package.recipient. And let's see what we see here. python packages.py package one, Alice to Bob, package two, Bob to Charlie. This is all happening by accessing these instance variables that I set up in dunder init as well. Let's now add in the weight. I'll say comma the weight was, in this case, in kilograms. I'll go ahead and now um try to run this again. I'll go ahead and go back to my terminal. python packages.py and we'll see a much prettier way of formatting these individual packages. In fact, we can get the benefits of the strings we saw, let's say, in the short on defining classes, which allows them to be more prettily printed, but we also get the benefits of this class here. So, we're encapsulating information now using these things called instance variables. This then was our short on instance variables and we'll see you next time.