【七月Python入门】第五课面文件访问与函数式编程入门

雨点打透心脏的1/2处 2022-06-03 07:19 176阅读 0赞

1.文本文件读写三种方法：

（1）直接读入

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

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

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

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

（3）文件上下文管理器 (好处在于不需要自己关闭文件)

#打开文件
    #用with..open自带关闭文本的功能
    with open('somefile.txt', 'r') as f: 
        data = f.read() 
    
    # loop整个文档
    with open('somefile.txt', 'r') as f: 
        for line in f: 
            # 处理每一行
    
    # 写入文本 
    with open('somefile.txt', 'w') as f: 
        f.write(text1) 
        f.write(text2) 
        ... 
    
    # 把要打印的line写入文件中 
    with open('somefile.txt', 'w') as f: 
        print(line1, file=f) 
        print(line2, file=f)

2.二进制文件读写：python默认的是文本文件的读写，如果要二进制文件读写，需要加上‘b’。例如： 需要把刚刚的'r'改成'rb'。

f = open('EDC.jpg', 'rb')
    print(f.read())
    # 输出 '\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...' # 十六进制表示的字节

需要用二进制读入这个文件，然后再用 .decode('...')的方法来解码这个二进制文件：

f = open('DegangGuo.txt', 'rb')
    # 读入郭德纲老师的作文, 但是郭老师用的是参合着错别字的繁体编码，假设叫个"DeyunCode"
    # 那么你读入以后，就需要解码它
    u = f.read().decode('DeyunCode')

3. 通过os.path.split()函数，这样可以把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名：

os.path.split('/Users/EDC/Pictures/AJiao.avi')
    # ('/Users/EDC/Pictures/', 'AJiao.avi')

os.path.splitext()得到文件扩展名：

os.path.splitext('/Users/EDC/Pictures/AJiao.avi')
    # ('/Users/EDC/Pictures/AJiao', '.avi')

4.什么是序列化？

程序运行的过程中，所有变量都是在内存中操作的，当程序一旦执行完毕，结束退出后，变量占有的内存就被操作系统回收了。 因此我们需要将某些数据持久化存储到磁盘中，下次运行的时候从磁盘中读取相关数据。我们将变量从内存中变成可以存储或传输的过程称之为序列化，在Python中叫做pickling，在其它语言中也称之为 serialization、marshaling、flattening等等，说的都是一个意思。 反之，则为反序列化，称之为unpickling，把变量内容从序列化的对象重新读取到内存中。

序列化：

import pickle
    
    # 此处定义一个dict字典对象
    d = dict(name='思聪', age=29, score=80)
    str = pickle.dumps(d) # 调用pickle的dumps函数进行序列化处理
    print(str)
    # 你可以看看它长什么样子
    
    # 定义和创建一个file文件对象，设定模式为wb
    f = open('dump.txt', 'wb')
    # 将内容序列化写入到file文件中
    pickle.dump(d, f)
    f.close() # 最后关闭掉文件资源

反序列化：

import pickle
    
    # 从之前序列化的dump.txt文件里边读取内容
    f = open('dump.txt', 'rb') # 设定文件选项模式为rb
    d = pickle.load(f) # 调用load做反序列处理过程
    f.close() # 关闭文件资源
    print(d)
    print('name is %s' % d['name'])

5. 我们可以用JSON来做序列化。Python的数据结构跟Json有非常完美的兼容：

<table style="border-collapse:collapse; border-spacing:0px; background-color:transparent; margin-left:auto; margin-right:auto; border:1px solid #000000; margin-top:1em; color:rgb(0,0,0); font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; font-size:14px"> 
 <thead> 
  <tr style="border:1px solid #000000; border-collapse:collapse; margin:1em 2em"> 
   <th style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> JSON类型</th> 
   <th style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> Python类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr style="border:1px solid #000000; border-collapse:collapse; margin:1em 2em"> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> {}</td> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> dict</td> 
  </tr> 
  <tr style="border:1px solid #000000; border-collapse:collapse; margin:1em 2em"> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> []</td> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> list</td> 
  </tr> 
  <tr style="border:1px solid #000000; border-collapse:collapse; margin:1em 2em"> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> "string"</td> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> 'str'或者u'unicode'</td> 
  </tr> 
  <tr style="border:1px solid #000000; border-collapse:collapse; margin:1em 2em"> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> 1234.56</td> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> int或float</td> 
  </tr> 
  <tr style="border:1px solid #000000; border-collapse:collapse; margin:1em 2em"> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> true/false</td> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> True/False</td> 
  </tr> 
  <tr style="border:1px solid #000000; border-collapse:collapse; margin:1em 2em"> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> null</td> 
   <td style="padding:4px; border:1px solid #000000; border-collapse:collapse; margin:1em 2em; vertical-align:middle"> None</td> 
  </tr> 
 </tbody> 
</table>

如果你有一个比较结构化的数据想要序列化，并且想要别的地方别的语言也能看得懂。那么你可以用JSON来做：

import json
     
    # 定义dict字典对象
    d1 = dict(name='小王', age=20, score=80)
    str = json.dumps(d1) # 调用json的dumps函数进行json序列化处理
    print(str)
     
    # 调用json的loads函数进行反序列化处理
    d2 = json.loads(str)

6.可以把别的函数作为参数传入的函数叫高阶函数。

7.python 使用 lambda 来创建匿名函数。lambda只是一个表达式，函数体比def简单很多。lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。Lambda函数的语法只包含一个语句，如下：

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

sum = lambda arg1, arg2: arg1 + arg2
    
    sum(10, 20)

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

from functools import reduce
    
    l = [1,2,3,4,5]
    print(reduce(lambda x,y: x+y, l))
    # 这里代表着，把list中的值，一个个放进lamda的x,y中
    
    # 如果你给出一个初始值，可以放在list后面
    print(reduce(lambda x,y: x+y, l, 10))
    # 这样，x开始的时候被赋值为10，然后依次

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

l = [1,2,3]
    new_list = list(map(lambda i: i+1, l))
    print(new_list)
    # Py3里，外面需要套个list：
    # 这是为了让里面的值给显示出来，要不然你会得到这是个map函数
    # 而不是里面的值。
    # Py2的童鞋不虚
    
    # 我们也可以把两个数组搞成一个单独的数组
    l2 = [4,5,6]
    new_list = list(map(lambda x,y: x+y, l, l2))
    print(new_list)

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

l = [100, 20, 24, 50, 110]
    new = list(filter(lambda x: x<50, l))
    # 同理，py3得套个list来转化成list函数，便于打印出来
    print(new)

11.偏函数： 偏函数又可以翻译成部分函数，大概意思就是说，只设置一部分参数。functools.partial就是帮助我们创建一个偏函数的：

import functools
    
    int2 = functools.partial(int, base=2)
    int2('1000000')