Aaron Toponce » Python

Largest Palindromic Number In Python

Aaron — Sat, 15 Sep 2007 20:53:39 +0000

I found the absolute best way to learn the Python programming language, while at the same time, increasing deductive logic capacity and learning mathematics. The way is through Project Euler. Of course, you don’t have to use the Python language to complete the problems. You can use any language you like, or use pencil and paper if that suits your needs best.

At any event, I’m going through the problems one by one, and have completed the first 4. The fourth problem took a great deal of thinking to get right, but I nailed it out slowly, and actually came up with a pretty fast solution. The problem is this:

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 99.
Find the largest palindrome made from the product of two 3-digit numbers.

After hacking a bit, I realized that the only way I knew how to solve this problem, was to brute force it. Some things came to mind almost immediately:

I should start with 999 * 999 and count down, rather than 100 * 100 and count up, seeing as though I’m looking for the largest palindromic number.
999 * 999 = 998001 iterations through every number, but I will be testing each one at least twice, so I only need to test half (999 * 999, 999 * 998, 999 * 997, … 999*100, 998 * 998, 998 * 997, … 998 * 100, 997 * 997, 997 * 996, …, etc)
There should a pattern with palindromic numbers to further increase my algorithm.

Point 3 was the hardest for me to find, but I found it. There is in fact a pattern with 6-digit palindromic numbers (technically speaking, any even-digit palindrome (I know that my result will be 6-digits, or at least I’m fairly confident)). Consider the palindrome “abccba”:

Let's look at the numeric column of each letter:

a(100,000) + b(10,000) + c(1,000) + c(100) + b(10) + a(1)

Adding similar variables (in algebraic notation):

100001a + 10010b + 1100c

The common denominator is 11:

11(9091a + 910b + 100c)

This means that each palindrome will be a multiple of 11.

This means that I can start with 999 * 990 for my first test, 999 * 979 for my second, 999 * 968 for my third, and so on. This will greatly reduce the number of iterations that I need to step through when finding this palindromic number. It wasn’t long, however, that I realized this problem will need to be separated into two functions. One to determine if the number is in fact a palindrome, returning either True or False, and the second function to iterate through all the possible product combinations, filling an array with nothing but palindromic numbers. Here is my solution:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#!/usr/bin/env python
def is_palin(string):
"""Returns true if a string is a palindrome"""
start, end = 0, len(string) - 1
while end > start:
if string[start] != string[end]:
return False
start += 1
end -= 1
return True

def palindrome():
"""Finds the largest palindrome that is the product of 2 3-digit numbers"""
num1 = 999
result_arr = []
while num1 > 100:
num2 = 990
if num2 > num1:
num2 = num1 - (num1 % 11)
while num2 > 109:
if is_palin(str(num1 * num2)):
result_arr.append(num1 * num2)
num2 -= 11
num1 -= 1
result_arr.sort()
print result_arr[len(result_arr) - 1]

palindrome()

A couple comments about the code. First, I’m turning the number into a string, then determining if that string is in fact a palindrome. I look at the beginning and ending letter of the string. If they match, I increase the beginning letter by 1 and decrease the ending letter by one, and test again if they match. I continue to do this throughout the string until every letter was tested. If they all passed, return True, otherwise, return False. Second, to keep my algorithm only churning through half of the required iterations, I want to make sure that I start with the square, and work down from there. For example:

View with a monospace font, or this table won't make much sense (see the original post):

999*990    998*990    997*990    ...    990*990
999*979    998*979    997*979    ...    990*979    989*979    988*979    987*979    etc.
999*968    998*968    997*968    ...    990*968    989*968    988*968    987*968
  ...        ...        ...      ...      ...        ...        ...        ...
999*121    998*121    997*121    ...    990*121    989*121    988*121    987*121
999*110    998*110    997*110    ...    990*110    989*110    988*110    987*110

The only aspect about my algorithm, was that I am not breaking out when I find the largest palindromic number. The reason for this was simple- I got too caught up in churning through every 11 numbers, that I forgot to test when I found the largest. However, after looking at the code, I figured that I was curious about all the palindromes that I have found, so I stored them in an array then sorted it ascending. It is interesting to look through the array at each one, seeing the patterns throughout.

