Python: Making Objects Callable

Problem Statement: Have you ever wandered if we could make an object callable? Yes, I mean just use the object name as if you were calling function! Intersted?
Here's a simple solution!

Solution:
class Add:
#class for addition
 def __init__(self, num1, num2):
  self.num1 = num1
  self.num2 = num2
  print "Sum of", self.num1, "and", self.num2, "is:"

 def __call__(self):
  return (self.num1 + self.num2)

add = Add(1,2)
print add()

Output:
Sum of 1 and 2 is:
3

Explanation:
In this example, when 'add' is created using add = Add(1,2), def __init__() is called, since the constructor is called while object is getting created.
Because of the attribute __call__, the object becomes callable and hence we could use as add(). when add() is used, def __call__() is called.

Hope it's clear!

Python: Knowing the path of the currently running script

Problem Statement:

When we deal with frameworks, how often do we have to import modules. And it doesn't stop there; there arises a need where the imported would in turn import an another module, right? Would debugging an error condition be easy in these cases. If you have dealt with frameworks before, you would definitely understand the complexity of finding the fault location (exact module where the fault lies). Often people using logging mechanisms where they print to a file and start debugging. Wouldn't it be simple if we have a single line of code, just to tell which module is currently running? Was the first module being run when error occurred or was it the second module?

Solution:

Solution to this problem is fairly simple. Use of __file__ attribute in python.

__file__ attribute gets you information on the currently running script/module. Let's demonstrate this with an example. Consider, we have a parent script Main.py which imports a module called Module.py. Codes would like these:

Main.py

import Module

from Module import method

print "We're in %r" %__file__

Module.method()

Module.py

def method():

  import os

  f = open("C:\\sample.txt", "w")

  f.write('This is a sample file')

  print "We're in %r" %__file__

  f.close()

  os.system("del C:\\sample.txt")

Now, if we run the parent script Main.py, on command prompt, the output that we get is:

Output:

C:\Python26>Main.py

We're in 'C:\\Python26\\Main.py'
We're in 'C:\\Python26\\Module.py'

When the Main.py was running, __file__ gave us the path of current running script, but when the Module.py was imported and then __file__ was used, it gave the path of the module, and not the path of the parent script.

Utility:

- We can easily find the path of the current running script.

- Also we can easily find out which module is currently being run. This helps in easy debugging.

Python: MVC Pattern Example

Problem Statement: Demonstarte with example, Model-View-Controller Design pattern.

Script:

import sqlite3

class MVCModel:

def request(self, id):

# Would query database...

conn = sqlite3.connect('querydb')

c = conn.cursor()

results = c.execute('''select name from data where id = %d''' %id)

conn.commit()

c.close()

for row in results:

name = row[0]

return { "id" : id, "name": name}

class MVCController:

def __init__(self):

self.model = MVCModel()

self.view = MVCView()

def main(self):

post = self.model.request(1)

self.view.show(post)

class MVCView:

def show(self, post):

print "%(id)s %(name)s" % post

Controller = MVCController()

Controller.main()

Consistent to MVC Pattern,

the model runs a business logic that pings a database for an id and gets the corresponding name,

the controller accepts the request, sends it to the model, receives the return data from model and communicates to the view,

and the view represents the return data.

You could find a similar example on stackoverflow.

DOS: Create a 0KB file

Problem Statement:

I want to create a 0KB file using a DOS Command.

Here's how to do it:

Just Run->cmd and type in

goto >> "Filepath"

Since goto doesn't lead to any code execution its a command that is successful and since there is no return of the goto command, there is no data added to the file and hence the filesize is 0KB. Solves the purpose!

Just a try!

One could try "cls >> "Filepath" "; but this doesn't work as it adds a binary character in the file to be created.