迭代器：迭代的工具

#1 什么是迭代：指的是一个重复的过程，每一次重复称为一次迭代，并且每一次重复的结果是下一次重复的初始值

#2 为什么要有迭代器？
#对于序列类型：str，list，tuple，可以依赖索引来迭代取值，
#但是对于dict，set，文件,python必须为我们提供一种不依赖于索引的迭代取值的方式-》迭代器

#3 可迭代的对象(下列都是)：obj.iter

name='egon'l=[1,2,3]t=(1,2,3)d={'name':'egon','age':18,'sex':'male'}s={'a','b','c'}f=open('a.txt','w',encoding='utf-8')name.__iter__l.__iter__t.__iter__d.__iter__s.__iter__f.__iter__

#4 迭代器对象（文件是）：obj.iter,obj.next

f.__iter__f.__next__

#总结：
#1 可迭代对象不一定是迭代器对象
#2 迭代器对象一定是可迭代的对象
#3 调用obj.iter()方法,得到的是迭代器对象(对于迭代器对象，执行iter得到的仍然是它本身)

#for循环就是依赖的将可迭代对象转换为迭代器对象，然后进行迭代

#总结迭代器的优缺点：
#优点:
#1、提供一种统一的、不依赖于索引的取值方式，为for循环的实现提供了依据
#2、迭代器同一时间在内存中只有一个值——》更节省内存，

#缺点：
#1、只能往后取，并且是一次性的
#2、不能统计值的个数，即长度

l=[1,2,3,4,5,6]l[0]l[1]l[2]l[0]l_iter=l.__iter__()# print(l_iter)print(next(l_iter))print(next(l_iter))print(next(l_iter))

生成器

#1 什么是生成器：只要在函数体内出现yield关键字，那么再执行函数就不会执行函数代码，会得到一个结果，该结果就是生成器
#生成器就是迭代器

#yield的功能：
#1、yield为我们提供了一种自定义迭代器对象的方法
#2、yield与return的区别1：yield可以返回多次值 #2：函数暂停与再继续的状态是由yield帮我们保存的

#模拟tail -f access.log |grep 404

import timedef tail(file):    with open(file,'rb') as f:        f.seek(0,2)        while True:            line = f.readline()            if line:                yield line            else:                time.sleep(0.05)lines=tail('access.log')def grep(lines,pattern):    for line in lines:        line = line.decode('utf-8')        if pattern in line:            print(line)grep(tail('access.log'),'404')

#了解知识点：yield表达式形式的用法

def eater(name):    print('%s 开始吃饭' %name)    food_list=[]    while True:        food=yield food_list #food=yield='鸡丁'        food_list.append(food)        print('%s start to eat %s' %(name,food))e=eater('dzm')#需要先初始化next(e)#然后e.send:1 从暂停的位置将值传给yield  2、与next一样print(e.send('米饭'))print(e.send('鸡丁'))

三元表达式

def my_max(x,y):    if x > y:        return x    else:        return yres=my_max(10,20)print(res)

#示例一

x=10y=20res=x if x > y else yprint(res)

#示例二

name=input('>>: ').strip()res='sb' if name == 'alex' else 'nb'print(res)

列表推导式

#示例一

l=[]for i in range(1,11):    res='egg'+str(i)    l.append(res)print(l)l=['egg'+str(i) for i in range(1,11)]print(l)

#示例二

l1=['egg'+str(i) for i in range(1,11) if i >= 6]print(l1)l1=[]for i in range(1,11):    if i >= 6:        l1.append('egg'+str(i))

生成器表达式

#把列表推导式的[]换成()就是生成器表达式
#生成器比较节省内存

g=('egg'+str(i) for i in range(0,1000000000000000000000000000000000))print(g) #显示结果g是个生成器print(next(g))print(next(g))print(next(g))

#示例
with open('a.txt','r',encoding='utf-8') as f:
#求文件a.txt中最长的行的长度（长度按字符个数算，需要使用max函数）
print(max(len(line)for line in f))

#求文件a.txt中总共包含的字符个数
print(sum(len(line) for line in f))

递归

#递归调用：在调用一个函数的过程中，直接或者间接又调用该函数本身，称之为递归调用
#递归必备的两个阶段：1、递推  2、回溯
#python中的递归效率低，需要在进入下一次递归时保留当前的状态，在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，但是python又没有尾递归，且对递归层级做了限制

#举例，计算age（5）的数值

# age(5) = age(4) + 2# age(4) = age(3) + 2# age(3) = age(2) + 2# age(2) = age(1) + 2## age(1) = 18def func(n):    if n == 1:        return 18    else:        return func(n-1)+2res=func(5)print(res)

#总结递归的使用：
#1. 必须有一个明确的结束条件
#2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
#3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

二分法

