Python-сообщество

class C(object): pass
c = C()
iter(c)

class ifib():
    def __init__(self, n):
        self.n = n
        self.prev = 1
        self.prevprev = 0
        
    def __iter__(self):
        return self
        
    def next(self):
        self.prev, self.prevprev = self.prev + self.prevprev, self.prev
        if self.prev<self.n:
            return self.prev
        else:
            raise StopIteration

void perm(char *in, char *buf, int len) {
    static cur = 0;
    int i;
    if (cur == len) {
        puts(buf);
        return;
    }
    for (i = 0; i < len; i++) {
        if (in[i]) {
            buf[cur] = in[i];
            in[i] = 0;
            cur++;
            perm(in, buf, len);
            in[i] = buf[--cur];
        }
    }
}

class C(object):
    def __init__(self, L):
        self.list = L
    def __iter__(self):
        for i in xrange(0, len(self.list)):
            yield self.list[i]

def ifibonacci():
    last, curr = 0, 1
    while True:
        last, curr = curr, last + curr
        yield curr

>>> print iter.__doc__
iter(collection) -> iterator
iter(callable, sentinel) -> iterator

Get an iterator from an object.  In the first form, the argument must
supply its own iterator, or be a sequence.
In the second form, the callable is called until it returns the sentinel.

>>> class C(object):
    def __init__(self, L):
        self.list = L
    def __iter__(self):
        for i in xrange(0, len(self.list)):
            yield self.list[i]
            
>>> s = C([1,2,3])
>>> a = iter(s)
>>> a
<generator object at 0x011592B0>
>>> a.next()
1
>>> a.next()
2
>>> a.next()
3
>>> a.next()

Traceback (most recent call last):
  File "<pyshell#118>", line 1, in <module>
    a.next()
StopIteration

class C(object):
    def __iter__(self): return self

# -*- coding: utf-8 -*-

class xrange(object):
    """xrange([start = 0], end, [step = 1])"""

    def __init__(self, start_or_stop, end = None, step = 1):
        if end is None:
            start, end = 0, start_or_stop
        else:
            start = start_or_stop
        self.start = start
        self.end = end
        self.step = step

        # Вычисляем количество членов последовательности 
        if start < end and step < 0:
            self.len = 0
        elif start > end and step > 0:
            self.len = 0
        elif start == end:
            self.len = 0
        elif step == 0:
            raise ValueError("xrange() step argument must not be zero")
        else:
            self.len = abs((end - start) / step)

        # Максимальный и минимальный (отрицательный) индексы
        self.max_index = self.len - 1
        self.min_index = self.len * (-1)

    def __len__(self): return self.len

    def __getitem__(self, n):    # Вызывается при доступе к индексу
        if self.len == 0:
            raise IndexError("xrange object index out of range")
        elif not self.min_index <= n <= self.max_index:
            raise IndexError("xrange object index out of range")

        if n < 0:    # Если индекс отрицательный, то приводим его к положительному
            n = self.len + n

        return self.start + self.step * n    # Вспоминаем шестой(?) класс средней школы

print type(iter(xrange(10, 20, 2)))