匿名函数
lambda表达式：对于简单的函数，存在一种简便的表示方式，即lambda表达式
1 #这段代码
2 defcalc(n):3 return n**n4 print(calc(10))5
6 #换成匿名函数
7 calc = lambda n:n**n8 print(calc(10))
匿名函数主要是和其它函数搭配使用
举例：
1 #########次方函数举例############
2 res = map(lambda x:x**2,[1,5,7,4,8])3 for i inres:4 print(i)5
6 输出7 1
8 25
9 49
10 16
11 64
高阶函数、函数式编程
高阶函数：
满足俩个特性任意一个即为高阶函数
1.函数的传入参数是一个函数名
2.函数的返回值是一个函数名
一、map函数
1 ###############map函数################
2 array=[1,3,4,71,2]3
4 ret=[]5 for i inarray:6 ret.append(i**2)7 print(ret)8
9 #如果我们有一万个列表,那么你只能把上面的逻辑定义成函数
10 defmap_test(array):11 ret=[]12 for i inarray:13 ret.append(i**2)14 returnret15
16 print(map_test(array))17
18 #如果我们的需求变了,不是把列表中每个元素都平方,还有加1,减一,那么可以这样
19 defadd_num(x):20 return x+1
21 defmap_test(func,array):22 ret=[]23 for i inarray:24 ret.append(func(i))25 returnret26
27 print(map_test(add_num,array))28 #可以使用匿名函数
29 print(map_test(lambda x:x-1,array))30
31
32 #上面就是map函数的功能,map得到的结果是可迭代对象
33 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函数
对可迭代对象中的指合并操作
reduce()函数也是Python内置的一个高阶函数。
reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。
例如，编写一个f函数，接收x和y，返回x和y的和：
deff(x, y):return x + y
调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：
先计算头两个元素：f(1, 3)，结果为4；
再把结果和第3个元素计算：f(4, 5)，结果为9；
再把结果和第4个元素计算：f(9, 7)，结果为16；
再把结果和第5个元素计算：f(16, 9)，结果为25；
由于没有更多的元素了，计算结束，返回结果25。
上述计算实际上是对 list 的所有元素求和。虽然Python内置了求和函数sum()，但是，利用reduce()求和也很简单。
reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：
reduce(f, [1, 3, 5, 7, 9], 100)
结果将变为125，因为第一轮计算是：
计算初始值和第一个元素：f(100, 1)，结果为101。
1 from functools importreduce2 #合并,得一个合并的结果
3 array_test=[1,2,3,4,5,6,7]4 array=range(100)5
6 #报错啊,res没有指定初始值
7 defreduce_test(func,array):8 l=list(array)9 for i inl:10 res=func(res,i)11 returnres12
13 #print(reduce_test(lambda x,y:x+y,array))
14
15 #可以从列表左边弹出第一个值
16 defreduce_test(func,array):17 l=list(array)18 res=l.pop(0)19 for i inl:20 res=func(res,i)21 returnres22
23 print(reduce_test(lambda x,y:x+y,array))24
25 #我们应该支持用户自己传入初始值
26 def reduce_test(func,array,init=None):27 l=list(array)28 if init isNone:29 res=l.pop(0)30 else:31 res=init32 for i inl:33 res=func(res,i)34 returnres35
36 print(reduce_test(lambda x,y:x+y,array))37 print(reduce_test(lambda x,y:x+y,array,50))
文件处理
open函数，该函数用于文件处理
文件句柄 = open('文件路径'，'模式')
1 ####### r 读 #######
2
3 f = open('test.log','r',encoding='utf-8')4
5 a =f.read()6
7 print(a)8
9
10
11 ###### w 写(会先清空！！！) ######
12
13 f = open('test.log','w',encoding='utf-8')14
15 a = f.write('ocean')16
17 print(a) #返回字符
18
19
20
21 ####### a 追加(指针会先移动到最后) ########
22
23 f = open('test.log','a',encoding='utf-8')24
25 a = f.write('good\nboy')26
27 print(a) #返回字符
28
29
30
31 ####### 读写 r+ ########
32
33 f = open('test.log','r+',encoding='utf-8')34
35 a =f.read()36
37 print(a)38
39 f.write('ocean')40
41
42
43 ##### 写读 w+(会先清空！！！) ######
44
45 f = open('test.log','w+',encoding='utf-8')46
47 a =f.read()48
49 print(a)50
51 f.write('ocean')52
53
54
55 ######## 写读 a+(指针先移到最后) #########
56
57 f = open('test.log','a+',encoding='utf-8')58
59 f.seek(0) #指针位置调为0
60
61 a =f.read()62
63 print(a)64
65 b = f.write('ocean')66
67 print(b)68
69
70
71 ####### rb #########
72 #字节只读方式
73 f = open('test.log','rb')74
75 a =f.read()76
77 print(str(a,encoding='utf-8'))78
79
80
81 ######### ab #########
82
83 f = open('test.log','ab')84
85 f.write(bytes('老男人\n',encoding='utf-8'))86
87 f.write(b'oldman')88
89 #结果：
90 #老男人
91 #oldman
92
93
94 ##### 关闭文件 ######
95
96 f.close()97
98
99
100 ##### 内存刷到硬盘 #####
101
102 f.flush()103
104
105
106 ##### 获取指针位置 #####
107
108 f.tell()109
110
111
112 ##### 指定文件中指针位置 #####
113
114 f.seek(0)115
116
117 ###### 读取全部内容(如果设置了size，就读取size字节) ######
118
119 f.read()120
121 f.read(9)122
123
124
125 ###### 读取一行 #####
126
127 f.readline()128
129
130
131 ##### 读到的每一行内容作为列表的一个元素 #####
132
133 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异常，以终止迭代。
1 l=['a','b','c']2 #一:下标访问方式
3 print(l[0])4 print(l[1])5 print(l[2])6 #print(l[3])#超出边界报错:IndexError
7
8 #二:遵循迭代器协议访问方式
9 diedai_l=l.__iter__()10 print(diedai_l.__next__())11 print(diedai_l.__next__())12 print(diedai_l.__next__())13 #print(diedai_l.__next__())#超出边界报错:StopIteration
14
15 #三:for循环访问方式
16 #for循环l本质就是遵循迭代器协议的访问方式,先调用diedai_l=l.__iter__()方法,或者直接diedai_l=iter(l),然后依次执行diedai_l.next(),直到for循环捕捉到StopIteration终止循环
17 #for循环所有对象的本质都是一样的原理
18
19 for i in l:#diedai_l=l.__iter__()
20 print(i) #i=diedai_l.next()
21
22 #四:用while去模拟for循环做的事情
23 diedai_l=l.__iter__()24 whileTrue:25 try:26 print(diedai_l.__next__())27 exceptStopIteration:28 print('迭代完毕了,循环终止了')29 break
三元表达式
三元运算又称三元运算(三目运算)，是对简单的条件语句的缩写。
1 #result = 值1 if 条件 else 值2
2
3 #如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量
4
5 #三元表达式
6 name='marry'
7 name='jack'
8 res='woman' if name == 'marry' else 'man'
9 print(res)
列表解析与生成器表达式
总结： 1 egg_list=['鸡蛋%s' %i for i in range(10)] #列表解析
2
3
4 #列表解析直接生成列表，占用内存空间，用生成器表达式可避免浪费内存
5
6 laomuji=('鸡蛋%s' %i for i in range(10))#生成器表达式
7 print(laomuji)8 print(next(laomuji)) #next本质就是调用__next__
9 print(laomuji.__next__())10 print(next(laomuji))
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：
1 sum(x ** 2 for x in xrange(4))
而不用多此一举的先构造一个列表：
1 sum([x ** 2 for x in xrange(4)])
生成器
一、什么是生成器？
可以理解为一种数据类型，这种数据类型自动实现了迭代器协议(其他的数据类型需要调用自己内置的__iter__方法)，所以生成器就是可迭代对象
二、生成器分类及在python中的表现形式：(Python有两种不同的方式提供生成器)
1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表
三、为何使用生成器之生成器的优点
Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。
四、生成器小结：
1.是可迭代对象
2.实现了延迟计算,省内存
3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象没有这点好处。
1 deflay_eggs(num):2 egg_list=[]3 for egg inrange(num):4 egg_list.append('蛋%s' %egg)5 returnegg_list6
7 yikuangdan=lay_eggs(10) #我们拿到的是蛋
8 print(yikuangdan)9
10
11 deflay_eggs(num):12 for egg inrange(num):13 res='蛋%s' %egg14 yieldres15 print('下完一个蛋')16
17 laomuji=lay_eggs(10)#我们拿到的是一只母鸡
18 print(laomuji)19 print(laomuji.__next__())20 print(laomuji.__next__())21 print(laomuji.__next__())22 egg_l=list(laomuji)23 print(egg_l)24 #演示只能往后不能往前
25 #演示蛋下完了，母鸡就死了
195
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