At any rate, on my machine, I benchmarked the code:

aaron@kratos:~$ time python palindrome.py
906609

real    0m0.067s
user    0m0.068s
sys     0m0.000s

Nice and lean. 0.067 seconds isn’t bad for a first attempt, I think. Thoughts? Comments?

Prime Numbers In Python

Aaron — Wed, 05 Sep 2007 21:41:41 +0000

The following program returns True if a number is prime or False otherwise. I am proud of this code, as it implements dead code. Upon the first positive condition in the if statement nested in the while loop, the program terminates, ignoring any further code following. As far as I can tell, this is the most efficient way (not necessarily the fastest) to test if a number is prime or not. ~~This means that this function has an order of O(n-2) (it doesn’t test against 1 and itself) as a worst case scenario, and O(n/m) where m is the first factor of n as a best case.~~ As elementary as it is, I think it’s pretty slick. All handled in 9 very readable lines of code.

UPDATE: Thanks to some observant readers, I have come to the realization that I only need to loop to the square root of n, and not n, as the square root of n is the largest factor. This brings the order to O(sqrt(n)-2) at the worst case scenario, and O(1) as the best case.

1
2
3
4
5
6
7
8
9

def is_prime(n):
import math
n = abs(n)
i = 2
while i <= math.sqrt(n):
if n % i == 0:
return False
i += 1
return True

Recursion In Python

Aaron — Thu, 09 Aug 2007 12:58:59 +0000

I took my Perl script that I wrote some time ago, and rewrote it in Python. The exercise of the initial Perl script, was to get a better handle on the language using recursion, and to inventory my Ogg Vorbis collection of music. The same reasons were used for this Python version. This script traverses a directory tree, full of Ogg Vorbis files, printing out to a file in indented form, the contents, and counting the number of Ogg Vorbis files it comes across. You’ll notice the lack of comments, as I find Python code much more readable than Perl code. It should be fairly obvious what this script is doing.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#!/usr/bin/env python
import dircache, os
counter = 0

def PrintFiles(indent):
global counter
thisDir = os.getcwd()

for file in dircache.listdir(thisDir):
if (file.endswith('ogg') or os.path.isdir(file)) and not file.startswith('.'):
if file.endswith('ogg'):
counter += 1

oggFile.write('%s%s\n' %(indent, file))

if os.path.isdir(file):
os.chdir(file)
PrintFiles(indent + ' ')
os.chdir('../')

try:
oggFile = open('oggfiles.txt', 'w')
except IOError, e:
print "Unable to open 'oggfiles.txt' for writing: ", e
else:
PrintFiles('')
oggFile.write('\nCurrent number of ogg files: %d\n\n' %(counter))
oggFile.close()

29 And Holding

Aaron — Sat, 09 Jun 2007 13:31:42 +0000

1
2
3
4
5
6
7
8
9
10
11
12

from datetime import date

birth_day = date(1977, 6, 9)
right_now = date.today()

if (right_now.month >= birth_day.month) & (right_now.day >= birth_day.day):
age = right_now.year - birth_day.year
else:
age = right_now.year - birth_day.year - 1

if age >= 30:
age = 29

Poll: First Programming Language?

Aaron — Tue, 13 Mar 2007 16:47:19 +0000

My coworker asked me this question, and began asking a few others in a couple IRC channels. So, I thought I’d extend it to my blog, and the planets that I syndicate. I added as many choices as I could hoping to see a wide array of votes. I added a few newer languages for the younger audience.

For me, my first language that I sat down and learned in a formal setting was Java. However, I had TI, Casio, and HP calculators, as well as an Atari 800 that I would fiddle with, and program. So, Basic was really the first language that I toyed with. I just never sat down, and took the time to “learn” it.

So, for all the programmers, coders, script kiddies and developers out there, what is the 1st programming language that you learned? If applicable, leave a comment specifying the system that you learned the language on.

Some Spam Karma Automation in Python

Aaron — Thu, 08 Mar 2007 01:58:18 +0000

Being a WordPress blogger, unfortunately, I have to wade through tons and tons of comment spam. As of current, I have caught 18,119 comment spams since the inception of this blog in September 2005. Thats more than 1,000 spams per month! That’s some serious spam.

