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

已于 2024-02-26 22:42:04 修改
阅读量784 收藏 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多进程编程-进程间共享 对象
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  实例代码： ...
python进程的概念与使用
weixin_44786231的博客
04-10 216
进程以及状态 1. 进程 程序：例如xxx.py这是程序，是一个静态的 进程：一个程序运行起来后，代码+用到的资源 称之为进程，它是操作系统分配资源的基本单元。 不仅可以通过线程完成多任务，进程也是可以的 2. 进程的状态 工作中，任务数往往大于cpu的核数，即一定有一些任务正在执行，而另外一些任务在等待cpu进行执行，因此导致了有了不同的状态 - 就绪态：运行的条件都已经慢去，正在等在cpu执行...
Python知识——进程对象及其他方法、互斥锁
xiaotangyu7dong的博客
08-11 126
Python知识进程对象及其他方法僵尸进程与孤儿进程守护进程互斥锁 进程对象及其他方法 一台计算机上面运行着很多进程，那么计算机是如何区分并管理这些进程服务端的呢？ 计算机会给每一个运行的进程分配一个PID号 如何查看： Windows，加入cmd输入tasklist即可查看 tasklist | findstr PID查看具体的进程 mac电脑 进入终端后输入ps aux from multiprocessing import Process, current_process import time
python-开启进程的两种方法；进程对象的方法或属性详解
Marck
07-15 702
# 方式一：通用版 # from multiprocessing import Process # import time # def task(x): # print('%s is running '%x) # time.sleep(3) # print('%s is done'%x) # # if __name__ == '__main__': # #p=P...
python多任务笔记.doc
10-01
为此，可以使用`Lock`或`RLock`等同步机制来保护临界区，确保同一时刻只有一个线程可以执行特定代码。 在上述示例中，`test`函数中的全局变量`g_num`在多线程环境中可能会引发线程安全问题。如果没有适当的同步措施...
Python爬虫全套学习流程+源码+笔记，初学者可以参考学习.zip
02-21
初学者想要入门Python爬虫，本资源提供了一套完整的学习流程，包括源码示例和学习笔记，非常实用。下面将详细介绍Python爬虫的学习路径、核心概念以及可能涉及的关键技术。 1. **Python基础**：学习Python爬虫首先...
python学习代码
10-30
"python学习代码"这个标题表明这是一个包含与Python编程相关的学习资料的压缩包，可能包括示例代码、练习项目或者学习笔记。描述中提到有42个代码文件，这暗示了学习者在Python学习过程中接触到了各种概念和技术，...
python的学习笔记
01-30
Python是一种高级、通用的编程语言，以其简洁明了的语法和强大的功能而受到广大程序员的喜爱。...Python_knowledge-master这个压缩包可能包含了更详细的教程、代码示例和练习，是深入学习Python的好资源。
python_study:python学习笔记
03-30
【Python学习笔记】是关于Python编程语言的一系列学习记录，主要涵盖了基础概念、语法特性以及实战案例等内容。Python作为一门广泛应用于数据科学、Web开发、自动化运维、人工智能等多个领域的高级编程语言，其简洁...
deepseek-vl 论文阅读笔记
samoyan的博客,记录技术成长~
07-22 653
我们的语言模型基于DeepSeek LLM（DeepSeek-AI，2024），其微设计大体遵循LLaMA（Touvron等，2023a,b）的设计，采用带有RMSNorm（Zhang和Sennrich，2019）函数的Pre-Norm结构，并使用SwiGLU（Shazeer，2020）作为前馈网络（FFN）的激活函数，中间层维度为8/3模型维度。此外，我们引入了一种新的“模态预热”策略。为了促进创新并支持广泛的应用需求，我们公开了两个版本的模型，分别为1.3B和7B，以满足不同计算能力的需求。
OpenGL笔记十四之GLM数学库的配置与使用
小勇博客
07-20 319
— 2024-07-20 中午。
【Blockly图形化积木编程二次开发学习笔记】5.自动保存与恢复
乙酸氧铍的博客
07-21 116
/ 用户离开页面时自动将块备份到本地存储中。关闭后再次打开，工作区仍存在。// 从本地存储中恢复块。
Vue3企业级项目开发实战课-笔记记录
tuku0801的专栏
07-20 929
实践 Vue 3 自研组件库开发、Node.js 服务端开发、Vue 3 结合 Node.js 的全栈项目开发以及全栈项目的单元测试等大厂常见的项目技术场景
cs224w笔记（p5）
m0_51118873的博客
07-19 478
它特别关注两个节点共有的邻居节点，并给予那些在网络中不太常见的共有邻居更高的权重，而对于那些更常见的共有邻居则给予较低的权重。其中，Γ(𝑢)Γ(u) 表示节点 𝑢u 的邻居节点集合，Γ(𝑣)Γ(v) 表示节点 𝑣v 的邻居节点集合，Γ(𝑢)∩Γ(𝑣)Γ(u)∩Γ(v) 表示 𝑢u 和 𝑣v 的共有邻居节点集合。其中，𝐴A 和 𝐵B 分别代表两个集合，∣𝐴∩𝐵∣∣A∩B∣ 表示集合 𝐴A 与 𝐵B 的交集元素的数量，而 ∣𝐴∪𝐵∣∣A∪B∣ 表示集合 𝐴A 与 𝐵B 的并集元素的数量。
cs224w笔记（p1-p4）
m0_51118873的博客
07-18 601
图元是小的、固定的图结构，通常由少量的节点和边组成，它们在较大的图中频繁出现。它基于这样一个理念：一个节点的重要性不仅取决于它直接连接的节点数量，还取决于它所连接的节点的重要性。个人理解：首先有G图抽取出来的图元有以上3个，其次在这3个图元中不出现同构的位置有a，b，c，d，，然后将abcd依次放入v位置得出的具有不重复的表示有a->2种,b->1种,c->0种,d->2种。白话：如果一个节点到其余各点的最短的路径和是最短的，那么他是最重要的。白话：描述的是一个节点于周围节点之间的连接程度。
动手学深度学习V2每日笔记（多层感知机）
xiaostudennt的博客
07-18 729
感知机
【摸鱼笔记】了解itertools，优雅处理list
最新发布
the_singing_towers的博客
07-22 571
itertools 库是 Python 中处理迭代操作的标准工具，在处理序列和集合时，它可以像函数式编程过程一样，在处理过程中直接过滤内容，并且在组合处理其他序列或集合时，无需显式地创建中间序列或集合，可以显著提高代码的开发效率和可读性。
上海昇腾AI训练营笔记
嵌入式点灯砖家的博客
07-18 1001
Ascend C系列AI处理器适用于计算力需求较低的场景，如智能监控、边缘计算等。提供多种精简模式和高性能模式，满足不同应用场景下的性能要求。支持全场景覆盖，既可以部署在云端也可以部署在端侧。
python运维笔记md文档
07-14
Python运维笔记md文档是一个以Markdown格式编写的文档，用于记录Python运维工作中的经验、问题和解决方案。 在该文档中，可以记录各种Python运维相关的内容，比如常见的运维任务、常用的Python库和工具、部署和维护...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值