Python Multiprocessing une grande liste avec une boucle

Question

Honnêtement, je n'étais même pas sûr de savoir quoi nommer cette question. J'essaie de parcourir une grande liste d'URL, mais je ne traite que 20 URL (20 sont basées sur le nombre de proxies que j'ai) à la fois. Mais j'ai également besoin de continuer à boucler la liste de proxy, car je suis en train de traiter les URL. Ainsi, par exemple, il commencerait avec la 1ère URL et le 1er proxy, et dès qu'il atteindrait la 21ème URL, il utiliserait à nouveau le 1er proxy. Voici mon pauvre exemple ci-dessous, si quelqu'un peut même me pointer dans la bonne direction, ce serait très apprécié.

import pymysql.cursors 
from multiprocessing import Pool 
from fake_useragent import UserAgent 

def worker(args): 
    var_a, id, name, content, proxy, headers, connection = args 
    print (var_a) 
    print (id) 
    print (name) 
    print (content) 
    print (proxy) 
    print (headers) 
    print (connection) 
    print ('---------------------------') 

if __name__ == '__main__': 
    connection = pymysql.connect(
     host = 'host ', 
     user = 'user', 
     password = 'password', 
     db = 'db', 
     charset='utf8mb4', 
     cursorclass=pymysql.cursors.DictCursor 
    ) 

    ua = UserAgent() 
    user_agent = ua.chrome 
    headers = {'User-Agent' : user_agent} 

    proxies = [ 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx', 
     'xxx.xxx.xxx.xxx:xxxxx' 
    ] 

    with connection.cursor() as cursor: 
     sql = "SELECT id,name,content FROM table" 
     cursor.execute(sql) 
     urls = cursor.fetchall() 

    var_a = 'static' 

    data = ((var_a, url['id'], url['name'], url['content'], proxies[i % len(proxies)], headers, connection) for i, url in enumerate(urls)) 
    proc_num = 20 
    p = Pool(processes=proc_num) 
    results = p.imap(worker, data) 
    p.close() 
    p.join() 

Answer 1

Vous pouvez utiliser une liste pour stocker de nouveaux processus. Lorsque vous atteignez un certain nombre d'éléments, appelez le join pour chaque processus de la liste. Cela devrait vous donner un certain contrôle sur le nombre de processus actifs.

if __name__ == '__main__': 
    proc_num = 20 
    proc_list = [] 
    for i, url in enumerate(urls): 
     proxy = proxies[i % len(proxies)] 
     p = Process(target=worker, args=(url, proxy)) 
     p.start() 
     proc_list.append(p) 
     if i % proc_num == 0 or i == len(urls)-1: 
      for proc in proc_list: 
       proc.join() 

Si vous voulez un nombre constant de processus actifs, vous pouvez essayer le module Pool. Il suffit de modifier la définition worker pour recevoir un tuple.

if __name__ == '__main__': 
    data = ((url, proxies[i % len(proxies)]) for i, url in enumerate(urls)) 
    proc_num = 20 
    p = Pool(processes=proc_num) 
    results = p.imap(worker, data) 
    p.close() 
    p.join() 

---

Juste pour clarifier les choses, la fonction worker devrait recevoir un tuple puis décompresser.

def worker(args): 
    var_a, id, name, content, proxy, headers, connection = args 
    print (var_a) 
    ... etc ... 

Answer 2

Essayez le code ci-dessous:

for i in range(len(urls)): 
    url = urls[i] # Current URL 
    proxy = proxies[i % len(proxies)] # Current proxy 
    # ...