[toc]
python 文件的IO一
练习
有一个文件，对其进行单词统计，不区分大小写，并显示单词重复最多的10个单词
# 第一次处理
# os.path /usr/local/lib '/usr/local/lib'
def wordcount(file='sample.txt'):
chars = '''~!@#$%^&*()_+{}[]|\\/"'=;:.-<>'''
with open(file,encoding='utf-8') as f:
word_count = {}
for line in f:
words = line.split()
for k,v in zip(words,(1,)*len(words)):
k = k.strip(chars)
k = k.lower()
word_count[k] = word_count.get(k,0) + 1
lst = sorted(word_count.items(), key=lambda x:x[1],reverse=True)
for i in range(10):
print(str(lst[i]).strip("'()").replace(",",""))
return lst
wordcount()
# 输出
the, 5
a, 5
can, 3
download, 3
and, 3
for, 3
version, 2
these, 2
in, 2
this, 2
第二次改进
def wordcount(file='sample.txt'):
chars = '''~!@#$%^&*()_+{}[]|\\/"'=;:.-<>'''
charset = set(chars)
with open(file,encoding='utf-8') as f:
word_count = {}
for line in f:
words = line.split()
for k,v in zip(words,(1,)*len(words)):
k = k.strip(chars)
if len(k) < 1:
continue
k = k.lower()
start = 0
for i, c in enumerate(k):
if c in charset:
if start ==i :
start = i +1
continue
key = k[start:i]
word_count[key] = word_count.get(key,0) +1
start = i + 1
else:
key = k[start:]
word_count[key] = word_count.get(key,0) +1
print()
lst = sorted(word_count.items(), key=lambda x:x[1],reverse=True)
for i in range(10):
if i < len(lst):
print(str(lst[i]).strip("'()").replace("'",""))
return lst
wc = wordcount()
print(wc)
print(len(wc))
the, 5
a, 5
can, 3
download, 3
and, 3
for, 3
version, 2
these, 2
in, 2
this, 2
[('the', 5), ('a', 5), ('can', 3), ('download', 3), ('and', 3), ('for', 3), ('version', 2), ('these', 2), ('in', 2), ('this', 2), ('to', 2), ('as', 2), ('new', 2), ('of', 2), ('changes,', 2), ('with', 2), ('linux', 2), ('common', 2), ('control', 1), ('systems', 1), ('keep', 1), ('revisions', 1), ('straight,', 1), ('storing', 1), ('modifications', 1), ('central', 1), ('repository', 1), ('allows', 1), ('developers', 1), ('easily', 1), ('collaborate,', 1), ('they', 1), ('software,', 1), ('make', 1), ('upload', 1), ('newest', 1), ('revision', 1), ('every', 1), ('developer', 1), ('see', 1), ('them,', 1), ('contribute', 1), ('similarly,', 1), ('people', 1), ('who', 1), ('have', 1), ('nothing', 1), ('do', 1), ('development', 1), ('project', 1), ('still', 1), ('files', 1), ('use', 1), ('them', 1), ('most', 1), ('users', 1), ('should', 1), ('be', 1), ('familiar', 1), ('process,', 1), ('using', 1), ('git,', 1), ('subversion,', 1), ('or', 1), ('some', 1), ('other', 1), ('similar', 1), ('method', 1), ('is', 1), ('pretty', 1), ('downloading', 1), ('needed', 1), ('files—especially', 1), ('preparation', 1), ('compiling', 1), ('program', 1), ('from', 1), ('source', 1), ('code', 1), ('rather', 1), ('practice', 1), ('geeks', 1)]
82
StringIO
- io 模块中的类;
- from io import StringIO;
- 内存中，开辟的一个文本模式的buffer, 可以像文件对象一样操作它：
- 当close方法被调用的时候，这个buffer会被释放。
StringIO操作
- getvalue() 获取全部内容。跟文件指针没有关系;
用法
from io import StringIO
sio = StringIO()
print(sio.readable(),sio.writable(),sio.seekable())
sio.write("asjin.com\npython")
sio.seek(0)
print(sio.readlines())
print(sio.getvalue())
print()
sio.seek(0)
print(sio.read())
sio.close()
# 输出
True True True
['asjin.com\n', 'python']
asjin.com
python
asjin.com
python
- 好处
- 一般来说，磁盘的操作比内存的操作要慢得多，内存足够的情况下，一般的优化思路是少落地，减少磁盘IO的过程，可以大大提高程序的运行效率。
BytesIO
- io模块中的类
from io import BytesIO- 内存中，开辟一个二进制模式的buffer，可以像文件对象一样操作它;
- 当close方法被调用的时候，这个buffer会被释放。
from io import BytesIO # 内存中构建
bio = BytesIO()
print(bio.readable(),bio.writable(),bio.seekable())
bio.write(b"ssjinyao.com\nPython")
bio.seek(0)
print(bio.readlines())
print(bio.getvalue()) # 无视指针，输出全部内容
bio.close()
# 输出
True True True
[b'ssjinyao.com\n', b'Python']
b'ssjinyao.com\nPython'
file-like 对象
- 类文件对象，可以像文件对象一样操作;
- sock对象、输入输出对象(stdin、stdout)都是类文件对象;
from sys import stdout
f = stdout
print(type(f))
f.write('asjin.com')
os.path 模块
python3.4 之前
from os import path
p = path.join('/etc','hosts')
print(type(p),p)
print(path.exists(p))
print(path.split(p))
print(path.abspath('.'))
p = path.join('o://',p,'test.txt')
print(path.dirname(p))
print(path.basename(p))
print(path.splitdrive(p))
# 输出
<class 'str'> /etc/hosts
True
('/etc', 'hosts')
/Users/ssjinyao/Desktop/MyPython/testpy/kernel
/etc/hosts
test.txt
('', '/etc/hosts/test.txt')
3.4版本开始
建议使用pathlib模块，提供Path对象来操作。包括目录和文件；
pathlib模块
In [1]: from pathlib import Path
In [2]: p = Path()
In [3]: type(p)
Out[3]: pathlib.PosixPath
实现
In [1]: from pathlib import Path
In [2]: p = Path()
In [3]: type(p)
Out[3]: pathlib.PosixPath
In [4]: p.absolute()
Out[4]: PosixPath('/root/mypython/python3')
In [5]: p.joinpath('as','jin')
Out[5]: PosixPath('as/jin')
In [6]: p.absolute()
Out[6]: PosixPath('/root/mypython/python3')
In [7]: p = p.joinpath('as','jin')
In [8]: p.absolute()
Out[8]: PosixPath('/root/mypython/python3/as/jin')
In [9]: p = p / 'a' / 'b'
In [10]: p.absolute()
Out[10]: PosixPath('/root/mypython/python3/as/jin/a/b')
拼接
In [13]: p2 = Path('')
In [14]: p2 = p2 / '/etc/' / 'sysconfig'
In [15]: p2
Out[15]: PosixPath('/etc/sysconfig')
路径拼接和分解
操作符/
Path对象/ Path对象
Path对象/ 字符串或者字符串 / Path 对象
分解
parts 属性， 可以返回路径中的每一个部分
joinpath
joinpath(*other)连接多个字符串到Path对象中
In [16]: p = Path()
In [17]: p = p / 'a'
In [18]: p1 = 'b' / p
In [19]: p2 = Path('c')
In [20]: p3 = p2 / p1
In [21]: print(p3.parts)
('c', 'b', 'a')
In [22]: p3.joinpath('etc','init.d',Path('httpd'))
Out[22]: PosixPath('c/b/a/etc/init.d/httpd')
获取路径
str获取路径字符串
bytes获取路径字符串的bytes
In [24]: p = Path('/etc')
In [25]: print(str(p),bytes(p))
/etc b'/etc'
parent 目录的逻辑父目录
parents 父目录序列，索引|0是直接父
p =Path('/a/b/c/d')
In [29]: p = Path('/a/b/c/d')
In [30]: print(p.parent.parent)
/a/
In [31]: for x in p.parents:
...: print(x)
...:
/a/b/c
/a/b
/a
/
name、stem、 suffix、 suffixes、 with_suffix(suffix)、with_name(name)
name 目录的最后一个部分
suffix 目录中最后一个部分的扩展名
stem 目录最后一个部分，没有后缀
suffixes 返回多个扩展名列表
with_suffix(suffix)补充扩展名到路径尾部，返回新的路径，扩展名存在则无效;
with_name(name) 替换目录最后一个部分并返回一个新的路径。
In [33]: p4 = Path('/etc/sysconfig/network/xx.ifg.gz')
In [34]: p4.name
Out[34]: 'xx.ifg.gz'
In [35]: p4.stem
Out[35]: 'xx.ifg'
In [36]: p4.suffix
Out[36]: '.gz'
In [39]: p4.suffixes
Out[39]: ['.ifg', '.gz']
In [40]: p4.with_suffix('.tgz')
Out[40]: PosixPath('/etc/sysconfig/network/xx.ifg.tgz')
In [41]: p4.with_name('test')
Out[41]: PosixPath('/etc/sysconfig/network/test')
cwd() 返回当前工作目录;
home() 返回当前家目录;
is_dir() 是否是目录;
is_file() 是滞是普通文件;
is_symlink() 是否是软链接;
is_socket() 是否是socket文件;
is_block_device() 是否是块设备;
is_char_device() 是否是字符设备;
is_absolute() 是否是绝对路径;
resove() 返回一个新的路径，这个新路径就是当前Path对象的绝对路径，如果是软链接则直接被解析;
absolute() 也可以获取绝对路径，但是推荐使用resolve();
exists() 目录或文件是否存在;
remdir() 删除空目录。没有提供判断目录为空的方法;
touch(mode=0o666,exist_ok=True)创建一个文件;
as_uri() 将路径返回成URL，例如’file:///etc/passwd’
mkdir(mode=0o777,parents=False,exist_ok=False)
parents, 是否创建父目录，True等同于mkdir -p; False时父目录不存在，则抛出;
FileNotFoundError
exist_ok参数，在3.5版本加入。False时，路径存在，抛出FileExistsError; True 时FileExistsError被忽略；
In [3]: p =Path('/a/b/c/d')
In [4]: p.home()
Out[4]: PosixPath('/root')
In [5]: p.is_dir()
Out[5]: False
In [6]: p.is_absolute()
Out[6]: True
In [7]: p.absolute().parent
Out[7]: PosixPath('/a/b/c')
iterdir()
迭代当前目录
In [12]: for x in Path().iterdir():
...: if x.is_dir():
...: print(x)
.ipynb_checkpoints
通配符
glob(pattern)通配给定的模式
rglob(pattern)通配给定的模式，递归目录
list(p.glob('test*')) # 返回当前目录对象下的test开头的文件
list(p.glob('**/*.py')) # 递归所有目录，等同rglob
list(p.rglob('*.py'))
In [1]: from pathlib import Path
In [2]: list(Path().glob('*.py'))
Out[2]:
PosixPath('random_max_min2.py'),
匹配
match(pattern)
模式匹配，成功返回True
In [4]: Path('.py').match('*.py')
Out[4]: True
In [5]: Path('/a/b/c.py').match('b/*.py')
Out[5]: True
In [6]: Path('/a/b/c.py').match('a/*.py')
Out[6]: False
In [7]: Path('/a/b/c.py').match('a/*/*.py')
Out[7]: True
In [8]: Path('/a/b/c.py').match('a/**/*.py')
Out[8]: True
In [9]: Path('/a/b/c.py').match('**/*.py')
Out[9]: True
文件操作
open(mode=’r’,buffering=-1,encoding=None, errors=None,newline=None)
使用的方法类似内建函数open。返回一个文件对象
3.5 增加的新函数
read_bytes()
以’rb’ 读取路径对应文件，并返回二进制流;
Path.write_bytes(date)
以’wb’ 方式写入数据到路径对应文件;
write_text(data,enconding=None,errors=None)
以’wt’方式写入字符串到路径对应文件;
In [10]: p4 = Path('/root/testfile')
In [11]: p4.open('w+')
Out[11]: <_io.TextIOWrapper name='/root/testfile' mode='w+' encoding='UTF-8'>
In [12]: p4.touch()
In [13]: with p4.open('w+') as f:
...: f.write('test')
...:
In [14]: f.closed
# 可以直接写入
In [15]: p4.write_text('test_write_text')
In [17]: p4.read_text()
Out[17]: 'test_write_text'
from pathlib import Path
p = Path('/etc/config.py')
p.write_text('workprocess=16')
print(p.read_text())
with p.open() as f:
print(f.read(5))
os模块
os.name windows是nt，linux 是posix;
os.uname() Linux支持显示;
sys.platform windows 显示32，Linux是Linux
os.listdir(‘/etc’)
返回目录内容列表。
os 也有open、 read、 write 等方法，但是太低级，建议使用内建函数open、read、 write;
调用Linux系统的stat;
path: 路径的sting 或者bytes, 或者fd
follow symlinks True 返回文件本身信息，False如果是软链接则显示软链接本身;
os.chmod(path,mode,*,dir_fd=None, follow_symlinks=True)
os.chmod(‘test’,0o777)
os.chown(path,uid,gid)
改变文件的属主、属组，但需要足够的权限
shutil 模块
到目前为止
文件拷贝：使用打开2个文件对象，源文件读取内容，写入目标文件中来完成拷贝过程。但是这样丢失stat数据信息(权限等)，因为根本就没有复制过去。
目录怎么办呢 ？
Python提供了一个方便的库shutil(高级文件操作)。
copy复制
copyfileobj(fsrc,fdst[,length])
文件对象的复制，fsrc和fdst 是open打开的文件对象，复制内容。fdst要求可写。
length指定了表示buffer的大小;
from pathlib import Path
import shutil
p1 = Path('./test')
p1.touch()
with open('./test','r+') as f1:
f1.write('abcd\n asjin')
f1.flush()
with open('./test1','w+') as f2:
shutil.copyfileobj(f1,f2)
(py3_env) testpy ➤ cat kernel/test
abcd
asjin% (py3_env) testpy ➤ cat kernel/test1
copyfile(src,dst,*,follow_symlinks=True)
复制文件内容，不含元数据。src、dst为文件的路径字符串;
本质上调用的就是copyfileobj，所以不带元数据二进制内容复制;
import shutil
shutil.copyfile('./test','./test2')
copymode(src,dst,*,follow_symlinks=True)
仅仅复制权限
(py3_env) testpy ➤chmod 400 kernel/test2
import shutil
shutil.copymode('./test','./test2')
#执行后再查看copy的权限
-rw-r--r-- 1 ssjinyao staff 0B Oct 11 21:58 kernel/test1
-rw-r--r-- 1 ssjinyao staff 11B Oct 11 22:10 kernel/test2
copystat(src,dst,*,follow_symlinks=True)
复制元数据，stat包含权限
copy(src,dst,*,follow_symlinks=True)
复制文件内容、权限和部分元数据，不包括创建时间和修改时间。
本质上调用的是
copyfile(src,dst,follow_symlinks=follow_symlinks)
copymode(src,dst,follow_symlinks=follow_symlinks)
copy2 比copy多了复制全部元数据，但需要平台支持;
本质上调用的是
copyfile(src,dst,follow_symlinks=follow_symlinks)
copystat(src,dst,follow_symlinks=follow_symlinks)
copytree(src,dst,symlinks=False,ignore=None,copy_function=copy2,ignore_dangling_symlinks=False)
递归复制目录。默认使用copy2，也就是带更多的元数据复制；
src、dst 必须是目录，src必须是存在 dst必须不存在;
ignore=func, 提供一个callabe(src,names) -> ignored_names。提供一个函数，它会被调用。src是源目录，names是os.listdir(src)的结果，就是列出src中的文件名，返回值是要被过滤的文件名的set类型数据。
copytree 是最常用的
def ignore(src, names):
ig = filter(lambda x: x.startswith('a'), names) #忽略a
return set(ig)
shutil.copytree('./testdir','/test/dir',ignore=ignore)
rm删除
shutil.rmtree(path,ignore_errors=False,onerror=None)
递归删除。如同rm -rf 一样危险，慎用。
它不是原子操作，有可能删除错误，就会中断，已经删除的就删除了;
ignore_errors为ture，忽略错误。当为False或者omitted时onerror生效;
onerror为callable，接受函数function、path和execinfo。
shutil.rmtree('./test') #类似rm -rf
move 移动
move(src,dst,copy_function=copy2)
递归移动文件、目录到目标，返回目录;
本身移动文件、目录到目标，返回目标;
如果不支持rename，如果是目录则想copytree再删除源目录;
默认使用copy2方法。
os.rename('./test.txt','/temp/t')
os.rename('test3','/temp/test/test300')
shutil还有打包功能。生成tar并压缩。支持zip、gz、bz、xz。
格言
共情的实质—把你的生活扩展到别人的生活里，把你的耳朵放到别人的灵魂中，用心去聆听那里最急切的喃喃私语
