Python、IO编程

一、文件读写
读文件
open（）函数用来打开一个文件对象 语法：open（‘路径’，‘打开方式’）
文本文件打开方式为‘r’，
二进制文件、字符编码文件（GBK编码等）打开方式为‘rb’

f=open('/file/f.txt','r')

如果未成功打开会抛出一个IOError错误，反之，可用read（）函数一次性读取文件内容，会返回一个字符串str

>>>f.read()
'Hello,World!'

文件使用完毕后必须关闭，用close（）函数关闭文件，语法同read（）

为防止忘记关闭文件，用with语句自动调用close（）函数
语法：with open(‘路径’ ,’打开方式’) as: +方法

with open('F:/file/f.txt','r') as f:
    print f.read()

用with读取字符编码文件，如GBK编码文件：

import codecs
with codecs.open('/Users/michael/gbk.txt', 'r', 'gbk') as f:
    f.read() 

read（）为一次读取全部内容
read（size）可反复调用，最多读取size个字节，size为数字
readline（）每次读取一行内容
readlines（）一次读取所有内容，并按行返回list。（返回内容为[ ‘…….’ ]x形式）

写文件
写文件用write（）函数 语法：write（‘路径’，‘文件格式’）
文本文件为‘w’
二进制文件为‘wb’
同样一般用with语句

with open('F:/file/f.txt','w') as f:
    f.write('Hello,world')

要输入特定编码的文件同语法read一样

二、操作文件和目录
操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中
需要对文件和目录进行操作时，先导入os模块

import os

创建目录用os.mkdir()函数 语法 os.mkdir(‘已知路径/目录名’)
删除目录用os.rmdir()函数 语法 os.rmdir(‘路径’)

用os.path.join()函数将两个路径合成一个，（注意：目录或文件不需真实存在，其只对字符串进行操作。）语法 os.path.join(‘路径’,’目录或文件’)

>>>print os.path.join('F:/file/test8dir','test9dir')
F:/file/test8dir\test9dir  #windows分隔符为'\'，其他为'/'

用os.path.split()函数来拆分路径，同样目录或文件不需真实存在。语法：os.path.split(‘路径’)

print os.path.split('F:/file/test8dir/X.txt)
('F:/file/test8dir', 'X.txt')  #最后一个分隔符为分离点

用os.path.splitext()函数可以得到文件扩展名。语法：os.path.splitext(‘路径’)

print os.path.splitext('F:/file/test8dir/test8dir/X.txt')
('F:/file/test8dir/test8dir/X', '.txt')  #文件扩展名 '.'为分隔点

文件重命名：os.rename(‘初始文件名’,’更改明’)
删除文件：os.remove(‘文件名’)

列出当前目录下所有目录

print [x for x in os.listdir('.') if os.path.isdir(x)]

要列出所有的 .py 文件

print [x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']

三、序列化
序列化 – pickling：变量从内存中编程可存储或传输的过程。
反序列化 – unpickling：把变量内容从序列化的对象重新读到内存里。
实现序列化模块：cPickle和pickle 。 前者C语言写的速度快，导入时先尝试导入

try:
    import cPickle as pickle
except ImportError:
    import pickle

把对象序列化写入文件：
法①：pickle.dumps() ：把任一对象序列化成一个str，之后按照文件的读写操作把对象写入文件；
法②：pickle.dump() ：直接把对象序列化后写入文件
把对象从磁盘读到内存：
法①：先把内容读到一个str，之后pickle.loads() ：反序列化对象
法②：直接用pickle.load()直接反序列化对象，同时用一个变量保存。
法一：

try:
    import cPickle as pickle
except ImportError:
    import pickle
d=dict(name='Bob',age=20,score=77)
t=pickle.dumps(d)
with open('F:/file/test1dir/dump.txt','wb') as f:
    f.write(t)
with open('F:/file/test1dir/dump.txt','rb') as f:
    h=pickle.load(f)
print h

法二：

try:
    import cPickle as pickle
except ImportError:
    import pickle
d=dict(name='Bob',age=20,score=77)
with open('F:/file/test1dir/dump.txt','wb') as f:
    pickle.dump(d,f)      #不同点

with open('F:/file/test1dir/dump.txt','rb') as f:
    h=pickle.load(f)
print h

JSON
在不同的编程语言之间传递对象，必须把对象序列化为标准格式，比如XML，但更好的是JSON，其表示出来的就是一个字符串，可被所有语言读取。
把python对象变成一个JSON：

import json
d=dict(name='Bob',age=20)
print json.dumps(d)

返回一个字典

{"age": 20, "name": "Bob"}

把JSON反序列化为python对象，用loads（）：把JSON的字符串反序列化。 load（）方法后者从file-like Object中读取字符串并反序列化:
注意：反序列化得到的所有字符串对象都是unicode而不是str

json_str='{"height":175,"name":"Tom"}'
print json.loads(json_str)

输出：

{u'name': u'Tom', u'height': 175}

JSON进阶
Python的dict（字典）对象可直接序列化为JSon的{}，不过也可用来序列化class（类）对象

class Student(object):
    def __init__(self,name,age,score):   #构造函数
        self.name=name
        self.age=age
        self.score=score
def Student1dict(std):                #将类对象转换成dict（字典）的函数
    return {
        'name':std.name,
        'age':std.age,
        'score':std.score}
s=Student('Bob',20,99)
print (json.dumps(s,default=Student1dict))   #dumps（）方法第一个为obj（对象名），默认情况下需要传入一个将转换成dict的方法，不然将报错

上例，Student实例先被转换成dict，再序列化为JSON

但，一般class实例都有一个dict属性，可直接将实例转换成dict

print(json.dumps(s,default=lambda obj:obj.__dict__))

同样，将JSON反序列化为Student对象实例使用json.loads()方法，需先转换出一个dict对象，然后将方法传入object_hook函数

def dict2Student(d):
    return Student(d["name"],d["age"],d["score"])
json_str='{"name":"Bob","age":20,"score":99}'
print (json.loads(json_str,object_hook=dict2Student))

输出：

<__main__.Student object at 0x0000000002B27240>  #是反序列化的Student实例对象