# a class to allow you to toggle between True and False
 
class Static:
    """toggle between True and False"""
    flag = False
    # decorator allows you to simply call Static.toggle()
    @classmethod
    def toggle(self):
        self.flag = not self.flag
        return self.flag
 
for k in range(6):
    print( '%d) flag = %s' % (k+1, Static.toggle()) )
 
"""my output -->
1) flag = True
2) flag = False
3) flag = True
4) flag = False
5) flag = True
6) flag = False
"""

class Static(object):
    def __init__(self, **kwd):
        self.__dict__.update(kwd)
 
def toggle(static=Static(flag=True)):
    static.flag = not static.flag
    return static.flag
 
for i in range(5):
     print(toggle())
 
""" my output --->
False
True
False
True
False
"""

# a simple way to display plural strings
 
def visits(n):
    # adds an s to 'time' if n > 1
    return "I visited you %d time%s" % (n, ['','s'][n>1])
 
for n in range(1, 4):
    print( visits(n) )
 
"""my result -->
I visited you 1 time
I visited you 2 times
I visited you 3 times
"""

# a Fahrenheit/Celsius program easy on the user
# tested with Python25
# snee
 
def f2c(t):
    """given t Fahrenheit return Celsius"""
    return 5/9.0 * (t - 32)
 
def c2f(t):
    """given t Celsius return Fahrenheit"""
    return 9/5.0 * t + 32
 
def extract_number(s):
    """
    extract the numeric value from string s
    (the string can contain only one numeric value)
    return the number or None
    """
    ts = ""
    for c in s:
        if c in '1234567890.-':
            ts += c
    if ts:
        # convert number to int or float
        return eval(ts)
    else:
        return None
 
def pick_cf(s):
    """given a numeric string s select f or c calculation"""
    t = extract_number(s)
    print('')
    if not t:
        print("***need a number***")
        return False
    if 'f' in s.lower():
        print( "%0.2f Fahrenheit is %0.2f Celsius" % (t, f2c(t)) )
    else:
        print( "%0.2f Celsius is %0.2f Fahrenheit" % (t, c2f(t)) )
    return True
 
prompt = """
Enter a temperature ending with an F to calculate Celsius
otherwise the temperature is assumed to be Celsius and will
give the result in Fahrenheit (press just enter to quit): """
 
while True:
    s = raw_input(prompt)
    if not s:
        break
    s = pick_cf(s)

# create a table string from a list
 
def create_table(mylist, itemsperline=5):
    """
    given a list mylist return a string containing
    itemsperline of the list items in each line
    """
    table = ""
    for ix, element in enumerate(mylist):
        # add new line character after every itemsperline elements
        if ix % itemsperline == 0 and ix != 0:
            table += '\n'
        # use string formatting (adjust to your needs)
        # if length of element varies from 1 to 10 use for instance
        # table += "%-12s" % element 
        table += "%-4s" % element
    return table
 
 
# create the test list
mylist = [x+y for x in 'abcdef' for y in '1234']
 
#print mylist  # test ['a1', 'a2', 'a3', 'a4', 'b1', 'b2', ... ]
 
itemsperline = 4
table = create_table(mylist, itemsperline)
 
print(table)
 
"""my result -->
a1  a2  a3  a4  
b1  b2  b3  b4  
c1  c2  c3  c4  
d1  d2  d3  d4  
e1  e2  e3  e4  
f1  f2  f3  f4  
"""

# a simple reverse polish notation calculator
 
def do_operation(a, b, op):
    """
    here a dictionary combined with the
    lambda inline function acts like C switch/case
    a and b are numbers and op is a string
    """
    return {'+': lambda: a + b,
            '-': lambda: a - b,
            '*': lambda: a * b,
            '/': lambda: a / b
           }[op]()
 
# evaluate a reverse Polish notation string
rev_pol = "12 3 *"
 
a, b , op = rev_pol.split()
result = do_operation(float(a), float(b) , op)
 
print( "%s --> %s" % (rev_pol, result) )  # 12 3 * --> 36.0

# a permutation or combination does not repeat sample items
# Python3 has a non-recursive combination function
# via itertools.combinations(iterable, sample_size)
# and a non-recursive permutation function
# via itertools.permutations(iterable, sample_size=None)
# vegaseat
 
def permutations(seq, n):
    """
    permutations(seq, n) is a recursive generator function where
    seq is an iterable object like a list or string
    n is the sample size
    returns a list of nonrepeating sample size items
    n = len(seq) is the max sample size
    """
    if n == 0:
        yield []
    else:
        for k in range(len(seq)):
            # a recursive function
            for p in permutations(seq[:k] + seq[k+1:], n - 1):
                yield [seq[k]] + p
 
def unique_combinations(seq, n):
    """
    unique_combinations(seq, n) is a recursive generator function 
    where
    seq is an iterable object like a list or string
    n is the sample size
    returns a list of nonrepeating sample size items
    n = len(seq) is the max sample size
    """
    if n == 0:
        yield []
    else:
        for i in range(len(seq) - n + 1):
            # recursion
            for uc in unique_combinations(seq[i+1:], n - 1):
                yield [seq[i]] + uc
 
 
iterable = 'abc'
sample_size = 2
perm_list = list(permutations(iterable, sample_size))
 
# show as a list of lists
print( perm_list )
 
print( '-'*40 )
 
# show as a list of strings
print( ["".join(item) for item in perm_list] )
 
print( '-'*40 )
 
comb_list = list(unique_combinations(iterable, sample_size))
 
# show as a list of lists
print( comb_list )
 
print( '-'*40 )
 
# show as a list of strings
print( ["".join(item) for item in comb_list] )
 
""" my result (sample size max - 1) -->
[['a', 'b'], ['a', 'c'], ['b', 'a'], 
['b', 'c'], ['c', 'a'], ['c', 'b']]
----------------------------------------
['ab', 'ac', 'ba', 'bc', 'ca', 'cb']
----------------------------------------
[['a', 'b'], ['a', 'c'], ['b', 'c']]
----------------------------------------
['ab', 'ac', 'bc']
"""

# convert one time format to another
 
import time
 
date_old = "08-Jan-2009"
 
# use strptime(string, format_str) to form a time tuple
# (year,month,day,hour,min,sec,weekday(Monday=0),yearday,dls-flag)
time_tuple = time.strptime(date_old, "%d-%b-%Y")
 
# use time.strftime(format_str, time_tuple) to create new format
date_new = time.strftime("%m/%d/%y", time_tuple)
 
print( "New format = %s" % date_new )
print( "Old format = %s" % date_old )
print( "Time_tuple = %s" % time_tuple )
 
"""my output -->
New format = 01/08/09
Old format = 08-Jan-2009
Time tuple = (2009, 1, 8, 0, 0, 0, 3, 8, -1)
"""

#!/usr/bin/env python
 
version = '3.1.1'
 
def main():
    pass
 
if __name__ is "__main__":
    main()