Python3之输入和输出_{x:.3f} python文件-优快云博客

本文链接：https://blog.youkuaiyun.com/wxhjw507/article/details/105669257

一、输出格式美化

Python中输出值的方式：

1、表达式语句
2、print()函数
3、文件对象的 write() 方法，标准输出文件可以使用sys.stdout引用

1、str()：函数返回一个用户易读的表达形式

语法：class str(object='')

参数：object - 对象

返回值：返回对象的字符串格式

2、repr()：生成一个解释器易读的表达式

语法：repr(object)

参数：object - 对象

返回值：返回对象的字符串格式

3、str.format()

语法：str.formant(value)

str.format()基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序，当不设置位置时，按默认位置处理

a）、!a (使用 ascii())，!s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化

b）、位置及关键字参数可以任意的结合

c）、可选项 : 和格式标识符可以跟着字段名，实现输出位数控制；在 : 后传入一个整数, 可以保证该区域至少有这么多的宽度

d）、通过变量名可实现不分开输出较长的格式化字符串

import math
"""
str()：函数返回一个用户易读的表达式
repr()：产生一个解释器易读的表达式
str.format()：格式化字符串函数，增强了字符串格式化的功能
"""
dictA = {'runoob': 'runoob.com', 'google': 'google.com'}
strA = 'Hello, Runoob\n'
print("str(strA):" , str(strA))
print("str(dictA):" , str(dictA))
# repr()函数可以保留字符串中的转义字符
print("repr(strA):" , repr(strA))
print("repr(dictA):" , repr(dictA))

# str.format()不设置指定位置，按默认顺序，括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换，
# 在括号中的数字用于指向传入对象在 format() 中的位置
print("str.format()不设置指定位置，按默认顺序：" , "{} {}".format('Hello' , 'Kobe'))
print("str.format()设置指定位置：" , "{0} {1} {0}".format('Hello' , 'Kobe'))

# 通过字典设置参数
player = {"name":"Kobe" , "number":24}
print("通过字典设置参数：" , "姓名:{name} , 球衣号码:{number}".format(** player))

# 通过列表索引设置参数：
# 为了读取列表中完整数据，format()必须传入必需参数listplayer，且"0" 是必须的，0[i]代表列表中元素的索引
# formant()传入可变参数(* listplayer)时，'科比'被拆成"科"和"比"传入
listplayerA = ['科比', '得分后卫' , "杜兰特" , "小前锋"]
listplayerB = [['科比', '得分后卫' , "杜兰特" , "小前锋"] , ['乔丹', '得分后卫' , "詹姆斯" , "小前锋"]]
# "0" 是必须的
# 列表listplayerA以必填参数(listplayerA)传入后为：['科比', '得分后卫' , "杜兰特" , "小前锋"]，
# 列表作为一个整体，只算一个元素，元素包含四个字符串子元素
print("通过列表索引设置参数，必填参数，取listplayerA[2]和listplayerA[3]：" , '姓名：{0[2]} , 位置：{0[3]}'.format(listplayerA))
# 列表listplayerB以必填参数(listplayerBA)传入后为：[['科比', '得分后卫' , "杜兰特" , "小前锋"] , ['乔丹', '得分后卫' , "詹姆斯" , "小前锋"]]，
# 列表作为一个整体，算一个元素，元素包含两个子列表元素，子列表元素再包含四个字符串子元素
print("通过列表索引设置参数，必填参数，取listplayerB第二个子列表的[2]和[3]元素：" , '姓名：{0[1][2]} , 位置：{0[1][3]}'.format(listplayerB))
# 列表listplayerA以可变参数(* listplayerA)传入后为：[['科','比'], ['得','分','后','卫'] , ['杜','兰','特'] , ['小','前','锋']]
print("通过列表索引设置参数，可变参数listplayerA：" , '姓名：{1[2]} , 位置：{1[3]}'.format(* listplayerA))
# 列表listplayerB以可变参数(* listplayerB)传入后为：[['科比', '得分后卫' , "杜兰特" , '小前锋'] , ['乔丹', '得分后卫' , "詹姆斯" , "小前锋"]]
print("通过列表索引设置参数，可变参数listplayerB：" , '姓名：{1[0]} , 位置：{1[1]}'.format(* listplayerB))

