Understanding Classes in Python: Everything About Classes and Attributes

1. What is a Class in Python?

In Python, a class is a blueprint or a template for creating objects that have similar characteristics and behaviors. It provides a structure for organizing and grouping data and functions that operate on that data. In this tutorial, we'll go over the basics of defining and using classes in Python.

1.1. Defining a Class

To define a class in Python, you use the class keyword, followed by the name of the class. Here is a simple example:

python
class Person:
    pass

This creates a new class called Person that doesn't do anything. The pass statement is used as a placeholder for future code.

2. Class Attributes

A class can have attributes that are shared by all instances of the class. To define a class attribute, you simply create a variable inside the class:

python
class Person:
    species = 'human'

In this case, species is a class attribute that is shared by all instances of the Person class. You can access this attribute using the class name:

python
print(Person.species) # Output: 'human'

3. Class Methods

A class can also have methods, which are functions that are associated with the class. These methods can access and modify the class attributes and can be used to perform operations on instances of the class. To define a class method, you use the def keyword inside the class:

python
class Person:
    species = 'human'
    
    def greet(self):
        print('Hello, I am a', self.species)

In this example, greet() is a class method that takes one parameter (self), which refers to the instance of the class. The method simply prints a greeting that includes the species the attribute of the class.

To use the class method, you create an instance of the class and call the method on that instance:

python
person = Person()
person.greet() # Output: 'Hello, I am a human'

4. Instance Attributes

In addition to class attributes, each instance of a class can have its own attributes that are specific to that instance. To define an instance attribute, you create a variable inside the __init__() method of the class:

python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def introduce(self):
        print('My name is', self.name, 'and I am', self.age, 'years old.')

In this example, the __init__() the method is used to initialize the name and age attributes of the instance. These attributes are specific to each instance of the Person class. The introduce() the method is used to print out the name and age of the instance.

To create an instance of the class, you simply call the class name with any required parameters:

python
person = Person('Alice', 25)
person.introduce() # Output: 'My name is Alice and I am 25 years old.'

5. Private Attributes

Private attributes are attributes that are intended to be used only within the class. They are prefixed with double underscores __ to make them private. Private attributes can only be accessed within the class using the same name or through instance methods defined within the class. They cannot be accessed directly from outside the class or even from subclasses.

Here's an example class that demonstrates private attributes:

python
class MyClass:
    def __init__(self, public_attribute, private_attribute):
        self.public_attribute = public_attribute
        self.__private_attribute = private_attribute
    
    def get_private_attribute(self):
        return self.__private_attribute
    
    def set_private_attribute(self, value):
        self.__private_attribute = value
    
    def print_attributes(self):
        print(f'Public attribute: {self.public_attribute}')
        print(f'Private attribute: {self.__private_attribute}')

In this example, we define a class MyClass with a public attribute public_attribute and a private attribute __private_attribute. We also define instance methods get_private_attribute() and set_private_attribute() to get and set the value of the private attribute, respectively. The method print_attributes() is defined to print both the public and private attributes.

python
obj = MyClass('public', 'private')
print(obj.public_attribute)             # Output: public

# This will raise an AttributeError because the attribute is private.
print(obj.__private_attribute)

print(obj.get_private_attribute())      # Output: private

obj.set_private_attribute('new value')
print(obj.get_private_attribute())      # Output: new value

obj.print_attributes()
# Output: Public attribute: public
#         Private attribute: new value

In this example, we can access the public attribute public_attribute directly using the instance name. However, we cannot access the private attribute __private_attribute directly from outside the class. We can only access it using the instance methods get_private_attribute() and set_private_attribute(). When we call the print_attributes() method, we can see that both the public and private attributes are printed.

Note that although private attributes cannot be accessed directly from outside the class, they can still be accessed using the _ClassName__private_attribute syntax. However, this is considered bad practice and should be avoided.

