python10

一、IO open
open() 函数用于创建或打开指定文件，该函数的语法格式如下：

file = open(file_name [, mode[, buffering]])

1.open() 函数第二个参数是一个字符串，用于指定文件的打开方式，如果该字符串中出现 b，则表示以二进制格式打开文件；反之，则以普通的文本格式打开文件。

2.在 Windows 系统中，文件中用 “\r\n” 作为行末标识符（即换行符）。
当以文本格式读取文件时，会将 “\r\n” 转换成 “\n”；反之，以文本格式将数据写入文件时，会将 “\n” 转换成 “\r\n”。
这种隐式转换换行符的行为，对用文本格式打开文本文件是没有问题的，但如果用文本格式打开二进制文件，就有可能改变文本中的数据（将 \r\n 隐式转换为 \n）。

而在 Unix/Linux 系统中，默认的文件换行符就是 \n，因此在 Unix/Linux 系统中文本格式和二进制格式并无本质的区别。

总的来说，为了保险起见，对于 Windows平台最好用 b 打开二进制文件；对于 Unix/Linux 平台，打开二进制文件，可以用 b，也可以不用。

二、read() 函数的
基本语法格式如下：

file.read([size])

1.调用 read() 方法时不传入参数，该方法默认会读取全部文件内容。

2.read()函数抛出UnicodeDecodeError异常的解决方法

当使用 open() 函数打开文本文件时，默认会使用当前操作系统的字符集，比如 Windows 平台，open() 函数默认使用 GBK 字符集。
因此，上面程序读取的 a.txt 也必须使用 GBK 字符集保存；否则，程序就会出现UnicodeDecodeError错误。

如果要读取的文件所使用的字符集和当前操作系统的字符集不匹配，则有两种解决方式：
1）使用二进制模式读取，然后用 bytes 的 decode() 方法恢复成字符串。

例如，下面程序使用二进制模式来读取文本文件：

# 指定使用二进制方式读取文件内容，a.txt 以 utf-8 编码存储
f = open("a.txt", 'rb', True)

# 直接读取全部文件，并调用bytes的decode将字节内容恢复成字符串
print(f.read().decode('utf-8'))
f.close()

2）利用 codecs 模块的 open() 函数来打开文件，该函数在打开文件时允许指定字符集。

下面程序使用 codes 模块的 open() 函数来打开文件，此时可以显式指定字符集：

import codecs
#指定使用utf-8 字符集读取文件内容
f = codecs.open("a.txt", 'r', 'utf-8', buffering=True)
while True:
    #每次读取一个字符
    ch = f.read(1)
    #如果没有读取到数据，则跳出循环
    if not ch : break
    #输出ch
    print (ch, end='')
f.close()

三、readline()函数

file.readline([size])

其中，file 为打开的文件对象；size 为可选参数，用于指定读取每一行时，一次最多读取的字符数。

#a.txt中有两行内容，分别是：
#C语言中文网
#http://c.biancheng.net

f = open("a.txt", 'r', True)
while True:
    # 每次读取一行
    line = f.readline(3)
    # 如果没有读到数据，跳出循环
    if not line: break
    # 输出line
    print(line)
f.close()

运行结果为：

C语言
中文网


htt
p:/
/c.
bia
nch
eng
.ne
t

readlines()函数
readlines() 函数用于读取文件中的所有行，它和调用不指定 size 参数的 read() 函数类似，只不过该函数返回是一个字符串列表，其中每个元素为文件中的一行内容。

f = open("a.txt", 'r', True)
lines = f.readlines()
for line in lines:
    print(line)

运行结果为：

C语言中文网
http://c.biancheng.net

四、seek()和tell()函数详解
1。文件指针用于标明文件读写的起始位置。假如把文件看成一个水流
文件中每个数据（以 b 模式打开，每个数据就是一个字节；以普通模式打开，每个数据就是一个字符）就相当于一个水滴，而文件指针就标明了文件将要从文件的哪个位置开始读起。

2.tell() 函数用于判断文件指针当前所处的位置，而 seek() 函数用于移动文件指针到文件的指定位置。

3.seek()函数
seek() 函数用于将文件指针移动至指定位置，该函数的语法格式如下：

