读写文本数据

使用其他分隔符或行终止符打印

问题：

　　你想使用print() 函数输出数据，但是想改变默认的分隔符或者行尾符。

解决方案：

　　可以使用在print() 函数中使用sep 和end 关键字参数，以你想要的方式输出。比如：

#正常输出
print('dmeon', 89 , 8, 23)

#指定分隔符,
print('dmeon', 89 , 8, 23, sep=',')

#指定结尾符号
print('dmeon', 89 , 8, 23, sep=',',end='!!!
')

#使用end 参数也可以在输出中禁止换行。比如：
for i in range(5):
    print(i, end=' ')

#另外一种添加分隔符的方法
print()
print('分隔符的方法'.center(30, '-'))
s1 = ('dmeon', 89 , 8, 23)
result = ' '.join((str(s) for s in s1))
print(result)

#高逼格的方法
print("s1的值", s1)
print('高逼格的输出方式', *s1,sep=',')

以上代执行输出的结果为:

dmeon 89 8 23
dmeon,89,8,23
dmeon,89,8,23!!!
0 1 2 3 4 
------------分隔符的方法------------
dmeon 89 8 23
s1的值 ('dmeon', 89, 8, 23)
高逼格的输出方式,dmeon,89,8,23

读写字节数据

问题：

　　你想读写二进制文件，比如图片，声音文件等等

解决方案：

　　使用模式为rb 或wb 的open() 函数来读取或写入二进制数据。比如：

#使用with打开文件，不需要考虑文件close的问题，rb模式是使用读二进制的模式打开
with open('/tmp/go.pdf', 'rb') as f:
    #获取文件中的内容
    data = f.read()

#wb是写的二进制模式打开，当文件存在会覆盖文件已有的内容，文件不存在会创建
with open('/tmp/test.bin','wb') as f:
    f.write(b'Hello World')

#天坑，读取二进制数据的时候，字节字符串和文本字符串的语义差异可能会导致一个潜在的陷阱
t = 'Hello World'
print("t中0索引第一个元素为：", t[0])

#循环t并打印每个元素
for i in t:
    print('循环t中的每个元素：', i)

#坑的地方来了
print('*'*30)
b = b'Hello World'
print('b中0索引的元素：', b[0])

#循环bytes类型b变量中的每个元素
for x in b:
    print('循环b中的每个元素：', x)

以上代执行输出的结果为:

t中0索引第一个元素为： H
循环t中的每个元素： H
循环t中的每个元素： e
循环t中的每个元素： l
循环t中的每个元素： l
循环t中的每个元素： o
循环t中的每个元素：  
循环t中的每个元素： W
循环t中的每个元素： o
循环t中的每个元素： r
循环t中的每个元素： l
循环t中的每个元素： d
******************************
b中0索引的元素： 72
循环b中的每个元素： 72
循环b中的每个元素： 101
循环b中的每个元素： 108
循环b中的每个元素： 108
循环b中的每个元素： 111
循环b中的每个元素： 32
循环b中的每个元素： 87
循环b中的每个元素： 111
循环b中的每个元素： 114
循环b中的每个元素： 108
循环b中的每个元素： 100

如果你想从二进制模式的文件中读取或写入文本数据，必须确保要进行解码和编码操作。比如：

with open('/tmp/test.bin', 'rb') as f:
    data = f.read(16)
    print('data的数据类型：', type(data))
    print('data的数据：', data)

    text = data.decode('utf-8')
    print('data转码以后的数据类型：', type(text))
    print('text的数据：', text)

以上代执行输出的结果为:

data的数据类型： <class 'bytes'>
data的数据： b'Hello World'
data转码以后的数据类型： <class 'str'>
text的数据： Hello World

文件不存在才能写入

问题：

　　你想像一个文件中写入数据，但是前提必须是这个文件在文件系统上不存在。也就是不允许覆盖已存在的文件内容

解决方案：

　　可以在open() 函数中使用x 模式来代替w 模式的方法来解决这个问题。比如：

#如果文件存在，会覆盖内容，如果文件不存在会创建文件并写入内容
with open('/tmp/test.bin', 'wt') as f:
    f.write('Hello
')

#如果文件存在，会报异常，否则创建文件并写入内容，如果文件是二进制，使用wb代替
try:
    f = open('/tmp/test.bin', 'xt')
except Exception as e:
    print(e)
else:
    f.write('Hello
')
finally:
    f.close()

以上代执行输出的结果为:

[Errno 17] File exists: '/tmp/test.bin'

字符串的I/O 操作

问题：

　　你想使用操作类文件对象的程序来操作文本或二进制字符串

解决方案：

　　使用io.StringIO() 和io.BytesIO() 类来创建类文件对象操作字符串数据。比如：

import io

s = io.StringIO()
print(s.write('Hello World
'))

print('This is a test', file=s)

#获取s中的内容
content = s.getvalue()
print('s中的内容为：', content)

#读取5个长度的内容
s = io.StringIO('Hello
World
')
print("五个字符的内容：")
print(s.read(5))

#读取剩余的内容
print("剩余的内容：")
print(s.read())

以上代执行输出的结果为:

12
s中的内容为： Hello World
This is a test

五个字符的内容：
Hello
剩余的内容：

World

io.StringIO 只能用于文本。如果你要操作二进制数据，要使用io.BytesIO 类来代替。比如：

import io
s = io.BytesIO()
s.write(b'binary data')
data = s.getvalue()
print("数据类型：", type(data))
print("data的值：", data)

以上代执行输出的结果为:

数据类型： <class 'bytes'>
data的值： b'binary data

注意：

　　需要注意的是， StringIO 和BytesIO 实例并没有正确的整数类型的文件描述符。因此，它们不能在那些需要使用真实的系统级文件如文件，管道或者是套接字的程序中使用

读写压缩文件

问题：

　　你想读写一个gzip 或bz2 格式的压缩文件

解决方案：

　　gzip 和bz2 模块可以很容易的处理这些文件。两个模块都为open() 函数提供了另外的实现来解决这个问题。比如，为了以文本形式读取压缩文件，可以这样做：

import gzip
import bz2
import os

#打开/tmp/bashrc的文件并获取内容
with open('/etc/bashrc', 'rb') as f:
    content = f.read()

#使用gzip打开文件，xb如果文件存在就报错，不存在创建，把读取的内容写入到文件
try:
    f = gzip.open('/tmp/bashrc.gz', 'xb')
except Exception as e:
    print('文件已存在~')
else:
    f.write(content)
finally:
    f.close()

#获取文件类型
result = os.popen('file /tmp/bashrc.gz').read()
print(result)

#打开gzip文件并读取内容
with gzip.open('/tmp/bashrc.gz') as f:
    content = f.read()
print('bashrc.gz中的内容为:')
print(content.decode('utf-8'))

#bz2的操作和上面一样..
# with bz2.open('samefile.bz2', 'rb') as f:
#     #f.write(content)
#     #f.read()
#     pass

以上代执行输出的结果为:

文件已存在~
/tmp/bashrc.gz: gzip compressed data, was "bashrc", last modified: Sat Aug  5 00:57:56 2017, max compression

bashrc.gz中的内容为:
# System-wide .bashrc file for interactive bash(1) shells.
if [ -z "$PS1" ]; then
   return
fi

PS1='h:W u$ '
# Make bash check its window size after a process completes
shopt -s checkwinsize

[ -r "/etc/bashrc_$TERM_PROGRAM" ] && . "/etc/bashrc_$TERM_PROGRAM"
alias cls='clear'
alias ll='ls -l'

读取二进制数据到可变缓冲区中

问题：

　　你想直接读取二进制数据到一个可变缓冲区中，而不需要做任何的中间复制操作。或者你想原地修改数据并将它写回到一个文件中去

解决方案：

　　为了读取数据到一个可变数组中，使用文件对象的readinto() 方法。比如：

import os.path

def read_into_buffer(filename):
    buf = bytearray(os.path.getsize(filename))
    with open(filename, 'rb') as f:
        f.readinto(buf)
    return buf

#创建文件并写入内容
with open('sample.bin', 'wb') as f:
    f.write(b'Hello World')

#获取buf的内容
buf = read_into_buffer('sample.bin')

#修改缓存文件中五个长度的值
print("未修改文件中的前五个值：", buf[:5])
buf[:5] = b'hello'
print('修改bu文件以后的值：',buf)

#再次打开文件并把修改的数据放入到里面
with open('sample.bin', 'wb') as f:
    f.write(buf)

以上代执行输出的结果为:

未修改文件中的前五个值： bytearray(b'Hello')
修改bu文件以后的值： bytearray(b'hello World')

内存映射的二进制文件

问题：

　　你想内存映射一个二进制文件到一个可变字节数组中，目的可能是为了随机访问它的内容或者是原地做些修改

解决方案：

　　使用mmap 模块来内存映射文件。下面是一个工具函数，向你演示了如何打开一个文件并以一种便捷方式内存映射这个文件

import os
import mmap

#使用mmap模块内存映射文件
def memory_map(filename, access=mmap.ACCESS_WRITE):
    size = os.path.getsize(filename)
    fd = os.open(filename, os.O_RDWR)
    return mmap.mmap(fd, size , access=access)


#以创建并且内容不为空的文件
size = 1000000
with open('data', 'wb') as f:
    f.seek(size-1)
    f.write(b'x00')

#memory_map()函数内存映射
print('内存映射'.center(30, '*'))
m = memory_map('data')
print(len(m))
print(m[:10])
#重新赋值
m[:11] = b'hello world'
m.close()

#获取内存映射的内容
print('获取内存映射的内容：'.center(30, '-'))
with open('data', 'rb') as f:
    print(f.read(11))

以上代执行输出的结果为:

*************内存映射*************
1000000
b'x00x00x00x00x00x00x00x00x00x00'
----------获取内存映射的内容：----------
b'hello world'

为了随机访问文件的内容，使用mmap 将文件映射到内存中是一个高效和优雅的方法。例如，你无需打开一个文件并执行大量的seek() ， read() ， write() 调用，只需要简单的映射文件并使用切片操作访问数据即可。

文件路径名的操作

问题：

　　你需要使用路径名来获取文件名，目录名，绝对路径等等

解决方案：

　　使用os.path 模块中的函数来操作路径名。下面是一个交互式例子来演示一些关键的特性：

import os
path = '/etc/passwd/passwd.bak'

#获取文件名
basename = os.path.basename(path)
print('file name:', basename)

#获取目录路径
dirname = os.path.dirname(path)
print("dirname：", dirname)

#做多个目录拼接在拼接上文件
path_join = os.path.join('/tmp/a/b/c', 'd',os.path.basename(path))
print('path join：', path_join)

#获取当前用户的家目录信息
path = '~/Data/data.csv'
print("user：", os.path.expanduser(path))


#获取后缀名
split_path = os.path.splitext(path)
print("splitext：", split_path)

以上代执行输出的结果为:

file name: passwd.bak
dirname： /etc/passwd
path join： /tmp/a/b/c/d/passwd.bak
user： /Users/demon/Data/data.csv
split： ('~/Data/data', '.csv')

测试文件是否存在

问题：

　　你想测试一个文件或目录是否存在

解决方案：

　　使用os.path 模块来测试一个文件或目录是否存在。比如：

import os

#判断/etc/passwd是否存在
print('/etc/passwd exists：', os.path.exists('/etc/passwd'))

#判断/tmp/spam是否存在
print('/tmp/spam exists：', os.path.exists('/tmp/spam'))

#判断/etc/passwd是否为一个文件
print('/etc/passwd is file：', os.path.isfile('/etc/passwd'))

#判断/tmp是否为一个目录
print('/tmp is directory：', os.path.isdir('/tmp'))

#判断/usr/local/bin/python3是否为一个链接文件
print('/usr/local/bin/python3 is link：', os.path.islink('/usr/local/bin/python3'))

#获取软连接的绝对路径
print('/usr/local/bin/python3 real directory：', os.path.realpath('/usr/local/bin/python3'))

#获取文件的大小
print('file size：', os.path.getsize('/etc/passwd'))

#文件的修改时间
print('file mtime：', os.path.getmtime('/etc/passwd'))

#文件的改变时间
import time
print('file ctime:', time.ctime(os.path.getctime('/etc/passwd')))

以上代执行输出的结果为:

/etc/passwd exists： True
/tmp/spam exists： False
/etc/passwd is file： True
/tmp is directory： True
/usr/local/bin/python3 is link： True
/usr/local/bin/python3 real directory： /Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6
file size： 5925
file mtime： 1456440624.0
file ctime: Sat Aug  6 07:46:53 2016

获取文件夹中的文件列表

问题：

　　你想获取文件系统中某个目录下的所有文件列表

解决方法：　　

　　使用os.listdir() 函数来获取某个目录中的文件列表：

import os

#获取当前目录下的文件
# names = os.listdir('somedir')

#获取所有的文件
path = '/tmp'
#列表推到式的写法
names = [name for name in os.listdir(path) if os.path.isfile(os.path.join(path,name))]
print('所有文件名的列表：', names)

#另外一种通过高阶函数filter
filter_names = list(filter(lambda name:os.path.isfile(os.path.join(path,name)),os.listdir(path)))
print('filter的所有文件名列表：', filter_names)


#获取所有的目录
dirnames = list(filter(lambda name:os.path.isdir(os.path.join(path,name)),os.listdir(path)))
print('所有目录的名称 ：', dirnames)

#过滤内容，查找当前目录下的所有以.log结尾或者.gz结尾的文件
files = [name for name in names if name.endswith(('log','gz'))]
print("查找目录下以log或者gz结尾的文件", files)

#另外一种写法
from fnmatch import fnmatch
fnmatch_files = [name for name in names if fnmatch(name, '*.log')]
print('另外一种查找以log结尾的文件：', fnmatch_files)

以上代执行输出的结果为:

所有文件名的列表： ['.adobeLockFile', '.keystone_install_lock', 'adobegc.log', 'AlTest1.err', 'AlTest1.out', 'bashrc.gz', 'com.adobe.acrobat.rna.AcroCefBrowserLock', 'escalatelantern.ico', 'swtag.log']
filter的所有文件名列表： ['.adobeLockFile', '.keystone_install_lock', 'adobegc.log', 'AlTest1.err', 'AlTest1.out', 'bashrc.gz', 'com.adobe.acrobat.rna.AcroCefBrowserLock', 'escalatelantern.ico', 'swtag.log']
所有目录的名称 ： ['com.apple.launchd.18kY10uuPh', 'com.apple.launchd.dVLT4hIllt']
查找目录下以log或者gz结尾的文件 ['adobegc.log', 'bashrc.gz', 'swtag.log']
另外一种查找以log结尾的文件： ['adobegc.log', 'swtag.log']

打印不合法的文件名

问题：

　　你的程序获取了一个目录中的文件名列表，但是当它试着去打印文件名的时候程序崩溃，出现了UnicodeEncodeError 异常和一条奇怪的消息—— surrogates not allowed

解决方案：

　　当打印未知的文件名时，使用下面的方法可以避免这样的错误：

import sys

names = ['spam.py', 'budce4d.txt', 'foo.txt']

def bad_filename(filename):
    return repr(filename)[1:-1]

print('第一个版本的错误处理：'.center(40, '*'))
for filename in names:
    try:
        print(filename)
    except UnicodeEncodeError:
        print(bad_filename(filename))


#另外一个版本的解决办法
def bad_filename(filename):
    #忽略编码的错误，sys.getfilesystemencoding是获取当前系统的编码
    temp = filename.encode(sys.getfilesystemencoding(), errors='surrogateescape')
    return temp.decode('latin-1')

print('第二个版本的错误处理：'.center(40, '-'))
for filename in names:
    try:
        print(filename)
    except UnicodeEncodeError:
        print(bad_filename(filename))

以上代执行输出的结果为:

**************第一个版本的错误处理：***************
spam.py
budce4d.txt
foo.txt
--------------第二个版本的错误处理：---------------
spam.py
bäd.txt
foo.txt

序列化Python 对象

问题：

　　你需要将一个Python 对象序列化为一个字节流，以便将它保存到一个文件、存储到数据库或者通过网络传输它

解决方案： 

　　对于序列化最普遍的做法就是使用pickle 模块。为了将一个对象保存到一个文件中，可以这样做：

import pickle

'''
data = 'same python object....'
#序列化对象到文件存储中
f = open('somefile', 'wb')
pickle.dump(data, f)
'''

#实例
#利用pickle分别把列表 字符串 字典类型的数据写入到/tmp/test文件中
f = open('/tmp/test', 'wb')
pickle.dump([1, 2, 3, 4], f)
pickle.dump('Hello World', f)
pickle.dump({'name':'demon'}, f)
print('写入完毕')
f.close()

#读取文件中的内容
f = open('/tmp/test', 'rb')
print(pickle.load(f))
print(pickle.load(f))
print(pickle.load(f))

以上代执行输出的结果为:

写入完毕
[1, 2, 3, 4]
Hello World
{'name': 'demon'}