Python Object Oriented

The python is an Object-oriented programming language. This means there exists a concept called 'class' that lets the programmer structure the codes of software in a fashioned way. Because of the use of classes and objects, the programming became easy to understand and code.

Defining Class and Object

A class is a technique to group functions and data members and put them in a container so that they can be accessed later by using a dot (.) operator. Objects are the basic runtime entities of object-oriented programming. It defines the instance of a class. Objects get their variables and functions from classes, and the class we will be creating are the templates made to create the object.

Object-Oriented Terminologies

• class: Classes are a user-defined data type that is used to encapsulate data and associated functions together. It also helps in binding data together into a single unit.
• Data Member: A variable or memory location name that holds value to does a specific task within a program.
• Member Function: They are the functions, usually a block of a code snippet that is written to re-use it.
• Instance variable: A variable that is defined inside a method of a class.
• Function Overloading: This technique is used to assign multiple tasks to a single function, and the tasks are performed based on the number of arguments or the type of argument the function has.
• Operator Overloading: It is the technique of assigning multiple functions/tasks to a particular operator.
• Inheritance: It is the process of acquiring the properties of one class to another, i.e., one class can acquire the properties of another.
• Instantiation: It is the technique of creating an instance of a class.

Program for Class in Python

Example:

class karl :
    varabl = 'Hello'

def function(self) :
    print ("This is a message Hello")

Another program to explain functions inside a class:

Example:

class karl(object) :
    def __init__(self, x, y):
        self.x = x
        self.y = y

def sample(self) :
    print ("This is just a sample code")

In the above code, we created a class name karl using the 'class' keyword. And two functions are used namely __init__() (for setting the instance variable) & sample(). Classes are used instead of modules because programmers can take this class 'karl' & use it or modify it as many times as we want & each one won't interfere with each other. Importing a module brings the entire program into use.

Creating Objects (Instance of A Class)

Let's see an example to show how to create an object:

Example:

class student:
        def __init__(self, roll, name):
                self.r = roll
                self.n = name
                print ((self.n))
                
#...       
stud1 = student(1, "Alex")
stud2 = student(2, "Karlos")

print ("Data successfully stored in variables")

Output:

Alex
Karlos
Data successfully stored in variables

Accessing Object Variables

We can access the object's variable using the dot (.) operator.
The syntax is:

my object_name.variable_name

Example:

print object.varabl

Accessing Attributes

Object attributes can also be accessed by using the dot operator.

Example:

stud1.display()
stud2.display()

print ("total number of students are: %d" %  student.i)

Use of Pre-defined Functions

Instead of using general statements to access attributes, programmers can use the following functions:

• getattr( obj, name [,default] ) : used to access object's attribute.

• hasattr( object, name): used for checking whether the attribute exists or not.

• setattr( obj, name, value ) : set or create an attribute, if it doesn't exist.

• delattr( obj, name ) : used to delete an attribute.

Built-in Class Attributes

All the Python built-in class attributes can be accessed using dot (.) operator like other attributes.

The built-in class attributes are:

• __dict__: This attribute is a dictionary that contains the class's -namespace.
• __doc__: Used for class documentation string.
• __name__: used as class-name.
• __module__: used to define the module name for the class in which it is defined. In interactive mode, it is __main__.
• __bases__: An empty tuple containing the base-class.