|
Python全栈开发【基础四】 |
本节内容：
- 匿名函数（lambda）
- 函数式编程（map,filter,reduce）
- 文件处理
- 迭代器
- 三元表达式
- 列表解析与生成器表达式
- 生成器
| 匿名函数 |
lambda表达式：对于简单的函数，存在一种简便的表示方式，即lambda表达式
#这段代码 def calc(n): return n**n print(calc(10)) #换成匿名函数 calc = lambda n:n**n print(calc(10))
匿名函数主要是和其它函数搭配使用
举例：
#########次方函数举例############ res = map(lambda x:x**2,[1,5,7,4,8]) for i in res: print(i) 输出 1 25 49 16 64
| 高阶函数、函数式编程 |
高阶函数：
满足俩个特性任意一个即为高阶函数
1.函数的传入参数是一个函数名
2.函数的返回值是一个函数名
一、map函数
###############map函数################ array=[1,3,4,71,2] ret=[] for i in array: ret.append(i**2) print(ret) #如果我们有一万个列表,那么你只能把上面的逻辑定义成函数 def map_test(array): ret=[] for i in array: ret.append(i**2) return ret print(map_test(array)) #如果我们的需求变了,不是把列表中每个元素都平方,还有加1,减一,那么可以这样 def add_num(x): return x+1 def map_test(func,array): ret=[] for i in array: ret.append(func(i)) return ret print(map_test(add_num,array)) #可以使用匿名函数 print(map_test(lambda x:x-1,array)) #上面就是map函数的功能,map得到的结果是可迭代对象 print(map(lambda x:x-1,range(5)))
二、filter函数
真假值判断，如果为真就留下，为假则舍弃
1 filter(lambda x:x>22, [55,11,22,33,])
print(list(filter(lambda x:x>22, [55,11,22,33,])))
结果：[55, 33]
三、reduce函数
对可迭代对象中的指合并操作
from functools import reduce #合并,得一个合并的结果 array_test=[1,2,3,4,5,6,7] array=range(100) #报错啊,res没有指定初始值 def reduce_test(func,array): l=list(array) for i in l: res=func(res,i) return res # print(reduce_test(lambda x,y:x+y,array)) #可以从列表左边弹出第一个值 def reduce_test(func,array): l=list(array) res=l.pop(0) for i in l: res=func(res,i) return res print(reduce_test(lambda x,y:x+y,array)) #我们应该支持用户自己传入初始值 def reduce_test(func,array,init=None): l=list(array) if init is None: res=l.pop(0) else: res=init for i in l: res=func(res,i) return res print(reduce_test(lambda x,y:x+y,array)) print(reduce_test(lambda x,y:x+y,array,50))
| 文件处理 |
open函数，该函数用于文件处理
文件句柄 = open(‘文件路径’，’模式’)
打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。
打开文件的模式有：
- r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
- w，只写模式【不可读；不存在则创建；存在则清空内容】
- x， 只写模式【不可读；不存在则创建，存在则报错】
- a， 追加模式【可读； 不存在则创建；存在则只追加内容】
“+” 表示可以同时读写某个文件
- r+， 读写【可读，可写】
- w+，写读【可读，可写】
- x+ ，写读【可读，可写】
- a+， 写读【可读，可写】
“b”表示以字节的方式操作
- rb 或 r+b
- wb 或 w+b
- xb 或 w+b
- ab 或 a+b
-
f = open ("1.txt","rb") data = f.read() print(data) print(data.decode("utf8")) f = open ("1.txt","wb") f.write('ocean\n'.encode('utf8')) f = open ("1.txt","ab") f.write('ocean\n'.encode('utf8'))
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码
####### r 读 ####### f = open('test.log','r',encoding='utf-8') a = f.read() print(a) ###### w 写(会先清空！！！) ###### f = open('test.log','w',encoding='utf-8') a = f.write('ocean') print(a) #返回字符 ####### a 追加（指针会先移动到最后） ######## f = open('test.log','a',encoding='utf-8') a = f.write('good\nboy') print(a) #返回字符 ####### 读写 r+ ######## f = open('test.log','r+',encoding='utf-8') a = f.read() print(a) f.write('ocean') ##### 写读 w+（会先清空！！！） ###### f = open('test.log','w+',encoding='utf-8') a = f.read() print(a) f.write('ocean') ######## 写读 a+（指针先移到最后） ######### f = open('test.log','a+',encoding='utf-8') f.seek(0) #指针位置调为0 a = f.read() print(a) b = f.write('ocean') print(b) ####### rb ######### #字节只读方式 f = open('test.log','rb') a = f.read() print(str(a,encoding='utf-8')) # ######## ab ######### f = open('test.log','ab') f.write(bytes('老男人\n',encoding='utf-8')) f.write(b'oldman') #结果： #老男人 #oldman ##### 关闭文件 ###### f.close() ##### 内存刷到硬盘 ##### f.flush() ##### 获取指针位置 ##### f.tell() ##### 指定文件中指针位置 ##### f.seek(0) ###### 读取全部内容(如果设置了size，就读取size字节) ###### f.read() f.read(9) ###### 读取一行 ##### f.readline() ##### 读到的每一行内容作为列表的一个元素 ##### f.readlines()
注意：read(3)代表读取3个字符，其余的文件内光标移动都是以字节为单位如seek，tell，read，truncate
| 迭代器 |
一、什么是迭代器协议？
1.迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）
2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）
3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。
二、for循环本质：循环所有对象，全都是使用迭代器协议。
(字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环式，调用了他们内部的__iter__方法，把他们变成了可迭代对象
然后for循环调用可迭代对象的__next__方法去取值，而且for循环会捕捉StopIteration异常，以终止迭代。
l=['a','b','c'] #一:下标访问方式 print(l[0]) print(l[1]) print(l[2]) # print(l[3])#超出边界报错:IndexError #二:遵循迭代器协议访问方式 diedai_l=l.__iter__() print(diedai_l.__next__()) print(diedai_l.__next__()) print(diedai_l.__next__()) # print(diedai_l.__next__())#超出边界报错:StopIteration #三:for循环访问方式 #for循环l本质就是遵循迭代器协议的访问方式,先调用diedai_l=l.__iter__()方法,或者直接diedai_l=iter(l),然后依次执行diedai_l.next(),直到for循环捕捉到StopIteration终止循环 #for循环所有对象的本质都是一样的原理 for i in l:#diedai_l=l.__iter__() print(i) #i=diedai_l.next() #四:用while去模拟for循环做的事情 diedai_l=l.__iter__() while True: try: print(diedai_l.__next__()) except StopIteration: print('迭代完毕了,循环终止了') break
| 三元表达式 |
三元运算又称三元运算（三目运算），是对简单的条件语句的缩写。
#result = 值1 if 条件 else 值2 # 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量 #三元表达式 name='marry' name='jack' res='woman' if name == 'marry' else 'man' print(res)
| 列表解析与生成器表达式 |
egg_list=['鸡蛋%s' %i for i in range(10)] #列表解析 #列表解析直接生成列表，占用内存空间，用生成器表达式可避免浪费内存 laomuji=('鸡蛋%s' %i for i in range(10))#生成器表达式 print(laomuji) print(next(laomuji)) #next本质就是调用__next__ print(laomuji.__next__()) print(next(laomuji))
总结：
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：
sum(x ** 2 for x in xrange(4))
而不用多此一举的先构造一个列表：
sum([x ** 2 for x in xrange(4)])
| 生成器 |
一、什么是生成器？
可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象
二、生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）
1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表
三、为何使用生成器之生成器的优点
Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。
四、生成器小结：
1.是可迭代对象
2.实现了延迟计算,省内存
3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象没有这点好处。
def lay_eggs(num): egg_list=[] for egg in range(num): egg_list.append('蛋%s' %egg) return egg_list yikuangdan=lay_eggs(10) #我们拿到的是蛋 print(yikuangdan) def lay_eggs(num): for egg in range(num): res='蛋%s' %egg yield res print('下完一个蛋') laomuji=lay_eggs(10)#我们拿到的是一只母鸡 print(laomuji) print(laomuji.__next__()) print(laomuji.__next__()) print(laomuji.__next__()) egg_l=list(laomuji) print(egg_l) #演示只能往后不能往前 #演示蛋下完了，母鸡就死了
