for i in range(3):
    print(i)

l = range(3)
l

help(l.__iter__)

li = iter(l)
li

dir(li)

li.next()

li.next()

li.next()

li.next()

from __future__ import print_function

def my_for(item, iterable, iter_func):
    it = iter(iterable)
    while True:
        try:
            item = it.next()
            # Iteration code goes here
            iter_func(item)
        except StopIteration:
            break

my_for(i, range(3), print)

l = range(1000000);

class iter_range(object):
    def __init__(self, stop):
        self.current = 0
        self.stop = stop
    
    def next(self):
        self.current += 1
        if self.current >= self.stop:
            raise StopIteration

        else:
            return self.current
    
    def __iter__(self):
        return self

L = [1,2,3,4]

iter(L)

range_4 = iter(iter_range(4))
for i in range_4:
    print(i)

range_4

dir(range_4)

li = xrange(4)

iter(li)

range_4.next()

def iter_range(stop):
    current = 0
    while current < stop:
        yield current
        current += 1

range_4 = iter_range(4)
range_4

def iter_range(stop):
    current = 0
    print("Before loop")
    while current < stop:
        if current == "stop":
            return

        print("Before yield")
        yield current
        current += 1
        print("After yield")
    
    print("After loop")

range_4 = iter_range(4)

range_4.next()

range_4.next()

range_4.next()

range_4.next()

range_4.next()

range_5 = iter_range(5)
range_5_even = (i for i in range_5 if i % 2 == 0)

range_5_even

for i in range_5_even:
    print(i)

from itertools import tee

range_5 = iter_range(5)
r1, r2 = tee(range_5, 2)

r1.next()

r2.next()

from itertools import izip

def pairs(it):
    a, b = tee(it, 2)
    b.next()  # Advance one step in the second copy
    return izip(a, b)

range_4 = iter_range(4)
pairs_4 = pairs(range_4)

for i in pairs_4:
    print(i)

(2*i for i in range(3))

range_4 = iter_range(4)
dir(range_4)

def cr():
    while True:
        n = (yield)
        yield 1

c = cr()

c.next()

c.next()

c.send(2)

c.next()

c.send()

def doubler():
    while True:
        n = (yield)
        print(2*n)

d = doubler()
d.next()

for i in range_4:
    d.send(i)

d.send(7)

d.send(10)

def doubler(target):
    while True:
        n = (yield)
        target.send(2 * n)


def halfer():
    while True:
        n = (yield)
        print(n / 2)

h = halfer()
h.next()
doubler_halfer = doubler(h)
doubler_halfer.next()

for i in range(3):
    doubler_halfer.send(i)

def coroutine(func):
    def start(*args, **kwargs):
        cr = func(*args, **kwargs)
        cr.next()
        return cr
    
    return start

@coroutine
def doubler(target):
    while True:
        n = (yield)
        target.send(2. * n)
        
@coroutine
def halfer(target):
    while True:
        n = (yield)
        target.send(n / 2.)

@coroutine
def printer():
    while True:
        n = (yield)
        print(str(n))

doubler_halfer_printer = doubler(halfer(printer()))

for i in range(4):
    doubler_halfer_printer.send(i)

@coroutine
def broadcaster(targets):
    while True:
        value = (yield)
        for target in targets:
            target.send(value)

stuff = broadcaster([halfer(printer()), doubler(printer())])
for i in range(5):
    stuff.send(i)

def gen():
    yield 1
    yield 2

g = gen()

g.next()

g.next()

g.next()

@coroutine
def cr():
    a = (yield)
    print(a)

c = cr()

c.send(34)

type(c)

from termcolor import colored

for i in range(1, 100):
    if not i % 7:
        print(colored(i, "red"), end=" ")
    else:
        print(colored(i, "cyan"), end=" ")

@coroutine
def colorer(color, target):
    while True:
        text = str((yield))
        target.send(colored(text, color))

stuff = broadcaster([halfer(colorer("red", printer())), \
                     doubler(colorer("cyan", printer()))])
for i in range(5):
    stuff.send(i)

stuff.close()

@coroutine
def summer(target):
    s = 0
    try:
        while True:
            s += (yield)

    except GeneratorExit:
        target.send(s)
        return

a = summer(printer())

for i in range(4):
    a.send(i)

a.close()

@coroutine
def router(func, true_target, false_target):
    while True:
        v = (yield)
        if func(v):
            true_target.send(v)
        else:
            false_target.send(v)

