python 进程笔记一 （概念+示例代码）

已于 2024-02-26 22:42:04 修改
阅读量803 收藏 23
点赞数 29
分类专栏： Python线程与进程笔记 文章标签： 笔记 python
于 2024-02-26 15:39:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70694811/article/details/136300045
版权

1. 进程的概念

        进程是资源分配的最小单位，也是线程的容器，线程（python 线程 （概念+示例代码））是CPU调度的基本单位，一个进程包括多个线程。

程序：例如xxx.py是一个程序

进程：一个程序运行起来后，代码＋用到的资源称为进程，它是系统分配资源的基本单位。

2. 进程的状态

        在计算机工作中，其任务数往往大于CPU核数，即一定有一些任务正在执行，而另外一些任务在等待CPU执行，因此进程有了不同的状态。

        就绪态：运行的条件都已经满足，正在等待CPU执行

        执行态：CPU正在执行其功能

        等待态：等待某些条件满足，例如一个程序sleep了，此时处于等待态

3. 进程的基本使用

        multiprocessing模块时夸平台版本的多进程模块，提供了一个Process类来代表一个进程对象，这个对象可以理解为是一个独立的进程，可以执行另外的事情。

子进程的创建：

import time,multiprocessing
 
def work1():
    for i in range(5):
        print("正在运行 work1...")
        time.sleep(0.5)
 
if __name__ == '__main__':
    process_obj = multiprocessing.Process(target=work1)  # 创建子进程对象
    process_obj.start()  # 启动进程
 
    print("主进程同时在运行...")

结果：

子进程的语法结构、常用方法和常用属性：

4.进程的名称和PID

4.1 获取主进程的名称
if __name__ == '__main__':
    print(multiprocessing.current_process())

结果：

4.2 获取子进程的名称
import time,multiprocessing
 
def work1():
    print(multiprocessing.current_process())  # 获取子进程名称
    time.sleep(1)
 
if __name__ == '__main__':
    process_obj = multiprocessing.Process(target=work1)  # 创建子进程对象
    process_obj.start()  # 启动进程

结果： 

4.3 设置子进程的名称
import time,multiprocessing
 
def work1():
    print(multiprocessing.current_process())  # 获取子进程名称
    time.sleep(1)
 
if __name__ == '__main__':
    process_obj = multiprocessing.Process(target=work1, name="MyProcess")  # 创建子进程对象
    process_obj.start()  # 启动进程

结果：

4.4 获取进程PID （process id）

方式一，通过multiprocessing模块获取

获取主进程pid：

if __name__ == '__main__':
    print(multiprocessing.current_process().pid)  # 获取主进程pid

获取子进程pid：

import time,multiprocessing
 
def work1():
    print(multiprocessing.current_process().pid)  # 获取子进程pid
    time.sleep(1)
 
if __name__ == '__main__':
    process_obj = multiprocessing.Process(target=work1, name="MyProcess")  # 创建子进程对象
    process_obj.start()  # 启动进程

方式二，通过os模块获取

import os
 
 
if __name__ == '__main__':
    print(os.getpid())  # 获取主进程pid
4.5 获取子进程的父id
import time,multiprocessing,os
 
def work1():
    print("该子进程的父id是：%s" % str(os.getppid()))  # 获取子进程父id
    time.sleep(1)
 
if __name__ == '__main__':
    process_obj = multiprocessing.Process(target=work1, name="MyProcess")  # 创建子进程对象
    process_obj.start()  # 启动进程
    print(os.getpid())

结果：

4.6 杀掉进程
import time,multiprocessing,os
 
def work1():
    for i in range(10):
        print("正在运行work1...",i,"子进程pid:",multiprocessing.current_process().pid)
        time.sleep(1)
 
if __name__ == '__main__':
    process_obj = multiprocessing.Process(target=work1, name="MyProcess")  # 创建子进程对象
    process_obj.start()  # 启动进程
    print("主进程pid：", multiprocessing.current_process().pid)
 
    time.sleep(2)
    os.popen("taskkill /f /t /im " + str(multiprocessing.current_process().pid))  # 杀死主进程

