A collection of software related insights

Python compiled is worse than pure Python?

linuxcoding1 — Sun, 13 Sep 2009 21:24:46 +0000

So lately I’ve been playing with python, and obviously one of the first things you do when you start to use a new language is make a prime number generator. I did this using the ‘Sieve of Eratosthenes’. Here is the code (Bearing in mind this is one of my first attempts in python, so I have no idea if it is efficient or to standards)

def GetPrimeNumbers(Amount):
	Primes = []
	NPrime = dict()
	Total = 0
	Current = 2
	while Total <= Amount:
		try:
			NPrime[str(Current)]
		except KeyError:
			IsPrime = 1
		else:
			IsPrime = 0
		x=1;
		while x < Amount:
			NPrime[str(x*Current)] = [1]
			x+=1
		if IsPrime == 1:
			Primes.append(Current)
			Total+=1
		Current+=1
	return Primes

Now this took no time at all for 100 primes, but it took around a minute for 1000. I remembered hearing about CxFreeze, which is a python compiler, so I decided to use it and see if it would increase the speed. Now interestingly, this is what I got:

Generating Primes using Python and CxFreeze

Python:
100 primes :	real    0m0.123s
			user    0m0.112s
			sys     0m0.004s

1000 primes:	real    0m53.467s
			user    0m48.631s
			sys     0m0.512s

Compiled Python:
100 primes:	real    0m0.139s
			user    0m0.124s
			sys     0m0.012s

1000 primes:	real    1m0.173s
			user    0m54.163s
			sys     0m0.576s

Pure C (Slightly different algorithm):
100 primes:	real    0m0.002s
			user    0m0.000s
			sys     0m0.004s

1000 primes:	real    0m0.052s
			user    0m0.028s
			sys     0m0.004s

Now this got me thinking;

1. If I ever need to generate prime numbers, I’m going to use C.

2. The compiled python seemed to increase the time.

The answer to the latter becomes obvious from the output of CxFreeze, which seems to add every default python library to the executable, even if they are not used. So it seems that the only reason you should use CxFreeze is if you are adamant to not have to install python on a clients computer, and if you are using prime numbers, use C.

def GetPrimeNumbers(Amount):
Primes = []
NPrime = dict()
Total = 0
Current = 2
while Total <= Amount:
try:
NPrime[str(Current)]
except KeyError:
IsPrime = 1
else:
IsPrime = 0
x=1;
while x < Amount:
NPrime[str(x*Current)] = [1]
x+=1
if IsPrime == 1:
Primes.append(Current)
Total+=1
Current+=1
retun Primes

Python Music Daemon

linuxcoding1 — Wed, 09 Sep 2009 20:48:09 +0000

So yesterday I was contemplating what to try to develop using python, and found the python gstreamer wrappers. Seeing as how it is rather hard to put music into php applications, I decided to make a daemon, which the php script could easily access. The code currently is very basic, probably not very good looking, as it is my first real shot at python, but the source is below. It uses the python-twisted library, and listens on a port for an incoming connection, and then takes commands from that connection. Please feel free to add your opinions or criticisms.

import sys, os
import pygtk, gtk, gobject
import pygst
pygst.require("0.10")
import gst
from string import *
import re
from twisted.internet.protocol import Protocol, Factory
from twisted.internet import reactor
from twisted.internet import gtk2reactor # for gtk-2.0

