跟我一起学Python（八）

一、IO编程

读写文件是最常见的IO操作，Python内置了读写文件的函数。
文件读写的原理：在磁盘上读写文件的功能都是由操作系统提供的，现代操作系统不允许普通的程序直接操作磁盘，所以，读写文件就是请求操作系统打开一个文件对象（通常称为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）。

读文件

#如果文件不存在，open()函数就会抛出一个IOError的错误，
>>> f = open('/Users/Administrator/angular-cli.json',"r")#绝对地址  当前的盘符+'/Users/Administrator/angular-cli.json' 构成绝对地址
>>> f.read()
'{\n  "warnings": {\n    "packageDeprecation": false\n  }\n}\n'

最后一步是调用close()方法关闭文件。文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源，并且操作系统同一时间能打开的文件数量也是有限的：

>>> f.close()

由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现：

try:
    f = open('/path/to/file', 'r')
    print(f.read())
finally:
    if f:
        f.close()

此时我们先来学一下python里面的try finally 语句

def f():
    try:
        print 1
        return 1
    finally:
        print 0
        return 0
s = f()
print(s)

输出为：1 0 0

不论try里执行什么，都会执行到finnally语句，且如果finally里面有return语句，就会替代了try里面的return语句。

def f():
    try:
        print 1
        return 1
    finally:
        print 0
        #return 0
s = f()
print(s)

输出为 1 0 1

def f():
    try:
        print 1
        return 1
    except:
        return 2
    else:
        print 3
        return 3
    finally:
        print 0
        return 0
s = f()
print(s)

输出为：1 0 0

只要try语句里有return语句（不包括finally语句里面的return语句），则不执行else语句。
只要try语句执行后抛出错误，紧跟着就会执行except语句。

利用try...finally语句太繁琐了，Python引入了with语句来自动帮我们调用close()方法：

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

调用read()会一次性读取文件的全部内容，如果文件有10G，内存就爆了，所以，要保险起见，可以反复调用read(size)方法，每次最多读取size个字节的内容。外，调用readline()可以每次读取一行内容，调用readlines()一次读取所有内容并按行返回list。因此，要根据需要决定怎么调用。

for line in f.readlines():
    print(line.strip()) # 把末尾的'\n'删掉

Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

file-like Object

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

二进制文件

前面讲的默认都是读取文本文件，并且是UTF-8编码的文本文件。要读取二进制文件，比如图片、视频等等，用'rb'模式打开文件即可：

>>> f = open('/Users/michael/test.jpg', 'rb')
>>> f.read()
b'\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...' # 十六进制表示的字节

字符编码

要读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：

>>> f = open('/Users/michael/gbk.txt', 'r', encoding='gbk')
>>> f.read()
'测试'

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

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

写文件

写文件和读文件是一样的，唯一区别是调用open()函数时，传入标识符'w'或者'wb'表示写文本文件或写二进制文件：

>>> f = open('/Users/michael/test.txt', 'w')
>>> f.write('Hello, world!')
>>> f.close()

with写法

with open('/Users/michael/test.txt', 'w') as f:
    f.write('Hello, world!')

写文件时，如果文件事先不存在，则会创建出来，且只有在close()操作结束之后才可以显示出写进去的内容。
因为当我们写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入。只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘。

关于open()的mode参数：
'r'：读
'w'：写
'a'：追加
'r+' == r+w（可读可写，文件若不存在就报错(IOError)）
'w+' == w+r（可读可写，文件若不存在就创建）
'a+' ==a+r（可追加可写，文件若不存在就创建）
对应的，如果是二进制文件，就都加一个b就好啦：
'rb'　　'wb'　　'ab'　　'rb+'　　'wb+'　　'ab+'

二、StringIO和BytestIO

很多时候，数据读写不一定是文件，也可以在内存中读写。
StringIO顾名思义就是在内存中读写str。

>>> from io import StringIO
>>> f = StringIO()
>>> f.write('hello')
5
>>> f.write(' ')
1
>>> f.write('world!')
6
>>> print(f.getvalue())
hello world!

getvalue()方法用于获得写入后的str
要读取StringIO，可以用一个str初始化StringIO，然后，像读文件一样读取

