五.Python文件IO和路径操作

Posted 2020-11-26 luckyleaf

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了五.Python文件IO和路径操作相关的知识，希望对你有一定的参考价值。

clumn	column
open	打开
read	读取
write	写入
close	关闭
readline	行读取
readlines	多行读取
seek	文件指针操作
tell	指针位置

file 打开或者要创建的文件名，如果不指定路径，默认是当前路径
文件描述符
0 1 2已经被占用
mode模式
r 缺省的，表示只读打开
w 只写打开
x 创建并写入一个新文件
a 写入打开，如果文件存在，则追加
b 二进制模式打开
t 缺省的，文本模式
+ 读写打开一个文件，给原来只读、只写方式打开提供缺失的读或者写能力

模式	描述
r 模式	只读打开文件，如果使用write方法，则会抛出异常；如果文件不存在，抛出FileNotFoundError异常
w	只写打开，如果读取则抛出异常；如果文件不存在，则直接创建文件；如果文件存在，则清空文件内容
x	文件不存在，创建文件，并只写方式打开；文件存在，抛出FileExistsError异常
a	文件存在，只写打开，追加内容；文件不存在，则创建后，只写打开，追加内容
r只读，wxa都是只写	wxa都可以产生文件，w不管文件存在与否，都会生成全新内容的文件；a不管文件是否存在，都能在打开的文件尾部追加；x必须要求文件事先不存在，自己造一个文件。
文本模式t	字符流，将文件的字节按照某种字符编码理解，按照字符操作。默认模式。
二进制模式b	字节流，将文件按照字节理解，与字符编码无关。二进制模式操作时，字节操作使用bytes类型。

文件指针
mode = r 指针起始在0
mode = a 指针起始在EOF（文件末尾）
tell() 显示指针位置

seek(offset[,whence]) 移动指针. offset偏移多少字节。
文本模式下：
whence 0 缺省值，表示从头开始，只接受正整数
whence 1 表示从当前位置，只接受0
whence 2表示从EOF位置开始，只接受0
字节模式：
wence 0 缺省值，表示从头开始，offset只接受正整数
whence 1 表示从当前位置，offset可正可负
whence 2表示从EOF位置开始，offset可正可负

常用函数

函数	说明
read(size=-1)	默认读取所有，文本模式下为读取字符数量，字节模式下为字节数
readline(size=-1)	一次读取多少行内容，默认所有
readlines	读取多行内容
write(s)	把字符串s写入到文件中，并返回字符的个数
close()	flush并关闭文件对象，关闭后，再次关闭没有效果

其他函数

函数	说明
seekable()	是否可seek
readable()	是否可读
writeabel()	是否可写
closed()	是否已经关闭

02 上下文管理

引出：

#
lst = []
for _ in range(2000):
    lst.append(open("test"))
# OSError: [Errno 24] Too many open files:'test'
print(len(lst))

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

解决办法：

1.异常处理
当出现异常的时候，拦截异常，但是很多代码都可能出现OSError异常，还不好判断异常就是因为资源限制产生的。

f = open('test')
try:
    f.write('abc')
finally:
    f.close()

使用finally 可以保证所有文件可以被关闭。

2.上下文管理
一种特殊的语法，交给解释器去释放文件。

with open('test') as f:
    f.read()

使用with...as关键字：
上下文管理语句并不会开启新的作用域
with语句块执行完的时候，会自动关闭文件对象

对应类似文件对象的IO对象，一般来说都需要在不使用的时候关闭、注销，以释放资源。
IO被打开的时候，会获得的文件描述符fd。计算机资源是有限的，所以操作系统都会做限制。
就是为了保护计算机资源不要被完全耗尽，计算资源是共享的，不是独占的。
一般情况下，除非特别明确的知道资源情况，否则不要提高资源的限制来解决问题。

StingIO和BytesIO

StingIO
io模块中类： from io import StringIO
内存中，开辟的一个文本模式的buffer，可以像文件对象一样操作它
当close方法被调用的时候，这个buffer会被释放
getvalue() 获取全部内容，跟文件指针没有关系

from io import StingIO
sio = StringIO() # 跟文件操作类似
sio.write("test context")
sio.seek(0)
print(sio.getvalue())
print(sio.readline())
sio.close()

BytesIO
io模块中类： from io import BytesIO
内存中，开辟的一个二进制模式的buffer，可以像文件对象一样操作它
当close方法被调用的时候，这个buffer会被释放
getvalue() 获取全部内容，跟文件指针没有关系

与StringIO相似。
好处：一般来说，磁盘操作比内存操作慢的多，内存足够的情况下，一般的优化是少落地，减少磁盘IO的过程，可大大提高程序的运行效率。

file-like对象
类文件对象，可以像文件对象一样操作
socke对象、输入输出对象（stdin、stdout）都是类文件对象

from sys import stdout
f = stdout
print(type(f))
f.write('leafgood.com')

03 路径操作

