二进制文件包括文本文件，这里讨论的是狭义上的二进制文件与文本文件的比较：

1. 能存储的数据类型不同
   文本文件只能存储char型字符变量。二进制文件可以存储char/int/short/long/float/……各种变量值。
2. 每条数据的长度
   文本文件每条数据通常是固定长度的。以ASCII为例，每条数据(每个字符)都是1个字节。进制文件每条数据不固定。如short占两个字节，int占四个字节，float占8个字节……
3. 读取的软件不同
   文本文件编辑器就可以读写。比如记事本、NotePad++、Vim等。二进制文件需要特别的解码器。比如bmp文件需要图像查看器，rmvb需要播放器……
4. 操作系统对换行符(‘\n’)的处理不同（不重要）
   文本文件，操作系统会对’\n’进行一些隐式变换，因此文本文件直接跨平台使用会出问题。
   在Windows下，写入’\n’时，操作系统会隐式的将’\n’转换为”\r\n”，再写入到文件中；读的时候，会把“\r\n”隐式转化为’\n’，再读到变量中。
   在Linux下，写入’\n’时，操作系统不做隐式变换。
   二进制文件，操作系统不会对’\n’进行隐式变换，很多二进制文件（如电影、图片等）可以跨平台使用。

从存储方式来说，文件在磁盘上的存储方式都是二进制形式，所以，文本文件其实也应该算二进制文件。先从他们的区别来说，虽然都是二进制文件，但是二进制代表的意思不一样。打个比方，一个人，我们可以叫他的大名，可以叫他的小名，但其实都是代表这个人。二进制读写是将内存里面的数据直接读写入文本中，而文本呢，则是将数据先转换成了字符串，再写入到文本中。

要弄明白二者的区别，需要知道文件的读写过程。以读文件为例，

实际上是磁盘 》》 文件缓冲区》》应用程序内存空间这两个转化过程。我们说“文本文件和二进制文件没有区别”，实际上针对的是第一个过程；既然没有区别，那么打开方式不同，为何显示内容就不同呢？这个区别实际上是第二个过程造成的。

文件实际上包括两部分，控制信息和内容信息。纯文本文件仅仅是没有控制格式信息罢了；

实际上也是一种特殊的二进制文件。所以，我们很难区分二者的不同，因为他们的概念上不是完全互斥的。我们说文本文件是特殊的二进制文件，是因为文本文件实际上的解释格式已经确定了：ASCII或者unicode编码。文本文件的一个缺点是，它的熵往往较低，也就是说，其实本可以用更小的存储空间记录这些信息。比如，文本文件中的一个数字65536，需要用5个字节来存储；但是用二进制格式，采用int存储，仅仅需要2个字节。而二进制文件elf和bmp等，都往往有一个head，告诉你文件信息和解释方式。

记事本支持文本文件而不支持二进制文件，所以如果你用记事本打开文本文件那么一切正常，如果打开的是二进制文件就会出现乱码。但也有不乱码的地方，你会注意到那些地方都是字符编码的，而对于int、double等类型所对应的值都是乱码的，这是由于记事本只能够识别字符类型，而无法识别其他类型。

1、二进制文件是把内存中的数据按其在内存中的存储形式原样输出到磁盘上存放，也就是说存放的是数据的原形式。

2、文本文件是把数据的终端形式的二进制数据输出到磁盘上存放，也就是说存放的是数据的终端形式。

字符数据本身在内存中就经过了编码，所以无论是二进制还是文本形式都是一样的，而对于非字符数据来说，例如inti=10；如果用二进制来进行存储的话为1010，但是如果需要用文本形式来进行存储的话就必须进行格式化编码（对1和0分别编码，即形式为‘1’和‘0’分别对应的码值）。

---

一、文本文件与二进制文件的定义

大家都知道计算机的存储在物理上是二进制的，所以文本文件与二进制文件的区别并不是物理上的，而是逻辑上的。这两者只是在编码层次上有差异。简单来说，文本文件是基于字符编码的文件，常见的编码有ASCII编码，UNICODE编码等等。二进制文件是基于值编码的文件，你可以根据具体应用，指定某个值是什么意思（这样一个过程，可以看作是自定义编码。

从上面可以看出文本文件基本上是定长编码的(也有非定长的编码如UTF-8)。而二进制文件可看成是变长编码的，因为是值编码嘛，多少个比特代表一个值，完全由你决定。大家可能对BMP文件比较熟悉，就拿它举例子吧，其头部是较为固定长度的文件头信息，前2字节用来记录文件为BMP格式，接下来的8个字节用来记录文件长度，再接下来的4字节用来记录bmp文件头的长度。

二、文本文件与二进制文件的存取

文本工具打开一个文件的过程是怎样的呢？拿记事本来说，它首先读取文件物理上所对应的二进制比特流，然后按照你所选择的解码方式来解释这个流，然后将解释结果显示出来。一般来说，你选取的解码方式会是ASCII码形式（ASCII码的一个字符是8个比特），接下来，它8个比特8个比特地来解释这个文件流。例如对于这么一个文件流”01000000_01000001_01000010_01000011”(下划线”_”，为了增强可读性手动添加的)，第一个8比特”01000000”按ASCII码来解码的话，所对应的字符是字符”A”，同理其它3个8比特可分别解码为”BCD”，即这个文件流可解释成“ABCD”，然后记事本就将这个“ABCD”显示在屏幕上。

事实上，世界上任何东西要与其他东西通信会话，都存在一个既定的协议，既定的编码。人与人之间通过文字联络，汉字“妈”代表生你的那个人，这就是一种既定的编码。但注意到这样一种情况，汉字“妈”在日本文字里有可能是你生下的那个人，所以当一个中国人A与日本B之间用“妈”这个字进行交流，出现误解就很正常的。用记事本打开二进制文件与上面的情况类似。记事本无论打开什么文件都按既定的字符编码工作（如ASCII码），所以当他打开二进制文件时，出现乱码也是很必然的一件事情了，解码和译码不对应嘛。例如文件流”00000000_00000000_00000000_00000001”可能在二进制文件中对应的是一个四字节的整数int 1，在记事本里解释就变成了”NULL_NULL_NULL_SOH”这四个控制符。

文本文件的存储与其读取基本上是个逆过程。而二进制文件的存取显然与文本文件的存取差不多，只是编／解码方式不同而已。

三、文本文件与二进制文件的优缺点