结果：

也可以采用terminate()方法来中止子进程执行：

import time,multiprocessing
 
 
def work1():
    for i in range(5):
        print("正在运行work1...")
        time.sleep(0.5)
 
if __name__ == '__main__':
    process_obj1 = multiprocessing.Process(target=work1)
    process_obj1.start()
 
    time.sleep(1)
    process_obj1.terminate()  # 关闭子进程
    exit()  # 关闭主进程
 
    print("123456")

结果：

5. 进程参数、全局变量问题

5.1 进程的参数传递

方式一、使用 args 传递元组：

import time,multiprocessing
 
def work1(a, b, c):
    for i in range(5):
        print("a=%d, b=%d, c=%d" % (a,b,c))
        time.sleep(1)
 
if __name__ == '__main__':
    process_obj = multiprocessing.Process(target=work1, args=(10,20,30))  # 创建子进程对象
    process_obj.start()  # 启动进程

方式二、使用 kwargs 传递字典：

import time,multiprocessing
 
def work1(a, b, c):
    for i in range(5):
        print("a=%d, b=%d, c=%d" % (a,b,c))
        time.sleep(1)
 
if __name__ == '__main__':
    process_obj = multiprocessing.Process(target=work1, kwargs={"c":30,"a":10,"b":20})  # 创建子进程对象
    process_obj.start()  # 启动进程

方式三、混合使用 args 和 kwargs：

import time,multiprocessing
 
def work1(a, b, c):
    for i in range(5):
        print("a=%d, b=%d, c=%d" % (a,b,c))
        time.sleep(1)
 
if __name__ == '__main__':
    process_obj = multiprocessing.Process(target=work1, args=(10,),kwargs={"c":30, "b":20})  # 创建子进程对象
    process_obj.start()  # 启动进程

三种方式的结果均如下图所示

5.2  进程间不共享全局变量
import time,multiprocessing
 
g_num = 10
 
def work1():
    global g_num
    for i in range(5):
        g_num += 1
    print("---work1---",g_num)
 
def work2():
    time.sleep(2)
    print("---work2---",g_num)
 
if __name__ == '__main__':
    process_obj1 = multiprocessing.Process(target=work1)
    process_obj2 = multiprocessing.Process(target=work2)
 
    process_obj1.start()
    process_obj2.start()
 
    time.sleep(2)
    print("---mian---",g_num)

结果：

        原因是每个子进程会把主进程中的部分资源（如：变量g_num的值）分别复制到各自的子进程内，子进程内部改变的是复制的全局变量的值，不影响主进程和其它子进程的全局变量的值。

6 守护主进程

6.1没有守护主进程
import time,multiprocessing
 
 
def work1():
    for i in range(5):
        print("正在运行work1...")
        time.sleep(0.5)
 
if __name__ == '__main__':
    process_obj1 = multiprocessing.Process(target=work1)
    process_obj1.start()
 
    time.sleep(1)
    print("结束主进程")
    exit()
 
    print("123456")

结果：

可以看出主进程结束后，子进程依然在执行。

6.2 守护主进程
import time,multiprocessing
 
 
def work1():
    for i in range(5):
        print("正在运行work1...")
        time.sleep(0.5)
 
if __name__ == '__main__':
    process_obj1 = multiprocessing.Process(target=work1)
    process_obj1.daemon = True  # 设置子进程守护主进程
    process_obj1.start()
 
    time.sleep(1)
    print("结束主进程")
    exit()
 
    print("123456")

结果：

可以看到当主进程结束后，子进程也结束了。

7. 消息队列的基本操作

7.1 Queue介绍

        可以使用multprocessing模块的Queue实现多进程之间的是数据传递

        Queue本身是一个消息队列程序

7.2 创建Queue
import multiprocessing
 
