Python is an amazing programming language that supports both the functional programming paradigm and object-oriented programming paradigm.
Python's object-oriented programming system supports all the four fundamental features of a general OOPS framework: encapsulation, abstraction, inheritance and polymorphism.
What is a Class and an Object?
- A class is a bundle of instance variables and related methods meant for defining a type of object viewed as a blueprint or a template of the objects.
- An object is an instance of a class with a specific set of attributes.
Class Definition Syntax
To create a class, use the keyword class as shown below
class ClassName:
<statement-1>
<statement-N>
Object Types
1.Class Objects
From python documentation;
Class objects support two kinds of operations: attribute references and instantiation.
Attribute references use the standard syntax used for all attribute references in Python: obj.name.
- Valid attribute names are all the names that were in the class’s namespace when the class object was created. Example:
class Student:
"""A simple example class"""
rollno = 12
name = "Korir"
def messg(self):
return 'New Session will start soon.'
From the above example, Student.roll_no, Student.name are valid attribute references, returning an 12 and 'Korir' respectively.
Student.messg returns a function object.In Python self is a name for the first argument of a method which is different from ordinary function. Rather than passing the object as a parameter in a method the word self refers to the object itself.
Instantiation uses function notation.
To create an instance of a class, you call the class as if it were a function. The example below creates a new instance of the class and assigns this object to the local variable x.
x = Student()
- The instantiation operation creates an empty object. Therefore a class may define a special method named init(), like this:
def __init__(self):
self.data = []
__ init __() method may have arguments for greater flexibility for example:
class Student:
"""A simple example class"""
def __init__(self,sroll, sname):
self.r = sroll
self.n = sname
x = Student(10, 'Korir')
x.r, x.n
Output
(10, 'Korir')
2.Instance Objects
- The only operations understood by instance objects are attribute references. There are two kinds of valid attribute names: data attributes and methods.
Data attributes correspond to instance variables and need not be declared; like local variables, they spring into existence when they are first assigned to.
A method is a function that belongs to an object.
Valid method names of an instance object depend on its class. By definition, all attributes of a class that are function objects define corresponding methods of its instances.
From our example;
x.messg is a valid method reference, since Student.messg is a function.
3.Method Objects
- Usually, a method is called right after it is bound:
x.messg()
- In the Student example, this will return the string 'New Session will start soon'.
Class and Instance Attributes
Instance attribute
- An instance attribute is a Python variable belonging to only one object.
- It is only accessible in the scope of the object and it is defined inside the constructor function of a class. For example:
class Circle:
def __ init __(self, radius):
self.pi = 3.14159
self.radius = radius
def area(self):
return self.pi * self.radius**2
def circumference(self):
return 2*self.pi * self.radius
- Both pi and radius are called instance attributes. Since they belong to a specific instance of the Circle class.
Class Attribute
- A class attribute is a Python Variable that belongs to a class rather than a particular object.
- It is shared between all other objects of the same class and is defined outside the constructor function __ init __(self,…), of the class. Example:
class Circle:
pi = 3.14159
def __init__(self, radius):
self.radius = radius
def area(self):
return self.pi * self.radius**2
def circumference(self):
return 2 * self.pi * self.radius
- The above example defines pi as a class attribute
- You can access the class attribute via instances of the class or via the class name:
object_name.class_attribute
class_name.class_attribute
From class attribute example;
c = Circle(10)
print(c.pi)
print(Circle.pi)
Output will be;
3.14159
3.14159
Inheritance
- Like other object-oriented language, Python allows inheritance from a parent (or base) class as well as multiple inheritances in which a class inherits attributes and methods from more than one parent.
- The concept of inheritance provides an important feature to the object-oriented programming is reuse of code
- The syntax for single inheritance is:
class DerivedClassName(BaseClassName):
<statement-1>
<statement-N>
- Below is a simple example of single inheritance in python.
class Parent():
def first(self):
print('first function')
class Child(Parent):
def second(self):
print('second function')
ob = Child()
ob.first()
ob.second()
Here's the output:
first function
second function
- From the above code, you can access the parent class function using the child class object.
Sub-classing
Calling a constructor of the parent class by mentioning the parent class name in the declaration of the child class is known as sub-classing. A child class identifies its parent class by sub-classing.
Other types of inheritance are;
Multiple Inheritance-When a child class inherits from more than one parent class.
Multilevel Inheritance-When a child class becomes a parent class for another child class.
Hybrid Inheritance- involves multiple inheritance from the same base or parent class.
Hierarchical Inheritance-involves multiple inheritance taking place in a single program.
Top comments (1)
Thanks for this insightful post. We look forward to many of this kind. Keep us learning