【Python多进程,通过from multiprocessing import Process实现,需要多个独立的数据,更推荐进程池map 】

Python多进程,通过from multiprocessing import Process实现

前提知识: 进程是python中最小的资源分配单元,也就是进程中间的数据,内存是不共享的,每启动一个进程,都要独立分配资源和拷贝访问的数据,所以进程的启动和销毁的代价是比较大了,下面这个方法就是每个进程都需要copy一份数据,占内存大。
总结:
1.进程池map(第二种方法)适合爬虫爬取多个链接和处理多个图片数据。作用的是可迭代对象里面的每一个子元素。
2.第一种方法多进程需要用到多份数据,占较多内存。但是可以对列表,元组等可迭代数据使用,Process(target=fun1,args=(data,))只需要修改这个代码,前面是函数,后面是对这个整体列表作用的函数。

测试代码


def fun1(name):
    cour = name[0]
    data = name[1]
    print(f'测试{cour}多进程{data}')

if __name__ == '__main__':
    process_list = []
    for i in range(5):  #开启5个子进程执行fun1函数
        data = (['Python1'],[i])
        p = Process(target=fun1,args=(data,)) #实例化进程对象
        p.start()
        process_list.append(p)

    for i in process_list:
        p.join()

    print('结束测试')

另一种方法,进程池实现

import PIL 

from multiprocessing import Pool 
from PIL import Image

SIZE = (75,75)
SAVE_DIRECTORY = \'thumbs\'

