# 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(itr, n):
    """
    permutations(items, n) is a recursive generator function where
    itr is an iterable object like a list or string
    n is the sample size
    returns a list of nonrepeating sample size items
    n = len(itr) is the max sample size
    """
    if n == 0:
        yield []
    else:
        for k in range(len(itr)):
            # a recursive function
            for c in permutations(itr[:k] + itr[k+1:], n - 1):
                yield [itr[k]] + c
 
iterable = 'abc'
sample_size = 2
perm_list = list(permutations(iterable, sample_size))
 
# show as a list of lists
print( perm_list )
 
print( '-'*50 )
 
# show as a list of strings
print( ["".join(item) for item in perm_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']
"""