Problem is, though, that some of it is getting through the Spam Karma 2 filters and tests (the single best spam protection for WordPress that you can get). As such, I have had to strengthen the grip on some of the rules. Unfortunately, though, this causes some legit comments to get flagged as spam. If you have fallen victim to this, please contact me, with the date and the post of the comment, and I’ll retrieve it from the database.

Well, I can’t have this happening. If it does, I need to catch it. So, in an effort to learn Python better (seeing as though my job requires it), I set out to write a script that emails me the results of each days spam at the end of the day. This proved to be a bit tricky, but thanks to the wonderful Python language, it was a lot of fun, and not too bad. After the script is written, I throw it in a cron job that runs each night before the beginning of the new day.

First, let me mention that I know some of this code isn’t as efficient as it could be (if you’re an uber-Python hacker, please be gentle). The problem is, I am a complete n00b to Python. As such, I am sure that there are much better ways to achieve the results that I am looking for. However, given the results, it runs quickly, and I’m proud of it. At any event, here is a sample output and here is the code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

#!/usr/bin/python
#
# Script details:
# Connects to your wordpress database, runs a query, returns the result, prints to a file, and emails you a notification
# Spam Karma 2 provides the ability to email you spam comments under a certain karma threshold. Unfortunately, the
# email sent is not in a good format, and the email can be fairly large in size. This script returns the comment spams
# into a comma-separated file left on the server, and just emails you a notification to review the file.
#
# To take the best advantage of this script, place in a directory on your server away from the web document root, then
# place into cron to run at the end of each day. The cron syntax:
#
# 59 23 * * * ~/sk_mysql.py
#
# Author: Aaron Toponce
# Version: 0.3
# License: GPL v. 2

import time, MySQLdb, smtplib, re, csv
from datetime import datetime

# Function declarations
def strip_tags(value):
value = re.sub(r'< [^>]*?>', '', value) # Returns the given HTML with all tags stripped
value = re.sub(r'\[[^\]]*?\]', '', value) # Returns the given phpBB with all tags stripped
value = re.sub(r'[\r\n$]*?\n','',value) # Returns the given text with no newlines
return value

# Database connection and query
Con = MySQLdb.Connect(host='127.0.0.1', port=3306, user='root', passwd='cs3210!', db='wordpress')
Cursor = Con.cursor()
sql = 'SELECT c.comment_ID, s.karma, c.comment_author, c.comment_author_email, c.comment_date, c.comment_content FROM wp_comments c, wp_sk2_spams s WHERE c.comment_ID = s.comment_ID AND c.comment_date like \'%%%s%%\' AND c.comment_approved = \'spam\' AND s.karma > -50 ORDER BY c.comment_ID' % time.strftime('%Y-%m-%d')
Cursor.execute(sql)
Results = Cursor.fetchall()
Con.close()

# Creating a modifiable list
NewList1 = []
for i in Results:
NewList2 = []
for j in range(len(i)):
if j == 5:
NewList2.append(strip_tags(i[j]))
elif j == 4:
NewList2.append(i[j].strftime('%Y-%m-%d %H:%M:%S'))
else:
NewList2.append(i[j])
NewList1.append(NewList2)

# Creating a .csv file for mailing
now = datetime.now()
outfile = '/var/www/pthree/mysql/%s.csv' % now.strftime('%Y-%m-%d')
output = csv.writer(open(outfile, 'w'))
for item in csv.reader(['id,karma,author,email,date,content']):
output.writerow(item)
for item in NewList1:
output.writerow(item)

# Email to the user
server = smtplib.SMTP('localhost')
sender = 'root@localhost'
reply_to = 'root@localhost'
recipient = 'aaron@localhost'
subject = '[Pthree.org] MySQL wordpress spam comments results'
headers = 'From: %s\r\nReply-To: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n' % (sender, reply_to, recipient, subject)
text = '"http://www.pthree.org/mysql/%s.csv" is ready for review.' % now.strftime('%Y-%m-%d')
message = headers + text
server.sendmail(sender, recipient, message)

UPDATE (11-Mar-2007): Realizing that Python has a CSV module, I added that into the code, and removed what I was typing up by hand. First it removed 6 lines of code, plus, it seems to execute a bit quicker. Cheers!

Python and the Horrendous Tab Character

