# IPython log file

get_ipython().magic(u'logstart')
try:
    x = 1
    sys
except:
    pass
import sys
try:
    sys.exit()
finally:
    print "Hello"
d = dict(x=1, y=2)
def foo(x, y):
    pass
get_ipython().magic(u'pinfo reduce')
def sum(x, y):
    return x + y
reduce(sum, [1,2,3])
map(print, [1,2,3])
import __future__
__future__.print_function
from __future__ import print_function
map(print, [1,2,3])
from __future__ import braces
import optparse
get_ipython().magic(u'pinfo optparse.OptionParser.add_option')
get_ipython().magic(u'pinfo2 optparse.OptionParser.add_option')
def foo():
    pass
def double_positive(lst):
    def dbl(x):
        return x * 2
    def pos(x):
        return x > 0
    return map(dbl, filter(pos, lst))
double_positive([-1, 2, 4, -9])
dbl
def outer():
    def inner():
        print 1
    inner()
def outer():
    def inner():
        print(1)
    inner()
outer()
def outer():
    def inner():
        print 1
    return inner
def outer():
    def inner():
        print(1)
    return inner
outer()
i = outer()
i()
i2 = outer()
i
i2
id(i)
id(i2)
i is i2
def outer():
    x = 1
    def inner():
        print x
    inner()
def outer():
    x = 1
    def inner():
        print(x)
    inner()
outer()
def outer():
    x = 1
    def inner():
        print(x)
    return inner
i = outer()
i()
i.func_closure
def outer(x):
    def inner():
        print(x)
    return inner
i = outer(3)
i()
i2 = outer(5)
i2()
i()
i.x
lst = ["words", "python", "is", "great"]
sorted(lst, key=lambda w:w[-1])
sorted(lst, key=lambda w:w[1])
def itemgetter(index):
    def inner(w):
        return w[index]
    return inner
sorted(lst, key=itemgetter(-1))
sorted(lst, key=itemgetter(1))
sorted(lst, key=itemgetter(0))
def itemgetter_fail(item, index):
    return item[index]
sorted(lst, key=itemgetter_fail)
import operator
get_ipython().magic(u'pinfo reduce')
reduce(+, [1,2,3])
get_ipython().magic(u'pinfo operator.add')
reduce(operator.add, [1,2,3])
get_ipython().magic(u'pinfo operator.itemgetter')
filter(operator.itemgetter(-1), [(1, 0), (1, 2)])
get_ipython().magic(u'pinfo operator.methodcaller')
get_ipython().magic(u'pinfo operator.setslice')
get_ipython().magic(u'pinfo optparse.OptionParser')
get_ipython().magic(u'pinfo optparse.OptionParser.set_default')
get_ipython().magic(u'pinfo optparse.OptionParser.set_defaults')
4 ** 3
get_ipython().magic(u'pinfo reduce')
get_ipython().magic(u'pinfo map')
import random
get_ipython().magic(u'pinfo random.sample')
random.sample(range(100), 5)
lst = []
lst.append(random.sample(range(100), 5)))
lst.append(random.sample(range(100), 5))
lst.append(random.sample(range(100), 5))
lst.append(random.sample(range(100), 5))
lst.append(random.sample(range(100), 5))
lst.append(random.sample(range(100), 5))
lst
get_ipython().magic(u'pinfo sorted')
sorted(lst)
lst
map(sorted, lst)
lst
get_ipython().magic(u'pinfo filter')
get_ipython().magic(u'pinfo sorted')
sorted(lst)
sorted(lst, key=lambda l:l[1])
f = operator.itemgetter(1)
f([1,2,3])
sorted(lst, key=operator.itemgetter(1))
sorted(lst, key=operator.itemgetter(1), reverse=True)
st
lst
lst
lst[3]
lst[3][2]
lst[3][2] = 0
lst[2][4] = 0
lst
get_ipython().magic(u'pinfo filter')
filter(somefunc, lst)
def somefunc(r):
    if 0 not in r:
        return True
