python中open文件路径_五.Python文件IO和路径操作

目录

Python文件IO操作

上下文管理with

路径操作

01 Python文件IO操作：

clumn

column

open

打开

read

读取

write

写入

close

关闭

readline

行读取

readlines

多行读取

seek

文件指针操作

tell

指针位置

打开文件

open(file, mode=‘r‘, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

示例

f = open('test')

# windows < io.TextIOWrapper name='test', mode='r', encoding='cp936'

# linux < io.TextIOWrapper name='test', mode='r', encoding='utf-8'

print(f.read())

f.close()

文件操作中，最常用的就是读和写。

文件访问的模式有两种：文本模式和二进制模式。不同模式下，操作函数不尽相同，表现的结果也不一样。

open的参数

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

>>> 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='\t')

if x.is_dir():

flag = False

for _ in x.iterdir():

flag = True

break

print('dir', 'Not Empty' if flag else 'Empty', sep='\t')

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语句

with p.open('w') as f:

pass

3.5增加的新函数

p.write_text(content) #每次打开会清空，重新数据

p.write_bytes(content) #每次打开会清空，重写数据

p.read_text()

p.read_bytes()

原文地址：https://www.cnblogs.com/luckyleaf/p/12112792.html