这里主要讲切片、迭代、列表生成式、生成器和迭代器用法，见识一下Python的简洁，1行代码就能搞定其他语言5行代码才能实现的功能。
切片
Python 中有两种方式获取 list 或 tuple 的部分元素，一种是通过inde索引获取，一种是利用循环。
上面两种方式很常见，但是取指定索引范围内的元素以及循环很繁琐。 Python 提供了更为强大切片（Slice）操作符，能简化这种列表操作。
L = ['Michale', 'Coralline', 'Cindy', 'Jane']
# 1. 切片优化
print('L[0:3] =', L[0:3]) # 从索引0开始取，直到索引3为止，但不包括索引3
# 若第一个索引是0，可省略
print('L[:3] =', L[:3])
# 2. 取倒数第一个元素
print('L[-1] =', L[-1]) # L[-1] = Jane
print('L[-2:] =', L[-2:]) # L[-1] = ['Cindy', 'Jane']
# 3. 倒数切片
print('L[-2:-1] =', L[-2:-1]) # 取倒数第二个: L[-2:-1] = ['Cindy']
# 4. 切片的作用体现
# 创建0-99的数列
L = list(range(100))
print('列表前10个数：', L[:10]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print('列表后10个数：', L[-10:]) # [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
print('列表前11-20个数：', L[10:20])
print('列表前10个数中，每两个取一个：', L[:10:2]) # [0, 2, 4, 6, 8]
print('列表所有数，每五个取一个：', L[::5])
print('复制一个列表：', L[:])
# tuple 不可变的切换操作
print('tuple前3个数：', (0, 1, 2, 3, 4, 5)[:3]) # tuple前3个数： (0, 1, 2)
# 字符串 ‘xxx’ 也可看做一种list，每个元素是一个字符，切片操作后仍是字符串
print('字串前三个字符：', 'ABCDEFG'[:3]) # 'ABC'
print('每两个取一个字符：', 'ABCDEFG'[::2]) # 'ACEG'
切片对于操作字符串来说很有用，可以取字串、反转字符串等，以下用两种方式展示如何使用切片进行字符串反转：
def reverse(s):
return s[::-1]
def reverse2(s):
if s == '':
return s
else:
return reverse2(s[1:]) + s[0]
print(reverse('Hello, World')) # dlroW ,olleH
print(reverse2('Hello')) # 递归：olleH
列表生成式
定义：即 List Comprehensions，Python内置的超强大简单的可用于创建 list的生成式。
以下面的示例代码来认识下如何使用列表生成器：
# 1. 普通创建列表方式
L0 = [1, 2, 3, 4, 5]
L1 = list(range(1, 6))
print('L1 =', L1) # L1 = [1, 2, 3, 4, 5]
# 2. 生成1-10的平方数组成的数组。
# 一般写法：
L = []
for x in range(1, 11):
L.append(x * x)
print('普通创建列表方法：', L)
print('列表生成式创建列表：', [x * x for x in range(1, 11)])
print('列表生成式+条件筛选创建偶数平方数组：', [x * x for x in range(1, 11) if x % 2 == 0])
# ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
print('列表生成式生成全排列：', [m + n for m in 'ABC' for n in 'XYZ'])
# 3. 列出当前目录下的所有文件和目录
import os
print('', [d for d in os.listdir('.')])
# 4. 列表生成时使用两个变量生成list
d = {'x': 'A', 'y': 'B', 'z': 'C'}
print('', [k + '=' + v for k, v in d.items()]) # ['x=A', 'y=B', 'z=C']
# 5. 把一个list中所有字符串变成小写
print('', [s.lower() for s in ['Hello', 'World', 'Apple']]) # ['hello', 'world', 'apple']
# 6. 列表中存储混合元素，但是整数没有小写方法需要先剔除
L = ['Hello', 'World', 18, 'Apple', None]
print('混合: ', [s.lower() for s in L if isinstance(s, str)])
# 混合 ['hello', 'world', 'apple']
生成器
在 Python 中，一边循环一边计算的机制，成为生成器。（不用创建完整list 从而节省大量空间）
创建生成器有两种方式：
- 把一个列表生成式的 [] 改成 ()，就创建了一个 generator ；
- 若一个函数中包含 yield 关键字，那么这个函数就不再是 一个普通函数，而是一个 generator。
列表生成式 和 生成器的唯一区别是最外层的 [] 和 () ，L 是一个 list，g 是一个 generator。如下代码所示：
# 列表生成器
L = [x * x for x in range(10)]
# 生成器
G = (x * x for x in range(10))
如何使用生成器呢？也用一段代码展示：
# 生成器
G = (x * x for x in range(10))
print('Generator =', G)
# 如何打印 generator 的每一个元素呢？
print('use next() to print: ', next(G)) # 0
print('use next() to print: ', next(G)) # 1
print('use next() to print: ', next(G)) # 4
print('use next() to print: ', next(G)) # 9
print('use next() to print: ', next(G)) # 16
# 上述是通过每次调用 next(g) 计算出 g 的下一个元素的值，知道计算最后一个元素，没有更多元素时，抛错。
# 正确写法可以使用 for 循环，因为 generator 也是可迭代对象，所以需少使用 next() 方法。
for n in G:
print(n)
# 当推算算法比较复杂时，用类似列表生成式的 for 循环无法实现时，使用函数实现 Generator。
# 如，斐波拉契数列，用列表生成式无法实现，用函数实现如下：
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
# t = (b, a + b)
# a = t[0]
# b = t[1]
n = n + 1
return 'done'
print(fib(6))
# 总结： fib 函数实际上定义了斐波拉契数列的推算规则，从第一个元素开始，推算出后续任意的元素，逻辑上很像 generator.
def fib0(max):
n, a, b = 0, 0, 1
while n < max:
yield b # generator 遍历时，每次遇到 yield就返回，再次执行时从上次返回的 yield语句处执行。
a, b = b, a + b
# t = (b, a + b)
# a = t[0]
# b = t[1]
n = n + 1
return 'done'
print(fib(6))
# 注： yield 说明
# 1）若一个函数定义中包含 yield 关键字，则该函数就不再是一个普通函数，而是一个 generator；
# 2）generator 和 函数执行流程不一，函数时顺序执行，遇到return就返回，
# 而变成 generator 的函数，每次调用 next() 时执行，遇到 yield 语句就中断返回，
# 再次执行时从上次返回的 yield 语句处继续执行；
# 3）一般不用 next() 一个个取值，而是使用 for 循环遍历。
def yield_test():
print('step 1')
yield 1
print('step 2')
yield 2
print('step 3')
yield 3
it = yield_test()
print(next(it)) # step 1 1
print(next(it)) # step 2 2
print(next(it)) # step 3 3
# print(next(it)) # 抛出异常
看了上述代码觉得 genarator 和 函数很像，那么生成器与函数有什么区别呢？
- 函数时顺序执行，遇到 return 语句或最后一行函数语句就返回；
- 变成 generator 的函数，每次调用 next(g) 时执行算法，遇到 yield 语句就返回，再次执行时就从上次返回的 yield 语句继续执行。
迭代
for 循环便是迭代。Python 的 for 循环不仅可用于 list 或 tuple，还可以作用在其他可迭代对象上。只要是可迭代对象，无论有无下标，均可以迭代，如 dict。
关键字：可迭代对象 Iterable .
以一张简图展示：
迭代器
前面说到 可迭代对象 Iterable，能制作作用于 for 循环的数据类型，这种数据类型分为两类：
- 集合数据类型，如 list, tuple, dict, set, str 等；
- generator，包括生成器和带 yield 的 generator function。
问题：Iterable 可迭代对象和迭代器有什么关联呢？看一下迭代器的相关说明。
定义: 可以被 next() 函数调用并不断返回下一个值的对象称为迭代器，用 Iterator 表示迭代器。
特点：Python 的 Iterator 对象表示的是一个数据流，该对象可被 next() 函数调用并不断返回下一个数据，直到没有抛出 StopIteration 错误。
这里暂不举例说明，直接总结迭代器和可迭代对象关联点：
1）生成器都是 Iterator 对象，但 list dict str 是Iterable，却不是 Iterator；
2）将 list dict str 等 Iterable 变成 Iterator ，可以使用 iter() 函数；如：isinstance(iter([]), Iterator) = True .
3）为什么 list, dict, str 等数据类型不是 Iterator 呢？—— Iterator 的计算是惰性的，只有在需要返回下一个数据时才会计算；
4）Iterator 可以表示一个无限大的数据流，如全体自然数。而 list 永远不肯存储全体自然数；
5）凡是可作用于 for 循环的对象都是 Iterable 类型；凡是可作用于 next() 函数的都是 Iterator 类型，表示一个惰性计算序列。
To myself
Python 的高级特性，对于生成器这块，听说用得很多，但比较难理解，目前暂时总结到这个程度，后续深入学习再补上。