# 元组的 format 用法
tupplayer = ('科比', '得分后卫' , "杜兰特" , "小前锋")
# {2}和{3}分别指元组的索引位置，对应"杜兰特"和"小前锋"
print("元组的 format 用法：" , "姓名：{2} , 球衣号码：{3}".format(* tupplayer))

# 若format() 中使用了关键字参数, 它的值会指向使用该名字的参数，与参数位置无关
print("我最喜欢的球星是{name}，他的球衣号码是{number}".format(number = 24 , name = '科比'))

# 位置及关键字参数可以任意的结合
print("我最喜欢的球星是{0}，他的球衣号码是{1}，他效力于{team}".format('科比' , 24 , team = 'Lakers'))

# !a (使用 ascii())，!s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化
print("常量PI的值为：{}".format(math.pi))
print("常量PI的值为：{!r}".format(math.pi))

# 可选项 : 和格式标识符可以跟着字段名，实现输出位数控制；在 : 后传入一个整数, 可以保证该区域至少有这么多的宽度
print("常量PI的值为：{0:.3f}".format(math.pi)) # 意为保留小数点后5位数字
playerC = {'name':"科比" , 'number':"24", 'Team':'Lakers'}
for i , j in playerC.items():
    print("{0:10} --- {1:10}".format(i , j))

# 通过变量名可实现不分开输出较长的格式化字符串
# 方法一：传入一个字典, 然后使用方括号 [] 来访问键值
table = {'科比': 24 , '乔丹': 23, '库里': 30}
print("科比:{0[科比]:d} , 库里:{0[库里]:d} , 乔丹:{0[乔丹]:d}".format(table))
# 方法二：变量前使用 ** 来实现不分开输出较长的格式化字符串
print("科比:{科比:d} , 库里:{库里:d} , 乔丹:{乔丹:d}".format(** table))

str(strA): Hello, Runoob

str(dictA): {'runoob': 'runoob.com', 'google': 'google.com'}
repr(strA): 'Hello, Runoob\n'
repr(dictA): {'runoob': 'runoob.com', 'google': 'google.com'}
str.format()不设置指定位置，按默认顺序： Hello Kobe
str.format()设置指定位置： Hello Kobe Hello
通过字典设置参数： 姓名:Kobe , 球衣号码:24
通过列表索引设置参数，必填参数，取listplayerA[2]和listplayerA[3]： 姓名：杜兰特 , 位置：小前锋
通过列表索引设置参数，必填参数，取listplayerB第二个子列表的[2]和[3]元素： 姓名：詹姆斯 , 位置：小前锋
通过列表索引设置参数，可变参数listplayerA： 姓名：后 , 位置：卫
通过列表索引设置参数，可变参数listplayerB： 姓名：乔丹 , 位置：得分后卫
元组的 format 用法： 姓名：杜兰特 , 球衣号码：小前锋
我最喜欢的球星是科比，他的球衣号码是24
我最喜欢的球星是科比，他的球衣号码是24，他效力于Lakers
常量PI的值为：3.141592653589793
常量PI的值为：3.141592653589793
常量PI的值为：3.142
name       --- 科比        
number     --- 24        
Team       --- Lakers    
科比:24 , 库里:30 , 乔丹:23
科比:24 , 库里:30 , 乔丹:23

二、旧式字符串格式化

% 操作符也可以实现字符串格式化

import math
"""
旧式字符串格式化
% 操作符也可以实现字符串格式化
"""
print("我最喜欢的球星是%s , 他效力于%s" % ("科比" , '湖人'))
print("PI的值为：%6.4f" % (math.pi)) # 意思是一共输出6位数字，保留小数点后4位

我最喜欢的球星是科比 , 他效力于湖人
PI的值为：3.1416

三、读取键盘输入

input() 内置函数从标准输入中读入一行文本，默认的标准输入是键盘

同时input 可以接收一个Python表达式作为输入，并将运算结果返回

"""
input() 内置函数从标准输入中读入一行文本，默认的标准输入是键盘
同时input() 可以接收一个Python表达式作为输入，并将运算结果返回
"""
strA = input("请输入一句话表达你对祖国的热爱之情：")
print("你输入的一句话是：" , strA)
print(input(1 + 1))