file.seek(offset[, whence])

其中，各个参数的含义如下：
file：表示文件对象；
whence：作为可选参数，用于指定文件指针要放置的位置，该参数的参数值有 3 个选择：0 代表文件头（默认值）、1 代表当前位置、2 代表文件尾。
offset：表示相对于 whence 位置文件指针的偏移量，正数表示向后偏移，负数表示向前偏移。例如，当whence == 0 &&offset == 3（即 seek(3,0) ），表示文件指针移动至距离文件开头处 3 个字符的位置；当whence == 1 &&offset == 5（即 seek(5,1) ），表示文件指针向后移动，移动至距离当前位置 5 个字符处。

注意，当 offset 值非 0 时，Python 要求文件必须要以二进制格式打开，
否则会抛出 io.UnsupportedOperation 错误。

五、with as用法详解
1.with as 语句的基本语法格式为：

with 表达式 [as target]：
    代码块

2.with as底层原理详解

1.简单的理解，同时包含 enter() 和 exit() 方法的对象就是上下文管理器。也就是说，上下文管理器必须实现如下两个方法：
__enter__(self)：进入上下文管理器自动调用的方法，该方法会在 with as 代码块执行之前执行。如果 with 语句有 as子句，那么该方法的返回值会被赋值给 as 子句后的变量；该方法可以返回多个值，因此在 as 子句后面也可以指定多个变量（多个变量必须由“()”括起来组成元组）。

__exit__（self, exc_type, exc_value, exc_traceback）：退出上下文管理器自动调用的方法。该方法会在 with as 代码块执行之后执行。如果 with as 代码块成功执行结束，程序自动调用该方法，调用该方法的三个参数都为 None：如果 with as 代码块因为异常而中止，程序也自动调用该方法，使用 sys.exc_info 得到的异常信息将作为调用该方法的参数。

当 with as 操作上下文管理器时，就会在执行语句体之前，先执行上下文管理器的 __enter__() 方法，然后再执行语句体，最后执行 __exit__() 方法。

2.基于类的上下文管理器
通过上面的介绍不难发现，只要一个类实现了 enter() 和 exit() 这 2 个方法，程序就可以使用 with as 语句来管理它，通过 exit() 方法的参数，即可判断出 with 代码块执行时是否遇到了异常。

3.除了基于类的上下文管理器，它还可以基于生成器实现。
可以使用装饰器 contextlib.contextmanager，来定义自己所需的基于生成器的上下文管理器

from contextlib import contextmanager

@contextmanager
def file_manager(name, mode):
    try:
        f = open(name, mode)
        yield f
    finally:
        f.close()
       
with file_manager('a.txt', 'w') as f:
    f.write('hello world')

不要忘记在方法“exit()”或者是 finally 块中释放资源，这一点尤其重要。

六、fileinput模块：逐行读取多个文件
fileinput 模块提供了 input 函数，可以把多个输入流合并在一起，该函数的语法格式如下：

fileinput.input（files="filename1, filename2, ...", 
inplace=False, backup='', bufsize=0, mode='r', openhook=None）

此函数会返回一个 FileInput 对象，其中，各个参数的含义如下：

files：多个文件的路径列表；
inplace：用于指定是否将标准输出的结果写回到文件，此参数默认值为 False；
backup：用于指定备份文件的扩展名；
bufsize：指定缓冲区的大小，默认为 0；
mode：打开文件的格式，默认为 r（只读格式）；
openhook：控制文件的打开方式，例如编码格式等。

假设，目前有 a.txt 和 b.txt 文件，它们位于同一目录，并各自包含如下内容：

#a.txt包含如下内容：
C语言中文网
http://c.biancheng.net

#b.txt包含如下内容：
Python基础教程
http://c.biancheng.net/python

===============================================================

import fileinput
# 一次读取多个文件
for line in fileinput.input(files=('a.txt', 'b.txt')):
    # 输出文件名，当前行在当前文件中的行号
    print(fileinput.filename(), fileinput.filelineno(), line)
# 关闭文件流
fileinput.close()

上面程序使用 fileinput.input 直接合并了 a.txt 和 b.txt 两个文件，这样程序可以直接遍历读取这两个文件的内容。程序运行结果如下：