def get_image_paths(folder):
    return (os.path.join(folder, f) 
            for f in os.listdir(folder) 
            if \'jpeg\' in f)

def create_thumbnail(filename): 
    im = Image.open(filename)
    im.thumbnail(SIZE, Image.ANTIALIAS)
    base, fname = os.path.split(filename) 
    save_path = os.path.join(base, SAVE_DIRECTORY, fname)
    im.save(save_path)

if __name__ == \'__main__\':
    folder = os.path.abspath(
        \'11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840\')
    os.mkdir(os.path.join(folder, SAVE_DIRECTORY))

    images = get_image_paths(folder)

    pool = Pool()
    pool.map(creat_thumbnail, images) #关键点,images是一个可迭代对象
    pool.close()
    pool.join()
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答1: 好的,我明白了您的要求。以下是示例代码: ```python import asyncio from multiprocessing import Pool async def process_item(item): # 处理单个item的函数 return item * 2 async def process_list_async(lst): coroutines = [] for item in lst: coroutines.append(process_item(item)) results = await asyncio.gather(*coroutines) return results def process_list_sync(lst): pool = Pool() results = pool.map(process_item, lst) return results if __name__ == '__main__': # 测试数据 test_list = [1, 2, 3, 4, 5] # 使用协程并发处理列表 loop = asyncio.get_event_loop() async_results = loop.run_until_complete(process_list_async(test_list)) # 使用多进程并发处理列表 sync_results = process_list_sync(test_list) print("Async results:", async_results) print("Sync results:", sync_results) ``` 这段代码演示了如何使用Python的协程和多进程实现列表的并发处理,并返回处理结果。其中,`process_item`是一个处理单个元素的函数,在异步模式下通过添加协程实现异步并发处理。而在多进程模式下,使用Python的`multiprocessing.Pool`实现多进程并发处理。最后,使用测试数据对两种模式的处理结果进行比较。 ### 回答2: Python中可以使用多进程和协程来实现并发处理列表并返回的示例。 下面介绍一个使用Python多进程和协程实现并发处理列表的简单示例: ```python import multiprocessing import asyncio def process_item(item): # 在这里实现对列表中每个元素的处理逻辑 # ... return processed_item # 返回处理后的结果 def process_list(items): # 使用多进程来并发处理列表中的每个元素 with multiprocessing.Pool() as pool: processed_items = pool.map(process_item, items) return processed_items async def process_item_coroutine(item): # 在这里实现对列表中每个元素的处理逻辑 # ... return processed_item # 返回处理后的结果 async def process_list_coroutine(items): # 使用协程来并发处理列表中的每个元素 processed_items = await asyncio.gather(*(process_item_coroutine(item) for item in items)) return processed_items # 示例使用 if __name__ == "__main__": items = [1, 2, 3, 4, 5] # 待处理的列表 # 使用多进程并发处理列表 processed_items = process_list(items) print("使用多进程并发处理列表的结果:", processed_items) # 使用协程并发处理列表 loop = asyncio.get_event_loop() processed_items_coroutine = loop.run_until_complete(process_list_coroutine(items)) print("使用协程并发处理列表的结果:", processed_items_coroutine) ``` 上述示例中,`process_item` 是用来处理列表中的每个元素的函数,`process_list` 是使用多进程来并发处理列表的函数。另外,`process_item_coroutine` 是使用协程来处理列表中的每个元素的函数,`process_list_coroutine` 是使用协程来并发处理列表的函数。 在示例中,使用多进程来并发处理列表时,使用 `multiprocessing.Pool()` 来创建一个进程,并使用 `pool.map()` 方法来映射处理函数到列表中的每个元素,返回处理后的结果。 而使用协程来并发处理列表时,使用 `asyncio.gather()` 方法来同时运行多个协程,并等待它们都执行完成后返回结果。 示例程序中,输出了使用多进程和协程并发处理列表的结果。可以根据实际情况选择使用多进程还是协程来实现并发处理列表。 ### 回答3: Python中可以通过多进程和协程来实现并发处理列表并返回结果。 多进程是指使用多个进程同时处理任务。在Python中,可以使用`multiprocessing`模块来创建和管理多个进程。具体实现步骤如下: 1. 定义一个需要处理的任务函数,如`process_item(item)`,用于处理列表中的每个元素。 2. 将需要处理的列表分割成多个子列表,使每个子列表可以由一个独立进程处理。 3. 使用`multiprocessing.Pool()`创建一个进程。 4. 使用`pool.map(process_item, sub_list)`方法将任务函数和子列表传递给进程实现并发处理。 5. 使用`pool.close()`关闭进程,防止新的任务提交到进程。 6. 使用`pool.join()`等待所有进程完成任务。 7. 获取处理结果。 协程是一种轻量级的线程,可以在同一个线程中实现多个任务的切换执行。在Python中,可以使用`asyncio`模块来创建和管理协程。具体实现步骤如下: 1. 定义一个协程函数,如`async def process_item(item)`,用于处理列表中的每个元素。 2. 使用`asyncio.gather(*[process_item(item) for item in item_list])`将所有的协程任务收集起来。 3. 使用`await`关键字等待所有协程任务执行完成,并获取结果。 以下是示例代码: 使用多进程实现并发处理列表: ```python import multiprocessing def process_item(item): # 处理单个元素的逻辑 result = ... return result item_list = [...] # 需要处理的列表 # 将列表分割成子列表 chunk_size = len(item_list) // multiprocessing.cpu_count() sub_lists = [item_list[i:i+chunk_size] for i in range(0, len(item_list), chunk_size)] # 创建进程 pool = multiprocessing.Pool() # 并发处理子列表 results = [] for sub_list in sub_lists: results += pool.map(process_item, sub_list) # 关闭进程 pool.close() pool.join() # 处理结果 print(results) ``` 使用协程实现并发处理列表: ```python import asyncio async def process_item(item): # 处理单个元素的逻辑 result = ... return result item_list = [...] # 需要处理的列表 # 创建协程任务 coroutines = [process_item(item) for item in item_list] # 并发执行协程任务 loop = asyncio.get_event_loop() results = loop.run_until_complete(asyncio.gather(*coroutines)) # 处理结果 print(results) ``` 以上是使用多进程和协程实现并发处理列表并返回结果的示例。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

热爱生活的五柒

谢谢你的打赏,人好心善的朋友!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值