因为文本文件与二进制文件的区别仅仅是编码上不同，所以他们的优缺点就是编码的优缺点，这个找本编码的书来看看就比较清楚了。一般认为，文本文件编码基于字符定长，译码容易些；二进制文件编码是变长的，所以它灵活，存储利用率要高些，译码难一些（不同的二进制文件格式，有不同的译码方式）。关于空间利用率，想想看，二进制文件甚至可以用一个比特来代表一个意思(位操作)，而文本文件任何一个意思至少是一个字符。

在windows下,文本文件不一定是一ASCII来存贮的,因为ASCII码只能表示128的标识,你打开一个txt文档,然后另存为,有个选项是编码,可以选择存贮格式,一般来说UTF-8编码格式兼容性要好一些.而二进制用的计算机原始语言,不存贮兼容性. 很多书上还认为，文本文件的可读性要好些，存储要花费转换时间(读写要编译码)，而二进制文件可读性差，存储不存在转换时间（读写不要编解码，直接写值）．这里的可读性是从软件使用者角度来说的，因为我们用通用的记事本工具就几乎可以浏览所有文本文件，所以说文本文件可读性好；而读写一个具体的二进制文件需要一个具体的文件解码器，所以说二进制文件可读性差，比如读BMP文件，必须用读图软件。

而这里的存储转换时间应该是从编程的角度来说的，因为有些操作系统如windows需要对回车换行符进行转换(将”\n”，换成”\r\n”，所以文件读写时，操作系统需要一个一个字符的检查当前字符是不是”\n”或”\r\n”).这个在存储转换在Linux操作系统中并不需要，当然，当在两个不同的操作系统上共享文件时，这种存储转换又可能出来。

---

文本文件是一种计算机文件，它是一种典型的顺序文件，其文件的逻辑结构又属于流式文件。

特别的是，文本文件是指以ASCII码方式(也称文本方式)存储的文件，更确切地说，英文、数字等字符存储的是ASCII码，而汉字存储的是机内码。文本文件中除了存储文件有效字符信息（包括能用ASCII码字符表示的回车、换行等信息）外，不能存储其他任何信息。

文本文件是一种由若干行字符构成的计算机文件。文本文件存在于计算机文件系统中。通常，通过在文本文件最后一行后放置文件结束标志来指明文件的结束。文本文件是指一种容器，而纯文本是指一种内容。文本文件可以包含纯文本。一般来说，计算机文件可以分为两类：文本文件和二进制文件。

只含有ASCII字符的文本文件可以在Unix、Macintosh、Microsoft Windows、DOS和其它操作系统之间自由交互，而其它格式的文件是很难做到这一点的。但是，在这些操作系统中，换行符并不相同，处理非ASCII字符的方式也不一致。

.txt是包含极少格式信息的文字文件的扩展名。.txt格式并没有明确的定义，它通常是指那些能够被系统终端或者简单的文本编辑器接受的格式。任何能读取文字的程序都能读取带有.txt扩展名的文件，因此，通常认为这种文件是通用的、跨平台的。

在英文文本文件中，ASCII字符集是最为常见的格式，而且在许多场合，它也是默认的格式。对于带重音符号的和其它的非ASCII字符，必须选择一种字符编码。在很多系统中，字符编码是由计算机的区域设置决定的。常见的字符编码包括支持许多欧洲语言的ISO 8859-1。

由于许多编码只能表达有限的字符，通常它们只能用于表达几种语言。Unicode制定了一种试图能够表达所有已知语言的标准，Unicode字符集非常大，它囊括了大多数已知的字符集。Unicode有多种字符编码，其中最常见的是UTF-8，这种编码能够向后兼容ASCII，相同内容的的ASCII文本文件和UTF-8文本文件完全一致。

微软的MS-DOS和Windows采用了相同的文本文件格式，它们都使用CR和LF两个字符作为换行符，这两个字符对应的ASCII码分别为13和10。通常，最后一行文本并不以换行符(CR-LF标志)结尾，包括记事本在内的很多文本编辑器也不在文件的最后添加换行符。

大多数Windows文本文件使用ANSI、OEM或者Unicode编码。Windows所指的ANSI编码通常是1字节的ISO-8859编码，不过对于像中文、日文、朝鲜文这样的环境，需要使用2字节字符集。在过渡至Unicode前，Windows一直用ANSI作为系统默认的编码。而OEM编码，也是通常所说的MS-DOS代码页，是IBM为早期IBM个人电脑的文本模式显示系统定义的。在全屏的MS-DOS程序中同时使用了图形的和按行绘制的字符。新版本的Windows可以使用UTF-16LE和UTF-8之类的Unicode编码。

由于结构简单，文本文件被广泛用于记录信息。它能够避免其它文件格式遇到的一些问题。此外，当文本文件中的部分信息出现错误时，往往能够比较容易的从错误中恢复出来，并继续处理其余的内容。文本文件的一个缺点是，它的熵往往较低，也就是说，可以用较小的存储空间记录这些信息。

文本文件基本上是定长编码的(也有非定长的编码如UTF-8)，基于字符，每个字符在具体编码中是固定的，ASCII码是8个比特的编码，UNICODE一般占16个比特。而二进制文件可看成是变长编码的，因为是值编码，多少个比特代表一个值，完全由自己决定。

广义的二进制文件即指文件，由文件在外部设备的存放形式为二进制而得名。狭义的二进制文件即除文本文件以外的文件。

每个字符由一个或多个字节组成，每个字节都是用的-128—127之间的部分数值来表示的，也就是说，-128——127之间还有一些数据没有对应任何字符的任何字节。如果一个文件中的每个字节的内容都是可以表示成字符的数据，我们就可以称这个文件为文本文件。文本文件只是二进制文件中的一种特例，为了与文本文件相区别，人们又把除了文本文件以外的文件称为二进制文件，由于很难严格区分文本文件和二进制文件的概念，所以我们可以简单地认为，如果一个文件专门用于存储文本字符的数据，没有包含字符以外的其他数据，我们就称之为文本文件，除此之外的文件就是二进制文件。

为什么要使用二进制文件。原因大概有三个：

第一是二进制文件比较节约空间，这两者储存字符型数据时并没有差别。但是在储存数字，特别是实型数字时，二进制更节省空间；第二个原因是，内存中参加计算的数据都是用二进制无格式储存起来的，因此，使用二进制储存到文件就更快捷。如果储存为文本文件，则需要一个转换的过程。在数据量很大的时候，两者就会有明显的速度差别了。第三，就是一些比较精确的数据，使用二进制储存不会造成有效位的丢失。

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

文本文件和二进制文件

1. 文本文件
   文本文件存储的是普通“字符”文本，可以用记事本程序打开。
2. 二进制文件
   二进制文件把数据内容用“字节”进行存储，无法用记事本打开。