Aaron — Thu, 01 Feb 2007 05:08:17 +0000

This thread was on reddit about a month or so ago, but I didn’t stumble on it until just recently. Basically, the thread talks about the dreaded tab character, and it’s effect on Python code using different editors. I have pasted the items I find most interesting.

It’s amazing the philosophy changes that one can have when stumbling upon something of this nature. Moral of the story? Don’t use the tab character when editing Python code. Have your editor fill the tab with spaces to keep everything uniform.

You know, the more I see the debate about spaces and tabs, the more puzzled I become that anyone still wants to use tabs. They *only* work nicely, IME, when a source file has only one author making changes, with only one editor. Give the file to another author (who uses a different editor) and boom! Nasty stuff happens, about 80-85% of the time.
… (snip) …
I cringe every time I see a tab character in source code that I have to edit, because I know indentation issues are going to be ugly. I have to guess what tabstop settings the original author used so that I can exactly mimic his view of the code, otherwise my own additions will look fine on my screen but ugly on his. And nobody ever seems to document what tabstop settings they use! A simple comment in the header of the file would make a lot of difference…
… (snip) …
I don’t like tab characters. I wish they would go away and that everyone would stop using them. They cause me far too many headaches, and I have never found a good use for them. Every time I have to edit a source file with tabs, I have to explicitly think about indentation levels…
… (snip) …
Lest anyone get me wrong, I am in no way opposed to using the Tab *key* on your keyboard to indent lines. That’s a great use for it. My Vim has the “expandtab”, “smarttab”, and “autoindent” options turned on, which
makes my Tab key practically into a Do-What-I-Mean key. And it always inserts spaces (ASCII 0×20), not tabs (ASCII 0×09). The Tab key is good. But tab characters are bad.
Tab characters have no place in modern source code. Their use is considered harmful and should be strictly avoided.

“We’re Going In A New Direction”

Aaron — Sat, 16 Dec 2006 18:30:06 +0000

Looking back at the archives of this blog, it’s overall theme and vibrancy has changed throughout the months, and honestly, I don’t like where it’s landed. So, this blog is taking a new turn and revisiting it’s roots.

The initial reason this blog was put up, back in September 2005, was to provide an archive to Perl, Python and PHP (thus, the “Pthree”). It was to take a look at those languages from a scripting point of view. Being fairly new in all 3, I thought this would provide great tutorials to those languages for those who are also new to those languages. More importantly, it was to keep me working with those languages to improve my programming prowess. Well, it took a different direction, and it didn’t take long either.

I’d like to go back to what this blog was initially designed for, and provide my experience in looking at those three languages. However, I admit that I am intimidated by the expertise of those out in the “real world”. I fear that my experiences will be ridiculed by those of greater experience and knowledge. However, I’m going to take a step in the dark, and brave the journey. Starting tomorrow, the overall content of the blog will be in respects to Perl, Python and PHP with touches of Ruby and Bash all on GNU/Linux systems, primarily Ubuntu. Of course, comments are always open, and I encourage those of higher knowledge to help me identify what to fix or improve with my code. I plan to have a post up per day at a minimum.

This means that I’ll need a good syntax highlighter for my blog. I have been using Geshi, and like it so far, but it needs a little tweaking. If anyone knows of a solid syntax highlighter, which cover the above languages, for the WordPress platform, I’m all ears.

I hope you enjoy the direction this blog takes.

Python Fibonacci Sequence

Aaron — Fri, 21 Jul 2006 03:33:05 +0000

So, in case you were wondering, Pthree stands for Perl, Python and PHP. I know, I know. I haven’t posted hardly anything at all. So I make a feeble attempt at starting now.

Everything that I have been doing at work is supposed to be written in Python, but instead, I have been writing everything in Bash. Well, tonight, I turn over a new leaf. It’s time to convert many of Bash scripts into Python.

Problem.

I don’t know Python.

So, I have decided to start getting serious. I have literally jumped leaps and bounds these past few months learning Bash, and while I am far from perfect, I think I should begin applying that energy to Python. So, here we go.

First, I went to http://doc.python.org, and began reading. It wasn’t long, but I stumbled upon writing a Fibonacci sequence in Python. I thought, sure, why not?

1
2
3
4

