python(三)高级特性切片迭代等

切片：取一个list或tuple的部分元素是很是常见的操做

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
 ##取前3个元素
 L[0:3]=['Michael', 'Sarah', 'Tracy'] ##或 L=[:3]
 ##N个元素，也就是索引为0-(N-1)的元素
## 能够从索引1开始，取出2个元素出来：
 >>> L[1:3]
['Sarah', 'Tracy']
##L[-1]取倒数第一个元素，那么它一样支持倒数切片,倒数第一个元素是-1 不是从零开始
>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']
##前10个数，每两个取一个：
>>> L[:10:2]
[0, 2, 4, 6, 8]

迭代 for循环来遍历这个list或tuple，这种遍历咱们称为迭代（Iteration）

for ch in 'ABC':
...     print(ch)
...
A
B
C
###字典 dict 迭代（dict迭代的是key。若是要迭代value，能够用for value in d.values()，若是要同时迭代key和value，能够用for k, v in d.items()）
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

Python内置的enumerate函数能够把一个list变成索引-元素对，这样就能够在for循环中同时迭代索引和元素自己：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

请使用迭代查找一个list中最小和最大值，并返回一个tuple：

def findMinAndMax(L):
    if L == []:
        return None,None
    # elif len(L) ==1:
    #     max = min = L[0]
    #     return min,max
    else:
        max =L[0]
        min =L[0]
        for i in L:     ### 注意这地方的循环嵌套 要在当前嵌套if里面 max和min的值才会生效
            if i > max:
             max = i
        # for i in L:
            if i < min:
                min =i
        return min,max
#####优解
def findMinAndMax(L):
    if not isinstance(L, list):
        raise TypeError('Invalid')
    L_num = [ x for x in L if type(x) is int]  
    if len(L_num) == 0:
        return (None, None)
    min = 0
    max = 0
    for i, value in enumerate(L_num):
        if i == 0:
            min = value
        if value < min:
            min = value
        if value > max:
            max = value
    return (min, max)

列表生成式
用一行语句代替循环生成上面的list

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
##写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环 判断条件 写到循环后面
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

生成器
受到内存限制，列表容量确定是有限，列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素，没必要建立完整的list，从而节省大量的空间。一边循环一边计算的机制，称为生成器。
建立一个generator，有不少种方法：
其中一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>
###generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

在好比斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数均可由前两个数相加获得：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'
##用生成器表达（要把fib函数变成generator，只须要把print(b)改成yield b就能够了）
##定义一个generator，依次返回数字1，3，5：
def odd():                      ## 这里没有参数变量须要传入，因此不用命名参数名，每次执行next()函数 生成值
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

练习杨辉三角定义以下：

1
     / \
    1   1
   / \ / \
  1   2   1
 / \ / \ / \
1   3   3   1

把每一行看作一个list，试写一个generator，不断输出下一行的list：

def triangles():
    L=[1]                               #定义数组并赋初始值
    whiel True:
        yield L                     #生成器每次输入上次计算的结果 因为yield 返回的缘由 会继续执行下去，并查询上一次的计算结果
        L1=L[1]                         #每次初始化计算器
        for n in range(1,len(L)):       #循环遍历上次计算结果
            L1.append(L[n-1]+L[n])      #将上次结果的相邻两数相加并赋值
        L1.append(1)                    #末尾加1
        L=L1                            #将计算结果赋值