{"id":988,"date":"2021-07-30T10:13:14","date_gmt":"2021-07-30T09:13:14","guid":{"rendered":"https:\/\/thepythoncodingbook.com\/?page_id=988"},"modified":"2023-11-12T12:51:11","modified_gmt":"2023-11-12T12:51:11","slug":"object-oriented-programming","status":"publish","type":"page","link":"https:\/\/thepythoncodingbook.com\/object-oriented-programming\/","title":{"rendered":"7 | Object-Oriented Programming"},"content":{"rendered":"\n
\n\n\n\n

In a previous Chapter, I defined programming as \u201cstoring data and doing stuff with the data\u201d. This definition is not the most technical and detailed definition you\u2019ll read, but it\u2019s still a very good one. You\u2019ve learned about both parts of this definition. You can store data using various data types, and you can perform actions with the data, primarily by using functions. Object-oriented programming<\/strong> merges these two into a single item.<\/p>\n

I\u2019ll get back to this merger a bit later. This topic brings along with it some new terminology, too. You\u2019ll soon read about classes, objects, instances, attributes, and a few more too. As I\u2019ve done previously in this book, I\u2019ll make sure to explain the concepts behind these terms as clearly as possible.<\/p>\n

Indeed, you\u2019ve already come across the term class. You\u2019ve been using classes since your first program in Chapter 1. Have a look at the following variables:<\/p>\n<\/div>\n\n\n\n

>>> number = 10\n>>> name = \"Stephen\"\n>>> shopping_list = [\"Coffee\", \"Bread\", \"Butter\", \"Tomatoes\"]\n\n>>> type(number)\n<class 'int'>\n>>> type(name)\n<class 'str'>\n>>> type(shopping_list)\n<class 'list'><\/pre>\n\n\n\n
When you use the type()<\/code> built-in function to display an object\u2019s data type, you\u2019re told that this is of class 'int'<\/code> or class 'str'<\/code> or whatever the name of the data type may be.<\/p>\n
If you reread the previous sentence, you\u2019ll also notice the use of the word \u2018object\u2019. You can see you\u2019ve also been using objects all the time! All will be clear by the end of this Chapter.<\/p>\n
The Object-Oriented Programming Paradigm<\/h2>\n
First, let\u2019s have a quick word about philosophy. Object-oriented programming is one of several programming paradigms<\/strong> or styles of programming. Whereas the tools you have learned about so far are unavoidable in most modern programming, object-oriented programming is a style of programming that you can use if you wish. However, there are some applications where it may be hard to avoid this paradigm.<\/p>\n
If you search on the internet\u2013a dangerous place to be most of the time\u2013you\u2019ll find a vast range of views about object-oriented programming, or OOP. Some love it. Others hate it. But if you don\u2019t get dragged into these philosophical debates about programming, you\u2019ll find that object-oriented programming is a great tool to have in your toolbox that you can choose to use on some occasions and avoid in other cases.<\/p>\n
Python is inherently an object-oriented programming language. However, you\u2019ll often see Python described as a multi-paradigm language. This means that it\u2019s a language that supports many different programming styles, including object-oriented programming.<\/p>\n
Meet The Market Seller<\/h2>\n
That\u2019s enough about the theory of object-oriented programming for the time being. Let\u2019s work our way towards what object-oriented programming is.<\/p>\n
In this Chapter, you\u2019ll use the example of a market seller who\u2019s been learning Python and who decides to write code to help him deal with his daily operations of selling items at the market stall. You\u2019ve already met the market seller in Chapter 5 when you read about errors and bugs.<\/p>\n
He has four items on sale in this small stall. His first attempt at writing this code uses a number of lists:<\/p>\n<\/div>\n\n\n\n
items = [\"Coffee\", \"Tea\", \"Chocolate\", \"Sandwich\"]\ncost_price = [1.1, 0.5, 0.9, 1.7]\nselling_price = [2.5, 1.5, 1.75, 3.5]\nstock = [30, 50, 35, 17]<\/pre>\n\n\n\n
His next section prompts the user to enter the item sold and the quantity:<\/p>\n<\/div>\n\n\n\n
items = [\"Coffee\", \"Tea\", \"Chocolate\", \"Sandwich\"]\ncost_price = [1.1, 0.5, 0.9, 1.7]\nselling_price = [2.5, 1.5, 1.75, 3.5]\nstock = [30, 50, 35, 17]\n\n# Input items and quantity sold\nitem_sold = input(\"Enter item sold: \").title()\nquantity = int(input(\"Enter quantity sold: \"))\nitem_index = items.index(item_sold)<\/pre>\n\n\n\n
In this code, you\u2019ll note that you used the string method title()<\/code> directly after the input()<\/code> function. This is possible because input()<\/code> returns a string. The title()<\/code> method converts a string into title case. Try to run "this is a string".title()<\/code> in the Console to see what\u2019s the output.<\/p>\n
You\u2019ve already seen the need for changing the string returned from input()<\/code> to a numeric format when you get the value for the quantity sold. You\u2019ve used the built-in function int()<\/code> with the input()<\/code> function as its argument.<\/p>\n
The list method index()<\/code> returns the index that matches the item in the list. You can use this method to find the location of a specific item in the list.<\/p>\n
The +=<\/code> and -=<\/code> Operators<\/h2>\n
Let\u2019s take a small detour before returning to the market seller\u2019s first attempt at this code.<\/p>\n
A common requirement in a program is to increment the value stored within a variable. For example, if you want to add to the score in a game, you can write:<\/p>\n<\/div>\n\n\n\n
>>> score = 0\n>>> score = score + 1\n>>> score\n1<\/pre>\n\n\n\n
There\u2019s a shortcut in Python for this operation which makes the code easier to write and more succinct:<\/p>\n<\/div>\n\n\n\n
>>> score = 0\n>>> score += 1\n>>> score\n1<\/pre>\n\n\n\n
The +=<\/code> operator increments the value of the variable by the amount which follows the operator. The above code snippet is identical to the one before it.<\/p>\n
You can also decrease the value in a similar manner:<\/p>\n<\/div>\n\n\n\n
>>> score = 0\n>>> score -= 5\n>>> score\n-5<\/pre>\n\n\n\n
Other arithmetic operators work in the same way. You may want to experiment with *=<\/code> and \/=<\/code> as well, for example.<\/p>\n
Market Seller\u2019s First Attempt<\/h2>\n
Let\u2019s look at the next section in the market seller\u2019s first attempt at writing the code:<\/p>\n<\/div>\n\n\n\n
items = [\"Coffee\", \"Tea\", \"Chocolate\", \"Sandwich\"]\ncost_price = [1.1, 0.5, 0.9, 1.7]\nselling_price = [2.5, 1.5, 1.75, 3.5]\nstock = [30, 50, 35, 17]\n\ndaily_income = 0\n\n# Input items and quantity sold\nitem_sold = input(\"Enter item sold: \").title()\nquantity = int(input(\"Enter quantity sold: \"))\nitem_index = items.index(item_sold)\n\n# Work out required values\nprofit = quantity * (selling_price[item_index] - cost_price[item_index])\ndaily_income += selling_price[item_index] * quantity\n\n# Update stock\nstock[item_index] -= quantity\n# TODO Add check to make sure stock does not go below zero\n\nprint(profit)\nprint(daily_income)\nprint(stock[item_index])<\/pre>\n\n\n\n
This works. The section headed with the comment \u2018Work out required values\u2019 works out the profit by subtracting the item\u2019s cost price from its selling price and multiplying that by the quantity sold. The next line increases the income for the day using the increment operator +=<\/code> which takes the current value of daily_income<\/code> and adds the income from this sale to it.<\/p>\n
The following section, which has the heading \u2018Update stock\u2019, updates the number of items in stock by using the decrement operator. The market seller also added a comment to remind him to add a bit more code later to check that the stock doesn\u2019t go below zero. Adding such a comment is a common technique to leave notes in your code for later on. Most IDEs also interpret the # TODO<\/code> comments differently from other comments, and the IDE will show you a to-do list using these comments.<\/p>\n
You can see the output from the test the market seller ran:<\/p>\n<\/div>\n\n\n\n
Enter item sold: chocolate\nEnter quantity sold: 7\n5.95\n12.25\n28\n<\/code><\/pre>\n
But the market seller stopped at this point as he realised that this might become quite cumbersome to deal with. Every operation will need to carefully reference the correct item in the correct list using the index. As the market seller adds more products and more information about each product, this method can quickly get out of hand.<\/p>\n
Data that belong together<\/h4>\n
The code above stores the item\u2019s name, cost price, selling price, and stock quantity in separate variables. You<\/em> know that these separate storage boxes \u201cbelong together\u201d and that each item in each list is related to the other items occupying the same position in the other lists.<\/p>\n
However, the computer program doesn\u2019t know that these data are related. Therefore, you need to ensure you make all of those links in the code. This style can make the code less readable and more prone to errors and bugs.<\/p>\n
The Market Seller\u2019s Second Attempt<\/h2>\n
The market seller noticed the problem with having many lists which store the various attributes linked to each product. So, he decided to refactor his code and use dictionaries instead. Refactoring<\/strong> is the process of changing the code to make it neater and better without changing the overall behaviour of the code. Here\u2019s the market seller\u2019s refactored second attempt:<\/p>\n<\/div>\n\n\n\n
# Create dictionary with item names as keys and a list of numbers as the values. The\n# numbers in the lists refer to the cost price, selling price, and quantity in stock\n# respectively\nitems = {\n    \"Coffee\": [1.1, 2.5, 30],\n    \"Tea\": [0.5, 1.5, 50],\n    \"Chocolate\": [0.9, 1.75, 35],\n    \"Sandwich\": [1.7, 3.5, 17],\n}\n\ndaily_income = 0\n\n# Input items and quantity sold\nitem_sold = input(\"Enter item sold: \").title()\nquantity = int(input(\"Enter quantity sold: \"))\n\n# Work out required values\nprofit = quantity * (items[item_sold][1] - items[item_sold][0])\ndaily_income += items[item_sold][1] * quantity\n\n# Update stock\nitems[item_sold][2] -= quantity\n# TODO Add check to make sure stock does not go below zero\n\nprint(profit)\nprint(daily_income)\nprint(items[item_sold][2])<\/pre>\n\n\n\n
You\u2019re now storing the data in a single dictionary instead of several lists. The keys in the dictionary are strings with the names of the items. The value for each key is a list. Each list contains the cost price, selling price, and the number of items in stock in that order.<\/p>\n
You may have already spotted one drawback. You need to reference the data in the lists using the index. Look at the following line as an example:<\/p>\n<\/div>\n\n\n\n
profit = quantity * (items[item_sold][1] - items[item_sold][0])<\/pre>\n\n\n\n
You first need to use one of the keys to extract a value from the dictionary items<\/code>. The variable item_sold<\/code> is the string that contains the name of the item.<\/p>\n
items[item_sold]<\/code> refers to the value of the item_sold<\/code> key, which is a list. You\u2019re then indexing this to get one of the numerical values in the list. Therefore, items[item_sold][1]<\/code> refers to the selling price of the item represented by the string item_sold<\/code>. This makes the code harder to read and, for the same reason, more prone to errors.<\/p>\n
Using a single data structure to store all the data has its advantages. Adding a new item or removing one that\u2019s no longer sold is easier with the dictionary version than with the list approach. However, as the data structure becomes more complex, accessing items can also become trickier, leading to code that\u2019s harder to write, read, and maintain.<\/p>\n
Adding Functions To Perform The Tasks<\/h3>\n
Before looking at yet another way of writing this code, you can add some functions to the code you have so far:<\/p>\n<\/div>\n\n\n\n
# Create dictionary with item names as keys, and a list of numbers as value. The\n# numbers in the lists refer to the cost price, selling price, and quantity in stock\n# respectively\nitems = {\n    \"Coffee\": [1.1, 2.5, 30],\n    \"Tea\": [0.5, 1.5, 50],\n    \"Chocolate\": [0.9, 1.75, 35],\n    \"Sandwich\": [1.7, 3.5, 17],\n}\n\ndaily_income = 0\n\ndef get_sale_info():\n    item_sold = input(\"Enter item sold: \").title()\n    quantity = int(input(\"Enter quantity sold: \"))\n    return item_sold, quantity\n\ndef get_profit(item_sold, quantity):\n    return quantity * (items[item_sold][1] - items[item_sold][0])\n\ndef update_income(item_sold, quantity):\n    return daily_income + items[item_sold][1] * quantity\n\ndef update_stock(item_sold, quantity):\n    items[item_sold][2] -= quantity\n    # TODO Add check to make sure stock does not go below zero\n\n# Call functions\nitem_sold, quantity = get_sale_info()\nprofit = get_profit(item_sold, quantity)\ndaily_income = update_income(item_sold, quantity)\nupdate_stock(item_sold, quantity)\n\nprint(profit)\nprint(daily_income)\nprint(items[item_sold][2])<\/pre>\n\n\n\n
This code now puts all the functionality of the code into standalone functions. You\u2019ll recall the definition of programming I started the Chapter with. This code now clearly has the data stored in one variable and all the tasks that need to happen are defined as functions.<\/p>\n
Let\u2019s look at these functions a bit closer. The first one is get_sale_info()<\/code>. This function asks the user to type in the product sold and how many of it were sold in a particular sale. The function returns a tuple with the values stored in item_sold<\/code> and quantity<\/code>. You\u2019ll recall that the parentheses are not needed to create a tuple, so the variable names in the return<\/code> statement are not enclosed in brackets.<\/p>\n
The functions get_profit()<\/code>, update_income()<\/code>, and update_stock()<\/code> all have two parameters. When you call these functions, the name of the item sold and the quantity sold need to be passed to the function.<\/p>\n
Accessing global variables in functions<\/h4>\n
These three functions also use the data stored in the variable items<\/code>. And update_income()<\/code> also uses the data in daily_income<\/code>. Functions have access to the global variables of the scope that\u2019s calling them. This means that when Monty<\/a>, the computer program, goes to a Function Room, he can still use any of the boxes which are on the White Room<\/a>\u2019s shelves.<\/p>\n
However, you can only ever use these functions with these variables. So, you may want to define the functions so that all the data needed is passed in as an argument and then returned when the function finishes its tasks. However, I won\u2019t make this change to this code as instead, I\u2019ll discuss the third option.<\/p>\n
Changing the state of an object<\/h4>\n
You can notice another difference in the behaviour of these functions. The update_stock()<\/code> function doesn\u2019t return anything as its only job is to change a value directly within the dictionary items<\/code>. Dictionaries are mutable data types, and therefore this is valid. You may hear this referred to as changing the state<\/strong> of the object items<\/code>.<\/p>\n
The other functions do not make any changes to existing variables directly. Instead, they return the new values, which you can then assign to variables when you call the functions, as you do in the section labelled \u2018Call functions\u2019 in the code.<\/p>\n
In this Chapter and the later Chapter on Functional Programming, you\u2019ll learn more about functions that change existing objects\u2019 state and others that do not.<\/p>\n
Object-Oriented Programming<\/h2>\n
We\u2019ve gone a long way in this Chapter without having written any object-oriented code. Let\u2019s redress this now that you\u2019re familiar with the problems the market seller has encountered.<\/p>\n
When thinking with an object-oriented programming mindset, the starting point is to think of the main objects<\/strong> relevant to the problem you\u2019re solving. In a way, you need to think of the problem from a human being\u2019s perspective first and design your solution accordingly.<\/p>\n
Let\u2019s see what this means from the market seller\u2019s perspective. What are the objects that are relevant for the market seller? The objects that matter to him are the four products he sells. Although coffee, tea, chocolate, and sandwiches are different products with different prices and so on, they all share similar characteristics. They are all products that the market seller sells.<\/p>\n
You can therefore start by creating a class of objects in Python that describes these products.<\/p>\n
Creating A Class<\/h2>\n
To create a class<\/strong> in Python, you can use the class<\/code> keyword. You can create a new Python file called market_stall.py<\/code> where you\u2019ll create your classes. If you choose a different file name, make sure you don\u2019t use any spaces in the file name:<\/p>\n<\/div>\n\n\n\n
class Product:<\/pre>\n\n\n\n
The convention is to use a capital letter for the name of a class. More generally, you should use upper camel case, such as MyInterestingClass<\/code>.<\/p>\n
When you create a class, you\u2019re creating your own data type, one that\u2019s relevant for the application you\u2019re writing. The class definition that you\u2019ll be writing in the following sections acts as a template or a blueprint to create objects that belong to this class of objects.<\/p>\n
You\u2019ll see how to create an object of type Product<\/code> soon, but first, we need to add a function definition within the class definition. A function that\u2019s a member of a class is called a method<\/strong>. Methods are functions, and therefore they behave in the same way as functions:<\/p>\n<\/div>\n\n\n\n
class Product:\n    def __init__(self):\n        self.name = \"Coffee\"\n        self.cost_price = 1.1\n        self.selling_price = 2.5\n        self.number_in_stock = 30<\/pre>\n\n\n\n
There\u2019s a lot to understand in this code. I\u2019ll explain all of the strange new additions in the following paragraphs.<\/p>\n
The __init__()<\/code> method<\/h3>\n
The __init__()<\/code> method is a special function, and it\u2019s often the first part of a class definition. This method tells the program how to initialise a Product<\/code> when you create one. When you create an object of type Product<\/code>, the initial state of this object will be determined based on what happens in the __init__()<\/code> method. Hint:<\/em> if you just start typing \u201cinit\u201d in your IDE, the underscores and the parameter self<\/code>, which you\u2019ll learn about soon, will autocomplete.<\/p>\n
Methods whose names start and end with double underscores have a special status and are often referred to as dunder methods<\/strong>. Dunder is a contraction of d<\/strong>ouble under<\/strong>score. Sometimes they\u2019re also called magic methods. However, there\u2019s nothing magical about them, so some prefer not to use that term.<\/p>\n
You\u2019ll have noticed another new term used in the __init__()<\/code> method: self<\/code>. I\u2019ll discuss self<\/code> shortly as you\u2019ll see it a lot in class definitions.<\/p>\n
Creating An Instance of A Class<\/h2>\n
When you defined the class in market_stall.py<\/code>, you\u2019ve created a template for making products, but you haven\u2019t created any products yet. Let\u2019s create an instance<\/strong> of the class Product<\/code> in the Python Console instead of in the script market_stall.py<\/code>.<\/p>\n
When you start a Console session, you\u2019re creating a new White Room, which is separate from the one created when you run the market_stall.py<\/code> script. Therefore, the Console\u2019s White Room doesn\u2019t know about the class Product<\/code> yet. However, you can import your script in the same way you\u2019ve imported other modules previously:<\/p>\n<\/div>\n\n\n\n
>>> import market_stall\n>>> market_stall\n<module 'market_stall' from '\/<path>\/market_stall.py'><\/pre>\n\n\n\n
When you import a module, you\u2019re importing the contents of a Python script. This script could be one written by someone else or one you\u2019ve written yourself. You can see that the name market_stall<\/code> in the Console session refers to the module, and it references the file. As with any module you import, you can now access anything from within this module. In this case, you can access the class Product<\/code>.<\/p>\n
You can create an instance of the class Product<\/code> as follows:<\/p>\n<\/div>\n\n\n\n
>>> market_stall.Product()\n<market_stall.Product object at 0x7f9178d61b20><\/pre>\n\n\n\n
You can create an instance of a class by using the class name followed by parentheses. The output doesn\u2019t tell you much except that you\u2019ve created an object of type Product<\/code> which is a part of the market_stall<\/code> module. The memory address is also displayed, but you won\u2019t need this.<\/p>\n
You can assign this instance of the class to a variable name:<\/p>\n<\/div>\n\n\n\n
>>> my_product = market_stall.Product()\n>>> my_product.name\n'Coffee'\n>>> my_product.selling_price\n2.5<\/pre>\n\n\n\n
The name my_product<\/code> now refers to the object you have created. When an instance of the class is created, the __init__()<\/code> method is called. This means that every Product<\/code> will always have a variable called name<\/code> attached to it, and another one called selling_price<\/code>. You can see the values of these instance variables displayed above. You can even access the other instance variables you have defined in the __init__()<\/code> method in the same way.<\/p>\n
Making the class more flexible<\/h4>\n
The problem with the code you have is that each product you create can only be coffee with the same cost price, selling price, and quantity in stock. You\u2019d like your class to be more general than this so that you can create other products as well.<\/p>\n
You can go back to market_stall.py<\/code> and make some changes:<\/p>\n<\/div>\n\n\n\n
# market_stall.py\n\nclass Product:\n    def __init__(self, name, cost_price, selling_price, number_in_stock):\n        self.name = name\n        self.cost_price = cost_price\n        self.selling_price = selling_price\n        self.number_in_stock = number_in_stock<\/pre>\n\n\n\n
Like any other function, __init__()<\/code> can have parameters defined in its signature. The mysterious self<\/code> was already there, but you\u2019ve now added more parameters.<\/p>\n
The arguments passed to the __init__()<\/code> method are then attached<\/em> to the instance. In the next section, we\u2019ll walk through what happens when you create an instance again, but this time you\u2019ll have to pass arguments when you create the instance.<\/p>\n
Creating a new file to test the class definition<\/h4>\n
Rather than carrying on in the Console, you can now create a second file. Let\u2019s call this second script market_seller_testing.py<\/code>. When dealing with object-oriented programming, it\u2019s common practice to define the classes in one file, or module, and then use these classes in other files:<\/p>\n<\/div>\n\n\n\n
# market_seller_testing.py\n\nfrom market_stall import Product\n\nfirst_prod = Product(\"Coffee\", 1.1, 2.5, 30)\nsecond_prod = Product(\"Chocolate\", 0.9, 1.75, 35)\n\nprint(first_prod.name)\nprint(second_prod.name)<\/pre>\n\n\n\n
I\u2019ve included the file name as a comment at the top of each code block since you\u2019ll be working on two separate files from now on in this Chapter.<\/p>\n
You\u2019ve also used the import<\/code> keyword differently from previous times. Instead of importing the whole module, you\u2019re now only importing one object from within that module. In this case, you\u2019re just bringing in the Product<\/code> class and not the entire module. You can now use the class name Product<\/code> without having to add market_stall<\/code> and a dot before it.<\/p>\n
You created two instances of the class Product<\/code>. The arguments you use within the parentheses are passed to the class\u2019s __init__()<\/code> method. The objects first_prod<\/code> and second_prod<\/code> are both of type Product<\/code>, and therefore they have been created using the same template. Both of them have instance variables called name<\/code>, cost_price<\/code>, selling_price<\/code>, and number_in_stock<\/code>. However, the values of these instance variables are different, as the output from the print()<\/code> lines show:<\/p>\n
Coffee\nChocolate\n<\/code><\/pre>\n
You can also confirm the data type of these two objects you have created:<\/p>\n<\/div>\n\n\n\n
# market_seller_testing.py\n\nfrom market_stall import Product\n\nfirst_prod = Product(\"Coffee\", 1.1, 2.5, 30)\nsecond_prod = Product(\"Chocolate\", 0.9, 1.75, 35)\n\nprint(type(first_prod))\nprint(type(second_prod))<\/pre>\n\n\n\n
The output now shows that both objects are of type Product<\/code>:<\/p>\n
<class 'market_stall.Product'>\n<class 'market_stall.Product'>\n<\/code><\/pre>\n
When you create a class you\u2019re creating a new data type, one that you have designed to suit your specific needs.<\/p>\n
Viewing two scripts side-by-side<\/h4>\n
A small practical note:<\/em> In most IDEs, you can split your window into multiple parts so that you can view two files side-by-side. Since you\u2019re defining your class in one file and testing it in a different file, this is a perfect time to explore some options in your IDE.<\/p>\n
If you\u2019re using PyCharm, you can look in the Window<\/em> menu and choose the Editor Tabs<\/em> option. You\u2019ll find the option to split your screen<\/a> there. You can also make sure that any sidebars on the left-hand side are closed so that your screen is split between the two files.<\/p>\n<\/div>\n\n\n
\n
\"Split<\/figure>\n<\/div>\n\n\n
If you\u2019re using other IDEs, you\u2019ll be able to find similar functionality, too.<\/p>\n
Understanding self<\/code><\/h2>\n
In the definition of the __init__()<\/code> method, you\u2019ve used the keyword self<\/code><\/strong> several times. Let\u2019s start by looking at its use inside the function definition first. Here are the four lines in this definition that all reference self<\/code>:<\/p>\n<\/div>\n\n\n\n
# ...\n        self.name = name\n        self.cost_price = cost_price\n        self.selling_price = selling_price\n        self.number_in_stock = number_in_stock<\/pre>\n\n\n\n
The keyword self<\/code> refers to the instance of the class that you\u2019ll create when you use the class. You read earlier that the class definition doesn\u2019t create any objects itself but serves as a blueprint for creating objects elsewhere in the code. The name self<\/code> refers to the future name of the variable that the object will have.<\/p>\n
For example, in market_seller_testing.py<\/code>, you created two variables named first_prod<\/code> and second_prod<\/code>. These variables each store a different instance of the class Product<\/code>. You can think of the term self<\/code> in the class definition as a placeholder for these names.<\/p>\n
Therefore, the above lines provide the instructions for the program to create four instance variables when it creates a new object. These lines are assignment statements, as shown by the =<\/code> operator. The variables you\u2019re creating are attached<\/em> to the instance. The dot between self<\/code> and the variable name shows this link.<\/p>\n
An instance variable is a variable that is attached to an instance of a class. So every instance of the class you create will have its own instance variables name<\/code>, cost_price<\/code>, selling_price<\/code>, and number_in_stock<\/code>.<\/p>\n
Creating the instance variables in the __init__()<\/code> method<\/h4>\n
The __init__()<\/code> method assigns values to the instance variables based on the arguments passed when creating the object. Recall that the values you place within parentheses when you create the instance of Product<\/code> are passed to the __init__()<\/code> method. The parameters name<\/code>, cost_price<\/code>, selling_price<\/code>, and number_in_stock<\/code> listed in the method\u2019s signature store the values passed when creating the instance.<\/p>\n
The parameter names and the instance variable names do not need to be the same name. Therefore, the following __init__()<\/code> method is identical to the one you\u2019ve written above:<\/p>\n<\/div>\n\n\n\n
# market_stall.py\n\nclass Product:\n    def __init__(self, product_name, cost, sell, n_stock):\n        self.name = product_name\n        self.cost_price = cost\n        self.selling_price = sell\n        self.number_in_stock = n_stock<\/pre>\n\n\n\n
The parameter names are only used to move information from the method call to the instance variables. Recall that the program calls the __init__()<\/code> method whenever you create an instance of the class.<\/p>\n
self<\/code> in the method signature<\/h4>\n
The other place you\u2019ve used self<\/code> is as the first parameter in the __init__()<\/code> signature. You may have noticed that your IDE probably auto-filled this for you when autocompleting __init__()<\/code>. If you\u2019re not making the most of autocompletion in your IDE, then you should do so!<\/p>\n
This parameter tells the function that its first argument is the object itself. Therefore, the method has access to the object it is acting on. You\u2019ll see this used again in the following section when you create other methods for this class.<\/p>\n
Adding Methods To The Class<\/h2>\n
So far, the Product<\/code> class assigns instance variables to each instance of the class. Each product you\u2019ll create using the class Product<\/code> will have a \u2018storage box\u2019 attached to it to store the product\u2019s name, another one to store the selling price, and so on.<\/p>\n
However, you can add more attributes to the class, and these are not limited just to data that can be stored in each object. You can also give the instances of the class the ability to do things as well. And as you know, \u201cdoing things\u201d is done by functions in Python:<\/p>\n<\/div>\n\n\n\n
# market_stall.py\n\nclass Product:\n    def __init__(self, name, cost_price, selling_price, number_in_stock):\n        self.name = name\n        self.cost_price = cost_price\n        self.selling_price = selling_price\n        self.number_in_stock = number_in_stock\n        \n    def decrease_stock(self, quantity):\n        self.number_in_stock -= quantity\n        \n    def change_cost_price(self, new_price):\n        self.cost_price = new_price\n        \n    def change_selling_price(self, new_price):\n        self.selling_price = new_price<\/pre>\n\n\n\n
In addition to the __init__()<\/code> method, you\u2019ve also defined three further methods. These functions are called methods as they belong to a class. Only objects of type Product<\/code> will have access to these methods.<\/p>\n
Using methods<\/h4>\n
Let\u2019s see how you can use these methods by going back to market_seller_testing.py<\/code>:<\/p>\n<\/div>\n\n\n\n
# market_seller_testing.py\n\nfrom market_stall import Product\n\nfirst_prod = Product(\"Coffee\", 1.1, 2.5, 30)\nsecond_prod = Product(\"Chocolate\", 0.9, 1.75, 35)\n\nprint(f\"{first_prod.name} | Number in stock: {first_prod.number_in_stock}\")\nprint(f\"{second_prod.name} | Number in stock: {second_prod.number_in_stock}\")\n\nfirst_prod.decrease_stock(7)\n\nprint()\nprint(f\"{first_prod.name} | Number in stock: {first_prod.number_in_stock}\")\nprint(f\"{second_prod.name} | Number in stock: {second_prod.number_in_stock}\")<\/pre>\n\n\n\n
In this version of the script, you\u2019re printing lines to show how many items there are in stock for each product you\u2019ve created. You then call the decrease_stock()<\/code> method for first_prod<\/code> with the argument 7<\/code>. When you print out the numbers in stock again, you\u2019ll see that the number of items in stock for first_prod<\/code>, which is coffee, has decreased by 7<\/code>. However, the number of items in stock for second_prod<\/code>, which is chocolate, remains unchanged since you didn\u2019t call the method for this object:<\/p>\n
Coffee | Number in stock: 30\nChocolate | Number in stock: 35\n\nCoffee | Number in stock: 23\nChocolate | Number in stock: 35\n<\/code><\/pre>\n
This simple example shows one of the benefits of object-oriented programming. Once you\u2019ve defined the methods in the class, it becomes straightforward to keep track of which data belong to which object. If you look back at the first and second attempts the market seller made at the beginning of this Chapter, where he used lists and dictionaries, you\u2019ll recall that things weren\u2019t so easy there.<\/p>\n
Each object of a certain class has access to methods that will only act on that object. These methods will only change the data linked to that object.<\/p>\n
Revisiting self<\/code><\/h4>\n
Each method you\u2019ve created has self<\/code> as the first parameter in the signature. You\u2019ll always call a method preceded by the object\u2019s name and a full stop, for example first_prod.decrease_stock()<\/code>. The object itself is passed as the first unseen argument of the method decrease_stock()<\/code>. Therefore the method call first_prod.decrease_stock(7)<\/code> has two arguments and not just one. The first argument is first_prod<\/code>, and the second is the integer 7<\/code>. However, you don\u2019t explicitly write the first argument as this is implied.<\/p>\n
You can confirm this with the following experiment in the Console (note, you should close your previous Console and restart a new one since market_stall.py<\/code> has changed):<\/p>\n<\/div>\n\n\n\n
>>> from market_stall import Product\n>>> test = Product(\"Coffee\", 1.1, 2.5, 30)\n>>> test.decrease_stock(4, 5)\nTraceback (most recent call last):\n  File \"<input>\", line 1, in <module>\nTypeError: decrease_stock() takes 2 positional arguments but 3 were given<\/pre>\n\n\n\n
You\u2019ve tried calling decrease_stock()<\/code> with the integers 4<\/code> and 5<\/code>. This is incorrect as this method only needs one integer. Therefore, the program raises an error. However, look at the last line of the error message very carefully. The message tells you that decrease_stock()<\/code> takes 2<\/code> positional arguments because the method has two parameters in its signature. These two parameters are self<\/code> and quantity<\/code>. The error message also says that you passed 3<\/code> arguments, even though you only put two numbers in the parentheses. The three arguments you passed are test<\/code>, 4<\/code>, and 5<\/code>.<\/p>\n
One more method<\/h4>\n
Let\u2019s add one more method to this class. In market_seller_testing.py<\/code>, you\u2019ve printed out a formatted string to show the user the number of items in stock for each product. Unless you enjoy typing, you had to copy and paste that line and change the variable name.<\/p>\n
However, this is something that an object of type Product<\/code> should be able to do. You can do this by adding a method to the class whose job is to print out this formatted string:<\/p>\n<\/div>\n\n\n\n
# market_stall.py\n\nclass Product:\n    def __init__(self, name, cost_price, selling_price, number_in_stock):\n        self.name = name\n        self.cost_price = cost_price\n        self.selling_price = selling_price\n        self.number_in_stock = number_in_stock\n\n    def decrease_stock(self, quantity):\n        self.number_in_stock -= quantity\n\n    def change_cost_price(self, new_price):\n        self.cost_price = new_price\n\n    def change_selling_price(self, new_price):\n        self.selling_price = new_price\n\n    def show_stock(self):\n        print(f\"{self.name} | Number in stock: {self.number_in_stock}\")<\/pre>\n\n\n\n
The method show_stock()<\/code> doesn\u2019t make any changes to the object. It merely prints out the formatted string. You can compare the print()<\/code> line in this method to the ones you wrote in market_seller_testing.py<\/code> earlier. In the method, you\u2019ve now replaced the variable name with the keyword self<\/code>, which is the placeholder for the name of the object.<\/p>\n
You can now also update market_seller_testing.py<\/code> to use this new method:<\/p>\n<\/div>\n\n\n\n
# market_seller_testing.py\n\nfrom market_stall import Product\n\nfirst_prod = Product(\"Coffee\", 1.1, 2.5, 30)\nsecond_prod = Product(\"Chocolate\", 0.9, 1.75, 35)\n\nfirst_prod.show_stock()\nsecond_prod.show_stock()\n\nfirst_prod.decrease_stock(7)\n\nprint()\nfirst_prod.show_stock()\nsecond_prod.show_stock()<\/pre>\n\n\n\n
You should spend some time experimenting with the methods you\u2019ve created, and you can even create one or two more!<\/p>\n
Storing Data And Doing Stuff With Data<\/h2>\n
At the beginning of this Chapter, I described object-oriented programming as a way of merging the storage of data with doing stuff with data into one structure. There are two types of attributes<\/strong> that an object of a certain class can have:<\/p>\n