Python基础及语法（七）

文件操作

文件常用操作

open：打开

read：读取

write：写入

close：关闭

readline：行读取

readlines：多行读取

seek：文件指针操作

tell：指针位置

打开操作

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

mode模式

r：只读打开

w：只写打开新文件

x：创建新文件

a：只写打开，追加内容

b：二进制模式

t：缺省模式，文本模式

+：读或写打开后，追加缺失模式

buffering缓冲区

缺省-1，二进制模式使用io.DEFAULT_BUFFER_SIZE可以查到默认是4096或8192。文本模式终端设备下是行缓冲。

0表示关闭行缓冲。

1表示只使用行缓冲。

大于1表示设置二进制模式缓存值。

缓冲区指暂时放置在内存。

encoding

编码

errors

None和strict表示错误抛出异常，ignore表示忽略。

newline

读时：缺省为None，表示'\r','\n','\r\n'均转为'\n'，‘’表示不换行，其它字符可为分行。

写时：缺省表示'\n'被替换为系统缺省行分隔符os.linesep,'\n'表示'\n'不替换，其它字符表示换行符会替换为指定字符。

closefd

关闭文件描叙符，True表示关闭它。False会在文件关闭后保留描叙符。fileobj.fileno()查看

文件指针

 seek(offset, whence = 0)

offset为0时代表文本开头，为1时代表当前指针位置，为2时代表文件末端。

文本模式下offset只能时0的时候whence可以不为0，为正整数，表示偏移多少字节。

二进制模式下offset为0时whence为正整数，表示便宜多少字节，offset为1和2时可正可负。

read读取

read(size=-1)

缺省-1表示指针所在位置后全部读取，填正数表示读取指针位置后多少个字节。

行读取

readline(size=-1)

缺省-1一行行读取，填正数表示读取行内前几个字节。

readlines()

按行读取所有内容，返回列表。

write写

write(s)，文本模式时，从指针开始写入s并返回写入字节数，二进制时把bytes写入并返回字节数。

writelines(lines)，把字符串列表写入文件。

close关闭

关闭文件。

其它

seekable()：是否可seek

readable()：是否可读

writeable()：是否可写

closed：是否已关闭

f = open('test.txt', 'w+')
f.write('HI\n')
f.writelines(['Hello\n', 'a'])
f.seek(0)
print(f.readlines())  # ['HI\n', 'Hello\n', 'a']
print(f.seekable())  # True
print(f.readable())  # True
print(f.writable())  # True
print(f.closed)  # False
f.close()
print(f.closed)  # True

上写文管理

文件打开用完后一定要关闭，不然系统会有进程残留，久了当数量达到上限张不能再打开文件导致错误。

with语句可以有效控制文件关闭。

with open('test') as f:
    print(f.closed)  # False
print(f.closed)  # True

 StringIO和BytesIO

IO模块中的类，在内存中开辟一个处理文本或二进制文本的空间，close后内存释放。

import io
f = io.StringIO()
f.write('HI')  # HI
f.seek(0)
print(f.read())
b = io.BytesIO()
b.write(b'a')
b.seek(0)
print(b.read())  # b'a'

file-like对象

类文件对象，可以像文件一样操作。

import sys
f = sys.stdout
f.write('HI')  
f = sys.stderr
f.write('Hello')
# HelloHI

 正则表达式

正则表达式修饰符 - 可选标志

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

正则表达式模式

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	匹配n个前面表达式。例如，"o{2}"不能匹配"Bob"中的"o"，但是能匹配"food"中的两个o。
re{ n,}	精确匹配n个前面表达式。例如，"o{2,}"不能匹配"Bob"中的"o"，但能匹配"foooood"中的所有o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	G匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (...), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。
\w	匹配字母数字
\W	匹配非字母数字
\s	匹配任意空白字符，等价于 [\t\n\r\f].
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9].
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.	匹配一个换行符。匹配一个制表符。等
\1...\9	匹配第n个分组的子表达式。
\10	匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。

详细正则表达式参考：https://www.w3cschool.cn/regex_rmjc/

路径操作

from os import path模块

 

from os import path
p = path.join('d:/', 'python', 'vn')
print(p, type(p))  # d:\python\vn <class 'str'>
print(path.exists(p))  # True 或 False 表示存在或不存在
print(path.split(p))  # ('d:\\python', 'vn')，分割路径
print(path.dirname(p), path.basename(p))  # d:\python vn 路径和基名
print(path.abspath(''), path.abspath('.'))  # 绝对路径
print(path.abspath(__file__))  # 打印当前文件路径
print(path.splitdrive(p))  # ('d:', '\\python\\vn')，windows方法

 

from pathlib import Path模块