filter(somefunc, lst)
get_ipython().magic(u'pinfo all')
all([0,1,2])
all([1,2,3])
lst
filter(all, lst)
dir(__builtin__)
get_ipython().magic(u'pinfo apply')
dir(__builtin__)
get_ipython().magic(u'pinfo cmp')
cmp(4,5)
dir(__builtin__)
get_ipython().magic(u'pinfo divmod')
dir(__builtin__)
get_ipython().magic(u'pinfo xrange')
lst
map(sum, lst)
get_ipython().magic(u'pinfo sum')
get_ipython().magic(u'pinfo2 sum')
__builtin__.sum
get_ipython().magic(u'pinfo __builtin__.sum')
sum = __builtin__.sum
sum
get_ipython().magic(u'pinfo sum')
map(sum, lst)
lst
map(lambda row: reduce(operator.add ,row), lst)
sum(map(sum, lst))
reduce(operator.add,map(sum, lst))
map(sum, lst)
sum(map(sum, lst))
def outer(x):
    def inner():
        print(x)
    return inner
f1 = outer(4)
f()
f1()
f2 = outer("foobar")
f2()
outer(lambda x: x)
f1 = outer(lambda x: x)
sum
f2 = outer(sum)
f1()
f2
f2()
def outer():
	pass    
def outer(func):
    def inner():
        func()
    return inner
f1 = outer(lambda x: x)
f2 = outer(sum)
f1
f2
f1()
f2()
def mysum(x,y):
    return x + y
def mydiff(x, y):
    return x - y
def outer(f):
    def inner(x, y):
        f(x, y)
    return inner
f1 = outer(mysum)
f2 = outer(mydiff)
f1(4,5)
def outer(f):
    def inner(x, y):
        return f(x, y)
    return inner
f1 = outer(mysum)
f2 = outer(mydiff)
f1(4,5)
f1
f2(4,5)
f2
def outer(f):
    def inner(x, y):
        if not all([x, y]):
            raise Exception("%s does not accept zeroes" % f)
        return f(x, y)
    return inner
mysum(0, 4)
f1 = outer(mysum)
f1(0, 4)
f1(1, 4)
mysum = outer(mysum)
mysum
mysum(0, 34)
@outer
def mymul(x, y):
    return x * y
mymul
mymul(4, 0)
def mymul(x, y):
    return x * y
mymul = outer(mymul)
mymul
get_ipython().magic(u'hist ')
def turnoff(f):
    def nullfunc(*args, **kwargs):
        pass
    return nullfunc
def mymul(x, y):
    return x * y
mymul(4, 5)
mymul = turnoff(mymul)
mymul(4,5)
@turnoff
def mydiff(x, y):
    return x - y
mydiff(4,4)
def log(f):
    def inner(*args, **kwargs):
        print args, kwargs
        return f(*args, **kwargs)
    return inner
def log(f):
    def inner(*args, **kwargs):
        print(args, kwargs)
        return f(*args, **kwargs)
    return inner
@log
def myprint(st):
    print st
    
@log
def myprint(st):
    print(st)
@log
def mymul(x, y):
    return x * y
@log
def mysum(lst):
    return sum(lst) + 1
mymul(4,5)
mysum([1,2,3])
mymul(4, 2)
get_ipython().magic(u'hist ')
@log("/tmp/foo.log")
def mymul(4, 5):
   pas
   
"[1, 2, 3]"
import json
get_ipython().magic(u'pinfo json.loads')
data = "[1, 2, 3]"
json.loads(data)
def wrap1(f):
    def inner():
        print 1
    return inner
def wrap1(f):
    def inner():
        print(1)
    return inner
def wrap2(f):
    def inner():
        print(2)
    return inner
@wrap1
@wrap2
def foo():
    pass
foo()
@wrap1
def foo():
    pass
foo()
foo
foo = wrap2(foo)
foo()
def wrap1(f):
    def inner():
        print(1)
        return f()
    return inner
def wrap2(f):
    def inner():
        print(2)
        return f()
    return inner
@wrap1
@wrap2
def foo():
    print 3
@wrap1
@wrap2
def foo():
    print(3)
foo()
def wrap1(f):
    print "going to wrap a func1"
    def inner():
        print(1)
        return f()
    return inner
def wrap1(f):
    print("going to wrap a func1")
    def inner():
        print(1)
        return f()
    return inner
def wrap1(f):
    print("going to wrap a func2")
    def inner():
        print(2)
        return f()
    return inner
@wrap1
@wrap2
def foo():
    print 3
@wrap1
@wrap2
def foo():
    print(3)
def wrap1(f):
    print("going to wrap a func1")
    def inner():
        print(1)
        return f()
    return inner
def wrap2(f):
    print("going to wrap a func2")
    def inner():
        print(2)
        return f()
    return inner
@wrap1
@wrap2
def foo():
    print(3)
