>>> 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’]

（4）关闭文件

每次打开文件后，无论进行了多少读写操作，最终都一定要将文件关闭，因为打开文件会消耗相关系统资源（文件描述符），不使用时应及时释放。

关闭文件使用：

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() 步骤。

2、文件系统操作

文件系统操作需要使用内置的 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')

3 、序列化和反序列化

程序运行时，产生的所有对象都位于内存之中。内存有个特点，那就是它是非持久的，如果程序运行结束或者计算机断电，占用的内存将被清空。

有时，我们需要把程序运行时内存中的对象，持久化下来保存在文件系统中，或者传输至网络。比如将这样一个类的对象保存在文件中：

class Pair:
    def __init__(self, first, second):
        self.first = first
        self.second = second

pair = Pair(10, 20)

这就涉及到序列化和反序列化了。序列化是将内存中的对象转换为可被存储或可被传输的形式的过程。反序列化是将序列化后的内容恢复回内存中对象的过程。

（1）pickle

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)

（2）JSON

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)

二、让你的代码更加灵活——进程和线程操作

进程和线程时操作系统所提供的，能让程序在同一时间处理多个任务的方法，让程序能够做到「一心二用」。

1、进程操作

当我们运行一个程序时，这个程序的代码会被操作系统加载内存中，并创建出一个进程来承载和运行它。简单来说，每一个运行中的程序就是一个进程，这个进程被称为主进程。

在主进程中，我们可以创建子进程来协助处理其它任务，这时主进程和子进程是并行运行的。子进程也可以有它的子进程，从而形成以主进程为根的一棵进程树。

我们可以使用 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() 后主进程将等待子进程执行完成，然后再向下执行代码。

2 、线程操作

每一个进程都默认有一个线程，这个线程被称为主线程。我们可以在主线程中创建其它线程来协助处理任务，这些线程也是并行运行的。

线程是进程的执行单元，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
主线程结束

（1）线程锁

多个线程间回共享进程的内存空间，如果多个线程同时修改和访问同一个对象，则可能会出现非预期的错误。

比如下面这个例子中，我们创建了两个线程，这两个线程分别对 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操作及进程线程操作就和大家先分享这些，大家有疑问或者补充的话，欢迎在评论区留言！

持续为大家分享更多优质干货中...感兴趣的小伙伴记得关注一起学习呀！

灰小猿陪你一起进步！

本文版权归趣KUAI排www.SEOguruBlog.com 所有,如有转发请注明来出,竞价开户托管,seo优化请联系QQ→61910465

写在前面

一 、Python输入输出——IO操作

1、文件读写

（1）打开文件

（2）写入文件

（3）读取文件

（4）关闭文件

2、文件系统操作

3 、序列化和反序列化

（1）pickle

（2）JSON

二、让你的代码更加灵活——进程和线程操作

1、进程操作

2 、线程操作

（1）线程锁

OK，关于常见的Python高阶IO操作及进程线程操作就和大家先分享这些，大家有疑问或者补充的话 ，欢迎在评论区留言！

持续为大家分享更多优质干货中...感兴趣的小伙伴记得关注一起学习呀！

灰小猿陪你一起进步！

一、Python输入输出——IO操作

1、文件读写

2、文件系统操作

3 、序列化和反序列化

二、让你的代码更加灵活——进程和线程操作

1、进程操作

2 、线程操作

OK，关于常见的Python高阶IO操作及进程线程操作就和大家先分享这些，大家有疑问或者补充的话，欢迎在评论区留言！