# 创建队列
queue = multiprocessing.Queue(5)  # 5表示队列长度为5
7.3 向Queue中放值

方式一、使用put()方法

import multiprocessing
 
# 创建队列
queue = multiprocessing.Queue(5)  # 5表示队列长度为5
 
# 向队列放值
queue.put(1)
queue.put("hello")
queue.put([1,2,3])
queue.put((4,5,6))
queue.put({"a":10,"b":20})
# queue.put(2)  # 由于队列长度为5，当准备向队列放入第6个值时，队列就会处于阻塞状态，默认等待直到队列取出值后有空余位置

方式二、使用put_nowait()方法

import multiprocessing
 
# 创建队列
queue = multiprocessing.Queue(5)  # 5表示队列长度为5
 
# 向队列放值
queue.put_nowait(1)
queue.put_nowait("hello")
queue.put_nowait([1,2,3])
queue.put_nowait((4,5,6))
queue.put_nowait({"a":10,"b":20})
# queue.put_nowait(2)  # 超出队列长度直接报错
7.4 从Queue中取值

方式一 、使用get()方法

import multiprocessing
 
# 创建队列
queue = multiprocessing.Queue(5)  # 5表示队列长度为5
 
# 向队列放值
queue.put_nowait(1)
queue.put_nowait("hello")
queue.put_nowait([1,2,3])
queue.put_nowait((4,5,6))
queue.put_nowait({"a":10,"b":20})
 
# 取值
for i in range(6):
    value = queue.get()
    print(i,value)

当取第6个值时，由于队列已经空了，此时队列会处于阻塞状态，直到有新的值进入队列

方式二、使用get_nowait()方法

import multiprocessing
 
# 创建队列
queue = multiprocessing.Queue(5)  # 5表示队列长度为5
 
# 向队列放值
queue.put_nowait(1)
queue.put_nowait("hello")
queue.put_nowait([1,2,3])
queue.put_nowait((4,5,6))
queue.put_nowait({"a":10,"b":20})
 
# 取值
for i in range(6):
    value = queue.get_nowait()
    print(i,value)

当队列已经空后，再取值会报错

7.4 从Queue中取值

方式一 、使用get()方法

import multiprocessing

# 创建队列
queue = multiprocessing.Queue(5)  # 5表示队列长度为5

# 向队列放值
queue.put_nowait(1)
queue.put_nowait("hello")
queue.put_nowait([1, 2, 3])
queue.put_nowait((4, 5, 6))
queue.put_nowait({"a": 10, "b": 20})

# 取值
for i in range(6):
    value = queue.get()
    print(i, value)
    
# 结果
# 0 1
# 1 hello
# 2 [1, 2, 3]
# 3 (4, 5, 6)
# 4 {'a': 10, 'b': 20}

 当取第6个值时，由于队列已经空了，此时队列会处于阻塞状态，直到有新的值进入队列

方式二、使用get_nowait()方法

import multiprocessing
 
# 创建队列
queue = multiprocessing.Queue(5)  # 5表示队列长度为5
 
# 向队列放值
queue.put_nowait(1)
queue.put_nowait("hello")
queue.put_nowait([1,2,3])
queue.put_nowait((4,5,6))
queue.put_nowait({"a":10,"b":20})
 
# 取值
for i in range(6):
    value = queue.get_nowait()
    print(i,value)

当队列已经空后，再取值会报错

8. 消息队列的常见判断

8.1 判断队列是否已满
import multiprocessing
 
# 创建队列
queue = multiprocessing.Queue(3)  # 5表示队列长度为5
 
# 向队列放值
queue.put_nowait(1)
queue.put_nowait("hello")
queue.put_nowait([1,2,3])
 
# 判断队列是否已满
print(queue.full())

结果：

8.2 判断队列的消息数量
print(queue.qsize())
8.3 判断队列是否为空
print(queue.empty())

有一定的概率会打印相反的结果，因此在调用empty()方法前，通常可以sleep 0.00001秒