#了解的知识点
l=[1,2,10,30,33,99,101,200,301,402] #从小到大排列的数字列表,找到301

def search(l,num):    print(l)    if len(l) == 0:        print('没有这个内容')        return    mid_index = len(l) // 2    if num > l[mid_index]:        search(l[mid_index+1:],num)    elif num < l[mid_index]:        search(l[0:mid_index],num)    else:        print(num)x=int(input('请输入数字: '))search(l,x)

匿名函数

def func(): #func=内存地址    print('from func')func()

#上面这是有名函数

#举例
#内存地址

def my_sum(x,y):    return x+y

#把上面有名函数变为匿名函数

#自带return返回值效果
print(lambda x,y:x+y)
#打印后得到一个内存地址

#给这个内存地址传参执行
print((lambda x,y:x+y)(1,2))
#得到3

#也可以：

func=lambda x,y:x+y#print(func)print(func(1,2))

#lambda匿名函数通常跟别的函数配合使用
#匿名意味着引用计数为0，使用一次就释放，除非让其有名字

内置函数（与匿名函数配合使用）

#max,min,sorted,map,reduce,filter
#上面的函数都遵循迭代器对象
#next一次取一次值

#字典的运算：最小值，最大值，排序

salaries={    'egon':3000,    'alex':100000000,    'wupeiqi':10000,    'yuanhao':2000}

#zip 拉链

s='hello'l=[1,2,3]g=zip(s,l)

#g是一个内存地址
#zip的结果是一个迭代器

print(list(g))#结果[('h', 1), ('e', 2), ('l', 3)]

#使用列表形式表现出来，从结果可以看出一一对应的保存在一个小元祖中

#max函数
#举例，求上面字典中工资最高的人名

#方法1，可以和上面的zip函数配合
g=zip(salaries.values(),salaries.keys())
#这样就可以按照薪资value比较，字典默认按照keys比较
print(max(g))
#结果
(100000000, 'alex')

#方法2，与匿名函数配合
print(max(salaries,key=lambda x:salaries[x]))
#结果：
alex
#'key='表示指定max函数比较的依据
#'k'是前面每次循环salaries后得到的字典的key，salaries[k]的结果返回给前面的key
#也就是说这里使用字典中的value进行比较，但显示的还是比较后结果所对应的字典中的key

#min函数
#用法跟max相同
print(min(salaries,key=lambda k:salaries[k]))

#sorted 排序
#与max用法相同
print(sorted(salaries,key=lambda k:salaries[k]))
#还可以加个reverse=True将结果反转
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

#map,reduce,filter
#map 映射

#举例说明：
#将列表中的字符串后面都加上_SB

names=['alex','wupeiqi','yuanhao']l=[]for name in names:    res='s%_SB' %name    l.append(res)print(l)

#使用map函数实现

g=map(lambda name:'%s_SB' %name,names)print(list(g))

#结果：
['alex_SB', 'wupeiqi_SB', 'yuanhao_SB']

#filter 过滤

names=['alex_SB', 'wupeiqi_SB', 'yuanhao_SB','egon']g=filter(lambda x:x.endswith('SB'),names)print(list(g))

#结果:
['alex_SB', 'wupeiqi_SB', 'yuanhao_SB']

#reduce 合并

from functools import reduceprint(reduce(lambda x,y:x+y,range(1,101)))

#结果

5050print(reduce(lambda x,y:x+y,range(1,101),100))

#结果
5150
#最后的100是初始值，原本初始值是1，现在改为100

内置函数

#需要掌握

#divmod 得到商和余

print(divmod(10001,25))(400, 1)

#只要余不为0就需要加1

#enumerate
#对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
#enumerate多用于在for循环中得到计数

l=['a','b','c']for i,v in enumerate(l):    print(i,v)

#结果：

0 a1 b2 c

#enumerate还可以接收第二个参数，用于指定索引起始值，如：

list1 = ["这", "是", "一个", "测试"]for index, item in enumerate(list1, 1):    print(index, item)

#结果：
1 这
2 是
3 一个
4 测试

#补充
#如果要统计文件的行数，可以这样写：
#利用enumerate()：

count = 0for index, line in enumerate(open(filepath,'r')):    count += 1

#eval
#将字符串str当成有效的表达式来求值并返回计算结果
#将字符串转成相应的对象，转换成列表，转换成字典，转换成元组等

res=eval('[1,2,3]')print(res,type(res))

#结果：
[1, 2, 3] <class 'list'>

#pow

res=pow(2,3,3) #2的三次方的结果对3取余print(res)

#结果：
2

#round 四舍五入

print(round(3.5))4

#slice 切片
#制造一个切片格式

l=['a','b','c','d','e','f']s=slice(1,5,2)print(l[s])

#结果：
['b', 'd']