Python PhD

Often during recursive programming we hit the maximum set depth for recursive calls. But as usual Python’s flexibility help us in this situation too. In this post we discuss how we can increase the maximum recursive calls a python code segment can make.

To increase recursive calls depth just add the following lines to your code:

import  sys
sys.setrecursionlimit(NEW_LIMIT)

Pretty isn’t it?

Python is an interpreted high-level programming language for general-purpose programming. Created by Guido van Rossum and first released in 1991, Python has a design philosophy that emphasizes code readability, notably using significant whitespace. It provides constructs that enable clear programming on both small and large scales.

Python is known for its beautiful short solutions to rather complex problems. This characteristic of Python often comes out while programming.

Take the example of Pythonic solution to this Google’s Question: 

QUESTION: Given a string as your input, delete any reoccurring character, and return the new string.

Example Input: aaaaffffhhhh

Example Output: afh

Solution:

print(‘’.join(map(str,set(list(input(“Enter reoccurring characters”))))))

Sample Run:

>>>print(‘’.join(map(str,set(list(input(“Enter reoccurring characters”))))))

>>>Enter reoccurring characters

aaabbbcccc

>>>abc

In part-5 of this segment we discussed Polymorphism. In this article we’ll discuss Abstraction and its implementation in Python

Abstraction means, showcasing only the required things to the outside world while hiding the details. Continuing our example, Human Being’s can talk, walk, hear, eat, but the details are hidden from the outside world. We can take our skin as the Abstraction factor in our case, hiding the inside mechanism.

 The terms encapsulation and abstraction (also data hiding) are often used as synonyms. They are nearly synonymous, i.e. abstraction is achieved through encapsulation. Data hiding and encapsulation are the same concept, so it’s correct to use them as synonyms. 

Confusion in Encapsulation and Abstraction often leads to implementation of these two concepts. For example:

class AbstractClass:

    def do_somthing(self):
        pass

class B(AbstractClass):
    pass


a=AbstractClass()
b = B()

Above example is WRONG for the following reasons:

1. We can instantiate an object for AbstractClass hence it not an Abstract class.
2. We should not be able to instantiate objects of abstract classes.
3. We should be forced to implement do_something method in derived class B.

Hence, for the above reasons above example is wrong. Correct way of implementing Abstraction under Python is as , following:

1. We have to use Python’s inbuilt module like this –
   from abc import ABC, abstractmethod
   
2.  We need to import like above before making abstract classes
   
3.  After that give ABC as an argument to class definition to make it abstract.

CORRECT Code:

from abc import ABC, abstractmethod

class AbstractBaseClass(ABC):

    def __init__(self,value):
        super().__init__()
        self.value = value

    @abstractmethod
    def do_something(self,value):
        pass

#derive from above class to make abstraction in Python
class dABC(AbstractBaseClass):

    def do_something(self,value):
        print("doing something %r" %value)

x = dABC(4)
x.do_something(9)

In part-5 we’ll discuss Polymorphism under Python Programming Language.

Polymorphism means that different types respond to the same function.

Polymorphism is very useful as it makes programming more intuitive and therefore easier.

Polymorphism is a fancy word that just means the same function is defined on objects of different types.

Python provides protocols which is polymorphism under the hood. These implement consistent behaviour for built in objects of different type.

To make use of polymorphism, we’re going to create two distinct classes to use with two distinct objects. Each of these distinct classes need to have an interface that is in common so that they can be used polymorphically, so we will give them methods that are distinct but that have the same name.

We’ll create a Shark class and a Clownfish class, each of which will define methods for swim(), swim_backwards(), and skeleton().

class Shark():
    def swim(self):
        print("The shark is swimming.")

    def swim_backwards(self):
        print("The shark cannot swim backwards, but can sink backwards.")

    def skeleton(self):
        print("The shark's skeleton is made of cartilage.")


class Clownfish():
    def swim(self):
        print("The clownfish is swimming.")

    def swim_backwards(self):
        print("The clownfish can swim backwards.")

    def skeleton(self):
        print("The clownfish's skeleton is made of bone.")

In the code above, both the Shark and Clownfish class have three methods with the same name in common. However, each of the functionalities of these methods differ for each class.

Let’s instantiate these classes into two objects:

sammy = Shark()
sammy.skeleton()

casey = Clownfish()
casey.skeleton()

When we run the program with the python polymorphic_fish.py command, we can see that each object behaves as expected:

The shark's skeleton is made of cartilage.
The clownfish's skeleton is made of bone.

Method Overriding in Python

In the part-3 of this segment, notice that __init__() method was defined in both classes, Triangle as well Polygon. When this happens, the method in the derived class overrides that in the base class. This is to say, __init__() in Triangle gets preference over the same in Polygon.

Generally when overriding a base method, we tend to extend the definition rather than simply replace it. The same is being done by calling the method in base class from the one in derived class (calling Polygon.__init__() from __init__() in Triangle).

A better option would be to use the built-in function super(). So, super().__init__(3) is equivalent to Polygon.__init__(self,3) and is preferred. 

Two built-in functions isinstance() and issubclass() are used to check inheritances. Function isinstance() returns True if the object is an instance of the class or other classes derived from it. Each and every class in Python inherits from the base class object.

>>> isinstance(t,Triangle)
True