路径操作模块

3.4版本之前:os.path模块

from os import path
p = path.join('/etc'. 'sysconfig', 'network')
print(type(p), p)
print(path.exists(p))
print(path.split(p))
print(path.abspath('.'))
p = path.join('o:/', p, 'text.txt')
print(path.dirname(p))
print(path.basename(p))
print(path.splitdrive(p)) # window下使用

3.4版本之后:pathlib模块，提供path对象来操作，包括目录和文件。

from pathlib import Path
p = Path()
p.absolute() #绝对路径
p = p.joinpath('a','b')
p.absolute()
p = p / 'c'  #拼接 等价于 p / = 'c' , p = p.joinpath('c')
#目录初始化
p = Path() #当前目录
p = Path('a', 'b', 'c/d') #当前目录下a/b/c/d
p = Path('/etc')

路径拼接和分解

操作符 /
Paht对象 / Path对象
Path对象 / 字符串或者字符串/Path对象

分解
parts属性，可以返回路径中的每一个部分

joinpath
joinpath(*others) 连接多个字符串到Path对象

获取路径
str(Path对象) 获取路径字符串
bytes(Path对象) 获取路径字符串的bytes
p = Path(‘/etc‘)
print(str(p), bytes(p))

父目录
p.parent
p.parents 返回一个可迭代对象
示例

>>> p.parents
<PosixPath.parents>
>>> list(p.parents)
[PosixPath('/home/zhaow/py/c/d'), PosixPath('/home/zhaow/py/c'), PosixPath('/home/zhaow/py'), PosixPath('/home/zhaow'), PosixPath('/home'), PosixPath('/')]
>>> p.parent
PosixPath('/home/zhaow/py/c/d')
>>> p.parent.parent
PosixPath('/home/zhaow/py/c')

相对路径转化成绝对路径后，再获取父目录，parent可以连续
name 目录的最后一个部分
suffix 目录最后一个部分的扩展名.后缀
stem 目录最后一个部分，没有后缀名
suffixes 返回多个扩展名列表
with_suffix(suffix) 补充扩展名到路径，或者替换扩展名
with_name(name) 替换目录最后一个部分并返回一个新的路径

>>> p
PosixPath('/home/zhaow/py/c/d/c/d.ifg.zip')
>>> p.name
'd.ifg.zip'
>>> p.stem
'd.ifg'
>>> p.suffix
'.zip'
>>> p.suffixes
['.ifg', '.zip']
>>> p.with_suffix('.gz')
PosixPath('/home/zhaow/py/c/d/c/d.ifg.gz')
>>> p.with_name('gz')
PosixPath('/home/zhaow/py/c/d/c/gz')
>>> p
PosixPath('/home/zhaow/py/c/d/c/d.ifg.zip')

不修改原路径：
cwd() 返回当前工作目录
home() 返回当前家目录

is_dir()是否是目录
is_file() 是否是文件
is_symlink()是否是软链接
is_socket() 是否是socket文件
is_block_device() 是否是块设备文件
is_char_device() 是否是字符设备
is_absolute() 是否是绝对路径

resolve() 返回一个新的路径，这个新路径就是当前Path对象的绝对路径，如果是软链接直接解析
absolute()
exists() 目录或者文件是否文件
rmdir() 删除空目录，没有提供判断目录为空的方法
touch(mode=0o666, exist_ok=True) 创建一个新文件
as_uri() 将路径返回成url

mkdir(mode=0o777, parents=False, exist_ok=False)
-- parents 是否创建父目录，True等同于mkdir -p

iterdir()迭代当前目录内容，返回一生成器对象

for x in p.parents[len(p.parents)-1].iterdir():
    print(x, end='	')
    if x.is_dir():
        flag = False
        for _ in x.iterdir():
            flag = True
            break
        print('dir', 'Not Empty' if flag else 'Empty', sep='	')
    elif x.is_file():
        print('file')
    else:
        print('other file')

通配符：
glob(pattern) 通配给定的模式

>>> list(p.glob('*/m*'))  #一个* 任意字符下
[PosixPath('Aclsm/manage.py')]
>>> list(p.glob('*m*'))
>>> list(p.glob('**/m*')) #任意字符任意级别

rglob(pattern) 通配给定的模式，递归目录

匹配
match(pattern) 模式匹配成功，返回True

>>> Path('a/b.py').match('*.py')
True
>>> Path('a/b/c.py').match('*.py')
True
>>> Path('a/b/c.py').match('b/*.py')
True
>>> Path('a/b/c.py').match('a/*.py')
False
>>> Path('a/b/c.py').match('a/**/.py')
False
>>> Path('a/b/c.py').match('a/**/*.py')
True
>>> Path('a/b/c.py').match('**/*.py')
True

文件操作
p = Path()
p.open(mode=‘r,buffering=-1,encoding=None,errors=None,newline=None)
使用方法类似内建函数open，返回一个文件对象
可以使用with语句