def f():
    print(1)
    
g = f
g()

import sys


def checkout(*args):
    print('checkout{}'.format(args))

def commit(*args):
    print('commit{}'.format(args))


commands = {
        'checkout': checkout,
        'co': checkout,
        'commit': commit,
        'ci': commit
        }

cmd, *args = 'commit', 'arg1', 'arg2' #sys.argv[1:]
commands[cmd](*args)

def filter(function, iterable):
    for e in iterable:
        if function(e):
            yield e

def is_even(number):
    return number % 2 == 0


a = [1, 2, 3, 4, 5]
for e in filter(is_even, a):
    print(e)

a = range(6)
for e in filter(is_even, a):
    print(e)

def map(function, iterable):
    for e in iterable:
        yield function(e)
        
def square(x):
    return x ** 2


for e in map(square, [1, 2, 3]):
    print(e)

def map(function, *iterables):
    iters = [iter(iterable) for iterable in iterables]
    while True:
        try:
            args = [next(it) for it in iters]
            yield function(*args)
        except StopIteration:
            break
            
def add(a, b):
    return a + b


for e in map(add, [1, 2, 3], [4, 5, 6]):
    print(e)

for e in map(lambda a, b: a + b, [1, 2, 3], [4, 5, 6]):
    print(e)

def add(a, b):
    return a + b

def partial(function, *args):    
    def new_function(*more_args):
        all_args = args + more_args
        return function(*all_args)
    return new_function
    
inc = partial(add, 1)
inc(4)


import functools
import operator


inc = functools.partial(operator.add, 1)
print(inc(4))

import timeit

def caching(function):
    computed_results = {}
    def new_function(*args):
        if args not in computed_results:
            computed_results[args] = function(*args)
        return computed_results[args]
    return new_function


def fibonacci_number(i):
    if i == 0 or i == 1:
        return 1
    return fibonacci_number(i - 1) + fibonacci_number(i - 2)

print(timeit.timeit('fibonacci_number(30)', number=3, setup='from __main__ import fibonacci_number'))
fibonacci_number = caching(fibonacci_number)
print(timeit.timeit('fibonacci_number(30)', number=3, setup='from __main__ import fibonacci_number'))

import timeit

def caching(function):
    computed_results = {}
    def new_function(*args):
        if args not in computed_results:
            computed_results[args] = function(*args)
        return computed_results[args]
    return new_function


@caching
def fibonacci_number(i):
    if i == 0 or i == 1:
        return 1
    return fibonacci_number(i - 1) + fibonacci_number(i - 2)

print(timeit.timeit('fibonacci_number(30)', number=3, setup='from __main__ import fibonacci_number'))

def f(x):
    print(x)
    
print(f.__name__)
g = f
print(g.__name__)
g = lambda: 1
print(g.__name__)
print(f.__module__)


def caching(function):
    '''Caching decorator for functions with positional arguments.'''

    computed_results = {}
    def new_function(*args):
        if args not in computed_results:
            computed_results[args] = function(*args)
        return computed_results[args]
    new_function.__name__ = function.__name__
    new_function.__doc__ = function.__doc__
    return new_function

@caching
def fibonacci_number(i):
    '''Function for calculating i-th Fibonacci number.'''

    if i == 0 or i == 1:
        return 1
    return fibonacci_number(i - 1) + fibonacci_number(i - 2)

import caching
help(caching) #    $ pydoc caching

from IPython.display import HTML
with open('caching.html') as f:  #   $ pydoc -w caching
    h = HTML(f.read())
h

caching.caching.__code__.co_code

import dis
dis.dis(caching.caching)

import inspect
sig = inspect.signature(caching.caching)
print(sig)

print(sig.parameters)

print(inspect.getsource(caching.caching))