class Music(Protocol):

	def dataReceived(self, data):
		data = re.sub('\r\n', "", data)
		arr =  split(data, " ")

		if arr[0] == "play":
			self.play()
		elif arr[0] == "load":
			self.load_file(data[5:])
		elif data == "pause":
			self.pause()
		elif data == "resume":
			self.unpause()
		elif arr[0] == "get":
			if arr[1] == "state":
				self.get_state()
			if arr[1] == "duration":
				self.get_duration()
			if arr[1] == "position":
				self.get_position()
		elif arr[0] == "seek":
			self.seek(arr[1])
		elif arr[0] == "seekn":
			self.seekn(arr[1])
		elif data == "quit":
			self.transport.write("closing session\r\n")
			self.transport.loseConnection()
			self.player.set_state(gst.STATE_NULL)
		else:
			self.transport.write("unrecognized command")

	def load_file(self, file):
		if os.path.isfile(file):
			self.player.set_state(gst.STATE_NULL)
			self.transport.write("Loading file %s\r\n" % file)
			self.player.set_property("uri", "file://" + file)
			self.player.set_state(gst.STATE_PLAYING)
			self.player.set_state(gst.STATE_PAUSED)

	def seekn(self, nseconds):
		self.player.seek_simple(self.time_format, gst.SEEK_FLAG_FLUSH, nseconds)

	def connectionMade(self):
		self.transport.write("connected\r\n")
		self.player = gst.element_factory_make("playbin", "player")
		fakesink = gst.element_factory_make("fakesink", "fakesink")
		self.player.set_property("video-sink", fakesink)
		bus = self.player.get_bus()
		bus.add_signal_watch()
		bus.connect("message", self.message)

		self.current_state = "STATE_NULL"
		self.time_format = gst.Format(gst.FORMAT_TIME)

	def connectionLost(self, data):
		self.player.set_state(gst.STATE_NULL)

	def message(self, bus, message):
		t = message.type
		if t == gst.MESSAGE_EOS:
			self.player.set_state(gst.STATE_NULL)
		elif t == gst.MESSAGE_ERROR:
			self.player.set_state(gst.STATE_NULL)
			err, debug = message.parse_error()
			print "Error: %s" % err, debug

	def play(self):
		self.player.set_state(gst.STATE_PLAYING)
		self.current_state = "STATE_PLAYING"

	def pause(self):
		self.player.set_state(gst.STATE_PAUSED)
		self.current_state = "STATE_PAUSED"

	def unpause(self):
		self.player.set_state(gst.STATE_PLAYING)
		self.current_state = "STATE_PLAYING"

	def get_state(self):
		self.transport.write(self.current_state)

	def convert_ns(self, time_int):
		time_int = time_int / 1000000000
		return time_int

	def seek(self, seconds):
		sec = int(seconds)
		seek_ns = sec * 1000000000
		self.player.seek_simple(self.time_format, gst.SEEK_FLAG_FLUSH, seek_ns)

	def get_duration(self):
		#self.player.set_state(gst.STATE_PAUSED)
		#pos_int = self.player.query_position(gst.Format(gst.FORMAT_TIME), None)[0]
		dur_int = self.player.query_duration(gst.Format(gst.FORMAT_TIME), None)[0]
		dur = str(self.convert_ns(dur_int))
		self.transport.write(dur)
		#self.player.set_state(gst.STATE_PLAYING)

	def get_position(self):
		#self.player.set_state(gst.STATE_PAUSED)
		pos_int = self.player.query_position(gst.Format(gst.FORMAT_TIME), None)[0]
		pos = self.convert_ns(pos_int)
		self.transport.write(str(pos))
		#self.player.set_state(gst.STATE_PLAYING)

factory = Factory()
factory.protocol = Music

reactor.listenTCP(8007, factory)

reactor.run()

Python

linuxcoding1 — Tue, 08 Sep 2009 20:28:36 +0000

With most of my programming experience being with Php, (mostly command line, I have no need for the web based stuff) I have been checking out python, and it seems a rather nice toy to play with. If anyone else has gone from Php to python, they will probably agree that the hardest thing to get to grips with is the huge difference in syntax. From curlies, to indents, this is possibly one of the most abstract ideas for syntax I have used. I also know some C and C++, and I’ve read that python and C can be linked, which is also quite a nice feature. The only roadblock I have is what to make. If anyone has an idea feel free to post.

Hello world!

linuxcoding1 — Tue, 08 Sep 2009 20:15:00 +0000

Hello world seems to be a good place to start, as with most programming languages, it is the standard. I have decided to make a blog, to talk about nice things like linux (with my favorite being ubuntu) and programming, because in my opinion, both of these topics need more exposure, and if my tiny corner of the interwebs educates a few people, then I’ll be happy.

I’m also hoping to use this blog as a place to put some of the ideas, and or, programs that I have. So if you have stumbled across here, please feel free to leave a comment.

Cameron