Added more work

progrmoiz · progrmoiz · commit c2d1b05775af · 2017-09-18T20:50:49.000+05:00
diff --git a/formats.py b/formats.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+"""
+File: formats.py
+Various specialized string display formatting utilities.
+Test me with canned self-test or command-line argumnets.
+To do: add parans for negative money, and more feature.
+"""
+
+
+def commas(N):
+    """
+    Format positive integer-like N for display with
+    commas between digits grouping: "XXX,YYY,ZZZ"
+    """
+    digits = str(N)
+    assert(digits.isdigit())
+    result = ''
+    while digits:
+        digits, last3 = digits[:-3], digits[-3:]
+        result = (last3 + ',' + result) if result else last3
+    return result
+
+
+def money(N, numwidth=0, currency="$"):
+    """
+    Format number N for display with commas, 2 decimal digits,
+    leading $ and sign, and optional padding: "$ -xxx,yyy.zz".
+    numwidth=0 for no space padding, currency='' to omit symbol,
+    and non-ASCII for others (e.g., pound=u'\xA3' or u'\u00A3').
+    """
+    sign = '-' if N < 0 else ''
+    N = abs(N)
+    whole = commas(int(N))
+    fract = ('%2f' % N)[-2:]
+    number = '%s%s.%s' % (sign, whole, fract)
+    return '%s%*s' % (currency, numwidth, number)
+
+if __name__ == '__main__':
+    def selftest():
+        tests = 0, 1             # fails -1, 1.23
+        tests += 12, 123, 1234, 12345, 123456, 1234567
+        tests += 2 ** 32, 2 ** 100
+        for test in tests:
+            print(commas(test))
+
+        tests = 0, 1, -1, 1.23, 1., 1.2, 3.1341
+        tests += 12, 123, 1234, 12345, 123456, 1234567
+        tests += 2 ** 32, (2 ** 32 + .2342)
+        tests += 1.2324, 1.2, 0.2345
+        tests += -1.242, -1.2, -15.2
+        tests += -(2 ** 32), -(2 ** 32 + 0.2324)
+        tests += 2 ** 100, -(2 ** 100)
+        for test in tests:
+            print('%s [%s]' % (money(test, 17), test))
+
+    import sys
+    if len(sys.argv) == 1:
+        selftest()
+    else:
+        print(money(float(sys.argv[1]), int(sys.argv[2])))
diff --git a/mydir.py b/mydir.py
@@ -0,0 +1,33 @@
+#!python
+"""
+mydir.py: a module that lists the namespaces of other module
+"""
+from __future__ import print_function
+
+seplen = 60
+sepchr = '-'
+
+def listing(module, verbose=True):
+    sepline = sepchr * seplen
+    if verbose:
+        print(sepline)
+        print('name:', module.__name__, 'file:', module.__file__)
+        print(sepline)
+
+    count = 0
+    for attr in sorted(module.__dict__):  # Scan namespace keys (or enumerate)
+        print('%02d) %s' % (count, attr), end=' ')
+        if attr.startswith('__'):
+            print('<built-in name>')  # Skip __file__, etc
+        else:
+            print(getattr(module, attr))  # Same as .__dict__[attr]
+        count += 1
+
+    if verbose:
+        print(sepline)
+        print(module.__name__, 'has %d names' % count)
+        print(sepline)
+
+if __name__ == '__main__':
+    import mydir
+    listing(mydir)
diff --git a/mymap.py b/mymap.py
@@ -0,0 +1,24 @@
+def mymap(func, *seqs):
+    res = []
+    for args in zip(*seqs):
+        res.append(func(*args))
+    return res
+
+
+# def mymap(func, *seqs):
+    # return [func(*args) for args in zip(*seqs)]
+
+print(mymap(abs, [-2, -1, 0, 1, 2]))
+print(mymap(pow, [1, 2], [2, 3, 4]))
+
+
+def mymap(func, *seqs):
+    for args in zip(*seqs):
+        yield func(*args)
+
+
+def mymap(func, *seqs):
+    return (func(args) for args in zip(*seqs))
+
+print(list(mymap(abs, [-2, -1, 0, 1, 2])))
+print(list(mymap(pow, [1, 2], [2, 3, 4])))
diff --git a/myzip.py b/myzip.py
@@ -0,0 +1,58 @@
+def myzip(*seqs):
+    seqs = [list(S) for S in seqs]
+    res = []
+    while all(seqs):
+        res.append(tuple(x.pop(0) for x in seqs))
+    return res
+
+
+def mymapPad(*seqs, pad=None):
+    seqs = [list(S) for S in seqs]
+    res = []
+    while any(seqs):
+        res.append(tuple((S.pop(0) if S else pad) for S in seqs))
+    return res
+
+# Using Generator
+def myzip(*seqs):
+    seqs = [list(S) for S in seqs]
+    while all(seqs):
+        yield tuple(x.pop(0) for x in seqs)
+
+
+def mymapPad(*seqs, pad=None):
+    seqs = [list(S) for S in seqs]
+    while any(seqs):
+        yield tuple((S.pop(0) if S else pad) for S in seqs)
+
+# Using min and max len
+def myzip(*seqs):
+    minlen = min(len(S) for S in seqs)
+    return [tuple(S[i] for S in seqs) for i in range(minlen)]
+
+def mymapPad(*seqs, pad=None):
+    maxlen = max(len(S) for S in seqs)
+    index = range(maxlen)
+    return [tuple((S[i] if len(S) > i else pad) for S in seqs) for i in index]
+
+# Using Generator
+def myzip(*seqs):
+    minlen = min(len(S) for S in seqs)
+    return (tuple(S[i] for S in seqs) for i in range(minlen))
+
+def mymapPad(*seqs, pad=None):
+    maxlen = max(len(S) for S in seqs)
+    index = range(maxlen)
+    return (tuple((S[i] if len(S) > i else pad) for S in seqs) for i in index)
+
+# Clever implementation from python manual
+def myzip(*seqs):
+    iters = list(map(iter, seqs))
+    while iters:
+        res = [next(i) for i in iters]
+        yield tuple(res)
+
+S1, S2 = 'abc', 'xyz123'
+print(myzip(S1, S2))
+print(mymapPad(S1, S2))
+print(mymapPad(S1, S2, pad=99))
diff --git a/permute.py b/permute.py
@@ -0,0 +1,22 @@
+def permute(seq):
+    if not seq:
+        yield seq
+    else:
+        for i in range(len(seq)):
+            rest = seq[:i] + seq[i+1:]
+            for x in permute(rest):
+                yield seq[i:i+1] + x
+
+def permute1(seq):
+    if not seq:
+        return [seq]
+    else:
+        res = []
+        for i in range(len(seq)):
+            rest = seq[:i] + seq[i+1:]
+            for x in permute(rest):
+                res.append(seq[i:i+1] + x)
+    return resn
+
+for i in permute('maths'):
+    print(i)
diff --git a/scramble.py b/scramble.py
@@ -0,0 +1,27 @@
+L, S = [1, 2, 3], 'spam'
+# for i in range(len(S)):
+    # S = S[1:] + S[:1]
+    # print(S, end=' ')
+
+# simple function
+def scramble(seq):
+    res = []
+    for i in range(len(seq)):
+        X = seq[1:] + seq[:1]
+        res.append(X)
+    return res
+
+
+def scramble1(seq):
+    return [seq[1:] + seq[:1] for i in range(len(seq))]
+
+# above wait caller to wait until all list is done
+
+# generator function
+def scramble2(seq):
+    for i in range(len(seq)):
+        yield seq[1:] + seq[:1]
+
+def scramble3(seq):
+    return (seq[1:] + seq[:1] for i in range(len(seq)))
+
diff --git a/timer.py b/timer.py
@@ -0,0 +1,49 @@
+"""
+Homegrown timing tools for function calls.
+Does total time, best-of time and best-of-totals time
+"""
+
+import time
+import sys
+
+if sys.version_info[0] >= 3 and sys.version_info[1] >= 3:
+    timer = time.perf_counter
+else:
+    timer = time.clock if sys.platform[:3] == 'win' else time.time
+
+
+def total(reps, func, *pargs, **kargs):
+    """
+    Total time to run func() reps times.
+    Return (total time, last result)
+    """
+    replist = list(range(reps))  # Hoist out, eqvalize 2.x, 3.x
+    start = timer()
+    for i in replist:
+        ret = func(*pargs, **kargs)
+    elapsed = timer() - start
+    return (elapsed, ret)
+
+
+def bestof(reps, func, *pargs, **kargs):
+    """
+    Quickest func() among reps runs.
+    Return (best time, last result)
+    """
+    best = 2 ** 32  # 136 years seems large enough
+    for i in range(reps):
+        start = timer()
+        ret = func(*pargs, **kargs)
+        elapsed = timer() - start
+        if elapsed < best:
+            best = elapsed
+    return (best, ret)
+
+
+
+def bestoftotal(reps1, reps2, func, *pargs, **kargs):
+    """
+    Best of totals:
+    (best of reps1 runs of (total of reps2 runs of func))
+    """
+    return bestof(reps1, total, reps2, func, *pargs, **kargs)
diff --git a/timer2.py b/timer2.py
@@ -0,0 +1,49 @@
+# File timer2.py (2.x and 3.x)
+"""
+total(spam, 1, 2, a=3, b=4, _reps=1000) calls and times span(1, 2, a=3, b=4)
+_reps times, and return total time for all runs, and final result.
+
+bestof(spam, 1, 2, a=3, b=4, _reps=1000) runs best-of-N timer to attempt to
+filter out the system load variation, and return best result among _reps tests.
+
+bestoftotal(spam, 1, 2, a=3, b=4, _reps1=5, _reps=1000) runs best-of-totals
+test, which take the best among _reps1 run of (the total of _reps runs);
+"""
+
+import time
+import sys
+
+if sys.version_info[0] >= 3 and sys.version_info[1] >= 3:
+    timer = time.perf_counter
+else:
+    timer = time.clock if sys.platform[:3] == 'win' else time.time
+
+
+def total(func, *pargs, **kargs):
+    _reps = kargs.pop('_reps', 1000)
+    repslist = list(range(_reps))
+
+    start = timer()
+    for i in repslist:
+        ret = func(*pargs, **kargs)
+    elapsed = timer() - start
+    return (elapsed, ret)
+
+
+def bestof(func, *pargs, **kargs):
+    _reps = kargs.pop('_reps', 1000)
+    repslist = list(range(_reps))
+
+    best = 2 ** 32
+    for i in repslist:
+        start = timer()
+        ret = func(*pargs, **kargs)
+        elapsed = timer() - start
+        if elapsed < best:
+            best = elapsed
+    return (best, ret)
+
+
+def bestoftotal(func, *pargs, **kargs):
+    _reps1 = kargs.pop('_reps1', 5)
+    return min(total(func, *pargs, **kargs) for i in range(_reps1))
diff --git a/timer3.py b/timer3.py
@@ -0,0 +1,41 @@
+# File timer3.py
+"""
+Same usage as timer2.py, but uses 3.x keyword-only default arguments
+istead of dict pops for simpler code. No need to hoist range() out of tests
+in 3.x: always a generator in 3.x, and this can't run on 2.x
+"""
+
+import time
+import sys
+
+if sys.version_info[0] >= 3 and sys.version_info[1] >= 3:
+    timer = time.perf_counter
+else:
+    timer = time.clock if sys.platform[:3] == 'win' else time.time
+
+
+def total(func, *pargs, _reps=1000, **kargs):
+    repslist = list(range(_reps))
+
+    start = timer()
+    for i in repslist:
+        ret = func(*pargs, **kargs)
+    elapsed = timer() - start
+    return (elapsed, ret)
+
+
+def bestof(func, *pargs, _reps=1000, **kargs):
+    repslist = list(range(_reps))
+
+    best = 2 ** 32
+    for i in repslist:
+        start = timer()
+        ret = func(*pargs, **kargs)
+        elapsed = timer() - start
+        if elapsed < best:
+            best = elapsed
+    return (best, ret)
+
+
+def bestoftotal(func, *pargs, _reps1=5, **kargs):
+    return min(total(func, *pargs, **kargs) for i in range(_reps1))