6. Example Class that demonstrates each type of attribute:

python
class MyClass:
    class_attribute = 'class attribute'
    
    def __init__(self, instance_attribute):
        self.instance_attribute = instance_attribute
    
    def instance_method(self):
        print('This is an instance method.')
    
    @classmethod
    def class_method(cls):
        print('This is a class method.')
    
    @staticmethod
    def static_method():
        print('This is a static method.')

In this example, we define a class MyClass with a class attribute class_attribute, an instance attribute instance_attribute, an instance method instance_method(), a class method class_method(), and a static method static_method(). Here's how we can access each of these attributes:

python
print(MyClass.class_attribute)     # Output: class attribute

obj = MyClass('instance attribute')
print(obj.instance_attribute)      # Output: instance attribute

obj.instance_method()             # Output: This is an instance method.
MyClass.class_method()            # Output: This is a class method.
MyClass.static_method()           # Output: This is a static method.

In this example, class_attribute is a class attribute that is shared by all instances of the class. instance_attribute is an instance attribute that is specific to each instance of the class. instance_method() is an instance method that can only be called on instances of the class. class_method() is a class method that can be called on the class itself, and static_method() is a static method that can also be called on the class itself.


2. Types of Classes in Python

In Python, there are several types of classes that you can define, depending on your requirements. Here are the most common types of classes in Python:

  1. Simple Class:

A simple class is the most basic type of class in Python. It defines attributes and methods, which can be used to represent an object. Here's an example of a simple class:

python
class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed
        
    def bark(self):
        print(f'{self.name} barks!')

In this example, we define a Dog class with two attributes, name and breed, and one method, bark(). The __init__() method is used to initialize the name and breed attributes with the values passed as arguments. The bark() method simply prints a message indicating that the dog is barking.


  1. Abstract Class:

An abstract class is a class that cannot be instantiated directly but can be used as a base class for other classes. It defines abstract methods that must be implemented in any concrete subclass. Here's an example of an abstract class:

python
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass
        
class Dog(Animal):
    def make_sound(self):
        print('Woof!')

In this example, we define an abstract class Animal that has one abstract method, make_sound(). The @abstractmethod decorator is used to indicating that this method must be implemented in any concrete subclass. We define a concrete subclass Dog that implements the make_sound() method by printing 'Woof!' to the console.


  1. Concrete Class:

A concrete class is a class that can be instantiated and used directly. It doesn't have any abstract methods that need to be implemented in any subclass. Here's an example of a concrete class:

python
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        
    def start_engine(self):
        print(f'{self.make} {self.model} ({self.year}) engine started!')

In this example, we define a Car class with three attributes, make, model, and year, and one method, start_engine(). The __init__() method is used to initialize the attributes with the values passed as arguments. The start_engine() method simply prints a message indicating that the car's engine has been started.


  1. Inherited Class:

An inherited class is a class that inherits attributes and methods from a parent class. It can add new attributes and methods, or override existing ones. Here's an example of an inherited class:

python
class Animal:
    def __init__(self, name):
        self.name = name
        
    def make_sound(self):
        print('Animal makes sound!')
        
class Dog(Animal):
    def make_sound(self):
        print('Woof!')

In this example, we define a Animal class with one attribute, name, and one method, make_sound(). We define a Dog class that inherits from Animal and overrides the make_sound() method with its own implementation. When make_sound() is called on an instance of Dog, it prints 'Woof!' to the console.


  1. Mixin Class:

A mixin class is a class that provides specific functionality that can be added to other classes. It doesn't have its own instance attributes but defines methods that can be used by other classes. Here's an example of a mixin class:


python
class FlyMixin:
    def fly(self):
        print(f'{self.__class__.__name__} flies!')
        
class Bird(FlyMixin):
    def __init__(self, name):
        self.name = name
        
class Plane(FlyMixin):
    def __init__(self, model):
        self.model = model