from io import StringIO
f = StringIO('Hello!\nHi!\nGoodbye!')
s = f.read()
print(s)

注意：初始化为空，用write方法写入数据的StringIO对象，无法像读文件一样读取

BytesIO

StringIO操作的只能是str，如果要操作二进制数据，就需要使用BytesIO。

>>> from io import BytesIO
>>> f = BytesIO()
>>> f.write('中文'.encode('utf-8'))
6
>>> print(f.getvalue())
b'\xe4\xb8\xad\xe6\x96\x87'

三、操作文件和目录

如果我们要操作文件、目录，可以在命令行下面输入操作系统提供的各种命令来完成。比如dir、cp等命令，而Python内置的os模块也可以直接调用操作系统提供的接口函数。

>>> import os
>>> os.name # 操作系统类型
'posix'

如果是posix，说明系统是Linux、Unix或Mac OS X，如果是nt，就是Windows系统。
要获取详细的系统信息，可以调用 uname()函数

环境变量

在操作系统中定义的环境变量，全部保存在os.environ这个变量中，可以直接查看：
要获取某个环境变量的值，可以调用os.environ.get('key')：

操作文件和目录

操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中，

# 查看当前目录的绝对路径:
>>> os.path.abspath('.')
'/Users/michael'
# 在某个目录下创建一个新目录，首先把新目录的完整路径表示出来:
>>> os.path.join('/Users/michael', 'testdir')
'/Users/michael/testdir'
# 然后创建一个目录:
>>> os.mkdir('/Users/michael/testdir')
# 删掉一个目录:
>>> os.rmdir('/Users/michael/testdir')

把两个路径合成一个时，不要直接拼字符串，而要通过os.path.join()函数，
在Linux/Unix/Mac下，

part-1/part-2

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

part-1\part-2

同样的道理，要拆分路径时，也不要直接去拆字符串，而要通过os.path.split()函数，这样可以把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名：

>>> os.path.split('/Users/michael/testdir/file.txt')
('/Users/michael/testdir', 'file.txt')

这些合并、拆分路径的函数并不要求目录和文件要真实存在，它们只对字符串进行操作。

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

列出当前目录下的所有目录

>>> [x for x in os.listdir('.') if os.path.isdir(x)]
['.lein', '.local', '.m2', '.npm', '.ssh', '.Trash', '.vim', 'Applications', 'Desktop', ...]

os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表。这个列表以字母顺序。 它不包括 '.' 和'..' 即使它在文件夹中。

只支持在 Unix, Windows 下使用。
列出所有的.py文件