请输入一句话表达你对祖国的热爱之情：我爱你，我的祖国
你输入的一句话是： 我爱你，我的祖国
2

四、读写文件

Python中使用open()函数实现文件的读写操作，返回一个 file 对象

语法：

open(name , mode , buffering)

参数：

name : 包含访问的文件名称的字符串值；
mode : mode 决定了打开文件的模式：只读，写入，追加等。这个参数是选填项，默认文件访问模式为只读(r)；
buffering : 如果 buffering(缓存) 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果 buffering 的值设为大于 1 的整数，表明了这就是寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认；

模式	说明
r	只读，文件的指针会放在文件的开头，，如果文件不存在时报错，open()函数的默认模式
rb	二进制只读，文件的指针放在文件的开头
r+	读写，文件的指针放在文件的开头
rb+	二进制读写，文件的指针放在文件的开头
w	只写，如果文件已存在，从头开始编辑，删除之前文件的内容，如果文件不存在，创建新文件
wb	二进制只写，如果文件已存在，从头开始编辑，删除之前文件的内容，如果文件不存在，创建新文件
w+	读写，如果文件已存在，从头开始编辑，删除之前文件的内容，如果文件不存在，创建新文件
wb+	二进制读写，如果文件已存在，从头开始编辑，删除之前文件的内容，如果文件不存在，创建新文件
a	追加，文件指针将会放在文件的末尾，如文件已存在，新写入内容存放在旧内容之后，如文件不存在，创建新文件
ab	二进制追加，文件指针将会放在文件的末尾，如文件已存在，新写入内容存放在旧内容之后，如文件不存在，创建新文件
a+	读写，文件指针将会放在文件的末尾，如文件已存在，新写入内容存放在旧内容之后，如文件不存在，创建新文件
ab+	二进制追加，文件指针将会放在文件的末尾，如文件已存在，新写入内容存放在旧内容之后，如文件不存在，创建新文件

模式	r	r+	w	w+	a	a+
读	+	+		+		+
写		+	+	+	+	+
创建			+	+	+	+
覆盖			+	+
指针在开始	+	+	+	+
指针在结尾					+	+

"""
open()函数实现文件的读写操作，返回一个 file 对象
语法：
open(name , mode , buffering)
参数：
name : 包含访问的文件名称的字符串值；
mode : mode 决定了打开文件的模式：只读，写入，追加等。这个参数是选填项，默认文件访问模式为只读(r)；
buffering : 如果 buffering(缓存) 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。
如果 buffering 的值设为大于 1 的整数，表明了这就是寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认；
"""
# 创建一个文件时使用w或a，r只能读取文件，不能创建文件
filename = open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Runoob.txt" , 'w+' , buffering= 5)
# 文件里写入内容
filename.write("科比，你好")
# 关闭文件
filename.close()

# 读取文件内容，返回一个字符串
file = open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Runoob.txt" , 'r')
strA = file.read()
print("文件内容为：" , strA)
# 关闭文件
filename.close()

文件内容为： 科比，你好

五、文件对象的方法

1、read()方法

filename.read(size)方法从文件中读取指定字节数的内容，返回字符串或者字节对象，size用于规定从文件中读取的字节数大小，如果未给定或为负则读取文件里所有内容

语法：

fileObject.read(size)

参数：

size -- 从文件中读取的字节数

返回值：

返回从字符串中读取的字节(str型)

# 1、read()用于读取文件的内容
# 只读方式打开一个文件
RunboobFile = open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Kobe.txt" , 'r')
# 读取文件内容，size设置读取的字节数量
strFile = RunboobFile.read(1024)
# 输出读取文件内容
print(strFile)
# 打印文件路径
print(RunboobFile.name)
# 关闭文件读取
RunboobFile.close()

你好，科比
你好，老大
再见，曼巴
再见，青春
G:\Python\Runoob\ZX_16_输入和输出\Kobe.txt

2、readline()方法

filename.readline(size)方法用于从文件内读取整行，若size为一个非负参数，则返回一个指定大小的字节数，包括"\n"字符，

当size设置为负数或不设置时，默认读取第一行全部内容

