Introduction

Overriding is an interesting concept in object-oriented programming.  When the method definitions of a Base Class are changed in a Subclass (Derived) Class this is called a method override.  You are keeping the same signature of the method but changing the definition or implementation of a method defined by one of the ancestors.  There is no special syntax or additional keywords needed to do method overriding in Python.  It is a very important object-oriented programming concept since it makes inheritance exploit its full power.  In essence, you are not duplicating code, thus following the programming principle of DRY (do not repeat yourself), and you can enhance the method in the subclass.

To understand the concept of overrides, you must know the basic concepts of object-oriented programming such as classes and inheritance.  There are many resources on the internet about OOP.  A really good resource is Finxter Academy’s object-oriented Python class: https://academy.finxter.com/university/object-oriented-python/

Need for Overrides

In the following example, you see how inheritance works and the problem of not overriding a method in the subclass.  The Parent class has a method whoami that displays “I am a parent”.  This method is inherited by the Child class.  Calling the whoami method from the Child class, calls the inherited method from the Parent class and thus displays “I am a parent” which is wrong.

Inheritance example with no method overriding:

class Parent():
    def whoami(self):
        print("I am a parent")

class Child(Parent):
    def play(self):
        print(" I am playing")

child = Child()
child.whoami()

# Output:
# I am a parent

Basic Override

The next example, shows how basic overriding works.  In this example the Child class has a definition of the whoami method that overrides the method from the Parent class. Calling the whoami method from the Child class now displays “I am a child”.

Basic Overriding example:

#Overriding
class Parent():
    def whoami(self):
        print("I am a parent")

class Child(Parent):
    def play(self):
        print(" I am playing")

    def whoami(self):
        print("I am a child")
        
parent = Parent()
parent.whoami()
print()
child = Child()
child.whoami()

# Output:
# I am a parent
# I am a child

Extending a Method Through Overrides

The third example shows how you can extend a method in a Base Class by overriding the method in the Subclass.  To do that we use the super() built-in function.  It returns a proxy object that allows us to access methods of the base class.  We can refer to the base class from the subclass without having to call the base class name explicitly.

The Employee class has the following details for the employee: employee number, employee name, salary and, department number.  This information is passed to the instantiated object in the __init__ method.  The showEmployee method of the class then displays this information formatted using new lines.

The Salesman class inherits from the Employee class.  By default, it inherits the showEmployee method as-is from the Employee class.  The only problem is that we want to display the commission that the salesman receives as part of the printed information.  Here is where overriding is needed.  We want to reuse the showEmployee method from the Employee class but we want to extend it to add the commission information.  This is accomplished by using the super() built-in function.  In the example below you see that in the Salesman class, super() is used twice.  The __init__ method uses it to call the __init__ method of the Employee base class and the showEmployee uses it to override the showEmployee method of the Employee base class.  In it, we display the employee information for the salesman plus the commission for the salesman.

A third class called CEO uses the same logic as before.  The showEmployee method in this case displays the employee information plus the stock options for the CEO.

class Employee():
    def __init__(self, empno, ename, salary, deptno):
        self.Empno = empno
        self.Ename = ename
        self.Salary = salary
        self.Deptno = deptno
    
    def showEmployee(self):
        print("Employee # : {}\nEmployee Name : {}\nSalary : {}\nDepartment : {}".format(self.Empno, self.Ename, self.Salary, self.Deptno))
              
class Salesman(Employee):
    def __init__(self, empno, ename, salary, deptno, comm):
        self.Commission = comm
        super().__init__(empno, ename, salary, deptno)
              
    def showEmployee(self):
        print("Salesman Profile")       
        super().showEmployee()      
        print("Commision : ", self.Commission)

class CEO(Employee):
    def __init__(self, empno, ename, salary, deptno, stock):
        self.Stock = stock
        super().__init__(empno, ename, salary, deptno)
              
    def showEmployee(self):
        print("CEO Profile")      
        super().showEmployee()      
        print("Stock Options : ", self.Stock)

              
salesman = Salesman(200, "John Doe", 67000, "Sales", 100)
salesman.showEmployee()
print("")
ceo = CEO(40, "Jennifer Smith", 300000, "Director", 1000000)
ceo.showEmployee()              