from pathlib import Path
p = Path('.')  # 空白，''， '.'均为当前目录
print(Path('d:/', 'python/vn'))  # d:\python\vn
print(Path('d:/', Path('python', 'vn')))  # d:\python\vn
p1 = 'vn' / p
p2 = 'python' / p1
p3 = p1 / p2
print(p1, p2, p3)  # vn python\vn vn\python\vn
print(p3.joinpath('a', 'b/c', Path('d/e')))  # vn\python\vn\a\b\c\d\e
print(p3.parts)  # ('vn', 'python', 'vn')
print(p3.parent)  # vn\python
for i in p3.parents:
    print(i)
# vn\python
# vn
# .
p = Path('/a/b/c/d/e.py')
print(p.parent)  # \a\b\c\d
print(p.name)  # e.py
print(p.stem)  # e
print(p.suffix)  # .py
print(p.suffixes)  # ['.py']
print(p.with_name('f'))  # \a\b\c\d\f
print(p.with_name('f').with_suffix('.txt'))  # \a\b\c\d\f.txt
print(p.cwd())  # 返回当前工作目录
print(p.home())  # 返回当前家目录
print(p.exists())  # 返回True或False，判断目录或文件是否存在
print(p.is_dir())  # 返回True或False，判断是否为目录
print(p.is_file())  # 返回True或False，判断是否为文件
print(p.is_symlink())  # 返回True或False，判断是否为软连接
print(p.is_socket())  # 返回True或False，判断是否为socket文件
print(p.is_block_device())  # 返回True或False，判断是否为块设备
print(p.is_char_device())  # 返回True或False，判断是否为字符设备
print(p.is_absolute())  # 返回True或False，判断是否为绝对路径
print(p.resolve())  # 返回一个绝对路径，如果是软连接则直接被解析
print(p.absolute())  # 获取结对路径
p = Path('d:/a/b')
p.mkdir(parents=True, exist_ok=True)  # 创建目录
p.rmdir()  # 删除空目录，目录非空不能删除，抛出异常
p.mkdir(parents=True, exist_ok=True)  # 创建目录，parents为False时父目录不存在抛出异常，exit_ok为False时路径存在抛出异常
(p / 'c.py').touch()  # 创建文件
print(p.stat())  # 获取文件或目录信息
print(p.lstat())  # 获取文件或目录信息
print(p.as_uri())  # file:///d:/a/b，把路径返回成URI
for i in Path('d:/').iterdir():  # 迭代目录里的文件和目录
    print(i)

通配符

glod(pattern)通配给定的模式，返回生成器对象

 

rglod(pattern)通配给定的模式，递归目录，返回生成器对象

？代表一个字符

*代表任意个字符

[a-z]或[abc]代表一个字符

from pathlib import Path
print(list(Path('d:/a/b').glob('c*')))  # 返回c开头的文件路径列表

文件操作

from pathlib import Path
p = Path('d:/a/b/c.py')
p.write_text('a')  # 文档模式写入
p.write_bytes(b'a')  # 二进制模式写入
print(p.read_text())  # a，文本模式读取
print(p.read_bytes())  # b'a'，二进制模式读取
with Path('d:/a/b/c.txt').open() as f:
    print(f.read())

os模块

操作系统平台

from pathlib import Path
import os
print(os.name)  # windows系统是nt，linux系统是linux
print(os.listdir(Path('d:/')))  # 获取目录下文件和目录信息
print(os.stat(Path('d:/a/b/c.py')))  # 获取文件信息
os.chmod(Path('d:/a/b/c.py'), 0o777)  # 修改权限

shutil模块

高级文件操作库

copy复制

 

from pathlib import Path
import shutil


def ignore(src, names):
    print(src, names)
    ig = filter(lambda x: x.startswith('a'), names)
    print(list(ig))
    return set(ig)


a = Path('d:/a/b/a.txt')  # 原文件
b = Path('d:/a/b/b.txt')
c = Path('d:/a/b/c.txt')
d = Path('d:/a/b/d.txt')
e = Path('d:/a/b/e.txt')
with a.open() as aa:
    with b.open('w') as bb:
        shutil.copyfileobj(aa, bb)  # 复制内容
shutil.copyfile(a, c)  # 复制内容
shutil.copymode(a, c)  # 复制权限
shutil.copystat(a, c)  # 复制元数据和权限
shutil.copy(a, d)  # 复制内容和权限和部分元数据
shutil.copy2(a, e)  # 复制内容和权限和元数据
shutil.copytree(Path('d:/a/b/'), Path('d:/a/c/'), ignore=ignore)  # 复制目录
# copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,ignore_dangling_symlinks=False)
# ignore接受一个函数,函数接收两个参数src和os.listdir(src),返回set,copytree张过滤set的内容

rm删除

from pathlib import Path
import shutil
shutil.rmtree(Path('d:/a/c'))  # 如同rm -rf一样危险，慎用

move移动

from pathlib import Path
import shutil
shutil.move(Path('d:/a/b'), Path('d:/a/c'))

压缩

from pathlib import Path
import shutil
shutil.make_archive(Path('d:/a/z'), 'zip', Path('d:/a/c/'))  # 把目录c里的文件和目录压缩成z.zip