a.txt 1 C语言中文网

a.txt 2 http://c.biancheng.net
b.txt 1 Python基础教程

b.txt 2 http://c.biancheng.net/python

七、linecache模块用法：随机读取文件指定行

1.linecache 模块允许从 Python 源文件中随机读取指定行，并在内部使用缓存优化存储。由于该模块主要被设计成读取 Python 源文件，因此它会用 UTF-8 字符集来读取文本文件。

2.linecache 模块包含以下常用函数：
linecache.getline(filename, lineno, module_globals=None)：读取指定模块中指定文件的指定行。其中 filename 指定文件名，lineno 指定行号。
linecache.clearcache()：清空缓存。
linecache.checkcache(filename=None)：检查缓存是否有效。如果没有指定 filename 参数，则默认检查所有缓存的数据。

import linecache
import random
# 读取random模块的源文件的第3行
print(linecache.getline(random.__file__, 3))
# 读取本程序的第3行
print(linecache.getline('linecache_test.py', 3))
# 读取普通文件的第2行
print(linecache.getline('utf_text.txt', 2))

八、pathlib模块用法详解

程序在创建 PurePath 和 Path时，既可传入单个路径字符串，也可传入多个路径字符串，PurePath 会将它们拼接成一个字符串。

1.如果在创建 PurePath 时不传入任何参数，系统默认创建代表当前路径的 PurePath，相当于传入点号（代表当前路径）作为参数。例如如下代码：

from pathlib import *
# 如果不传入参数，默认使用当前路径
pp = PurePath()
print(pp) # .

2.如果在创建 PurePath 时传入的参数包含多个根路径，则只有最后一个根路径及后面的子路径生效。例如如下代码：

# 如果传入参数包含多个根路径，则只有最后一个根路径及后面子路径生效
pp = PurePosixPath('/etc', '/usr', 'lib64')
print(pp) # /usr/lib64
pp = PureWindowsPath('c:/Windows', 'd:info')
print(pp) # d:info

3.需要说明的是，在 Windows 风格的路径中，只有盘符才能算根路径，仅有斜杠是不算的。例如如下代码：

# 在Windows风格路径中，只有盘符才算根路径
pp = PureWindowsPath('c:/Windows', '/Program Files')
print(pp) # c:\Program Files

4.如果在创建 PurePath 时传入的路径字相串中包含多余的斜杠和点号，系统会直接忽略它们。但不会忽略两点，因为两点在路径中有实际意义（两点代表上一级路径）。例如如下代码：

# 路径字符串中多出来的斜杠和点号（代表当前路径）都会被忽略
pp = PurePath('crazyit//info')
print(pp) # crazyit\info

pp = PurePath('crazyit/./info')
print(pp) # crazyit\info

pp = PurePath('crazyit/../info')
print(pp) # crazyit\..\info，相当于找和crazyit同一级的info路径

5.PurePath 对象支持斜杠（/）作为运算符，该运算符的作用是将多个路径连接起来。不管是 UNIX 风格的路径，还是 Windows 风格的路径，都是使用斜杠作为连接运算符的：

pp = PureWindowsPath('abc')
# 将多个路径拼起来（Windows风格的路径）
print(pp / 'xyz' / 'wawa') # abc\xyz\wawa
pp = PurePosixPath('abc')

# 将多个路径拼起来（Unix风格的路径）
print(pp / 'xyz' / 'wawa') # abc/xyz/wawa
pp2 = PurePosixPath('haha', 'hehe')

# 将pp、pp2两个路径连接起来
print(pp / pp2) # abc/haha/hehe

**

Path类的功能和用法

**

1.PurePath 和 Path 最根本的区别在于，PurePath 处理的仅是字符串，而 Path 则会真正访问底层的文件路径，因此它提供了属性和方法来访问底层的文件系统。

2.Path方法
Path 对象包含了大量 is_xxx() 方法，用于判断该 Path 对应的路径是否为 xxx。

Path 包含一个 exists() 方法，用于判断该 Path 对应的目录是否存在。

Path 还包含一个很常用的 iterdir() 方法，该方法可返回 Path 对应目录下的所有子目录和文件。

