标签：一个 readline 模式 byte 文件内容 with 决定 实现 默认
文件读写
打开和关闭文件
- 一般并不使用此种方法打开和关闭文件，而是使用
with open(file_name,‘r|w|a‘) as f:
打开文件
-
open()：只有在使用python内置的open()函数打开一个文件，创建一个file对象后，相关的方法才可以调用它进行读写操作。
file object = open(file_name [, access_mode][,buffering])
#------------------#
file_name：是一个包含了想要访问文件的文件名称的字符串值。
access_mode：决定了打开文件的模式：只读(r)，写入(w)，追加(a)等。默认为只读(r)
buffering：
如果buffering的值设为0，就不会有寄存；
如果buffering的值设为1，访问文件时会寄存行；
如果buffering的值设为大于1的整数，表明这就是寄存区的缓冲大小；
如果buffering的值设为负数，寄存区的大小为系统默认；
#-----------------#
| 读 |
y |
y |
|
y |
|
y |
| 写 |
|
y |
y |
y |
y |
y |
| 创建 |
|
|
y |
y |
y |
y |
| 覆盖 |
|
|
y |
y |
|
|
| 模式 |
r |
r+ |
w |
w+ |
a |
a+ |
| 指针在开始 |
y |
y |
y |
y |
|
|
| 指针在结尾 |
|
|
|
|
y |
y |
| file对象的属性 |
描述 |
| file.closed |
返回true：如果文件已经关闭，返回true；否则返回false |
| file.mode |
返回被打开文件的访问模式 |
| file.name |
返回文件的名称 |
| file.softspace |
返回false：如果用print输出后，必须跟一个空格符，则返回false。否则返回true |
关闭文件
-
close()：刷新缓冲区里任何还没有写入的信息，并关闭该文件，这之后就不能再进行写入。当一个文件对象的引用被重新指定给另一个文件时，python会关闭之前的文件。
fileObject.close()
读取和写入文件
读取文件
file-like Object
-
file-like Object：向
open()函数返回的这种有个read()方法的对象，在Python中统称为 file-like Object的对象
- 除了file外，还可以是内存的字节流|网络流|自定义流等。
- file-like Object不要求从特定的类继承，只要写个
read()方法就行。
二进制文件
- 要读取二进制文件，比如图片，视频等，使用
rb模式打开文件。
with open(‘pic/mypic.jpg‘,‘rb‘) as f:
print(f.read())
字符编码
- 要读取非UTF-8的文本文件，需要给
open()函数传递encoding参数。errors参数表示要怎样处理编码异常
with open(‘text/mytext.txt‘,‘rb‘,encoding=‘gbk‘,errors=‘ignore‘) as f:
print(f.read())
写入文件
- 要写入文件，首先需要打开文件：
with open(file_name,‘w|wb‘) as f:
-
wb：写入二进制文件
-
w：写文本，以w模式写入文件时，如果文件已经存在，会直接覆盖（相当于删掉旧的），如果想要在后面接着写内容，使用a附加模式。
- 然后写入内容到文件：
-
f.write(str)：可以将任何字符串写入一个打开的文件中。
- python字符串不仅仅是二进制数据，还可以是文字；
StringIO和BytesIO
StringIO
-
StringIO：在内存中读写str
- 要把str写入
StringIO：
- 首先，导入StringIO模块：
from io import StringIO
- 接着，创建一个
StringIO：f = StringIO()
- 然后，写入str：
f.write(str)
-
getvalue()：获取写入的str
- 要读取
StringIO：
- 首先，导入StringIO模块：
from io import StringIO
- 接着，创建一个
StringIO：f = StringIO()
- 然后，读取：
f.read()|f.readline()|f.readlines()
#写入StringIO：
from io import StringIO
f = StringIO()
f.write(‘ssfaf‘)
#读取StringIO：
from io import StringIO
f = StringIO(‘ssssssssssssss‘)
print(f.read())
BytesIO
-
StringIO只能操作str，要操作二进制数据，就需要使用BytesIO
-
BytesIO：在内存中读写bytes
- 要把bytes写入
BytesIO：
- 首先，导入BytesIO模块：
from io import BytesIO
- 接着，创建一个
BytesIO：f = BytesIO()
- 然后，写入bytes：
f.write(bytes)
-
getvalue()：获取写入的bytes
- 要读取
BytesIO：
- 首先，导入BytesIO模块：
from io import BytesIO
- 接着，创建一个
BytesIO：f = BytesIO()
- 然后，读取：
f.read()|f.readline()|f.readlines()
序列化和反序列化
- 在程序的运行过程中，所有的变量都是在内存中，可以随时修改变量，但是一旦程序结束，变量所占用的内存就会被操作系统全部回收，如果没有把修改后的变量存储到磁盘（存储到磁盘 《===》 存储到文件）中，下次重新运行程序，变量又会被初始化为原先的。
**序列化 **
-
序列化：把变量从内存中变成可以存储或者可以传输的过程称之为序列化，即pickling。序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
- 在python中，序列化是由
pickle模块实现的。
import pickle
-
pickle.dumps()：把任意对象序列化成为一个bytes，然后就可以把bites写入文件中。
-
pickle.dump()：直接把对象序列化后写入一个file-like Object：
import pickle
# 把变量b序列化：把变量b变成可以存储为文件的bytes
d = ‘sd‘
a = pickle.dumps(d)
print(a)
# 把序列化后的内容存储到文件中：因为序列化变量b后，为bytes类型，所以使用“wb|rb”
f = open(‘pickle.txt‘,‘wb‘)
# f.write(a)
pickle.dump(d,f)
f.close()
- 当我们需要把对象从磁盘中读到内存中时，先把内容读到一个
bytes上，然后使用：
# 反序列
f = open(‘pickle.txt‘,‘rb‘)
d = pickle.load(f)
f.close()
print(d)
反序列化
-
反序列化：把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
JSON
- 如果想要在不同的编程语言中传递对象，就必须把对象序列化为标准格式，比如说JSON|XML，推荐JSON。
- JSON和Python内置的数据类型对照表：
| JSON类型 |
Python类型 |
| {} |
dict |
| [] |
list |
| "String" |
str |
| 1234.51 |
int|float |
| true|false |
True|False |
| null |
None |
import json
d =dict(name=‘si‘,age=14,sex=‘nan‘,qq=(124,24,555))
# 把python对象-->json：序列化
# help(json.dumps)
json_dumps_str = json.dumps(d)
print(json_dumps_str)
# help(json.dump)
# f = open(‘json.txt‘,‘w‘)
# json_dump_str = json.dump(d,f)
# print(json_dump_str)
# 把json格式-->python对象：反序列化
# help(json.loads)
python_loads_object = json.loads(json_dumps_str)
print(python_loads_object)
# help(json.load)
# f1 = open(‘json.txt‘,‘r‘)
# python_load_object = json.load(f1)
# print(python_load_object)
python基础--文件IO
标签：一个 readline 模式 byte 文件内容 with 决定 实现 默认
原文地址：https://www.cnblogs.com/bright-future/p/14729131.html