day14 迭代器 生成器 面向过程思想

""
    迭代器
    什么是迭代器(iterator)
        器指的某种工具,
        迭代指的是更新换代的过程,例如应用程序的版本更新从1.0 变成 1.1 再1.2
        迭代的目的是要根据上一个结果,产生下一个结果,这是一个重复的过程,但不是单纯的重复
    迭代器就是,一种根据上一个结果得到下一个结果的工具,简单地说就是一种获取数据的工具

    可迭代对象
        指的就是可以使用迭代器取出数据的对象
        如何判断一个对象是否可迭代,就看这个对象是否提供迭代器,通过对象调用__iter__()来获取迭代器
        所有的容器类型(包括字符串)都是可迭代的

    迭代器的使用
        1.通过调用对象的__iter__()方法的到迭代器
        2.调用迭代器的__next__()方法来获取每一个值
    如何判断一个对象是不是迭代器?
        迭代是为了取值,取值使用next方法,那么只要对象具备 next方法就称之为迭代器
        其中文件类型比较特殊,它既是迭代器,又是可迭代对象

    迭代器总结:
        迭代器是一种通用的取值工具
        只有具备__iter__()方法的对象才能被迭代器取值,称之为可迭代对象
        迭代器是为了取值,只要具备next方法的就是迭代器,
        python中迭代器同时具备iter方法和next方法  调用iter将返回迭代器自身
        每一种数据类型内部的迭代实现都不各不相同

    为什么用迭代器?
        统一取值方式

    如何使用
        for ....
"""

# 要获取数据 首先得要有数据
# 保存数据的方式有很多,如下
# a = 10
# print(a)

# nums = [1,2,3,4,5,6,7,8]
# nums = "hello python"
# nums = {1,3,5,7,9}
# index = 0
# while index < len(nums):
#     t = nums[index]
#     index += 1
#     print(t)

# 目前每种数据类型 取值方式不统一这就有问题了,万一后续增加新的数据类型,还得学习新的取值方式,
# 每种类型还不同,最好的解决方案是:提供一种通用的取值方式使其可以搭配任何数据类型,于是就有迭代器

# 可迭代的类型

# msg = "hello python"
# # 带有__开头__结尾的方法都是内置的特殊方法,会在某个时间自动执行
# res = msg.__iter__()
# print(res)
#
# d = {}
# d.__iter__()
#
# s = set()
# s.__iter__()
#
# t = (1,)
# t.__iter__()
#
# li =[]
# li.__iter__()

#

# li = [1,23,4,5]
# res = li.__iter__()
# print(res)
#
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())

# print(res.__next__())

# msg = "hello python"
# msg = [1,2,4,5]
# msg = {"name":"张无忌","sex":"女"}
# msg = {1,2,3,4,5}
# # msg = 10
# res = msg.__iter__()
# while True:
#     try:
#         print(res.__next__())
#     except:
#         print("停止迭代啦.... 没有值了")
#         break
# print("over")
#
# # for
# for i in msg: # i = msg.__iter__().__next__()
#     print(i)
#
# f = open("1.迭代器.py",encoding="utf-8")
# for line in f:
#     print(line,end="")
#
# f.__iter__() # 文件也是可迭代对象

# f = open("1.迭代器.py",encoding="utf-8")
# f.__iter__() # 是一个可迭代对象
# f.__next__() # 是一个迭代器
# # 文件自身就是一个迭代器
# res = f.__iter__()
# print(res)
# print(f)
# print(res is f)

li = [ 1,2,3,4]
res = li.__iter__()
res.__iter__()

print(res)
print(res.__iter__().__iter__().__iter__().__iter__())

# msg = "hello world"

# 对于for而言 所有的对象都需要先判断是否是一个可迭代对象
"""
    伪代码
    if data.has(__iter__):
        it = data.__iter__()

"""

# res = msg.__iter__()
# while True:
#     try:
#         print(res.__next__())
#     except:
#         print("停止迭代啦.... 没有值了")
#         break
# print("over")
#
# d = {"name":"bgon","sex":"man"}
# print(list(d.keys()).__iter__())

s = {1,2,3,4,5}

while len(s) > 0:
    print(s.pop())
#
# 迭代器一定是可迭代对象
# 可迭代对象对应是迭代器
生成器

迭代器,生成器,for之间的关系
        for的原理是使用迭代器取值
        迭代器是通过生成实现的

    了解知识点:
    yield的特殊用法
        当你的生成器中需要外界数据参与时,生成器中如何接受外界数据?
        闭包和参数都能传数据到生成器中,但是都只能接收一次值,如果想要多次传值就需要使用send函数了
    send函数用于向生成器发送数据,但是要注意必须先进行初始化,也就是先调用一次__next__()方法

"""

# def my_generator():
#     print("start")
#     yield 1
#     print("over")
#     yield 2
#
#
# gen = my_generator()
# print(gen)
#
# res1 = gen.__next__()
# print(res1)
# res2 = gen.__next__()
# print(res2)

# 可以生成100个数字的生成器
# def get_num():
#     i = 1
#     while i <= 100:
#         yield i
#         i+=1
# #
# g = get_num()
# for i in range(100):
#     print(g.__next__())

# def my_range():
#     i = 0
#     while i < 5:
#         yield "a"
#         i += 1

# res = my_range()
# for i in res: # i = res.__iter().__next__()
#     print("=============")
#     print(i)

# for i in range(10):
#     print("123")

# send的使用
# def eat(name):
#     print("this is a chicken name is",name)
#     while True:
#         food = yield "鸡蛋"
#         print("收到的数据",food)
#
# c = eat("bgon")
#
#
# c.__next__() #初始化生成器
# c.send("饲料") #fasng shu
# c.send("虫子")

面向过程编程
    是一种编程思想,同样的在编程界不只有这一种编程思想,还要面向对象编程等等...
    编程思想没有高低之分,只有适合与不适合
    你要思考的是什么样的应用程序应该采用哪种编程思想

    核心在于过程,指的是在编程时时刻想着过程
        过程指的就是,第一步干什么第二步干什么,完成这个任务需要哪些步骤
        以及每个步骤要干什么

    面向过程编程思想的优点与缺点
    优点:可以将一个复杂的大问题,拆分简单的小问题,将复杂的问题简单化,流程化.
    缺点:牵一发需要动全身,扩展性极差,正因如此,才有了新的编程思想,即面向对象
    使用场景:对于一些对扩展性要求不高的应用程序,建议采用面向过程,例如系统内核,shell脚本程序等等
    后期我们开发的应用程序大多都是直接面向用户的,需求变化非常频繁,所以这时候就需要使用面向对象了