Python学习笔记 - IO编程

Python学习笔记 - IO编程

根据廖雪峰的Python教程做成的笔记，其中不包含全部知识点，仅是重点或是容易发生混淆或者忘记的部分。

1. 文件读写

1.1 打开文件

• 基本方法

f = open('E:\codePractice/Python/readme.txt', 'r') 
# 文件读写操作略...（见下文）
f.close()

• 简单方法
  使用with语句免去了close()的操作。

with open('E:\codePractice/Python/readme.txt', 'r') as f:
    s = f.read()
    print('s = ', s)

1.2 读文件

• read()
  读取文件全部内容。

with open('E:\codePractice/Python/readme.txt', 'r') as f:
    s = f.read()
    print('s = ', s)
# 输出：
# s = C
# C++
# Python

• read(size)
  如果文件太大（如10G），使用read()的话内存就爆了，这是可以使用read(size)指定要读取的size(字节数)
• readline()
  读取一行。

with open('E:\codePractice/Python/readme.txt', 'r') as f:
    s = d.readline()
    print('s = ', s)
# 输出：
# s = C

• readlines()
  读取文件全部内容按行返回list。

with open('E:\codePractice/Python/readme.txt', 'r') as f:
    for s in f.readlines():
        print('s' = )
# 输出
# s = C
# s = C++
# s = Python

1.3 写文件

1.3.1 写文件

with open('E:\codePractice/Python/readme.txt', 'w') as f:
    f.write('Hello')

1.3.2 mode文件操作模式

mode	说明	备注
r	可读不可写
w	可写不可读	写时删除文件既存内容，重新写入
a	可写不可读	写时不删除文件既存内容，在文件末尾追加
r+	可读写	写时不删除文件既存既存内容，但会从文件开头逐渐覆盖既存内容
w+	可读写	写时删除文件既存内容，重新写入
a+	可读写	写时不删除文件既存内容，在文件末尾追加

2. StringIO和BytesIO

StringIO顾名思义就是在内存中读写str。

2.1 StringIO

2.1.1 写入IO

from io import StringIO

f = StringIO()  # 创建IO
f.write('Hello\nworld!\n') # 内容写入IO
print(f.getvalue()) # 取得IO中的内容并输出

# 输出
# Hello
# world！

2.1.2 从IO中读取

from io import StringIO

f = StringIO('Hello\nworld\n!!!\n')
while True:
    s = f.readline()
    if s == '':
        break
    print(s.strip())
# 输出
# Hello
# world
# !!!

2.2 BytesIO

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

BytesIO实现了在内存中读写bytes，我们创建一个BytesIO，然后写入一些bytes：

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

请注意，写入的不是str，而是经过UTF-8编码的bytes。

和StringIO类似，可以用一个bytes初始化BytesIO，然后，像读文件一样读取：

>>> from io import BytesIO
>>> f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
>>> f.read()
b'\xe4\xb8\xad\xe6\x96\x87'

3. 序列化

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

变量写入文件可以使用pickle.dump()函数，从文件中读取使用pickle.load()函数。

例：把dict写入文件再读出。

import pickle

def save_d():
    f = open('readme.txt', 'wb')
    d = dict(name = 'Bob', age = 26, score = 88)
    print('d = ', d)
    d['age'] = 30
    d['number'] = 1
    pickle.dump(d, f)
    f.close()

def get_d():
    f = open('readme.txt', 'rb')
    d = pickle.load(f)
    f.close()
    print('d = ', d)

save_d()
get_d()

# 输出：
# d =  {'name': 'Bob', 'score': 88, 'age': 26}
# d =  {'name': 'Bob', 'number': 1, 'score': 88, 'age': 30}

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

Json
如果我们要在不同的编程语言之间传递对象，可以把对象序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。

import json

f = open('readme.json', 'w')
d = dict(name = 'Bob', age = 26, score = 88)
json.dump(d, f)
f.close()

f1 = open('readme.json', 'r')
a = json.load(f1)
print(a['name'])
f1.close()