此外，Path 还包含一个 glob() 方法，用于获取 Path 对应目录及其子目录下匹配指定模式的所有文件，借助此方法可以非常方便地查找指定文件。

from pathlib import *

# 获取当前目录
p = Path('.')

# 遍历当前目录下所有文件和子目录
for x in p.iterdir():
    print(x)
    
# 获取上一级目录
p = Path('../')

# 获取上级目录及其所有子目录下的的py文件
for x in p.glob('**/*.py'):
    print(x)
    
# 获取g:/publish/codes对应的目录
p = Path('g:/publish/codes')

# 获取上级目录及其所有子目录下的的py文件
for x in p.glob('**/Path_test1.py'):
    print(x)

运行上面程序，可以看到如下输出结果：

Path_test1.py
PurePath_test1.py
PurePath_test2.py
PurePath_test3.py
..\12.1\Path_test1.py
..\12.1\PurePath_test1.py
..\12.1\PurePath_test2.py
..\12.1\PurePath_test3.py
g:\publish\codes\12\12.1\path_test1.py

此外，Path 还提供了 read_bytes() 和 read_text(encoding=None, errors=None) 方法，分别用于读取该 Path 对应文件的字节数据（二进制数据）和文本数据；也提供了 write_bytes(data) 和 Path.write_text(data, encoding=None, errors=None) 方法来输出字节数据（二进制数据）和文本数据。

九、os.path模块常见函数用法（实例+详细注释）

os.path 模块下提供了一些操作目录的方法，这些函数可以操作系统的目录本身。
例如，该模块提供了 exists() 函数判断该目录是否存在，
也提供了 getctime()、getmtime()、getatime() 函数来获取该目录的创建时间、最后一次修改时间、最后一次访问时间，
还提供了 getsize() 函数来获取指定文件的大小。

import os
import time
# 获取绝对路径
print(os.path.abspath("abc.txt")) # G:\publish\codes\12\12.2\abc.txt
# 获取共同前缀
print(os.path.commonprefix(['/usr/lib', '/usr/local/lib'])) # /usr/l
# 获取共同路径
print(os.path.commonpath(['/usr/lib', '/usr/local/lib'])) # \usr
# 获取目录
print(os.path.dirname('abc/xyz/README.txt')) #abc/xyz
# 判断指定目录是否存在
print(os.path.exists('abc/xyz/README.txt')) # False
# 获取最近一次访问时间
print(time.ctime(os.path.getatime('os.path_test.py')))
# 获取最后一次修改时间
print(time.ctime(os.path.getmtime('os.path_test.py')))
# 获取创建时间
print(time.ctime(os.path.getctime('os.path_test.py')))
# 获取文件大小
print(os.path.getsize('os.path_test.py'))
# 判断是否为文件
print(os.path.isfile('os.path_test.py')) # True
# 判断是否为目录
print(os.path.isdir('os.path_test.py')) # False
# 判断是否为同一个文件
print(os.path.samefile('os.path_test.py', './os.path_test.py')) # True

十、 fnmatch模块：用于文件名的匹配
前面介绍的那些操作目录的函数只能进行简单的模式匹配，但 fnmatch 模块可以支持类似于 UNIX shell 风格的文件名匹配。
fnmatch 匹配支持如下通配符：
*：可匹配任意个任意字符。
？：可匹配一个任意字符。
[字符序列]：可匹配中括号里字符序列中的任意字符。该字符序列也支持中画线表示法。比如[a-c]可代表a、b 和 c 字符中任意一个。
[!字符序列]：可匹配不在中括号里字符序列中的任意字符。

在该模块下提供了如下函数：
1.fnmatch.fnmatch(filename, pattern)：判断指定文件名是否匹配指定 pattern。如下程序示范了 fnmatch() 函数的用法：

from pathlib import *
import fnmatch
# 遍历当前目录下所有文件和子目录
for file in Path('.').iterdir():
    # 访问所有以_test.py结尾的文件
    if fnmatch.fnmatch(file, '*_test.PY'):
        print(file)

上面程序先遍历当前目录下的所有文件和子目录，然后第 7 行代码调用 fnmatch() 函数判断所有以 _test.py 结尾的文件，并将该文件打印出来。
2.fnmatch.fnmatchcase(filename, pattern)：该函数与上一个函数的功能大致相同，只是该函数区分大小写。