In this example, we define a FlyMixin the class that has one method, fly(), which simply prints a message indicating that the object is flying. We define two classes, Bird and Plane, that inherit from FlyMixin and can use the fly() method. The Bird the class has an additional attribute, name, while the Plane the class has an additional attribute, model.


  1. Metaclass:

A metaclass is a class that defines the behavior of other classes. It's used to customize the behavior of class creation and class instances. Here's an example of a metaclass:

python
class MyMeta(type):
    def __new__(cls, name, bases, attrs):
        attrs['class_name'] = name
        return super().__new__(cls, name, bases, attrs)
        
class MyClass(metaclass=MyMeta):
    pass

In this example, we define a metaclass MyMeta that has a __new__() method. This method is called when a new class is created, and it adds a new attribute, class_name, to the class. We define a MyClass class that uses MyMeta as its metaclass, which means that MyMeta's __new__() method is called when MyClass is created. When we create an instance of MyClass, it has a class_name attribute that is set to 'MyClass'.


  1. Singleton Class:

A singleton class is a class that allows only one instance to be created. This is useful when you want to ensure that there's only one instance of a class in your program. Here's an example of a singleton class:

python
class Singleton:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

In this example, we define a Singleton class that has a private class attribute _instance, which is initially set to None. The __new__() method is used to create a new instance of the class if _instance is None, or return the existing instance if it's not. When we create multiple instances of Singleton, we always get the same instance.


  1. Data Class:

A data class is a class that is designed primarily to store data. It automatically generates special methods such as __init__(), __repr__(), __eq__(), and __hash__(). Here's an example of a data class:

python
from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
    email: str

In this example, we define a Person class using the @dataclass decorator. The class has three attributes, name, age, and email, which are automatically initialized by the __init__() method generated by dataclass. The __repr__(), __eq__(), and __hash__() methods are also automatically generated. We can create instances of Person and access its attributes directly, like this:

python
person = Person('John', 30, '[email protected]')
print(person.name)     # Output: John
print(person.age)      # Output: 30
print(person.email)    # Output: [email protected]

Conclusion

In this tutorial, we've covered the basics of defining and using classes in Python. A class is a blueprint or a template for creating objects that have similar characteristics and behaviors. It provides a structure for organizing and grouping data and functions that operate on that data. We've looked at defining class attributes, class methods, instance attributes, and how to create instances of a class. With this knowledge, you can start building more complex programs using classes and objects.


Author
Vaneesh Behl
Passionately writing and working in Tech Space for more than a decade.

Comments

Post a Comment

Popular posts from this blog

What Role Graphic Design Services Play in Marketing

Image
Graphic design plays an essential part in today's marketing landscape and can provide an advantage for businesses. If you believe that graphic design is about images or drawings, then you're not right. Instead, it's about visuals proficient in solving problems using images. The vast majority of digital experts widely accept it as being one of the most important aspects of digital marketing because it helps marketers increase brand recognition and affect the decision-making process for their clients. In general, it is a representation of typography, symbols, colours, images, and symbols that contribute to the overall aesthetics of the communicated message. It is based on certain rules, trends, and concepts derived from a target audience's psychology studies. Get your work done by professional graphic design services 2022 .  Improve User Experience By in-Corporating Graphics In everything from brand identity to marketing via digital, any business can use graphic designs t
Read more

Python Behave Tutorial: A Comprehensive Guide to Behavior-Driven Development (BDD)

Image
In this tutorial, we'll explain each and every aspect of Behavior Driven Development. This BDD Python tutorial will help you create and design your automation tests and framework. Table of Content 1. What is BDD? 2. What is Gherkin Language in BDD? 3. What is Behave in Python? 4. Installing and Setup Behave 5. Project Structure for Behave Python (BDD) 6. Feature Files, Step Functions and Other Files in Behave Feature File Step Functions Step Parameters Passing String Param from Feature File Passing Integer Param from Feature File environment.py file behave.ini file 7. Run Feature files in Behave Run a single feature file Run multiple feature files Generate JUNIT xml reports with behave Run feature files with Python suite file Upcoming Tutorials: 8. API Automation Testing with BDD Python (Behave) 9. Selenium Automation with BDD Python (Behave) 1. What is BDD? BDD stands for Behavior Driven Development. BDD is an agile process of development. It encourages non-technical or business t
Read more