lst
filter(any, lst)
filter(all, lst)
[row for row in lst if 0 not in row]
map(sum, filter(all, lst)
)
map(sum, filter(all, lst))
[sum(row) for row in lst if 0 not in row]
lst
[r for r in lst]
[sorted(r) for r in lst]
map(sorted, lst)
lst
[r for r in lst]
[sum(r) for r in lst]
[sum(row) for row in lst]
sum([sum(row) for row in lst])
(sum(row) for row in lst)
g = (sum(row) for row in lst)
g
g.next()
g.next()
g.next()
g.next()
g.next()
g.next()
g.next()
g.next()
g2 = (sum(row) for row in lst)
g2
g3 =(row for row in g2 if len(row) > 3)
g3
for data in g3:
    print data
for data in g3:
    print (data)
def foo():
    while True:
        return 1
foo()
def foo():
    while True:
        yield 1
foo()
g = foo()
g.next()
g.next()
g.next()
g.next()
def foo():
    while True:
        yield 1
        print("after yield")
get_ipython().magic(u'hist ')
g = foo()
g.next()
g.next()
item = 0
index = 0
class Chain(object):
    def __init__(self, *args):
        self.args = args
        self.item = 0
        self.index = 0
    def next():
        if item < len(self.args):
            if index < len(self.args[item]:
class Chain(object):
    def __init__(self, *args):
        self.args = args
        self.item = 0
        self.index = 0
    def next():
        if self.item < len(self.args):
            if self.index < len(self.args[self.item]:
                val = self.args[self.item][self.index]
            else:
                self.item += 1
                self.index = 0
                val = self.args[self.item][self.index]
            
get_ipython().magic(u'hist ')
class Chain(object):
    def __init__(self, *args):
        self.args = args
        self.item = 0
        self.index = 0
    def next():
        if self.item < len(self.args):
            if self.index < len(self.args[self.item]:
                val = self.args[self.item][self.index]
            else:
                self.item += 1
                self.index = 0
                val = self.args[self.item][self.index]
            else:
                raise StopIteration()
            return val
class Chain(object):
    def __init__(self, *args):
        self.args = args
        self.item = 0
        self.index = 0
    def next():
        if self.item < len(self.args):
            if self.index < len(self.args[self.item]):
                val = self.args[self.item][self.index]
            else:
                self.item += 1
                self.index = 0
                val = self.args[self.item][self.index]
            else:
                raise StopIteration()
            return val
class Chain(object):
    def __init__(self, *args):
        self.args = args
        self.item = 0
        self.index = 0
    def next():
        if self.item < len(self.args):
            if self.index < len(self.args[self.item]):
                val = self.args[self.item][self.index]
            else:
                self.item += 1
                self.index = 0
                val = self.args[self.item][self.index]
        else:
            raise StopIteration()
        return val
lst
for row in lst:
    for num in row:
        print num
for row in lst:
    for num in row:
        print (num)
lst
def chain(*args):
    for item in args:
        for val in item:
            yield val
for val in chain([1,2,3], "abc", {'x':1, 'y': 0}):
    print(val)
class Foo(object):
    x = 1
Foo
Foo.x
o = Foo()
Foo
o
o2 = Foo()
o
o is o2
o.x
o2.x
o.__dict__
Foo.x = 2
o.x
o2.x
o.x = 10
o.x
o2.x
Foo.x
o.__dict__
o2.__dict__
class Foo(object):
    def func():
        pass
o = Foo()
o.func()
class Foo(object):
    def func(self):
        print(self.__dict__)
o = Foo()
o.func()
Foo.func()
Foo.func(o)
Foo.func([])
class Foo(object):
    def func(self, x):
        self.x = x
o = Foo()
o.func(4)
o.x
o2 = Foo()
o2.func(3)
o2.x
o.x
import unittest
get_ipython().magic(u'pinfo unittest.main')
get_ipython().magic(u'pinfo unittest.TestCase.assertEqual')
get_ipython().magic(u'pinfo unittest.TestCase.assertIn')
get_ipython().magic(u'pinfo unittest.TestCase.assertEqual')
get_ipython().magic(u'pinfo unittest.TestCase.assertEquals')
import itertools
get_ipython().magic(u'pinfo itertools.chain')
range(100)
range(1000)
get_ipython().magic(u'pinfo xrange')
xrange(9)
for i in xrange(9):
    print i
for i in xrange(9):
    print(i)