Python编程进阶之IO编程

文件读写

文本文件

with open('/path/to/file', 'r') as f:
    print(f.read())

withopen会自动调用close（）方法

• read()一次性读取文件的全部内容，如果文件有10G，内存就爆了，适用于小文件
• read(size)反复调用，适用于不能确定文件大小
• readline()可以每次读取一行内容
• readlines()一次读取所有内容并按行返回list，适用于配置文件

for line in f.readlines():
    print(line.strip()) # 把末尾的'\n'删掉
strip函数不止能删空格鸭

file-like object

像open()函数返回的这种有个read()方法的对象，在Python中统称为file-like Object。除了file外，还可以是内存的字节流，网络流，自定义流等等。file-like Object不要求从特定类继承，只要写个read()方法就行。

StringIO就是在内存中创建的file-like Object，常用作临时缓冲

二进制文件

要读取二进制文件，比如图片、视频等等，用’rb’模式打开文件即可

字符编码

读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件
遇到有些编码不规范的文件，你可能会遇到UnicodeDecodeError，因为在文本文件中可能夹杂了一些非法编码的字符。遇到这种情况，open()函数还接收一个errors参数，表示如果遇到编码错误后如何处理。最简单的方式是直接忽略：

>>> f = open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')

读取为string再打印出来的话，命令行里展示的更加漂亮

StringIO和BytesIO

StringIO:在内存中读写str

要把str写入StringIO，我们需要先创建一个StringIO，然后，像文件一样写入即可

f=StringIO()
f.write('hello')
f.write(' ')
f.write('yry')
print(f.getvalue())

b=StringIO('Hello! \n Yry!\n You will get better!\n')
while True:
    s=b.readline()
    if s=='':
        break
    print(s.strip())
    
hello yry
Hello!
Yry!
You will get better!

• f.write()：向StringIO对象中写入
• f,getvalue(): 获得写入后的str

ByteIO：向内存中写入二进制数据

f=BytesIO()
f.write('我支持香港警察，你也不能打我'.encode('utf-8'))
print(f.getvalue())

f=BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
print(f.read()) #file-like obj的方法
b'\xe6\x88\x91\xe6\x94\xaf\xe6\x8c\x81\xe9\xa6\x99\xe6\xb8\xaf\xe8\xad\xa6\xe5\xaf\x9f\xef\xbc\x8c\xe4\xbd\xa0\xe4\xb9\x9f\xe4\xb8\x8d\xe8\x83\xbd\xe6\x89\x93\xe6\x88\x91'

b'\xe4\xb8\xad\xe6\x96\x87'

操作文件和目录

用os模块直接调用操作系统提供的接口函数

os.name ：查看操作系统类型，‘POSIX’说明是Linux,Uninx或Mac OS X，如果是’nt’，则是Windows系统
os.uname() :获得详细信息，在Windows上不提供

环境变量

os.environ: 保存了操作系统中定义的环境变量
os.environ,get(‘key’) : 获取环境变量的值

操作文件和目录

os.path.abspath('.')：查看当前目录的绝对路径
os.path.join('.','testdir') : 在某个目录下创建一个新目录，首先把新目录的完整路径表示出来
‘.\testdir’

os.mkdir('.\\testdir')
os.rmdir('.\\testdir')
os.mkdir('.\\testdir')
os.path.split('.\\testdir' )
('.', 'testdir')
filename='C:\\Users\\Administrator\\Desktop\\problems.txt'
os.path.splitext('C:\\Users\\Administrator\\Desktop\\problems.txt' )
('C:\\Users\\Administrator\\Desktop\\problems', '.txt')

把两个路径合成一个时，不要直接拼字符串，而要通过os.path.join()函数，这样可以正确处理不同操作系统的路径分隔符。在Linux/Unix/Mac下，os.path.join()返回这样的字符串：

part-1/part-2

而Windows下会返回这样的字符串：

part-1\part-2

同样的道理，要拆分路径时，也不要直接去拆字符串，而要通过os.path.split()函数,os.path.splitext()可以直接让你得到文件扩展名，很多时候非常方便：

列出了所有以py结尾的文件。合并、拆分路径的函数并不要求目录和文件要真实存在，它们只对字符串进行操作。

os.rename('test.txt', 'test.py') 对文件重命名:
os.remove('test.py') 删掉文件

复制文件的函数在shutil模块copyfile()

