Python-文件操作

1. 文件基本使用
2. with语句
3. json
4. pickle
5. yaml

1、文件基本操作

1.1 打开文件

f = open(name,mode='r',encoding='utf-8')	# 打开文件,文本文件
"""
name: 文件名，也可以是文件的的路径。
mode：打开模式，默认'r'，只读模式。
encoding：指定编码格式
ps：r、r+、w、w+、a、a+
"""
f = open(name,mode='rb')					# 打开文件，二进制，不需要编码
"""
所有模式都是在后面加b，且所有模式的权限与文本文件一样
ps：rb、rb+、wb、wb+、ab、ab+
"""

1.2 打开文件模式，权限表：

1.3 文件的方法

f1 = open(name,mode='r',encoding='utf-8')		# 只读模式打开文件
f2 = open(name,mode='wb')						# 只写模式打开文件
1、读取
1.1  读取全部内容
f1.read(n)
# n: 可以指定读取的字节数，不指定则全部读取

1.2  读取整行内容，包括 "\n" 字符
f1.readline(size)
# size: 指定读取的字节数，不指定则读取整行

1.3  读取所有行，将每一行放到列表里，并返回列表
f1.readlines()

2、 写入
2.1	写入字符串
f2.write(n)
# n: 写入内容，文本模式类型为字符串，二进制模式需要编码成二进制数

2.2 写入可迭代对象
f2.writelines(n)
# n: 写入内容，可迭代对象里的内容：文本模式类型为字符串，二进制模式需要编码成二进制数

3、控制指针
3.1  移动指针
f1.seek(offset,whence=0): 
"""
offset: 需要移动偏移的字节数
whence: 模式控制默认是0
0: 默认的模式,该模式代表指针移动的字节数是以文件开头为参照的
1: 该模式代表指针移动的字节数是以当前所在的位置为参照的
2: 该模式代表指针移动的字节数是以文件末尾的位置为参照的
强调:其中0模式可以在t或者b模式使用,而1跟2模式只能在b模式下用
"""

3.2 获取指针的位置
f1.tell()

4、关闭文件和刷新
4.1  刷新: 立刻将文件内容从内存刷到硬盘
f1.flush()

4.2 关闭文件
f1.close()
f2.close()

2、with语句

with语可以管理上下文

# 在执行完子代码块后，with 会自动执行f.close()
with open('a.txt','w',encoding='utf-8') as f:
    pass 

3、json

json序列化是字符串类型，使用 json 需要先导入json

import json
>>> a = {'a': 1,'b': [1,'2'], 'c': (1,2)}
1、序列化对象并写入文件里
json.dump(obj,fp)				
"""
obj: 需要序列化的对象
fp：需要写入的文件对象
"""
>>> with open('1.json','w',encoding='utf-8') as f:	
		json.dump(a,f)									# 序列化对象a并写入文件
>>> with open('1.json','w',encoding='utf-8') as f:
		a = f.read()									# 读取出来
		print(a)
{"a": 1, "b": [1, "2"], "c": [1, 2]}

2、序列化对象
json.dumps(obj)
# obj: 需要序列化的对象
>>> json.dumps(a)										# 序列换对象a 
'{"a": 1, "b": [1, "2"], "c": [1, 2]}'

3、反序列化
json.loads(s)
# s:json格式数据
>>> a = '{"a": 1, "b": [1, "2"], "c": [1, 2]}'
>>> json.loads(a)										# 反序列化
{'a': 1, 'b': [1, '2'], 'c': [1, 2]}

4、从文件读出并反序了化
json.load(fp)
# fp: 文件对象
>>> with open("1.json", "r", encoding='utf-8') as f:
        data = json.load(f)								# 从文件读出并反序了化
    	print(data)
{'a': 1, 'b': [1, '2'], 'c': [1, 2]}

4、pickle

pickle序列化的是二进制类型，使用方法和json一样，使用前也需要先导入pickle

import pickle
1、序列化
pickle.dump(obj,file),pickle.dumps(obj)
"""
obj: 需要序列化的对象
file：需要写入的文件
"""
>>> a = {'a': 1, 'b': [1, '2'], 'c': [1, 2]}
>>> pickle.dumps(a)									# 序列化
b'\x80\x04\x95%\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x01a\x94K\x01\x8c\x01b\x94]\x94(K\x01\x8c\x012\x94e\x8c\x01c\x94]\x94(K\x01K\x02eu.'
>>> with open('1.pkl','wb') as f:
		pickle.dump(a,f)							# 序列化并写入文件
>>> with open('1.pkl','rb') as f:
		data = f.read()
		print(data)
b'\x80\x04\x95%\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x01a\x94K\x01\x8c\x01b\x94]\x94(K\x01\x8c\x012\x94e\x8c\x01c\x94]\x94(K\x01K\x02eu.'

2、反序列化
pickle.load(file),pickle.loads(data)
"""
data: pickle数据类型
file：文件对象
"""
>>> data = b'\x80\x04\x95%\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x01a\x94K\x01\x8c\x01b\x94]\x94(K\x01\x8c\x012\x94e\x8c\x01c\x94]\x94(K\x01K\x02eu.'
>>> pickle.loads(data)								# 反序列化
{'a': 1, 'b': [1, '2'], 'c': [1, 2]}
>>> with open('1.pkl','rb') as f:
		data = pickle.load(f)						# 从文件读出并反序列化
		print(data)
{'a': 1, 'b': [1, '2'], 'c': [1, 2]}

5、yaml

yaml支持三种数据结构

1. 对象：键值对的集合，对应python的字典，例如：a: 1 ==> {“a”: 1}
2. 数组：一组按次序排列的值，对应python的列表，例如：- a ==> [“a”]
3. 纯量：单个的、不可再分的值，对应python的字符串，整数，例如：1 ==> 1

ps：对象的冒号后面必须有个空格，数组的杠后面必须有个空格

1. 安装：pip install pyyaml
2. 序列化：yaml.dump(data, stream=None)
3. 反序列化：yaml.load(stream, Loader=yaml.FullLoader)

import yaml

# 序列化
with open('./test.yaml', 'w',encoding='utf8') as f:
    yaml.dump({"data":1}, f)			# 将python格式转化成yaml格式并写入文件内

res3 = yaml.dump({"data":1})			# 将python格式转化成yaml格式的字符串
print(res3)			# data: 1


# 反序列化
with open('./test.yaml', encoding='utf8') as f:
    res1 = yaml.load(f, Loader=yaml.FullLoader)			# 直接从文件内读取转换成python格式

res2 = yaml.load('a: 1', Loader=yaml.FullLoader)			# 将字符串转换成python格式
print(res1)			# {'data': 1}
print(res2)			# {'a': 1}