Output:

Salesman Profile
Employee # : 200
Employee Name : John Doe
Salary : 67000
Department : Sales
Commision :  100

CEO Profile
Employee # : 40
Employee Name : Jennifer Smith
Salary : 300000
Department : Director
Stock Options :  1000000

Multiple Inheritance Overriding

Understanding multiple inheritance has its own challenges.  One of them is the use of super().  Here is a link to an article about this issue: https://www.datacamp.com/community/tutorials/super-multiple-inheritance-diamond-problem

In the example below, I wanted to show a way to override a method from a subclass with multiple inheritance.  The example consists of three classes: Account, Customer, and Orders. 

• The Account class has its name and number and a display method which displays this information. 
• The Customer class has also its name and number and a display method that displays this information. 
• The Orders class displays the orders information for a customer in a specific account.  It inherits from both the Account and Orders class.  The display method in this class overrides the display methods of the base classes.  The display method prints the Account information, the Customer information, and the Orders information

Here’s an example:

class Account():
    def __init__(self, name, number):
        self.Name = name
        self.Number = number
    
    def display(self):
        print("Account # : {}\nAccount Name : {}".format(self.Number, self.Name))
              
class Customer():
    def __init__(self, name, number):
        self.Name = name
        self.Number = number
              
    def display(self):
        print("Customer # : {}\nCustomer Name : {}".format(self.Number, self.Name))

class Orders(Account, Customer):
    def __init__(self, acctnumber, acctname, custnumber, custname, ordnumber, ordnamename, product, qty):
        self.OrdNumber = ordnumber
        self.Product = product
        self.Qty = qty
        self.OrdName = ordnamename
        self.acct = Account(acctname, acctnumber)
        self.cust = Customer(custname, custnumber)
              
    def display(self):
        print("Order Information")
        self.acct.display()
        self.cust.display() 
        print("Order # : {}\nOrder Name : {}\nProduct : {}\nQuantiy : {}".format(self.OrdNumber, self.OrdName, self.Product, self.Qty))

acct = Account("AB Enterprise", 12345)
acct.display()
print("")
cust = Customer("John Smith", 45678)
cust.display()
print("")
order = Orders(12345, "AB Enterprise", 45678,"John Smith", 1, "Order 1", "Widget", 5, )
order.display()

Output:

Account # : 12345
Account Name : AB Enterprise

Customer # : 45678
Customer Name : John Smith

Order Information
Account # : 12345
Account Name : AB Enterprise
Customer # : 45678
Customer Name : John Smith
Order # : 1
Order Name : Order 1
Product : Widget
Quantiy : 5

Different Overriding Scenarios

1 – Class Methods

Class methods are special in the sense that they can be called on a class by itself or by instances of a class.  They bind to a class so this means that the first argument passed to the method is a class rather than an instance.

Class methods are written similarly to regular instance methods.  One difference is the use of the decorator @classmethod to identify that the method is a class method.  Also, by convention, instead of using self to reference the instance of a class, cls is using to reference the class.  For example:

