Python 基础 内置函数 迭代器与生成器

今天就来介绍一下内置函数和迭代器 、生成器相关的知识

一、内置函数：就是Python为我们提供的直接可以使用的函数。

简单介绍几个自己认为比较重要的
1.#1.eval函数：（可以把文件中每行中的数据类型提取出来（之前是字符串类型））
a = "{'a':23,'b':43,'book':'english'}"
print(eval(a))
 
2.#2.hash(可以hash的数据类型是不可变数据类型)
a = 'alex'
b = hash(a)
print(b)
 
3.#zip 函数(组成一一对应的元组)（如果外面不加一个lis那没得到的就是一个zip对象）
print(list(zip(('a','b','c'),(1,2,3))))
print(list(zip(('a','b','c'),(1,2,3,4))))
print(list(zip(('a','b','c','d'),(1,2,3))))
 
p = {'name':'alex','age':23,'gender':'male'}
print(list(zip(p.keys(),p.values())))
输出结果为：
[('a', 1), ('b', 2), ('c', 3)]
[('a', 1), ('b', 2), ('c', 3)]
[('a', 1), ('b', 2), ('c', 3)]
[('name', 'alex'), ('age', 23), ('gender', 'male')]
 
# #max 和 min 函数
# l = [
#     (5,'e'),
#     (2,'b'),
#     (3,'c'),
#     (6,'d')
# ]
#
# print(list(max(l)))
# #max 函数的两点说明：
# #1.max处理的是可以迭代的对象，相当于for循环取出每个元素进行比较，不同数据类型之间不可以比较
# #2.每个元素之间的比较是从每个元素的第一个位置依次比较，如果此位置可以区分出大小，后面就不需要比较了，直接得出这两个元素的大小
#
#
# #sorted函数的使用(都是按照从小到大的顺序进行排列)
#
# name_dict ={
#     'yuanhao':80,
#     'alex':99,
#     'wupeiqi':700
# }
# print(sorted(name_dict))
# print(sorted(name_dict,key = lambda key:name_dict[key]))
#

内置函数的补充：

1.对数据的进制转化
a = hex(12)#10转16
b = bin(12) #10转 2
c = oct(12) #10 转8
print(a)
print(b)
print(c)
 
#输出结果为：
0xc
0b1100
0o14
 
2.数字转字母，字母转数字
a = ord('A')
b = chr(99)
print(a,b)
输出结果：65 c
 
3.divmod 取余函数（用在做网页的文章分页）
c = divmod(10,3)
print(c)
输出结果：(3, 1)  #3余数为1
 
4.求次方函数
d = pow(2,3)
e = pow(2,3,4)
print(d,e) #d:2的3次方；e:2的3次方对4取余
 
5.reversed函数取翻转
 
6.round（） #四舍五入函数

二、迭代器协议与生成器

1.迭代器协议：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）

2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）

3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。

三、Python中强大的for 循环机制

for循环的本质：循环所有对象，全都是使用迭代器协议。

很多人会想，for循环的本质就是遵循迭代器协议去访问对象，那么for循环的对象肯定都是迭代器了啊，没错，那既然这样，for循环可以遍历（字符串，列表，元组，字         典，集合，文件对象），那这些类型的数据肯定都是可迭代对象啊？但是，我他妈的为什么定义一个列表l=[1,2,3,4]没有l.next()方法，打脸么。