a,b=0,1
while b < 10:
print b
a, b = b, a+b

Not bad. Only 4 simple lines, and already, I feel like I am getting the hang of the language. The only problem, is, if I don’t have any exercises to run through, then I won’t have any motivation to learn the language, and if I spend time learning the language, then by the time it will be time to convert everything over, the window will have passed, and I will feel like I wasted time.

Anyway, I am enjoying myself, and I guess that is what is most important. Maybe in the next post, I’ll post a solution in Python to the traveling salesman problem.

Gmail-notify as an Example of the Power of Open Source Software

Aaron — Sun, 09 Apr 2006 01:13:50 +0000

The example I am about to expense is why Open Source Software (OSS) is so powerful.

A friend of mine was reading my blog, and cheking out my Firefox extension list (that I still need to update badly). He noticed that I use the gmail notifier extension for Firefox rather than the gmail-notify package for Ubuntu that sits in the notification area. I hadn’t tried the gmail-notify package, so I thought I would give it a try. What the heck.

sudo apt-get install gmail-notify

After installing and launching, the first thing I noticed was how horrible the icon was. Take a look:

Ouch. Whomever designed that icon needed a little help. Anyway, the first thing on the agenda was either to redesign the icon, or find one the open commons, and use that. So, I needed to know where the application was looking for the images, so I could make the necessary changes. This was as easy as doing a simple:

whereis gmail-notify

I was lead to the /usr/lib/gmail-notify directory where the python files are stored for the application. Looking at GmailConfig.py, I found the icons were stored in /usr/share/apps/gmail-notify. Duh. I should’ve looked there first. Upon discovery of the directory, there were 6 images that needed to be changed. Four red and two blue.

Now to change the icons. Redesigning the current icon made it look worse, so I went on the hunt to find a Gmail icon that was much more professional looking. Unfortunately, all “official” Gmail icons are copyrighted and I don’t know if they can be used freely for this purpose or not. However, for the meantime, I took the Gmail logo, grabbed the “M” and worked with it as necessary. I’ll fire off an email to Gmail and see if this is okay. If it is, I’ll post a tar.gz for download.

So, in Gimp, I copied the size and name of each image just as it is in the /usr/share/apps/gmail-notify directory. I made all the changes as necessary. Then, the big test. I shutdown the application, made a backup of the current images, and copied my new images into the directory, then fired up the application. Much better. Here’s the same icon, but more professional looking:

How’s that? Better? I think so. Shadow and all. The only thing left was to change the icon that the launcher in the menu looks at. That was easy by just pointing it from /usr/share/pixmaps to /usr/share/apps/gmail-notify.

Why is this so cool? Because this is the exact reason OSS is so powerful. Proprietary applications may or may not give you this ability, but OSS always does. Think of it, for a second. I didn’t like the way an application looked, and I decided to do something about it. I didn’t do any coding, any compiling, hacking or tweaking. All I did was change the images. Now, the application looks the way I want it to look. Try, just try, doing that with, say, Microsoft Office. Good luck.

Sudoku Mania

Aaron — Sun, 05 Mar 2006 16:29:00 +0000

My wife and I were in Barnes and Noble last night. Of course, the first place I go is the magazine rack to pick up the latest Linux Format issue, then over to the prgramming section to get a new computer book. I was completely torn between a number of different computer books, but finally settled on Wicked Cool Shell Scripts by Dave Taylor. You just can’t get enough of shell scripting, even if it is in csh and not bash.

Anyway, while browsing around, I couldn’t help but notice Sudoku books everywhere! Gads, they were on tables, end-caps, at the cash register- literally everywhere. All different kinds of books too. In fact, while at the cash register, paying for our books, Barnes and Noble was even selling a Sudoku game!

Now mind you, I am not foreign to the game by any means of the word. I have Sudoku books at home, and a page-a-day Sudoku calendar at work. Now you can’t open a newspaper without seeing Sudoku puzzles. Which is fine I guess. For me, I got into this game about 7-8 months ago, before all the craze and hype. But here’s what’s funny: I open my newly purchased Linux Format magazine, and what is on page 98, but a review of 3 Sudoku solvers for Linux. It’s a global takeover. Resistance is futile.

