函数—函数进阶（二）

                                      函数—函数进阶（二）

•  函数—函数进阶—列表生成式

#列表回顾
name = [2,5,7,9,4]
print(name)
for i in name:
    print(i)
#结果为：
# [2, 5, 7, 9, 4]
# 2
# 5
# 7
# 9
# 4

#枚举
for index,i in enumerate(name):
    print(index,i)
#结果为：
# 0 2
# 1 5
# 2 7
# 3 9
# 4 4


#问题：把列表里的每个值加1
#二逼青年版
a = [0,1,2,3,4,5,6,7,8,9]
print(a)               #结果为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b = []
for i in a:b.append(i+1)
print(b)                 #结果为：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = b             #将b列表赋值给a列表
print(a)               #结果为：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#普通青年版
a = [0,1,2,3,4,5,6,7,8,9]
print(a)               #结果为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for index,i in enumerate(a):        #通过索引值增加
    a[index] += 1
print(a)               #结果为：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#文艺青年版
a = [0,1,2,3,4,5,6,7,8,9]
print(a)               #结果为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = map(lambda x:x+1,a)
print(a)              #结果为：<map object at 0x000001853C723FD0>
for i in a:
   print(i)           #结果为：1,2,3,4,5,6,7,8,9,10


#装逼青年版（列表生成式）
a = list(range(10))
print(a)               #结果为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = [i+1 for i in a]        #列表生成式
print(a)              #结果为：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

a = [i for i in a]
print(a)              #结果为：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

a = [i*i for i in a]
print(a)              #结果为：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

#三元运算
b = list(range(10))
print(b)               #结果为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b = [i if i < 5 else i*i for i in b]
print(b)              #结果为：[0, 1, 2, 3, 4, 25, 36, 49, 64, 81]


#既可以循环元组，字典，还可以循环字符串
c = 'alexli'
c = [i for i in c]
print(c)             #结果为：['a', 'l', 'e', 'x', 'l', 'i']

#字符串可以相加
c = 'alexli'
c = [i+'w' for i in c]
print(c)             #结果为：['aw', 'lw', 'ew', 'xw', 'lw', 'iw']

#字符串可以相乘
c = 'alexli'
c = [i*2 for i in c]
print(c)             #结果为：['aa', 'll', 'ee', 'xx', 'll', 'ii']

•  函数—函数进阶—生成器

        通过列表生成式可以直接创建一个列表。但是受到内存限制，列表容量是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。 

       如果列表元素可以按照某种算法推算出来，可以在循环的过程中不断推算出后续的元素。这样就不必创建完整的list，从而节省大量的空间。

      在Python中，这种一边循环一边计算的机制，称为生成器：generator。

      

#创建一个包含1000个元素的列表
a = [i for i in range(1000)]
print(a)

#生成器(把一个列表生成式的[]改成()，就创建了一个generator )
a2 = (i for i in range(1000))
print(a2)                     #结果为：<generator object <genexpr> at 0x000002B27DF5A048>
print(next(a2))               #结果为：0
print(next(a2))               #结果为：1
print(next(a2))               #结果为：2
print(next(a2))               #结果为：3
print(next(a2))               #结果为：4
print(next(a2))               #结果为：5
print(next(a2))               #结果为：6
print(next(a2))               #结果为：7
print(next(a2))               #结果为：8
#停止
print(a2)                     #结果为：<generator object <genexpr> at 0x0000018F10C2A048>
#继续
print(next(a2))               #结果为：9
print(next(a2))               #结果为：10
print(next(a2))               #结果为：11
print(next(a2))               #结果为：12

#小结：
#使用next(a2)方法
#一个个的打印，可以打印1000个，不占用内存空间。
# 这种方法只能够向前，不能够后退。
#到最后的时候，会报错

a = (i for i in range(5))
print(next(a))          #结果为：0
print(next(a))          #结果为：1
print(next(a))          #结果为：2
print(next(a))          #结果为：3
print(next(a))          #结果为：4
print(next(a))          #结果为：StopIteration

•  函数—函数进阶—斐波那契

#这种不断调用next(a)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象
#for 循环
a = (i for i in range(10))
for i in a:
    print(i)                 #结果为：0  1  2  3  4  5  6  7  8  9

#while 语句
while True:
    print(next(a))          #结果为：0  1  2  3  4  5  6  7  8  9    但是会报错

#range就是生成器的原理生成的
'''
range在Python3与Python2中range的区别:
Python3(生成器)：
E:Python>python3
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:59:51) [MSC v.19
14 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more informa
tion.
>>> range(100)
range(0, 100)      不会占用内存

Python2：
E:Python>python2
Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.
1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more informa
tion.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

在Python2中，如何用生成器方式表示range：
E:Python>python2
Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit
(AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> xrange(1000000)
xrange(1000000)

总结：Python2中的xrange(100000)等价于Python3中的range(100000)
'''

#著名的斐波拉契数列（Fibonacci）：除第一个和第二个数外，任意一个数都可由前两个数相加得到：
#1, 1, 2, 3, 5, 8, 13, 21, 34, ...
#斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

a,b = 1,2
print(a)               #结果为：1
print(b)               #结果为：2

#斐波那契数列
def fib(max):
    n, a, b = 0, 0, 1              #n=0 a=0 b=1
    while n < max:
        print(b)
        a, b = b, a+b              #将b的值赋值给a,同时将a+b的值赋值给b
        n = n + 1
    return 'done'
fib(15)                            #结果为：1 1 2 3 5 8 13 21 34 55 89 144 233 377 610

