By born, Python supports Object Oriented Programming (OOP). We will learn in detail the Python OOP features. Before that we will learn some important topics, which will empower our knowledge of Python programming.
In this tutorial we are going to learn the following topics –
3. Assessing Files
4. Encapsulating Data
There are two kinds of comments in Python. First one is single line comment and the second one is multiline comment. The second one also called docstring in Python.
# this is the first comment “”” This is multi line comment”””
The docstring specially stated right after declaring module, function, class, or method.
def printMe(): “”” this function will print 0 to 4 “”” for i in range(0, 5): print i printMe()
All modules should normally have docstrings, and all functions and classes exported by a module should also have docstrings. Public methods (including the __init__ constructor) should also have docstrings. A package may be documented in the module docstring of the __init__.py file in the package directory.
The fun is you can see the docstring from Python shell like –
>>> print printMe.__doc__
Modules are simple Python script, which accomplish some task. It helps programmers at the time of coding by doing some job. Usually Python modules can be imported. We can import whole module or specific function of that module to make our job done.
Let’s create a simple Python script called “fibonacci.py” and write the following lines of code:
# Fibonacci numbers module def fib(n): # write Fibonacci series up to n a, b = 0, 1 while b < n: print b, a, b = b, a+b def fib2(n): # return Fibonacci series up to n result =  a, b = 0, 1 while b < n: result.append(b) a, b = b, a+b return result
This script contains two functions, fib() and fib2(). So for our purpose we can import the whole module or a particular one or two function of the module, as needed.
So, let’s create one more Python script, say – fibcall.py
from fibonacci import fib fib(10)
Now change the same script as follows:
from fibonacci import fib2 print fib2(10)
Or, as follows:
from fibonacci import * fib(10) print "" print fib2(10)
We can find thousand of modules in PyPI, https://pypi.python.org/pypi. PyPI is called Python Package Index. Like, PyMySQL is for MySQL driver and Django is a popular web framework.
To install just run the following commands from your console:
$ pip install PyMySQL $ pip install django
These commands will download and install all the dependencies and install into your environment.
You can check you’re these installed modules from your Python console.
>>> import pymysql >>> pymysql.get_client_info() '0.6.6.None' >>> import django >>> django.get_version() '1.8.2'
3. Assessing Files
In Python, creating, reading and writing in the file is very easy. The file object has different methods for working with files, open(), read(), write() and close(). The open() function takes two arguments, one is one is file name and other is file mode. The file has several “mode” of opening. Like-
r: Open and existing file to read.
w: Open an existing file to write. Creates a new file if none exists or opens an existing file and discards all its previous contents.
a: Append text. Opens or creates a text file for writing at the end of the file.
r+: Open a text file to read from or write.
w+: Open a text file to write to or read from.
a+: Open or creates a text file to read from or write to at the end of the file.
Now create a python script called fileaccess.py in our directory.
# creating a file for writing file = open("example.txt", "w") file.write("This is my first text for the file.") file.close() # opening the file for reading file = open("example.txt", "r") content = file.readline() file.close() print content
As simple as it is right!!!
4. Encapsulating Data
Encapsulating data means we will enclose all the varialbes and methods inside a class. The basic structure of Python class structure is using “class” keyword and name the class name. Usually, the class name and the file name is same, it is a good practice. The basic structure of a simple class is given below. Let’s create a Python class file called Bird.py –
class Bird : '''A base class to define bird properties.''' count = 0 def __init__( self , chat ) : self.sound = chat Bird.count += 1 def talk( self ) : return self.sound
The bird class contains two methods __init__() and talk().
__init__() is called class constructor or initialization method that Python calls when you create a new instance of this class.
talk() is a regular method.
Now let’s create one more python file called Encapsul.py and don’t forget to import Bird class.
from Bird import * print( '\nClass Instances Of:\n' , Bird.__doc__ ) polly = Bird( 'Squawk, squawk!' ) print( '\nNumber Of Birds:' , polly.count ) print( 'Polly Says:' , polly.talk() ) harry = Bird( 'Tweet, tweet!' ) print( '\nNumber Of Birds:' , harry.count ) print( 'Harry Says:' , harry.talk() )
The concept of inheritance in OOP is same for all the languages. The class inheritance mechanism allows multiple base classes, a derived class can override any methods of its base class or classes, and a method can call the method of a base class with the same name. Objects can contain arbitrary amounts and kinds of data. As is true for modules, classes partake of the dynamic nature of Python: they are created at runtime, and can be modified further after creation.
To understand inheritance let’s create on Python class called Polygon.py
class Polygon : width = 0 height = 0 def set_values( self , width , height ) : Polygon.width = width Polygon.height = height
Then import it form another class, Rectangle.py
from Polygon import * class Rectangle( Polygon ) : def area( self ) : return self.width * self.height
Now, create one more class, Triangle.py
from Polygon import * class Triangle( Polygon ) : def area( self ) : return ( self.width * self.height ) / 2
If you check it carefully, Rectangle and Triangle class contains one same method called area. However the definition is different. First one calculates the area of rectangle and the next one calculate the area of triangle.
To test it, create one more Python file called, inherit.py and import the both class.
from Rectangle import * from Triangle import * rect = Rectangle() trey = Triangle() rect.set_values( 4 , 5 ) trey.set_values( 4 , 5 ) print( 'Rectangle Area:' , rect.area() ) print( 'Triangle Area:' , trey.area() )
Data attributes override method attributes with the same name; to avoid accidental name conflicts, which may cause hard-to-find bugs in large programs, it is wise to use some kind of convention that minimizes the chance of conflicts. Derived classes may override methods of their base classes. Because methods have no special privileges when calling other methods of the same object, a method of a base class that calls another method defined in the same base class may end up calling a method of a derived class that overrides it.
So, to test the overriding mechanism let’s create three classes one by one called, Person.py the base class, Man.py and Woman.py contains overridden method called speak.
class Person : '''A base class to define Person properties.''' def __init__( self , name ) : self.name = name def speak( self , msg = '(Calling The Base Class)' ) : print( self.name , msg )
from Person import * '''A derived class to define Man properties.''' class Man( Person ) : def speak( self , msg ) : print( self.name , ':\n\tHello!' , msg )
from Person import * '''A derived class to define Hombre properties.''' class Woman( Person ) : def speak( self , msg ) : print( self.name , ':\n\tHi!' , msg )
Now create one python file called override.py to check our overriding mechanism.
from Man import * from Woman import * guy_1 = Man( 'Richard' ) guy_2 = Woman ( 'Anne ' ) guy_1.speak( 'It\'s a beautiful evening, from Richard.\n' ) guy_2.speak('It\'s a beautiful evening, from Anne.\n') Person.speak( guy_1 ) Person.speak( guy_2 )
In programming languages, polymorphism (from Greek, polys, “many, much” and, morphē, “form, shape”) means many form of a single intrface.
Let’s check it by example, create two classes Duck.py and Mouse.py. Both the class contains talk() and coat() methods.
class Duck : '''A class to define Duck properties.''' def talk( self ) : print( '\nDuck Says: Quack!' ) def coat( self ) : print( 'Duck Wears: Feathers' )
class Mouse : '''A class to define Mouse properties.''' def talk( self ) : print( '\nMouse Says: Squeak!' ) def coat( self ) : print( 'Mouse Wears: Fur' )
Now create polymorph.py, which imports Duck and Mouse class and all the properties.
from Duck import * from Mouse import * def describe( object ) : object.talk() object.coat() donald = Duck() mickey = Mouse() describe( donald ) describe( mickey )
We are all done with Object Oriented Programming features of Python. However, Python does not support the technique of “overloading” found in other languages – in which methods of the same name can be created with different argument lists in a single class.
You can download all the codes from my github account.
Happy coding… 🙂
OOP with Python