python —— I/O

CPU构成：
	运算器：完成各种算数运算、逻辑运算、数据传输等数据加工处理
	控制器：控制程序的执行
	存储器：用于记忆程序和数据，例如内存
	输入设备：将数据或者程序输入到计算机中，例如：键鼠
	输出设备：将数据或者程序处理结果展示给用户 例如：显示器、打印机等
	一般I/O操作，指的是文件IO，若是网络IO会直接称呼
网络IO
文件IO常用操作：
	Open ：打开
	Read ：读取
	write：写入
	close：关闭
readline： 行读取
readlines：多行读取
seek：文件指针操作
tell：指针位置
open(file, mode=’r’, buffering = -1, encoding= None, errors = None, newline = None, closefd = Ture, opener = None)
打开一个文件，返回一个文件(流)对象和文件描述符。打开文件失败则返回异常
F = open(‘test’) #file对象  -> 打开test文件
f.read() 读文件
f.close() 关闭文件
文件的访问模式有两种： 文本模式和二进制模式
不同模式下，操作函数不尽相同，表现的结果也不一样

Open参数：
file：
	打开或者要创建的文件名，如果不指定路径，默认当前工作路径(相对路径)
Mode —> 模式：
#r 模式-> 可读不可写
f = open('test') 
f.read()
f.write('abc')#不可写
f.close()

f = open('test', 'r')#使用r 只读方式 不可写
f.write('abc')
f.close()

#打开一个不存在的文件 报错
f = open('test1', 'r')
 
#w 模式
f = open('test', 'w')
f.write('ccc')
f.close()

>>>cat test
>>> ccc

#在使用一次写入功能 直接覆盖test为空
f = open('test', mode = 'w')
f.close()
>>> cat test
>>>

#w 可以直接新建个test1 写入'123'
f = open('test1', mode='w')
f.write('123')
f.close()
>>>cat test1
>>>123%

open默认是只读模式r打开已经存在的文件。
r：
	只读打开文件，如果使用write方法，抛异常
	如果文件不存在，抛FileNotFoundError异常
w:
	只写方式打开，读取则抛异常
	文件不存在，可以直接创建文件
	如果文件存在，清空文件内容
-----------------------------------------------
x:
	文件不存在，创建文件，只可写入
	文件存在，抛出FileExistsError异常
f = open('test2', 'x')
f.read()
f.write('abcd')
f.close()
>>>cat test2
>>>abcd

f = open('test2', 'x')

a:
	文件存在，可写可打开，追加内容
	文件不存在，则创建后，可写可打开，追加内容

f = open('test3', 'a')
f.read()

f.write('zzzzzzz')
f.close()

>>cat test3
>>>zzzzzzz

f = open('test4', 'a')
f.wirte('test4')
f.close()

>>>cat test4
>>>test4

总结：
	r是只读，wxa都是只写
	wxa都可以产生新文件。
	w不管文件存在与否，都会生成全新内容的文件
	a不管文件是否存在，都能在打开的文件尾部追加内容
	x必须要求文件事先不存在，自己创建一个新文件

文本模式 t：
	字符流，将文件的字节按照某种字符编码理解，按照字符操作。open默认mode是rt

二进制模式 b:
	字节流，将文件按照字节理解，与字符编码无关。二进制模式操作时，字节操作使用bytes类型


f = open('test', 'wb')
f.write('abc测试'.encode())
f.close()

f = open('test')
f.read(3)
>>>bc测
f.read(1)
>>>a
f.close()

f = open('test', 'rb')
f.read(1)
>>>'a'
f.read(3)
>>>'bc\xe6'
f.close()

--------------------------------------------------
f = open('test', 'r+')
f.write('abc123')
f.read()
f.close()

f = open('test', 'w+')
f.write('abc123')
f.read()
f.close()

f = open('test', 'a+')
f.write('abc123')
f.read()
f.close()

f = open('test2', 'x+')
f.write('abc123')
f.read()
f.close()

以上f.read都为空，但是cat可以显示内容
+:
	为r/w/a/x 提供缺失的读写功能(缺读给读，缺写给写)，但是，获取文件对象依旧按照r/w/a/x自己的特征。
+ 不能单独使用，可以认为它是为前面的模式字符做增强功能的。