语法：

fileObject.readline(size)

参数：

size -- 从文件中读取的字节数

返回值：

返回从字符串中读取的字节(str型)

# 2、readline()用于读取整行文件的内容
# 只读方式打开一个文件
RunboobFile = open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Kobe.txt" , 'r')
# 读取文件内容，size设置读取的字节数量，当设置为负数或不设置时，默认读取第一行全部内容
lineFile = RunboobFile.readline(-1)
# 输出读取文件内容
print(lineFile)
# 打印文件路径
print(RunboobFile.name)
# 关闭文件读取
RunboobFile.close()

科比，你好

G:\Python\Runoob\ZX_16_输入和输出\Runoob.txt

3、readlines()方法

filename.readlines()方法用于读取文件内所有行的内容(直到结束符 EOF停止)，返回一个列表对象，该列表可以用for...in...结构循环体处理，若遇到结束符 EOF，则返回空字符串

语法：

filename.readlines()

参数：

无

返回值：

返回文件所有行内容的列表(str型)

# 3、readlines()用于读取文件所有行的内容
# 只读方式打开一个文件
RunboobFile = open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Kobe.txt" , 'r')
# readlines()方法没有参数
linesFilelist = RunboobFile.readlines()
# for...in...循环处理输出内容，依次读取每行内容
for line in linesFilelist:
    # 去掉每行头尾空白
    print(line.strip())
# 关闭文件读取
RunboobFile.close()

你好，科比
你好，老大
再见，曼巴
再见，青春

4、 write()方法

file.write()方法用于向文件写入指定字符串

注意：

在文件关闭或缓冲区刷新前，字符串内容存储在缓冲区中，此时文件中无法看到写入的内容；
若文件打开模式带 b，则写入文件内容时，str (参数)要用 encode 方法转为 bytes 形式，否则报错TypeError: a bytes-like object is required, not 'str'；
若要写入内容不是字符串，则需要先进行转换，转换为字符串；
如果向文件末尾换行输入内容(不做读取操作)，则在Filename.seek(0, 2)后添加一行代码：File.write('\n')，该代码用于在文件最后一行换行，文件读取模式可选择r+、a和a+；若同时做读写操作时，文件读取模式仅可选择r+和a+；不可使用w或w+操作，因为w或w+会删除文件之前内容，覆盖添加

语法：

file.write(str)

参数：

str：写入文件的字符串

返回值：

返回写入字符串的长度(int型)

# 4、file.write()方法用于向文件写入指定字符串
# 读写方式打开一个文件
File = open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Kobe.txt" , 'a+' , encoding= 'utf-8')
strA = "传奇，永恒"
# 文件最后一行末尾
File.seek(0, 2)
# 换行符
File.write('\n')
# 写入str内容
print(type(File.write(strA)))
# 读取文件所有内容，第一行开始读取
File.seek(0,0)
for line in File.readlines():
    # 去掉每行头尾空白
    print(line.strip())
File.close()

<class 'int'>
你好，科比
你好，老大
再见，曼巴
再见，青春
传奇，永恒

# 若要写入内容不是字符串，则需要先进行转换，转换为字符串
DictA = {'姓名':'科比' , "球队":"湖人"}
# 读写方式打开一个文件
file = open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Kobe.txt" , 'a+' , encoding='utf-8')
# 定位到文件最后一行末尾
file.seek(0 ,2)
# 换行
file.write('\n')
# 写入字典内容，字典需要先进行转换为字符串
file.write(str(DictA))
# 定位到文件开头
file.seek(0 , 0)
# for循环读取文件内容
for line in file.readlines():
    # 去掉每行头尾空白
    print(line.strip())
file.close()

你好，科比
你好，老大
再见，曼巴
再见，青春
传奇，永恒
{'姓名': '科比', '球队': '湖人'}

5、tell()方法

file.tell()方法返回文件当前的位置，即文件指针当前的位置

语法：file.tell()

参数：无

返回值：文件指针当前的位置

# 5、tell()方法返回文件的当前位置，即文件指针当前位置
# 打开一个文件
file = open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Kobe.txt" , 'r+' , encoding='utf-8')
# 文件路径和名称
filename = file.name
print("文件名为：" , filename)
# 读取文件一行，并去除两头字符串的空白
line = file.readline().strip()
print("读取的文件内容为：" , line)
# 文件指针当前位置
print("文件指针当前位置为：" , file.tell())
file.close()