# 赋值语句：  a, b = b, a + b
# 相当于：
# t = a + b
# a = b
# b = t


#生成器(yield)
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print('before yield')
        yield b                        #yield的作用：把函数的执行过程冻结在这一步并且把b的值返回给外面的next()方法
        print(b)
        a, b = b, a+b
        n = n + 1
    return 'done'

f = fib(15)                            #将功能转换成一个“生成器”
next(f)
next(f)
next(f)
next(f)
#结果为：
# before yield
# 1
# before yield
# 1
# before yield
# 2
# before yield

#小结：
# yield 把函数的执行过程冻结在了这一步
# 此时可以把 b 的值，返回给外面的 next() 方法
# 函数名添加()，内部代码不执行，只是生成一个生成器对象

•  函数—函数进阶—生成器调用方法

#生成器
a = (i for i in range(10))
print(a)                      #结果为：<generator object <genexpr> at 0x0000022D719CA408>
print(next(a))                #结果为：0
print(next(a))                #结果为：1
print(next(a))                #结果为：2
print(next(a))                #结果为：3
print(next(a))                #结果为：4
print(next(a))                #结果为：5

#while
a = (i for i in range(10))
while True:
    print(next(a))

#for 循环
a = (i for i in range(10))
for i in a:
    print(i)
'''
总结：
Python2：
   range = list
   xrange = 生成器
   
Python3：
   range = 生成器
   xrange   没有
'''

•  函数—函数进阶—函数写生成器

'''
生成器的创建方式：
  1、列表 生成 式 （）  只能写一个三元运算
  2、函数
'''
#函数
def range2(n):
    count = 0
    while count < n:
        print(count)
        count += 1
range2(10)                        #函数内部执行


#将函数变为生成器
def range2(n):
    count = 0
    while count < n:
        print('count',count)
        count += 1
        yield count     #类似return， yield 使程序冻结，next 解冻
range2(10)               #因为 yield 没有返回结果
print(range2(10))                   #结果为：<generator object range2 at 0x0000024840A7A408>
new_range = range2(10)
r1 = next(new_range)                #结果为：count 0
print(r1)                           #结果为：1
print('干点别的事...')            #结果为：干点别的事...
r2 = next(new_range)                #结果为：count 2
print(r2)                           #结果为：2

# 除了使用next()方法外，还可以使用new_range.__next__()
new_range.__next__()                #结果为：count 2

'''
小结
yield vs return
return 返回并且中止function
yield 返回数据并且冻结当前的执行过程
next 唤醒冻结的函数执行过程，继续执行，直到遇到下一个yield
'''
'''
生成器：
之前的函数从调用起，就必须等待执行结果结束，并返回计算值
生成器可以把函数整个运行过程中的结果，返回至外面
yield,是暂停的意思
'''

 

•  函数—函数进阶—生成器send方法

# def range2(n):
#     count = 0
#     while count < n:
#         print('count',count)
#         count += 1
#         yield count          #类似于return,yield使程序冻结，next才解冻
#     print('-------')
#     return 333333
#
# new_range = range2(3)
#
# n1 = next(new_range)
# n2 = next(new_range)
# n3 = next(new_range)
# n4 = next(new_range)
# print(n3)
# print(n4)

'''
函数有了yield之后：
 1、函数名称加()，就得到了一个生成器
 2、return 在生成器里代表生成器的终止，直接报错
'''

def range2(n):
    count = 0
    while count < n:
        print('count',count)
        count += 1
        sign = yield count               #类似于return,yield使程序冻结，next才解冻
        if sign == 'stop':
             print('--sign',sign)
             break
    return 333333              #函数中有了yield 就不会被执行了
    
new_range = range2(3)
n1 = next(new_range)

new_range.send('stop')

#send方法的作用：
#1、唤醒并继续执行,next方法只能唤醒
#2、发送一个信息到生成器内部

 

•  函数—函数进阶—迭代器

'''
我们已经知道，可以直接作用于for循环的数据类型有以下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
'''
#可以使用isinstance()判断一个对象是否是Iterable对象
from collections import Iterable
print(isinstance('abc',Iterable))           #结果为：True
print(isinstance(100,Iterable))              #结果为：False
print(isinstance([],Iterable))               #结果为：True
print(isinstance({ },Iterable))              #结果为：True
print(isinstance((x for x in range(10)),Iterable))      #结果为：True

#生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
#可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

#可以使用isinstance()判断一个对象是否是Iterator对象：
from collections import Iterator
print(isinstance((x for x in range(10)), Iterator))             #结果为：True
print(isinstance([], Iterator))                           #结果为：False
print(isinstance({}, Iterator))                           #结果为：False
print(isinstance('abc', Iterator))                       #结果为：False

#生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

#但是可以把list、dict、str等Iterable变成Iterator，使用iter()函数：
print(isinstance(iter([]), Iterator))                      #结果为：True
print(isinstance(iter('abc'), Iterator))                  #结果为：True

'''
那么，为什么list、dict、str等数据类型不是Iterator？

因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。
可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据。
所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如，全体自然数。而使用list是永远不可能存储全体自然数的。

在当前的阶段，generator与Iterator基本是一致的。

小结：
1、凡是可作用于for循环的对象都是Iterable类型
2、凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列
3、集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
4、Python3的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass
等价于：
it = iter([1, 2, 3, 4, 5])

# 循环
while True:
    try:
        x = next(it)
    except StopIteration:
        break
'''