3.fnmatch.filter(names, pattern)：该函数对 names 列表进行过滤，返回 names 列表中匹配 pattern 的文件名组成的子集合。如下代码示范了该函数的功能：

names = ['a.py', 'b.py', 'c.py', 'd.py']
# 对names列表进行过滤
sub = fnmatch.filter(names, '[ac].py')
print(sub) # ['a.py', 'c.py']

上面程序定义了一个 [‘a.py’, ‘b.py’, ‘c.py’, ‘d.py’] 集合，该集合中的 4 个元素都代表了指定文件（实际上文件是否存在，fnmatch 模块并不关心）。接下来程序中第 3 行代码调用了 filter() 函数对 names 进行过滤，过滤完成后只保留匹配 [ac].py 模式的文件名（要求文件名要么是 a.py，要么是 c.py）。

4.fnmatch.translate(pattern)：该函数用于将一个 UNIX shell 风格的 pattern 转换为正则表达式 pattern。如下代码示范了该函数的功能：

print(fnmatch.translate('?.py')) # (?s:.\.py)\Z
print(fnmatch.translate('[ac].py')) # (?s:[ac]\.py)\Z
print(fnmatch.translate('[a-c].py')) # (?s:[a-c]\.py)\Z

十一、os模块详解
os模块与目录相关的函数
与目录相关的函数如下：
os.getcwd()：获取当前目录。
os.chdir(path)：改变当前目录。
os.fchdir(fd)：通过文件描述利改变当前目录。该函数与上一个函数的功能基本相似，只是该函数以文件描述符作为参数来代表目录。

import os
# 获取当前目录
print(os.getcwd())  # G:\publish\codes\12.7
# 改变当前目录
os.chdir('../12.6')
# 再次获取当前目录
print(os.getcwd())  # G:\publish\codes\12.6

os.chroot(path)：改变当前进程的根目录。
os.listdir(path)：返回 path 对应目录下的所有文件和子目录。
os.mkdir(path[, mode])：创建 path 对应的目录，其中 mode 用于指定该目录的权限。该 mode参数代表一个 UNIX 风格的权限，比如 0o777 代表所有者可读/可写/可执行、组用户可读/可写/可执行、其他用户可读/可写/可执行。
os.makedirs(path[, mode])：其作用类似于 mkdir()，但该函数的功能更加强大，它可以边归创建目录。比如要创建 abc/xyz/wawa 目录，如果在当前目录下没有 abc 目录，那么使用 mkdir() 函数就会报错，而使用 makedirs() 函数则会先创建 abc，然后在其中创建 xyz 子目录，最后在 xyz 子目录下创建 wawa 子目录。

os.rmdir(path)：删除 path 对应的空目录。如果目录非空，则抛出一个 OSError 异常。程序可以先用 os.remove() 函数删除文件。
os.removedirs(path)：边归删除目录。其功能类似于 rmdir()，但该函数可以递归删除 abc/xyz/wawa 目录，它会从 wawa 子目录开始删除，然后删除 xyz 子目录，最后删除 abc 目录。

os.rename(src, dst)：重命名文件或目录，将 src 重名为 dst。
os.renames(old, new)：对文件或目录进行递归重命名。其功能类似于 rename()，但该函数可以递归重命名 abc/xyz/wawa 目录，它会从 wawa 子目录开始重命名，然后重命名 xyz 子目录，最后重命名 abc 目录。

os模块与权限相关的函数

os.access(path, mode)：检查 path 对应的文件或目录是否具有指定权限。该函数的第二个参数可能是以下四个状态值的一个或多个值：
os.F_OK：判断是否存在。
os.R_OK：判断是否可读。
os.W_OK：判断是否可写。
os.X_OK：判断是否可执行。

十二、 tempfile模块：生成临时文件和临时目录

上面第一行输出结果就是程序生成的临时文件的文件名，最后一行输出结果就是程序生成的临时目录的目录名。需要注意的是，不要去找临时文件或临时文件夹，因为程序退出时该临时文件和临时文件夹都会被删除。