或使用

if queue.qsize() == 0:

来判断队列是都为空

9. Queue实现进程间数据共享

        在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据，看看子进程read_queue能否读取到子进程write_queue写入到队列中的数据。

import multiprocessing,time
 
def write_queue(queue):
    """写入数据到队列"""
    for i in range(10):
        if queue.full():
            print("队列已满")
            break
        else:
            queue.put(i)
            print("已经写入：%d" % i)
            time.sleep(0.5)
 
def read_queue(queue):
    """读取队列数据并显示"""
    while True:
        if queue.qsize() == 0:
            print("队列已空")
            break
        else:
            value = queue.get()
            print("获取数据：%d" % value)
 
 
if __name__ == '__main__':
    # 创建空队列
    queue = multiprocessing.Queue(5)
 
    # 创建两个子进程
    write_q = multiprocessing.Process(target=write_queue, args=(queue,))
    read_q = multiprocessing.Process(target=read_queue, args=(queue,))
 
    write_q.start()
 
    # 让写入队列的子进程先执行
    write_q.join()
 
    read_q.start()

结果：

10. 进程池

10.1 进程池概述

        当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态生成多个进程，但如果是成百上千个进程，用手动方式创建就十分麻烦，此时就可以用到multiprocessing模块提供的Pool方法。

        初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求，但如果池中的进程数已经达到最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务。

10.2 multiprocessing.Pool常用函数

1.apply()

进程池中进程以同步方式执行任务

import multiprocessing,time
 
def copy_work(a,b):
    """用于模拟文件拷贝的函数"""
    print("正在拷贝文件...",multiprocessing.current_process(),a,b)
    time.sleep(0.5)
 
if __name__ == '__main__':
    # 创建进程池
    pool = multiprocessing.Pool(3)  # 最大允许创建3个进程
    for i in range(10):
        # 让进程池以同步方式执行copy_work
        pool.apply(copy_work,(10,20))

结果：

2.apply_async()

进程池中进程以异步方式执行任务

如果使用apply_async方式，需要做以下两点：

  （1）pool.close() 表示不再接收新的任务

  （2）pool.join() 让主进程等待进程池执行结束后再退出

import multiprocessing,time
 
def copy_work(a,b):
    """用于模拟文件拷贝的函数"""
    print("正在拷贝文件...",multiprocessing.current_process(),a,b)
    time.sleep(0.5)
 
if __name__ == '__main__':
    # 创建进程池
    pool = multiprocessing.Pool(3)  # 最大允许创建3个进程
    for i in range(10):
        # 让进程池以异步方式执行copy_work
        pool.apply_async(copy_work,(10,20))
    pool.close()
    pool.join()

结果：

10.3 进程池中的Queue

专门用于进程池中的进程间的数据共享

（1）同步方式

import multiprocessing,time
 
def write_queue(queue):
    """写入数据到队列"""
    for i in range(10):
        if queue.full():
            print("队列已满")
            break
        else:
            queue.put(i)
            print("已经写入：%d" % i)
            time.sleep(0.5)
 
def read_queue(queue):
    """读取队列数据并显示"""
    while True:
        if queue.qsize() == 0:
            print("队列已空")
            break
        else:
            value = queue.get()
            print("获取数据：%d" % value)
 
 
if __name__ == '__main__':
    # 创建进程池
    pool = multiprocessing.Pool(2)
 
    # 创建进程池中的队列
    queue = multiprocessing.Manager().Queue(5)
 
    # 使用进程池执行任务(同步方式)
    pool.apply(write_queue, (queue,))
    pool.apply(read_queue, (queue,))

结果：

（2）异步方式 

import multiprocessing,time
 
def write_queue(queue):
    """写入数据到队列"""
    for i in range(10):
        if queue.full():
            print("队列已满")
            break
        else:
            queue.put(i)
            print("已经写入：%d" % i)
            time.sleep(0.5)
 
