转载https://blog.csdn.net/weixin_44015805/article/details/99884093
Py文件操作库及应用(os、sys、pathlib ; open、fileinput、linecache)
# -*- coding: utf-8 -*-
'''
Py文件操作库及应用.py
(os、sys、pathlib ; open、fileinput、linecache)
深入：
注意：
一、文件编码解码问题
open(file,mode='a+', encoding='utf-8')
注意打开模式mode为带b的二进制打开模式时的后期输出时的解码才能输出中文问题，且编码解码注意一致。
使用：
一、文件系统级操作
1、os
2、sys
3、pathlib 提供了一组面向对象的类，类可代表各种操作系统上的路径
Path类 是 PurePath 的子类，除了支持 PurePath 的各种操作、属性和方法之外，
Path类会真正访问底层的文件路径，提供了属性和方法来访问底层的文件系统。
二、文件应用级操作
1、open
2、fileinput 迭代一系列文本文件中的所有行。其中input函数，可以把多个输入流合并在一起,然后进行一些循环操作等
fileinput.input()支持从命令行输入参数 即文件名（多个文件名用 files=[,]）
3、linecache 从文件中（所有utf-8文件中）读取指定行（所有行），并在内部使用缓存优化存储。
'''
# =============================================================================
# #文件系统级操作
# #(os、sys、pathlib)
# =============================================================================
# =============================================================================
# #os模块
# #os模块访问多个操作系统服务
# #os及其子模块os.path包含多个查看、创建和删除目录及文件的函数，以及一些操作路径的函数。如os.path.split 和 os.path.join
# =============================================================================
####################
#探索os模块
import os
help(os) #获取帮助信息
os.__doc__ #获取文档信息
os.__file__ #获取源码文件路径
os.__all__ #获取导入所有名称列表
os.__name__
dir(os) #打印所有 属性、方法、类。
help(os.environ) #包含环境变量的映射 如访问环境变量PATHONPATH,则使用 os.environ['PYTHONPATH]
help(os.system) #系统命令 在子shell中执行命令
help(os.sep) #路径中使用的分隔符
####################
#常用的变量、函数、类
#访问环境变量 PYTHONPATH
os.environ['PYTHONPATH'] #访问环境变量 PYTHONPATH
#运行命令行命令 直接输入CMD命令
os.system('cmd') #运行命令行命令 直接输入CMD命令
os.system('shutdown -s -t 300') #自动关机 300秒后
#打开一个路径/程序
os.startfile('C:\\Users\\Administrator\\AppData\\Local\\Google\\Chrome\\Application\\chrome.exe')
print(os.name) # 显示导入依赖模块的操作系统的名称
os.getenv('PYTHONPATH') # 获取PYTHONPATH环境变量的值
os.getlogin() # 返回当前系统的登录用户名
os.getpid() # 获取当前进程ID
os.getppid() # 获取当前进程的父进程ID
os.cpu_count() # 返回当前系统的CPU数量
os.sep # 返回路径分隔符
os.pathsep # 返回当前系统的路径分隔符
os.linesep # 返回当前系统的换行符
os.urandom(3) # 返回适合作为加密使用的、最多3个字节组成的bytes
####################
#与目录相关的函数
#获取当前目录
os.getcwd() #获取当前目录
#改变当前目录到指定目录
os.chdir('F:/SpyderXIANGMUWENJIANJIA/编程基础') #改变当前目录到指定目录
os.getcwd() #再次获取当前目录
#返回指定目录下的所有文件和子目录
os.listdir(os.getcwd()) #返回指定目录下的所有文件和子目录
#创建、重命名、删除等操作
#os.mkdir('os.mkdir测试创建目录',777) #当前目录下创建子目录 如果中间目录为空则报错
#os.rename('os.mkdir测试创建目录','o') #重命名当前目录下的子目录
#os.makedirs('os.mkdir测试创建目录1\\递归目录1\\递归目录2',777) #递归创建/a/b/c连环目录，比mkdir强大
#os.renames('os.mkdir测试创建目录1\\递归目录1\\递归目录2','a\\b\\c') #递归重命名连环目录
#os.remove('b.txt') # 删除文件 b.txt
#os.rmdir('o') #删除当前目录下的子目录 目录需要为空，否则报错。
#os.removedirs('a\\b\\c') #递归删除连环目录 如果没有找到目录则报错
####################
#os.path模块
#os.path模块提供了操作目录的方法。
import os,time
print(os.path.abspath('abc.txt')) #获取绝对路径
print(os.path.abspath('.')) #获取当前路径的绝对路径
print(os.path.commonprefix(['/usr/lib','/usr/local/lib'])) #获取共同前缀
print(os.path.commonpath(['usr/lib','usr/local/lib'])) #获取共同路径
print(os.path.dirname('abc/xyz/README.txt')) #获取目录
print(os.path.exists('abc/xyz/README.txt')) #判断指定目录是否存在
print(time.ctime(os.path.getatime('Py文件库linecache.py'))) #获取最近一次访问时间
print(time.ctime(os.path.getmtime('Py文件库linecache.py'))) #获取最后一次修改时间
print(time.ctime(os.path.getctime('Py文件库linecache.py'))) #获取创建时间
print(os.path.getsize('Py文件库linecache.py')) #获取文件大小
print(os.path.isfile('Py文件库linecache.py')) #判断是否为文件 # True
print(os.path.isdir('Py文件库linecache.py')) #判断是否为目录 # False
print(os.path.samefile('Py文件库linecache.py', './Py文件库linecache.py')) #判断是否为同一个文件 # True
# =============================================================================
# #sys模块
# #sys模块访问与python解释器紧密相关的变量和函数
# =============================================================================
####################
#探索sys模块
import sys,pprint #打印函数，能够妥善的打印输出
help(sys) #获取帮助信息
sys.__doc__ #获取文档信息
dir(sys) #打印包内所有 变量、函数、类等
help(sys.path) #python的搜索路径的目录列表，是一个字符串列表，其中每个字符串都是一个目录名
help(sys.modules) #将模块名映射到模块（仅限当前导入的模块）
help(sys.exit) #退出当前程序。可提供一个整数参数，支出程序是否成功
#应用于 try/finally 异常捕获时子句依然会执行。
help(sys.argv) #获取命令行输入参数 sys.argv[]
#包含传传递给python解释器的参数，包括脚本名，
#可应用于命令行
####################
#常用变量、函数、类
##########
#模块搜索路径列表中的 sit-packages目录 就是专门用来安放模块的目录。
print(sys.path) #输出python的搜索路径的目录列表
pprint.pprint(sys.path) #格式化打印函数
##########
#程序退出 sys.exit()
'''
sys.exit()会引发一个异常：SystemExit，如果这个异常没有被捕获，那么python解释器将会退出。
如果有捕获此异常的代码，那么这些代码还是会执行。捕获这个异常可以做一些额外的清理工作。
0为正常退出，其他数值（1-127）为不正常，可抛异常事件供捕获。也可添加异常提示信息。
os._exit()会直接将python程序终止，之后的所有代码都不会继续执行。
'''
help(sys.exit)
sys.exit.__doc__
#sys.exit('hahaha') #退出程序，并抛出异常。
try:
sys.exit()
except SystemExit: #捕获异常，做一些额外的清理工作。
print('die')
finally:
print('这里通过sys.exit()方法已程序退出，余下代码不再执行。')
#import os
#os._exit(0)
####################
#示例1
#sys.argv示例 获取命令行输入参数 sys.argv[]
#从命令行输入命令， 通过提供命令行输入的参数来执行源码内容
#命令行输入格式： python py文件名 参数1 参数2
#sys.argv[] 是用来获取命令行输入的参数的(参数和参数之间空格区分),
#sys.argv[0] 参数表示代码本身文件路径,所以从参数1开始,表示获取的参数了
'''
参考网址：
https://blog.csdn.net/u013205877/article/details/78571453
'''
#testSys_命令行参数.py
#自建测试文件 testSys_命令行参数.py 输出命令行参数
import sys
print('执行程序，参数为{}'.format(sys.argv[1:]))
#testSys_反转命令行参数.py
#自建测试文件 testSys_命令行参数.py 输出反向排序的命令行参数
import sys
args=sys.argv[1:]
args.reverse()
print('反转参数输出: ',' '.join(args))
####################
#示例2
#sys.path应用示例 sys.path.append() 动态修改添加python模块加载路径
#scrapy框架爬虫出现No module named: 的问题
'''
python执行的时候，是根据最初设置的python路径，
而我们创建的scrapy的路径不在上面路径的情况下，导致scrapy找不到路径，所以把该路径添加到python执行路径即可；
添加搜索路径至python搜索包路径的目录列表里就好，如下，然后重启程序运行即可。
'''
import os,sys
ffpath = os.path.dirname(os.path.dirname(os.path.abspath("."))) #获取目录名称os.path.dirname()，获取绝对路径os.path.abspath('.')
sys.path.append(ffpath)
# =============================================================================
# #pathlib模块
# #pathlib模块提供了一组面向对象的类，这种类可代表各种操作系统上的路径
# =============================================================================
'''
继续深入：
参考文档
https://docs.python.org/3/library/pathlib.html
'''
import pathlib
from pathlib import *
####################
#探索模块
help(pathlib)
pathlib.__doc__
pathlib.__file__
pathlib.__all__
dir(pathlib)
help(pathlib.PurePath) #PurePath类有两个子类，即 PurePosixPath 和 PureWindowsPath，分别代表 UNIX 风格的路径（包括 Mac OS X）和 Windows 风格的路径。；
help(pathlib.Path) #Path类有两个子类， 即 PosixPath 和 WindowsPath
####################
#常用属性、函数、类
'''
pathlib模块提供的一组面向对象的类，这种类可代表各种操作系统上的路径。
PurePath类 PurePath类有两个子类，即 PurePosixPath 和 PureWindowsPath，分别代表 UNIX 风格的路径（包括 Mac OS X）和 Windows 风格的路径。；
PurePath只是代表特定平台的路径字符串（它们本质上就是字符串）
Path类 Path类有两个子类，即 PosixPath 和 WindowsPath
Path 是 PurePath 的子类，除了支持 PurePath 的各种操作、属性和方法之外，
还会真正访问底层的文件系统，包括判断 Path 对应的路径是否存在，获取 Path 对应路径的各种属性（如是否只读、是文件还是文件夹等），甚至可以对文件进行读写。
PurePath 和 Path 最根本的区别在于，PurePath 处理的仅是字符串，而 Path 则会真正访问底层的文件路径，因此它提供了属性和方法来访问底层的文件系统。
'''
help(PurePath) #PurePath类有两个子类如下：
help(PurePosixPath)
help(PureWindowsPath)
help(Path) #Path类有两个子类如下：
help(PosixPath)
help(WindowsPath)
#########
#PurePath类
#PurePath只是代表特定平台的路径字符串（它们本质上就是字符串）
#创建PurePath类，在windows系统中实际上使用PureWindowsPath类。
help(PurePath)
pp=PurePath('test.py')
print(type(pp)) #如果在 Windows 系统上使用 PurePath 创建对象，程序实际返回 PureWindowsPath 对象。
#PurePath自动组成路径字符
pp=PurePath('crazyit','some/path','info') #自动组成路径字符串 #程序在创建 PurePath 和 Path时，既可传入单个路径字符串，也可传入多个路径字符串，PurePath 会将它们拼接成一个字符串
pp=PurePath() #无参数则默认创建当前路径，即点号 .
pp=PurePath(Path('crazyit'),Path('info')) #等同于上面的创建路径方法
pp=PurePosixPath('crazyit', 'some/path', 'info') #明确创建 unix风格 的路径
#根目录路径，只有最后一个生效
pp=PureWindowsPath('c:/windows','d:info') #如果传入多个根路径，则只有最后一个根路径及后面的子路精生效。
pp=PureWindowsPath('c:/windows','/program files') #在windows中只有盘符才算根路径
#路径字符串中多出来的斜杠和点号（代表当前路径）都会被忽略
#不会忽略两点..，因为两点在路径中有实际意义（两点代表上一级路径）
pp=PurePath('crazyit//info') #输出 crazyit//info
pp=PurePath('crazyit/./info') #点被忽略，因为代表当前路径。等同于上
pp=PurePath('crazyit/../info') #两个点不被忽略，因为代表上级目录
print(pp)
#PurePath类对象的比较运算
#不同风格的 PurePath，unix 和 windows它们依然可以比较是否相等（结果总是返回 False），但不能比较大小，否则会引发错误
PurePosixPath('info') == PurePosixPath('INFO') #unix系统的路径区分大小写
PureWindowsPath('info') == PureWindowsPath('INFO') #windows系统的路径不区分大小写
PureWindowsPath('info') in {PureWindowsPath('INFO')} #注意后面是 set类型集合
PurePosixPath('D:') < PurePosixPath('c:') #unix系统的路径区分大小写，所以返回True
PureWindowsPath('D:') > PureWindowsPath('c:') #windows系统的路径不区分大小写 所以返回True
#斜杠（/）拼接路径
#将多个路径连接起来。不管是 UNIX 风格的路径，还是 Windows 风格的路径，都是使用斜杠作为连接运算符
pp=PureWindowsPath('windows:','abc')
print(pp/'xyz') #拼接多个路径 windows风格
pp2=PurePosixPath('unix:','hehe') #拼接多个路径 unix风格
print(pp2/'haha')
print(pp/pp2) #拼接两个路径
#PurePath 的本质其实就是字符串，因此程序可使用 str() 将它们恢复成字符串对象
print(str(pp))
#PurePath类属性和类方法
'''
类属性和方法名 功能描述
PurePath.parts 该属性返回路径字符串中所包含的各部分。
PurePath.drive 该属性返回路径字符串中的驱动器盘符。
PurePath.root 该属性返回路径字符串中的根路径。
PurePath.anchor 该属性返回路径字符串中的盘符和根路径。
PurePath.parents 该属性返回当前路径的全部父路径。
PurePath.parent 该属性返回当前路径的上一级路径，相当于 parents[0] 的返回值。
PurePath.name 该属性返回当前路径中的文件名。
PurePath.suffixes 该属性返回当前路径中的文件所有后缀名。
PurePath.suffix 该属性返回当前路径中的文件后缀名。相当于 suffixes 属性返回的列表的最后一个元素。
PurePath.stem 该属性返回当前路径中的主文件名。
PurePath.as_posix() 将当前路径转换成 UNIX 风格的路径。
PurePath.as_uri() 将当前路径转换成 URI。只有绝对路径才能转换，否则将会引发 ValueError。
PurePath.is_absolute() 判断当前路径是否为绝对路径。
PurePath.joinpath(*other) 将多个路径连接在一起，作用类似于前面介绍的斜杠运算符。
PurePath.match(pattern) 判断当前路径是否匹配指定通配符。
PurePath.relative_to(*other) 获取当前路径中去除基准路径之后的结果。
PurePath.with_name(name) 将当前路径中的文件名替换成新文件名。如果当前路径中没有文件名，则会引发 ValueError。
PurePath.with_suffix(suffix) 将当前路径中的文件后缀名替换成新的后缀名。如果当前路径中没有后缀名，则会添加新的后缀名。
'''
# 访问drive属性
#返回驱动器盘符
print(PureWindowsPath('c:/Program Files/').drive) #返回驱动器盘符 c:
print(PureWindowsPath('/Program Files/').drive) #返回驱动器盘符 ''
print(PurePosixPath('/etc').drive) #返回驱动器盘符 ''
# 访问root属性
#返回路径字符串中的根路径
print(PureWindowsPath('c:/Program Files/').root) #返回路径字符串中的根路径 \
print(PureWindowsPath('c:Program Files/').root) # ''
print(PurePosixPath('/etc').root) # /
# 访问anchor属性
#返回路径字符串中的 盘符和根路径
print(PureWindowsPath('c:/Program Files/').anchor) # c:\
print(PureWindowsPath('c:Program Files/').anchor) # c:
print(PurePosixPath('/etc').anchor) # /
# 访问parents属性
#返回当前路径的全部福路径
pp = PurePath('abc/xyz/wawa/haha')
print(pp.parents)
print(pp.parents[0]) # abc\xyz\wawa
print(pp.parents[1]) # abc\xyz
print(pp.parents[2]) # abc
print(pp.parents[3]) # .
# 访问parent属性
#返回当前路径的上一级路径，相当于parents[0]
print(pp.parent) # abc\xyz\wawa
# 访问name属性
#返回当前路径的路径名
print(pp.name) # haha
pp = PurePath('abc/wawa/bb.txt')
print(pp.name) # bb.txt
#返回文件的所有后缀名
pp = PurePath('abc/wawa/bb.txt.tar.zip')
# 访问suffixes属性
print(pp.suffixes[0]) # .txt
print(pp.suffixes[1]) # .tar
print(pp.suffixes[2]) # .zip
#返回文件的最后一个后缀名
# 访问suffix属性
print(pp.suffix) # .zip
#返回路径中的主文件名
print(pp.stem) # bb.txt.tar
#转成Unix风格的路径
print(pp.as_posix()) # abc/xyz/wawa/haha
#将绝对路径转换成uri,只有绝对路径才能转换
#将相对路径转换成Uri引发异常
#print(pp.as_uri()) # ValueError
#创建绝对路径
pp = PurePath('d:/', 'Python', 'Python3.6')
#将绝对路径转换成Uri
print(pp.as_uri()) # file:///d:/Python/Python3.6
#判断当前路径是否匹配指定模式
print(PurePath('a/b.py').match('*.py')) # True
print(PurePath('/a/b/c.py').match('b/*.py')) # True
print(PurePath('/a/b/c.py').match('a/*.py')) # False
#创建unix风格绝对路径
pp = PurePosixPath('c:/abc/xyz/wawa')
#测试relative_to方法
#获取当前路径中 去除指定基准路径 之后的结果
print(pp.relative_to('c:/')) # abc\xyz\wawa
print(pp.relative_to('c:/abc')) # xyz\wawa
print(pp.relative_to('c:/abc/xyz')) # wawa
# 测试with_name方法
#将当前路径中的主文件名 替换成 指定文件名，若无主文件名则报错。
p = PureWindowsPath('e:/Downloads/pathlib.tar.gz')
print(p.with_name('fkit.py')) # e:\Downloads\fkit.py
p = PureWindowsPath('c:/')
#print(p.with_name('fkit.py')) # ValueError
# 测试with_suffix方法
#将当前路径中的 文件后缀名 替换成 指定后缀名，若无则添加后缀名
p = PureWindowsPath('e:/Downloads/pathlib.tar.gz')
print(p.with_suffix('.zip')) # e:\Downloads\pathlib.tar.zip
p = PureWindowsPath('README')
print(p.with_suffix('.txt')) # README.txt
##########
#Path类
#Path 是 PurePath 的子类，除了支持 PurePath 的各种操作、属性和方法之外，
#还会真正访问底层的文件系统，包括判断 Path 对应的路径是否存在，获取 Path 对应路径的各种属性（如是否只读、是文件还是文件夹等），甚至可以对文件进行读写。
#PurePath 和 Path 最根本的区别在于，PurePath 处理的仅是字符串，而 Path 则会真正访问底层的文件路径，因此它提供了属性和方法来访问底层的文件系统。
'''
继续深入，参考文档：
https://docs.python.org/3/library/pathlib.html
''''
#获取当前目录
p=Path('.')
#遍历当前目录下所有的 文件和子目录
for x in p.iterdir():
print(x)
list(p.iterdir())
#获取上一级目录
p=Path('../')
#获取上级目录 及其 所有子目录下的py文件
for x in p.glob('**/*.py'):
print(x)
#获取指定对应目录
p=Path('F:/SpyderXIANGMUWENJIANJIA')
#获取 上级目录 及 所有子目录下的 指定PY文件
for x in p.glob('**/实盘交易.py'):
print(x)
help(Path)
#创建相对路径字符串
p = Path('测试文件/testPathlib_A.txt')
#以GBK字符集输出文本内容
#并实际创建路径
result = p.write_text('''有一个美丽的新世界
它在远方等我
那里有天真的孩子
还有姑娘的酒窝''', encoding='GBK')
#返回输出的字符数
print(result)
#指定以GBK字符集读取文本内容
content = p.read_text(encoding='GBK')
#输出读取的文本内容
print(content)
#读取字节内容
bb = p.read_bytes()
print(bb)
# =============================================================================
# #文件应用级操作
# #(open、fileinput、linecache、pathlib)
# =============================================================================
# =============================================================================
# #open
# #open函数位于自动导入的模块io中
# =============================================================================
'''
深入：
1、标准输入输出等（sys.stdin/sys.stdout/sys.stderr）
可应用管道重定向输出
注意：
1、文件打开模式，直接决定了后续可以对文件做哪些操作。例如，使用 r 模式打开的文件，后续编写的代码只能读取文件，而无法改动文件内容。
2、read()读取方法的参数如果省略，则默认一次性读取所有内容。若参数为数字，则根据打开模式来区分读取指定字符/字节。
3、读取后的文件 可当做 迭代器 来使用，可循环，可操作，可list、序列解包、多重赋值等
使用：
1、打开文件 open()
2、读取操作 read()、readline()、readlines()
3、写入操作 write()、writelines()
4、关闭文件 close()
5、文件指针 tell()、seek()
'''
####################
#打开文件
'''
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数file： 要创建或打开文件的文件名称，该名称要用引号（单引号或双引号都可以）括起来。需要注意的是，如果要打开的文件和当前执行的代码文件位于同一目录，则直接写文件名即可；否则，此参数需要指定打开文件所在的完整路径。
参数mode： 可选参数，用于指定文件的打开模式。可选的打开模式如表 1 所示。如果不写，则默认以只读（r）模式打开文件。
参数buffing： 可选参数，用于指定对文件做读写操作时，是否使用缓冲区。
'''
help(open)
open.__doc__
dir(open)
#文件打开模式，直接决定了后续可以对文件做哪些操作。例如，使用 r 模式打开的文件，后续编写的代码只能读取文件，而无法改动文件内容。
'''
open 函数支持的文件打开模式
模式 意义 注意事项
r 只读模式打开文件，读文件内容的指针会放在文件的开头。 操作的文件必须存在。
rb 以二进制格式、采用只读模式打开文件，读文件内容的指针位于文件的开头，一般用于非文本文件，如图片文件、音频文件等。
r+ 打开文件后，既可以从头读取文件内容，也可以从开头向文件中写入新的内容，写入的新内容会覆盖文件中等长度的原有内容。
rb+ 以二进制格式、采用读写模式打开文件，读写文件的指针会放在文件的开头，通常针对非文本文件（如音频文件）。
w 以只写模式打开文件，若该文件存在，打开时会清空文件中原有的内容。 若文件存在，会清空其原有内容（覆盖文件）；反之，则创建新文件。
wb 以二进制格式、只写模式打开文件，一般用于非文本文件（如音频文件）
w+ 打开文件后，会对原有内容进行清空，并对该文件有读写权限。
wb+ 以二进制格式、读写模式打开文件，一般用于非文本文件
a 以追加模式打开一个文件，对文件只有写入权限，如果文件已经存在，文件指针将放在文件的末尾（即新写入内容会位于已有内容之后）；反之，则会创建新文件。
ab 以二进制格式打开文件，并采用追加模式，对文件只有写权限。如果该文件已存在，文件指针位于文件末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。
a+ 以读写模式打开文件；如果文件存在，文件指针放在文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。
ab+ 以二进制模式打开文件，并采用追加模式，对文件具有读写权限，如果文件存在，则文件指针位于文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。
'''
#open()
#file=open('a.txt') #默认打开模式 r 只读模式，若无则报错
file=open('测试文件\\testOpen_A.txt','w+') #指定打开模式 w+ 为新建读写模式，若无则创建，若存在则替换覆盖
file.write('这里是第一次写入内容') #write()方法按行写入内容
#print(file) #通过file.reade()等读取方法才能输出内容
file.close()
file=open('测试文件\\testOpen_A.txt',encoding='utf-8') #指定打开文件的编码格式，默认为GBK编码
#print(file) #通过file.reade()等读取方法才能输出内容
file.close()
#open()文件对象常用属性
file.encoding #获取对象的编码方式
file.mode #获取对象的打开模式
file.closed #获取对象是否处于关闭状态，返回布尔值
file.name #获取对象打开的文件名
####################
#文件读取操作
'''
1、read()
file.read([size])
其中，file 表示打开的文件对象；
size 作为一个可选参数，用于指定要读取的字符个数，如果省略，则默认一次性读取所有内容。
2、readline()
file.readline([size])
file 为打开的文件对象；
size 为可选参数，用于指定读取每一行时，一次最多读取的字符数。
3、readlines()
用于读取文件中的所有行，
它和调用不指定 size 参数的 read() 函数类似，只不过该函数返回是一个字符串列表，其中每个元素为文件中的一行内容。
和 readline() 函数一样，readlines() 函数在读取每一行时，会连同行尾的换行符一块读取。
'''
#read()
#参数为空，则默认读取全部文件内容
#参数为1， 则读取1个字符/字节
#按字节/字符来读取文件内容
#注意：（打开模式为 B 二进制则按字节读取；其他模式则按字符读取）
f=open('测试文件\\testOpen_A.txt','r',True)
while True:
ch=f.read(1) #读取一个字符，循环一直读取
if not ch: #如果读取不到内容，则退出；否则输出读取的内容。
break
# print(ch)
print(ch,end='') #自定义结束字符串味空 以此输出原文原样。默认为换行符
f.close()
#read() #参数为空，则默认读取全部文件内容
f=open('测试文件\\testOpen_A.txt','r',True)
print(f.read())
f.close()
#read()后解码输出 打开模式为二进制的bytes对象
f=open('测试文件\\testOpen_A.txt','rb',True) #用二进制模式打开文件，获取得到bytes文件对象
#print(f.read())
print(f.read().decode('GBK')) #open()的默认encoding='GBK',注意需要一致编解码。
f.close()
####################
#文件写入操作
'''
1、file.write(string)
其中，file 表示已经打开的文件对象；string 表示要写入文件的字符串（或字节串，仅适用写入二进制文件中）。
2、file.writelines()
可以实现将字符串列表写入文件中
'''
#write()
f=open('测试文件\\testOpen_A.txt','a+')
f.write('\n写入第二行数据 追加写入') #注意 a+为追加读写模式在末尾，注意内容自行添加换行符\n
f.close()
#writelines()写入列表结构，
#可写入readlines()读取返回的列表结构
f=open('测试文件\\testOpen_A.txt','r')
n=open('测试文件\\testOpen_B.txt','w+')
#print(f.readline())
#print(f.readlines())
n.writelines(f.readlines()) #readlines()读取文件中的所有行，返回列表结构。 writelines()写入列表结构
n.close()
f.close()
#美化输出
import pprint
pprint.pprint(open('测试文件\\testOpen_A.txt').readlines())
####################
#使用文件的基本方法(读取/写入/迭代)
#通过readlines()读取全部内容成列表后，修改列表元素，然后添加该列表，形成修改后的新的文本文件
f=open('测试文件\\testOpen_A.txt')
lines=f.readlines() #读取文件所有行，返回列表结构
f.close()
lines[1]="通过提取f.readlines()的列表，然后对列表进行赋值操作。所以这里进行了添加和新的修改。"
f=open('测试文件\\testOpen_D.txt','w+')
f.writelines(lines) #注意 a+为追加读写模式在末尾，添加换行符\n
f.close()
print(lines)
#迭代文件内容的多重方式（read,readline,readlines)
#自建虚构的 内容处理函数
def process(string):
'''
用作展示 处理字符或行，可换做其他处理方法
'''
print('Processing: ',string)
#通过read方式读取 单个字符 来循环迭代
with open('测试文件\\testOpen_A.txt') as f:
char=f.read(1)
while char:
process(char)
char=f.read(1)
with open('测试文件\\testOpen_A.txt') as f:
while True:
char=f.read(1)
if not char:
break
print(char,end='') #去除输出结尾的默认换行符，从而达到连续输出的目的。
#通过readline读取 单行 来进行循环迭代
with open('测试文件\\testOpen_A.txt') as f:
while True:
char=f.readline()
if not char:
break
process(char)
#通过read 和 readlines 读取全部内容，来进行循环迭代
with open('测试文件\\testOpen_A.txt') as f:
for char in f.read():
process(char)
with open('测试文件\\testOpen_A.txt') as f:
for char in f.readlines():
process(char)
#使用fileinput实现延迟 行迭代
import fileinput
for line in fileinput.input('测试文件\\testOpen_A.txt'):
process(line)
#文件迭代器
#注意：将读取后的文件当做 迭代器 来使用，可循环，可操作，可list、序列解包、多重赋值等
with open('测试文件\\testOpen_A.txt') as f:
for line in f:
process(line)
#在不将 文件对象 赋值给 变量的情况下 迭代文件
for line in open('测试文件\\testOpen_A.txt'):
process(line)
#对迭代器做的事情基本上都可以对文件做。
#list方法将文件转换成成字符串列表，效果等同于 readlines
list(open('测试文件\\testOpen_A.txt'))
#通过print的参数file指定,实现对文件近些 写入操作
f=open('测试文件\\testOpen_E.txt','w')
print('First','line',file=f) #输出内容到指定文件
print('Second','line',file=f)
print('Third','and final','line',file=f)
f.close()
#对文件读取并序列解包，然后赋值应用
first,second,third=open('测试文件\\testOpen_E.txt') #给文件内容的每行进行赋值操作
print(first)
print(second)
print(third)
####################
#文件关闭操作
'''
file.close()
如果打开的文件对象不进行close()操作的话，会影响 譬如 os.remove('b.txt') 删除文件等的操作
'''
####################
#文件指针
'''
实现对文件指针的移动，（以 b 模式打开，每个数据就是一个字节；以普通模式打开，每个数据就是一个字符）文件指针就标明了文件将要从文件的哪个位置开始读起。
tell() 函数用于判断文件指针当前所处的位置，
seek() 函数用于移动文件指针到文件的指定位置。
file.seek(offset[, whence])
参数whence： 可选参数，用于指定文件指针要放置的位置，
3 个选择：0 代表文件头（默认值）、1 代表当前位置、2 代表文件尾。
参数offset： 表示相对于 whence 位置文件指针的偏移量，正数表示向后偏移，负数表示向前偏移。
例如，当whence == 0 &&offset == 3（即 seek(3,0) ），表示文件指针移动至距离文件开头处 3 个字符的位置；
当whence == 1 &&offset == 5（即 seek(5,1) ），表示文件指针向后移动，移动至距离当前位置 5 个字符处。
'''
f=open('测试文件\\testOpen_A.txt','r')
print(f.tell()) #输出当前文件指针位置
print(f.read(3)) #按行读取字符3个字符
print(f.tell()) #输出当前文件指针位置
f.close()
f=open('测试文件\\testOpen_A.txt','rb')
print(f.tell()) #输出当前文件指针位置
print(f.read(1)) #按行读取1个字节，现文件指针位置在1
print(f.tell()) #输出当前文件指针位置
f.seek(5) #设置文件指针位置至 5
print(f.tell()) #输出当前文件指针位置
print(f.read(1)) #按行读取1个字节
print(f.tell())
#将文件指针位置 向后移动到5个字符的位置
f.seek(5,1) #单设置文件指针至 当前指针向后移动5个字节 的位置
print(f.tell())
print(f.read(1))
print(f.tell())
#
f.seek(-1,2) #设置文件指针至 文件结尾向前移动1个字节 的位置
print(f.tell())
print(f.read(1))
print(f.tell())
f.close()
####################
#上下文管理器 同时包含__enter__() 和 __exit__()方法的对象就是上下文管理器
'''
http://c.biancheng.net/view/5319.html
同时包含__enter__() 和 __exit__() 两个方法的对象就是上下文管理器
__enter__(self)
__exit__（self, exc_type, exc_value, exc_traceback）
构建上下文管理器，常见的有 2 种方式：基于类实现和基于生成器实现。
只要一个类实现了 __enter__() 和 __exit__() 这 2 个方法，程序就可以使用 with as 语句来管理它，
通过 __exit__() 方法的参数，即可判断出 with 代码块执行时是否遇到了异常。
'''
with open('a.txt','a') as f:
f.write('\nPython大法')
#自定义类 实现上下文管理协议的类，并尝试用 with as 语句来管理它：
class FkResource:
'''
自定义一个实现上下文管理协议的类，并尝试用 with as 语句来管理它.
只要一个类实现了 __enter__() 和 __exit__() 这 2 个方法，程序就可以使用 with as 语句来管理它，
通过 __exit__() 方法的参数，即可判断出 with 代码块执行时是否遇到了异常。
'''
def __init__(self,tag): #初始化构造器方法
self.tag=tag
print('构造器，初始化资源：{}'.format(tag))
def __enter__(self): #定义__enter__魔法方法，即with体之前执行的方法
print('[__enter__方法: {}]'.format(self.tag))
return 'fkit' #可以返回任何类型来测试该自建类方法
def __exit__(self, exc_type, exc_value, exc_traceback): #定义__exit__魔法方法，即with体之后执行的方法
print('[__exit__方法: {}]'.format(self.tag))
'''
参数exc_traceback 为None，代表没有异常
'''
if exc_traceback is None:
print('没有异常,关闭资源')
else:
print('遇到异常,关闭资源')
return False #可以省略，默认返回None也被看成是False
with FkResource('孙悟空') as dr:
print(dr)
##测试异常
#with FkResource('白骨精'):
# print('[with代码块]异常之前的代码')
# raise Exception
# print('[with代码块]异常之后的代码----------------')
# =============================================================================
# #fileinput模块
# #fileinput模块能够轻松的迭代一系列文本文件中的所有行
# #fileinput模块提供了input函数，可以把多个输入流合并在一起,然后进行一些循环操作等
# #可以在命令行运行脚本 命令如：python testNumberlines.py testNumberlines.py
# =============================================================================
####################
#探索fileinput模块
import fileinput
help(fileinput)
fileinput.__doc__
fileinput.__file__
fileinput.__all__
dir(fileinput)
help(fileinput.filename) #返回正在读取的文件的文件名。
help(fileinput.fileno) #返回当前文件的文件描述符（file descriptor），该文件描述符是一个整数。
help(fileinput.lineno) #返回当前读取的行号。
help(fileinput.filelineno) #返回当前读取的行在其文件中的行号。
help(fileinput.isfirstline) #返回当前读取的行在其文件中是否为第一行。
help(fileinput.isstdin) #返回最后一行是否从 sys.stdin 读取。程序可以使用“-”代表从 sys.stdin 读取。
help(fileinput.nextfile) #关闭当前文件，开始读取下一个文件。
help(fileinput.close) #关闭 FileInput 对象。
####################
#常用属性、方法、类等
help(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： 控制文件的打开方式，例如编码格式等。
'''
#通过input函数创建了 FileInput 对象之后，即可通过 for 循环来遍历文件的每一行。
#在for循环里即可通过方法来进行相关操作
'''
#fileinput.filename() 返回正在读取的文件的文件名。
#fileinput.fileno() 返回当前文件的文件描述符（file descriptor），该文件描述符是一个整数。
#fileinput.lineno() 返回当前读取的行号。
#fileinput.filelineno() 返回当前读取的行在其文件中的行号。
#fileinput.isfirstline() 返回当前读取的行在其文件中是否为第一行。
#fileinput.isstdin() 返回最后一行是否从 sys.stdin 读取。程序可以使用“-”代表从 sys.stdin 读取。
#fileinput.nextfile() 关闭当前文件，开始读取下一个文件。
#fileinput.close() 关闭 FileInput 对象。
'''
####################
#示例1
'''
不支持中文问题
通过参数打开模式 mode='rb' 即二进制模式打开，然后输出执行解码utf-8，输出中文成功
'''
import fileinput
for line in fileinput.input(files=('testFileinput_A.txt', 'testFileinput_B.txt'),mode='rb'): # 一次读取多个文件
print(fileinput.filename(), fileinput.filelineno(), line.decode('utf-8')) # 输出文件名，当前行在当前文件中的行号，行内容。
fileinput.close() # 关闭文件流
with fileinput.input(files=('testA.txt','testB.txt'),mode='rb') as f:
for line in f:
print(line.decode('utf-8'))
####################
#示例2 可改写格式，然后即可用于给文件进行格式添加
#自建脚本文件 testFileinput_格式添加.py 在程序右侧添加行号格式化
#然后在控制台运行这个脚本程序，并将其作为参数传入。
#命令如：python testFileinput_格式添加.py testFileinput_格式添加.py
'''
出现解码问题
通过参数打开模式 mode='rb' 即二进制模式打开，然后输出执行解码utf-8，输出中文成功
'''
import fileinput
for line in fileinput.input(mode='rb',inplace=False): #inplace可选择是否本地修改
line=line.rstrip() #清洗右侧空白字符
num=fileinput.lineno() #输出当前文件的当前行号
#print格式设置 冒号前为输出对象，冒号后面：整数部分代表宽度，符号<代表左对齐，d代表十进制格式
print('{:<50} # {:2d}'.format(line.decode('utf-8'),num))
fileinput.close()
# =============================================================================
# #linecache模块
#
# #linecache模块允许从python源文件中（所有utf-8文件）随机读取指定行，并在内部使用缓存优化存储。
# #由于该模块主要被设计成读取 Python 源文件，因此它会用 UTF-8 字符集来读取文本文件。
# #实际上，使用 linecache 模块也可以读取其他文件，只要该文件使用了 UTF-8 字符集存储。
# =============================================================================
'''
#注意:
1、非UTF-8字符集存储的文件读取不出来问题。
'''
import linecache
import random
##################
#探索模块
help(linecache)
linecache.__doc__
linecache.__file__
linecache.__all__
dir(linecache)
help(linecache.getline) #获取 文件filename 的 第lineno行 内容 参数(filename,lineno)
help(linecache.getlines) #获取 问价filename 的全部行，返回列表结构。
help(linecache.clearcache)
help(linecache.checkcache)
###################
#常用属性、函数、类
#行数index从1开始，而非0
print(linecache.getline(random.__file__,3)) #读取random源文件的第三行内容
print(linecache.getlines(random.__file__)) #读取random源文件的所有行,返回列表结构
#注意非UTF-8字符集存储的文件读取不出来问题。
print(linecache.getline('F:\\SpyderXIANGMUWENJIANJIA\\编程基础\\Py基础标准库及应用\Py基础标准库time.py',2))
print(linecache.getlines('F:\\SpyderXIANGMUWENJIANJIA\\编程基础\\Py基础标准库及应用\Py基础标准库time.py'))
1063
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
