用和学妹聊天的时间学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操作、线程和进程操作!帮助你掌握在基础进阶之后又一高阶技术!小伙伴们可以关注我一起学习呀!

用和学妹聊天的时间学Python高级进阶技术——IO操作、进程和线程操作【建议收藏】_第1张图片

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

1、文件读写

(1)打开文件

在进行文件读写之前,有个重要的步骤——将文件打开,同时指定针对文件的读写模式,比如只读、只写、可读可写等等。只有先打开文件才能对文件进行读写操作。

打开文件使用内置函数 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')

(2)写入文件

写入文件使用:

length = f.write('内容')

>>> f = open(’/Users/obsession/text’, ‘w’)
>>> f.write(‘The quick brown fox jumps over the lazy dog’)
43

调用 f.write() 后将返回写入字符的长度。

(3)读取文件

读取文件使用:

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

(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)

 

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

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

用和学妹聊天的时间学Python高级进阶技术——IO操作、进程和线程操作【建议收藏】_第2张图片

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操作及进程线程操作就和大家先分享这些,大家有疑问或者补充的话,欢迎在评论区留言!

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

灰小猿陪你一起进步!

 

你可能感兴趣的:(编程语言,python,多线程,IO操作,多进程)