>>> from collections.abc import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance(‘abc‘, Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

>>> class MyList(object):
...     def __init__(self):
...             self.container = []
...     def add(self, item):
...             self.container.append(item)
...     def __iter__(self):
...             """返回一个迭代器"""
...             # 我们暂时忽略如何构造一个迭代器对象
...             pass
...
>>> mylist = MyList()
>>> from collections import Iterable
>>> isinstance(mylist, Iterable)
True
>>>
# 这回测试发现添加了__iter__方法的mylist对象已经是一个可迭代对象了

from collections.abc import Iterable
import time


class MyList(object):
    """自定义一个可迭代对象"""

    def __init__(self):
        self.content = list()

    def add(self, item):
        self.content.append(item)

    def __iter__(self):
        # 1.要使一个对象是可迭代对象，必须实现__iter__方法
        # 2.要使一个对象迭代时能每次都返回一个值，必须让__iter__返回一个迭代器对象
        # 创建迭代器对象
        myiterator = MyIterator(self)
        return myiterator


class MyIterator(object):
    """自定义一个迭代器，必须实现__iter__方法和__next__方法"""

    def __init__(self, mylist_obj):
        self.mylist = mylist_obj
        self.current = 0

    def __iter__(self):
        pass

    def __next__(self):
        """每次迭代时返回的值实际是通过__next__方法返回的"""
        # 1.定义一个下标current，每次调用时+1，用来实现每次调用__next__时，返回下一个值
        # 2.注意判断下标current自增时是否会越界，若越界则手动抛出StopIteration异常
        #   外层for循环迭代时，若遇到StopIteration异常，则会停止迭代
        if self.current == len(self.mylist.content):
            raise StopIteration
        value = self.mylist.content[self.current]
        self.current += 1
        return value


def main():
    my_list = MyList()
    my_list.add(11)
    my_list.add(22)
    my_list.add(33)
    print(‘my_list是不是可迭代对象：‘, isinstance(my_list, Iterable))
    my_list_iterator = iter(my_list)
    print(‘my_list返回的迭代器为：‘, my_list_iterator)
    print(‘my_list的下一个值为：‘, next(my_list_iterator))
    for i in my_list:
        print(i)
        time.sleep(1)


if __name__ == ‘__main__‘:
    main()

import time


class MyList(object):
    """自定义迭代器"""

    def __init__(self):
        self.content = list()
        self.current = 0

    def add(self, value):
        self.content.append(value)

    def __iter__(self):
        return self

    def __next__(self):
        # 若越界则抛出StopIteration异常
        if self.current == len(self.content):
            raise StopIteration
        # 不越界则返回当前迭代的值，并自增下标current
        value = self.content[self.current]
        self.current += 1
        return value


def main():
    # 创建迭代器对象
    my_list = MyList()
　　print(‘my_list是不是一个可迭代对象‘, isinstance(my_list, Iterable))
　　print(‘my_list是不是一个迭代器‘, isinstance(my_list, Iterator))

# 添加值
    my_list.add(‘小明‘)
    my_list.add(‘小红‘)
    my_list.add(‘小花‘)
    # 遍历my_list
    for value in my_list:
        print(value)
        time.sleep(0.5)


if __name__ == ‘__main__‘:
    main()

import time


class Fibonacci(object):
    def __init__(self, num):
        self.a = 0
        self.b = 1
        self.num = num
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current == self.num:
            raise StopIteration
        temp = self.a
        self.a, self.b = self.b, self.a + self.b
        self.current += 1
        return temp


def main():
    fibonacci_1 = Fibonacci(10)
    fibonacci_2 = Fibonacci(5)
    fibonacci_3 = Fibonacci(8)
    # for循环接收可迭代对象
    for i in fibonacci_1:
        print(i)
        time.sleep(0.2)
    # list接收可迭代对象
    lst = list(fibonacci_2)
    print(lst)
    # tuple接收可迭代对象
    tpl = tuple(fibonacci_3)
    print(tpl)


if __name__ == ‘__main__‘:
    main()