def dump(xs) :
    print 'One:',
    for x in xs : print x,
    print
    print 'Two:',
    for x in xs : print x,
    print

def series(n) :
    for x in range(n) : yield x

print 'Range:'
dump(range(5))

print 'Series:'
dump(series(5))

Range:
One: 0 1 2 3 4
Two: 0 1 2 3 4
Series:
One: 0 1 2 3 4
Two:

def dump(xsf) : # means 'x series function'
    print 'One:',
    for x in xsf() : print x,
    print
    print 'Two:',
    for x in xsf() : print x,
    print

dump(lambda : range(5))
dump(lambda : series(5))

def rnd_gen():
  yield random( )

# -*- coding: windows-1251 -*-

class RewindableGenerator(object):

    def __init__(self, func, args, kwargs):
        self.func = func
        self.args = args
        self.kwargs = kwargs

    def __iter__(self):
        return self.func(*self.args, **self.kwargs)


def real_generator(func):
    def wrapper(*args, **kwargs):
        return RewindableGenerator(func, args, kwargs)
    return wrapper


@real_generator
def foo():
    yield 42


gen = foo()
print list(gen)
print list(gen)

def squares() :
    for x in range(10) :
        yield x*x

@real_generator
def roots(xs) :
    for x in xs :
        yield sqrt(x)
        if x==1 : break # чуть более затейливая логика, чтоб веселее было

s = squares
r = roots(s)
print list(r) # [0.0, 1.0]
print list(r) # [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

E>@real_generator
E>def foo():
E>    yield 42

>>> x = (i for i in (1, 2, 3))
>>> x
<generator object at 0x00C48440>
>>> list(x)
[1, 2, 3]
>>> list(x)
[]

>>> x = lambda : (i*i for i in (1,2,3))
>>> x
<function <lambda> at 0x00B877B0>
>>> x()
<generator object at 0x00B86AD0>
>>> list(x)
[1, 2, 3]
>>> list(x)
[1, 2, 3]

x = [1, 2, 3].map { |i| i * i }

x.map { |i| puts(i) } # puts - аналогог питоновского print

x.map { |i| puts(i) }

x = [1, 2, 3].map { |i| i * i }

puts x # puts - аналог питоновского print
puts x

def over_squares
    for i in (1..3)
        yield i * i
    end
end

over_squares { |i| puts i }
over_squares { |i| puts i }

print map(sqrt, map(lambda x: x * x, xrange(10)))

(1..9)
    .map {|x| x * x }        
            .map { |x| sqrt(x) }

К>Кстати, а лепо ли, что map, помимо побочных эффектов, ещё и список (из nil'ов) возвращает?

E>(1..9)
E>    .map {|x| x * x }        
E>            .map { |x| sqrt(x) }
E>

map_ = flip map
xs = [1..9] `map_` (\x -> x*x) `map_` sqrt

К>А в хаскеле можно любую двухместную функцию записать как инфиксный оператор Которым, безусловно, является вызов метода (слева — объект, справа — кортеж аргументов).

К>map_ = flip map
К>xs = [1..9] `map_` (\x -> x*x) `map_` sqrt
К>

-- Подготовить список замен к использованию в lookup
prepareSubsts x = x
    -- Удалить пустые строки, пробелы и комментарии
    .$ map (filter (not.isSpace) . fst . split2 ';') .$ filter (not.null)
    -- Заменить каждую строку с символом # на 9 строк, где # пробегает значения от 1 до 9
    .$ concatMap (\s -> map (\d->replace '#' d s) ['2'..'9'])
    -- Преобразовать список строк вида "a=b" в список для lookup
    .$ map (split2 '=')

class Generator.<O, I, E> {
  public function send(i: I) : O,
  public function next() : O;
  public function throw(e : E) : O,
  public function close() : void
};

from generator_tools import copy_generator

def gen(n):
    while n > 0:
        yield n
        n -= 1

g1 = gen(10)
g2 = copy_generator(g1)
    
print zip(g1, g2)