文件操作相关模块

名称	说明
io 模块	文件流的输入和输出操作input output
os 模块	基本操作系统功能，包括文件操作
glob 模块	查找符合特定规则的文件路径名
fnmatch 模块	使用模式来匹配文件路径名
fileinput 模块	处理多个输入文件
filecmp 模块	用于文件的比较
cvs 模块	用于 csv 文件处理
pickle 和 cPickle	用于序列化和反序列化
xml 包	用于 XML 数据处理
bz2、gzip、zipfile、zlib、tarfile	用于处理压缩和解压缩文件（分别对应不同的算法）

open()创建文件对象

open()函数用于创建文件对象
open(文件名[,打开方式])
为了减少“\”的输入，可以使用原始字符串：r“d:\b.txt”

模式	描述
r	读 read 模式
w	写 write 模式。如果文件不存在则创建；如果文件存在，则重写新内容；
a	追加 append 模式。如果文件不存在则创建；如果文件存在，则在文件末尾追加内容
b	二进制 binary 模式（可与其他模式组合使用）
+	读、写模式（可与其他模式组合使用）

注：文本文件对象和二进制文件对象的创建：
没有增加模式“b”，则默认创建的是文本文件对象，处理的基本单元是“字符”。
加二进制模式“b”，则创建的是二进制文件对象，处理的基本单元是“字节”。

文件对象的常用属性和方法

文件对象属性：

属性	说明
name	返回文件的名字
mode	返回文件的打开模式
closed	若文件被关闭则返回 True

文件对象打开模式：

模式	说明
r	读模式
w	写模式
a	追加模式
b	二进制模式（可与其他模式组合）
+	读写模式（可以其他模式组合）

文件对象的常用方法:

方法名	说明
read([size])	从文件中读取 size 个字节或字符的内容返回。若省略[size]，则读 取到文件末尾，即一次读取文件所有内容
readline()	从文本文件中读取一行内容
readlines()	把文本文件中每一行都作为独立的字符串对象，并将这些对象放入 列表返回
write(str)	将字符串 str 内容写入文件
writelines(s)	将字符串列表 s 写入文件文件，不添加换行符
seek(offset[,whence])	把文件指针移动到新的位置，offset 表示相对于 whence 的多少个字节的偏移量； offset：为正往结束方向移动，为负往开始方向移动 whence 不同的值代表不同含义： 0: 从文件头开始计算（默认值） 1：从当前位置开始计算 2：从文件尾开始计算
tell()	返回文件指针的当前位置
truncate([size])	不论指针在什么位置，只留下指针前 size 个字节的内容，其余全 部删除； 如果没有传入 size，则当指针当前位置到文件末尾内容全部删除
flush()	把缓冲区的内容写入文件，但不关闭文件
close()	把缓冲区内容写入文件，同时关闭文件，释放文件对象相关资源

pickle 序列化

序列化指的是：将对象转化成“串行化”数据形式，存储到硬盘或通过网络传输到其他 地方。反序列化是指相反的过程，将读取到的“串行化数据”转化成对象。

使用 pickle 模块中的函数，实现序列化和反序列操作。

序列化&反序列化：
pickle.dump(obj, file) obj 就是要被序列化的对象，file 指的是存储的文件
pickle.load(file) 从 file 读取数据，反序列化成对象

文本文件读取和写入

文本文件写入步骤

写入三个步骤：
1. 创建文件对象
2. 写入数据
3. 关闭文件对象

write()/writelines()写入数据

write(a)：把字符串 a 写入到文件中 writelines(b)：把字符串列表写入文件中，不添加换行符

close()关闭文件流

打开的文件对象必须显式调用 close()方法 关闭文件对象。当调用 close()方法时，首先会把缓冲区数据写入文件(也可以直接调用 flush() 方法)，再关闭文件，释放文件对象。
为了确保打开的文件对象正常关闭，一般结合异常机制的 finally 或者 with 关键字实现。

with 语句(上下文管理器)

自动管理上下文资源，不论什么原因跳出 with 块，都能确保文件正确的关闭，并且可以在代码块执行完毕后自动还原进入该代码块时的现场。

文本文件的读取

一般如下三种方法：
1. read([size]) 从文件中读取 size 个字符，并作为结果返回。如果没有 size 参数，则读取整个文件。 读取到文件末尾，会返回空字符串。
2. readline() 读取一行内容作为结果返回。读取到文件末尾，会返回空字符串。
3. readlines() 文本文件中，每一行作为一个字符串存入列表中，返回该列表

二进制文件读取和写入

二进制文件的处理流程和文本文件流程一致。不过，需要指定二进制模式，从而创建出二进制文件对象。

f = open(r"d:\a.txt", 'wb') #可写的、重写模式的二进制文件对象 
f = open(r"d:\a.txt", 'ab') #可写的、追加模式的二进制文件对象 
f = open(r"d:\a.txt", 'rb') #可读的二进制文件对象

创建好二进制文件对象后，仍然可以使用 write()、read()实现文件的读写操作。

CSV 文件读取和写入

csv(Comma Separated Values)是逗号分隔符文本格式，常用于数据交换、Excel 文件和数据库数据的导入和导出。与 Excel 文件不同，CSV 文件中：
1. 值没有类型，所有值都是字符串
2. 不能指定字体颜色等样式
3. 不能指定单元格的宽高，不能合并单元格
4. 没有多个工作表
5. 不能嵌入图像图表

例如：Excel表格：

另存为CSV格式，用记事本打开：
姓名,电话,地址
小明,18889303000,金凤路
小红,18829920000,五原路
王明,16668829922,凤天路

csv模块

Python 标准库的模块 csv 提供了读取和写入 csv 格式文件的对象

csv.reader 对象(csv 文件读取)

import csv
with open(r"e:\a.csv") as a:
        a_csv = csv.reader(a) #创建 csv对象,它是一个包含所有数据的列表，每一行为一个元素
        headers = next(a_csv) #获得列表对象，包含标题行的信息
        print(headers)
        for row in a_csv: #循环打印各行内容
                print(row)
                
##print
['姓名', '电话', '地址']
['小明', '18889303000', '金凤路']
['小红', '18829920000', '五原路']
['王明', '16668829922', '凤天路']

csv.writer 对象( csv 文件写入)

import csv
headers = ["工号","姓名","年龄","地址","月薪"]
rows =[("1001","王明",18,"西三旗1号院","50000"),("1002","高八",19,"西三旗 1号院","30000")]
with open(r"d:\b.csv","w") as b:
        b_csv = csv.writer(b) #创建csv 对象
        b_csv.writerow(headers) #写入一行（标题）
        b_csv.writerows(rows) #写入多行（数据）