def read_queue(queue):
    """读取队列数据并显示"""
    while True:
        if queue.qsize() == 0:
            print("队列已空")
            break
        else:
            value = queue.get()
            print("获取数据：%d" % value)
 
 
if __name__ == '__main__':
    # 创建进程池
    pool = multiprocessing.Pool(2)
 
    # 创建进程池中的队列
    queue = multiprocessing.Manager().Queue(5)
 
    # 使用进程池执行任务(异步方式)
    pool.apply_async(write_queue, (queue,))
    pool.apply_async(read_queue, (queue,))
 
    pool.close()  # 表示不再接收新的任务
    pool.join()  # 主进程会等待进程池执行结束后再退出

结果：

11. 案例：进程池实现文件夹拷贝器

目标：使用进程池实现文件夹整体拷贝到另外一个目录

思路：

import multiprocessing,time,os
 
def copy_file(source_dir, target_dir, file):
    print(multiprocessing.current_process())
    source_path = source_dir + "/" + file
    target_path = target_dir + "/" + file
    # print("%s  -->  %s" % (source_path, target_path))
 
    # 读取源文件内容
    with open(source_path,"rb") as source_file:
 
        # 创建目标文件
        with open(target_path, "wb") as target_file:
            while True:
                # 读源文件保存到目标文件
                source_file_data = source_file.read(1024)  # 每次读1024个字节
                if source_file_data:  # 判断是否完成读取源文件
                    target_file.write(source_file_data)
                else:
                    break
 
 
if __name__ == '__main__':
    source_dir = "C:/Users/DOUH/Desktop/pythonCode"  # 源文件路径
    target_dir = "C:/Users/DOUH/Desktop/test"  # 目标文件路径
 
    # 在指定位置创建test文件夹
    try:
        os.mkdir(target_dir)
    except:
        pass
 
    # 获取源文件夹中的所有的文件
    file_list = os.listdir(source_dir)
 
    # 创建进程池
    pool = multiprocessing.Pool(3)
 
 
    for file in file_list:
        # 拷贝文件
        pool.apply_async(copy_file, (source_dir, target_dir, file))
 
    pool.close()
    pool.join()

结果：

12. 案例：使用多进程向同一文件写入数据

import multiprocessing
 
# 设置回调函数
def setcallback(x):
    with open('result.txt', 'a+') as f:
        line = str(x) + "\n"
        f.write(line)
 
def multiplication(num):
    return num
 
if __name__ == '__main__':
    pool = multiprocessing.Pool(6)
    for i in range(1000):
        pool.apply_async(func=multiplication, args=(i,), callback=setcallback)
    pool.close()
    pool.join()

参考：

1.python 多进程一篇学懂

2.Python基础之多进程

3.【Python】Python多进程详解

4.Python多进程详解