Top 10 Highly Paid Indian CEOs in the USA

Image
Top Indian CEOs in the USA Indian Americans have been making significant contributions to the US economy for decades. Many Indian-origin executives have reached the pinnacle of success in American corporations and hold some of the highest-paid positions in the country. In this post, we will take a look at the top 10 highly paid Indian-origin CEOs in the USA, their history, academics, salary, and net worth. 1. Sunder Pichai   Salary US$ 199.7 million Sundar Pichai is the CEO of Google and Alphabet Inc. Born in Tamil Nadu, India, Pichai grew up in a middle-class family and earned a Bachelor’s degree in Metallurgical Engineering from the Indian Institute of Technology in Kharagpur. He went on to earn a Master’s degree in Material Sciences and Engineering from Stanford University and an MBA from the Wharton School of the University of Pennsylvania. Pichai joined Google in 2004 and rose through the ranks to become CEO in 2015. His annual salary in 2021 was $2 million, and his net wort
Read more

Testing a Web Page/Website: Best Practices for Quality Assurance and Improved User Experience

Image
Testing a web page is an essential aspect of ensuring that it performs optimally and provides a seamless user experience. Testing involves a series of activities that are aimed at identifying and fixing issues with the web page, ensuring that it is accessible, responsive, and user-friendly. This post will discuss the various aspects of testing a web page, including the types of testing, the tools and techniques used, and the best practices for testing a web page. Table of Contents Types of Testing for Web Pages/ Website, Example, Checklist and Tools Functional Testing Perfomrance Testing Compatiblity Testing Usability Testing Security Testing Content Testing Accessibility Testing UI Testing Demo Websites for Practising Web Testing Best Practices for Testing Webpage / Website Conclusion Types of Testing for Web Pages/WebSite: There are several types of testing that can be performed on a web page. Some of the most common types of testing include: 1. Functional Testing This type of testi
Read more

How to Solve Easily the Reader-Writer Locks in Golang

Image
Reader-writer locks are one of the most intriguing topics in Golang. Golang web app development requires extensive use of goroutines and channels, which support concurrency. And this is where locks, or as we will learn reader-writer locks come in handy.  What is the Concept of Locks in Golang? The notion of locks is not only restricted to Golang, but it can be applied in a plethora of  ing languages. Locks, which prevent access to sensitive data, may cause additional overheads in complex applications. Then it has to be optimized by developers. Reader-writer locks are one of the most popular techniques to optimize it. Developers who are new to the concept of locks use Golang to comprehend the idea. This is because Golang has a great reader-writer lock implementation and concurrency support.  What is the Requirement of Reader-Writer Locks? As long as no one modifies the shared data while it is being read, several threads can access it concurrently. You should know that reader-writer lo
Read more

17 Best Demo Websites for Automation Testing Practice

Image
We need demo websites for various purposes, like learning new tools and for automation testing practice. In this post, we cherry-picked some of the best websites to practice Selenium automation testing. This set of demo websites would help you to enhance your automation skills.  This post can help various people like,  Automation Testing learners, Experienced professionals, and even Automation Testing tutors/teachers. They all can benefit from these demo websites. Table of Contents 1. Techlistic Automation Practice Form 2. Amazon like Demo E-Commerce Website 3. Make My Trip like Travel Portal 4. Demo Automation Practice Web Table 5. Google.com 6. Demo Website for Handling Alerts 7. Way2Automation Demo 8. NewTours DemoAUT 9. The Demo Site 10. DemoQA 11. Para Bank 12. Orange HRM 13. Sauce Labs Demo E-Commerce Site 14. Demo Bank Demo Websites for API Automation Testing Practice 15. Restful Booker 16. Pet Store 17. Demo REST API Best Demo Websites for Automation Practice Let's take
Read more

