Advanced Python Objects

Introduction

Python is an object-oriented programming language that allows the creation and manipulation
of objects. Advanced Python objects involve deeper concepts such as custom objects, special
methods, property decorators, class methods, static methods, and more. These concepts are
crucial for writing more efficient, readable, and maintainable code.

1. Custom Objects and Classes

Defining a Class

A class is a blueprint for creating objects (instances). Classes encapsulate data and functions
that operate on the data.

class Person:
def __init__(self, name, age):
self.name = name
self.age = age

def greet(self):
return f"Hello, my name is {self.name} and I am {self.age} years
old."

Creating an Object

person1 = Person("Alice", 30)

print(person1.greet())

2. Special Methods (Magic Methods)

Special methods in Python start and end with double underscores (__). They are used to
emulate built-in behavior within user-defined classes.

Common Special Methods

 __init__(self, ...) : Constructor, initializes the object's attributes.

 __str__(self) : Returns a string representation of the object.
 __repr__(self) : Returns an official string representation of the object.
 __len__(self) : Defines behavior for the built-in len() function.
 __getitem__(self, key) : Defines behavior for element access, e.g., obj[key].
 __setitem__(self, key, value) : Defines behavior for setting elements, e.g.,
obj[key] = value.
Interfacing with Mathematical Operators

The following special methods control how an object interacts with + , * , ** , and other
mathematical operators.

Method Signature Explanation

Add __add__(self, other) x + y invokes x.__add__(y)

Subtract __sub__(self, other) x - y invokes x.__sub__(y)

Multiply __mul__(self, other) x * y invokes x.__mul__(y)

__truediv__(self, oth x / y invokes x.__truediv__(

Divide
er) y)

Power __pow__(self, other) x ** y invokes x.__pow__(y)

Example

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

def __repr__(self):
return f"Vector({self.x}, {self.y})"

def __add__(self, other):

return Vector(self.x + other.x, self.y + other.y)

def __len__(self):
return int((self.x**2 + self.y**2) ** 0.5)

v1 = Vector(3, 4)
v2 = Vector(1, 2)
v3 = v1 + v2

print(v3) # Output: Vector(4, 6)

print(len(v1)) # Output: 5

3. Property Decorators

Property decorators provide a way to manage the access to instance attributes. They are
useful for adding getter, setter, and deleter functionality.

Using Property Decorators

class Circle:
def __init__(self, radius):
 self._radius = radius

@property
def radius(self):
return self._radius

@radius.setter
def radius(self, value):
if value < 0:
raise ValueError("Radius cannot be negative")
self._radius = value

@property
def area(self):
return 3.14159 * self._radius ** 2

c = Circle(5)
print(c.radius) # Output: 5
print(c.area) # Output: 78.53975
c.radius = 3
print(c.area) # Output: 28.27431

4. Class Methods and Static Methods

Class methods and static methods are different ways to define methods that are not bound to
instance objects.

Class Methods

Class methods are bound to the class and not the instance of the class. They can modify class
state that applies across all instances. A class method receives the class as an implicit first
argument, just like an instance method receives the instance

class MyClass:
class_variable = 0

@classmethod
def increment_class_variable(cls):
cls.class_variable += 1

MyClass.increment_class_variable()
print(MyClass.class_variable) # Output: 1

Static Methods

Static methods are bound to the class and not the instance of the class. They do not modify
object or class state.

class MathOperations:
@staticmethod
def add(x, y):
return x + y

print(MathOperations.add(3, 4)) # Output: 7

5. Inheritance and Polymorphism

Inheritance allows one class to inherit attributes and methods from another class.
Polymorphism allows methods to do different things based on the object it is acting upon.

Inheritance

Syntax:

class DerivedClass(BaseClass):
# Class definition

Single Inheritance

class parent: # parent class

def func1(self):
print("Hello Parent")

class child(parent):
# child class
def func2(self): # we include the parent class
print("Hello Child") # as an argument in the child
# class

# Driver Code
test = child() # object created
test.func1() # parent method called via child object
test.func2()

Multiple Inheritance

class parent1: # first parent class

def func1(self):
print ("Hello Parent1")

class parent2: # second parent class

def func2(self):
print ("Hello Parent2")

class parent3: # third parent class

def func2(self): # the function name is same as
parent2
print ("Hello Parent3")

class child (parent1, parent2, parent3): # child class

def func3(self): # we include the parent classes
print ("Hello Child") # as an argument comma separated