os 模块

os 模块可以帮助我们直接对操作系统进行操作。

os.system(执行系统命令)

import os
os.system("ping www.baidu.com")

注：可能中文乱码，需要调整IDE编码为GBK

os.startfile（直接调用可执行文件）

#启动微信
import os
os.startfile(r"C:\Program Files (x86)\Tencent\WeChat\WeChat.exe")

os 模块-文件和目录相关操作

常用文件操作：

方法名	描述
remove(path)	删除指定的文件
rename(src,dest)	重命名文件或目录
stat(path)	返回文件的所有属性
listdir(path)	返回 path 目录下的文件和目录列表

常见目录操作：

方法名	描述
mkdir(path)	创建目录
makedirs(path1/path2/path3/… )	创建多级目录
rmdir(path)	删除目录
removedirs(path1/path2…)	删除多级目录
getcwd()	返回当前工作目录：current work dir
chdir(path)	把 path 设为当前工作目录
walk()	遍历目录树 sep 当前操作系统所使用的路径分隔符

#coding=gbk
#测试os模块中，文件目录相关操作
import os
#############获取文件和文件夹相关的信息################
print (os.name) #windows->nt linux和unix->posix
print (os.sep) #windows->\ linux和unix->/
print (repr(os.linesep)) #windows->\r\n linux-->\n\
print(os.stat("main.py"))

##############关于工作目录的操作###############
#注：相对路径都是相对于当前的工作目录
print(os.getcwd()) #当前工作目录
#os.chdir("d:") #改变当前的工作目录为：d:盘根目录
#os.mkdir("书籍".encode("GBK")) #创建目录
#os.rmdir("书籍") #删除目录
#os.makedirs("电影/港台/周星驰") #创多级目录
#os.removedirs("电影/港台/周星驰") #只能删除空目录
#os.rename("电影","movie")
# dirs = os.listdir("movie")
# print(dirs)

os.path 模块

os.path 模块提供了目录相关（路径判断、路径切分、路径连接、文件夹遍历）的操作。

方法	描述
isabs(path)	判断 path 是否绝对路径
isdir(path)	判断 path 是否为目录
isfile(path)	判断 path 是否为文件
exists(path)	判断指定路径的文件是否存在
getsize(filename)	返回文件的大小 （单位字节）
abspath(path)	返回绝对路径
dirname§	返回目录的路径
getatime(filename)	返回文件的最后访问时间
getmtime(filename)	返回文件的最后修改时间
walk(top,func,arg)	递归方式遍历目录
join(path,*paths)	连接多个 path
split(path)	对路径进行分割，以列表形式返回
splitext(path)	从路径中分割文件的扩展名

##encoding: utf-8
#测试 os.path 常用方法
import os.path
#################获取目录、文件基本信息
print(os.path.isabs("d:/a.txt")) #是否绝对路径
print(os.path.isdir("d:/a.txt")) #是否目录
print(os.path.isfile("d:/a.txt")) #是否文件
print(os.path.exists("a.txt")) #文件是否存在
print(os.path.getsize("a.txt")) #文件大小
print(os.path.abspath("a.txt")) #输出绝对路径
print(os.path.dirname("d:/a.txt")) #输出所在目录
########获得创建时间、访问时间、最后修改时间##########
print(os.path.getctime("a.txt")) #返回创建时间
print(os.path.getatime("a.txt")) #返回最后访问时间
print(os.path.getmtime("a.txt")) #返回最后修改时间
################对路径进行分割、连接操作############
path = os.path.abspath("a.txt") #返回绝对路径
print(os.path.split(path)) #返回元组：目录、文件
##print ('E:\\PythonProject', 'a.txt')
print(os.path.splitext(path)) #返回元组：路径、扩展名
##print ('E:\\PythonProject\\a', '.txt')
print(os.path.join("aa","bb","cc")) #返回路径：aa/bb/cc

walk()递归遍历所有文件和目录

os.walk()方法：
返回一个 3 个元素的元组(dirpath, dirnames, filenames)
dirpath：要列出指定目录的路径
dirnames：目录下的所有文件夹
filenames：目录下的所有文件

#coding=utf-8
import os
all_files = []
path = os.getcwd()
list_files = os.walk(path)
for dirpath,dirnames,filenames in list_files:
    for dir in dirnames:
        all_files.append(os.path.join(dirpath,dir))
    for name in filenames:
        all_files.append(os.path.join(dirpath,name))
for file in all_files:
    print (file)

shutil 模块(拷贝和压缩)

shutil 模块,主要用来做文件和文件夹的拷贝、移动、删除等；还可以做文件和文件夹的压缩、解压缩操作。
os 模块提供了对目录或文件的一般操作。shutil 模块作为补充，提供了移动、复制、压缩、解压等操 作，这些 os 模块都没有提供。

#encoding=gbk
import shutil
import zipfile
#copy 文件内容
#shutil.copyfile("a.txt","a_copy.txt")

#"音乐"文件夹不存在才能用！！！
#文件夹“电影/学习”下面的内容拷贝到文件夹“音乐”下。拷贝时忽略所有的 html 和 htm 文件。
#shutil.copytree("电影/港台","音乐",ignore=shutil.ignore_patterns("*.html","*.htm"))

#将"电影/港台"文件夹下所有内容压缩到"音乐2"文件夹下生成 movie.zip
#shutil.make_archive("音乐/movie","zip","电影/港台")

#压缩:将指定的多个文件压缩到一个 zip 文件
# z = zipfile.ZipFile("a.zip","w")
# z.write("1.txt")
# z.write("2.txt")
# z.close()
#解压缩：
# z2 = zipfile.ZipFile("a.zip","r")
# z2.extractall("d:/") #设置解压的地址
# z2.close()

常用字符编码

ASCII

ASCII 码用 7 位表示，只能表示 128 个字符。一字节 ASCII 的编码最高位总是 0。

ISO8859-1

ISO-8859-1 又称 Latin-1，是一个 8 位单字节字符集，它把 ASCII 的最高 位也利用起来，并兼容了 ASCII，新增的空间是 128，但它并没有完全用完。 在 ASCII 编码之上又增加了西欧语言、希腊语、泰语、阿拉伯语、希伯来语 对应的文字符号，它是向下兼容 ASCII 编码。

GB2312,GBK,GB18030

GB2312

GB2312 全称为信息交换用汉字编码字符集，是中国于 1980 年发布，主要用于计算机系统中的汉字处理。覆盖汉字大部分，不能处理像古汉语等特殊的罕用字， 所以后来出现了像 GBK、GB18030 这种编码。
GB2312 完全兼容 ISO8859-1。