文件名为： G:\Python\Runoob\ZX_16_输入和输出\Kobe.txt
读取的文件内容为： Kobe Bryant
文件指针当前位置为： 13

6、seek()方法

file.seek()方法用于移动文件读取指针到指定位置

语法： file.seek(offset , whence)

参数：

offset -- 开始的偏移量，也就是代表需要移动偏移的字节数
whence -- 表示要从哪个位置开始偏移；可选，默认值为 0；如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾
文本文件中，假如没有使用b模式选项打开的文件，只允许从文件头开始计算相对位置，从文件尾计算时就会引发异常，打开方式后必须加一个b，即为rb、rb+、wb、wb+、ab、ab+

返回值：如果操作成功，返回新的文件当前位置；若操作失败，则返回-1

seek(x,0) ：从文件首行首字符开始往后移动 x 个字符
seek(x,1) ：从当前文件位置往后移动 x 个字符
seek(-x,2)：从文件的结尾往前移动 x 个字符

"""
# 6、file.seek()方法用于移动文件读取指针到指定位置
seek(x,0) ： 从文件首行首字符开始往后移动 x 个字符
seek(x,1) ： 从当前文件位置往后移动 x 个字符
seek(-x,2)：从文件的结尾往前移动 x 个字符
"""
# 打开一个文件
file = open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Kobe.txt" , 'a+' , encoding='utf-8')
# 从文件首行首字符开始往后移动 1 个字符
file.seek(1 , 0)
# 读取文件内容
print("从文件首行首字符往后移动 4 个字符:" , file.readline().strip())
print("当前指针位置为：" , file.tell())
file.close()

从文件首行首字符往后移动 4 个字符: obe，Bryant
当前指针位置为： 15

7、close()方法

file.close()方法用于关闭一个已打开的文件

关闭后的文件不能再进行读写操作，否则会触发 ValueError 错误：ValueError: I/O operation on closed file；
close()方法允许多次被调用
当处理一个文件对象时, 使用 with 关键字是非常好的方式，在with结束后, 它会帮你关闭文件；
close()方法无参数和返回值

语法：file.close()

# 7、file.close()方法用于关闭一个已打开的文件
with open("G:\\Python\\Runoob\\ZX_16_输入和输出\\Kobe.txt" , "rb+" ) as file:
    # 文本文件中，假如没有使用b模式选项打开的文件，只允许从文件头开始计算相对位置，从文件尾计算时就会引发异常，
    # 打开方式后必须加一个b，即为rb、rb+、wb、wb+、ab、ab+
    # 指针指向文件最后一行，向前两个字符
    file.seek(-2 , 2)
    print(file.readline().strip())
# with结束后自动关闭文件
print(file.closed)

b'ry'
True

8、pickle模块

Python的pickle模块实现了基本的数据序列和反序列化

pickle模块使用的数据格式是python专用的，能够把Python对象直接保存到文件，而不需要把他们转化为字符串，也不用底层的文件访问操作把它们写入到一个二进制文件中；
通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象；

Pickle模块中最常用的函数：

A、pickle.dump(obj , file , protocol)

功能：接受一个文件句柄和一个数据对象obj作为參数，把数据对象obj以特定的格式保存到给定的文件file里；pickle.dump()可以实现将数据转化为pickled对象，然后存入到本地文件（自动实现）

参数：

obj：想要序列化的obj对象；
file:文件名称；
protocol：序列化使用的协议。如果该项省略，则默认为0。如果为负值或HIGHEST_PROTOCOL，则使用最高的协议版本；

返回值：None

dump序列化一个数据步骤：

1、导入pickle模块

import pickle

2、定义需要序列化的数据序列

3、创建一个可写的文件对象

4、通过pickle.dump(obj , file , protocol)将数据序列化后写入文件内

5、关闭文件