文件指针：
	指向当前字节位置

	mode = r  指针起始在0
	mode = a  指针起始在EOF(文件末尾)

	tell() 显示指针当前位置
	seek(offset[,whence])
	移动文件指针位置。offset 偏移x个字节
文本模式下：
	whence 0 缺省值，表示从头开始，offset只能正整数
	whence 1 表示从当前位置开始， offset 只接受0
	whence 2 表示从EOF开始，offset只接受0
test4 = ('test4')
	f = open('test4', 'r+')
	f.tell() #起始  0
	f.read() #'test4'
	f.tell() # EOF  5
	f.seek(0)# 0
	f.read() # test4
	f.seek(2,0) # 2
	f.read()	#st4
	f.seek(2,0) #st4
	f.seek(2,1) #Error offset 只能为0
	f.seek(2,2)	#Error offset 只能为0
	f.close()
中文
	f = open('test4', 'w+')
	f.write('测试')
	f.tell() #6
	f.close()
	f = open('test4', 'r+')
	f.read(3)#'测试'
	f.seek(1)#1
	f.tell()#1
	f.read()#Error
	f.seek(2)#2
	f.close()
文本模式支持从开头向后偏移的方式

二进制模式：
	whence 0 缺省值，表示从头开始，offset只能正整数
	whence 1 表示从当前位置开始，offset可正负
	whence 2 表示从EOF开始，offset可正负

f = open('test4', 'rb+')
f.tell() #0
f.read()#b'\xe6\xb5\x8b\xe8\xaf\x95'
f.tell() #6
f.write(b'abc')
f.seek(0)#0
f.seek(2,1)#2
f.read()#b'\x8b\xe8\xaf\x95abc'
f.seek(-2,1)#7
f.seek(2,2)#9
f.seek(0)#0
f.seek(-2,2)#
f.read()#'bc'
f.seek(-20,2)#Error  Invaild argument
f.close()

buffering：缓冲区
     -1 表示使缺省值大小的buffer，如果是而精致模式，使用io.defaults_buffer_size值，
默认是4096或者8192
如果是文本模式，如果是终端设备，是行缓存方式，如果不是则使用二进制的策略
  0只在二进制模式使用，表示管buffer
  1只在文本模式使用，表示使用行缓冲，意思就是见到换行符flush
  大于1 用于指定buffer的大小

buffer缓冲区：
 	缓冲一个内存空间，一般来说是一个FIFO队列，到缓冲区满了或者达到阈值，数据才会flush到磁盘

flush()  将缓冲区数据写入磁盘
close()	 关闭前会调用flush()

io.DEFAULT_BUFFER_SIZE 缺省缓冲区大小，字节

>>>import io
>>>io.DEFAULT_BUFFER_SIZE
>>>8192

buffering = -1  t和b，都是io.DEFAULT_BUFFER_SIZE
buffering = 0	b 关闭缓冲区，t不支持
buffering = 1	b 就一个字节，t行缓冲，遇到换行符才flush
buffering > 1	
	b模式表示缓冲大小。缓冲区的值可以超过io.DEFAULT_BUFFER_SIZE，直到
设定的值超出后才把缓冲区flush。
	t模式，是io.DEFAULT_BUFFER_SIZE，flush完成后把当前字符串也写入磁盘

总结：
	1、文本模式，一般都用默认缓冲区大小
	2、二进制模式，是一个个字节的操作，可以指定buffer的大小
	3、默认缓冲区大小是个比较好的选择，除非明确的知道，否则不调整
	4、明确知道需要写磁盘，都会手动调用一次flush，而不是等到自动flush或者close的时候

上下文管理：
ulimit -a查看所有限制，其中open files就是打开文件数的限制，默认1024

异常处理：
当出现异常的时候，拦截异常，但是因为很多代码都可能出现oserror异常，不好判断异常，是因为资源限制产生的
f = open('test')
try:
     f.write('abc')     #文件只读，写入失败
finally:
     f.close（）     #正确做法
使用finally可以保证打开的文件可以被关闭
上下文管理，一种特殊的语法，交给解释器取释放文件对象

使用with...as关键字
上下文管理的语句块并不会开启新的作用域
with语句块执行完的时候，会自动关闭文件对象
def f
with open('test')as f:
     f.write('hello')     #文件只读，写入失败
f.closed（测试f是否关闭）
 

　　

转载于:https://www.cnblogs.com/hkcs/p/7731673.html