Programs

Python Classes and Objects [With Examples]

OOP – short for Object-Oriented Programming – is a paradigm that relies on objects and classes to create functional programs. OOPs work on the modularity of code, and classes and objects help in writing reusable, simple pieces of code that can be used to create larger software features and modules. C++, Java, and Python are the three most commonly used Object-Oriented Programming languages. However, when it comes to today’s use cases – the likes of Data Science and Statistical Analysis – Python trumps the other two. 

This is no surprise as Data Scientists across the globe swear by the capabilities of the Python programming language. If you’re planning to start a career in Data Science and are looking to master Python – knowing about classes and objects should be your first priority. 

Through this article, we’ll help you understand all the nuances behind objects and classes in Python, along with how you can get started with creating your own classes and working with them. 

Classes in Python

A class in Python is a user-defined prototype using which objects are created. Put simply, a class is a method for bundling data and functionality together. The two keywords are important to note. Data means any variables instantiated or defined, whereas functionality means any operation that can be performed on that data. Together with data and functionality bundled under one package, we get classes. 

To understand the need for creating a class, consider the following simple example. Suppose, you wish to keep track of cats in your neighbourhood having different characteristics like age, breed, colour, weight, etc. You can use a list and track elements in a 1:1 manner, i.e., you could track the breed to the age, or age to the weight using a list. What if there are supposed to be 100 different cats? What if there are more properties to be added? In such a scenario, using lists tends to be unorganized and messy. 

That is precisely where classes come in! 

Classes help you create a user-defined data structure that has its own data members (variables) and member functions. You can access these variables and methods simply by creating an object for the class (we’ll talk more about it later). So, in a sense, classes are just like a blueprint for an object. 

Further, creating classes automatically creates a new type of objects – which allows you to further create more objects of that same type. Each class instance can have attributes attached to it in order to maintain its state. Class instances can themselves have methods (as defined by their class) for modifying the state. 

Some points on Python class:  

  • Classes are created by using the keyword class.
  • Attributes are the variables that are specific to the class you created. 
  • These attributes are always public in nature and can be accessed by using the dot operator after the class name. For example, ClassName.AttributeName will fetch you the particular attribute detail of that particular class. 

Syntax for defining a class: 

class ClassName:

    # Statement-1

    .

    .

    .

    # Statement-N

For example: 

class cat:

    pass

In the above example, the class keyword indicates that you are creating a class followed by the name of the class (Cat in this case). The role of this class has not been defined yet. 

Advantages of using Classes in Python

  • Classes help you keep all the different types of data properly organized in one place. In this way, you’re keeping the code clean and modular, improving your code’s readability. 
  • Using classes allows you to take the benefit of another OOP paradigm – called Inheritance. This is when a class inherits the properties of another class. 
  • Classes allow you to override any standard operators.
  • Classes make your code reusable which makes your program a lot more efficient. 

Objects in Python

An object is simply an instance of any class that you’ve defined. The moment you create a class, an automatic instance is already created. Thus, like in the example, the Cat class automatically instantiates an object like an actual cat – of Persian breed and 3 years of age. You can have many different instances of cats having different properties, but for it to make sense – you’ll need a class as your guide. Otherwise, you’ll end up feeling lost, not knowing what information is needed. 

An object is broadly characterized by three things: 

  • State: This refers to the various attributes of any object and the various properties it can show. 
  • Behaviour: This basically denotes the methods of that object. It also reflects how this particular object interacts with or responds to other objects. 
  • Identity: Identity is the unique name of the object using which it can be invoked as and when required. 

1. Declaring Objects

Declaring Objects is also known as instantiating a class because as soon as you define a class, a default object is created in itself (as we saw earlier) – which is the instance of that class. Likewise, each time you create an object, you’re essentially creating a new instance of your class. 

In terms of the three things (state, behaviour, identity) we mentioned earlier, all the instances (objects) share behaviour and state, but their identities are different. One single class can have any number of objects, as required by the programmer.

Check out the example below. Here’s a program that explains how to instantiate classes. 

class cat:

    # A simple class

    # attribute

    attr1 = “feline”

    attr2 = “cat”

    # A sample method 

    def fun(self):

        print(“I’m a”, self.attr1)

        print(“I’m a”, self.attr2)

# Driver code

# Object instantiation

Tom = cat()

# Accessing class attributes

# and method through objects

print(Tom.attr1)

Tom.fun();

The output of this simple program will be as follows:

Feline

I’m a feline

I’m a cat

As you can see, we first created a class called cat and then instantiated an object with the name ‘Tom.’ The three outputs we got were as follows: 

  • Feline – this was the result of the statement print(Tom.attr1). Since Tom is an object of the Cat class and attr1 has been set as Feline, this function returns the output Feline. 
  • I’m a feline – Tom.fun(); uses the object called Tom to invoke a function in the cat class, known as ‘fun’. The Tom object brings with it the attributes to the function, and therefore the function outputs the following two sentences – “I’m a feline”.
  • I’m a cat – same reason as stated above. 

Now that you have an understanding of how classes and objects work in Python, let’s look at some essential methods. 

2. The Self Method