>>> isinstance(t,Polygon)
True

>>> isinstance(t,int)
False

>>> isinstance(t,object)
True

Similarly, issubclass() is used to check for class inheritance.

>>> issubclass(Polygon,Triangle)
False

>>> issubclass(Triangle,Polygon)
True

>>> issubclass(bool,int)
True

In part-2 of this segment, we discussed Encapsulation. In this post, we’ll discuss Inheritance in detail and its implementation in Python.

Inheritance is the process by which a class can be derived from a base class with all features of a base class and some of its own. This increases code reusability.

Inheritance is a powerful feature in object-oriented programming. It refers to defining a new class with little or no modification to an existing class. The new class is called derived (or child) class and the one from which it inherits is called the base (or parent) class.

Python Inheritance Syntax

class BaseClass:
  Body of base class
class DerivedClass(BaseClass):
  Body of derived class

Example of Inheritance in Python

A polygon is a closed figure with 3 or more sides. Let us make a class with name Polygon.

class Polygon:
    def __init__(self, no_of_sides):
        self.n = no_of_sides
        self.sides = [0 for i in range(no_of_sides)]

    def inputSides(self):
        self.sides = [float(input("Enter side "+str(i+1)+" : ")) for i in range(self.n)]

    def dispSides(self):
        for i in range(self.n):
            print("Side",i+1,"is",self.sides[i])

This class has data attributes to store the number of sides, n and magnitude of each side as a list, sides.

Method inputSides() takes in magnitude of each side and similarly, dispSides() will display these properly.

A triangle is a polygon with 3 sides. So, we can created a class called Triangle which inherits from Polygon. This makes all the attributes available in class Polygon readily available in Triangle. We don’t need to define them again (code re-usability). Triangle is defined as follows.

class Triangle(Polygon):
    def __init__(self):
        Polygon.__init__(self,3)

    def findArea(self):
        a, b, c = self.sides
        # calculate the semi-perimeter
        s = (a + b + c) / 2
        area = (s*(s-a)*(s-b)*(s-c)) ** 0.5
        print('The area of the triangle is %0.2f' %area)

However, theTriangleclass has a new method tofindArea() and print the area of the triangle. Here is a sample run.

>>> t = Triangle()

>>> t.inputSides()
Enter side 1 : 3
Enter side 2 : 5
Enter side 3 : 4

>>> t.dispSides()
Side 1 is 3.0
Side 2 is 5.0
Side 3 is 4.0

>>> t.findArea()
The area of the triangle is 6.00

As we can see that, even though we did not define methods like inputSides() or dispSides() for class Triangle, we were able to use them.

In part-1 of this segment, we discussed general characteristics of Object-oriented programming language. In this post, we’ll discuss these characteristics in detail and their implementation in Python.

In an object-oriented python program, you can restrict access to methods and variables. This can prevent the data from being modified by accident and is known as Encapsulation.

Encapsulation allows programmers better control of how data flows in their programs, and it protects that data. Encapsulation also makes objects into more self-sufficient and independently functioning pieces.

Private methods

We create a class truck which has two methods:  drive() and updateSoftware().  When a truck object is created, it will call the private methods __updateSoftware().  

This function cannot be called on the object directly, only from within the class.

#!/usr/bin/env python
 
class Truck:
 
    def __init__(self):
        self.__updateSoftware()
 
    def drive(self):
        print 'driving'
 
    def __updateSoftware(self):
        print 'updating software'
 
redtruck = Truck()
redtruck.drive()
#redtruck.__updateSoftware()  not accesible from object.

This program will output:

updating software
driving

Encapsulation prevents from accessing accidentally, but not intentionally.

The private attributes and methods are not really hidden, they’re renamed adding “_Truck” in the beginning of their name.

The method can actually be called using redtruck._Truck__updateSoftware()

Private variables

Variables can be private which can be useful on many occasions. A private variable can only be changed within a class method and not outside of the class.

Objects can hold crucial data for your application and you do not want that data to be changeable from anywhere in the code.
An example:

#!/usr/bin/env python
 
class Truck:
 
    __maxspeed = 0
    __name = ""
 
    def __init__(self):
        self.__maxspeed = 200
        self.__name = "Supertruck"
 
    def drive(self):
        print 'driving. maxspeed ' + str(self.__maxspeed)
 
redtruck = Truck()
redtruck.drive()
redtruck.__maxspeed = 10  # will not change variable because its private
redtruck.drive()

If you want to change the value of a private variable, a setter method is used.  This is simply a method that sets the value of a private variable.

#!/usr/bin/env python
 
class Truck:
 
    __maxspeed = 0
    __name = ""
 
    def __init__(self):
        self.__maxspeed = 200
        self.__name = "Supertruck"
 
    def drive(self):
        print 'driving. maxspeed ' + str(self.__maxspeed)
 
    def setMaxSpeed(self,speed):
        self.__maxspeed = speed
 
redtruck = Truck()
redtruck.drive()
redtruck.setMaxSpeed(320)
redtruck.drive()

To summarise, in Python there are:

Type	Description
public methods	Accessible from anywhere
private methods	Accessible only in their own class. starts with two underscores
public variables	Accessible from anywhere
private variables	Accessible only in their own class or by a method if defined. starts with two underscores