GBK

汉字内码扩展规范，主要是扩展了 GB2312。1995 年制定

GB18030

最新的内码字集于 2000 年发布，主要采用单字节、双字节、四字节对字符编码，它是向下兼容 GB2312 和 GBK 的。用得最多的是 GBK 和 GB2312。

Unicode

Unicode 编码设计成了固定两个字节，所有的字符都用 16 位。
Unicode 完全重新设计，不兼容 iso8859-1，也不兼容任何其他编码。

UTF-8

对于英文字母，unicode 也需要两个字节来表示。所以 unicode 不便 于传输和存储。因此而产生了 UTF 编码。

UTF 编码兼容 iso8859-1 编码，同时也可以用来表示所有语言的字符， 不过，UTF 编码是不定长编码，每一个字符的长度从 1-4 个字节不等。其中， 英文字母都用一个字节表示，而汉字使用三个字节。

中文乱码问题

windows 操作系统默认的编码是 GBK，Linux 操作系统默认的编码是 UTF-8。当我们 用 open()时，调用的是操作系统打开的文件，默认的编码是 GBK。

文件的打开与关闭

文件的实质就是存储在外部储存介质上的一段连续的二进制数据。在程序中，可能需要从文件中读取数据，也可能会将程序的数据或运行日志输出、记录到文件中。因此程序和文件之间的关系是非常密切的

从可否阅读的角度来看，可将文件分为文本文件和二进制文件两大类。
文本文件是可阅读的，例如用Windows自带的记事本、写字板所编辑出来的文件，就是文本文件，文本文件是以字符码（字符的二进制码）的形式进行存储的，用户可以随时打开文本文件，阅读文件的内容。
二进制文件并非以字符码形式进行存储的文件，例如图片、音乐、视频都是属于二进制文件，由于这些文件所存储的并非是字符，无法以字符的形式进行阅读，通常要用专门的软件进行图片的查看或者音乐、视频的播放。
因此，我们所编写的程序源代码文件就属于文本文件，而编译生成的可执行文件就属于二进制文件

C语言程序对文件的处理采用文件流的形式，程序运行在内存中的，而文件存储在外部存储介质上，例如硬盘、光盘、U盘等。
在程序运行时，就会在指定的 文件之上建立一条管道，当读取文件时，数据就会像流水一样从文件端流向程序端，而写入文件时，数据就会像流水一样从程序端流向文件端。

从文件端向程序端的文件流称为输入流，从程序端向文件端的文件流称为输出流

只要打开一个文件，就会得到一个文件流。有了文件流之后，就可以对文件进行相应的读写操作。

文件的打开

下面就来讲述如何在C程序中打开和关闭一个文件，即如何在C程序中得到一个文件流与关闭一个文件流。在C语言标准库中，有一系列和文件相关的库函数，只需在程序中包含stdio.h这个头文件，就可以使用这些函数

C语言中，打开文件需要使用fopen函数，该函数原型如下

FILE *fopen(const char *fname,const char *mode);

fopen函数的返回值是一个文件流，其实就是FILE结构体类型的指针。函数执行成功会返回一个指向FILE结构体变量的指针，这个结构体变量包括了文件的名称、大小、属性、缓冲区等相关信息；若函数执行失败，则返回的是空指针。因此，可以通过对fopen函数所返回的文件流进行判断，从而获知文件打开是否成功

fopen函数的两个参数都是字符类型的常量指针，即指向字符串常量的指针。其中fname用于指定所要打开的文件，可以是文件的绝对路径（从盘符开始的文件路径），也可以是文件的相对路径（从当前工作目录开始的文件路径）

参数mode用于指定文件的打开模式，以确定用何种方式对文件进行处理得到相关的文件流

模式字符串	功能
“r”	以只读模式打开文本文件
“w”	以只写模式打开文本文件
“a”	以追加模式打开文本文件
“r+”	以读写模式打开文本文件
“w+”	以读写模式打开文本文件
“a+”	以读写模式打开文本文件
“rb”	以只读模式打开二进制文件
“wb”	以只写模式打开二进制文件
“ab”	以追加模式打开二进制文件
“rb+”	以读写模式打开二进制文件
“wb+”	以读写模式打开二进制文件
“ab+”	以读写模式打开二进制文件

说明：
1.只读方式要求文件必须存在，否则打开文件失败
2.只写方式会清空所打开文件的内容，并做好从文件头写入数据的准备。若文件不存在，则会自动创建
3.追加方式不会清空文件内容，并做好从文件末写入数据的准备。若文件不存在，则会自动创建
4.读写方式打开文件，则会对打开的文件具有读取和写入的能力。不过，它们仍然要受到基本属性的限制，如r+仍需文件必须存在，w+仍会清空文件内容，而a+仍会在文件末进行数据的写入
5.模式字符串中含有字符b表示对二进制文件的操作，没有字符b，表示对文本文件的操作

从文件流的角度来说，用r模式打开文件会得到一个文件的输入流，用w模式打开文件会得到一个文件的输出流，而用带+模式打开文件会得到文件的输入、输出流

下面使用fopen函数来打开一个文件

FILE *pfile = fopen("D:\\test.txt","r");
if(pfile != NULL)
	printf("File opened successfully.\n");
else
	printf("Failed to open file.\n");

代码中定义了一个FILE结构体类型的指针变量pfile，并调用fopen函数，以r（只读）模式打开D盘（确保Windows系统下有D盘）下面的文本文件test.txt，即想得到一个文件的输入流。fopen函数的返回值被初始化给指针变量pfile。需要注意的是，在fopen函数的第一个字符串参数中，使用的是绝对路径D:\test.txt，由于斜杠\在C语言中是作为转义字符来使用的，因此，必须用\（连续的两个斜杠），才能表示一个斜杠字符本身

编译运行程序，如果在计算机的D盘中有test.txt这个文件的话，就会打印如下结果

File opened successfully.

如果D盘下没有test.txt这个文件，则会得到如下结果

Failed to open file.

若是将fopen函数的文件打开模式修改为只写，即使用模式字符串w,即表示想得到一个文件的输出流

FILE *pfile = fopen("D:\\test.txt","w");

则无论在D盘（确保Windows系统下有D盘）下是否存在test.txt这个文件，它也会自动创建一个。但若此时在test.txt文件中手工输入一些内容并保存，当再次执行该程序后，会发现test.txt文件中原先输入的内容被清空了，即test.txt变成了一个空文件