So, I read the article. Linux Format was offering 500 to whomever could program the best Sudoku solvers, with 300 going to 1st place, 150 to 2nd place, and 50 to 3rd place. Heck, if I would’ve read the article last month, or at least paid attention to it, I could’ve submitted a solver in Python. Apparently, the 1st place winner SudokuBan, beat me to it. Because it is written in Python, it is completely platform independant.

Well, I went ahead, and downloaded SudokuBan, and began playing. It is a very polished program! Looking at the code (yes, it is OSS), it’s clean and can be easily maintained, even if it isn’t commented (which is a bit bothersome). Launching the program just means firing up the Python interpreter, and off you go! I made a shortcut in my games menu. The command for launching the program is

1	python sudokuban.py

Spellbound, The Workforce and Firefox Market Share

Aaron — Thu, 05 Jan 2006 14:17:29 +0000

Being a serious Firefox junkie, I was testing out a couple new extensions when a fellow coworker came by my desk and asked me what I was doing. He then asked what extensions I find useful, at which point I began showing off Spellbound. Immediately, he jumped out of his seat and couldn’t believe his eyes. He then asked if he could use my browser for a second, and navigated to an intranet site that he had been developing.

His intranet site is a Python powered application that pulls in large amounts of text for the data processing department to clean up. Being in market research, and talking with thousands of people on the phone through our surveys, we ask people how they feel about certain topics, at which point, they tell the interviewer as he/she types in their response. We end up with long text files of responses which include grammar, punctuation and spelling problems, not to mention foul language and slang. It is their job to clean up this text as best they can, removing the foul language, correcting the grammar, punctuation and fixing the spelling. Well, with this extension, the spelling aspect just got a whole lot easier.

It wasn’t long before the IT manager wanted to see me and wanted to know about the extension and how it worked. Once I showed it off, he was convinced, because for the past several months, he had been trying to program his own spell check program to implement into this Python application, and without much luck. Why reinvent the wheel? A tool has already been constructed, that works wonderfully, and virtually bug-free. Needless to say, the spell check program has now been abandoned for the new extension.

Which brings me to my next point. Now that this extension has been exposed, the workplace, specifically the Data Processing department, is very interested in the browser. In fact, they will need the browser if they want to make their jobs much less painful. So I spent an hour or two showing off the extension to the DP department, downloading and installing Firefox and the extension on their computers. Now, except for maybe one or two people, our entire workplace has been converted to Firefox. That may only be approximately 30 people, but, it’s about 20 more than before, and that brings the Firefox market share all that much closer to beating out Internet Explorer.

It then came to me, that it is the workplace that is the ultimate factor in determining whether or not Firefox will in fact beat out IE. I would dare say, although I have nothing to back this up, that the workplace makes up more than 60% of Internet activity, and if that is the case, then targeting corporations and businesses would be more successful for Firefox, than targeting individual users. With Firefox at the 10% mark, and growing, I would think that this would be the direction to go. Also, by converting the employees at work means converting them at home, which poses as a double threat. Lastly, the ultimate success of any service or product is word-of-mouth. When you like a movie you just saw, what do you do? You tell your friends about it, and they go and see it. It has been the secret weapon of anything successful. Word-of-mouth beats out direct advertising 10 to 1.

Go Firefox!

Python File Handling: Part I

Aaron — Thu, 10 Nov 2005 05:28:00 +0000

Because learning a new language takes a little bit of time, I haven’t had much to blog about here. I would like to blog more often, but I feel that I need to get a hang of the language before I can venture too far into blogging about it. I woudn’t have much to blog about, and would just be wasting your time as a reader. However, I do also need to remember that while the focus is Perl, Python and PHP, I can also blog about Linux news and other geek related stuff. I guess it is just habit to put it on my other blog.

So, where to begin? How about file handling? Remember, I am working on converting QuickBasic files at work into Python files for all of our data manipulation and setup. This is something that I have taken on myself, and can only do when things are slow at work. This is one of those last priorities things when everuthing else is out of the way. So far, all I have been able to accomplish is successfully open a text file for reading, create a text file for writing, copy data from the read-only file, and paste it to the newly created file. Here is what I have so far:

fout = open('sample.fin', 'w')
fin = open('sample.txt', 'r')

