Instance & Class Variables

NITIN GUPTA

 When working with objects in Python, we have to work with two types of variables, i.e., instance variables and class variables. But what do these types of variables mean, and how do they work? OOP allows the variables to be used at the class level or the instance level. In this tutorial, we will learn about the two different kinds of variables associated with a class and the difference between them. The variables are:

  • Instance variable
  • Class variable

Instance variable:

"Instance variables are the variables for which the value of the variable is different for every instance."

We can also say that the value is different for every object that we create. Let us dive into some in-depth explanations. When we create a class, we define a few variables along with it. For example, we have created a class of Students, and we have defined a variable age. All the students cannot have the same age in a class, so we have assigned the variable an average age of 16. Now, whenever we use an object to print the value of age, it will show 16. We can change the value of age, but it will create a new instance variable for the specific object that we are updating it for, hence defining the value to it.

The code for changing age for a particular object will be something like this:

Std1.age = 18

Class variable:

"Class attributes are owned by the class directly, which means that they are not tied to any object or instance."

 Same as in the above example, if we want to change the age for every instance from 16 to 17, then we can do it by using the class variable, which in this case is Student. 

"It is worth noting that updating the value of the class variable will not change it for the instance variables of the objects, such as in the case above."

The code for changing age using a class variable will be something like this:

Students.age = 18

The following are the notable differences between Class (static) and instance variables.

Following are the differences between Class and instance variables.

Instance variables

Class variables

When an object is created with the use of the new keyword, instance variables are created. They are destroyed when the object is destroyed.

When the program starts, static variables are created and destroyed when the program stops.

Instance variables can be accessed by calling the variable name inside the class. ObjectReference.VariableName.

 Static variables can be accessed by calling using a class name. ClassName.VariableName.

Every instance of the class has its own copy of that variable. Changes made to the variable don't affect the other instances of that class.

There is only one copy of that variable that is shared with all instances of the class. If changes are made to that variable, all other instances will be affected.

The __dict__ attribute

Every object in Python has an attribute that is denoted by __dict__. It maps the attribute name to its value. This dictionary stores all the attributes defined for the object itself. Following is the syntax of using __dict__:

object.__dict__

A quick review:

Instance variables are created only for a specific object. The object can change, create, or update only its instance variables. While in the case of class variables, the variables and values we create or define are set as default for all the objects. The objects cannot change the class value or variable by updating it using object_name.variableName.However, it can change the values of their particular instance variables. Making use of class and instance variables can ensure that our code adheres to the DRY (don't repeat yourself) principle to reduce repetition within code.

Code as described/written in the video

class Employee:
    no_of_leaves = 8
    pass

harry = Employee()
rohan = Employee()

harry.name = "Harry"
harry.salary = 455
harry.role = "Instructor"

rohan.name = "Rohan"
rohan.salary = 4554
rohan.role = "Student"

print(Employee.no_of_leaves)
print(Employee.__dict__)
Employee.no_of_leaves = 9
print(Employee.__dict__)
print(Employee.no_of_leaves)

Comments

Post a Comment

Popular posts from this blog

HOW IMPORT WORKS IN PYTHON?

NITIN GUPTA
  How does the import keyword work? When we write a certain module name along with the  import  keyword, it will start searching for a file with that name having an extension  .py . After finding the file, it will import it into our program, which means that it will permit our program to use the functions of the certain module we imported. We can import a module named  “sys”  to see the path that our import statement takes while searching for a module. import sys print ( sys . path ) Copy sys.path  prints out a list of directories. When we tell Python to import something, then it looks in each of the listed locations in order.  A common mistake that most of the beginners do and also the primary reason for making this tutorial is, why can’t we name our file, the same as the name of a module. The reason is associated with the path. When we give our file a name same as the name of a module, then instead of importing the original module, the system ...
Read more

Exercise 5: Health Management System

NITIN GUPTA
  Exercise#5 The task is to create a " Health Management System ." Suppose you are a fitness trainer and nutritionist. You have to deal with three clients, i.e., (Harry, Rohan, Hammad). For each client, you have to design their exercise and diet plan. Instructions: Create a food log file for each client Create an exercise log file for each client. Ask the user whether they want to log or retrieve client data. Write a function that takes the user input of the client's name. After the client's name is entered, it will display a message as "What you want to log- Diet or Exercise". Use function def getdate ( ) : import datetime return datetime . datetime . now ( ) Copy The purpose of this function is to give time with every record of food or exercise added in the file. Write a function to retrieve exercise or food file records for any client. You are advised to participate in solving this problem. This task helps you to become a good pr...
Read more

*args and **kwargs In Python

NITIN GUPTA
  Before discussing *args and **kwargs, we should have a basic knowledge about types of arguments. In Python programming, there are two types of arguments that can be passed in a function. positional arguments keyword arguments Positional arguments  are the one in which an order has to be followed while passing arguments. We have been dealing with them until now. We know how normal functions work with positional arguments, so now we will directly start exploring keyword arguments. But to understand them, we have to know about asterisk or more commonly known in Perl 6 and ruby as a splat operator.  Asterisk is used in python as a mathematical symbol for multiplication, but in case of arguments, it refers to unpacking. The unpacking could be for a list, tuple, or a dictionary. We will discover more about it by defining *args and **kwargs. *args: args is a short form used for arguments. It is used to unpack an argument. In the case of *args, the argument could be a list or t...
Read more