(字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环式，调用了他们内部的__iter__方法，把他们变成了可迭代对象

然后for循环调用可迭代对象的__next__方法去取值，而且for循环会捕捉StopIteration异常，以终止迭代

#2.for循环内部实现的机制
 
l = [1,2,3,4]
 
for i in l:#（i_1 = l._iter__() / i_l.__next__()）
    print(i)
 
iter_l = l.__iter__()#遵循迭代器协议，生成可以迭代的对象
print(iter_l.__next__())
print(iter_l.__next__())
print(iter_l.__next__())
 
#通过while循环实现遍历列表
l = [1,3,5]
index = 0
while index <len(l):
    print(l[index])
    index +=1
 
#集合中使用迭代器
s = {1,2,3}
iter_s = s.__iter__()
print(iter_s)
print(iter_s.__next__())
print(iter_s.__next__())
print(iter_s.__next__())
 
#字典中使用迭代器
d = {'alex':44,'egon':56}
iter_d = d.__iter__()#默认迭代的是key值
print(iter_d.__next__())
print(iter_d.__next__())
 
#文件中使用迭代器
with open('test','r+') as f:
 
    iter_f = f.__iter__()
    print(iter_f.__next__(),end = '')#通过end参数解决了不是以默认的方式换行的问题
    print(iter_f.__next__(),end = '')
    print(iter_f.__next__(),end = '')
 
#文件关闭后对文件的操作就会报错
f=open('test','r')
iter_f = f.__iter__()
print(iter_f.__next__())
#f.close()
print(iter_f.__next__())
 
'''

四、生成器

可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象

生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）

    1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

    2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

为何使用生成器之生成器的优点

Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。

生成器小结：

1.是可迭代对象

2.实现了延迟计算,省内存啊

3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处，记住喽！！！

 def test():
     yield 1
     yield 2
     yield 3
 g=test()#写完此句才是生成器对象
 print('来自函数',g)#来自函数 <generator object test at 0x02170CC0>
 # print(g.__next__())#生成器内部有next方法，直接调用就ok
 # print(g.__next__())
 # print(g.__next__())
 
 #三元表达式
 name='alex'
 name='linhaifeng'
 res='SB' if name == 'alex' else '帅哥'
 print(res)
 
 #列表解析
 #通过for循环的形式实现原理
 egg_list=[]
 for i in range(10):
     egg_list.append('鸡蛋%s' %i)
 print(egg_list)
 #列表解析的表达形式
 l=['鸡蛋%s' %i for i in range(10)]#%后面相当于一个要传给前面的一个参数
 l1=['鸡蛋%s' %i for i in range(10) if i > 5 ] #列表解析中的三元表达式形式
 # # l1=['鸡蛋%s' %i for i in range(10) if i > 5 else i] #没有四元表达式
 # l2=['鸡蛋%s' %i for i in range(10) if i < 5] #没有四元表达式
 
 print(l)
 print(l1)
 # print(l2)
 
 #生成器表达式
 laomuji=('鸡蛋%s' %i for i in range(10)) #生成器表达式，就是把列表解析中的[]换成（）
 print(laomuji)
 print(laomuji.__next__())
 print(laomuji.__next__())
 print(next(laomuji))
 print(next(laomuji))
 print(next(laomuji))
 print(next(laomuji))
 print(next(laomuji))
 print(next(laomuji))
 print(next(laomuji))
 print(next(laomuji))
 # print(next(laomuji)) 报错： StopIteration
 
 '''
 '''
 #生成器函数
 import time
 def test():
     print('开始生孩子啦。。。。。。')
     print('开始生孩子啦。。。。。。')
     print('开始生孩子啦。。。。。。')
     yield '我' #yield 相当于return 作用就是做返回值用
     time.sleep(3)
     print('开始生儿子啦')
     yield '儿子'
 
     time.sleep(3)
     print('开始生孙子啦')
     yield '孙子'
 
 res=test()#执行此句只是在定义一个生成器对象
 print(res)#<generator object test at 0x00700D20>
 print(res.__next__()) #test()
 print(res.__next__()) #test()
 print(res.__next__()) #test()

实现生产者和消费者模型的例子：

#实例：实现生产者消费者模型
#通过生成器实现协程并行运算
import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield 1 #yield 的第二个作用就是接受send传过来的参数赋值给包子变量
 
       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
 
def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    print( c.__next__())
    print(c2.__next__())
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)#send 函数实现了向yield函数传递参数的作用
        c2.send(i)
 
producer("alex")

生成器中send（）方法的应用

#send 参数的实例演示
#yield 相当于return 控制的是函数的返回值
#x = yield  的另外一个特性就是接受send传过来的值并且把值付给x
 
def test():
    print('开始啦')
    first = yield 1 #return 1 first = None
    print('第一次',first)
    yield 2
    print('第二次')
 
t = test()
res = t.__next__()# -->next()
print(res) #res取得是yield的返回值
 
t.send(None)
 
计算结果为：
开始啦
1
第一次 None

生成器总结：

综上已经对生成器有了一定的认识，下面我们以生成器函数为例进行总结

• 语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
• 自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常
• 状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从它离开的地方继续执行

优点一：生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。

优点二：生成器还能有效提高代码可读性

注：此处的总结来源于：http://www.cnblogs.com/linhaifeng/articles/6133014.html