OnceIWasAnOstrich fucked around with this message at 01:53 on Jun 8, 2012

Clugg fucked around with this message at 09:41 on Jun 10, 2012

import operator,numbers
# US dollar class based on fixed-point integer math
# inherits the abstract Rational class to ensure all appropriate operators are implemented
class USD(numbers.Real):
    # instantiate a new dollar value.  accepts float or integer dollars if cents==False, float or integer cents if cents==True.
    def __init__(self, v, cents=False):
        self.v = v if cents else v*100
    
    # printing the object prints a formatted dollar value
    def __repr__(self): return "$%.2f" % (self.v/100.0)
    __str__=__repr__
    
    # indirect call for any binary operator
    def _binary_op(self, other, op, like_type_only=False, reverse=False):
        if reverse: 
            op_orig = op
            op = lambda a,b: op_orig(b,a)
        if isinstance(other, type(self)):
            return USD(op(self.v, other.v), True)
        elif not like_type_only and isinstance(other, numbers.Real):
            return USD(op(self.v, other), True)
        else:
            raise TypeError("Unable to '%s' %s and %s" % (op.__name__, type(self), type(other)))
    
    # indirect call for any unary operator
    def _unary_op(self, op): return USD(op(self.v), True)
    
    # binary operators which must be applied to other USD objects (e.g., we're disallowing USD+int since it's not clear if it's cents or dollars)
    def __add__(self,other):  return self._binary_op(other, operator.__add__, like_type_only=True)
    def __sub__(self,other):  return self._binary_op(other, operator.__sub__, like_type_only=True)
    def __eq__(self,other):   return self._binary_op(other, operator.__eq__,  like_type_only=True)
    def __le__(self,other):   return self._binary_op(other, operator.__le__,  like_type_only=True)
    def __lt__(self,other):   return self._binary_op(other, operator.__lt__,  like_type_only=True)
    def __radd__(self,other): return self._binary_op(other, operator.__add__, like_type_only=True, reverse=True)
    
    # binary operators applicable to any number
    def __div__(self,other):       return self._binary_op(other, operator.__div__)
    def __floordiv__(self,other):  return self._binary_op(other, operator.__floordiv__)
    def __mod__(self,other):       return self._binary_op(other, operator.__mod__)
    def __mul__(self,other):       return self._binary_op(other, operator.__mul__)
    def __pow__(self,other):       return self._binary_op(other, operator.__pow__)
    def __truediv__(self,other):   return self._binary_op(other, operator.__truediv__)
    def __rdiv__(self,other):      return self._binary_op(other, operator.__div__,      reverse=True)
    def __rfloordiv__(self,other): return self._binary_op(other, operator.__floordiv__, reverse=True)
    def __rmod__(self,other):      return self._binary_op(other, operator.__mod__,      reverse=True)
    def __rmul__(self,other):      return self._binary_op(other, operator.__mul__,      reverse=True)
    def __rpow__(self,other):      return self._binary_op(other, operator.__pow__,      reverse=True)
    def __rtruediv__(self,other):  return self._binary_op(other, operator.__truediv__,  reverse=True)
    
    # unary operators
    def __abs__(self): return self._unary_op(operator.__abs__)
    def __neg__(self): return self._unary_op(operator.__neg__)
    def __pos__(self): return self._unary_op(operator.__pos__)
    def __float__(self): return self._unary_op(operator.__float__)
    def __trunc__(self): return self.v  # the only "special" unary operator
    
    # money math
    def dollars(self): return int(self.v / 100)
    def cents(self): return int(self.v % 100)

>>> x=USD(5)
>>> x
$5.00
>>> x+5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 26, in __add__
  File "<stdin>", line 20, in _binary_op
TypeError: Unable to '__add__' <class '__main__.USD'> and <type 'int'>
>>> x+USD(3)
$8.00
>>> x/3
$1.66

Stabby McDamage fucked around with this message at 19:46 on Jun 10, 2012

1. List comprehensions are a bit nicer/easier to understand:
   

   code:

   In [1]: [x * 2 for x in [1, 2, 3]]
   Out[1]: [2, 4, 6]
   

2. Use NumPy:
   

   code:

   In [1]: import numpy as np
   
   In [2]: a = np.array([1, 2, 3])
   
   In [3]: a * 2
   Out[3]: array([2, 4, 6])