class Account():
    @classmethod
    def getClassVersion(cls):
        print("Account class version is 1.0”)

For more information about class methods check this website.

Here is an example of the problem you will encounter when overriding a class method:

class ParentClass:
    @classmethod
    def display(cls, arg):
        print("ParentClass")
        
class SubClass(ParentClass):
    @classmethod
    def display(cls, arg):
        ret = ParentClass.create(cls, arg)
        print("Subclass")
        return ret
    
SubClass.display("test")

Output:

create() takes 2 positional arguments but 3 were given

In the Subclass, the call to the ParentClass create method is not an unbound call the way it happens with a normal instance method.  The outcome of this call is a TypeError because the method received too many arguments.

The solution is to use super() in order to successfully use the parent implementation.

class ParentClass:
    @classmethod
    def display(cls, arg):
        print("ParentClass")
        
        
        
class SubClass(ParentClass):
    @classmethod
    def display(cls, arg):
        ret = super(SubClass, cls).create(arg)
        print("Subclass")
        return ret
    
SubClass.display("test")

Output:

ParentClass
Subclass

2 – Magic Methods

What are magic methods?

Magic methods are a set of methods that Python automatically associates with every class definition. Your classes can override these magic methods to implement different behaviors and make them act just like Python’s built-in classes. Below you will see examples of two of the most common ones: __str__ and __repl__. Using these two methods, you can implement how your objects are displayed as strings, which will be of importance while debugging and presenting the information to the user.  Overriding these methods adds to the flexibility and power of Python.  

The __str__ method of a class is used when Python prints an object. This magic method is called by the str built-in function.

class DemoMagic():
    def display(self):
        print("Demo Magic class")
       
varDemo = DemoMagic()
varDemo.display()
str(varDemo)  

Output:

Demo Magic class
'<__main__.DemoMagic object at 0x000002A7A7F64408>'

class DemoMagic():
def display(self):
        print("Demo Magic class")
        
def __str__(self):
        return "Override of str function"
        
varDemo = DemoMagic()
varDemo.display()
str(varDemo)     

Output:

Demo Magic class
'Override of str function'

The __repr__ method of a class is used to display the details of an object’s values. This magic method is called by the built-in the repr function.

class Person(object):
    def __init__(self, firstname, lastname):
         self.first = firstname
         self.last = lastname

    def __repr__(self):
        return "%s %s" % (self.first, self.last)
    
Tom = Person("Tom", "Sawyer")
repr(Tom)

Output

'Tom Sawyer'

Here is a list of magic methods.  You can learn more about them here (https://www.tutorialsteacher.com/python/magic-methods-in-python) and think how to override them to fit your needs:

'__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__'

3 – Abstract Classes  

An abstract class is a blueprint that subclasses must follow.  It can be viewed as a contract between the abstract class and the subclass.  The abstract class tells you what to do by providing an empty abstract method and the subclass must implement it.  By default, you must override the abstract methods defined by the abstract class.  In other terms, we are providing a common interface for different implementations of a class.  This is very useful for large projects where certain functionality must be implemented.

Here is an example of an abstract class and the overrriden methods in the subclasses.

from abc import ABC, abstractmethod 
class Animal(ABC): 
       @abstractmethod
    def whoami(self): 
        pass

class Dog(Animal): 
  
    def move(self): 
        print("I am a dog") 

class Cat(Animal): 
  
    def move(self): 
        print("I am a cat") 

Conclusion

Overriding is a basic concept used in many places in object-oriented programming.  You must understand it to be able to implement better classes and modify their behavior.  This article shows you some examples where you can use overrides in Python.  Other concepts mentioned that are worth learning more about are: magic method and abstract classes.

Closures

Every function in Python is first class, because they can be passed around like any other object. Usually, when a programming language creates a function just like other data types, that programming language supports something called Closures.

A closure is a nested function. It is defined within an outer function.

def outer_hello_fn():
    def hello():
        print("Hello Finxter!")
        
    hello()

Here, we have an outer function called outer_ hello_ fn, it has no input arguments. The function hello is a nested function defined within the outer function. The hello function is a closure.

Try It Yourself:

Exercise: What’s the output of this code snippet? Run the code to test if you’re correct.

When the outer function is called, the hello function within it will be defined and then invoked. Here is the function call and output:

outer_hello_fn()

Output:

Hello Finxter!

hello has been defined within outer_hello_fn, which means if you try and invoke the hello function, it will not work.

hello()

Output:

NameError: name 'hello' is not defined

If you want access to a function that is defined within another function, return the function object itself. Here is how.

def get_hello_fn():
    def hello():
        print("Hello Finxter!")

    return hello

The outer function is called get_hello_fn. hello, is an inner function, or closure. Instead of invoking this hello function, simply return the hello function to whoever calls get_hello_fn. For example:

hello_fn = get_hello_fn()

Invoking get_hello_fn stores the return function object in the hello_fn variable. If you explore the contents of this hello_fn variable, you will see that it is a function object.

hello_fn

Output:

<function __main__.get_hello_fn.<locals>.hello>

As you can see in the structure, it is a locally defined function within get_hello_fn, that is, a function defined within another function, that is a closure. Now, this closure can be invoked by using the hello_fn variable.

hello_fn()

Output:

Hello Finxter!

Invoke hello_fn() will print out Hello Finxter! to screen. A closure is something more than just an inner function defined within an outer function. There is more to it. Here is another example:

def hello_by_name(name):
    
    def hello():
        print("Hello!", name)
        
    hello()
    
    return hello

Here, the outer function is called hello_by_name, which takes in one input argument, the name of an individual. Within this outer function, there is the hello inner function. It prints to the screen Hello!, and the value of the name.

The name variable is an input argument to the outer function. It is also accessible within the inner hello function. The name variable here can be thought of as a variable that is local to the outer function. Local variables in the outer function can be accessed by closures. Here is an example of passing an argument to the outside function:

greet_hello_fn = hello_by_name("Chris")

The function hello is returned and it is stored in the greet_hello_fn variable.

Executing this prints out Hello! Chris to screen. That is because we invoked the closure from within the outer function. We have a reference to the closure that was defined by the outer function.

greet_hello_fn()

Output:

Hello! Chris

Notice something interesting here. Chris is available in the variable name which is local to the hello_by_name function.

Now, we have already invoked and exited hello_by_name but the value in the name variable is still available to our closure. And this is another important concept about closures in Python. They hold the reference to the local state even after the outer function that has defined the local state has executed and no longer exists. Here is another slightly different example illustrating this concept.

def greet_by_name(name):
    
    greeting_msg = "Hi there!"

    def greeting():
        print(greeting_msg, name)
        
    return greeting

The outer function, greet_by_name, takes in one input argument, name. Within the outer function, a local variable called greeting_msg is defined which says, “Hi there!”. A closure called greeting is defined within the outer function. It accesses the local variable greeting_msg as well as the input argument name. A reference to this greeting closure is returned from the outer greet_by_name function.

Let’s go ahead and invoke greet_by_name and store the function object that it returns in the greet_fn variable. We will use this function object to greet Ray by name. Go ahead and invoke the greet_fn() by specifying parentheses. And it should say, Hi there! Ray. Observe how the closure has access not just to the name Ray but also to the greeting message, even after we have executed and exited the outer function.

greet_fn = greet_by_name("Ray")
greet_fn()

Output:

Hi there! Ray

Closures carry around information about the local state. Let’s see what happens when the greet_by_name function is deleted, so you no longer have access to the outer function.

del greet_by_name

Now, remember that name and greeting message are both variables that were defined in the outer function. What happens to them? Now if you try to invoke greet by name.

greet_by_name("Ray")

Output:

NameError: name 'greet_by_name' is not defined

What about the greet_fn?

Remember that greet_fn is a reference to our closure. Does this still work?

greet_fn()

Output:

Hi there! Ray

Not only does it work, but it still has access to the local variables that were defined in the outer function. The outer function no longer exists in Python memory, but the local variables are still available along with our closure.

Decorators – Code Modification

Decorators help to add functionality to existing code without having to modify the code itself. Decorators are so-called because they decorate code, they do not modify the code, but they make the code do different things using decoration. Now that we have understood closures, we can work our way step by step to understanding and using decorators.

def print_message():
    print("Decorators are cool!")

Here is a simple function that prints a message to screen.

print_message()

Output:

Decorators are cool!

Each time you invoke this function it will always print the same message. I want to use a few characters to decorate the original message, and I do this using the highlight function.

import random

def highlight():
    
    annotations = ['-', '*', '+', ':', '^']
    annotate = random.choice(annotations)
    
    print(annotate * 50)
    
    print_message()
    
    print(annotate * 50)

The outer function highlight has no input arguments. Within the highlight function, a random choice of annotations is used to decorate the original message. The message will be highlighted with a random choice between the dash, the asterisk, the plus, the colon, and the caret.  The output will have an annotation of 50 characters before and after the message which is inside the print_message function.

Try It Yourself:

Exercise: What’s the output of this code snippet? Run the code to test your understanding!

highlight()

Output:

::::::::::::::::::::::::::::::::::::::::::::::::::
Decorators are cool!
::::::::::::::::::::::::::::::::::::::::::::::::::

Here is another function with a different message, print_another_message.

def print_another_message():
    print("Decorators use closures.")

Now if I want to highlight this message as well, the existing highlight function will not work because it has been hardcoded to invoke the print_message function. So how do I change this highlight function so that it is capable of highlighting any message that I want printed out to screen? Remember that functions are first-class citizens in Python, which means whatever print function you have, you can pass it as an input argument to the highlight function. Here is a redefined highlight function, make_highlighted.

def make_highlighted(func):
    
    annotations = ['-', '*', '+', ':', '^']
    annotate = random.choice(annotations)
    
    def highlight():
        print(annotate * 50)
        func()
        print(annotate * 50)            
    
    return highlight

The only difference here is that make_highlighted takes in an input argument that is a function. This function is what will print out the message to be displayed. The next change is that within the highlight closure, the function object that was passed in is invoked. That is the function object that will print out the message. Now we have two print functions so far.

print_message()
print_another_message()

And now with the help of  make_highlighted function, any printed message can be highlighted. For example:

highlight_and_print_message = make_highlighted(print_message)

highlight_and_print_message()

Output:

++++++++++++++++++++++++++++++++++++++++++++++++++
Decorators are cool!
++++++++++++++++++++++++++++++++++++++++++++++++++

To print a different message and have it highlighted, simply pass a different function object to the make_highlighted function.

highlight_and_print_another_message = make_highlighted(print_another_message)

highlight_and_print_another_message()

Output:

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Decorators use closures.
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

It is clear that the make_highlighted function is very generic, you can use it to highlight any message that you want printed to screen. The function make_highlighted is a decorator.

Why is it a decorator? Well, it takes in a function object and decorates it and changes it. In this example, it highlights the function with random characters. Decorators are a standard design pattern, and in Python, you can use decorators more easily. Instead of passing in a function object to make_highlighted, accessing the closure, and then invoking the closure, you can simply decorate any function by using @ and placing the decorator before the function to decorate.

@make_highlighted
def print_a_third_message():
    print("This is how decorators are used")

The use of the decorator @make_highlighted will automatically pass the function print_a_third_message as an input to make_highlighted and highlight the message.

print_a_third_message()

Output:

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
This is how decorators are used
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Now you can use the decorator to highlight any messages.

@make_highlighted
def print_any_message():
    print("This message is highlighted!")

And now if you invoke print_any_message, you will find that the result that is displayed to screen is highlighted.

print_any_message()

Output:

++++++++++++++++++++++++++++++++++++++++++++++++++
This message is highlighted!
++++++++++++++++++++++++++++++++++++++++++++++++++

Decorators – Customization

Let’s see another example of a Decorator that will do some work. It will do some error checking for us.

Here are two functions that will be the input to our decorator

def square_area(length):
    
    return length**2

def square_perimeter(length):
    
    return 4 * length

We assume that the value of the radius passed in is positive and correct.

square_area(5)

Output:

25

What if I invoke the square_area and pass in -1?

square_area(-1)

Output:

-4

The input -1 doesn’t make sense as a value for the length. The function should have thrown an error or told us in some way that negative values of length are not valid. Now, if you were to perform an error check for each of these functions, we would have to do it individually. We would have to have an if statement within the area function as well as the perimeter function. Instead of that, let’s write a decorator that will perform this error checking for us. The decorator safe_calculate takes in one input argument that is a function object.

def safe_calculate(func):
    
    def calculate(length):
        if length <= 0:
            raise ValueError("Length cannot be negative or zero")
        
        return func(length)
    
    return calculate

This is the function object that will perform the calculation. Within the safe_calculate outer function, the inner function called calculate is the closure. calculate takes in one input argument, the length. It checks to see whether length is less than or equal to 0. If yes, it throws an error. And the way it throws an error is by simply calling a raise ValueError, “Length cannot be negative or zero”. Once we raise this error, Python will stop the execution. But if length is positive, it will invoke func and pass in length as an input argument. The safe_calculate is our decorator, which takes as its input a function object and returns a closure that will perform the safe calculation.

square_area_safe = safe_calculate(square_area)

Let’s test it first:

square_area_safe(5)

This is safe and I get the result here on the screen.

25

Invoking it with a negative number will raise an error

square_area_safe(-1)

Output:

ValueError: Length cannot be negative or zero

Let’s decorate the perimeter function as well with the safe_calculate.

square_perimeter_safe = safe_calculate(square_perimeter)

square_perimeter(10)

Output:

40

But if you were to call square_perimeter_safe with a negative value for length well, that is a ValueError.

square_perimeter_safe(-10)

Output:

ValueError: Length cannot be negative or zero

Now that you have a decorator, you should decorate your functions rather than use the way that we have been using so far.

@safe_calculate
def square_area(length):
    return length**2

@safe_calculate
def square_perimeter(length):
    return 4 * length

Now, the next time square_area or the square_perimeter is called, the safety check will be performed.

square_perimeter(3)

Output:

12

If you try to calculate the perimeter for a negative value of the length, you will get a ValueError. The safe_calculate function that we set up earlier has a limitation, and you will see what it in a future example.

square_perimeter(-3)

Output:

ValueError: Length cannot be negative or zero

What happens when you have more than one input? Here is a function that calculates the area of a rectangle.

@safe_calculate
def rectangle_area(length, width):
    return length * width

Within our safe_calculate function, we had invoked the func object which performs the calculation with just one input argument, with just the variable length. This is going to cause a problem when we use the safe_calculate decorator for the rectangle_area function.

Once I have decorated this function, I’m going to invoke it with 4, 5.

rectangle_area(4, 5)

Output:

TypeError: calculate() takes 1 positional argument but 2 were given

The problem is with the way we had defined the closure inside the safe_calculate function.

The calculate closure takes in just one input argument. If a function has multiple input arguments, then safe_calculate cannot be used. A redefined safe_calculate_all function is shown below:

def safe_calculate_all(func):
    
    def calculate(*args):
        
        for arg in args:
            if arg <= 0:
                raise ValueError("Argument cannot be negative or zero")
        
        return func(*args)
    
    return calculate. 

It takes in one input argument that is the function object that is to be decorated. The main change is in the input arguments that are passed into the calculate closure. The function calculate now takes in variable length arguments, *args.  The function iterates over all of the arguments that were passed in, and checks to see whether the argument is less than or equal to 0. If any of the arguments are less than or equal to 0, a ValueError will be raised. Remember, *args will unpack the original arguments so that the elements of the tuple are passed in individually to the function object, func. You can now use this safe_calculate_all decorator with functions that have any number of arguments.

@safe_calculate_all
def rectangle_area(length, width):
    return length * width
rectangle_area(10, 3)

Output:

30

Let’s try invoking the same function, but this time one of the arguments is negative. Width is negative and that gives me a ValueError, thanks to our safe_calculate_all decorator.

rectangle_area(10, -3)

When you invoke this function, it will check all arguments.

ValueError: Argument cannot be negative or zero

It doesn’t matter which argument is negative, you still get the ValueError. Here the length is negative:

rectangle_area(-10, 3)

Output:

ValueError: Argument cannot be negative or zero

Chaining Decorators

You can have a function decorated using multiple decorators. And these decorators will be chained together.

Here are two decorators, one prints asterisks and the other plus signs

def asterisk_highlight(func):
    
    def highlight():
        print("*" * 50)

        func()

        print("*" * 50)            
    
    return highlight

def plus_highlight(func):
    
    def highlight():
        print("+" * 50)

        func()

        print("+" * 50)            
    
    return highlight

The print_message_one is decorated with the asterisk_highlight.

@asterisk_highlight
def print_message_one():
    print("Decorators are cool!") 
print_message_one()

Output:

**************************************************
Decorators are cool!
**************************************************

Now let’s define another print function, but this time we will decorate it using two decorators, the plus_highlight and the asterisk_highlight.

@plus_highlight
@asterisk_highlight
def print_message_one():
    print("Decorators are cool!")

What you see here is an example of chaining decorators together. But how are they chained? Which decoration comes first, the asterisk_highlight, or the plus_highlight? Whichever decorator is the closest to the function definition is what is executed first, and then the decorator which is further away from the function definition. This means that the message will be first highlighted with the asterisk, then the plus.

print_message_one()

Output:

++++++++++++++++++++++++++++++++++++++++++++++++++
**************************************************
Decorators are cool!
**************************************************
++++++++++++++++++++++++++++++++++++++++++++++++++

If you change the order of the decorators, the decorations order will change as well.

@asterisk_highlight
@plus_highlight
def print_message_one():
    print("Decorators are cool!") 

You will have the same function print_message_one, but the decorator that is closest to the function definition is the plus_highlight and then the asterisk_highlight.

print_message_one()

Output:

**************************************************
++++++++++++++++++++++++++++++++++++++++++++++++++
Decorators are cool!
++++++++++++++++++++++++++++++++++++++++++++++++++
**************************************************

Use of kwargs in Decorators

In this example we are using kwargs to display different messages for a decorator that times the execution of a function

def timeit(func):
        def timed(*args, **kw):
            if 'start_timeit_desc' in kw:
                print(kw.get('start_timeit_desc'))
            ts = time.time()
            result = func(*args, **kw)
            te = time.time()
            if 'end_timeit_desc' in kw:
                print('Running time for {} is {} ms'.format(kw.get('end_timeit_desc'), (te - ts) * 1000))
            return result
        return timed 

The timeit decorator is used for the test function.  Three parameters are passed to the function test: a, b and, **kwargs. The parameters a and b are handled in the decorator with *args as we have seen before.  The **kwargs parameter is used to pass descriptions for the function.  These parameters are start_timeit_desc and end_timeit_desc.  These two parameters are checked inside the timed closure and will display the messages that are in them.

@timeit
def test(a,b, **kwargs):
    return a * b


result = test(10,20, start_timeit_desc = "Start of test(10,20)...", end_timeit_desc = "End of test(10,20)")
print("result of test(10,20) = " + str(result))
Output:
Start of test(10,20)...
Running time for End of test(10,20) is 0.0 ms
result of test(10,20) = 200

Prerequisites

To use pyodbc in this article some prerequisites need to be met.

1. ODBC Driver – you need to download and install the ODBC driver for the database provider you are using. In this article, I am using SQLite.  Downloaded an ODCB driver for sqlite3 from http://www.ch-werner.de/sqliteodbc/,
2. SQLite3 – this article assumes that you have SQLite3 in your system and have created a database called testDB.db.
3. Database DDL – different database providers use different data definition languages.  DDL is the language needed to create tables in a database.  You must be familiar with this syntax to successfully create your table.  Creating tables in SQLite can be found here: https://sqlite.org/lang_createtable.html
4. Design your table – This is the table that will be implemented in the example below:

Here is an example of why you need to know the Data Definition Language of your database.  The following information was taken from https://www.sqlite.org/datatype3.html

“SQLite does not have a storage class set aside for storing dates and/or times. Instead, the built-in Date And Time Functions of SQLite are capable of storing dates and times as TEXT, REAL, or INTEGER values:

• TEXT as ISO8601 strings ("YYYY-MM-DD HH:MM:SS.SSS").
• REAL as Julian day numbers, the number of days since noon in Greenwich on November 24, 4714 B.C. according to the proleptic Gregorian calendar.
• INTEGER as Unix Time, the number of seconds since 1970-01-01 00:00:00 UTC.

Applications can choose to store dates and times in any of these formats and freely convert between formats using the built-in date and time functions.”

SQLite Create Table Data Definition Language for the PeopleInfo table:

CREATE TABLE PeopleInfo (
        PersonId INTEGER PRIMARY KEY,
        FirstName TEXT NOT NULL,
        LastName  TEXT NOT NULL,
        Age INTEGER NULL,
        CreatedAt TEXT DEFAULT CURRENT_TIMESTAMP NOT NULL
 
);

Let’s dive into the steps to create a table in SQLite using pyodbc in Python.

Step 1: Install the pyodbc Package

Install the Pyodbc package using the following command:

pip install pyodbc

For Anaconda use the following command:

conda install -c anaconda pyodbc

Step 2: Connect Your Python Script to SQLite

Next, you will need to connect your script to SQLite.

You may use this template to perform the connection:

Remember to import the pyodbc package first. Connect to the database using the connect method with the ODBC connection string for SQLite.

import pyodbc
conn = pyodbc.connect('Driver={SQLite3 ODBC Driver};'
                      'Server=server_name;'
                      'Database=database_name;'
                      'Trusted_Connection=yes;')

Step 3: Create Cursor from Your Connection

The cursor object created by cursor() allows you to execute queries.

cursor = conn.cursor()

Step 4: Create the Table in SQLite

Now you will be able to create your table in SQLite

For our example, here is the code that I used to create the table in SQL Server using Python: 

cursor.execute('''
 CREATE TABLE PeopleInfo (
        PersonId INTEGER PRIMARY KEY,
        FirstName TEXT NOT NULL,
        LastName  TEXT NOT NULL,
        Age INTEGER NULL,
        CreatedAt TEXT DEFAULT CURRENT_TIMESTAMP NOT NULL
 
);

               ''')

Step 5: Commit the Transaction

conn.commit()

Committing the transaction is an important topic to discuss.  The statement above explicitly commits the transaction.  If you do not commit the transaction, the database will not create the table.  The transaction will be rolled back.

 Other options to consider are:

 1 – Add the autocommit parameter to connect.  This will not require a manual commit.  For example:

con = pyodbc.connect(your_connection_string, autocommit = True)

2 – Use a with block and anything will be committed before the connection is terminated at the end of the with block.  For example:

with pyodbc.connect(your_connection_string) as con:
    CREATE_TABLE_CODE

Step 6: Insert Records to Verify Your Table is Configured Correctly.

cursor.execute('''
                INSERT INTO PeopleInfo (PersonId, FirstName, LastName, Age)
                VALUES
                (1,'Bob','Smith', 55),
                (2, 'Jenny','Smith', 66)
                ''')
conn.commit()

Step 7: Run a SELECT Query to Retrieve the Records.

cursor.execute('SELECT * FROM PeopleInfo')
for row in cursor:
    print(row)

Step 8: Close Your Connection If It Isn’t Needed.

conn.close()

Database connections are an expensive resource and there might be limited connections available to your database.  Remember to close your connection explicitly if you are not using a “with“ block as explained in Step 5.

Complete code:

import pyodbc
conn = pyodbc.connect('Driver={SQLite3 ODBC Driver};'
                      'Server=localhost;'
                      'Database=testDB.db;'
                      'Trusted_Connection=yes;')
cursor = conn.cursor()
cursor.execute('''
 CREATE TABLE PeopleInfo (
        PersonId INTEGER PRIMARY KEY,
        FirstName TEXT NOT NULL,
        LastName  TEXT NOT NULL,
        Age INTEGER NULL,
        CreatedAt TEXT DEFAULT CURRENT_TIMESTAMP NOT NULL
 
);

               ''')
conn.commit()

cursor.execute('''
                INSERT INTO PeopleInfo (PersonId, FirstName, LastName, Age)
                VALUES
                (1,'Bob','Smith', 55),
                (2, 'Jenny','Smith', 66)
                ''')
conn.commit()

cursor.execute('SELECT * FROM PeopleInfo ')
for row in cursor:
    print(row)

conn.close()

Output:

(1, 'Bob', 'Smith', 55, '2020-08-01 20:37:04')
(2, 'Jenny', 'Smith', 66, '2020-08-01 20:37:04')

References

1 – Pyodbc Github repo: https://github.com/mkleehammer/pyodbc

2 – Pyodbc Getting Started: https://code.google.com/archive/p/pyodbc/wikis/GettingStarted.wiki

3 – Create tables with SQLite: https://www.sqlitetutorial.net/sqlite-create-table/

4 – Write table into a CSV file: https://blog.finxter.com/how-to-convert-access-accdb-table-to-a-csv-in-python/

Programming Humor

Programming is 10% science, 20% ingenuity, and 70% getting the ingenuity to work with the science.

~~~

• Question: Why do Java programmers wear glasses?
• Answer: Because they cannot C# …!

Feel free to check out our blog article with more coding jokes.