@coroutine
def averager(target):
    count = 0
    s = 0.
    while True:
        s += (yield)
        count += 1
        target.send(s / count)

p = printer()
pipeline = router(lambda i: i % 2, colorer("red", p), averager(colorer("cyan", p)))

for i in range(10):
    pipeline.send(i)

from random import randint
def number_producer(n=4):
    fstr = '{0:0' + str(n) + 'd}'
    n_max = 10 ** (n) - 1
    while True:
        yield fstr.format(randint(0, n_max))

producer = number_producer(10)
producer.next()

english = {0: "zero", 1: "one", 2: "two", 3: "three", 4: "four", \
           5: "five", 6: "six", 7: "seven", 8: "eight", 9: "nine"}

svenska = {0: "noll", 1: "ett", 2: "tva", 3: "tre", 4: "fyra", \
           5: "fem", 6: "sex", 7: "sju", 8: "atta", 9: "nio"}

@coroutine
def digit_splitter(target):
    try:
        while True:
            number = (yield)
            for digit in number:
                target.send(int(digit))
    except GeneratorExit:
        target.close()

@coroutine
def digit_mapper(map, target):
    try:
        while True:
            digit = (yield)
            target.send(map[digit])
    except GeneratorExit:
        target.close()

from collections import Counter

@coroutine
def letter_counter(target):
    c = Counter()
    try:
        while True:
            c.update((yield))

    except GeneratorExit:
        target.send(c)
        target.close()

@coroutine
def count_formatter(target, n=5):
    while True:
        counts = (yield)
        for letter, count in counts.most_common(n):
            s = letter + " - " + "|" * count
            target.send(s)

@coroutine
def multiline_printer():
    s = ""
    try:
        while True:
            s += (yield) + "\n"

    except GeneratorExit:
        print(s)

@coroutine
def broadcaster(targets):
    try:
        while True:
            value = (yield)
            for target in targets:
                target.send(value)
    except GeneratorExit:
        for target in targets:
            target.close()

eng_result_interpreter = count_formatter(multiline_printer(), 10)
swe_result_interpreter = count_formatter(colorer("magenta", multiline_printer()))

eng_counter = digit_mapper(english, letter_counter(eng_result_interpreter))
swe_counter = digit_mapper(svenska, letter_counter(swe_result_interpreter))

number_analyser = digit_splitter(broadcaster([eng_counter, swe_counter]))

P = number_producer(4)

for i in xrange(10):
    number_analyser.send(P.next())

number_analyser.close()

%%file hanoi.py
"""Solve 'Towers of Hanoi'
"""
import sys

PRINT = False

@profile
def solve(g,n):
    X = [sum(g[0])]
    Y = [sum(g[1])]
    Z = [sum(g[2])]

    moved = 0
    for i in range(2**n - 1):
        tops = [a[0] for a in g]
        movable = False
        j = 0
        while not movable:
            max_legal = max([t for t in tops if g[j][0] % 2 != t % 2])
            if g[j][0] != moved and g[j][0] > 0:
                num_zeros = len([z for z in tops if z == 0])
                if g[j][0] < max_legal or num_zeros > 0:
                    movable = True
            if not movable:
                j += 1
        
        moved = g[j][0]
        
        legal = False
        k = 2
        while not legal:
            if (tops[k] % 2 != g[j][0] % 2 and g[j][0] < tops[k]) or tops[k] == 0:
                legal = True
            if not legal:
                k -= 1
        
        g[k] = [g[j][0]] + g[k]
        g[j] = g[j][1::]

        if PRINT:
            print g

        S = [sum(s) for s in g]
        X += [S[0]]
        Y += [S[1]]
        Z += [S[2]]
    
    return (X,Y,Z)


if __name__ == "__main__":
    n = int(sys.argv[-1])
    game = [range(1,n+1)+[0], [0], [0]]

    X, Y, Z = solve(game,n)


%%bash
python -m cProfile hanoi.py 20

%%bash
python -m cProfile -o profile_name hanoi.py 18

%%script --bg bash
snakeviz profile_name

%%bash
python -m plop.collector hanoi.py 21

!cat /tmp/plop.out

%%script --bg bash
python -m plop.viewer --port=9876 --datadir=/tmp

%killbgscripts

%%bash
kernprof.py --line-by-line hanoi.py 12

%%bash
python -m line_profiler hanoi.py.lprof

%%bash
python -m memory_profiler hanoi.py 6

%%bash