Just realized that the poor performance I was seeing when downloading a file from Rackspace Cloudfiles to a local drive was due to shutil.copyfileobj without specifying a buffer size. As I found out, the default buffer is 16k (just in case you’re running on a 640k server), increasing it to 1MB sped up the process from 17.8 seconds to 0.8 seconds, with 5MB down to 0.3 seconds (for files averaging about 3-4MB).
So remember: always supply a buffer size, and the 60x speed increase can be yours too!
Since a new “hardest” Sudoku puzzle was just announced, I finally wrote my own Sudoku solver in Python. I based it on some ideas from Peter Norvig’s Sudoku solver, but ended up writing everything from scratch. The code is available on github.
I’m taking the Udacity CS373 Programming a Robotic Car class. Below is my solution to the localization homework problem in unit 1 that was due yesterday. Note that this is not the complete program, just the homework portion.
world_width = len(colors)
world_height = len(colors)
p = [[1. / (world_width * world_height)] * world_width
for i in range(world_height)]
def sense(p, Z):
q = [
pcol * (sensor_right if scol == Z else (1 - sensor_right))
for pcol, scol in zip(prow, crow)
for prow, crow in zip(p, colors)
norm = sum(sum(row) for row in q)
return [[col / norm for col in row] for row in q]
def move(p, motion):
ym, xm = motion
p_move * p[(y - ym) % world_height][(x - xm) % world_width]
+ (1 - p_move) * p[y][x]
for x in range(world_width)
for y in range(world_height)
for me, mo in zip(measurements, motions):
p = move(p, mo)
p = sense(p, me)
Instead of looping, I make use of list comprehensions, which I think is a cleaner solution.
Working on one of my Django projects, I created a new context processor to populate some template context variables. One of them was a list of values pulled from the database that was only used on a few pages, so I tried to wrap it in a SimpleLazyObject:
from django.utils.functional import SimpleLazyObject
presentation = SimpleLazyObject(lambda: fetch_current_presentation(request.user))
presentation_records = SimpleLazyObject(lambda: list(presentation.items.values_list('record_id', flat=True).distinct()))
That unfortunately does not work:
TemplateSyntaxError: Caught TypeError while rendering: argument of type 'SimpleLazyObject' is not iterable
The problem is that the SimpleLazyObject wrapper does not implement an __iter__ method, so a wrapped object that is iterable loses that property.
The fix: a new subclass of SimpleLazyObject:
if self._wrapped is None: self._setup()
Last night at the Shenandoah Ruby User Group meeting everybody gave this programming puzzle a shot. Only after the meeting did I make the connection to regular expressions and was able to cut my Python code down to a tweetable format (excluding the input data).
s = "iirytroyppytpeppowuiyoiuypipiyuyotyoiwiytorouqyiepyirueuiprpptwyiroqwtuyipourrrourorwipowiorutpwtwruuioquteorioriyutwqyyprptuqqquuituyywyuoewtrppqwrtiiruirpwyptpuoyyoeyerpqiotuieripurouwuwyuwrworowitoepoypeipeypiireeorrwripuuteoitpuutturruwiyryeetyrioweytueqrrrtotrpiqetoyepoipiwrwpppiritupwipruooiepoweypiuwrqywuuwyiroqpqpruioopuiuerputpwwuuiqwpiroewrtwiqerteoyeqtutwoeoipioiuqiiiouuoqtuuwtuwiiqwppqitywuqpuutrqiyoeuuutwrwtoqrqyoeyoiporuuioiwryoeruypreprqroiyuqwtuyoytoerwqryeeripryieypiwqirtriurueypiuyuypriuiwptywppupoioyrewooytreteeriiwroietuwypieeeeeqpiiiwrirtppoeyiwpooyyporpruwuoriiyowuytiwpwpryeywotoyirqypyypoeptiuwwoyprquoetepptorwiewprpiywwtuieeiweytrrwiqtwotioryoiptyyyuriiqiyroeeiqepwteuwptpruuypipieuoiiuuweeuryuuowporrooyywyyrryriqyirooitirueruptotpryoqtipippyptiurwyiryooywtryyuurtrutwqiqiiiqwouyeooueoturuowiuwrtruwwiupwopwweoo"
print sum("qwertyuiop".find(l) for l in s[:2]),