while 1:
    line = fin.readline()   # Read line by line
    if not line:            # If EOF reached
        break               # exit program
    fout.writelines(line)   # write each line to new file

As you can see, it is all to plain, and not much is going on. The while loop will continue processing until we reach the EOF marker. When we do, exit the loop, thus also exiting the program. Not very exciting. Certainly, nothing advanced. I do find it odd, however, that most programming books wait until the middle chapters to cover file handling. Just an observation.

While this Python program does nothing but copy one file into another, it will grow as I get more time to work on it, and learn more about the language. Eventually, it will be advanced enough to replace the current QuickBasic program that we currently use. The QB program opens a file, looks at a certain row and column in that file, copies a certain length of text and pastes it to a specific location in the newly created file. While this sounds easy, in the QB program, there are actually several variables to take into account, and the text locations have to be exact. Also, the QB program is generated source code from another fairly large QB program, that will also be converted. Converting the larger QB program will take a great deal of time, due to the size of the source, and figuring out what everything does exactly.

Number Arrays in Python

Aaron — Tue, 18 Oct 2005 01:30:45 +0000

Being new to Python and completely discovering the language has been quite the experience. I find it realy cool that it is whitespace dependant, and that indenting matters. This helps reduce alot of the “chatter” that is common in C/C++, Java, Perl, etc.

This week, I decided, among other things, to write a game in Python. A game called Su Doku. I got hooked on it over the weekend, and I have done almost 100 puzzles in the past few days. So I thought it would be cool to program the game. Heck, what an exercise, eh?

First things first, write the pseudocode. I figure the steps for creating such a game would be as follows:

Only the numbers 1 through 9 are possible
Create the “rules” of the puzzle in that no number can be in the same row, column or 3×3 quadrant
Build the 9×9 array using the “rules” established
Create “patterns” using 25-30 of the numbers that make up the solution
Show only the pattern of numbers to the user
Check the users solution against the 9×9 array solution for accuracy

Fairly straight forward. I am sure that there are probably some steps missing, and no doubt it can get more detailed, but the skeleton is there. So, I begin setting up the array using the standard list array in the Python language. It comes as a surprise to me, however, that Python treats every element in the list array as strings. If any integer, long or float arithmetic is done on that element, the element is converted to a number, and the manipulation is done “under the hood”. In other words, speed is compromised, and there is no numeric array built into the Python core.

Luckily, for Python developers, the language supports modules, much like the import statement in Java, so numeric arrays are supported. However, I did find it a little frustrating that it is not supported in the core. Although the math will not be complex, and in my situation, small, speed won’t be an issue. But still, it’s the principle that matters.

Ugh.

One Solid Python IDE

Aaron — Fri, 14 Oct 2005 04:48:00 +0000

A house contractor utilizes the best tools of his trade. As does a plumber, carpenter, mechanic and technician. So should developers.

It is easy as a developer to get caught into using simple tools to get the job done. For example, when editing a web page, a simple text editor gets the job done just as good as any IDE. It might just take a little longer to accomplish the task. Sure, you don’t have all of your project files at your fingertips. You don’t have intelligent word completion. You don’t have compiling and debugging tools. But, those can get in the way when you only need to edit a few lines of code. Why spend all the time bringing up the debugger, intelligent completion and project files, which could take a long time depending on the size of your project, when you can make your edit just as fast?

However, with that said, software development and programming just would not be where it is today had it not been for integrated deveopment environments (IDEs). IDEs make development as painless as possible. They provide run-time environments, compilers, debuggers, project information and much much more. IDEs just make coding pleasurable.

Okay. That’s great and all, but what about Python? There are great IDEs for C/C++, Java, BASIC, and even for web aps. But is there really anything solid out there for Python? Don’t you either have to create an executable script, or parse everything through the interpreter? For those of you who code in Python, know this isn’t the case. Welcome Stani’s Python Editor (SPE).

Just looking at SPE, without even getting into the code, it looks good. It is cross platform compatible (Linux, Mac, Windows), clean, loads quite fast and it’s just plain sexy. Digging into the code, we find managing projects, a compiler and debugger, command line interpreter, intelligent word completion, project building, etc. Pretty much everything we established what makes a good IDE. And it’s not even a first release! And, it’s free. Free as in beer, free as in freedom. Free.

Sweet.