# pickle.dump()序列化一个数据步骤：
#1、pickle.dump()函数接受一个文件句柄和一个数据对象obj作为參数，把数据对象obj以特定的格式保存到给定的文件file里
# 步骤1：导入pickle模块
import pickle
# 步骤2：定义一个数据
listA = ["科比" , '库里']
# pickle.dump() 将listA数据以特定的格式保存到给定的文件file里
# 步骤3：创建一个可写的文件对象file
File_dump = open(".\\a.txt" , 'ab+')
# 步骤4：将数据以设定的协议保存到file里，pickle.dump()方法返回值为none
# pickle.dump()可以实现将数据转化为pickled对象，然后存入到本地文件（自动实现）
file_dump = pickle.dump(listA, File_dump , pickle.HIGHEST_PROTOCOL)
# pickle.dump()方法返回值为none
print("pickle.dump()方法返回值为：" , file_dump)
print("pickle.dump()方法的返回类型为：" , type(file_dump))
File_dump.close()

pickle.dump()方法返回值为： None
pickle.dump()方法的返回类型为： <class 'NoneType'>

B、pickle.dumps(obj , protocol)

功能：将obj对象序列化为string形式，而不是存入文件中；pickle.dumps()仅仅是进行序列化操作，处理的数据（内存）>>pickled对象或文件

参数：
obj：想要序列化的obj对象；
protocal：序列化使用的协议。如果该项省略，则默认为0。如果为负值或HIGHEST_PROTOCOL，则使用最高的协议版本；

返回值：bytes型字符串

# pickle.dumps()序列化一个数据步骤：
#1、pickle.dumps()函数将obj对象序列化为string形式，而不是存入文件中；
# pickle.dumps()仅仅是进行序列化操作，处理的数据（内存）>>pickled对象或文件
# 步骤1：导入pickle模块
import pickle
# 步骤2：定义一个数据
listA = ['12', '34', '56']
# 步骤3：pickle.dumps() 仅仅是进行序列化操作，处理的数据（内存）>>pickled对象或文件
str_dumps = pickle.dumps(listA, pickle.HIGHEST_PROTOCOL)
# pickle.dumps()方法返回值是一个bytes型字符串
print("pickle.dumps()方法返回值为：" , str_dumps)
print("pickle.dumps()方法的返回类型为：" , type(str_dumps))

pickle.dumps()方法返回值为： b'\x80\x04\x95\x14\x00\x00\x00\x00\x00\x00\x00]\x94(\x8c\x0212\x94\x8c\x0234\x94\x8c\x0256\x94e.'
pickle.dumps()方法的返回类型为： <class 'bytes'>

C）、pickle.load(file)

功能：pickle.load(file)方法将file中的对象序列化读出，file一定是pickle.dump()序列化后的文件，否则报错

注意：pickle.load(file)文件中的数据，不需要执行file.read()方法

参数：

file：文件名称

返回值：返回值类型与序列化数据类型一致

# pickle.dump()序列化一个数据步骤：
#1、pickle.dump()函数接受一个文件句柄和一个数据对象obj作为參数，把数据对象obj以特定的格式保存到给定的文件file里
# 步骤1：导入pickle模块
import pickle
# 步骤2：定义一个数据
listA = ["科比" , '库里']
# pickle.dump() 将listA数据以特定的格式保存到给定的文件file里
# 步骤3：创建一个可写的文件对象file
File_dump = open(".\\a.txt" , 'ab+')
# 步骤4：将数据以设定的协议保存到file里，pickle.dump()方法返回值为none
# pickle.dump()可以实现将数据转化为pickled对象，然后存入到本地文件（自动实现）
file_dump = pickle.dump(listA, File_dump , pickle.HIGHEST_PROTOCOL)
# pickle.dump()方法返回值为none
print("pickle.dump()方法返回值为：" , file_dump)
print("pickle.dump()方法的返回类型为：" , type(file_dump))
File_dump.close()


# pickle.load()反序列化一个数据步骤：
# 步骤1：导入pickle模块
import pickle
# 步骤2：创建一个可读的文件对象
file_load = open(".\\a.txt" , 'rb+')
# 步骤3：pickle.load(file)读取文件file内容
str_load = pickle.load(file_load)
print("pickle.load()方法返回值为：" , str_load )
# 返回值类型与序列化数据类型一致，序列化数据为list型，返回型也是list型
print("pickle.load()方法的返回类型为：" , type(str_load))
file_load.close()

pickle.dump()方法返回值为： None
pickle.dump()方法的返回类型为： <class 'NoneType'>
pickle.load()方法返回值为： ['科比', '库里']
pickle.load()方法的返回类型为： <class 'list'>

D）、pickle.loads() 方法

函数的功能：pickle.loads(file/string)从文件中读出序列化前的obj对象，文件一定是pickle.dumps()序列化后的文件，否则报错

参数：
file：文件名称

注意：如果pickle.loads()函数反序列化输出pickle.dump()函数序列化生成的文件时，需要将文件中数据读取出来，需要执行file.read()方法；如果反序列化输出pickle.dumps()函数序列化生成的字符串时，不需要read()方法(因为pickle.dumps()函数将obj对象序列化为string形式，而不是存入文件中)

# pickle.dump()序列化一个数据步骤：
#1、pickle.dump()函数接受一个文件句柄和一个数据对象obj作为參数，把数据对象obj以特定的格式保存到给定的文件file里
# 步骤1：导入pickle模块
import pickle
# 步骤2：定义一个数据
listA = ["科比" , '库里']
# pickle.dump() 将listA数据以特定的格式保存到给定的文件file里
# 步骤3：创建一个可写的文件对象file
File_dump = open(".\\a.txt" , 'ab+')
# 步骤4：将数据以设定的协议保存到file里，pickle.dump()方法返回值为none
# pickle.dump()可以实现将数据转化为pickled对象，然后存入到本地文件（自动实现）
file_dump = pickle.dump(listA, File_dump , pickle.HIGHEST_PROTOCOL)
# pickle.dump()方法返回值为none
print("pickle.dump()方法返回值为：" , file_dump)
print("pickle.dump()方法的返回类型为：" , type(file_dump))
File_dump.close()


# loads()反序列化一个数据步骤：
# 步骤1：导入pickle模块
import pickle
# 创建一个可写文件
file_loads = open(".\\a.txt" , "rb+")
# 步骤3：pickle.loads(file)读取文件file内容，使用loads函数需要将文件中数据读取出来
str_loads = pickle.loads(file_loads.read())
print("pickle.loads()方法返回值为：" , str_loads )
# 返回值类型与序列化数据类型一致，序列化数据为list型，返回型也是list型
print("pickle.loads()方法的返回类型为：" , type(str_loads))

pickle.dump()方法返回值为： None
pickle.dump()方法的返回类型为： <class 'NoneType'>
pickle.loads()方法返回值为： ['科比', '库里']
pickle.loads()方法的返回类型为： <class 'list'>

# pickle.dumps()序列化一个数据步骤：
#1、pickle.dumps()函数将obj对象序列化为string形式，而不是存入文件中；
# pickle.dumps()仅仅是进行序列化操作，处理的数据（内存）>>pickled对象或文件
# 步骤1：导入pickle模块
import pickle
# 步骤2：定义一个数据
listA = ['12', '34', '56']
# 步骤3：pickle.dumps() 仅仅是进行序列化操作，处理的数据（内存）>>pickled对象或文件
str_dumps = pickle.dumps(listA, pickle.HIGHEST_PROTOCOL)
# pickle.dumps()方法返回值是一个bytes型字符串
print("pickle.dumps()方法返回值为：" , str_dumps)
print("pickle.dumps()方法的返回类型为：" , type(str_dumps))

# pickle.loads()反序列化一个数据步骤：
# 步骤1：pickle.loads(string)读取字符串string内容
str_load = pickle.loads(str_dumps)
print("pickle.loads()方法返回值为：" , str_load )
# 返回值类型与序列化数据类型一致，序列化数据为list型，返回型也是list型
print("pickle.loads()方法的返回类型为：" , type(str_load))

pickle.dumps()方法返回值为： b'\x80\x04\x95\x14\x00\x00\x00\x00\x00\x00\x00]\x94(\x8c\x0212\x94\x8c\x0234\x94\x8c\x0256\x94e.'
pickle.dumps()方法的返回类型为： <class 'bytes'>
pickle.loads()方法返回值为： ['12', '34', '56']
pickle.loads()方法的返回类型为： <class 'list'>