5.python 进程 （概念+示例代码）​​​​​​​​​​​​​
爱编码的小陈
关注
  • 29
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python进程间共享数值、字典、列表变量
LDC，公众号【轻松学编程】
02-25 3307
##python进程间共享数值、字典、列表变量 import multiprocessing def worker(num, mgr_dict, mgr_list, key, value): mgr_dict[key] = value mgr_list.append(key) num.value += value if __name__ == '__main__'...
python 多进程共享字典 dict() 非常慢解决
jacke121的专栏
02-27 1558
python 多进程共享字典 dict() 非常慢解决
Python知识——进程对象及其他方法、互斥锁
xiaotangyu7dong的博客
08-11 133
Python知识进程对象及其他方法僵尸进程与孤儿进程守护进程互斥锁 进程对象及其他方法 一台计算机上面运行着很多进程，那么计算机是如何区分并管理这些进程服务端的呢？ 计算机会给每一个运行的进程分配一个PID号 如何查看： Windows，加入cmd输入tasklist即可查看 tasklist | findstr PID查看具体的进程 mac电脑 进入终端后输入ps aux from multiprocessing import Process, current_process import time
python多进程中传递变量
Pcject的博客
03-29 4567
一句话，多进程传递的不是内存中的地址（浅拷贝），而是特码的整个对象（深拷贝），如果想操作同一对象还是使用队列或者其他的多进程共享变量的方法吧 遇到这个问题是对excel文件使用openpyxl写入的时候，希望能实现异步写入，使用协程发现没效果，初步估计应该是openpyxl的写入过程其实是cpu从内存中依次取了然后写入磁盘，并不是像网络请求那样，一个请求发出去cpu基本就不干活了，就处于接收响应...
Python Flask 并发处理笔记.md
08-15
多线程是一种常用的并发技术，在同一进程中运行多个线程，每个线程都是独立执行的。Python 的 `threading` 模块提供了创建和管理线程的功能。 **示例代码：** ```python from flask import Flask import threading ...
python多任务笔记.doc
10-01
为此，可以使用`Lock`或`RLock`等同步机制来保护临界区，确保同一时刻只有一个线程可以执行特定代码。 在上述示例中，`test`函数中的全局变量`g_num`在多线程环境中可能会引发线程安全问题。如果没有适当的同步措施...
Python进阶之路：笔记与源代码指南.zip
08-15
这本指南不仅涵盖了Python编程语言的进阶知识，如高级数据结构、并发编程、网络编程、数据库操作及Web开发等核心内容，还通过详尽的笔记和丰富的源代码示例，帮助读者深入理解并掌握这些高级话题。 书中，作者以...
Python爬虫全套学习流程+源码+笔记，初学者可以参考学习.zip
02-21
初学者想要入门Python爬虫，本资源提供了一套完整的学习流程，包括源码示例和学习笔记，非常实用。下面将详细介绍Python爬虫的学习路径、核心概念以及可能涉及的关键技术。 1. **Python基础**：学习Python爬虫首先...
python学习代码
10-30
"python学习代码"这个标题表明这是一个包含与Python编程相关的学习资料的压缩包，可能包括示例代码、练习项目或者学习笔记。描述中提到有42个代码文件，这暗示了学习者在Python学习过程中接触到了各种概念和技术，...
python 进程之间的数据共享
FG7144的博客
11-29 146
1 from multiprocessing import Process,Manager 2 import os 3 def f(d,n): 4 d[os.getpid()] = os.getppid()#对字典d添加键值对，子进程：父进程 5 n.append(os.getpid())#将子进程添加到列表里。 6 7 if __name...
Python进程间通信和进程池
weixin_43790276的博客
06-05 3705
Python进程间通信和进程池 Python实现多进程是通过multiprocessing模块来实现的。 参考：https://mp.csdn.net/postedit/90903916 在使用多进程时，有时候在多个进程之间需要传递数据。 一、使用Queue实现进程间通信 可以使用multiprocessing模块的Queue实现多个进程之间的数据传递。Queue本身是一个消息列队程序...
Python多进程编程-进程间共享 对象
热门推荐
jacke121的专栏
09-11 1万+
Value、Array是通过共享内存的方式共享数据  Manager是通过共享进程的方式共享数据。 队列直接插入元祖，对象也是可以的：event需要是manager的，这个对象可以在多个进程里面共享 em = SBD_msg(cam_no, frame, event_obj) mlock.acquire() data_queue.put(em) Value\Array  实例代码： ...
Freertos学习笔记
qq_45031559的博客
08-21 638
Freertos学习笔记
Conditional Flow Matching: Simulation-Free Dynamic Optimal Transport论文阅读笔记
weixin_46103454的博客
08-20 440
假设给定一个目标流pt和生成它的向量场ut .学习与pt相匹配的流的一种方法是通过对目标向量场的回归进行梯度下降。
分享思源笔记的几个骚操作
2301_80064376的博客
08-21 327
本文章主要分享下思源笔记软件最喜爱的几个功能
[Matsim]Matsim学习笔记-车辆和订单匹配的逻辑
最新发布
机器学习菜鸟
08-23 243
这个方法体现了在DRT系统中对未计划请求进行调度的逻辑，包括对旧请求的重试和新请求的调度。通过并行处理车辆入口信息的创建，提高了调度过程的效率。matsim扩展包中DRT动态线路的场景是，给定一些车辆、一些订单，进行车辆和订单的匹配，类似滴滴的拼车功能。的方法，它用于调度未计划的DRT（需求响应交通）请求。操作，确保了在调度过程中对已处理的请求进行清理，避免重复调度。
全栈笔记_浏览器工作原理篇（浏览器架构）
wwv的博客
08-20 112
浏览器是用于访问互联网资源的软件，其工作原理涉及多个组件的协同工作，包括用户界面、浏览器引擎、渲染引擎、JavaScript解释器和网络模块。
React学习笔记，从入门到砸门
留白声的博客
08-20 1042
react详细自我学习笔记，内容包括JSX、Redux、Router等
python运维笔记md文档
07-14
### 回答1： Python运维笔记md文档是一个以Markdown格式编写的文档，用于记录Python运维工作中的经验、问题和解决方案。 在该文档中，可以记录各种Python运维相关的内容，比如常见的运维任务、常用的Python库和工具、部署和维护技巧等等。通过整理和记录这些信息，可以方便自己和他人查阅和参考，提高工作效率和技术水平。 该文档可以分为不同的章节和目录，以便组织和查找信息。每个章节可以包含多个子章节，每个子章节可以包含多个文档段落。每个文档段落可以包含标题、正文、代码示例等内容。 在Python运维笔记md文档中，可以记录一些常见的运维任务，比如集群管理、日志处理、性能优化等。对于每个任务，可以记录该任务的目标、实现方法、相关代码和注意事项等。这样，在遇到类似的任务时，可以很快地查阅相关信息，缩短解决问题的时间。 此外，Python运维笔记md文档还可以记录一些常用的Python库和工具，比如Fabric、Ansible、Docker等。对于每个库或工具，可以记录其主要功能、安装配置方法、使用示例等。这样，在实际工作中，可以根据需要选择合适的库和工具，提高工作效率。 总之，Python运维笔记md文档是一个记录Python运维工作经验和解决方案的重要工具。通过不断地整理和更新这个文档，可以提高自己的技术水平，也可以为他人提供有价值的参考资料。 ### 回答2： Python运维笔记MD文档是一种记录和整理与Python运维相关资料和经验的文件格式。MD是指Markdown，一种轻量级标记语言，可用于快速编写格式化的文档。 Python运维笔记MD文档通常包含以下内容： 1. 环境搭建：记录如何安装Python解释器、依赖包和开发环境，以及如何配置开发环境和调试工具等。 2. 常用命令和技巧：记录Python运维常用的命令和技巧，包括文件操作、目录管理、进程控制、日志查看等。通过整理这些命令和技巧，可以帮助Python运维人员更加高效地进行工作。 3. 脚本开发：记录Python脚本的开发经验和技巧，包括如何编写高效的代码、处理异常、读写文件、数据库操作、网络编程等。这部分内容可以提供Python运维人员开发工具和脚本的参考和指导。 4. 故障排除和优化：记录Python运维中常见的故障排除和性能优化方法，包括如何定位和解决内存泄漏、死锁、性能瓶颈等问题。这部分内容可以提供Python运维人员在故障处理和性能优化方面的指导和支持。 5. 监控和告警：记录Python运维中常用的监控和告警工具，包括如何配置监控项、设置告警规则、收集指标数据等。这部分内容可以帮助Python运维人员建立可靠的监控和告警系统，及时发现和解决问题。 通过Python运维笔记MD文档的整理和使用，可以帮助Python运维人员更好地管理和维护Python环境和应用程序，提高工作效率和质量。它不仅是个人学习和积累的重要工具，也可以作为团队交流和协作的参考资料，促进知识共享和团队合作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值