andrew.io/weblog

How to import a module from just a file path

andrew — Sun, 17 Jul 2011 22:02:34 +0000

import a module from a file path, either through a stdlib function call or just constructed from scratch

via Coder Who Says Py: How to import a module from just a file path.

Some Common Django ORM Pitfalls

andrew — Wed, 05 May 2010 04:30:24 +0000

David Ziegler has posted a nice list of Common Django ORM Pitfalls.

Cue

andrew — Mon, 03 May 2010 04:21:35 +0000

On Friday, I was thinking about a simple queue for django and what that would look like, and today I came across Charles Leifer’s post: Idea for a simple task queue, where he introduces cue. I’ll probably be taking a deeper dive into this post, later in the upcoming week.

SQL to MongoDB

andrew — Tue, 23 Mar 2010 22:37:31 +0000

An example of mapping a MySQL query to a MongoDB mapreduce.

Finding Anagrams with Python

andrew — Thu, 11 Mar 2010 04:57:48 +0000

As a web developer a lot of my development activities really comes down to handling a request, authenticating the request, validating the request, making an sql query, serializing the data for a response, and then handling the response in the web browser and render accordingly. Needless to say, I don’t spend a lot of time working on algorithms and optimization (outside of sql) these days.

And, recently I saw a small programming challenge on the web for determining anagrams in the english dictionary for a given word, and I sat down today and worked out a solution and here it is:

    def possible_anagrams(word):
        '''given a word, return a list of possible anagrams for that word'''
 
        if len(word) == 1:
           yield word
 
        for i, letter in enumerate(word):
            # recursively call with a word whose characters have been rotated
            for s in possible_anagrams(word[i+1:] + word[:i]):
                yield '%s%s' % (letter, s)
 
    def anagrams(word):
        '''given a word, return a list of anagrams in an english dictionary'''
 
        words = [w.rstrip() for w in open('WORD.LST')]
        return [a for a in possible_anagrams(word) if a in words]
 
    if __name__ == "__main__":
        print anagrams('python')

Originally I wrote a recursive possible_anagrams function that returned a list, but then modified it to use a generator. There is room for optimization, but this was my first shot at getting a correct result.

Then, I was looking at the possible solutions and realized, as I typically do in these situations, I had made the problem more complex than it needed to be. Because, you don’t really need to find the possible anagrams. You can do something like:

    def anagrams(word):
        words = [w.rstrip() for w in open('WORD.LST')]
        sword = sorted(word)
        return [w for w in words if sorted(w) == sword]

which compares a sorted list of characters. The solution is very clean and easy to understand. However, one solution really stood out to me for its use of itertools to find the possible anagrams:

 
    import itertools
 
    def anagrams(word):
 
        words = [w.rstrip() for w in open('WORD.LST')]
        #Reduce the number of words to compare to 
        # just the ones with the same lengths
        # Also make a set to avoid duplicates
        words = set([ w for w in words if len(w) == len(word)])
 
        #Find all possible anagrams
        comb = set([ ''.join(w) for w in  
                    itertools.permutations(word, len(word))])
 
        #Now find the ones that are words intersecting two sets
        return comb.intersection(words)

I was previously unaware of the itertools.permutations method. And, this solution is also easier to read than mine and performed 10-20 ms faster than mine as well. So, while I did make the problem more complex than needed I now have 3 ways to find an anagram should similar problems ever come up in real life and more importantly, to me, I solved something that didn’t involve sql.

Zone mapping chart

andrew — Wed, 10 Mar 2010 16:06:04 +0000

I like living in the zone of fun and games.

How and why to use django-mongokit aka. Django to MongoDB – Peterbe.com Peter Bengtsson on Python, Zope, Kung Fu, London and photos

andrew — Tue, 09 Mar 2010 15:32:55 +0000

How and why to use django-mongokit aka. Django to MongoDB provides a great introduction of how to get started with Django and MongoDB. Although it’s still not exactly clear when/where/why MongoDB is better than a Relational DB like MySQL. And even less clear how something like MongoDB compares with Cassandra.

round-robin django setup with nginx

andrew — Sun, 07 Mar 2010 02:17:51 +0000

A small nginx configuration snippet to round robin a django setup.

Presenting django-devserver, a better runserver.

andrew — Sat, 06 Mar 2010 17:17:07 +0000

The most annoying thing to me about django’s runserver is lack of sql output in the terminal. django-devserver provides sql output, and does it nicely with syntax coloring.

Django query set iterator – for really large, querysets

andrew — Sat, 06 Mar 2010 17:07:52 +0000

A solution for dealing with very large querysets in django when memory is a limiting constraint, with some nice discussion in the comments about why limit and offset are not friendly to the database.