Automating Native Mobile Apps with Appium Commands

Image
  4. Automating Native Mobile Apps with Appium Now that we have set up the environment for Appium, we can move on to the actual testing process. In this section, we will create a basic Appium test that interacts with a mobile application. 4.1 Appium Commands for Interacting with Mobile Elements (Taps, Swipes, Inputs, etc.) In this section of the tutorial, we will explore the commands and methods available in Appium for interacting with mobile elements such as taps, swipes, inputs, and more. These commands are essential for automating interactions with mobile apps during testing. We'll cover the commonly used commands and their usage in Appium using the Java client. Locating Mobile Elements: i. Use the findElement(By locator) method to locate a single element based on a specified locator strategy (e.g., ID, XPath, class name). ii. Use the findElements(By locator) method to locate multiple elements based on the same locator strategy. Example : java Copy code MobileElement element
Read more

14 Best Selenium Practice Exercises for Automation Practice

Image
  This page contains the list of Selenium Program exercises for automation practice. Your skills will definitely get a boost after solving these Selenium Practice Assignments. In these assignments, you will find the Sample Applications for Automation Testing . These Practice Assignments are designed in such a way that learners can enhance their automation skills. They also include multiple Sample Test Cases for Selenium along with step-by-step description which needs to be automated.  Reference links to  Selenium WebDriver Commands  for solutions are provided in the assignments. 10 Best Selenium Practice Exercises for Automation Practice Automate Amazon-like e-Comm Website with Selenium WebDriver In this self-learning project assignment, we'll automate all the major e-commerce website features with Selenium and Java. We'll automate Sign-up and login, search products, and purchase products for Amazon an e-commerce website. Automate GoDaddy.com Website features with Selenium WebD
Read more

Top 51 Most Important Selenium WebDriver Interview Questions

Image
This Selenium Interview questions post will definitely help you prepare for a Selenium automation interview and brush up your Selenium skills easily. You can find Selenium interview questions and answers and also Selenium Java interview questions from Experienced to Beginners in this post. Selenium interview questions are divided into different topics for the sake of ease. Table of Contents 1. Selenium Basic Interview Questions 2. Actions Class Interview Questions 3. Selenium Locators Interview Questions 4. Windows and Frame Handling Interview Questions 5. Advanced Selenium Interview Questions 6. Selenium Automation Framework Questions 7. Java OOPS Interview Questions 8. Top 21 Selenium TestNG Interview Questions 9. Expert Tips to avoid Interview Blunders that can cost you the JOB! 10. Top 10 Interview Preparation Websites 11. Top Websites to Boost Your Career by Enhancing Skills 1. Selenium Basic Interview Questions Q1 - What is the syntax to launch the browser in Selenium WebDr
Read more

Complete Guide to Software Testing Levels: From Unit to End-to-End Testing

Image
Testing is an essential phase in software development, and it is essential to ensure that the software application or product functions as expected, meet the requirements and satisfies the user's needs. Testing is conducted at different levels of software development to detect defects, errors, and inconsistencies in the software. These levels of testing are commonly referred to as testing levels, and each level of testing has its purpose, scope, and objective. In this article, we will discuss the different levels of testing and their specific characteristics, along with detailed examples. Table of Contents Unit Testing Smoke Testing Sanity Testing Integration Testing System Testing Regression Testing Acceptance Testing Alpha Testing Beta Testing End-to-End Testing 1. Unit Testing Unit testing is a software testing technique in which individual units or components of the software application are tested in isolation to ensure that each component functions correctly and meets the spec
Read more