迭代器与生成器以及面向过程编程

十.迭代器
#什么是迭代？ 迭代
#l=['a','b','c','d','f']
l=('a','b','c','d')
n=0
while n < len(l):
	print(l[n])
	n+=1

可迭代对象：
1.获取可迭代对象的方式：Python内置 str list tuple dict set file都是可迭代对象
2.特点：
内置有_iter_方法都叫可迭代的对象

迭代器对象：文件对象本身就是迭代器对象

1.获取迭代器对象的方式：
    执行可迭代对象的_iter_方法 拿到的返回值就是迭代器对象
2.特点：
    内置有_next_方法 执行该方法会拿到迭代器对象中的一个值
    内置有_iter_方法 执行该方法会拿到迭代器本身


#字典
dic={'x':1,'y':2,'z':3}
iter_dic=dic.__iter__()
print(iter_dic.__next__())  #迭代取值 
print(iter_dic.__next__()) 

#字符串
l='hello'
iter_l=l.__iter__()
while True:
	try:
		print(iter_l.__next__())
	except StopIteration:
		break
#文件
l=open('a.txt','r',encoding='utf-8')
iter_1=l.__iter__()
while True:
	try:
		print(iter_l.__next__())
	except StopIteration:
		break

十一.生成器：函数内包含内有yield关键字 就不会执行函数体代码 拿到的返回值就是一个生成器对象

def chicken():
	print('=======>first')
	yield 1
	print('==========>second')
	yield 2
	print('=========>third')
	yield 3

obj=chicken()
res=obj.__next__()  #迭代取值
print(res)
res1=obj.__next__()
print(res1)
res2=obj.__next__()
print(res2)
#print(obj.__iter__())  #是个迭代对象


总结yield：
1.为我们提供了一种自定义迭代器的方式 可以在函数内用yield关键字 调用函数拿到的结果就是一个生成器 生成器就是迭代器
2.yield可以像return 一样用于返回值 区别是return只能返回一次 而yield可以返回多次 因为yield可以保持函数执行的状态

#造无穷个值
def my_rang():
	print('start.......')
	n=0
	while True:
		yield n  #返回多个值
		n+=1

obj=my_rang()  #得到迭代器
print(obj.__next__())
print(obj.__next__())
print(obj.__next__())

#自造rang函数
def my_range(start,stop,step=1): #step 为步长
	n=start  #初始化值
	while n < stop:   #迭代的值小于结束的值
		yield n 		# 返回值
		n+=step          #每次步长+初始化值 增长
for item in my_rang(5,10,2):  #传值 步长为2
	print(item)


obj=my_rang(3,7,2)   # 迭代器对象
print(obj.__next__())  #迭代取值
print(obj.__next__())

#yield 表达式 
 def eat(name):
 	print('%s ready to eat' %name)
 	food_list=[]
 	while True:
 		food=yield food_list  #yield 接收值的功能 转交给前面的变量 food=
 		food_list.append(food)  #food_list=['泔水'] 重新赋值给food
 		print('%s start to eat %s' %(name,food))

 dog1=eat('zhang')  #拿到生成器
 1.必须初始化一次 让函数停在yield的位置
 res0=dog1.__next__()
 print(res0)

2.喂狗  
send有两方面的功能：
1.与_next_的效果一致
2.给yield传值
res1=dog1.send('泔水')
print(res1)

十二.面向过程编程
'''
1 面向过程的编程思想
    核心是'过程'二字，过程即解决问题的步骤，即先干什么，再干什么。。。。
    基于面向过程编写程序就好比在设计一条流水线，是一种机械式的思维方式。


2、示范：

3、总结优缺点：
    优点：复杂的问题流程化，进而简单化
    缺点：修改一个阶段，其他阶段都有可能需要做出修改，牵一发而动全身，即扩展性极差
    应用：用于扩展性要求低的场景

'''
#1、步骤一：拿到用户输入的合法的信息：用户名、密码、余额、年龄
db_path='db.txt'

def get_uname():
    while True:
        uname=input('用户名>>：').strip()
        if not uname.isalpha(): #判断是否为英文字母
            print('33[45m用户名必须为英文字母...33[0m')
            continue
        with open(r'%s' %db_path,'r',encoding='utf-8') as f:
            for line in f:
                uinfo=line.strip('
').split(',') 以逗号分隔
                if uname == uinfo[0]:
                    print('33[45m用户名已存在...33[0m')
                    break
            else:
                return uname

def get_pwd():
    while True:
        pwd1=input('请输入密码>>: ').strip()
        pwd2=input('再次输入密码>>: ').strip()
        if pwd1 == pwd2:
            return pwd1
        else:
            print('33[45m两次输入的密码不一致，请重新输入...33[0m')

def get_bal():
    while True:
        bal=input('请输入余额: ').strip()
        if bal.isdigit(): #判断是否为数字
            # bal=int(bal)
            return bal
        else:
            print('33[45m钱必须是数字，傻叉...33[0m')

def get_age():
    pass

#2、步骤二：写入文件
def file_hanle(uname,pwd,bal,age):
    with open(r'%s' %db_path,'a',encoding='utf-8') as f:
        f.write('%s,%s,%s,%s
' %(uname,pwd,bal,age))

# 注册功能
def register():
    #步骤1：
    uname=get_uname() #拿到合法的用户名
    pwd=get_pwd() #拿到合法的密码
    bal=get_bal() #拿到合法的余额
    #步骤2：
    file_hanle(uname,pwd,bal) #写入文件