I’m a believing member in the church of emacs, and in honor of the new release I went looking for solutions to a couple of outstanding issues I’ve had with my emacs installation.
Today’s first emacs find is M-; which, although undocumented, works excellently to comment and uncomment code blocks in Python (it had puzzled me for a while that the comment-block command on the Python menu was C-c # and that there was no mapping for the uncomment command). The M-; command works in a plethora of other modes as well to comment and uncomment blocks.
The second emacs treasure I found today was how to turn on autocompletion. Not the mind-numbingly annoying kind that some editors have that pops up and obscures half your program whenever you type a key, but rather cycling through options when pressing M-RET. To enable it, simply put this in your .emacs file:
(define-key global-map (read-kbd-macro "M-RET") 'hippie-expand)
Searching for some info on hippie-expand, I ran into dabbrev-expand which is bound to M-/. I couldn’t tell you what the difference is, but the ESC-Enter combination is easier to find blindfolded so that’s what I’m going with.
It looks like Python is getting tuples with named members in 2.6(http://www.oluyede.org/blog/2007/03/11/updates-from-python-svn-part-2/ and http://docs.python.org/dev/lib/named-tuple-factory.html). I suspect many of us have implemented similar functionality ourselves, e.g. Shannon -jj Behrens describes how he sometimes uses dictionaries to return composite polymorphic values (http://jjinux.blogspot.com/2007/03/python-returning-multiple-things-of.html). The problem with dictionaries is of course that they require too much excercise of your little finger in typing ['xx']. That's even worse for me since I'm using a keyboard layout that switches national characters onto those keys when I tap the caps-lock key, so I can use my American-keyboard touch typing skillz and eat my national characters as well (I'm looking forward to the Metaphor-off!)
It looks like the new Python NamedTuple type is going to limit the fields to those that are defined at creation time. It's based on a tuple, so I suppose that follows naturally, however it doesn't seem natural for the abstract-data-type of a container of named fields with iteration and indexing. I've called my implementation of this ADT a property set since most of the motivating use cases for this was returning returning values that had properties attached to them. The use is as follows...
You can assign to random fields, the only limitation is that they cannot start with an underscore, but public fields wouldn't have that anyway so it's not really a limitation (the limitation comes from the fact that the implementation overrides __setattr__ and being able to interpret fields starting with an underscore as internal to the implementation simplifies things quite a bit):
PYTHON:
-
>>> p = pset()
-
>>> p.a = 42
-
>>> p.b = 'hello'
-
>>> p.c = [p.a, p.b]
-
>>> p
-
pset(a=42, b='hello', c=[42, 'hello'])
You can iterate over the values:
PYTHON:
-
>>> for key, value in p:
-
... print key, value
-
...
-
a 42
-
b hello
-
c [42, 'hello']
Notice that it maintains the insertion order, and you can also access by index:
For technical reasons it is not possible to maintain the order when creating a pset from keyword arguments (I was hesitating to put this functionality in, but practicality beats purity, and it's turned out to be very practical). Equality does not require isomorphism, which means that as long as the sets have the same fields they compare equal:
PYTHON:
-
>>> q = pset(a=42, b='hello', c=[42,'hello'])
-
>>> q
-
pset(a=42, c=[42, 'hello'], b='hello')
-
>>> p == q
-
True
You can keep the order given to the constructor by initializing with a list of tuples:
PYTHON:
-
>>> list(p.items())
-
[('a', 42), ('b', 'hello'), ('c', [42, 'hello'])]
-
>>> r = pset(p.items())
-
>>> r
-
pset(a=42, b='hello', c=[42, 'hello'])
The example above does of course not mean that you can't create a pset from a pset directly (this also maintains order):
PYTHON:
-
>>> s = pset(p)
-
>>> s
-
pset(a=42, b='hello', c=[42, 'hello'])
It's also extremely useful to be able to use field indexing notation as well:
PYTHON:
-
>>> p
-
pset(a=42, b='hello', c=[42, 'hello'])
-
>>> p.b
-
'hello'
-
>>> p[1]
-
'hello'
-
>>> p['b']
-
'hello'
-
>>> p['b'] = 'world'
-
>>> p
-
pset(a=42, b='world', c=[42, 'hello'])
-
>>> p[1] = 'foo'
-
>>> p
-
pset(a=42, b='foo', c=[42, 'hello'])
Here's the code:
PYTHON:
-
class pset(dict):
-
"""This code is placed in the Public Domain.
-
-
Property Set class.
-
A property set is an object where values are attached to attributes,
-
but can still be iterated over as key/value pairs.
-
The order of assignment is maintained during iteration.
-
Only one value allowed per key.
-
>>> x = pset()
-
>>> x.a = 42
-
>>> x.b = 'foo'
-
>>> x.a = 314
-
>>> x
-
pset(a=314, b='foo')
-
"""
-
def __init__(self, items=(), **attrs):
-
object.__setattr__(self, '_order', [])
-
super(pset, self).__init__()
-
for k, v in items:
-
self.add(k, v)
-
for k, v in attrs.items():
-
self.add(k, v)
-
-
def add(self, key, value):
-
if type(key) in (int, long):
-
key = self._order[key]
-
elif key not in self._order:
-
self._order.append(key)
-
dict.__setitem__(self, key, value)
-
-
def __eq__(self, other):
-
"""Equal iff they have the same set of keys, and the values for
-
each key is equal. Key order is not considered for equality.
-
"""
-
if set(self._order) == set(other._order):
-
for key in self._order:
-
if self[key] != other[key]:
-
return False
-
return True
-
return False
-
-
def __iadd__(self, other):
-
for k, v in other:
-
self.add(k, v)
-
-
# should probably have an __radd__ method too...
-
def __add__(self, other):
-
tmp = self.__class__()
-
tmp += self
-
tmp += other
-
return tmp
-
-
def __repr__(self):
-
vals = ', '.join('%s=%s' % (k, repr(v)) for (k,v) in self)
-
return '%s(%s)' % (self.__class__.__name__, vals)
-
-
def __getattr__(self, key):
-
if key not in self:
-
raise AttributeError(key)
-
return self.get(key)
-
-
def __getitem__(self, key):
-
if type(key) in (int, long):
-
key = self._order[key]
-
return self.get(key)
-
-
__str__ = __repr__
-
-
-
def __iter__(self):
-
return ((k, self.get(k)) for k in self._order)
-
-
def items(self):
-
return iter(self)
-
-
def __setattr__(self, key, val):
-
if key.startswith('_'):
-
object.__setattr__(self, key, val)
-
else:
-
self.add(key, val)
-
-
def __setitem__(self, key, val):
-
self.add(key, val)
It's a simple question, any ~5 y/o can answer it "I'm five years, four months, and two days". So, how do we calculate that using Python? Subtracting date objects only produces objects giving the difference in days, which is very excact, and very unhelpful -- still it's the only sane option for a datetime library...
One problem is how old a person is who is born in the leap-year 2000, on date(2000, 2, 29) if today was date(2003, 2, 28). I decided they were 2 years, 11 months, and 30 days, and that on date(2003, 3, 1) they were 3 years and 1 day. That seems very logical to me, although I know there are lot's of people that disagree with me... Feel free to come up with code that works for you 
The code turned out to be relatively short and simple and works on the simple principle of "I'm one year older if my birthday is today or was earlier this year".
PYTHON:
-
from datetime import date as _date
-
from calendar import monthrange as _monthrange
-
-
def age(dob, today=_date.today()):
-
y = today.year - dob.year
-
m = today.month - dob.month
-
d = today.day - dob.day
-
-
while m <0 or d <0:
-
while m <0:
-
y -= 1
-
m = 12 + m # m is negative
-
if d <0:
-
m -= 1
-
days = days_previous_month(today.year, today.month)
-
d = max(0, days - dob.day) + today.day
-
-
return y, m, d
-
-
def days_previous_month(y, m):
-
m -= 1
-
if m == 0:
-
y -= 1
-
m = 12
-
_, days = _monthrange(y, m)
-
return days
The calendar module is way underutilized most of the time, so it was nice to get to use it...