迭代器

可迭代協議：只要含有_iter_方法的都是可迭代的（list列表，dict字典，str字符串，tuple元祖，set集合， f=open(）文件打開操做拿到文件句柄 ，range()，                                                                                                 enumerate()枚舉函數等）

迭代器協議：只要內部含有_iter_ 方法和_next_方法的就是迭代器

可迭代的對象調用_iter_方法就變成了迭代器

[]._iter_()  (調用方法要加括號)

 

迭代器必定可迭代，可迭代的不必定是迭代器

只有是可迭代對象時才能用for循環

當遇到一個新對象不肯定能不能用for循環時，判斷是不是可迭代的（是否有_iter_方法）

 

# 雙下方法
# print([1].__add__([2]))
# print([1]+[2])

# 迭代器
# l = [1,2,3]
# 索引
# 循環 for
# for i in l:
#     i
#
# for k in dic:
#     pass


# list
# dic
# str
# set
# tuple
# f = open()
# range()
# enumerate
# print(dir([]))   #告訴我列表擁有的全部方法
# ret = set(dir([]))&set(dir({}))&set(dir(''))&set(dir(range(10))) #集合的交集
# print(ret)  #iterable
# print('__iter__' in dir(int))
# print('__iter__' in dir(bool))
# print('__iter__' in dir(list))
# print('__iter__' in dir(dict))
# print('__iter__' in dir(set))
# print('__iter__' in dir(tuple))
# print('__iter__' in dir(enumerate([])))
# print('__iter__' in dir(range(1)))

# 只要是能被for循環的數據類型 就必定擁有__iter__方法
# print([].__iter__())
# 一個列表執行了__iter__()以後的返回值就是一個迭代器
# print(dir([]))
# print(dir([].__iter__()))
# print(set(dir([].__iter__())) - set(dir([])))
# print([1,'a','bbb'].__iter__().__length_hint__())  #元素個數
# l = [1,2,3]
# iterator = l.__iter__()
# print(iterator.__next__())
# print(iterator.__next__())
# print(iterator.__next__())
# print(iterator.__next__())

# Iterable  可迭代的    -- > __iter__  #只要含有__iter__方法的都是可迭代的
# [].__iter__() 迭代器  -- > __next__  #經過next就能夠從迭代器中一個一個的取值

# 只要含有__iter__方法的都是可迭代的 —— 可迭代協議

# print('__iter__' in dir( [].__iter__()))
# print('__next__' in dir( [].__iter__()))
from collections import Iterable
from collections import Iterator
# print(isinstance([],Iterator))
# print(isinstance([],Iterable))

# isinstance()
# 函數來判斷一個對象是不是一個已知的類型，相似type()。
#
# isinstance()與type()區別：
#
# type()不會認爲子類是一種父類類型，不考慮繼承關係。
#
# isinstance()會認爲子類是一種父類類型，考慮繼承關係。
#
# 若是要判斷兩個類型是否相同推薦使用isinstance()。
#
# 語法
# 如下是isinstance()方法的語法:
#
# isinstance(object, classinfo)
# 參數
# object - - 實例對象。
# classinfo - - 能夠是直接或間接類名、基本類型或者由它們組成的元組。
# 返回值
# 若是對象的類型與參數二的類型（classinfo）相同則返回True，不然返回False。。
#
# 實例
# 如下展現了使用
# isinstance
# 函數的實例：
#
# >> > a = 2
# >> > isinstance(a, int)
# True
# >> > isinstance(a, str)
# False
# >> > isinstance(a, (str, int, list))  # 是元組中的一個返回 True
# True
#
# type()與isinstance()區別：
#
# class A:
#     pass
#
#
# class B(A):
#     pass
#
#
# isinstance(A(), A)  # returns True
# type(A()) == A  # returns True
# isinstance(B(), A)  # returns True
# type(B()) == A  # returns False


# class A:
#     # def __iter__(self):pass
#     def __next__(self):pass
#
# a = A()
# print(isinstance(a,Iterator))
# print(isinstance(a,Iterable))


# l = [1,2,3,4]
# for i in l.__iter__():
#     print(i)

# 迭代器的概念
# 迭代器協議 —— 內部含有__next__和__iter__方法的就是迭代器

# 迭代器協議和可迭代協議
# 能夠被for循環的都是可迭代的
# 可迭代的內部都有__iter__方法
# 只要是迭代器 必定可迭代
# 可迭代的.__iter__()方法就能夠獲得一個迭代器
# 迭代器中的__next__()方法能夠一個一個的獲取值

# for循環其實就是在使用迭代器
# iterator
# 可迭代對象
# 直接給你內存地址
# print([].__iter__())
# print(range(10))

#for
#只有 是可迭代對象的時候 才能用for
#當咱們遇到一個新的變量，不肯定能不能for循環的時候，就判斷它是否可迭代

# for i in l:
#     pass
#iterator = l.__iter__()
#iterator.__next__()

#迭代器的好處：
    # 從容器類型中一個一個的取值，會把全部的值都取到。
    # 節省內存空間
        #迭代器並不會在內存中再佔用一大塊內存，
            # 而是隨着循環 每次生成一個
            # 每次next每次給我一個
# range
# f
# l = [1,2,3,45]
# iterator = l.__iter__()
# while True:
#     print(iterator.__next__())

# print(range(100000000000000))
# print(range(3))
# print(list(range(3)))
# def func():
#     for i in  range(2000000):
#         i = 'wahaha%s'%i
#     return i

# 生成器 —— 迭代器
# 生成器函數 —— 本質上就是咱們本身寫得函數
# 生成器表達式
l = [1,2,3,4,5]
for i in l:
    print(i)
    if i == 2:
        break

for i in l:
    print(i)