# Driver Code
test = child() # object created
test.func1() # parent1 method called via child
test.func2() # parent2 method called via child instead of
parent3
test.func3(
Multilevel Inheritance

class grandparent: # first level

def func1(self):
print("Hello Grandparent")

class parent(grandparent): # second level

def func2(self):
print("Hello Parent")

class child(parent): # third level

def func3(self):
print("Hello Child")

# Driver Code
test = child() # object created
test.func1() # 3rd level calls 1st level
test.func2() # 3rd level calls 2nd level
test.func3()

Polymorphism

Polymorphism with class methods

class Liquid:
def __init__(self, name, formula):
self.name = name
self.formula = formula

def info(self):
print(f"I am Liquid Form. I am {self.name}. and my formula is {self.formula}")

def property(self):
print("I am clear and light form")

class Solid:
def __init__(self, name, formula):
self.name = name
self.formula = formula

def info(self):
print(f"I am Solid Form. I am {self.name}. and my formula is {self.formula}")

def property(self):
print("I can be transparent or clear or completely opaque")

liquid_1 = Liquid("Water", "H20")

solid_1 = Solid("Ice", "H20")
for material in (liquid_1,solid_1):
material.info()
material.property()

And the output is:

I am Liquid Form. I am Water. and my formula is H20

I am clear and light form
I am Liquid Form. I am Ice. and my formula is H20
I can be transparent or clear or complete opaque

Here, we create two classes: Liquid and Solid. Here, we define info() and property() for both

of them. These functions work differently depending on which class object you call.

Polymorphism with Inheritance

In Object-oriented programming, class inheritance lets you inherit the methods

and attributes of a parent class to a child class. The parent class is also known as base class,

whereas the derived subclass is known as derived or child class.

Child classes uses method overriding polymorphism to implement inheritance.

class F1():
def run(self):
print("Win")

class F2(F1):
def run(self):
print("2nd place - F2 cars are slower than F1 cars")

class F3(F1):
def run(self):
print("3rd place - F3 cars are slower than F2 and F1 cars")

obj_F1 = F1()
obj_F2 = F2()
obj_F3 = F3()
obj_F1.run()
obj_F2.run()
obj_F3.run()

And the output is:

Win
2nd place - F2 cars are slower than F1 cars
3rd place - F3 cars are slower than F2 and F1 cars

Here, we first defined our F1 class and then passed it as a parameter in the F2 class. Each time

we called the run() function on objects of F1, F2 and F3 class, the inheritance and method

overriding took place.

6. Encapsulation

Encapsulation restricts access to methods and variables to prevent data from being modified
directly. This is achieved using private and protected access modifiers.

Public, Private and Protected Attributes

The members of a class that are declared public are easily accessible from any part of the
program. All data members and member functions of a class are public by default.

The members of a class that are declared protected are only accessible to a class derived
from it. Data members of a class are declared protected by adding a single underscore ‘_’
symbol before the data member of that class.

The members of a class that are declared private are accessible within the class only,
private access modifier is the most secure access modifier. Data members of a class are
declared private by adding a double underscore ‘__’ symbol before the data member of that
class.

class Super:

# public data member

var1 = None

# protected data member

_var2 = None
 # private data member
__var3 = None

# constructor
def __init__(self, var1, var2, var3):
self.var1 = var1
self._var2 = var2
self.__var3 = var3

# public member function

def displayPublicMembers(self):

# accessing public data members

print("Public Data Member: ", self.var1)

# protected member function

def _displayProtectedMembers(self):

# accessing protected data members

print("Protected Data Member: ", self._var2)

# private member function

def __displayPrivateMembers(self):

# accessing private data members

print("Private Data Member: ", self.__var3)
# public member function
def accessPrivateMembers(self):

# accessing private member function

self.__displayPrivateMembers()

# derived class

class Sub(Super):

# constructor
def __init__(self, var1, var2, var3):
Super.__init__(self, var1, var2, var3)

# public member function

def accessProtectedMembers(self):

# accessing protected member functions of super class

self._displayProtectedMembers()

# creating objects of the derived class

obj = Sub("Geeks", 4, "Geeks !")

# calling public member functions of the class

obj.displayPublicMembers()
obj.accessProtectedMembers()
obj.accessPrivateMembers()

# Object can access protected member

print("Object is accessing protected member:", obj._var2)

# object can not access private member, so it will generate Attribute

error
# print(obj.__var3)