os.listdir('.') 得到当前目录下的所有文件
os.path.isfile(x) 判断x是否是文件，必须是一个完整的路径才能测试
os.path.isdir(x) 判断x是否是目录

练习

编写一个程序，能在当前目录以及当前目录的所有子目录下查找文件名包含指定字符串的文件，并打印出相对路径。

完全用C语言思维写出来的emm
def getRelativePath(dir,rootDir):
    abspath=os.path.abspath(dir)
    rootpath=os.path.abspath(rootDir)
    rel= abspath.replace(rootpath,'.',1)
    return rel

def find(str,rootDir='.',dir='.'):  #rootDir控制最开始的根目录，为了输出，递归的时候一直不变
    objs=[x for x in os.listdir(dir)] #ls下展现的字符串
    for obj in objs:
        path=os.path.join(dir,obj)  #ls下文件或文件夹的完整目录
        if os.path.isfile(path):    
            if obj.find(str)!=-1:   #in也可以
                print(getRelativePath(path,rootDir))
                                                     #输出相对路径
        elif os.path.isdir(path):
            find(str,rootDir,path)
            # print(getRelativePath(path,rootDir))
        #层次比较多的提取相对位置失败

find('明',r'D:\保研',r'D:\保研')

放一个我觉得挺不错der

# -*- coding: utf-8 -*-
#!/usr/bin/python
import os
def main():  全局变量
    str = input('输入查询字符串：')
    path_name = input('输入查询路径（默认为工作路径）:')
    if path_name == '':
        path_name = '.'#给懒癌患者一个交代
    minus = len(path_name)   这个输出相对路径的方式打call

    def list_file(str,path):
        list_all =os.listdir(path)
        for name_f in list_all:
            path_c = os.path.join(path,name_f) 
            if os.path.isfile(path_c) and str in os.path.splitext(name_f)[0]:
                print(path_c[minus:])#把路径前缀去掉
            elif os.path.isdir(path_c):
                list_file(str,path_c)


    list_file(str,path_name)

if __name__ == '__main__':
    main()

序列化

把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

pickle模块

把一个对象序列化写入文件

pickle.dumps()方法把任意对象序列化成一个bytes，然后，就可以把这个bytes写入文件。或者用另一个方法pickle.dump()直接把对象序列化后写入一个file-like Object：

pickle.load()方法从一个file-like Object中直接反序列化出对象

Json

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

JSON类型	Python类型
{}	dict
[]	list
“string”	str
1234.56	int或float
true/false	True/False
null	None

把Python对象变成一个JSON

dumps()方法返回一个str，内容就是标准的JSON。类似的，dump()方法可以直接把JSON写入一个file-like Object。

要把JSON反序列化为Python对象，用loads()或者对应的load()方法，前者把JSON的字符串反序列化，后者从file-like Object中读取字符串并反序列化：
由于JSON标准规定JSON编码是UTF-8，所以我们总是能正确地在Python的str与JSON的字符串之间转换。

Json进阶

Python的dict对象可以直接序列化为JSON的{}

>>> d = dict(name='Bob', age=20, score=88)

不过，很多时候，我们更喜欢用class表示对象，比如定义Student类，然后序列化：

import  json
class Student(object):
    def __init__(self,name,age,score):
        self.name=name
        self.age=age
        self.score=score


def student2dict(std):

    return{
        'name': std.name,
        'age': std.age,
        'score': std.score,
    }
    

def dict2student(d):
    return Student(d['name'],d['age'],d['score'])

s=Student('Bob', 20, 88)
print(json.dumps(s, default=lambda obj:obj.__dict__))

print(json.dumps(s, default=student2dict))
json_str = '{"age": 20, "score": 88, "name": "Bob"}'
print(json.loads(json_str,object_hook=dict2student))

{"name": "Bob", "age": 20, "score": 88}
{"name": "Bob", "age": 20, "score": 88}
<__main__.Student object at 0x000001EEEAD2FF98>

这样，Student实例首先被student2dict()函数转换成dict，然后再被顺利序列化为JSON。
通常class的实例都有一个__dict__属性，它就是一个dict，用来存储实例变量。也有少数例外，比如定义了__slots__的class
同样的道理，如果我们要把JSON反序列化为一个Student对象实例，loads()方法首先转换出一个dict对象，然后，我们传入的object_hook函数负责把dict转换为Student实例

ensure_ascii参数

obj = dict(name='小明', age=20)
s = json.dumps(obj, ensure_ascii=True)
print(s)

{"name": "\u5c0f\u660e", "age": 20}