All the methods defined in any class are required to have an extra first parameter in the function definition. This parameter is not assigned any value by the programmer. However, when the method is called, Python provides it a value. 

As a result, if you define a function with no arguments, it still technically has one argument. This is called ‘self’ in Python. To understand this better, you can revise your concepts of Pointers in C++ or reference them in Java. The self method works in essentially the same manner. 

To understand this better – when we call any method of an object, for example:

myObject.myMethod(arg1, arg2), Python automatically converts it into myClass.myMethod(myObject, arg1, arg2). 

So you see, the object itself becomes the first argument of the method. This is what the self in Python is about. 

3. The __init__ method

This method is similar to constructors in Java or C++. Like constructors, the init method is used to initialize an object’s state. This contains a collection of instructions (statements) that are executed at the time of object creation. When an object is instantiated for a class, the init method will automatically run the methods initialized by you. 

Here’s a code piece of code to explain that better: 

# A Sample class with init method

class Person:

  

    # init method or constructor 

    def __init__(self, name):

        self.name = name

 

    # Sample Method 

    def say_hi(self):

        print(‘Hello, my name is’, self.name)

 

p = Person(“Sam”)

p.say_hi()

Output: 

Hello, my name is Sam

Class and Instance Variables

Instance variables are unique to each instance, whereas class variables are for methods and attributes shared by all the instances of a class. Consequently, instance variables are basically variables whose value is assigned inside a constructor or a method with self. On the other hand, class variables are those whose values are assigned within a class. 

Go through the following code to understand how instance variables are defined using a constructor (init method): 

class cat:

    # Class Variable

    animal = ‘cat’           

    # The init method or constructor

    def __init__(self, breed, color):

        # Instance Variable    

        self.breed = breed

        self.color = color       

# Objects of Dog class

Tom = cat(“Persian”, “black”)

Snowy = cat(“Indie”, “white”)

print(“Tom details:’)  

print(‘Tom is a’, Tom.animal)

print(‘Breed: ‘, Tom.breed)

print(‘Color: ‘, Tom.color)

print(‘\nSnowy details:’)  

print(“Snowy is a’, Snowy.animal)

print(‘Breed: ‘, Snowy.breed)

print(‘Color: ‘, Snowy.color)

If you follow the above code line-by-line, here’s the output you’ll receive: 

Output: 

Tom details:

Tom is a cat

Breed:  Persian

Color:  black

Snowy details:

Snowy is a cat

Breed:  Indie

Color:  white

In Conclusion

Python is a comparatively easier programming language, particularly for beginners. Once you’ve mastered the basics of it, you’ll be ready to work with various Python libraries and solve data-specific problems. However, remember that while the journey begins from understanding classes and objects, you must also learn how to work with different objects, classes, and their nuances. 

We hope this article helped clarify your doubts about classes and objects in Python. If you have any questions, please drop us a comment below – we’ll get back to you real soon!

If you’re looking for a career change and are seeking professional help – upGrad is here for you.  Check out our Executive PG Program in Data Science offered in collaboration with IIIT-B. Get acquainted with 14+ programming languages and tools (including Python) while also gaining access to more than 30 industry-relevant projects. Students from any stream can enroll in this program, provided they scored a minimum of 50% in their bachelor’s.

We have a solid 85+ countries learner base, 40,000+ paid learners globally, and 500,000+ happy working professionals. Our 360-degree career assistance, combined with the exposure of studying and brainstorming with global students, allows you to make the most of your learning experience. 

What are classes and objects in Python?

A class is a template or a blueprint that binds the properties and functions of an entity. In Python, the keyword class is used to define a class. All the entities or objects having similar attributes can be put under a single class and can be accessed by the member functions.
An object is an instance of a class. Once a class is created, the objects get all the information of that class. It is just like a copy of the respected class with the actual values. An object is categorized by three factors:
a. State
b. Behaviour
c. Identity

Which programming paradigm does Python follow?

There are four major distinguishable paradigms followed by Python- object-oriented, procedural, functional, and imperative. Python strongly supports object-oriented concepts; however, it is not a purely object-oriented programming language.
The reason for supporting various programming paradigms is that it is noticeably influenced by some scripting like CoffeeScript and object-oriented programming languages like Ruby. It also combines with languages like R to increase efficiency and computational power.
Being a multi-paradigm language, Python is believed to be one of the most versatile languages. It is widely used for development, data analysis, web scraping, and automation.

What are access modifiers in Python?

Similar to other object-oriented programming languages, a class in Python also has three access modifiers:
a. Public Access Modifier: The class members specified as the public can be directly accessed by any function i.e., by member functions as well as non-member functions. If no access specifier is specified then all the class members are considered to be public members by default by the compiler.
b. Private Access Modifier: These class members are hidden from other class members. They can only be accessed by the member functions of the class in which they are defined.
c. Protected Access Modifier: The class members that are specified as protected can only be accessed by the member functions of the same class and will throw an error if tried to access outside the class. The only major difference between the private and protected access specifier is that protected members can be inherited while the private members cannot be inherited.

Prepare for a Career of the Future

0 replies on “Python Classes and Objects [With Examples]”

Accelerate Your Career with upGrad

Our Best Data Science Courses

×