>>> [x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']
['apis.py', 'config.py', 'models.py', 'pymonitor.py', 'test_db.py', 'urls.py', 'wsgiapp.py']

os模块下的常用方法
os.path.isdir()用于判断对象是否为一个目录
os.path.isfile()用于判断对象是否为一个文件
os.getcwd() 获取当前所在目录
os.path.abspath(path) 返回path规范化的绝对路径

>>> os.path.abspath("test.txt") 
'C:\WINDOWS\system32\test.txt'

os.path.split(path) 将path分割成目录和文件名二元组返回。

>>> os.path.split('C:\WINDOWS\system32\test.txt')
('C:\WINDOWS\system32', 'test.txt')
>>>

os.path.splitext(x) 将文件名和后缀名分割二元数组返回

>>> os.path.splitext("test.txt")
('test', '.txt')

os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素。
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素。

>>> os.path.basename('C:\WINDOWS\system32\test.txt')
'test.txt'

os.path.commonprefix(list) 返回list中，所有path共有的最长的路径。
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False。
os.path.isabs(path) 如果path是绝对路径，返回True。
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间。
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

复制文件的函数是不在os模块里面的，但是shutil模块提供了copyfile()的函数。
shutil模块
os.mkdir("file") 创建目录
复制文件：
shutil.copyfile("oldfile","newfile") oldfile和newfile都只能是文件
shutil.copy("oldfile","newfile") oldfile只能是文件，newfile可以是文件，也可以是目标目录
复制文件夹：
shutil.copytree("olddir","newdir") olddir和newdir都只能是目录，且newdir必须不存在
重命名文件（目录）
os.rename("oldname","newname") 文件或目录都是使用这条命令
移动文件（目录）
shutil.move("oldpos","newpos")
删除文件
os.remove("file")
删除目录
os.rmdir("dir")只能删除空目录
shutil.rmtree("dir") 空目录、有内容的目录都可以删
转换目录
os.chdir("path") 换路径

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

import os
import re
from io import StringIO
p = os.getcwd() 
list = []
def fun(t):
    global list
    list = list + [os.path.splitext(x)[0] for x in os.listdir(t) if os.path.isfile(x)]
    #print([os.path.splitext(x) for x in arr if os.path.isfile(x)])
    file_dir = [os.path.splitext(x)[0] for x in os.listdir(t) if os.path.isdir(x)]
    for file in file_dir:
        fun(t + "\" + file )
        # print(os.listdir(t + "\" + file))
fun(p)
print(list)
for item in list:
    if(re.search('n', item)):
        print(item)

打印相对路径 ： print(__ file __)

四、序列化

pickle

我们把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

Python提供了pickle模块来实现序列化。
首先，我们尝试把一个对象序列化并写入文件：

import pickle
d = dict(name='Bob', age=20, score=88)
f = open('dump.txt', 'wb')
pickle.dump(d, f)
f.close()

此时已经d写入了当前目目下dump.txt的文件里，科室当你打开文件时，发现里面是乱码，根本看不懂。这些都是Python用自己的方式保存的对象内部信息。
当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用pickle.loads()方法反序列化出对象，也可以直接用pickle.load()方法从一个file-like Object中直接反序列化出对象。

import pickle
f = open('dump.txt', 'rb')
d = pickle.load(f)
print(d)              #{'name': 'Bob', 'age': 20, 'score': 88}

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

JSON

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

Python内置的json模块:如下即可把Python对象转化成JSON

>>> import json
>>> d = dict(name='Bob', age=20, score=88)
>>> json.dumps(d)
'{"age": 20, "score": 88, "name": "Bob"}'

类似的也可以直接把JSON写入file-like里

import json
d = dict(name='Bob', age=20, score=88)
with open('dump.txt',"w") as f:
    json.dump(d,f)
f.close()

load:把文件打开，并把字符串变换为数据类型

import json
with open('dump.txt','r') as load_f:
    load_dict = json.load(load_f)
    print(load_dict)

loads: 将 字符串 转换为 字典

import json
d = dict(name='Bob', age=20, score=88)
json_str = json.dumps(d)    #dumps：将python中的 字典 转换为 字符串
new_dict = json.loads(json_str)
print(new_dict)

class对象的序列化
按照dict的转化方法是不可以的，因为dumps()方法不知道如何将Student实例变为一个JSON的{}对象。所以此时要给
dumps()方法新增一个参数default,可选参数default就是把任意一个对象变成一个可序列为JSON的对象，我们只需要为Student专门写一个转换函数，再把函数传进去即可：

import json
def student2dict(std):
    return {
        'name': std.name,
        'age': std.age,
        'score': std.score
    }
class Student(object):
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

s = Student('Bob', 20, 88)
print(json.dumps(s, default=student2dict))

但是如果你有好多class类都需要被转换，那么这种发放就会太繁琐
通常class类实例都有一个__dict__属性,**.__dict__就得到了该 类对应的dict对象，也有少数例外，比如定义了slots的class。

同样的道理，如果我们要把JSON反序列化为一个Student对象实例，loads()方法首先转换出一个dict对象，然后，我们传入的object_hook函数负责把dict转换为Student实例：

def dict2student(d):
    return Student(d['name'], d['age'], d['score'])
json_str = '{"age": 20, "score": 88, "name": "Bob"}'
print(json.loads(json_str, object_hook=dict2student)) #打印出的是反序列化的Student实例对象。

json.dumps的参数
sort_keys=True 是告诉编码器按照字典排序(a到z)输出。
indent=None 参数根据数据格式缩进显示，读起来更加清晰。None默认不缩进（indent=2表示缩进两个字节）
skipkeys=True，在encoding过程中，dict对象的key只可以是string对象，如果是其他类型，那么在编码过程中就会抛出ValueError的异常。skipkeys可以跳过那些非string对象当作key的处理.
ensure_ascii=False 输出真正的中文默认为True，输出的是ASCII字符