���ѧۧݧ�ӧ�� �ާ֧ߧ֧էا֧� - ���֧էѧܧ�ڧ��ӧѧ�� - /home/ukubnwwtacc0unt/chapelbellstudios.com/uploads/cover/classes.tar
���ѧ٧ѧ�
Rev.pyc 0000644 00000005461 15204305157 0006025 0 ustar 00 � ��^c @ s< d Z d d d � � YZ d � Z e d k r8 e � n d S( s� A class which presents the reverse of a sequence without duplicating it. From: "Steven D. Majewski" <sdm7g@elvis.med.virginia.edu> It works on mutable or inmutable sequences. >>> chars = list(Rev('Hello World!')) >>> print ''.join(chars) !dlroW olleH The .forw is so you can use anonymous sequences in __init__, and still keep a reference the forward sequence. ) If you give it a non-anonymous mutable sequence, the reverse sequence will track the updated values. ( but not reassignment! - another good reason to use anonymous values in creating the sequence to avoid confusion. Maybe it should be change to copy input sequence to break the connection completely ? ) >>> nnn = range(3) >>> rnn = Rev(nnn) >>> for n in rnn: print n ... 2 1 0 >>> for n in range(4, 6): nnn.append(n) # update nnn ... >>> for n in rnn: print n # prints reversed updated values ... 5 4 2 1 0 >>> nnn = nnn[1:-1] >>> nnn [1, 2, 4] >>> for n in rnn: print n # prints reversed values of old nnn ... 5 4 2 1 0 # >>> WH = Rev('Hello World!') >>> print WH.forw, WH.back Hello World! !dlroW olleH >>> nnn = Rev(range(1, 10)) >>> print nnn.forw [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> print nnn.back [9, 8, 7, 6, 5, 4, 3, 2, 1] >>> rrr = Rev(nnn) >>> rrr <1, 2, 3, 4, 5, 6, 7, 8, 9> t Revc B s, e Z d � Z d � Z d � Z d � Z RS( c C s | | _ | | _ d S( N( t forwt back( t selft seq( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __init__? s c C s t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __len__C s c C s | j | d S( Ni ( R ( R t j( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __getitem__F s c C s� | j } t | t � r' d } d } nH t | t � rE d } d } n* t | t � rc d } d } n d } d } g | j D] } t | � ^ qy } | d | j | � | d S( Ns []s , s ()t s <>i i����( R t isinstancet listt tuplet strR t join( R R t wrapt sept itemt outstrs( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __repr__I s "( t __name__t __module__R R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyR > s c C s% d d l } d d l } | j | � S( Ni����( t doctestR t testmod( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt _testZ s t __main__N( ( t __doc__R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt <module>< s Vec.pyc 0000644 00000005404 15204305157 0006003 0 ustar 00 � ��^c @ s' d d d � � YZ d � Z e � d S( t Vecc B sb e Z d Z d � Z e d � � Z d � Z d � Z d � Z d � Z d � Z d � Z e Z RS( sx A simple vector class Instances of the Vec class can be constructed from numbers >>> a = Vec(1, 2, 3) >>> b = Vec(3, 2, 1) added >>> a + b Vec(4, 4, 4) subtracted >>> a - b Vec(-2, 0, 2) and multiplied by a scalar on the left >>> 3.0 * a Vec(3.0, 6.0, 9.0) or on the right >>> a * 3.0 Vec(3.0, 6.0, 9.0) c G s t | � | _ d S( N( t listt v( t selfR ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __init__ s c C s. t | t � s t � n | � } | | _ | S( N( t isinstanceR t TypeErrorR ( t clsR t inst( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt fromlist s c C s) d j d � | j D� � } d j | � S( Ns , c s s | ] } t | � Vq d S( N( t repr( t .0t x( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pys <genexpr>% s s Vec({0})( t joinR t format( R t args( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __repr__$ s c C s t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __len__( s c C s | j | S( N( R ( R t i( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __getitem__+ s c C s? g t | j | j � D] \ } } | | ^ q } t j | � S( N( t zipR R R ( R t otherR t yR ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __add__. s 2c C s? g t | j | j � D] \ } } | | ^ q } t j | � S( N( R R R R ( R R R R R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __sub__3 s 2c C s- g | j D] } | | ^ q } t j | � S( N( R R R ( R t scalarR R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __mul__8 s ( t __name__t __module__t __doc__R t classmethodR R R R R R R t __rmul__( ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyR s c C s d d l } | j � d S( Ni����( t doctestt testmod( R! ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt test@ s N( ( R R# ( ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt <module> s ? Range.pyo 0000644 00000007773 15204305157 0006351 0 ustar 00 � ��^c @ sN d Z d � Z d � Z d d d � � YZ d � Z e d k rJ e � n d S( s Example of a generator: re-implement the built-in range function without actually constructing the list of values. OldStyleRange is coded in the way required to work in a 'for' loop before iterators were introduced into the language; using __getitem__ and __len__ . c C s� y� t | � d k r, d t | d � d f St | � d k r_ t | d � t | d � d f St | � d k r� | d d k r� t d � � n t d � | D� � St d t | � � � Wn t k r� t d � � n Xd S( sg Take list of arguments and extract/create proper start, stop, and step values and return in a tuplei i i i s step argument must not be zeroc s s | ] } t | � Vq d S( N( t int( t .0t x( ( s* /usr/lib64/python2.7/Demo/classes/Range.pys <genexpr> s s$ range() accepts 1-3 arguments, givensA range() arguments must be numbers or strings representing numbersN( t lenR t ValueErrort tuplet TypeError( t arglist( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt handleargs s ! c g sA t | � \ } } } | } x | | k r< | V| | 7} q Wd S( s, Function to implement 'range' as a generatorN( R ( t at startt stopt stept value( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt genrange s t oldrangec B s2 e Z d Z d � Z d � Z d � Z d � Z RS( s Class implementing a range object. To the user the instances feel like immutable sequences (and you can't concatenate or slice them) Done using the old way (pre-iterators; __len__ and __getitem__) to have an object be used by a 'for' loop. c G sE t | � \ | _ | _ | _ t d | j | j | j � | _ d S( s� Initialize start, stop, and step values along with calculating the nubmer of values (what __len__ will return) in the rangei N( R R R R t maxR ( t selfR ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __init__, s c C s d | j | j | j f S( s- implement repr(x) which is also used by prints range(%r, %r, %r)( R R R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __repr__2 s c C s | j S( s implement len(x)( R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __len__6 s c C s> d | k o | j k n r1 | j | j | St d � d S( s implement x[i]i s range[i] index out of rangeN( R R R t IndexError( R t i( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __getitem__: s ( t __name__t __module__t __doc__R R R R ( ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyR " s c C s9 d d l } d d l } | j d d d � } t t d d d � � } t t d d d � � } | | k su | | k r� t d | | | f � � n d GH| j � } x t d � D] } q� W| j � } x t d � D] } q� W| j � } x | j d � D] } q� W| j � } | | Gd GH| | Gd GH| | Gd GHd S( Ni����i id i sE error in implementation: correct = %s old-style = %s generator = %ss Timings for range(1000):i� s sec (old-style class)s sec (generator)s sec (built-in)( t timet __builtin__t ranget listR R t Exception( R R t correct_resultt oldrange_resultt genrange_resultt t1R t t2t t3t t4( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt testB s* t __main__N( ( R R R R R' R ( ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt <module> s Dbm.py 0000644 00000003046 15204305157 0005625 0 ustar 00 # A wrapper around the (optional) built-in class dbm, supporting keys # and values of almost any type instead of just string. # (Actually, this works only for keys and values that can be read back # correctly after being converted to a string.) class Dbm: def __init__(self, filename, mode, perm): import dbm self.db = dbm.open(filename, mode, perm) def __repr__(self): s = '' for key in self.keys(): t = repr(key) + ': ' + repr(self[key]) if s: t = ', ' + t s = s + t return '{' + s + '}' def __len__(self): return len(self.db) def __getitem__(self, key): return eval(self.db[repr(key)]) def __setitem__(self, key, value): self.db[repr(key)] = repr(value) def __delitem__(self, key): del self.db[repr(key)] def keys(self): res = [] for key in self.db.keys(): res.append(eval(key)) return res def has_key(self, key): return self.db.has_key(repr(key)) def test(): d = Dbm('@dbm', 'rw', 0600) print d while 1: try: key = input('key: ') if d.has_key(key): value = d[key] print 'currently:', value value = input('value: ') if value is None: del d[key] else: d[key] = value except KeyboardInterrupt: print '' print d except EOFError: print '[eof]' break print d test() Dbm.pyc 0000644 00000004730 15204305157 0005771 0 ustar 00 � ��^c @ s' d d d � � YZ d � Z e � d S( t Dbmc B sP e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s( d d l } | j | | | � | _ d S( Ni����( t dbmt opent db( t selft filenamet modet permR ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __init__ s c C sd d } xO | j � D]A } t | � d t | | � } | rJ d | } n | | } q Wd | d S( Nt s : s , t {t }( t keyst repr( R t st keyt t( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __repr__ s c C s t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __len__ s c C s t | j t | � � S( N( t evalR R ( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __getitem__ s c C s t | � | j t | � <d S( N( R R ( R R t value( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __setitem__ s c C s | j t | � =d S( N( R R ( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __delitem__ s c C s7 g } x* | j j � D] } | j t | � � q W| S( N( R R t appendR ( R t resR ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR ! s c C s | j j t | � � S( N( R t has_keyR ( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR ' s ( t __name__t __module__R R R R R R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR s c C s� t d d d � } | GHx� ya t d � } | j | � rN | | } d G| GHn t d � } | d k rp | | =n | | | <Wq t k r� d GH| GHq t k r� d GHPq Xq W| GHd S( Ns @dbmt rwi� s key: s currently:s value: R s [eof]( R t inputR t Nonet KeyboardInterruptt EOFError( t dR R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt test+ s& N( ( R R$ ( ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt <module> s $ Range.py 0000644 00000006066 15204305157 0006164 0 ustar 00 """Example of a generator: re-implement the built-in range function without actually constructing the list of values. OldStyleRange is coded in the way required to work in a 'for' loop before iterators were introduced into the language; using __getitem__ and __len__ . """ def handleargs(arglist): """Take list of arguments and extract/create proper start, stop, and step values and return in a tuple""" try: if len(arglist) == 1: return 0, int(arglist[0]), 1 elif len(arglist) == 2: return int(arglist[0]), int(arglist[1]), 1 elif len(arglist) == 3: if arglist[2] == 0: raise ValueError("step argument must not be zero") return tuple(int(x) for x in arglist) else: raise TypeError("range() accepts 1-3 arguments, given", len(arglist)) except TypeError: raise TypeError("range() arguments must be numbers or strings " "representing numbers") def genrange(*a): """Function to implement 'range' as a generator""" start, stop, step = handleargs(a) value = start while value < stop: yield value value += step class oldrange: """Class implementing a range object. To the user the instances feel like immutable sequences (and you can't concatenate or slice them) Done using the old way (pre-iterators; __len__ and __getitem__) to have an object be used by a 'for' loop. """ def __init__(self, *a): """ Initialize start, stop, and step values along with calculating the nubmer of values (what __len__ will return) in the range""" self.start, self.stop, self.step = handleargs(a) self.len = max(0, (self.stop - self.start) // self.step) def __repr__(self): """implement repr(x) which is also used by print""" return 'range(%r, %r, %r)' % (self.start, self.stop, self.step) def __len__(self): """implement len(x)""" return self.len def __getitem__(self, i): """implement x[i]""" if 0 <= i <= self.len: return self.start + self.step * i else: raise IndexError, 'range[i] index out of range' def test(): import time, __builtin__ #Just a quick sanity check correct_result = __builtin__.range(5, 100, 3) oldrange_result = list(oldrange(5, 100, 3)) genrange_result = list(genrange(5, 100, 3)) if genrange_result != correct_result or oldrange_result != correct_result: raise Exception("error in implementation:\ncorrect = %s" "\nold-style = %s\ngenerator = %s" % (correct_result, oldrange_result, genrange_result)) print "Timings for range(1000):" t1 = time.time() for i in oldrange(1000): pass t2 = time.time() for i in genrange(1000): pass t3 = time.time() for i in __builtin__.range(1000): pass t4 = time.time() print t2-t1, 'sec (old-style class)' print t3-t2, 'sec (generator)' print t4-t3, 'sec (built-in)' if __name__ == '__main__': test() Dates.pyo 0000644 00000016246 15204305157 0006350 0 ustar 00 � ��^c @ sp d d d d d d d d d d d d g Z d d d d d d d g Z d d d d d d d d d d d d g Z g Z d Z x% e D] Z e j e � e e Z q� W[ [ e d � e d � f Z d � Z d � Z d � Z d � Z d � Z d � Z e d � Z d � Z d! � Z d" d, d# � � YZ d$ � Z d% e f d& � � YZ d' � Z e d( k rle d) d* � n d+ S(- t Januaryt Februaryt Marcht Aprilt Mayt Junet Julyt Augustt Septembert Octobert Novembert Decembert Fridayt Saturdayt Sundayt Mondayt Tuesdayt Wednesdayt Thursdayi i i i i l c C s6 | d d k r d S| d d k r( d S| d d k S( Ni i i� i id ( ( t year( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _is_leap> s c C s d t | � S( Nim ( R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_in_yearC s c C s, | d | d d | d d | d d S( Nl mi i ic id i� i� ( ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_before_yearF s c C s( | d k r t | � r d St | d S( Ni i i ( R t _DAYS_IN_MONTH( t monthR ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_in_monthI s c C s" t | d | d k o t | � S( Ni i ( t _DAYS_BEFORE_MONTHR ( R R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_before_monthM s c C s' t | j � t | j | j � | j S( N( R R R R t day( t date( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _date2numP s i� c C s} t | � t k r( t d t | � � n t d d d � } | ` | ` | ` | ` | | _ | d t } d | | t | } } | d } t | � } | | k r� | d } | t | � } n | | t | | � } } y t | � } Wn t t f k rn Xt | d d d � } t | | � } | | k rX| d } | t | | � } n | | | | | _ | _ | _ | S( Ns argument must be integer: %ri i� im i i ( t typet _INT_TYPESt TypeErrort Datet ordR R R t _DI400YR R t intt ValueErrort OverflowErrort minR R ( t nt anst n400R t moret dbyR t dbm( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _num2dateW s0 !c C s t t | d � S( Ni ( t _DAY_NAMESR% ( R) ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _num2dayt s R" c B s_ e Z d � Z d � Z d � Z d � Z d � Z d � Z e Z d � Z d � Z d � Z RS( c C s� d | k o d k n s/ t d | f � n t | | � } d | k oU | k n sp t d | | f � n | | | | _ | _ | _ t | � | _ d S( Ni i s month must be in 1..12: %rs day must be in 1..%r: %r( R& R R R R R R# ( t selfR R R t dim( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __init__y s c C s3 | j j | � r" t d | � n | | j | <d S( Ns read-only attribute ( t __dict__t has_keyt AttributeError( R2 t namet value( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __setattr__� s c C s t | j | j � S( N( t cmpR# ( R2 t other( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __cmp__� s c C s t | j � S( N( t hashR# ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __hash__� s c C s+ d | j � | j t | j d | j f S( Ns %.3s %2d %.3s %ri ( t weekdayR t _MONTH_NAMESR R ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __repr__� s c C s9 t | � t k r( t d t | � � n t | j | � S( Ns can't add %r to date( R R R! R/ R# ( R2 R) ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __add__� s c C s5 t | � t k r# t | j | � S| j | j Sd S( N( R R R/ R# ( R2 R< ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __sub__� s c C s t d � d S( Ns Can't subtract date from integer( R! ( R2 R< ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __rsub__� s c C s t | j � S( N( R1 R# ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyR@ � s ( t __name__t __module__R4 R: R= R? RB RC t __radd__RD RE R@ ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyR" x s c C s= d d l } | j | j � � } t | d | d | d � S( Ni����i i i ( t timet localtimeR" ( RI t local( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt today� s t DateTestErrorc B s e Z RS( ( RF RG ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyRM � s c C s� t d d d � } t d d d � } t | � d k rB t d � n | | k ss | | k ss | | k ss | | k r t d � n | d | k s� d | | k r� t d � n | | d k s� | d | k r� t d � n y d | } t d � Wn t k rn Xy | | } t d � Wn t k r,n X| j � d k rKt d � n t | | � | k sut | | � | k r�t d � n i | | d 6| d | 6} | | d | k s�| | | | t d d d � k r�t d � n t | � } | } x� | | k r�| d } | t | � d } t d d | � t d d | � } } | j | j f | | f k rut d | f � n t | � t | � } } d d | d d | f | j | j | j | j | j | j f k r�t d | f � n | d } q�Wd S( Ni i iy iz s Tue 30 Sep 1913s __repr__ failures __cmp__ failureim s __add__ failures __sub__ failurei s int-date should have faileds date+date should have failedR s weekday() failures min/max failurein i s dictionary failurei i s date->num faileds num->date failed( R" t reprRM R! R@ t maxR( R R R# R/ R R R ( t firstyeart lastyeart at bt xt dt lordt yt fordt fdt ld( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt test� sP 1 * 8 % -t __main__i: if N( ( RA R0 R R R. R3 t appendR R R R R R R R R$ R/ R1 R" RL t ExceptionRM R[ RF ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt <module>, s6 * 4 . Complex.pyc 0000644 00000023446 15204305157 0006703 0 ustar 00 � ��^c @ s� d d l Z d d l Z e j d Z e j d Z d � Z d � Z d d e d � Z d � Z d � Z d d d � � YZ d � Z d d � Z d � Z e d k r� e � n d S( i����Ng @c C s t | d � o t | d � S( Nt ret im( t hasattr( t obj( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt IsComplexG s c C s7 t | � r | St | t � r) t | � St | � Sd S( N( R t isinstancet tuplet Complex( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt ToComplexJ s i c C s5 | t | } t t j | � | t j | � | � S( N( t twopiR t matht cost sin( t rt phit fullcircle( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt PolarToComplexR s c C s t | � r | j S| S( N( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt ReV s c C s t | � r | j Sd S( Ni ( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt Im[ s R c B s� e Z d d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z e Z Z e d � Z e Z d � Z e Z d � Z d � Z d � Z e Z d � Z d � Z d d � Z d � Z RS( i c C s� d } d } t | � r- | j } | j } n | } t | � r\ | | j } | | j } n | | } | | j d <| | j d <d S( Ni R R ( R R R t __dict__( t selfR R t _ret _im( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __init__b s c C s t d � d S( Ns Complex numbers are immutable( t TypeError( R t namet value( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __setattr__t s c C s, | j s t | j � St | j | j f � S( N( R t hashR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __hash__w s c C s/ | j s d | j f Sd | j | j f Sd S( Ns Complex(%r)s Complex(%r, %r)( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __repr__| s c C s. | j s t | j � Sd | j | j f Sd S( Ns Complex(%r, %r)( R t reprR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __str__� s c C s t | j | j � S( N( R R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __neg__� s c C s | S( N( ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __pos__� s c C s t j | j | j � S( N( R t hypotR R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __abs__� s c C s" | j r t d � n t | j � S( Ns, can't convert Complex with nonzero im to int( R t ValueErrort intR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __int__� s c C s" | j r t d � n t | j � S( Ns- can't convert Complex with nonzero im to long( R R% t longR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __long__� s c C s" | j r t d � n t | j � S( Ns. can't convert Complex with nonzero im to float( R R% t floatR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __float__� s c C s1 t | � } t | j | j f | j | j f � S( N( R t cmpR R ( R t other( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __cmp__� s c C s t | � } t | | � S( N( R R, ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rcmp__� s c C s! | j | j k o d k n S( Ni ( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __nonzero__� s c C s& | t t t j | j | j � t S( N( R t halfpiR t atan2R R ( R R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt angle� s c C s- t | � } t | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __add__� s c C s- t | � } t | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __sub__� s c C s t | � } | | S( N( R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rsub__� s c C sI t | � } t | j | j | j | j | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __mul__� s c C s� t | � } t | j | j | j | j � } | sB t d � n t | j | j | j | j | | j | j | j | j | � S( Ns Complex division( R R* R R t ZeroDivisionErrorR ( R R- t d( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __div__� s $ "c C s t | � } | | S( N( R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rdiv__� s c C s� | d k r t d � n t | � rk | j r_ | j rB t d � q_ t t j | j � | � Sn | j } n t | j � | � } | | j � } t t j | � | t j | � | � S( Ns& Complex does not support ternary pow()s Complex to the Complex power( t NoneR R R t expR t logR t powt absR3 R R R ( R t nt zR R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __pow__� s c C s t | � } t | | � S( N( R R? ( R t base( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rpow__� s N( t __name__t __module__R R R R R R! R" R$ R' R) R+ R. R/ R0 R@ t radiusR R3 R R4 t __radd__R5 R6 R7 t __rmul__R: R; R< RC RE ( ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyR ` s6 c C s? t j | j � } t t j | j � | t j | j � | � S( N( R R= R R R R R ( RB R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyR= � s g���ư>c C s� d G| Gd G| Gy t | � } Wn t j } n Xd G| GHt | t � sZ t | t � ri | | k } n t | | � | k } | s� d G| Gd Gt | | � GHn d S( Ns t ands ->s !! !! !! should bet diff( t evalt syst exc_typeR t strR@ ( t exprt at bR t fuzzt resultt ok( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt checkop� s c C s d GHd t � f d t � f d! t d � f d" t d d � f d# t t d d � � f d$ t t d d � d � f d% t d t d d � � f d& t d t d � � f d' t d t d d � � f d( t t d d � t d d � � f f } d d g } x� | D]x } | d c d 7<| d d | d j k sH| d d | d j k r� d G| d Gd G| d GH| d c d 7<q� q� Wd G| d Gd G| d Gd GHi d) d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d* d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d+ d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d, d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d- d t d d � d f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � d f d t d d � d f g d 6d. d t d d � d f t d d � d d f t d d � t d � d f t d � t d d � d f g d 6} xI t | � D]; } | d GH| f } x | | D] } t | | � q�Wq�Wd S(/ Ns test constructorsi i i i i i����i����i i s expectedt gots t ofs tests failedi i s a+bi����i����s a-bs a*bg �?g�������?g��������s a/bi s pow(a,b)s cmp(a,b)t :( i i ( i i ( i i ( i i ( i i ( i i ( i i ( i i ( i����i ( i����i ( i i i ( i i i����( i i i ( g �?i g�������?( i i i ( i i i����( R R R t sortedRW ( t constructor_testt cntt tt testsuiteRQ t item( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt test� sn * 6 $+ $+ $+ $+ $ % t __main__( ( R RN t piR R1 R R R R R R R= RW Ra RF ( ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt <module>A s � J README 0000644 00000001012 15204305157 0005420 0 ustar 00 Examples of classes that implement special operators (see reference manual): Complex.py Complex numbers Dates.py Date manipulation package by Tim Peters Dbm.py Wrapper around built-in dbm, supporting arbitrary values Range.py Example of a generator: re-implement built-in range() Rev.py Yield the reverse of a sequence Vec.py A simple vector class bitvec.py A bit-vector class by Jan-Hein B\"uhrman (For straightforward examples of basic class features, such as use of methods and inheritance, see the library code.) Range.pyc 0000644 00000007773 15204305157 0006335 0 ustar 00 � ��^c @ sN d Z d � Z d � Z d d d � � YZ d � Z e d k rJ e � n d S( s Example of a generator: re-implement the built-in range function without actually constructing the list of values. OldStyleRange is coded in the way required to work in a 'for' loop before iterators were introduced into the language; using __getitem__ and __len__ . c C s� y� t | � d k r, d t | d � d f St | � d k r_ t | d � t | d � d f St | � d k r� | d d k r� t d � � n t d � | D� � St d t | � � � Wn t k r� t d � � n Xd S( sg Take list of arguments and extract/create proper start, stop, and step values and return in a tuplei i i i s step argument must not be zeroc s s | ] } t | � Vq d S( N( t int( t .0t x( ( s* /usr/lib64/python2.7/Demo/classes/Range.pys <genexpr> s s$ range() accepts 1-3 arguments, givensA range() arguments must be numbers or strings representing numbersN( t lenR t ValueErrort tuplet TypeError( t arglist( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt handleargs s ! c g sA t | � \ } } } | } x | | k r< | V| | 7} q Wd S( s, Function to implement 'range' as a generatorN( R ( t at startt stopt stept value( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt genrange s t oldrangec B s2 e Z d Z d � Z d � Z d � Z d � Z RS( s Class implementing a range object. To the user the instances feel like immutable sequences (and you can't concatenate or slice them) Done using the old way (pre-iterators; __len__ and __getitem__) to have an object be used by a 'for' loop. c G sE t | � \ | _ | _ | _ t d | j | j | j � | _ d S( s� Initialize start, stop, and step values along with calculating the nubmer of values (what __len__ will return) in the rangei N( R R R R t maxR ( t selfR ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __init__, s c C s d | j | j | j f S( s- implement repr(x) which is also used by prints range(%r, %r, %r)( R R R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __repr__2 s c C s | j S( s implement len(x)( R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __len__6 s c C s> d | k o | j k n r1 | j | j | St d � d S( s implement x[i]i s range[i] index out of rangeN( R R R t IndexError( R t i( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt __getitem__: s ( t __name__t __module__t __doc__R R R R ( ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyR " s c C s9 d d l } d d l } | j d d d � } t t d d d � � } t t d d d � � } | | k su | | k r� t d | | | f � � n d GH| j � } x t d � D] } q� W| j � } x t d � D] } q� W| j � } x | j d � D] } q� W| j � } | | Gd GH| | Gd GH| | Gd GHd S( Ni����i id i sE error in implementation: correct = %s old-style = %s generator = %ss Timings for range(1000):i� s sec (old-style class)s sec (generator)s sec (built-in)( t timet __builtin__t ranget listR R t Exception( R R t correct_resultt oldrange_resultt genrange_resultt t1R t t2t t3t t4( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt testB s* t __main__N( ( R R R R R' R ( ( ( s* /usr/lib64/python2.7/Demo/classes/Range.pyt <module> s Dbm.pyo 0000644 00000004730 15204305157 0006005 0 ustar 00 � ��^c @ s' d d d � � YZ d � Z e � d S( t Dbmc B sP e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s( d d l } | j | | | � | _ d S( Ni����( t dbmt opent db( t selft filenamet modet permR ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __init__ s c C sd d } xO | j � D]A } t | � d t | | � } | rJ d | } n | | } q Wd | d S( Nt s : s , t {t }( t keyst repr( R t st keyt t( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __repr__ s c C s t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __len__ s c C s t | j t | � � S( N( t evalR R ( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __getitem__ s c C s t | � | j t | � <d S( N( R R ( R R t value( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __setitem__ s c C s | j t | � =d S( N( R R ( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt __delitem__ s c C s7 g } x* | j j � D] } | j t | � � q W| S( N( R R t appendR ( R t resR ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR ! s c C s | j j t | � � S( N( R t has_keyR ( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR ' s ( t __name__t __module__R R R R R R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyR s c C s� t d d d � } | GHx� ya t d � } | j | � rN | | } d G| GHn t d � } | d k rp | | =n | | | <Wq t k r� d GH| GHq t k r� d GHPq Xq W| GHd S( Ns @dbmt rwi� s key: s currently:s value: R s [eof]( R t inputR t Nonet KeyboardInterruptt EOFError( t dR R ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt test+ s& N( ( R R$ ( ( ( s( /usr/lib64/python2.7/Demo/classes/Dbm.pyt <module> s $ Complex.py 0000644 00000023342 15204305157 0006533 0 ustar 00 # Complex numbers # --------------- # [Now that Python has a complex data type built-in, this is not very # useful, but it's still a nice example class] # This module represents complex numbers as instances of the class Complex. # A Complex instance z has two data attribues, z.re (the real part) and z.im # (the imaginary part). In fact, z.re and z.im can have any value -- all # arithmetic operators work regardless of the type of z.re and z.im (as long # as they support numerical operations). # # The following functions exist (Complex is actually a class): # Complex([re [,im]) -> creates a complex number from a real and an imaginary part # IsComplex(z) -> true iff z is a complex number (== has .re and .im attributes) # ToComplex(z) -> a complex number equal to z; z itself if IsComplex(z) is true # if z is a tuple(re, im) it will also be converted # PolarToComplex([r [,phi [,fullcircle]]]) -> # the complex number z for which r == z.radius() and phi == z.angle(fullcircle) # (r and phi default to 0) # exp(z) -> returns the complex exponential of z. Equivalent to pow(math.e,z). # # Complex numbers have the following methods: # z.abs() -> absolute value of z # z.radius() == z.abs() # z.angle([fullcircle]) -> angle from positive X axis; fullcircle gives units # z.phi([fullcircle]) == z.angle(fullcircle) # # These standard functions and unary operators accept complex arguments: # abs(z) # -z # +z # not z # repr(z) == `z` # str(z) # hash(z) -> a combination of hash(z.re) and hash(z.im) such that if z.im is zero # the result equals hash(z.re) # Note that hex(z) and oct(z) are not defined. # # These conversions accept complex arguments only if their imaginary part is zero: # int(z) # long(z) # float(z) # # The following operators accept two complex numbers, or one complex number # and one real number (int, long or float): # z1 + z2 # z1 - z2 # z1 * z2 # z1 / z2 # pow(z1, z2) # cmp(z1, z2) # Note that z1 % z2 and divmod(z1, z2) are not defined, # nor are shift and mask operations. # # The standard module math does not support complex numbers. # The cmath modules should be used instead. # # Idea: # add a class Polar(r, phi) and mixed-mode arithmetic which # chooses the most appropriate type for the result: # Complex for +,-,cmp # Polar for *,/,pow import math import sys twopi = math.pi*2.0 halfpi = math.pi/2.0 def IsComplex(obj): return hasattr(obj, 're') and hasattr(obj, 'im') def ToComplex(obj): if IsComplex(obj): return obj elif isinstance(obj, tuple): return Complex(*obj) else: return Complex(obj) def PolarToComplex(r = 0, phi = 0, fullcircle = twopi): phi = phi * (twopi / fullcircle) return Complex(math.cos(phi)*r, math.sin(phi)*r) def Re(obj): if IsComplex(obj): return obj.re return obj def Im(obj): if IsComplex(obj): return obj.im return 0 class Complex: def __init__(self, re=0, im=0): _re = 0 _im = 0 if IsComplex(re): _re = re.re _im = re.im else: _re = re if IsComplex(im): _re = _re - im.im _im = _im + im.re else: _im = _im + im # this class is immutable, so setting self.re directly is # not possible. self.__dict__['re'] = _re self.__dict__['im'] = _im def __setattr__(self, name, value): raise TypeError, 'Complex numbers are immutable' def __hash__(self): if not self.im: return hash(self.re) return hash((self.re, self.im)) def __repr__(self): if not self.im: return 'Complex(%r)' % (self.re,) else: return 'Complex(%r, %r)' % (self.re, self.im) def __str__(self): if not self.im: return repr(self.re) else: return 'Complex(%r, %r)' % (self.re, self.im) def __neg__(self): return Complex(-self.re, -self.im) def __pos__(self): return self def __abs__(self): return math.hypot(self.re, self.im) def __int__(self): if self.im: raise ValueError, "can't convert Complex with nonzero im to int" return int(self.re) def __long__(self): if self.im: raise ValueError, "can't convert Complex with nonzero im to long" return long(self.re) def __float__(self): if self.im: raise ValueError, "can't convert Complex with nonzero im to float" return float(self.re) def __cmp__(self, other): other = ToComplex(other) return cmp((self.re, self.im), (other.re, other.im)) def __rcmp__(self, other): other = ToComplex(other) return cmp(other, self) def __nonzero__(self): return not (self.re == self.im == 0) abs = radius = __abs__ def angle(self, fullcircle = twopi): return (fullcircle/twopi) * ((halfpi - math.atan2(self.re, self.im)) % twopi) phi = angle def __add__(self, other): other = ToComplex(other) return Complex(self.re + other.re, self.im + other.im) __radd__ = __add__ def __sub__(self, other): other = ToComplex(other) return Complex(self.re - other.re, self.im - other.im) def __rsub__(self, other): other = ToComplex(other) return other - self def __mul__(self, other): other = ToComplex(other) return Complex(self.re*other.re - self.im*other.im, self.re*other.im + self.im*other.re) __rmul__ = __mul__ def __div__(self, other): other = ToComplex(other) d = float(other.re*other.re + other.im*other.im) if not d: raise ZeroDivisionError, 'Complex division' return Complex((self.re*other.re + self.im*other.im) / d, (self.im*other.re - self.re*other.im) / d) def __rdiv__(self, other): other = ToComplex(other) return other / self def __pow__(self, n, z=None): if z is not None: raise TypeError, 'Complex does not support ternary pow()' if IsComplex(n): if n.im: if self.im: raise TypeError, 'Complex to the Complex power' else: return exp(math.log(self.re)*n) n = n.re r = pow(self.abs(), n) phi = n*self.angle() return Complex(math.cos(phi)*r, math.sin(phi)*r) def __rpow__(self, base): base = ToComplex(base) return pow(base, self) def exp(z): r = math.exp(z.re) return Complex(math.cos(z.im)*r,math.sin(z.im)*r) def checkop(expr, a, b, value, fuzz = 1e-6): print ' ', a, 'and', b, try: result = eval(expr) except: result = sys.exc_type print '->', result if isinstance(result, str) or isinstance(value, str): ok = (result == value) else: ok = abs(result - value) <= fuzz if not ok: print '!!\t!!\t!! should be', value, 'diff', abs(result - value) def test(): print 'test constructors' constructor_test = ( # "expect" is an array [re,im] "got" the Complex. ( (0,0), Complex() ), ( (0,0), Complex() ), ( (1,0), Complex(1) ), ( (0,1), Complex(0,1) ), ( (1,2), Complex(Complex(1,2)) ), ( (1,3), Complex(Complex(1,2),1) ), ( (0,0), Complex(0,Complex(0,0)) ), ( (3,4), Complex(3,Complex(4)) ), ( (-1,3), Complex(1,Complex(3,2)) ), ( (-7,6), Complex(Complex(1,2),Complex(4,8)) ) ) cnt = [0,0] for t in constructor_test: cnt[0] += 1 if ((t[0][0]!=t[1].re)or(t[0][1]!=t[1].im)): print " expected", t[0], "got", t[1] cnt[1] += 1 print " ", cnt[1], "of", cnt[0], "tests failed" # test operators testsuite = { 'a+b': [ (1, 10, 11), (1, Complex(0,10), Complex(1,10)), (Complex(0,10), 1, Complex(1,10)), (Complex(0,10), Complex(1), Complex(1,10)), (Complex(1), Complex(0,10), Complex(1,10)), ], 'a-b': [ (1, 10, -9), (1, Complex(0,10), Complex(1,-10)), (Complex(0,10), 1, Complex(-1,10)), (Complex(0,10), Complex(1), Complex(-1,10)), (Complex(1), Complex(0,10), Complex(1,-10)), ], 'a*b': [ (1, 10, 10), (1, Complex(0,10), Complex(0, 10)), (Complex(0,10), 1, Complex(0,10)), (Complex(0,10), Complex(1), Complex(0,10)), (Complex(1), Complex(0,10), Complex(0,10)), ], 'a/b': [ (1., 10, 0.1), (1, Complex(0,10), Complex(0, -0.1)), (Complex(0, 10), 1, Complex(0, 10)), (Complex(0, 10), Complex(1), Complex(0, 10)), (Complex(1), Complex(0,10), Complex(0, -0.1)), ], 'pow(a,b)': [ (1, 10, 1), (1, Complex(0,10), 1), (Complex(0,10), 1, Complex(0,10)), (Complex(0,10), Complex(1), Complex(0,10)), (Complex(1), Complex(0,10), 1), (2, Complex(4,0), 16), ], 'cmp(a,b)': [ (1, 10, -1), (1, Complex(0,10), 1), (Complex(0,10), 1, -1), (Complex(0,10), Complex(1), -1), (Complex(1), Complex(0,10), 1), ], } for expr in sorted(testsuite): print expr + ':' t = (expr,) for item in testsuite[expr]: checkop(*(t+item)) if __name__ == '__main__': test() Dates.py 0000644 00000017215 15204305157 0006166 0 ustar 00 # Class Date supplies date objects that support date arithmetic. # # Date(month,day,year) returns a Date object. An instance prints as, # e.g., 'Mon 16 Aug 1993'. # # Addition, subtraction, comparison operators, min, max, and sorting # all work as expected for date objects: int+date or date+int returns # the date `int' days from `date'; date+date raises an exception; # date-int returns the date `int' days before `date'; date2-date1 returns # an integer, the number of days from date1 to date2; int-date raises an # exception; date1 < date2 is true iff date1 occurs before date2 (& # similarly for other comparisons); min(date1,date2) is the earlier of # the two dates and max(date1,date2) the later; and date objects can be # used as dictionary keys. # # Date objects support one visible method, date.weekday(). This returns # the day of the week the date falls on, as a string. # # Date objects also have 4 read-only data attributes: # .month in 1..12 # .day in 1..31 # .year int or long int # .ord the ordinal of the date relative to an arbitrary staring point # # The Dates module also supplies function today(), which returns the # current date as a date object. # # Those entranced by calendar trivia will be disappointed, as no attempt # has been made to accommodate the Julian (etc) system. On the other # hand, at least this package knows that 2000 is a leap year but 2100 # isn't, and works fine for years with a hundred decimal digits <wink>. # Tim Peters tim@ksr.com # not speaking for Kendall Square Research Corp # Adapted to Python 1.1 (where some hacks to overcome coercion are unnecessary) # by Guido van Rossum # Note that as of Python 2.3, a datetime module is included in the stardard # library. # vi:set tabsize=8: _MONTH_NAMES = [ 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December' ] _DAY_NAMES = [ 'Friday', 'Saturday', 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday' ] _DAYS_IN_MONTH = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ] _DAYS_BEFORE_MONTH = [] dbm = 0 for dim in _DAYS_IN_MONTH: _DAYS_BEFORE_MONTH.append(dbm) dbm = dbm + dim del dbm, dim _INT_TYPES = type(1), type(1L) def _is_leap(year): # 1 if leap year, else 0 if year % 4 != 0: return 0 if year % 400 == 0: return 1 return year % 100 != 0 def _days_in_year(year): # number of days in year return 365 + _is_leap(year) def _days_before_year(year): # number of days before year return year*365L + (year+3)//4 - (year+99)//100 + (year+399)//400 def _days_in_month(month, year): # number of days in month of year if month == 2 and _is_leap(year): return 29 return _DAYS_IN_MONTH[month-1] def _days_before_month(month, year): # number of days in year before month return _DAYS_BEFORE_MONTH[month-1] + (month > 2 and _is_leap(year)) def _date2num(date): # compute ordinal of date.month,day,year return _days_before_year(date.year) + \ _days_before_month(date.month, date.year) + \ date.day _DI400Y = _days_before_year(400) # number of days in 400 years def _num2date(n): # return date with ordinal n if type(n) not in _INT_TYPES: raise TypeError, 'argument must be integer: %r' % type(n) ans = Date(1,1,1) # arguments irrelevant; just getting a Date obj del ans.ord, ans.month, ans.day, ans.year # un-initialize it ans.ord = n n400 = (n-1)//_DI400Y # # of 400-year blocks preceding year, n = 400 * n400, n - _DI400Y * n400 more = n // 365 dby = _days_before_year(more) if dby >= n: more = more - 1 dby = dby - _days_in_year(more) year, n = year + more, int(n - dby) try: year = int(year) # chop to int, if it fits except (ValueError, OverflowError): pass month = min(n//29 + 1, 12) dbm = _days_before_month(month, year) if dbm >= n: month = month - 1 dbm = dbm - _days_in_month(month, year) ans.month, ans.day, ans.year = month, n-dbm, year return ans def _num2day(n): # return weekday name of day with ordinal n return _DAY_NAMES[ int(n % 7) ] class Date: def __init__(self, month, day, year): if not 1 <= month <= 12: raise ValueError, 'month must be in 1..12: %r' % (month,) dim = _days_in_month(month, year) if not 1 <= day <= dim: raise ValueError, 'day must be in 1..%r: %r' % (dim, day) self.month, self.day, self.year = month, day, year self.ord = _date2num(self) # don't allow setting existing attributes def __setattr__(self, name, value): if self.__dict__.has_key(name): raise AttributeError, 'read-only attribute ' + name self.__dict__[name] = value def __cmp__(self, other): return cmp(self.ord, other.ord) # define a hash function so dates can be used as dictionary keys def __hash__(self): return hash(self.ord) # print as, e.g., Mon 16 Aug 1993 def __repr__(self): return '%.3s %2d %.3s %r' % ( self.weekday(), self.day, _MONTH_NAMES[self.month-1], self.year) # Python 1.1 coerces neither int+date nor date+int def __add__(self, n): if type(n) not in _INT_TYPES: raise TypeError, 'can\'t add %r to date' % type(n) return _num2date(self.ord + n) __radd__ = __add__ # handle int+date # Python 1.1 coerces neither date-int nor date-date def __sub__(self, other): if type(other) in _INT_TYPES: # date-int return _num2date(self.ord - other) else: return self.ord - other.ord # date-date # complain about int-date def __rsub__(self, other): raise TypeError, 'Can\'t subtract date from integer' def weekday(self): return _num2day(self.ord) def today(): import time local = time.localtime(time.time()) return Date(local[1], local[2], local[0]) class DateTestError(Exception): pass def test(firstyear, lastyear): a = Date(9,30,1913) b = Date(9,30,1914) if repr(a) != 'Tue 30 Sep 1913': raise DateTestError, '__repr__ failure' if (not a < b) or a == b or a > b or b != b: raise DateTestError, '__cmp__ failure' if a+365 != b or 365+a != b: raise DateTestError, '__add__ failure' if b-a != 365 or b-365 != a: raise DateTestError, '__sub__ failure' try: x = 1 - a raise DateTestError, 'int-date should have failed' except TypeError: pass try: x = a + b raise DateTestError, 'date+date should have failed' except TypeError: pass if a.weekday() != 'Tuesday': raise DateTestError, 'weekday() failure' if max(a,b) is not b or min(a,b) is not a: raise DateTestError, 'min/max failure' d = {a-1:b, b:a+1} if d[b-366] != b or d[a+(b-a)] != Date(10,1,1913): raise DateTestError, 'dictionary failure' # verify date<->number conversions for first and last days for # all years in firstyear .. lastyear lord = _days_before_year(firstyear) y = firstyear while y <= lastyear: ford = lord + 1 lord = ford + _days_in_year(y) - 1 fd, ld = Date(1,1,y), Date(12,31,y) if (fd.ord,ld.ord) != (ford,lord): raise DateTestError, ('date->num failed', y) fd, ld = _num2date(ford), _num2date(lord) if (1,1,y,12,31,y) != \ (fd.month,fd.day,fd.year,ld.month,ld.day,ld.year): raise DateTestError, ('num->date failed', y) y = y + 1 if __name__ == '__main__': test(1850, 2150) bitvec.pyc 0000644 00000024065 15204305160 0006540 0 ustar 00 � ��^c @ s{ d d l Z e j j Z d e f d � � YZ d � Z d d l Z d � Z d � Z d � Z d f d � � YZ e Z d S( i����Nt errorc B s e Z RS( ( t __name__t __module__( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR s c C sE t | � t d � k s5 d | k o/ d k n rA t d � n d S( Ni i s) bitvec() items must have int value 0 or 1( t typeR ( t value( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_value s 5c C s� t j t | � � \ } } d | >} | | k rM t d | | f f � � n x, | r{ | d ?} | | @rn Pn | d } qP W| S( Nl s (param, l) = %ri ( t matht frexpt floatt RuntimeError( t paramt mantt lt bitmask( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _compute_len s c C si t | � t d � k r$ t d � n | d k r= | | } n d | k oT | k n se t d � n | S( Ni s sequence subscript not ints list index out of range( R t TypeErrort IndexError( t lent key( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_key! s c C s> t | d � t | | � } } | | k r4 | } n | | f S( Ni ( t maxt min( R t it j( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_slice* s t BitVecc B s e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c G s� d | _ d | _ t | � s! n�t | � d k r | \ } t | � t g � k r� d } d } x+ | D]# } | r� | | B} n | d >} qg W| | _ t | � | _ q�t | � t d � k r� | d k r� t d � n | | _ t | � | _ q�t d � n� t | � d k r�| \ } } t | � t d � k r�| d k rNt d � n | | _ t | � t d � k r{t d � n t | � } | | k r�d GH| j d | >d @| _ n | | _ q�t d � n t d � d S( Nl i i l s$ bitvec() can't handle negative longss) bitvec() requires array or long parameteri s can't handle negative longss$ bitvec()'s 2nd parameter must be intsM warning: bitvec() value is longer than the length indicates, truncating values% bitvec() requires 0 -- 2 parameter(s)( t _datat _lenR R R R ( t selft paramsR R t bit_maskt itemt lengtht computed_length( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __init__4 sL c C s( t t | � d � | | j | j +d S( Ni ( R t longR ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt appendb s c C sR | r | j } n | j } d } x) | rM | d ?| | d @d k } } q% W| S( Ni i ( R ( R R t datat count( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR& i s #c C s^ | r | j } n | j } d } | s4 t d � n x# | d @sY | d ?| d } } q7 W| S( Ni s list.index(x): x not in listi ( R t ValueError( R R R% t index( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR( u s c C s" t t | � d � | | | +d S( Ni ( R R# ( R R( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt insert� s c C s | | j | � =d S( N( R( ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt remove� s c C so | j d } } xO t | j � D]> } | sA | | j | >} Pn | d >| d @B| d ?} } q W| | _ d S( Nl i ( R t rangeR ( R R% t resultR ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt reverse� s !c C s/ | j d � } d | >d | j | >| _ d S( Ni l ( R& R R ( R t c( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt sort� s c C s t | j | j � S( N( R R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt copy� s c C s( g } x | D] } | j | � q W| S( N( R$ ( R R, R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt seq� s c C s d | j | j f S( Ns bitvec(%r, %r)( R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __repr__� s c G s# t | � t | � k r1 t t | f | � } n | j } | d k sU | j d k re t | | j � S| | j k r� t | | j � } t | | | | � p� t | | | | � S| j | j k r� d S| d k r� t | d | d � S| d ?} t | | | | � p t | | | | � Sd S( Ni i ( R t applyt bitvecR t cmpR R ( R t othert restR t min_length( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __cmp__� s c C s | j S( N( R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __len__� s c C s' t | j | � } | j d | >@d k S( Nl i ( R R R ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __getitem__� s c C sH t | j | � } | r/ | j d | >B| _ n | j d | >@| _ d S( Nl ( R R R ( R R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __setitem__� s c C sI t | j | � } | | j | | d j | ?B| _ | j d | _ d S( Ni ( R R R ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __delitem__� s #c C s� t | j | | � \ } } | | k r4 t d d � S| rJ | j | ?} n | j } | | } | | j k r� | d | >d @} n t | | � S( Nl i l i ( R R R R ( R R R t ndatat nlength( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __getslice__� s c G s� t | j | | � \ } } t | � t | � k rL t t | f | � } n | | } | | } | j | j | j | j >B| j >B| _ | j | | | j | _ d S( N( R R R R3 R4 R ( R R R t sequenceR7 t ls_partt ms_part( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __setslice__� s c C s� t | j | | � \ } } | d k rK | | j k rK d \ | _ | _ nB | | k r� | | j | | j | ?B| _ | j | | | _ n d S( Ni l ( l i ( R R R ( R R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __delslice__� s c C s# | j � } | | | j | j +| S( N( R0 R ( R R6 t retval( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __add__ s c C s� t | � t d � k r$ t d � n | d k r= t d d � S| d k rS | j � S| j d k rv t d | j | � S| j d k r� t d | j | � St d d � } x | r� | | | d } } q� W| S( Ni s sequence subscript not intl i ( R R R R0 R R ( R t multiplierRF ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __mul__ s c G sW t | � t | � k r1 t t | f | � } n t | j | j @t | j | j � � S( N( R R3 R4 R R R R ( R t otherseqR7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __and__ s c G sW t | � t | � k r1 t t | f | � } n t | j | j At | j | j � � S( N( R R3 R4 R R R R ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __xor__% s c G sW t | � t | � k r1 t t | f | � } n t | j | j Bt | j | j � � S( N( R R3 R4 R R R R ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __or__. s c C s# t | j d | j >d @| j � S( Nl i ( R R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __invert__7 s c G s; t | � t | � k r1 t t | f | � } n | | f S( N( R R3 R4 ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __coerce__< s c C s t | j � S( N( t intR ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __int__C s c C s t | j � S( N( R# R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __long__F s c C s t | j � S( N( R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __float__I s ( R R R" R$ R& R( R) R* R- R/ R0 R1 R2 R9 R: R; R< R= R@ RD RE RG RI RK RL RM RN RO RQ RR RS ( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR 2 s: . ( t syst stderrt writet rprtt ExceptionR R R R R R R R4 ( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt <module> s � Vec.pyo 0000644 00000005404 15204305160 0006011 0 ustar 00 � ��^c @ s' d d d � � YZ d � Z e � d S( t Vecc B sb e Z d Z d � Z e d � � Z d � Z d � Z d � Z d � Z d � Z d � Z e Z RS( sx A simple vector class Instances of the Vec class can be constructed from numbers >>> a = Vec(1, 2, 3) >>> b = Vec(3, 2, 1) added >>> a + b Vec(4, 4, 4) subtracted >>> a - b Vec(-2, 0, 2) and multiplied by a scalar on the left >>> 3.0 * a Vec(3.0, 6.0, 9.0) or on the right >>> a * 3.0 Vec(3.0, 6.0, 9.0) c G s t | � | _ d S( N( t listt v( t selfR ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __init__ s c C s. t | t � s t � n | � } | | _ | S( N( t isinstanceR t TypeErrorR ( t clsR t inst( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt fromlist s c C s) d j d � | j D� � } d j | � S( Ns , c s s | ] } t | � Vq d S( N( t repr( t .0t x( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pys <genexpr>% s s Vec({0})( t joinR t format( R t args( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __repr__$ s c C s t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __len__( s c C s | j | S( N( R ( R t i( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __getitem__+ s c C s? g t | j | j � D] \ } } | | ^ q } t j | � S( N( t zipR R R ( R t otherR t yR ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __add__. s 2c C s? g t | j | j � D] \ } } | | ^ q } t j | � S( N( R R R R ( R R R R R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __sub__3 s 2c C s- g | j D] } | | ^ q } t j | � S( N( R R R ( R t scalarR R ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt __mul__8 s ( t __name__t __module__t __doc__R t classmethodR R R R R R R t __rmul__( ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyR s c C s d d l } | j � d S( Ni����( t doctestt testmod( R! ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt test@ s N( ( R R# ( ( ( s( /usr/lib64/python2.7/Demo/classes/Vec.pyt <module> s ? bitvec.py 0000644 00000024377 15204305160 0006403 0 ustar 00 # # this is a rather strict implementation of a bit vector class # it is accessed the same way as an array of python-ints, except # the value must be 0 or 1 # import sys; rprt = sys.stderr.write #for debugging class error(Exception): pass def _check_value(value): if type(value) != type(0) or not 0 <= value < 2: raise error, 'bitvec() items must have int value 0 or 1' import math def _compute_len(param): mant, l = math.frexp(float(param)) bitmask = 1L << l if bitmask <= param: raise RuntimeError('(param, l) = %r' % ((param, l),)) while l: bitmask = bitmask >> 1 if param & bitmask: break l = l - 1 return l def _check_key(len, key): if type(key) != type(0): raise TypeError, 'sequence subscript not int' if key < 0: key = key + len if not 0 <= key < len: raise IndexError, 'list index out of range' return key def _check_slice(len, i, j): #the type is ok, Python already checked that i, j = max(i, 0), min(len, j) if i > j: i = j return i, j class BitVec: def __init__(self, *params): self._data = 0L self._len = 0 if not len(params): pass elif len(params) == 1: param, = params if type(param) == type([]): value = 0L bit_mask = 1L for item in param: # strict check #_check_value(item) if item: value = value | bit_mask bit_mask = bit_mask << 1 self._data = value self._len = len(param) elif type(param) == type(0L): if param < 0: raise error, 'bitvec() can\'t handle negative longs' self._data = param self._len = _compute_len(param) else: raise error, 'bitvec() requires array or long parameter' elif len(params) == 2: param, length = params if type(param) == type(0L): if param < 0: raise error, \ 'can\'t handle negative longs' self._data = param if type(length) != type(0): raise error, 'bitvec()\'s 2nd parameter must be int' computed_length = _compute_len(param) if computed_length > length: print 'warning: bitvec() value is longer than the length indicates, truncating value' self._data = self._data & \ ((1L << length) - 1) self._len = length else: raise error, 'bitvec() requires array or long parameter' else: raise error, 'bitvec() requires 0 -- 2 parameter(s)' def append(self, item): #_check_value(item) #self[self._len:self._len] = [item] self[self._len:self._len] = \ BitVec(long(not not item), 1) def count(self, value): #_check_value(value) if value: data = self._data else: data = (~self)._data count = 0 while data: data, count = data >> 1, count + (data & 1 != 0) return count def index(self, value): #_check_value(value): if value: data = self._data else: data = (~self)._data index = 0 if not data: raise ValueError, 'list.index(x): x not in list' while not (data & 1): data, index = data >> 1, index + 1 return index def insert(self, index, item): #_check_value(item) #self[index:index] = [item] self[index:index] = BitVec(long(not not item), 1) def remove(self, value): del self[self.index(value)] def reverse(self): #ouch, this one is expensive! #for i in self._len>>1: self[i], self[l-i] = self[l-i], self[i] data, result = self._data, 0L for i in range(self._len): if not data: result = result << (self._len - i) break result, data = (result << 1) | (data & 1), data >> 1 self._data = result def sort(self): c = self.count(1) self._data = ((1L << c) - 1) << (self._len - c) def copy(self): return BitVec(self._data, self._len) def seq(self): result = [] for i in self: result.append(i) return result def __repr__(self): ##rprt('<bitvec class instance object>.' + '__repr__()\n') return 'bitvec(%r, %r)' % (self._data, self._len) def __cmp__(self, other, *rest): #rprt('%r.__cmp__%r\n' % (self, (other,) + rest)) if type(other) != type(self): other = apply(bitvec, (other, ) + rest) #expensive solution... recursive binary, with slicing length = self._len if length == 0 or other._len == 0: return cmp(length, other._len) if length != other._len: min_length = min(length, other._len) return cmp(self[:min_length], other[:min_length]) or \ cmp(self[min_length:], other[min_length:]) #the lengths are the same now... if self._data == other._data: return 0 if length == 1: return cmp(self[0], other[0]) else: length = length >> 1 return cmp(self[:length], other[:length]) or \ cmp(self[length:], other[length:]) def __len__(self): #rprt('%r.__len__()\n' % (self,)) return self._len def __getitem__(self, key): #rprt('%r.__getitem__(%r)\n' % (self, key)) key = _check_key(self._len, key) return self._data & (1L << key) != 0 def __setitem__(self, key, value): #rprt('%r.__setitem__(%r, %r)\n' % (self, key, value)) key = _check_key(self._len, key) #_check_value(value) if value: self._data = self._data | (1L << key) else: self._data = self._data & ~(1L << key) def __delitem__(self, key): #rprt('%r.__delitem__(%r)\n' % (self, key)) key = _check_key(self._len, key) #el cheapo solution... self._data = self[:key]._data | self[key+1:]._data >> key self._len = self._len - 1 def __getslice__(self, i, j): #rprt('%r.__getslice__(%r, %r)\n' % (self, i, j)) i, j = _check_slice(self._len, i, j) if i >= j: return BitVec(0L, 0) if i: ndata = self._data >> i else: ndata = self._data nlength = j - i if j != self._len: #we'll have to invent faster variants here #e.g. mod_2exp ndata = ndata & ((1L << nlength) - 1) return BitVec(ndata, nlength) def __setslice__(self, i, j, sequence, *rest): #rprt('%s.__setslice__%r\n' % (self, (i, j, sequence) + rest)) i, j = _check_slice(self._len, i, j) if type(sequence) != type(self): sequence = apply(bitvec, (sequence, ) + rest) #sequence is now of our own type ls_part = self[:i] ms_part = self[j:] self._data = ls_part._data | \ ((sequence._data | \ (ms_part._data << sequence._len)) << ls_part._len) self._len = self._len - j + i + sequence._len def __delslice__(self, i, j): #rprt('%r.__delslice__(%r, %r)\n' % (self, i, j)) i, j = _check_slice(self._len, i, j) if i == 0 and j == self._len: self._data, self._len = 0L, 0 elif i < j: self._data = self[:i]._data | (self[j:]._data >> i) self._len = self._len - j + i def __add__(self, other): #rprt('%r.__add__(%r)\n' % (self, other)) retval = self.copy() retval[self._len:self._len] = other return retval def __mul__(self, multiplier): #rprt('%r.__mul__(%r)\n' % (self, multiplier)) if type(multiplier) != type(0): raise TypeError, 'sequence subscript not int' if multiplier <= 0: return BitVec(0L, 0) elif multiplier == 1: return self.copy() #handle special cases all 0 or all 1... if self._data == 0L: return BitVec(0L, self._len * multiplier) elif (~self)._data == 0L: return ~BitVec(0L, self._len * multiplier) #otherwise el cheapo again... retval = BitVec(0L, 0) while multiplier: retval, multiplier = retval + self, multiplier - 1 return retval def __and__(self, otherseq, *rest): #rprt('%r.__and__%r\n' % (self, (otherseq,) + rest)) if type(otherseq) != type(self): otherseq = apply(bitvec, (otherseq, ) + rest) #sequence is now of our own type return BitVec(self._data & otherseq._data, \ min(self._len, otherseq._len)) def __xor__(self, otherseq, *rest): #rprt('%r.__xor__%r\n' % (self, (otherseq,) + rest)) if type(otherseq) != type(self): otherseq = apply(bitvec, (otherseq, ) + rest) #sequence is now of our own type return BitVec(self._data ^ otherseq._data, \ max(self._len, otherseq._len)) def __or__(self, otherseq, *rest): #rprt('%r.__or__%r\n' % (self, (otherseq,) + rest)) if type(otherseq) != type(self): otherseq = apply(bitvec, (otherseq, ) + rest) #sequence is now of our own type return BitVec(self._data | otherseq._data, \ max(self._len, otherseq._len)) def __invert__(self): #rprt('%r.__invert__()\n' % (self,)) return BitVec(~self._data & ((1L << self._len) - 1), \ self._len) def __coerce__(self, otherseq, *rest): #needed for *some* of the arithmetic operations #rprt('%r.__coerce__%r\n' % (self, (otherseq,) + rest)) if type(otherseq) != type(self): otherseq = apply(bitvec, (otherseq, ) + rest) return self, otherseq def __int__(self): return int(self._data) def __long__(self): return long(self._data) def __float__(self): return float(self._data) bitvec = BitVec Rev.py 0000644 00000004004 15204305160 0005644 0 ustar 00 ''' A class which presents the reverse of a sequence without duplicating it. From: "Steven D. Majewski" <sdm7g@elvis.med.virginia.edu> It works on mutable or inmutable sequences. >>> chars = list(Rev('Hello World!')) >>> print ''.join(chars) !dlroW olleH The .forw is so you can use anonymous sequences in __init__, and still keep a reference the forward sequence. ) If you give it a non-anonymous mutable sequence, the reverse sequence will track the updated values. ( but not reassignment! - another good reason to use anonymous values in creating the sequence to avoid confusion. Maybe it should be change to copy input sequence to break the connection completely ? ) >>> nnn = range(3) >>> rnn = Rev(nnn) >>> for n in rnn: print n ... 2 1 0 >>> for n in range(4, 6): nnn.append(n) # update nnn ... >>> for n in rnn: print n # prints reversed updated values ... 5 4 2 1 0 >>> nnn = nnn[1:-1] >>> nnn [1, 2, 4] >>> for n in rnn: print n # prints reversed values of old nnn ... 5 4 2 1 0 # >>> WH = Rev('Hello World!') >>> print WH.forw, WH.back Hello World! !dlroW olleH >>> nnn = Rev(range(1, 10)) >>> print nnn.forw [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> print nnn.back [9, 8, 7, 6, 5, 4, 3, 2, 1] >>> rrr = Rev(nnn) >>> rrr <1, 2, 3, 4, 5, 6, 7, 8, 9> ''' class Rev: def __init__(self, seq): self.forw = seq self.back = self def __len__(self): return len(self.forw) def __getitem__(self, j): return self.forw[-(j + 1)] def __repr__(self): seq = self.forw if isinstance(seq, list): wrap = '[]' sep = ', ' elif isinstance(seq, tuple): wrap = '()' sep = ', ' elif isinstance(seq, str): wrap = '' sep = '' else: wrap = '<>' sep = ', ' outstrs = [str(item) for item in self.back] return wrap[:1] + sep.join(outstrs) + wrap[-1:] def _test(): import doctest, Rev return doctest.testmod(Rev) if __name__ == "__main__": _test() Vec.py 0000644 00000002515 15204305160 0005632 0 ustar 00 class Vec: """ A simple vector class Instances of the Vec class can be constructed from numbers >>> a = Vec(1, 2, 3) >>> b = Vec(3, 2, 1) added >>> a + b Vec(4, 4, 4) subtracted >>> a - b Vec(-2, 0, 2) and multiplied by a scalar on the left >>> 3.0 * a Vec(3.0, 6.0, 9.0) or on the right >>> a * 3.0 Vec(3.0, 6.0, 9.0) """ def __init__(self, *v): self.v = list(v) @classmethod def fromlist(cls, v): if not isinstance(v, list): raise TypeError inst = cls() inst.v = v return inst def __repr__(self): args = ', '.join(repr(x) for x in self.v) return 'Vec({0})'.format(args) def __len__(self): return len(self.v) def __getitem__(self, i): return self.v[i] def __add__(self, other): # Element-wise addition v = [x + y for x, y in zip(self.v, other.v)] return Vec.fromlist(v) def __sub__(self, other): # Element-wise subtraction v = [x - y for x, y in zip(self.v, other.v)] return Vec.fromlist(v) def __mul__(self, scalar): # Multiply by scalar v = [x * scalar for x in self.v] return Vec.fromlist(v) __rmul__ = __mul__ def test(): import doctest doctest.testmod() test() Complex.pyo 0000644 00000023446 15204305160 0006711 0 ustar 00 � ��^c @ s� d d l Z d d l Z e j d Z e j d Z d � Z d � Z d d e d � Z d � Z d � Z d d d � � YZ d � Z d d � Z d � Z e d k r� e � n d S( i����Ng @c C s t | d � o t | d � S( Nt ret im( t hasattr( t obj( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt IsComplexG s c C s7 t | � r | St | t � r) t | � St | � Sd S( N( R t isinstancet tuplet Complex( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt ToComplexJ s i c C s5 | t | } t t j | � | t j | � | � S( N( t twopiR t matht cost sin( t rt phit fullcircle( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt PolarToComplexR s c C s t | � r | j S| S( N( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt ReV s c C s t | � r | j Sd S( Ni ( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt Im[ s R c B s� e Z d d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z e Z Z e d � Z e Z d � Z e Z d � Z d � Z d � Z e Z d � Z d � Z d d � Z d � Z RS( i c C s� d } d } t | � r- | j } | j } n | } t | � r\ | | j } | | j } n | | } | | j d <| | j d <d S( Ni R R ( R R R t __dict__( t selfR R t _ret _im( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __init__b s c C s t d � d S( Ns Complex numbers are immutable( t TypeError( R t namet value( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __setattr__t s c C s, | j s t | j � St | j | j f � S( N( R t hashR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __hash__w s c C s/ | j s d | j f Sd | j | j f Sd S( Ns Complex(%r)s Complex(%r, %r)( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __repr__| s c C s. | j s t | j � Sd | j | j f Sd S( Ns Complex(%r, %r)( R t reprR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __str__� s c C s t | j | j � S( N( R R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __neg__� s c C s | S( N( ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __pos__� s c C s t j | j | j � S( N( R t hypotR R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __abs__� s c C s" | j r t d � n t | j � S( Ns, can't convert Complex with nonzero im to int( R t ValueErrort intR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __int__� s c C s" | j r t d � n t | j � S( Ns- can't convert Complex with nonzero im to long( R R% t longR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __long__� s c C s" | j r t d � n t | j � S( Ns. can't convert Complex with nonzero im to float( R R% t floatR ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __float__� s c C s1 t | � } t | j | j f | j | j f � S( N( R t cmpR R ( R t other( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __cmp__� s c C s t | � } t | | � S( N( R R, ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rcmp__� s c C s! | j | j k o d k n S( Ni ( R R ( R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __nonzero__� s c C s& | t t t j | j | j � t S( N( R t halfpiR t atan2R R ( R R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt angle� s c C s- t | � } t | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __add__� s c C s- t | � } t | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __sub__� s c C s t | � } | | S( N( R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rsub__� s c C sI t | � } t | j | j | j | j | j | j | j | j � S( N( R R R R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __mul__� s c C s� t | � } t | j | j | j | j � } | sB t d � n t | j | j | j | j | | j | j | j | j | � S( Ns Complex division( R R* R R t ZeroDivisionErrorR ( R R- t d( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __div__� s $ "c C s t | � } | | S( N( R ( R R- ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rdiv__� s c C s� | d k r t d � n t | � rk | j r_ | j rB t d � q_ t t j | j � | � Sn | j } n t | j � | � } | | j � } t t j | � | t j | � | � S( Ns& Complex does not support ternary pow()s Complex to the Complex power( t NoneR R R t expR t logR t powt absR3 R R R ( R t nt zR R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __pow__� s c C s t | � } t | | � S( N( R R? ( R t base( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt __rpow__� s N( t __name__t __module__R R R R R R! R" R$ R' R) R+ R. R/ R0 R@ t radiusR R3 R R4 t __radd__R5 R6 R7 t __rmul__R: R; R< RC RE ( ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyR ` s6 c C s? t j | j � } t t j | j � | t j | j � | � S( N( R R= R R R R R ( RB R ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyR= � s g���ư>c C s� d G| Gd G| Gy t | � } Wn t j } n Xd G| GHt | t � sZ t | t � ri | | k } n t | | � | k } | s� d G| Gd Gt | | � GHn d S( Ns t ands ->s !! !! !! should bet diff( t evalt syst exc_typeR t strR@ ( t exprt at bR t fuzzt resultt ok( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt checkop� s c C s d GHd t � f d t � f d! t d � f d" t d d � f d# t t d d � � f d$ t t d d � d � f d% t d t d d � � f d& t d t d � � f d' t d t d d � � f d( t t d d � t d d � � f f } d d g } x� | D]x } | d c d 7<| d d | d j k sH| d d | d j k r� d G| d Gd G| d GH| d c d 7<q� q� Wd G| d Gd G| d Gd GHi d) d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d* d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d+ d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d, d t d d � t d d � f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � t d d � f g d 6d- d t d d � d f t d d � d t d d � f t d d � t d � t d d � f t d � t d d � d f d t d d � d f g d 6d. d t d d � d f t d d � d d f t d d � t d � d f t d � t d d � d f g d 6} xI t | � D]; } | d GH| f } x | | D] } t | | � q�Wq�Wd S(/ Ns test constructorsi i i i i i����i����i i s expectedt gots t ofs tests failedi i s a+bi����i����s a-bs a*bg �?g�������?g��������s a/bi s pow(a,b)s cmp(a,b)t :( i i ( i i ( i i ( i i ( i i ( i i ( i i ( i i ( i����i ( i����i ( i i i ( i i i����( i i i ( g �?i g�������?( i i i ( i i i����( R R R t sortedRW ( t constructor_testt cntt tt testsuiteRQ t item( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt test� sn * 6 $+ $+ $+ $+ $ % t __main__( ( R RN t piR R1 R R R R R R R= RW Ra RF ( ( ( s, /usr/lib64/python2.7/Demo/classes/Complex.pyt <module>A s � J Dates.pyc 0000644 00000016246 15204305160 0006326 0 ustar 00 � ��^c @ sp d d d d d d d d d d d d g Z d d d d d d d g Z d d d d d d d d d d d d g Z g Z d Z x% e D] Z e j e � e e Z q� W[ [ e d � e d � f Z d � Z d � Z d � Z d � Z d � Z d � Z e d � Z d � Z d! � Z d" d, d# � � YZ d$ � Z d% e f d& � � YZ d' � Z e d( k rle d) d* � n d+ S(- t Januaryt Februaryt Marcht Aprilt Mayt Junet Julyt Augustt Septembert Octobert Novembert Decembert Fridayt Saturdayt Sundayt Mondayt Tuesdayt Wednesdayt Thursdayi i i i i l c C s6 | d d k r d S| d d k r( d S| d d k S( Ni i i� i id ( ( t year( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _is_leap> s c C s d t | � S( Nim ( R ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_in_yearC s c C s, | d | d d | d d | d d S( Nl mi i ic id i� i� ( ( R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_before_yearF s c C s( | d k r t | � r d St | d S( Ni i i ( R t _DAYS_IN_MONTH( t monthR ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_in_monthI s c C s" t | d | d k o t | � S( Ni i ( t _DAYS_BEFORE_MONTHR ( R R ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _days_before_monthM s c C s' t | j � t | j | j � | j S( N( R R R R t day( t date( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _date2numP s i� c C s} t | � t k r( t d t | � � n t d d d � } | ` | ` | ` | ` | | _ | d t } d | | t | } } | d } t | � } | | k r� | d } | t | � } n | | t | | � } } y t | � } Wn t t f k rn Xt | d d d � } t | | � } | | k rX| d } | t | | � } n | | | | | _ | _ | _ | S( Ns argument must be integer: %ri i� im i i ( t typet _INT_TYPESt TypeErrort Datet ordR R R t _DI400YR R t intt ValueErrort OverflowErrort minR R ( t nt anst n400R t moret dbyR t dbm( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _num2dateW s0 !c C s t t | d � S( Ni ( t _DAY_NAMESR% ( R) ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt _num2dayt s R" c B s_ e Z d � Z d � Z d � Z d � Z d � Z d � Z e Z d � Z d � Z d � Z RS( c C s� d | k o d k n s/ t d | f � n t | | � } d | k oU | k n sp t d | | f � n | | | | _ | _ | _ t | � | _ d S( Ni i s month must be in 1..12: %rs day must be in 1..%r: %r( R& R R R R R R# ( t selfR R R t dim( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __init__y s c C s3 | j j | � r" t d | � n | | j | <d S( Ns read-only attribute ( t __dict__t has_keyt AttributeError( R2 t namet value( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __setattr__� s c C s t | j | j � S( N( t cmpR# ( R2 t other( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __cmp__� s c C s t | j � S( N( t hashR# ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __hash__� s c C s+ d | j � | j t | j d | j f S( Ns %.3s %2d %.3s %ri ( t weekdayR t _MONTH_NAMESR R ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __repr__� s c C s9 t | � t k r( t d t | � � n t | j | � S( Ns can't add %r to date( R R R! R/ R# ( R2 R) ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __add__� s c C s5 t | � t k r# t | j | � S| j | j Sd S( N( R R R/ R# ( R2 R< ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __sub__� s c C s t d � d S( Ns Can't subtract date from integer( R! ( R2 R< ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt __rsub__� s c C s t | j � S( N( R1 R# ( R2 ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyR@ � s ( t __name__t __module__R4 R: R= R? RB RC t __radd__RD RE R@ ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyR" x s c C s= d d l } | j | j � � } t | d | d | d � S( Ni����i i i ( t timet localtimeR" ( RI t local( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt today� s t DateTestErrorc B s e Z RS( ( RF RG ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyRM � s c C s� t d d d � } t d d d � } t | � d k rB t d � n | | k ss | | k ss | | k ss | | k r t d � n | d | k s� d | | k r� t d � n | | d k s� | d | k r� t d � n y d | } t d � Wn t k rn Xy | | } t d � Wn t k r,n X| j � d k rKt d � n t | | � | k sut | | � | k r�t d � n i | | d 6| d | 6} | | d | k s�| | | | t d d d � k r�t d � n t | � } | } x� | | k r�| d } | t | � d } t d d | � t d d | � } } | j | j f | | f k rut d | f � n t | � t | � } } d d | d d | f | j | j | j | j | j | j f k r�t d | f � n | d } q�Wd S( Ni i iy iz s Tue 30 Sep 1913s __repr__ failures __cmp__ failureim s __add__ failures __sub__ failurei s int-date should have faileds date+date should have failedR s weekday() failures min/max failurein i s dictionary failurei i s date->num faileds num->date failed( R" t reprRM R! R@ t maxR( R R R# R/ R R R ( t firstyeart lastyeart at bt xt dt lordt yt fordt fdt ld( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt test� sP 1 * 8 % -t __main__i: if N( ( RA R0 R R R. R3 t appendR R R R R R R R R$ R/ R1 R" RL t ExceptionRM R[ RF ( ( ( s* /usr/lib64/python2.7/Demo/classes/Dates.pyt <module>, s6 * 4 . bitvec.pyo 0000644 00000024065 15204305160 0006554 0 ustar 00 � ��^c @ s{ d d l Z e j j Z d e f d � � YZ d � Z d d l Z d � Z d � Z d � Z d f d � � YZ e Z d S( i����Nt errorc B s e Z RS( ( t __name__t __module__( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR s c C sE t | � t d � k s5 d | k o/ d k n rA t d � n d S( Ni i s) bitvec() items must have int value 0 or 1( t typeR ( t value( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_value s 5c C s� t j t | � � \ } } d | >} | | k rM t d | | f f � � n x, | r{ | d ?} | | @rn Pn | d } qP W| S( Nl s (param, l) = %ri ( t matht frexpt floatt RuntimeError( t paramt mantt lt bitmask( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _compute_len s c C si t | � t d � k r$ t d � n | d k r= | | } n d | k oT | k n se t d � n | S( Ni s sequence subscript not ints list index out of range( R t TypeErrort IndexError( t lent key( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_key! s c C s> t | d � t | | � } } | | k r4 | } n | | f S( Ni ( t maxt min( R t it j( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt _check_slice* s t BitVecc B s e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c G s� d | _ d | _ t | � s! n�t | � d k r | \ } t | � t g � k r� d } d } x+ | D]# } | r� | | B} n | d >} qg W| | _ t | � | _ q�t | � t d � k r� | d k r� t d � n | | _ t | � | _ q�t d � n� t | � d k r�| \ } } t | � t d � k r�| d k rNt d � n | | _ t | � t d � k r{t d � n t | � } | | k r�d GH| j d | >d @| _ n | | _ q�t d � n t d � d S( Nl i i l s$ bitvec() can't handle negative longss) bitvec() requires array or long parameteri s can't handle negative longss$ bitvec()'s 2nd parameter must be intsM warning: bitvec() value is longer than the length indicates, truncating values% bitvec() requires 0 -- 2 parameter(s)( t _datat _lenR R R R ( t selft paramsR R t bit_maskt itemt lengtht computed_length( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __init__4 sL c C s( t t | � d � | | j | j +d S( Ni ( R t longR ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt appendb s c C sR | r | j } n | j } d } x) | rM | d ?| | d @d k } } q% W| S( Ni i ( R ( R R t datat count( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR& i s #c C s^ | r | j } n | j } d } | s4 t d � n x# | d @sY | d ?| d } } q7 W| S( Ni s list.index(x): x not in listi ( R t ValueError( R R R% t index( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR( u s c C s" t t | � d � | | | +d S( Ni ( R R# ( R R( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt insert� s c C s | | j | � =d S( N( R( ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt remove� s c C so | j d } } xO t | j � D]> } | sA | | j | >} Pn | d >| d @B| d ?} } q W| | _ d S( Nl i ( R t rangeR ( R R% t resultR ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt reverse� s !c C s/ | j d � } d | >d | j | >| _ d S( Ni l ( R& R R ( R t c( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt sort� s c C s t | j | j � S( N( R R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt copy� s c C s( g } x | D] } | j | � q W| S( N( R$ ( R R, R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt seq� s c C s d | j | j f S( Ns bitvec(%r, %r)( R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __repr__� s c G s# t | � t | � k r1 t t | f | � } n | j } | d k sU | j d k re t | | j � S| | j k r� t | | j � } t | | | | � p� t | | | | � S| j | j k r� d S| d k r� t | d | d � S| d ?} t | | | | � p t | | | | � Sd S( Ni i ( R t applyt bitvecR t cmpR R ( R t othert restR t min_length( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __cmp__� s c C s | j S( N( R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __len__� s c C s' t | j | � } | j d | >@d k S( Nl i ( R R R ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __getitem__� s c C sH t | j | � } | r/ | j d | >B| _ n | j d | >@| _ d S( Nl ( R R R ( R R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __setitem__� s c C sI t | j | � } | | j | | d j | ?B| _ | j d | _ d S( Ni ( R R R ( R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __delitem__� s #c C s� t | j | | � \ } } | | k r4 t d d � S| rJ | j | ?} n | j } | | } | | j k r� | d | >d @} n t | | � S( Nl i l i ( R R R R ( R R R t ndatat nlength( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __getslice__� s c G s� t | j | | � \ } } t | � t | � k rL t t | f | � } n | | } | | } | j | j | j | j >B| j >B| _ | j | | | j | _ d S( N( R R R R3 R4 R ( R R R t sequenceR7 t ls_partt ms_part( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __setslice__� s c C s� t | j | | � \ } } | d k rK | | j k rK d \ | _ | _ nB | | k r� | | j | | j | ?B| _ | j | | | _ n d S( Ni l ( l i ( R R R ( R R R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __delslice__� s c C s# | j � } | | | j | j +| S( N( R0 R ( R R6 t retval( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __add__ s c C s� t | � t d � k r$ t d � n | d k r= t d d � S| d k rS | j � S| j d k rv t d | j | � S| j d k r� t d | j | � St d d � } x | r� | | | d } } q� W| S( Ni s sequence subscript not intl i ( R R R R0 R R ( R t multiplierRF ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __mul__ s c G sW t | � t | � k r1 t t | f | � } n t | j | j @t | j | j � � S( N( R R3 R4 R R R R ( R t otherseqR7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __and__ s c G sW t | � t | � k r1 t t | f | � } n t | j | j At | j | j � � S( N( R R3 R4 R R R R ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __xor__% s c G sW t | � t | � k r1 t t | f | � } n t | j | j Bt | j | j � � S( N( R R3 R4 R R R R ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __or__. s c C s# t | j d | j >d @| j � S( Nl i ( R R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __invert__7 s c G s; t | � t | � k r1 t t | f | � } n | | f S( N( R R3 R4 ( R RJ R7 ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __coerce__< s c C s t | j � S( N( t intR ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __int__C s c C s t | j � S( N( R# R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __long__F s c C s t | j � S( N( R R ( R ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt __float__I s ( R R R" R$ R& R( R) R* R- R/ R0 R1 R2 R9 R: R; R< R= R@ RD RE RG RI RK RL RM RN RO RQ RR RS ( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyR 2 s: . ( t syst stderrt writet rprtt ExceptionR R R R R R R R4 ( ( ( s+ /usr/lib64/python2.7/Demo/classes/bitvec.pyt <module> s � Rev.pyo 0000644 00000005461 15204305160 0006033 0 ustar 00 � ��^c @ s< d Z d d d � � YZ d � Z e d k r8 e � n d S( s� A class which presents the reverse of a sequence without duplicating it. From: "Steven D. Majewski" <sdm7g@elvis.med.virginia.edu> It works on mutable or inmutable sequences. >>> chars = list(Rev('Hello World!')) >>> print ''.join(chars) !dlroW olleH The .forw is so you can use anonymous sequences in __init__, and still keep a reference the forward sequence. ) If you give it a non-anonymous mutable sequence, the reverse sequence will track the updated values. ( but not reassignment! - another good reason to use anonymous values in creating the sequence to avoid confusion. Maybe it should be change to copy input sequence to break the connection completely ? ) >>> nnn = range(3) >>> rnn = Rev(nnn) >>> for n in rnn: print n ... 2 1 0 >>> for n in range(4, 6): nnn.append(n) # update nnn ... >>> for n in rnn: print n # prints reversed updated values ... 5 4 2 1 0 >>> nnn = nnn[1:-1] >>> nnn [1, 2, 4] >>> for n in rnn: print n # prints reversed values of old nnn ... 5 4 2 1 0 # >>> WH = Rev('Hello World!') >>> print WH.forw, WH.back Hello World! !dlroW olleH >>> nnn = Rev(range(1, 10)) >>> print nnn.forw [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> print nnn.back [9, 8, 7, 6, 5, 4, 3, 2, 1] >>> rrr = Rev(nnn) >>> rrr <1, 2, 3, 4, 5, 6, 7, 8, 9> t Revc B s, e Z d � Z d � Z d � Z d � Z RS( c C s | | _ | | _ d S( N( t forwt back( t selft seq( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __init__? s c C s t | j � S( N( t lenR ( R ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __len__C s c C s | j | d S( Ni ( R ( R t j( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __getitem__F s c C s� | j } t | t � r' d } d } nH t | t � rE d } d } n* t | t � rc d } d } n d } d } g | j D] } t | � ^ qy } | d | j | � | d S( Ns []s , s ()t s <>i i����( R t isinstancet listt tuplet strR t join( R R t wrapt sept itemt outstrs( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt __repr__I s "( t __name__t __module__R R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyR > s c C s% d d l } d d l } | j | � S( Ni����( t doctestR t testmod( R R ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt _testZ s t __main__N( ( t __doc__R R R ( ( ( s( /usr/lib64/python2.7/Demo/classes/Rev.pyt <module>< s
| ver. 1.4 |
Github
|
.
| PHP 8.1.34 | ���֧ߧ֧�ѧ�ڧ� ����ѧߧڧ��: 0.21 |
proxy
|
phpinfo
|
���ѧ����ۧܧ