#Python的迭代跟java不同 java的迭代必须要有下标才可以迭代
#但是Python只有是可迭代对象无论有没有下标，都可以迭代
#比如list,tuple,dict,set,甚至字符串都可以
#比如dict
dict_f = {'aa':12,'bb':13,'cc':14}#dict字典
list_f = [213,3213,3213,32432,432542]#list
#key迭代
for key in dict_f:#因为dict是无需的 所以每次迭代的结果可能不一样
print(key)
打印：
bb
cc
aa
#value迭代
for value in dict_f.values():
print(value)
打印：
13
14
12
#同时迭代key和value
for k,v in dict_f.items():
print(k,v)
打印：
bb 13
cc 14
aa 12
#字符串的迭代
s = 'abcdef'
for s_v in s:
print(s_v)
打印：
a
b
c
d
e
f
#判断一个对象是否是可迭代对象通过 collections 模块的 Iterable 类型判断
from collections import Iterable
#通过 collections 模块的 Iterable 类型判断
if(isinstance(dict_f,Iterable)):#dict可迭代
for k, v in dict_f.items():
print(k, v)
if(isinstance(gg,Iterable)):#整数不可迭代
for fv in gg:
print(fv)
if(isinstance(list_f,Iterable)):#list可迭代
for fv in list_f:
print(fv)
if(isinstance(s,Iterable)):#字符串可迭代
for fv in s:
print(fv)
#Python实现类似于java那样的下标循环
#Python 内置的 enumerate 函数可以把一个 list 变成索引-元素对，这样就
#可以在 for 循环中同时迭代索引和元素本身
for i,value in enumerate(list_f):
print(i,value)
打印：
0 213
1 3213
2 3213
3 32432
4 432542
#同时引用两个变量
for x,y in [(1231,3213),(3213,3243),(3214,345)]:
print(x,y)
打印：
1231 3213
3213 3243
3214 345
#列表生成式
#列表生成式即 List Comprehensions，是 Python 内置的非常简单却强大的可以用来创建 list 的生成式
#写列表生成式时，把要生成的元素 x*x放到前面,后面跟 for 循环，就可以把list创建出来
L = [x*x for x in range(10)]
print(L)
#for 循环后面还可以加上 if 判断
L2 = [x*x for x in range(10) if x%2==0]
print(L2)
打印：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 4, 16, 36, 64]
#双层循环 实现全排列
L3 = [m+n for m in 'ABC' for n in 'XYZ']
print(L3)
#把一个list中的字符串大写变小写
L4 = ['Hello',16, 'World', 'IBM', 'Apple']
L5 = [s.lower() for s in L4 if isinstance(s,str)]
print(L5)
L6 = [s.lower() if isinstance(s,str)else s for s in L4]#三目运算符
print(L6)
打印：
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
['hello', 'world', 'ibm', 'apple']
['hello', 16, 'world', 'ibm', 'apple']
上边用了一个东西叫做三目运算符
#python三目运算符
a=3
b=4
c=5
print(a if(a>b) else b)
d = (a if (a>b) else b)
print(d if(d>c) else c)
生成器
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。
而且，创建一个包含 100 万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要
访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中
不断推算出后续的元素呢？这样就不必创建完整的 list，从而节省大量的空间。
在 Python 中，这种一边循环一边计算的机制，称为生成器：generator
要创建一个 generator，有很多种方法。第一种方法很简单，只要把一个
列表生成式的 [] 改成 () ，就创建了一个 generator
g = (x*x for x in range(10))
print(g)
#因为generator是一个可迭代对象，所以可以用for循环来遍历迭代 不用使用next(g)来获取每一个值
for n in g:
print(n)
打印：
<generator object <genexpr> at 0x000001EE56ED6FC0>
0
1
4
9
16
25
36
49
64
81
数学中有一个斐波那契压数列
1 1 2 3 5 8 13 21 34 55 从第三个数开始，每个数都等于前两个数字相加之和，这个数列直接写不好写，通过函数可以很方便的写出来
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return 'done'
print('----------------------------')
fib(10)
print('----------------------------')
打印：
----------------------------
1
1
2
3
5
8
13
21
34
55
----------------------------
fib 函数实际上是定义了斐波拉契数列的推算规
则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非
常类似 generator
也就是说，上面的函数和 generator 仅一步之遥。要把 fib 函数变成
generator，只需要把 print(b) 改为 yield b 就可以了
def fib2(max):
#try:
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
#except StopIteration as e:
# print(e.value)
f = fib2(10)
print(f)
for bb in f:
print(bb)
打印结果：
<generator object fib2 at 0x00000292A8166E08>
1
1
2
3
5
8
13
21
34
55
#如果一个函数定义中包含 yield 关键字，那么这个函数就不再是一个普通函数，而是一个 generator
#但是用 for 循环调用 generator 时，发现拿不到 generator 的 return 语句
#的返回值。如果想要拿到返回值，必须捕获 StopIteration 错误，返回值
#包含在 StopIteration 的 value 中
#generator 函数的“调用”实际返回一个 generator 对象：
#generator 和函数的执行流程不一样。函数是顺
#序执行，遇到 return 语句或者最后一行函数语句就返回。而变成
#generator 的函数，在每次调用 next() 的时候执行，遇到 yield 语句返回，
#再次执行时从上次返回的 yield 语句处继续执行
while True:
try:
hn = next(f)
print('f:',hn)
except StopIteration as e:
print("打印完了")
print('Generator return value:',e.value)
break
for bb in f:
print(bb)
生成器都是 Iterator 对象，但 list 、 dict 、 str 虽然是 Iterable ，却不是
Iterator
把 list 、 dict 、 str 等 Iterable 变成 Iterator 可以使用 iter() 函数：
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
你可能会问，为什么 list 、 dict 、 str 等数据类型不是 Iterator ？
这是因为 Python 的 Iterator 对象表示的是一个数据流，Iterator 对象可
以被 next() 函数调用并不断返回下一个数据，直到没有数据时抛出
StopIteration 错误。可以把这个数据流看做是一个有序序列，但我们却
不能提前知道序列的长度，只能不断通过 next() 函数实现按需计算下一
个数据，所以 Iterator 的计算是惰性的，只有在需要返回下一个数据时
它才会计算。
Iterator 甚至可以表示一个无限大的数据流，例如全体自然数。而使用
list 是永远不可能存储全体自然数的。
小结：
凡是可作用于 for 循环的对象都是 Iterable 类型；
凡是可作用于 next() 函数的对象都是 Iterator 类型，它们表示一个惰性
计算的序列；
集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator ，不过可
以通过 iter() 函数获得一个 Iterator 对象。
Python 的 for 循环本质上就是通过不断调用 next() 函数实现的，例如：
for x in [1, 2, 3, 4, 5]:
pass
实际上完全等价于：
#首先获得 Iterator 对象:
it = iter([1, 2, 3, 4, 5])
#循环:
while True:
try:
#获得下一个值:
x = next(it)
except StopIteration:
#遇到 StopIteration 就退出循环
break