文件访问与函数式编程入门

1. 文本文件读写
2. 二进制文件读写
3. 文件和目录操作
4. 序列化与反序列化
5. 高阶函数
6. 匿名函数
7. 装饰器
8. 偏函数

   文本文件读写3种方法：

第一种方法

直接读入

file1 = open("test.txt") 
file2 = open("output.txt","w") 

while True: 
    line = file1.readline() 
    #这里可以进行逻辑处理 
    file2.write('"'+line[:]+'"'+",") 
    if not line: 
        break 
#记住文件处理完，关闭是个好习惯 
file1.close() 
file2.close() 

读文件有3种方法：

• read()将文本文件所有行读到一个字符串中。
• readline()是一行一行的读
• readlines()是将文本文件中所有行读到一个list中，文本文件每一行是list的一个元素。 优点：readline()可以在读行过程中跳过特定行。

  第二种方法：

  文件迭代器，用for循环的方法

  file2 = open("output.txt","w") 
  for line in open("test.txt"): 
      #这里可以进行逻辑处理 
      file2.write('"'+line[:]+'"'+",") 
  file2.close()
  

  
  

  第三种方法：

  文件上下文管理器

  '''打开文件
  用with..open自带关闭文本的功能'''
  with open('somefile.txt', 'r') as f: 
            data = f.read() 
            print(data)
  with open('somefile.txt', 'r') as f: 
            for line in f: 
            #处理每一行
                      print(line)'''会出现空白行，因为每行末尾都有一个看不见的
                                  换行符，而且print语句也会加上一个换行符'''
                      #print(line.rstrip())#可以消除空白行
  
  # 写入文本 
  with open('somefile.txt', 'w') as f: 
            f.write("text1.txt") 
            f.write("text2.txt") 
       
  
  # 把要打印的line写入文件中 
  with open('somefile.txt', 'w') as f: 
            print('line1', file=f) 
            print('line2', file=f)

高阶函数：

接受函数为参数，或者把函数作为结果返回的函数成为高阶函数。

sorted函数：

#根据单词长度给一个列表排序
# sorted:可选的key参数用于提供一个函数，他应用到各个元素上进行排序
fruits=['strawberry','fig','apple','cherry','raspberry','banana']
print(sorted(fruits,key=len))
#根据反向拼写给一个单词列表排序
#注意：列表的单词没有变，只是把反向拼写当做排序条件
def reverse(word):
    return word[::-1]
print(reverse('testing'))
print(sorted(fruits,key=reverse))

map:

map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

格式：map(func, seq1[, seq2...] )

Python函数式编程中的map()函数是将func作用于seq中的每一个元素，并用一个列表给出返回值。

filter

filter()函数可以对序列做过滤处理，就是说可以使用一个自定的函数过滤一个序列，把序列的每一项传到自定义的过滤函数里处理，并返回结果做过滤。最终一次性返回过滤后的结果。 和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

语法

filter(func, seq)

#计算阶乘列表：map和filter与列表推到比较
#构建0！到5！的一个阶乘列表。
def fact(n):
    if n < 0 :
        raise ValueError()
    if n == 1&0 :
        return 1
    return n * fact(n - 1)
print(list(map(fact,range(6))))
#使用列表推导执行相同的操作
a=list(fact(n) for n in range(6))
print(a)
#使用map和filter计算直到5！的奇数阶乘列表
b=list(map(fact,filter(lambda n:n % 2,range(6))))
print(b)
#使用列表推导做相同的工作。
c=list(fact(n) for n in range(6) if n % 2)
print(c)

reduce:

Python中的reduce内建函数是一个二元操作函数，他用来将一个数据集合(列表，元组等)中的所有数据进行如下操作：传给reduce中的函数func() (必须是一个二元操作函数)先对集合中的第1，2个数据进行操作，得到的结果再与第三个数据用func()函数运算，最后得到一个结果。

#使用reduce和sum计算0~99之和
from functools import reduce
from operator import add
a=reduce(add,range(100))
print(a)
b=sum(range(100))
print(b)

sum和reduce的通用思想是把某个操作连续应用到序列的元素上，累计之前的结果，把一系列的直归约成一个值。

all和any也是内置的归约函数

all(iterable)

如果iterable的每个元素都是真值，返回True,all([])返回True

any(iterable)

只要iterable的有一个元素都是真值，返回True,all([])返回False

abs()取绝对值

add()求和

匿名函数

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。

• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

Lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

#使用lambda表达式反转拼写，然后依次给出单词列表排序
fruit=['strawary','fig','apple','cherry','raspberry','banana']
b=sorted(fruit,key=lambda word:word[::-1])
print(b)
#相加函数
sum=lambda arg1,arg2:arg1+arg2
print(sum(10,20))
#相当于定义了一个函数
def sun (arg1,arg2):
    return arg1+arg2
print(sun(10,20))

装饰器

装饰器是可调用的对象，其参数是另一个函数（被装饰的函数）。装饰器可能会处理被装饰的函数，然后把它返回，或者将其替换换成另一个函数或可调用对象。

#假如有一个名为decorate的装饰器：
@decorate
def target():
    print('running target()')
#上述代码的效果与上述写法一样：
def target():
    print('running target()')
target=decorate(target)

两种写法的最终结果一样：上述两个代码片段执行完毕后得到的target不一定是原来那个target函数，而是decorate(target)返回的函数。

#装饰器通常把函数替换成另一个函数
def deco(func):
    def inner():
        print('running inner()')
    return inner #deco返回inner函数对象
@deco
def target():   #使用deco装饰target
    print('running target()')
target()         #调用被装饰的target其实会运行inner
print(target)   #审查对象，发现target现在是inner的引用

我的理解是register为装修房子时墙的壁纸，f1,f2为墙上的开关，开关在墙上，

registry=[]
def register(func):
          print('running register(%s)'%func)
          registry.append(func)
          return func
@register
def f1():   #f1被装饰
          print('running f1()')
@register   #f2被装饰
def f2():
          print('running f2()')
def f3():
          print('running f3()')
def main():
          print('running main()')
          print('registry->',registry)
          f1()
          f2()
          f3()
if __name__=='__main__':
    main()
'''加载模块后，registry中有两个被装饰函数的引用：f1和f2。f1，f2及f3,只有在main明确调用的他们才执行。'''