如果既想打开一个文件，得到文件的输出流，而又不想让文件的内容被清空，那么就使用含有字符a的模式字符串

FILE *pfile = fopen("D:\\test.txt","a");

文件的关闭

可以使用fclose函数来关闭一个文件，该函数原型为

int fclose(FILE *stream);

fclose函数只有一个参数stream,是FILE结构体类型的指针，表示一个文件流。fclose函数的功能就是将该函数所指定的文件流关闭。函数的返回值为int类型，当函数执行成功，返回整型值0，当函数执行失败，返回一个EOF。EOF是一个宏的名字，是End of file(文件终点)的首字母缩写，它表示一个非零值，通常被定义为-1

我们可以将fopen函数所返回的文件流作为实参，调用fclose函数，以关闭与该文件流相关联的文件

FILE *pfile = fopen("D:\\test.txt","r");
if(pfile)
{
	printf("File opened successfully.\n");
	if(!fclose(pfile))
		printf("File closed successfully.\n");
	else
		printf("File closure failed successfully.\n");
}
else
	printf("Failed to open file.\n");

代码中，首先通过fopen函数打开D盘的test.txt文件，并返回与该文件相关联的输入流，然后通过if语句对文件流pfile进行检查，若文件流pfile是正常的、可用的，则执行大括号中的语句；若文件流是不可用的，则执行else部分，打印输出文件打开失败的信息

在大括号中，首先通过printf函数打印文件打开成功的信息，然后再次使用if…else语句。在小括号内的条件表达式中，将文件流pfile作为实参调用fclose函数，这会将与文件流pfile相关联的文件test.txt关闭。如果关闭成功，则fclose函数的返回值为0，由于前面使用了逻辑非运算符，因此，小括号内的表达式的值为真，这会通过printf函数在控制台窗口打印文件关闭成功的信息；若文件关闭失败，fclose函数的返回值为EOF，通过逻辑非运算符转换，小括号内表达式的结果为假，就会执行else部分，打印文件关闭失败的信息

由于之前已经在D盘上创建了test.txt文件，结果为

File opened successfully.
File closed successfully.

将D盘上的test.txt文件删除，并重新运行该程序

Failed to open file.

标准文件流

C语言还有3个特殊的文件流，即标准输入流（stdin）、标准输出流（stdout）和标准错误输出流（stderr）
称其特殊，主要是因为它们所关联的不是普通的文件，而是设备文件，即将计算机中的输入、输出设备当作文件来看待，例如默认情况下，标准输入流是和键盘相关联的，标准输出流和标准错误输出流是和控制台窗口相关联的。
另外一个特别之处就是用户不需要考虑这3个文件流的启用与关闭，它们是由系统管理的。当程序启动时，这3个文件流会自动被启用，用户可以直接使用，而在程序关闭时，这3个文件流会被自动关闭

像用户之前所用到的printf、scanf、getchar、putchar等函数都是使用的标准文件流，其中printf和putchar是通过标准输出流向控制台窗口打印输出数据，而scanf和getchar是通过标准输入流获取由键盘所输入的数据。标准输入流和标准输出流是带缓冲的文件流，数据在文件端和程序端之间进行传输时，需经过缓冲处理，即先将数据存入缓冲区，当缓冲区满了或是强制刷新缓冲区时，数据才会真正地到达目的端

使用缓冲区的好处是能够提高程序效率，要知道对（存储在硬盘上）文件的读写效率是远远低于对内存的读写效率的。因此，在读取文件时，可以先从文件中获取特定量的数据放入缓冲区中，程序再从缓冲区里读取数据；同样地，在写入文件时，先将数据写入缓冲区中，当缓冲区满或强制刷新时，再将缓冲区中的数据一次性写入文件，这样就大大地减少了对（存储在硬盘上）文件的读写次数，从而提高程序的运行效率

标准错误输出流用于程序发生错误或特殊情形发生时，能够打印输出相关信息。标准错误输出流是一种不带缓冲的输出流，这样做的目的，是为了不受缓区影响，能够及时地将信息打印显示出来

文件流的重定向

在C语言中，还可以使用文件流重定向的方式来改变文件流所关联的文件。这就需要使用freopen函数，函数原型如下

FILE *freopen(const char *fname,const char *mode,FILE *stream);

freopen函数的前两个参数和fopen函数的参数意义相同，第三个参数stream，即是需要重定向的文件流。freopen函数的返回值为重定向之后的新的文件流，如果重定向失败则为空指针。freopen函数的功能就是将文件流stream关联到以mode模式打开的fname文件上

可以将标准输出流重定向，让其关联到D盘的test.txt文件上。这样再使用printf、putchar、puts等函数进行打印输出，就不会再显示到控制台窗口，而是写入到D盘的test.txt文件中

freopen("D:\\test.txt","w",stdout);
printf("Hello");
putchar(' ');
printf("World");

在freopen语句中，第三个参数是stdout，表示需要重定向的是标准输出流，而第一个参数字符串指定了所关联的文件，第二个参数字符串指定了所关联文件的打开模式，由于输出流是往文件中写入数据，所以，这里使用的是w模式

编译运行程序，会发现在控制台窗口上无任何信息。打开D盘上的test.txt文件，可看到有如下内容

Hello World

也可以将标准输入流重定向，让其关联到D盘的test.txt文件上。这样再使用scanf、gettchar、gets等函数获取数据的时候，就不会再到控制台窗口上去获取由键盘输入的数据，而是到了D盘的test.txt文件中去获取数据

char ch1,ch2;
char str[100];
freopen("D:\\test.txt","r",stdin);
scanf("%c",&ch1);
ch2 = getchar();
gets(str);
printf("ch1:%c\nch2:%c\nstr:%s\n",ch1,ch2,str);

结果如下

ch1:H
ch2:e
str:llo World

通过对标准输入流的重定向之后，scanf、getchar和gets函数都变为从D盘的test.txt文件获取数据。其中由scanf函数获取了第一个字符H保存到变量ch1中，由getchar函数获取了第2个字符e保存到变量ch2中，由gets函数获取剩余的字符，然后组成字符串llo World保存到字符数组中

文件的读写

以字符的方式读写文件

对于文本文件来说，可以使用C语言标准库中提供的fgetc函数和fputc函数，以字符的方式对文件进行读写操作

fputc函数是以字符的方式向文件中输出（写入）数据。函数原型如下

int fputc(int ch,FILE *stream);

函数有两个参数，第一个参数ch为欲写入文件的字符，第二个参数stream为欲写入文件相关联的文件流。函数的功能就是将参数ch所表示的字符写入文件流stream所关联的文件中。函数返回值为所写入的字符，如果出错，返回EOF

