Discussion :

[devilsnake88]

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 python :

Sélectionner tout - Visualiser dans une fenêtre à part

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 python :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Merci pour votre temps!

[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

[jurassic pork]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.

[devilsnake88]

...

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...!