Python Blogs

Python vs. Haskell vs. PHP - real world performance

mypy

Recently I had to optimize a legacy PHP cgi application, which worked fine but was too slow for its purpose. The main bottleneck was in selecting matching lines from a file containing about 15000 lines. Not finding a way to optimize PHP code I decided to change the language.
Two candidates were Python and Haskell. Knowing that Haskell is the only language out of three which compiles to machine code I expected it to be a clear winner, but I was up for a surprise...

Benchmark results:

PHP: 18ms (PHP 5.3.3)
Python: 4ms (Python 2.6)
Haskell: 38ms (compiled with ghc --make -dynamic -O2, ghc 6.12)

Code of the fast cgi application I benchmarked in 3 languages:

PHP code:

[code php]
define('MAX_NAMES', 30);
$handle = fopen("names.dat", "r");

$name = strtoupper($_REQUEST['q']);
$res = array();
$size = 0;

while (($customer_name = fgets($handle, 4096)) !== false) {
if (strpos($customer_name, $bank_name) !== false) {
$res[] = "'" . trim($customer_name) . "'";
$size += 1;
if ($size > MAX_NAMES + 1) {
break;
}
}
}

fclose($handle);
print '['.implode(',',$res).']';
[/code]

Python code:
[code python]
import cgi
import sys, os
from flup.server.fcgi import WSGIServer

MAX_NAMES = 30

def app(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
form = cgi.FieldStorage(fp=environ['wsgi.input'], environ=environ)
name = form["q"].value.upper()
output_names = []
count = 0

with open("names.dat") as f:
for line in f:
if name in line:
output_names.append(line.strip())
count += 1
if count > MAX_NAMES:
break

yield "['" + "','".join(output_names) + "']"

WSGIServer(app).run()
[/code]

Haskell code:
[code haskell]
import Control.Concurrent
import System.Posix.Process (getProcessID)
import Char
import Data.List
import Data.Maybe

import Network.FastCGI

compute :: CGI CGIResult
bankSuggest = do setHeader "Content-type" "text/plain"
q <- getInput "q"
let key = maybe "" (map Char.toUpper) q
let n = 30
fileContent <- liftIO $ readFile "names.dat"
let result = if key /= ""
then take n $ filter (Data.List.isInfixOf key) $ lines fileContent
else []
output $ "['" ++ intercalate "','" result ++ "']"

main = runFastCGIConcurrent' forkIO 1 compute
[/code]

Parameter q for this benchmark was selected to produce less than 30 entries, which is the most common case for this application. As a result lazy evaluation and early loop termination did not help the performance.

To sum up Python version is 4.5 times faster than PHP and almost 10 times faster than Haskell, which is pretty amazing.

Follow up:

As Don Stewart pointed out String type is quite slow in Haskell and a faster alternative would be to use ByteString.
So I've rewritten Haskell cgi using ByteString functions:

[code haskell]
import Control.Concurrent
import System.Posix.Process (getProcessID)
import Char
import Data.Maybe
import Data.ByteString.Char8 as BS

import Network.FastCGI

bankSuggest :: CGI CGIResult
bankSuggest = do setHeader "Content-type" "text/plain"
q <- getInput "q"
let key = BS.pack (maybe "" (Prelude.map Char.toUpper) q)
let n = 30
fileContent <- liftIO $ BS.readFile "names.dat"
let result = if key /= ""
then Prelude.take n $ Prelude.filter (BS.isInfixOf key) $ BS.lines fileContent
else []
output $ "['" ++ BS.unpack (BS.intercalate "','" result) ++ "']"

main = runFastCGIConcurrent' forkIO 1 bankSuggest
[/code]

New benchmark results:

PHP: 18ms (PHP 5.3.3)
Python: 4ms (Python 2.6)
Haskell using String: 38ms
(compiled with ghc --make -dynamic -O2, ghc 6.12)
Haskell using ByteString: 8ms
(compiled with ghc -XOverloadedStrings --make -dynamic -O2, ghc 6.12)

Indeed Haskell code using ByteString is 5 times faster than Haskell using String.
However it is still twice slower than Python!

Extract comments in your python code

sharmavivek82

Comments in your code are always good for new person to understand the logic and flow of program. I guess, people likes programming more, if they comment properly, same way as i do. Proper commenting will not allow you to read code line by line. The best way to comment is to comment in such a way, you can extract it easily. I do comments in my python code using '##' which makes me easy to extract them from script. Following code extracts my comment:

[code python]
import os
import sys
## python extract_comment.py filename comment_delimeter
filename = sys.argv[1]
sepr = sys.argv[2]
fl = open(filename,'r')
fl_con = fl.readlines()
for row in fl_con:
if sepr in row:
ind = row.find(sepr)
print row[ind:]

fl.close()
[/code]

copy the code in file extract_comment.py, filename is the python script from where you need to extract comments and comment_delimeter is '##' in my case.

Script en bash para actualizar y limpiar el sistema con apt-get

pythonista

Ya tengo algún tiempo con este pequeño script el cual en pocas palabras lo que hace es actualizarme la lista de paquetes en ubuntu e instalarme opcionalmente nuevos paquetes así como eliminarme paquetes en desuso y tratar de corregirme aquellos con dependecias incumplidas.

Pueden apreciarlo aquí:



#!/bin/bash



# Actualiza el sistema y remueve paquetes no necesarios

update() {

    echo -e "\n********** ACTUALIZANDO EL SISTEMA **********\n"

    echo -e "1. ACTUALIZANDO LA LISTA DE PAQUETES...\n"

    sudo apt-get update 1> /dev/null 

    echo -e "2. ACTUALIZANDO...\n"

    sudo apt-get upgrade

    echo -e "\n3. CHECANDO DEPENDENCIAS INCUMPLIDAS...\n"

    sudo apt-get check  1> /dev/null 

    echo -e "4. CORRIGIENDO DEPENDENCIAS INCUMPLIDAS...\n"

    sudo apt-get install -fy 1> /dev/null 

    echo -e "********** ELIMINADO PAQUETES BASURA **********\n"

    echo -e "5. DESINSTALANDO PAQUETES EN DESUSO...\n"

    sudo apt-get autoremove

    echo -e "\n6. BORRANDO ARCHIVOS DESCARGADOS...\n"

    sudo apt-get autoclean 1> /dev/null 

    echo -e "7. BORRANDO ARCHIVOS ANTIGUOS DESCARGADOS...\n"

    sudo apt-get clean 1> /dev/null 

}



sudo true

update

echo -e "********** ^^ LISTO ^^ **********"

sleep 1

clear



#mas info en [man apt-get] o [apt-get --help] (mas breve)

Por último les recomiendo que cualquier script que hagan, lo guarden en un directorio que este incluido en el $PATH esto es en la variable de entorno para las rutas. Para que lo puedan ejecutar desde la terminal, p.e. yo nombre a mi script "update", entonces cada vez que lo quiero ejecutar voy a la terminal y escribo:

update

y me da la sig. salida:

user@host:~$ update
[sudo] password for user:

********** ACTUALIZANDO EL SISTEMA **********

1. ACTUALIZANDO LA LISTA DE PAQUETES...

2. ACTUALIZANDO...

Leyendo lista de paquetes... Hecho
Creando árbol de dependencias
Leyendo la información de estado... Hecho
0 actualizados, 0 se instalarán, 0 para eliminar y 0 no actualizados.

3. CHECANDO DEPENDENCIAS INCUMPLIDAS...

4. CORRIGIENDO DEPENDENCIAS INCUMPLIDAS...

********** ELIMINADO PAQUETES BASURA **********

5. DESINSTALANDO PAQUETES EN DESUSO...

Leyendo lista de paquetes... Hecho
Creando árbol de dependencias
Leyendo la información de estado... Hecho
0 actualizados, 0 se instalarán, 0 para eliminar y 0 no actualizados.

6. BORRANDO ARCHIVOS DESCARGADOS...

7. BORRANDO ARCHIVOS ANTIGUOS DESCARGADOS...

********** ^^ LISTO ^^ **********

Recomendación:

Ejecuta este comando hasta que en todas las secciones te aparezca

0 actualizados, 0 se instalarán, 0 para eliminar y 0 no actualizados.

Esto significa que ya no hay paquetes por actualizar, instalar, eliminar y actualizar, y que por lo tanto 0 paquetes se actualizaron.

Dudas?, comentarios?

A Quiet Sense of Accomplishment - First GAE Application Using Bottle.py

numbercruncher

Now We Have Working Code On GAE!

I'm going to bed slightly later than expected tonight, but with a quiet sense of accomplishment.

As of about 30 minutes ago, I just uploaded and started a barebones version of my first Google App Engine app - a lemonade stand revenue calculator (editorial update: was originally website revenue calculator, had a more creative idea this morning). Enter some assumptions about your lemonade stand and it will predict how much money per hour you should be making. I'm using bottle.py as the framework behind the site and the application is a comic twist on my website revenue estimator (the original Non-GAE implementation is here, underlying business research is here).

Why I'm Interested In This...

My day job is in Analytics, where my team and I spend a lot of time coming up with "the formula" behind a business process. Once we have "the formula", we have three challenges:

Make it simple enough for non-analyst to use
Track formula predictions and decisions made (accept / reject our recommendations)
Ensure the formula is protected from malicious use (loss to competitor, internal circumvention)

Historically, analytics has always retreated "to our mountain top" to mine insights from data. Our ideas would then be shared with senior management, who would frequently broadcast them to their subordinates. Net result: everyone knows everything (fail goal #3), we track nothing everything is ad-hoc (fail #2), and we struggled with the first challenge.

The irony is that we're only talking about a formula: something that can be implemented in a handful of lines of Python!

Thus my interest in Python microframeworks. Bottle is a microframework that simplifies the task of setting up a basic web service. In simple terms, you define URL routes (http://mysite.com/path/variable) for a specific request; these are mapped to a python function (passing information from the request) which creates an appropriate response. Many microframeworks are very AJAX friendly (very easy to return data as JSON), opening the door to building simple web applications.

So... if I can code the formula in Python, I can deliver it as a webservice (or simple AJAX application). This protects the formula and will make the formula's implementation easier to use and supervise. One little bonus for bottle and GAE - they have a Google App Engine Adapter. This made the process a snap. Oh...and GAE has a free plan for smaller applications (see them for details). Which makes it attractive to students and hobbyist developers.

I've got a lot of polishing to do (particularly on the web design piece). Interestingly enough, the calculator framework has been relatively easy to edit - I was able to flip the application's entire purpose over lunch (from a website profit estimator into the lemonade stand version). It's just a form and a formula - very easy to edit!

C�digo en python para hacer "La criba de Erat�stenes"

pythonista

Bueno como ya es de saberse en cada uno de los post donde exponga algún código de python sera de la versión 3.1 ó >, entonces no cabe la necesidad de estar mencionando la versión del lenguaje en el título del post.

Les presento un par de algoritmos muy parecidos ya que los dos usan la llamada criba de Eratóstenes para "cribar" los números primos de una sequencia de números. Ambos usan una sequencia 1..2000000.

La criba de Eratóstenes

Nota:

Si conoces algún algoritmo más eficiente tienes la libertad de comentarlo, gracias

[code python]
#inicializamos el tamano de la sequencia de numeros
n = 2000000
#se usa un conjunto porque es mas eficiente
#(no hay numeros repetidos)
noprimos = set()

#iteramos desde 2 hasta la raiz cuadrada de n
#y desde lo que lleva i, hasta n / i
#esto nos permite obtener todos los multiplos de i
#y agregarlos a el conjunto noprimos
for i in range(2, int(n ** .5) + 1):
if i not in noprimos:
for j in range(i, int(n / i) + 1): noprimos.add(i * j)

#por ultimo creamos una lista con todos los numeros
#primos desde 2 hasta n
primos = [p for p in range(2, n + 1) if p not in noprimos]
[/code]

Créditos:

http://es.wikipedia.org/wiki/Criba_de_Eratóstenes

y aquí esta el otro que a mi parecer es más eficiente

[code python]
#inicializamos la criba como una lista con n elementos True
criba = [True] * n

#iteramos desde 2 hasta la raiz cuadrada de n
#y desde lo que lleva i, por i, hasta n
for i in range(2, int(n ** .5) + 1):
for j in range(i * i, n + 1, i):
#esto nos permite poner False en la posicion j - i de la criba
#porque j es un multiplo de i y por lo tanto no es primo
criba[j - 1] = False

#por ultimo "cribamos" todos los numeros primos desde 2
#hasta la longitud de la criba
primos = [p for p in range(2, len(criba) + 1) if criba[p - 1])]
[/code]

Créditos:

http://www.s-anand.net/euler.html

Funciones para convertir de decimal a binario

pythonista

He encontrado 2 buenos algoritmos para convertir un numero decimal a binario a través de estas funciones que reciben el numero entero en base 10 a convertir y devuelven una cadena de caractéres con los dígitos del mismo número ya convertido a base 2.

Python versión 2.7

[code python]
def binario1(n):
"""este primer algoritmo utiliza la formula n = 2k + b"""
if n == 0 or n == 1: return str(n)
k = n / 2
E = binario1(k)
b = n % 2
return str(E) + str(b)

def binario2(n):
"""y este va recorriendo 1 bit hacia la derecha en cada iteracion"""
if n == 0: return str(n)
b = ''
while n > 0:
b = str(n % 2) + b
n >>= 1
#de esta forma el numero se va dividiendo entre 2 para llegar a 0
#y terminar el bucle
#tambien podria ser de esta forma
#n /= 2
return b [/code]

Siéntente libre de comentar que te parecieron y si conoces algún otro te invito a publicarlo, gracias

Random Password Generation in Python

hayathms

Auto Password Generating In Python

Here is the code for simple auto password generating in python using any string like first name, or username or anything .

import random

def gen_random_password(string_letters):
string_letters = string_letters.replace(' ','')
string_letters = string_letters.replace('.','')
a = random.choice(string_letters)
b = random.choice(string_letters)
c = random.choice(string_letters)
d = random.choice(string_letters)
e = str(random.randint(100,500))
f = str(random.randint(500,1000))
return a+e+b+f+c+d]

And Please comment me how strong password can be generated using my above code. :)

Python for Newbies: A Simple Anagram Finder

numbercruncher

Once you get past Hello World, there are a several good entry points for a new Python developer to get acquainted with the language. Three areas which really helped me were simple math problems, the Python challenge, and writing some word game solvers.

The best source of basic math problems for a new python developer is Project Euler. This site is basically an online math test - where you need to write a small program to perform the required calculations. Most of these problems can be solved by a new developer in under an hour (some faster). It will broaden your understanding of mathematics and give you a good grounding in basic Python.

The Python Challenge is another good learning environment. The participant is presented with a web page that contains a riddle, with clues buried somewhere on the page. Your job is to use Python to solve the riddle. This generally requiring you to take a deep dive into one of the modules in the Standard Library. We've used this as a warmup exercise in one of the meetups I attend - I can recall doing modules around regular expressions, urllib (simple web scraping), and image processing.

My deepest dive into the language occured when I started doing some "code doodling" around solving word puzzles. For example, the script below takes a list of words and searches a dictionary to identify their anagrams. For a dictionary, I opted to use Enable (Google hosts a copy of it - look for enable.txt on the Google Code directory behind this link).

A couple of insights made this script possible:

Exact anagrams of a word have the same number of letters - just in a different order. If you sort the letters of each word in the dictionary into alphabetical order (eg. cart => acrt), words that are anagrams of each other will have the same value.
This guides us towards a solution. Use Python's sort function to map the anagrams in a list of words into a common key; then construct a dictionary using this common key to accumulate a list of anagrams mapped to that value.
The anagrams for a particular word can be retrieved using the "get" method of the dictionary.
Finally - just for fun - we use Python's map function to demonstrate how you can run this check for a whole list of candidates

Since it's five o'clock somewhere, I opted to run this script against a list of beverages.

[code python]

testlist = ["wine","beer","mead","liquor","scotch","gin","whiskey","rum"]

def gethandle(word):
return ("").join(sorted(word))

anagrams={}

wordlist =open("enable1.txt")
for item in wordlist:
handle = gethandle(item.strip())
if handle not in anagrams:
anagrams[handle] = [item.strip()]
else:
anagrams[handle].append(item.strip())

def testforanagrams(word):
results = anagrams.get(gethandle(word),[])

if len(results)>1:
print word, ":",", ".join([item for item in results if item != word])
else:
print word, ":", "None"

map(testforanagrams,testlist)

[/code]

producing the following output:

[code python]

wine : None
beer : bree
mead : dame, made
liquor : None
scotch : None
gin : None
whiskey : None
rum : None

[/code]

This is a fairly basic and slightly verbose script and there are a number of ways to improve upon it. I'll suggest a couple of the more obvious ones, the implementation of which is left as an exercise for the student.

First, it could benefit by reorganizing all of the code into proper functions. Several elements of the script execute sequentially with the script vs. being packaged into reusable functions. I'd actually recommend reorganizing the entire script into a class object. This neatly encapsulates the above activities and helps you separate the act of loading the dataset from searching the dataset. From a performance perspective, you spend a lot of IO and CPU time parsing and loading the initial dictionary. If you operated this as some type of "service", you should leverage this setup time across as many requests as possible.

On a personal note, this little script actually got me started on a larger journey - involving two additional steps.

Once I had a basic anagram finder, I started looking at adding other word games into the package. This forced me to do some optimization around the underlying algorithm using several articles I found on Python data structures and processing performance. In the process, I was able to learn a lot about how to benchmark the memory usage and CPU speed for a Python program. While the final product was much more complicated, it was a lean, mean "word searching machine".

While I was building the class object, I was also learning about several python web frameworks for work and wanted to find a safe test project. Once I built the word search class object, I used a web framework to link a URL Route (/solveword) to a class method (solve-word function). This provided me with the server-side chassis for a word game solver website (the first "production grade" solver I wrote is here, a fancier version of the solver is here). I gave a talk on this project at my local Python meetup (overview and slides are here). This series of steps actually prompted me to learn a lot more than Python - HTML, CSS, Jquery, basic devops, etc...

Don't be afraid of taking little steps when learning a new language. Little steps and silly problems (eg. anagram finding, finding palindromes, many of the other Project Euler exercises) are frequently the gateway to working on more serious applications. Having "code in production" tends to prompt you to create more code - forcing you to learn more than you ever expected about topics you never knew existed until they were suddenly relevant to bringing your baby to life. Silly little steps sometimes can turn into respectable deliverables....

Comprehending List Comprehensions

numbercruncher

List comprehensions are often a bit intimidating to developers who are new to Python. They are really much friendlier than that :) It's just a way to repackage that pile of for-loops, if-then statements, and calculation logic which is littering your current code. Here's a simple example to put them in perspective.

Assume I have a list of data - (1,2,3,4,5,6....n).

Now, there are a couple of very common "building block" transformations which we can apply to this dataset. I can create a new list by doing each of the following (alone or in combinator with each other):

Applying a specific transformation to each element of the existing list (eg. add one to each item, take the cosine of each item, etc.); you do this with a for-loop and some basic calculation logic in many languages....
Applying a Boolean test (also a mathematical operation, in a sense) to each element of the existing list and rejecting any element that does not pass that test. This is commonly handled by including an if-if statement in the for-loop...

Notice something in common here? We're defining a mathematical operation and applying it to each element of a list.

What Python construct do we use to encapsulate mathematical operations? Yes, You in the back. Right, Functions...

What if there were a way to succinctly summarize a mathematical operation as a function and apply it to each element of a Python list. Guess what, you're in luck. This is where Python's functional programming constructs come into play - which include two functions that are designed to take a list and another function (as arguments) and create a new list by applying that function to every element of the intial list. These two functions are:

Map (function, list) - takes a list, applies the function to each element of the list to get a new value, returns a list of those values
Filter (function, list) - applies a test function (returns True / False) to each element of the list, keeps only items that return true

Entry level list comprehensions are just a one-liner way of expressing this.

Consider the following:

[code python]

initial_list = [1,2,3,4,5]

my_func = lambda x: x * x

[/code]

We can use for-loops and if-then logic to create a new list using the following in Python or - with minor syntax edits - many other languages, such as Visual Basic and C / C++:

[code python]

new_list = []

for element in initial_list:

if element > 5:

new_list.append(my_func(element))

[/code]

There's nothing obviously wrong with this - I mean, we get to write lots of "lines of code" so the boss feels good, right?

If we wanted to take advantage of Python's functional programming tools, we could also write this as:

[code python]

new_list = map(my_func,filter(lambda x:x>5, initial_list))

[/code]

Yuck...we've got it down to one line but now I have to think about it when I read it!

Or you could express it as a one line list comprehension:

[code python]

new_list = [my_func(item) for item in initial_list if item > 5]

[/code]

Ahh...much easier to parse.

The appeal of using a list comprehension is your code is more succinct and easy to read.

This is a simple example. I recommend you take a look at the Python docs on functional programming and list comprehensions for a much richer view of the many things you can do with this tool. But hopefully now you can map this concept back to a familiar technique.

IDLE Easter Egg...

numbercruncher

Presented without comment, aside from the fact that this made me laugh on an otherwise frustrating day...

[code python]

import antigravity

[/code]

Update: I found an article talking about this, with a comment from the BDFL...

Python Coding Standards

ugkarthik

Coding standards is not only to avoid ugly code. It is very useful to get responses quickly.

You can see the python coding standards in PEP8.

There are many third party packages to test standards you used in your modules. Especially pylint package is very simple to use.

To install pylint follow the link http://pypi.python.org/pypi/pylint.

Examples:

Here I write two modules having same logic. First one(ws.py) is written with standards and another one(wos.py) is not having standards.

#### With Standards (ws.py) ####

"""
Test the coding standards

"""

from datetime import datetime, timedelta

def with_standard():
"""

Test the coding standards

"""

st_time = datetime.\
now()
data = {'los':30,
'san':60,
'can':80,
'New':20}
for city, provider_count in data.\
iteritems():
if (city != '' and \
provider_count < 100):
pass
end_time = (datetime.\
now() - timedelta(hours=st_time.hour,
seconds=st_time.second,
microseconds=st_time.microsecond))
print "To get response the script took %s \
(Hour:Minutes:Seconds MicroSeconds)" % (end_time.\
strftime('%H:%M:%S %f'))
return ()

if __name__ == '__main__':
with_standard()

### End of Module ###

### Without standards (wos.py) ###

from datetime import datetime,timedelta

def without_standard():
st_time = datetime.now()
data = {'los':30,'san':60,'can':80,'New':20}
for key,value in data.iteritems():
if key != '' and value < 100:
pass
end_time = datetime.now() - timedelta(hours=st_time.hour,seconds=st_time.second,microseconds=st_time.microsecond)
print "To get response the script took %s (Hour:Minutes:Seconds MicroSeconds)" %(end_time.strftime('%H:%M:%S %f'))
return ()

if __name__ == '__main__':
without_standard()

### End of Module ###

Test standards:

If we execute pylint ws.py command from command line, it will give 10.00/10 as the standards rate.

When we execute pylint wos.py command, it will give 3.85/10 as the rate.

Now you can see a huge difference between standards' rate.

So try to follow standards in your future modules :)

JQuery and python script

sharmavivek82

Recently i have implemented JQuery in one of the site created through python CGI. I googled a lot about it and got very easy solution to this.
I guess, this can be used in any site where we need to call python script.

[code python]

$("#AnyID").click(function()
{
$.ajax({
type: "get",
url: "<your-python-script>.py",
data: {'param1':'abc'},
datatype:"script",
async: false,
success: function(response) {
// response is string, convert it to json and apply conditions.
var json_obj= eval('(' + response + ')');//$.parseJSON("'"+response+"'");
if (json_obj.type == 'Error'){
alert(json_obj.msg);
}
else {
alert(json_obj.msg);
}// else closed
}, // success closed
error:function(xhr,err)
{
alert("Error connecting to server, please contact system administator.");
}
})//ajax closed
}
[/code]
make sure that your python script is callable through url ex. www.example.com/<your-python-script>.py
What i did is, in my <your-python-script>.py script i return dictionary object like {'type':'Success', 'msg':'Your message'}.
If you have CGI script, dont return anything just print the dictionary.

JQuery ajax for python only supports get method for now (i found somewhere, i tried with POST, not working).
here, in above code, you can see "async:false", the purpose of it is very interesting.
While your JQuery run python script and fetch data for you, if you want to block any click event, use "async:true", interesting.. isn't it?

Timer Help Python 2.5

mike

Does anyone know how to make a Timer function in Python 2.5. Cancel or .cancel() only stops the Timer while in execution, but how do you stop the Timer or threading after execution is finished. This is what I made for a timer, but it locks up the program.

def main():
import time
import threading
global time
global threading
global stoneskinT

stoneskinT = threading.Timer(5.0, stoneskin)
stoneskinT.start()
string = raw_input ("... ")
stoneskinT.cancel()

while (string == ""):
stoneskinT = threading.Timer(5.0, stoneskin)
stoneskinT.start()
string = raw_input ("... ")
stoneskinT.cancel()

def stoneskin():
global string
global stoneskinT
print "Potion of stoneskin has worn off."
string = raw_input ("... ")
main()

Run Python script method using eval statement

sharmavivek82

Recently i did excellent work around to run python script using eval statement.
[code python]p_obj = eval(<python script name>, globals()),<arguments passed to script> [/code]
Now, you can run any method inside the script by calling p_obj.run()

Simple Web Server in python

sharmavivek82

Recently, I was hanging arround flex codes which calls python script resides on other server through web services. I got confused, Is it a good idea to use web service just to call python script from other server? Why not to use cgi module or mod-python to get the same result as getting through web services?

So i decided to write a simple web server which has some methods to be called as a URL. Got excellent help from
http://fragments.turtlemeat.com/pythonwebserver.php
then, i added some code.
[code python]

import string,cgi,time
from os import curdir, sep
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer

class VivekServer(BaseHTTPRequestHandler):

def do_GET(self):
try:
if self.path == '/fetch':
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
res = self.wcount()
self.wfile.write("Number of count for 'anyword' :")
self.wfile.write(res[0])
self.wfile.write(" url is :")
self.wfile.write(res[1])
return
if self.path == '/calculate':
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
res = self.calculate()
for each in res:
self.wfile.write(each)
self.wfile.write('\n')
return

return

except IOError:
self.send_error(404,'File Not Found: %s' % self.path)

def calculate(self):
import random
WORD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
data = []
for i in range(1, 100):
data.append((random.randrange(0, 1000), random.sample(WORD, len(WORD))[0]))
return data

def do_POST(self):
pass

def wcount(self):
from BeautifulSoup import BeautifulSoup as soup
import urllib2

htm = 'http://www.anyurl.com'
html_text = urllib2.urlopen( htm ) .read()
sp = soup(html_text)
idea = sp.findAll( "anyword" )
all_a = [ each.get('href') for each in sp.findAll('a') ]
num = 0
for each in all_a:
if each.find("anyword") > 0:
num=num+1
return (idea,num,htm)

def main():
try:
server = HTTPServer(('', 7999), VivekServer)
print 'Server Started.....'
server.serve_forever()
except KeyboardInterrupt:
print 'Server Ends.....'
server.socket.close()

if __name__ == '__main__':
main()

[/code]

This is just a help to start a simple web server and call your method through url.

To run above code, just do, python abovecode.py

open web browser, type url as
http://localhost:7999/fetch
http://localhost:7999/calculate