#include <stdio.h>
int main()
{
	char str[] = "Red apple";
	FILE *pfile = fopen("D:\\test.txt","w");
	if(pfile)
	{
		char *ptmp = str;
		while(*ptmp)
		{
			fputc(*ptmp,pfile);
			++ptmp;
		}
		fclose(pfile);
		puts("Write to complete.");
	}
	else
		puts("File opening failed.");
	return 0;
}

程序代码中，通过临时指针ptmp的移动来遍历字符数组中的字符串各字符，如果是非空字符，就通过fputc函数，将其写入到文件流pfile所关联的文件中，直至ptmp指向字符串末尾的空字符时止

需要注意的是，==在对文件处理完毕后，应养成及时关闭文件的好习惯。==因为在程序对文件进行读写时会使用缓冲区，向文件写入数据，其实是将数据写入到缓冲区中，只有在缓冲区满或是强制刷新的情况下，数据才会从缓冲区写到文件中。如果发生程序异常、崩溃或是突然断电等情况，可能会存在缓冲区中数据未写入文件的情况，造成数据的丢失

刷新缓冲区的函数为fflush，函数原型如下

int fflush(FILE *stream);

该函数对参数stream所对应的输出缓冲区进行刷新，将输出缓冲区中的数据强制写入文件。函数执行成功返回0，如果出错，则返回EOF

在完成对文件的数据写入后，我们可以调用fflush函数来刷新输出缓冲区，将数据真正地写入到文件中

if(pfile)
	{
		char *ptmp = str;
		while(*ptmp)
		{
			fputc(*ptmp,pfile);
			++ptmp;
		}
		fflush(pfile);			//刷新输出缓冲区
		fclose(pfile);			//关闭文件
		puts("Write to complete.");
	}

在关闭文件之前调用fflush函数，刷新pfile所对应的输出缓冲区，将数据强制写入D盘的test.txt文件中

其实，在fclose函数中也会隐含地调用fflush函数来刷新输出缓冲区，所以，当调用fclose函数对文件进行关闭时，也间接地达到了刷新输出缓冲区的目的。因此，在这儿是可以省略掉fflush函数的语句。但千万别既不用fflush显式地刷新缓冲区，也不使用fclose来隐含地刷新缓冲区

fgetc函数是以字符的方式从文件中读取数据，函数原型如下

int fgetc(FILE *stream);

fgetc函数的参数stream应该是一个文件输入流，函数的功能就是从stream相关联的文件中读取一个字符作为函数的返回值。若是读到了文件末尾，或是发生了错误，则返回EOF。EOF和用作字符串末尾结束标记的空字符有点类似，空字符用于标记字符串的末尾，而EOF用于标记文件的末尾

编写程序，以字符的方式读取D盘test.txt文件中的内容，将其存储到字符数组中，并打印输出

#include <stdio.h>
int main()
{
	char buf[128];
	FILE *pfile = fopen("D:\\test.txt","r");
	if(pfile)
	{
		char *p = buf;
		while((*p = fgetc(pfile)) != EOF)
			++p;
		*p = '\0';
		fclose(pfile);
		printf("The read content is: %s\n",buf);
	}
	else
		puts("File opening failed.");
	return 0;
}

在while循环的条件检测处，首先使用fgetc函数从文件中读取字符，并通过对指针p的解引用将字符存储到字符数组中，并判断读取到的字符是否为EOF字符。若非EOF字符，则移动指针，进行下个字符的读取与存储，若为EOF字符，则终止while循环。需要注意的是，由于赋值运算符的优先级低于关系运算符，因此，需要用小括号来提升赋值表达式的优先级

在while循环之后，通过指针p的解引用，将最后存储在字符数组中的EOF字符修改为空字符，以作为字符串的结束标记

编译运行程序，结果如下

The read content is: Red apple

以行的方式读写文件

可以使用fgets函数和fputs函数，非常方便地对文本文件进行一行字符的读取或写入

fputs函数用于向文件输出（写入）一行字符，函数原型为

int fputs(const char *str,FILE *stream);

参数str是一个字符串的指针，即将所要写入文件的一行字符看作为一个字符串，str为该字符串的首地址；参数stream为与所写入文件相关联的输出流。函数执行成功返回非负值，执行失败则返回EOF

#include <stdio.h>
int main()
{
	FILE *pfile = fopen("D:\\test.txt","w");
	if(pfile)
	{
		if(fputs("Red appple",pfile) != EOF)
			printf("File written successful.\n");
		else
			printf(Failed to write file.\n);
		fclose(pfile);
	}
	else
		printf("File opening failed.\n");
	return 0;
}

使用了fputs函数，不再是逐字符地写入，而是将一行字符一次性地写入文件

编译运行程序，正常情况下，写入文件成功，会打印如下结果

File written successful.

和fputs函数相对应的就是fgets函数，函数原型如下

char *fgets(char *str,int num,FILE *stream);

fgets函数可以从文件中读取一行或指定数量的字符，组成字符串存储到指定的数组或内存空间中。参数str是数组或内存空间的首地址，参数num是数组或内存空间的大小，参数stream是与文件相关联的输入流。函数执行成功返回str，若执行失败返回NULL

编写程序，以行的方式读取D盘test.txt文件中的内容，并打印输出

#include <stdio.h>
int main()
{
	char buf[128];
	FILE *pfile = fopen("D:\\test.txt","r");
	if(pfile)
	{
		if(fgets(buf,128,pfile))
			printf("The read content is: %s\n",buf);
		else
			printf("Failed to read file.\n");
		fclose(pfile);
	}
	else
		printf("File opening failed.\n");
	return 0;
}

代码中，定义了一个长度为128的字符数组buf，作为从文件读取字符的存储区域。在fgets函数的调用语句中，第一个参数为buf数组名，第二个参数为buf的大小128.这表示最多可以从文件中读取127个字符，并添加一个空字符，作为字符串的结束标记，存储到buf数组中

结果

The read content is: Red apple

fgets函数在文件中读取字符时，并不会总是固定地读取127个字符，当遇到换行字符或读到文件末尾（EOF）时，就会停止读取
fputs函数在向文件输出字符时，只会输出字符串本身所包含的字符，并不会像puts函数那样，在输出完字符串后再自动加上一个换行符

以格式化的方式读写文件

前面的两种文件的读写方式，适合于字符和字符串的处理，但若遇到数值类型的数据，就可以用C标准库中提供的fprintf函数和fscanf函数，可以对文件进行格式化方式的读写。它们像printf函数和scanf函数一样，可以处理多种类型的数据

