当前位置 博文首页 > 灰小猿的博客：用和学妹聊天的时间学Python高级进阶技术——IO操
Python基础及进阶内容已陆续更新！欢迎小伙伴们一起关注学习！
本篇文章和大家分享Python高阶开发中详细的IO操作、线程和进程操作！，建议先收藏之后慢慢学习！
目录
写在前面
一、Python输入输出——IO操作
1、文件读写
（1）打开文件
（2）写入文件
（3）读取文件
（4）关闭文件
2、文件系统操作
3、序列化和反序列化
（1）pickle
（2）JSON
二、让你的代码更加灵活——进程和线程操作
1、进程操作
2、线程操作
（1）线程锁
Hello，你好呀！我是灰小猿，一个超会写bug的程序猿！本想彪上一手好bug，奈何技术太差，只能苟且搞输出！
近期和大家分享了很多关于Python入门进阶相关的文章，帮助了很多小伙伴了解并深入的学习到了Python开发，在这里为大家安利上文章链接，有想学习的小伙伴可以收藏阅读：
Python入门及进阶技术：
【全网力荐】堪称最易学的Python基础入门教程
万字长文爆肝Python基础入门【第二弹、超详细数据类型总结】
诺，你们要的Python进阶来咯！【函数、类进阶必备】
周末加班想摸鱼？不如来点Python进阶干货呀！【超详细迭代器、生成器、装饰器使用教程】
秀！学妹看见都惊呆的Python小招数！【详细语言特性使用教程】
常见报错及解决方案：
全网最值得收藏的Python常见报错及其解决方案，再也不用担心遇到BUG了！
今天继续和大家分享Python高阶开发中详细的IO操作、线程和进程操作！帮助你掌握在基础进阶之后又一高阶技术！小伙伴们可以关注我一起学习呀！
在进行文件读写之前，有个重要的步骤——将文件打开，同时指定针对文件的读写模式，比如只读、只写、可读可写等等。只有先打开文件才能对文件进行读写操作。
打开文件使用内置函数 open()：
f = open('文件路径', 读写模式)
如：
f = open('/Users/obsession/text', 'w')
其中，读写模式 有以下常用选项：
'r'：只读，若文件不存在则抛出 FileNotFoundError 异常'w'：只写，将覆盖所有原有内容，若文件不存在则创建文件'a'：只写，以追加的形式写入内容，若文件不存在则创建文件'r+'：可读可写，若文件不存在则抛出 FileNotFoundError 异常'w+'：可读可写，若文件不存在则创建文件'a+'：可读可写，写入时使用追加模式，若文件不存在则创建文件以上所有读写模式都是基于文本内容的，如果想要读写二进制内容，可在上面的基础上添加 'b' 模式，如 rb、'wb+'。
open() 的返回值为 file 对象，也就是这里的变量 f。利用这个对象，我们可以进行文件读写。
上述打开方式默认使用 UTF-8 编码，如果文件内容并非 UTF-8 编码，可以使用 encoding 参数指定编码格式，如 f = open('/Users/obsession/text', 'w', encoding='gbk')。
写入文件使用：
length = f.write('内容')
>>> f = open(’/Users/obsession/text’, ‘w’)
>>> f.write(‘The quick brown fox jumps over the lazy dog’)
43
调用 f.write() 后将返回写入字符的长度。
读取文件使用：
content = f.read()
>>> f = open(’/Users/obsession/text’, ‘r’)
>>> f.read()
’The quick brown fox jumps over the lazy dog’
上例中将读取文件的所有内容。也可以指定要读取内容的字符长度：
>>> f = open(’/Users/obsession/text’, ‘r’)
>>> f.read(30)
’The quick brown fox jumps over’
>>> f.read(30)
’ the lazy dog’
>>> f.read(30)
’’
此时将根据所指定的长度来读取内容。注意观察示例，每次调用 f.read(30) 时都是从上一次读取的结束位置开始，来读取新的内容，直至所有的内容被获取完，之后再调用 f.read(30) 只会得到空字符串 ''。
还可以按行来读取文件，使用：
line = f.readline()
例如某文件内容为
The quick brown fox
jumps over
the lazy dog
按行读取文件如下：
>>> f = open(’/Users/obsession/text’, ‘r’)
>>> f.readline()
’The quick brown fox\n’
>>> f.readline()
’jumps over\n’
>>> f.readline()
’the lazy dog’
>>> f.readline()
’’
按行读取文件还可以一次性将所有行读出，然后放进列表里：
lines = f.readlines()
>>> f = open(’/Users/obsession/text’, ‘r’)
>>> f.readlines()
[‘The quick brown fox\n’, ‘jumps over\n’, ‘the lazy dog’]
每次打开文件后，无论进行了多少读写操作，最终都一定要将文件关闭，因为打开文件会消耗相关系统资源（文件描述符），不使用时应及时释放。
关闭文件使用：
f.close()
还有一种方式能自动关闭打开的文件，那就是使用 with 语句：
with open('/Users/obsession/text', 'w') as f:
f.write('The quick brown fox jumps over the lazy dog')
open() 后的 file 对象会被 as 关键字赋予变量 f。和之前一样，我们利用 f 进行文件读写。
with 语句会在它的代码块执行完毕后，或代码块抛出异常时，自动关闭文件，为我们省却了 f.close() 步骤。
文件系统操作需要使用内置的 os 模块。
import os
os.mkdir('/Users/obsession/test_dir')
os.path.isdir('/Users/obsession/test_dir')
os.listdir('/Users/obsession')
os.rmdir('/Users/obsession/test_dir')
open()： f = open('/Users/obsession/test_file', 'w')
f.close()
os.path.isfile('/Users/obsession/test_file')
os.remove('/Users/obsession/test_file')
os.rename('/Users/obsession/test_file', 'test_file_02')
程序运行时，产生的所有对象都位于内存之中。内存有个特点，那就是它是非持久的，如果程序运行结束或者计算机断电，占用的内存将被清空。
有时，我们需要把程序运行时内存中的对象，持久化下来保存在文件系统中，或者传输至网络。比如将这样一个类的对象保存在文件中：
class Pair:
def __init__(self, first, second):
self.first = first
self.second = second
pair = Pair(10, 20)
这就涉及到序列化和反序列化了。序列化是将内存中的对象转换为可被存储或可被传输的形式的过程。反序列化是将序列化后的内容恢复回内存中对象的过程。
Python 中内置的 pickle 模块用作序列化和反序列化。它的序列化结果是二进制形式。
序列化使用：
import pickle
some_bytes = pickle.dumps(对象)
>>> pair = Pair(10, 20)
>>> pickle.dumps(pair)
b’\x80\x03c__main__\nPair\nq\x00)\x81q\x01}q\x02(X\x05\x00\x00\x00firstq\x03K\nX\x06\x00\x00\x00secondq\x04K\x14ub.’
上面输出的乱码便是 pair 对象被序列化后的二进制。
对于刚才序列化后的结果，可以使用 pickle.loads() 将其反序列化回对象。如：
some_bytes = b'\x80\x03c__main__\nPair\nq\x00)\x81q\x01}q\x02(X\x05\x00\x00\x00firstq\x03K\nX\x06\x00\x00\x00secondq\x04K\x14ub.'
pair = pickle.loads(some_bytes)
此 pair 对象可以像之前一样正常被使用：
>>> pair.first
10
>>> pair.second
20
也可以与 open() 相结合，将序列化的结果保存在文件中，此时使用 pickle.dump()（注意与之前的 pickle.dumps() 不同）：
with open('/Users/obsession/dump', 'wb') as f:
pickle.dump(pair, f)
从文件中反序列化出对象，使用 pickle.load()（注意与之前的 pickle.loads() 不同）：
with open('/Users/obsession/dump', 'rb') as f:
pair = pickle.load(f)
pickle 使用 Python 专用的序列化格式，序列化后的结果无法做到跨语言使用。另外其序列化结果是二进制，不适合阅读。
JSON 相对而言更加通用和流行，并且其结果为文本格式，更具可读性。
同样是刚才的 pair 对象，可以像这样将它序列化为 JSON 字符串：
import json
json_string = json.dumps(pair.__dict__)
>>> json_string
’{“first”: 10, “second”: 20}’
注意上面结果为字符串类型。另外这里使用了 pair.__dict__ 来获取包含所有 pair 属性的字典，因为类对象不能直接用于 json.dumps() 序列化，而字典可以。
或者使用 default 参数，向 json.dumps() 告知如何进行从对象到字典的转换，这样便可以不使用 __dict__ 属性。如下：
def pair_to_dict(pair):
return {
'first': pair.first,
'second': pair.second,
}
json_string = json.dumps(pair, default=pair_to_dict)
>>> json_string
’{“first”: 10, “second”: 20}’
从 JSON 反序列化为对象：
def dict_to_pair(d):
return Pair(d['first'], d['second'])
pair = json.loads(json_string, object_hook=dict_to_pair)
上述反序列化过程中，json.loads() 首先会将 JSON 字符串反序列化为字典，然后使用 object_hook 参数进一步从字典转换出 pair 对象。
与 pickle 相似，json 也可以与 open() 结合使用，将序列化的结果保存在文件中：
with open('/Users/obsession/json', 'w') as f:
json.dump(pair, f, default=pair_to_dict)
或从文件中反序列化出对象：
with open('/Users/obsession/json', 'r') as f:
pair = json.load(f, object_hook=dict_to_pair)?
进程和线程时操作系统所提供的，能让程序在同一时间处理多个任务的方法，让程序能够做到「一心二用」。
当我们运行一个程序时，这个程序的代码会被操作系统加载内存中，并创建出一个进程来承载和运行它。简单来说，每一个运行中的程序就是一个进程，这个进程被称为主进程。
在主进程中，我们可以创建子进程来协助处理其它任务，这时主进程和子进程是并行运行的。子进程也可以有它的子进程，从而形成以主进程为根的一棵进程树。
我们可以使用 multiprocessing.Process() 方法来创建进程：
import multiprocessing
p = multiprocessing.Process(target=目标函数, args=(目标函数的参数,))
用 start() 方法来启动一个进程：
p.start()
来看个例子：
import multiprocessing
import os
def target_func():
print('子进程运行')
print('子进程 pid:', os.getpid())
print('子进程的 ppid:', os.getppid())
p = multiprocessing.Process(target=target_func)
p.start()
print('主进程运行')
print('主进程 pid:', os.getpid())
将上述代码拷贝至文件 process.py 中，执行下：
? ~ python3 process.py
主进程运行
主进程 pid: 13343
子进程运行
子进程 pid: 13344
子进程的 ppid: 13343
在这里例子中，
multiprocessing.Process() 来创建进程，并为该进程指定要执行的目标函数 target_func，进程启动后将执行该函数start() 方法来启动进程os.getpid() 获取进程的进程 ID，它是进程的唯一的标识，可用于区分进程os.getppid() 获取进程的父进程 ID，父进程是创建子进程的进程pid 和子进程的 ppid 相同（因为主进程是该子进程的父进程）另外可以看到，虽然子进程被创建并启动，但子进程中的 print() 函数并未立即执行，反而是主进程中的 print() 函数先执行。这说明进程间的执行顺序是不确定的，并非同步执行。
使用 join() 方法可以控制子进程的执行顺序：
import multiprocessing
import os
def target_func():
print('子进程运行')
print('子进程 pid:', os.getpid())
print('子进程的 ppid:', os.getppid())
p = multiprocessing.Process(target=target_func)
p.start()
p.join()
print('主进程运行')
print('主进程 pid:', os.getpid())
上述代码中新增了 p.join()。相应修改原先的 process.py 文件，再来执行下：
? ~ python3 process.py
子进程运行
子进程 pid: 13386
子进程的 ppid: 13385
主进程运行
主进程 pid: 13385
可以看到，使用 p.join() 后主进程将等待子进程执行完成，然后再向下执行代码。
每一个进程都默认有一个线程，这个线程被称为主线程。我们可以在主线程中创建其它线程来协助处理任务，这些线程也是并行运行的。
线程是进程的执行单元，CPU 调度进程时，实际上是在进程的线程间作切换。另外线程间共享它们所在进程的内存空间（栈除外）。
可以使用 threading.Thread() 方法来创建线程：
import threading
t = threading.Thread(target=目标函数, args=(目标函数的参数,))
用 start() 方法来启动一个线程：
t.start()
来看个例子：
import threading
def target_func(n):
for i in range(n):
print(i)
t = threading.Thread(target=target_func, args=(8,))
t.start()
print('主线程结束')
将上述代码拷贝至文件 thread.py 中，执行下：
? ~ python3 thread.py
0
1
主线程结束
2
3
4
5
6
7
上述子线程和主线程交替执行，可以使用 join() 让主线程等待子线程执行完成：
import threading
def target_func(n):
for i in range(n):
print(i)
t = threading.Thread(target=target_func, args=(8,))
t.start()
t.join()
print('主线程结束')
上述代码中新增了 t.join()。相应修改原先的 thread.py 文件，再来执行下：
? ~ python3 thread.py
0
1
2
3
4
5
6
7
主线程结束
多个线程间回共享进程的内存空间，如果多个线程同时修改和访问同一个对象，则可能会出现非预期的错误。
比如下面这个例子中，我们创建了两个线程，这两个线程分别对 number 变量做一百万次 +1 操作。
import threading
number = 0
def add():
for i in range(1000000):
global number
number += 1
t_1 = threading.Thread(target=add)
t_2 = threading.Thread(target=add)
t_1.start()
t_2.start()
t_1.join()
t_2.join()
print(number)
number 的预期结果应该是 2000000（两百万）。
将上述代码保存至文件 thread_add.py 中，来看下实际运行结果：
? ~ python3 thread_add.py
1584627
? ~ python3 thread_add.py
1413399
? ~ python3 thread_add.py
1541521
可以看到，每次运行的结果并不一致，并且均小于 2000000。
这是因为，number += 1 其实是两个操作——首先获取 number，然后对获取到的值 +1。这两个操作并不是原子的（也就是说，这两个操作并不一定会被 CPU 连续执行，执行第一个操作时，CPU 有可能被中断去执行其它任务，之后又回到这里执行第二个操作）。这个例子中有一种可能情形是，执行到某一时刻时，第一个线程获取到 number 值为 100，紧接着第二次线程也获取到 number 值为 100，第一个线程在 100 的基础上 +1 并将 101 赋值给 number，第二线程也在 100 的基础上 +1 并将 101 赋值给 number，由于两个线程是并行运行的，它们彼此间并不知情，这样就浪费了一次 +1 操作，最终的 number 结果也会变小。
在这种情况下想要得到正确的结果，应该对 number += 1 操作加锁。如下：
import threading
number = 0
lock = threading.Lock()
def add():
for i in range(1000000):
global number
lock.acquire()
number += 1
lock.release()
t_1 = threading.Thread(target=add)
t_2 = threading.Thread(target=add)
t_1.start()
t_2.start()
t_1.join()
t_2.join()
print(number)
更新 thread_add.py 文件，来看下运行结果：
? ~ python3 thread_add.py
2000000
? ~ python3 thread_add.py
2000000
? ~ python3 thread_add.py
2000000
可以看到，这次结果完全正确。但同时我们也能感受到，程序的执行速度变慢了，是的，锁会带来性能上的损耗，这就需要我们在正确性和性能间做取舍了。
OK，关于常见的Python高阶IO操作及进程线程操作就和大家先分享这些，大家有疑问或者补充的话，欢迎在评论区留言！
持续为大家分享更多优质干货中...感兴趣的小伙伴记得关注一起学习呀！
灰小猿陪你一起进步！
?
cs
