一、迭代器

迭代器：迭代的工具。

迭代也可以说是重复，每一次的结果都是基于上一次的结果来的。

• 可迭代对象：

height=180
salary=3.2
name='nick'
hobby_list=['run','read']
bobby_tup=('run','read')
info_dict={'name':'nick','weight':140}
hobby_set={'read','run',}
文件f

总结：

1. 只要拥有_ _ iter_ _方法的对象就是可迭代对象

2. python内置字符串/列表/元祖/字典/集合/文件 都是可迭代对象

• 迭代器对象

height.__iter__
salary.__iter__
func.__iter__
name.__iter__()
hobby_list.__iter__()
hobby_set.__iter__()
hobby_tup.__iter__()
info_dict.__iter__()
f.__iter__()

总结：

迭代器对象:执行可迭代对象的__iter__方法,拿到的返回值就是迭代器对象。

1. 内置有__next__方法
2. 文件本身就是迭代器对象

可迭代对象: 拥有iter方法的对象就是可迭代对象,推导:可迭代对象不一定是迭代器对象
迭代器对象: 拥有iter方法和next方法的就是迭代器对象,推导: 迭代器对象一定是可迭代对象,又是迭代器对象

• for循环原理

  for循环称为迭代器循环，in后必须是可迭代的对象。

二、三元表达式（三目表达式）

条件成立时的返回值if条件else条件不成立时的返回值。

dog_name='xiaogou'
if dog_name=='fenggou'print('远离他')
else:print('盘')
------------------------>>
print('远离他') if dog_name=='fenggou'else  print('盘他'）

• 不推荐使用，写程序的易懂，变得简单

三、列表推导式

lis=[]
for i in range(100):lis.append(i)
print(lis)
lis = [i*2 for i in range(100)]
print(lis)
lis1 = [i * 2 if i > 50 else i for i in range(100)]
print(lis1)

四、字典生成式

dic=dict.fromkeys([1,2,3,4],2)
print(dic)
#  {1: 2, 2: 2, 3: 2, 4: 2}
dic={i:i**2 for i in range(10)}
for i in dic.items():print(i)
##(0, 0)(1, 1)(2, 4)(3, 9)(4, 16)(5, 25)(6, 36)(7, 49)(8, 64)(9, 81)

拉链函数 zip()方法，通过解压缩函数生成一个字典。

res=zip('abcd',[1,2,3,4])
dic=dict()
for k,v in resdic[k]=v
print(dic)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
print({k:v for k,v in zip('abcd',[1,2,3,4])})
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

五、生成器：自定义的迭代器

生成器提供了非常方便的自定义迭代器的途径。

• yield关键字：接收值，但不会结束函数，而是继续运行下一个代码

def func():pass

def func():print('from 1')yieldprint('from 2')yield
#func调用之后变成一个迭代器，yield默认返回none
g=func()
print(g.__next__())
print(g.__next__())
g.__next__()
for i in g:print(i)

def func():print('from 1')yield 1,2print('from 2')yield['a',1,2],2
g=func()
for k,v in g:print(k,v)-------------->from 11 2from 2['a', 1, 2] 2
#yield：接收值，但是不会结束函数，然后继续下一行代码，直到return
#return：返回值，直到结束函数，其他的特性和yield一摸一呀

range(1,10)
print([i for i in range(10)])
---------->
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(range(10).__iter__().next__())
---------->
0

def range(end,start=0,step=1):end,start=start,endcount=startwhile count<end:yield countcount+=step
g=range(1,10)
def range(*args,**kwargs)start=0step=1if len(args)==1:end=args[0]#arg=(10,)elif len(args)==2:#arg=(1,10)start=arg[0]end=args[1]elif len(args)==3:start=args[0]end=args[1]step=args[2]else:raise('传多值了')count=startwhile count<endyield countcount+=step
print(list(range(2,10,3)))
------------>
[2,5,8]

tup=(i for i in range(10))
print(tup.__next__())
for i in tupprint(i)
lis=[i for i in range(10)]
print(lis)

总结：

yield:

1. 提供一种自定义迭代器的方式
2. yield可以暂停住函数，并提供当前的返回值

yield和return:

1. 相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制

2. 不同点：return只能返回一次之；yield可以返回多次值

• 生成器表达式
  1. 把列表推倒式的[]换成()就是生成器表达式
  2. 优点：省内存，一次只产生一个值在内存中

六、递归

def f2()；print（'from f2')

==递归：函数调用函数自己，类似于循环，但是这个循环必须得有结束条件==

• 直接调用：直接在函数内部调用函数自身
• 间接调用：不在原函数体内调用函数，而是通过其他的方法间接调用函数自身

def guess_age(age,count)age-=2count-=1if count==1print(age)returnguess_age(age,count)guess_age(38,5)
def guess-age(count):count-=1if count==1:print(age)return 26return guess_age(count)+2
res=guess_age(5)
print(res)

r()

递归必须要有两个明确的阶段：

1. 递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小
2. 回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯。

递归的精髓在于通过不断地重复逼近一个最终的结果。