fprintf函数的函数原型为

int fprintf(FILE *stream,const char *format,...);

fprintf函数比printf函数多一个参数stream，即与文件相关联的输出流。printf函数可以将格式化后的字符串打印输出到控制台窗口，而fprintf函数是将格式化后的字符串打印输出到与stream相关联的文件中。fprintf函数的返回值为所打印输出的字符数，如果函数执行出错，则返回一个负整数值

假若有如下的一个学生的结构体

struct STU
{
	int num;
	char name[20];
	float score;
};

接下来，在主函数中定义该结构体类型的变量并进行初始化。然后就可以通过fprintf函数将结构体变量的内容写入到文件中

int main()
{
	struct STU stu = {100,"zhangsan",90.5};
	FILE *pfile = fopen("D:\\test.txt","w");
	if(pfile)
	{
		fprintf(pfile,"%d %s %.2f",stu.num,stu.name,stu.score);
		fclose(pfile);
	}
	else
		printf("File opening failed.\n");
	return 0;
}

程序代码中，通过fprintf函数，将结构体变量stu的3个成员值写入到D盘test.txt文件中，各成员数据之间使用空格隔开。把数据隔开是为了后面能够方便地读取

编译运行程序，在控制台窗口不会显示任何信息，但打开D盘上的test.txt文件，会有以下内容

100 zhangsan 90.50

可见，fprintf函数会将格式化后的字符串输出到指定的文件中

还有一个和fprintf函数非常类似的函数，函数名为sprintf，它可以将格式化后的字符串输出到一个指定的内存空间中，用户可以非常方便地通过它来将一些数值类型的数据转换为字符串
sprintf函数的原型如下

int sprintf(char *buffer,const char *format,...)

和fprintf函数的唯一区别就是第一个参数buffer，它并非一个文件输出流，而是一个字符类型的指针，指向一块可以存储字符串的内存空间，通常称这块内存空间为缓冲区。可以在上面的代码中再定义一个字符数组，并将fprintf函数换成sprintf函数，这样就可以将结构体变量stu中的数据写入到字符数组中

int main()
{
	struct STU stu = {100,"zhangsan",90.5};
	char buf[1024];
	sprintf(buf,"%d %s %.2f",stu.num,stu.name,stu.score);
	puts(buf);
	return 0;
}

编译运行程序，结果如下

100 zhangsan 90.50

fscanf函数和scanf函数非常相似，唯一不同的是，fscanf函数也多出了一个参数，是和文件相关联的输入流，表示从文件中读取数据。fscanf函数的原型如下

int fscanf(FILE *stream,const char *format,...);

使用fscanf函数来对D盘上的test.txt文件进行数据读取，程序代码如下

int main()
{
	struct STU stu;
	FILE *pfile = fopen("D:\\test.txt","r");
	if(pfile)
	{
		fscanf(pfile,"%d%s%f",&stu.num,stu.name,&stu.score);
		fclose(pfile);
		printf("num:%d\nname:%s\nscore:%.2f\n",stu.num,stu.name,stu.score);
	}
	else
		printf("File opening failed.\n");
	return 0;
}

首先定义一个结构体变量stu，然后通过fscanf函数读取文件数据到变量stu的3个成员，最后通过printf函数将结构体变量stu的所有成员打印输出到控制台窗口

结果

num:100
name:zhangsan
score:90.50

以块的方式读写文件

通过格式化的方式读写文件，可以很方便地在文件中处理像结构体这种类型的数据。下面再来介绍块方式读写文件的函数，它可以对二进制文件进行读写，对于在文件中处理结构体、数组等类型的数据非常适合

块的写入函数fwrite的函数原型如下

int fwrite(const void *buffer,size_t size,size_t count,FILE *stream);

fwrite函数有4个参数，其中buffer为所要写入数据的首地址，即指向写入数据的指针；size为数据块的大小；count为数据块的数量；stream为与文件相关联的输出流。fwrite函数的功能就是将buffer所指向的count个size大小的数据块写入到stream相关联的文件中。函数的返回值为所写入文件的数据块的数量，正常情况下，应该为参数count的值

假设有一个结构体STU类型的变量，现在想将其写入到D盘的test.txt文件，就可以这样使用fwrite函数，参数size为结构体变量的大小，而参数count为1，即将一个结构体变量大小的数据块写入到D盘test.txt文件

#include <stdio.h>
struct STU
{
	int num;
	char name[20];
	float score;
};
int main()
{
	struct STU stu = {100,"zhangsan",90.5};
	FILE *pfile = fopen("D:\\test.dat","wb");
	if(pfile)
	{
		fwrite(&stu,sizeof(stu),1,pfile);
		fclose(pfile);
	}
	else
		printf("File opening failed.\n");
	return 0;
}

fopen函数中，打开文件的模式字符串为wb，即以二进制写入的模式打开文件。在fwrite函数中，第一个参数为结构体变量stu的内存地址，第二个参数为一个数据块的大小，即结构体变量stu的大小，第三个参数为数据块的数量，这里为1，第四个参数为与D盘test.dat文件相关联的输出流

编译运行该程序，正常情况下，在控制台窗口没有任何信息，但打开计算机上的D盘，会发现一个名为test.dat的文件。以文本的方式打开该文件，会看到许多乱码，这是因为test.dat并非文本文件，而是一个二进制文件，即存储在文件中的并非字符的ASCII码，因而无法转换为可读的字符

fread函数，它可以以数据块的方式从文件中读取数据。fread函数的原型如下

int fread(void *buffer,size_t size,size_t num,FILE *stream);

fread函数的功能为从stream相关联的文件中读取num个size大小的数据块，存储到buffer所指向的内存空间中。fread函数的返回值为所读取到的数据块的个数，正常情况下，应为参数num的值

下面使用fread函数，从D盘test.dat文件读取数据，并在控制台窗口上打印结果

#include <stdio.h>
struct STU
{
	int num;
	char name[20];
	float score;
};
int main()
{
	struct STU stu;
	FILE *pfile = fopen("D:\\test.dat","rb");
	if(pfile)
	{
		fread(&stu,sizeof(stu),1,pfile);
		fclose(pfile);
		printf("num:%d\nname:%s\nscore:%.2f\n",stu.num,stu.name,stu.score);
	}
	else
		printf("File opening failed.\n");
	return 0;
}

在打开D盘test.dat文件时，采用的是rb模式，即以二进制读取的模式打开文件。在fread函数中，数据块大小为结构体变量stu的大小，数据块的数量为1，将读取到的数据存储至结构体变量stu中

结果

num:100
name:zhangsan
score:90.50