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函数

对可迭代对象中的指合并操作

reduce()函数也是Python内置的一个高阶函数。

reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

例如，编写一个f函数，接收x和y，返回x和y的和：

def f(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。

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)

 列表解析与生成器表达式

总结： 1 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)
#演示只能往后不能往前
#演示蛋下完了，母鸡就死了