Exécuter simultanément une fonction pour chaque éléments d'un FOR

Version imprimable

Bonjour tout le monde!

J'essaye d'exécuter une fonction pour chaque éléments d'une liste en simultané (sous Windows 10 et Python 3) mais je n'y arrive pas donc je me tourne vers vous en espérant que vous pourrez m'aider.

Le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
from multiprocessing import Process
import os
 
addresses_to_work_with = [0x00000000004, 0x00000000008, 0x0000000000A]
 
 
def func1():
    for address in addresses_to_work_with:
        print(str(address) + " - 0")
        for i in range(9999):
            print(str(address) + " - " + str(i))
 
processes = []
 
for i in range(os.cpu_count()):
    print(str(i) + ' CPU cores')
    processes.append(Process(target=func1))
 
for process in processes:
    process.start()
 
for process in processes:
    process.join()

Explications:
Pour chaque éléments de "addresses_to_work_with", j'aimerais qu'ils exécutent tous le code suivant en même temps:

Code:

1
2
3
        print(str(address) + " - 0")
        for i in range(9999):
            print(str(address) + " - " + str(i))

Merci pour votre temps!

14/06/2021, 16h58
wiztricks

Salut,

Il y a des trucs spécifiques à Windows pour que çà fonctionne et les exemples donnés dans la documentation (et les explications) sont là pour çà.

- W

hello,
je n'ai peut-être pas très bien compris le sens de question mais si il s'agit d'exécuter une fonction en parallèle avec des arguments différents tu peux utiliser le multithreading. Voici un exemple
d'utilisation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# -*- coding: utf-8 -*- 
import threading
import os
exitFlag = 0
 
 
class myThread (threading.Thread):
   def __init__(self, threadID, name, address):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.address = address
   def run(self):
      print("Starting " + self.name)
      func1(self.name, self.address)
      print ("Exiting " + self.name) 
 
 
 
def func1(th, address):
    print(th + ": " +str(address) + " - 0")
    for i in range(9999):
        print(th + " : " + str(address) + " - " + str(i))
 
threads = []
addresses_to_work_with = [0x00000000004, 0x00000000008, 0x0000000000A]
i=1
for address in addresses_to_work_with:
    # Create new threads
    t = myThread( i,"Th"+ str(i), address)
    t.start()
    threads.append(t)
    i += 1
 
 
# Wait for all threads to complete
for t in threads:
   t.join()
print ("Exiting Main Thread")

Ami calmant, J.P

14/06/2021, 17h42
Invité

Salut !

Comme le dit jurassic pork le multithreading est une autre solution, qui me paraît pour ma part bien plus facile à utiliser que le multiprocessing.
14/06/2021, 18h48
devilsnake88

Citation:

Envoyé par jurassic pork

...

Merci à vous et un merci spécial pour Jurassic Pork!
Je ne savais pas que les dinoporks faisaient de la programmation mais visiblement, nous, pauvres humains, ne pouvons lutter contre des millions d'années d'expérience en développement...! :mrgreen: