impossible de supprimer une variable

Version imprimable

Bonjour, je bute sur un problème assez gênant, python refuse de supprimé une variable qui prend de la place, voici mon 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 27 28 29 30 from tkinter import * import multiprocessing import os def new_window(list): while True: print(list[0]) class Test: def __init__(self): def firstn(n): nums = [] for i in range(0,n): nums.append(i) return nums sum_of_first_n = firstn(2000000) self.new_window(sum_of_first_n) del sum_of_first_n print("end") def new_window(self, list): p = multiprocessing.Process(target=new_window, args=(list,)) p.start() if __name__ == '__main__': toto = Test()
une fois p = multiprocessing.Process(target=new_window, args=(list,)) lancé, python vas copié ma variable list dans le nouveau processus, mais après ne vas pas supprimé (même manuellement avec del) cette derniere.

Du coup je me retrouve avec 90mo de ram au lieu de seulement 45, y'a t'il une solution ?

21/03/2016, 07h59
tyrtamos

Bonjour,

Essaie de lancer la méthode new_window comme ça:

Code:

self.new_window(sum_of_first_n[:])
21/03/2016, 08h03
RyzenOC

bonjour et merci pour ta réponse, mais malheureusement sa ne change rien.

Je maitrise mal l'outil multi-processing en python, plutot que de copier ma variable list dans le nouveau processus, serait t'il possible de la partager en mémoire directement ?, un peu comme le ferais une variable global ?
21/03/2016, 08h47
VinsS
Salut,

Tu sais que c'est une boucle sans fin çà:
Code:

1 2 3 4 def new_window(list): while True: print(list[0])
?

Ceci:
Code:

1 2 3 4 5 6 7 8 def firstn(n): nums = [] for i in range(0,n): nums.append(i) return nums sum_of_first_n = firstn(2000000)
Revient à cela:
Code:

1 2 sum_of_first_n = list(range(2000000)) # python 3
Pour ton problème, je pense que la liste créée est nums elle est ensuite retournée en référence et sum_of_first_n n'est qu'une deuxième étiquette de cette liste. C'est donc simplement cette deuxième référence que tu delete.

Aussi, évite d'utiliser un terme du langage, list par exemple, pour tes propres noms.

Citation:

Tu sais que c'est une boucle sans fin çà:

Oui, c'est pour que mon nouveau processus ne s’arrête pas

Citation:

Pour ton problème, je pense que la liste créée est nums elle est ensuite retournée en référence et sum_of_first_n n'est qu'une deuxième étiquette de cette liste. C'est donc simplement cette deuxième référence que tu delete.

Aussi, évite d'utiliser un terme du langage, list par exemple, pour tes propres noms.

Pour le range, oui je sais que c'est équivalent, mais j'y ai pas pensé.

J'ai mis a jour mon code, mais aucun changement, je m'y attendais, car normalement python supprime toutes les variables une fois la fonction terminé.
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 from tkinter import * import multiprocessing import os def new_window(list): while True: print(list[0]) class Test: def __init__(self): sum_of_first_n = list(range(2000000)) self.new_window(sum_of_first_n) del sum_of_first_n print("end") def new_window(self, sum_of_first_n): p = multiprocessing.Process(target=new_window, args=(sum_of_first_n,)) p.start() del sum_of_first_n if __name__ == '__main__': toto = Test()

Je viens d'essayer le code du 1er message, et bizarrement, il fonctionne sans problème, c'est à dire que la tentative de supprimer la variable avec del s'exécute sans erreur.

Sinon, une solution simple pour partager une variable avec un processus est d'utiliser multiprocessing.Queue:
- On crée la queue dans le programme principal avec q=multiprocessing.Queue().
- On empile une donnée x dans la queue avec q.put(x), et on lit en dépilant la donnée avec y=q.get().
- On passe la queue q comme argument au lancement du processus

Voilà un petit code tout simple qui fait ça:
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 #!/usr/bin/python # -*- coding: utf-8 -*- # Python 3 import multiprocessing ############################################################################# def calcul(q): """cette fonction est lancée dans un processus l'argument q est une pile contenant les arguments passés, et utilisé à la fin pour contenir le résultat """ x = q.get() # lecture et dépilage de l'argument empilé y = q.get() # lecture et dépilage de l'argument empilé q.put(x * y) # calcul et empilage du résultat ############################################################################# if __name__ == '__main__': q = multiprocessing.Queue() q.put(3) # on empile 3 q.put(4) # on empile 4 proc = multiprocessing.Process(target=calcul, args=(q,)) proc.daemon = True proc.start() proc.join() # attendra la fin du processus print("resultat:", q.get())
Pour faire des choses plus compliquées, on peut utiliser multiprocessing.managers.

21/03/2016, 09h48
wiztricks

Salut,

Citation:

Envoyé par sazearte

une fois p = multiprocessing.Process(target=new_window, args=(list,)) lancé, python vas copié ma variable list dans le nouveau processus, mais après ne vas pas supprimé (même manuellement avec del) cette derniere.

Du coup je me retrouve avec 90mo de ram au lieu de seulement 45, y'a t'il une solution ?

Avez vous regardé ce qu'il se passe côté "mémoire" sans créer de process?
Normalement, après le "del", on a toujours 45 Mo occupés...

- W
21/03/2016, 10h22
RyzenOC

1 pièce(s) jointe(s)

Voila ce que j'ai chez moi:
Pièce jointe 204495

processus1 ave 95mo de ram, cpu a 0% (normal il fait plus rien)

processus2 95mo de ram, cpu 6% (a cause de ma boucle infinie)
21/03/2016, 10h46
wiztricks

Salut,

Citation:

Envoyé par sazearte

Voila ce que j'ai chez moi:

processus1 ave 95mo de ram, cpu a 0% (normal il fait plus rien)

processus2 95mo de ram, cpu 6% (a cause de ma boucle infinie)

Ce n'est pas ce que je vous ai demandé.
Vous faites une théorie comme quoi la mémoire devrait être libérée après un "del" et que si çà ne fonctionne pas çà serait à cause du multiprocessing. Moi je vous demande de vérifier ce qu'il se passe côté mémoire (après le "del") sans multiprocessing.
Vous devriez constater que la mémoire (ce que vous regardez) se comporte de la même façon.

- W
21/03/2016, 10h49
RyzenOC

Citation:

Vous faites une théorie comme quoi la mémoire devrait être libérée après un "del" et que si çà ne fonctionne pas çà serait à cause du multiprocessing. Moi je vous demande de vérifier ce qu'il se passe côté mémoire (après le "del") sans multiprocessing.
Vous devriez constater que la mémoire (ce que vous regardez) se comporte de la même façon.

ok, je comprend, mais je fais comment moi pour supprimer cette variable ?
21/03/2016, 11h13
wiztricks

Citation:

Envoyé par sazearte

ok, je comprend, mais je fais comment moi pour supprimer cette variable ?

"del variable" fonctionne et si c'est la dernière référence à l'objet associé, le garbage collector fera le ménage. Python pourra allouer la mémoire libérée à d'autres objets (mais côté système, vous n'allez pas voir la mémoire se libérer: Python la garde pour lui).

- W
21/03/2016, 11h25
RyzenOC

Ah d'accord, merci pour ces explications.

Sinon est il possible de dire à python de libérer cette espace mémoire ?
21/03/2016, 11h46
wiztricks

Citation:

Envoyé par sazearte

Sinon est il possible de dire à python de libérer cette espace mémoire ?

Je ne pense pas que cela soit possible mais çà n'a pas grande importance. Normalement, le système va récupérer les pages inutilisées dès qu'il en aura besoin et çà ne coûtera que quelques IO disques.

- W
21/03/2016, 12h16
VinsS
Citation:

Envoyé par wiztricks

Je ne pense pas que cela soit possible mais çà n'a pas grande importance. Normalement, le système va récupérer les pages inutilisées dès qu'il en aura besoin et çà ne coûtera que quelques IO disques.

- W

Il y a un temps j'avais enquêté sur le sujet pour une appli qui traite des images de grande taille et j'en étais arrivé à la même conclusion.

Au passage, je signale qu'il existe un moyen de connaître le nombre de références d'un objet:
Code:

1 2 3 4 5 6 >>> a = "jdhdg" >>> import sys >>> sys.getrefcount(a) 2 >>>
21/03/2016, 13h49
wiztricks

Salut,

Citation:

Envoyé par VinsS

Il y a un temps j'avais enquêté sur le sujet pour une appli qui traite des images de grande taille et j'en étais arrivé à la même conclusion.

Le gestionnaire de mémoire de Python est codé dans le module Objects/obmalloc.c. C'est relativement bien commenté. Python essaie de rendre de la mémoire depuis la version 2.5. Il ne peut pas le faire sans que de nombreuses conditions soient remplies et pour voir quelque chose, il faut qu'in fine, le système d'exploitation ne compte pas l'espace libéré comme étant toujours occupé.

- W

pour en revenir a la mémoire j'ai adapté le code de tyrtamos, mais il y'a toujours le même problème, a savoir que la variable est copié dans la ram en double:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 import multiprocessing def calcul(q): print(q.get()) if __name__ == '__main__': q = multiprocessing.Queue() sum_of_first_n = list(range(2000000)) q.put(sum_of_first_n) proc = multiprocessing.Process(target=calcul, args=(q,)) proc.daemon = True proc.start() proc.join() # attendra la fin du processus print("resultat:", q.get())
quand c'est 100-200mo sa vas, mais dans mon cas c'est une variable de 2Go, la copie je la sens passé. J'aimerais que python ne me copie pas en mémoire cette variable.

21/03/2016, 16h43
tyrtamos

Et en faisant directement:

Code:

q.put(list(range(2000000)))

???
21/03/2016, 17h26
wiztricks

Salut,

Citation:

Envoyé par sazearte

quand c'est 100-200mo sa vas, mais dans mon cas c'est une variable de 2Go, la copie je la sens passé. J'aimerais que python ne me copie pas en mémoire cette variable.

Vu comme vous vous y prenez, çà ne va pas le faire.
Et comme je suppose que c'est pas juste pour le fun que vous essayez de partager une liste d'entiers entre processus, çà serait mieux d'expliquer ce que vous cherchez à faire et que vous donniez une idée de ce que sont les informations à partager et pourquoi vous voulez absolument utiliser multiprocessing dans ce cas.

- W

Non c'est pas pour le fun en effet, a l'origine voila ce que je voulais faire:

Je voulais crée un processus après un clique sur une fenêtre tkinter, mais ce nouveau processus, je voulais pouvoir le manipuler depuis le processus parent :

voici le code que j'avais développé:
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 40 # -*- coding: utf-8 -*- from tkinter import * import multiprocessing class NewProcess(): def __init__(self): self.name="mon processus" def mamethode(self): print("hello") def CreateNewProcess(): proc=NewProcess() proc.mamethode() return proc class Window(): def __init__(self): self.fenetre = Tk() self.fenetre.geometry("700x880+100+0") self.fenetre.minsize(840, 70) def startprocess(): proc = multiprocessing.Process(target=CreateNewProcess, args=()) proc.start() #proc.mamethode() button = Button(self.fenetre, text="run", command=lambda: startprocess()) button.pack() self.fenetre.mainloop() if __name__ == '__main__': Window=Window()
Seulement j'ai 2 problème:
Je ne peut pas manipuler mon objet NewProcess depuis l'objet Window
Si je transforme mon code en executable avec cx_freeze, quand je clique sur run, sa me crée une nouvelle fenetre tkinter, sa ne m'affiche pas "hello"

21/03/2016, 18h32
wiztricks

Citation:

Envoyé par sazearte

Je voulais crée un processus après un clique sur une fenêtre tkinter, mais ce nouveau processus, je voulais pouvoir le manipuler depuis le processus parent

ok, mais comment à partir de là vous vous retrouvez à recopiez des Mo d'un processus à l'autre? Qu'entendez vous par "manipuler"?

- W
21/03/2016, 18h38
RyzenOC

J'ai un objet qui crée une fenêtre tkinter, depuis cette fenêtre je peut instancier (avec un bouton) un objet qui récupéré des données en provenance de fichiers et génère 2 listes.

Une fois ces 2 grosses listes crée, je crée un 3eme objet, dans un autre processus, qui lance une fenêtre tkinter avec un graphe matploltib dedans. Le graphique matplotlib affiche mes 2 listes

Pourquoi s'embêter avec le multi-processing ?, pour pouvoir avoir des graphiques lancée dans des processus différents, car matploltib n'exploite qu'un core, c'est pour pas bridé mon programme à 25% de mon cpu (j'ai 4 core)
21/03/2016, 18h57
wiztricks

Salut,

Citation:

Envoyé par sazearte

Une fois ces 2 grosses listes crée, je crée un 3eme objet, dans un autre processus, qui lance une fenêtre tkinter avec un graphe matploltib dedans. Le graphique matplotlib affiche mes 2 listes

grosse listes d'objets Python <=> pickle et transferts de messages entre les processus qui sera très inefficace et lent.
Il faudrait essayer de mapper (via mmap) ça directement en mémoire et utiliser des données simples (int, long, double) "mappables" par numpy et pas mal de boulot pour faire tomber çà en marche.

- W
21/03/2016, 19h05
RyzenOC

Pour mes 2 listes, j'en ai une qui contient des doubles/float, et une autre des dates.
Je sais pas si on peut mapper des dates ?

Je vais voir pour mmap, c'est peut être la solution.
21/03/2016, 19h22
wiztricks

Citation:

Envoyé par sazearte

Pour mes 2 listes, j'en ai une qui contient des doubles/float, et une autre des dates.
Je sais pas si on peut mapper des dates ?

Un datetime, c'est un quadword (64 bits sur les systèmes modernes) donc "on peut".
Ceci dit, c'est compliqué et plein de pièges. Vous avez des tas de discussions sur ce sujet sur le ouèbe. çà serait bien d'y jeter un oeil pour apprécier la complexité de la chose.

- W
21/03/2016, 19h34
RyzenOC

Citation:

Ceci dit, c'est compliqué et plein de pièges. Vous avez des tas de discussions sur ce sujet sur le ouèbe. çà serait bien d'y jeter un oeil pour apprécier la complexité de la chose.

Oui j'ai vue, je vais déjà essayé de faire une version "basique", avec juste ma liste de double.

j'ai réussie a partager ma matrice de float:

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
 
from multiprocessing import Pool, Array
from functools import partial
import ctypes
from time import sleep
from random import randint
 
import test
 
 
def heavy_duty_function(mytab):
	c = 0
	while c < 10**2:
		c += 1
	print(test.shared_array_base[0])
 
 
def _initialize_subprocess(shared_array_base):
	"Initialise notre subprocess avec la mémoire partagée."
	test.shared_array_base = shared_array_base
 
def from_array_to_np(array):
	"Transforme multiprocessing.Array -> np.array"
	shared_array = np.frombuffer(array.get_obj())
	return shared_array.reshape(4, 4)
 
def list_of_list_to_array(data):
	return np.array(data)
 
if __name__=='__main__':
 
	mylist=[[0.0,1.5,2,3,4,5,6], [0,1,2,3,4,5,6]]
 
	shared_array_base = list_of_list_to_array(mylist)
	with Pool(processes=None, initializer=_initialize_subprocess, initargs=(shared_array_base,)) as pool:
		pool.map(heavy_duty_function, range(1))

Pour les dates j'ai pas encore trouvé, mais je pense qu'il suffira d'utiliser le type datetime à la place de c_float et sa marcheras.

Mais mon but n'est pas de lancer une fonction, mais de crée un bojet, peut on instancier un objet avec pool ?
voici mon code (qui ne marche pas)

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
 
from multiprocessing import Pool, Array
from functools import partial
import ctypes
from time import sleep
from random import randint
 
import numpy as np
import test
 
class memory2():
	def __init__(self, arg1, arg2):
 
		self.ar1=arg1
		self.arg2=arg2
		c = 0
		while c < 10**2:
			c += 1
		print(test.shared_array_base[0])
 
 
def _initialize_subprocess(shared_array_base):
	"Initialise notre subprocess avec la mémoire partagée."
	test.shared_array_base = shared_array_base
 
def list_of_list_to_array(data):
	return np.array(data)
 
if __name__=='__main__':
 
	mylist=[[0.0,1.5,2,3,4,5,6], [0,1,2,3,4,5,6]]
	#mylist = [[randint(0, 30000000) for i in range(30000)] for j in range(300)]
	shared_array_base = list_of_list_to_array(mylist)
 
	with Pool(processes=None, initializer=_initialize_subprocess, initargs=(shared_array_base,)) as pool:
		pool.map(memory2, range(1))

23/03/2016, 17h41
wiztricks

Salut,

Citation:

Envoyé par sazearte

Mais mon but n'est pas de lancer une fonction, mais de crée un bojet, peut on instancier un objet avec pool ?

Un bout de mémoire partagée entre processus créé via multiprocessing.Array pourra difficilement être assigné à autre chose qu'une variable globale et créée dans la portion "if __name__ == '__main__':".
Rien ne vous empêche ensuite de regrouper un paquet de fonctions dans un emballage de type "class" qui auront des attributs en mémoire séparée et qui pourront accéder aux cases de l'Array partagé. Mais c'est un vrai boulot à construire et à mettre au point.

- W

c'est bon j'ai réussie:

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
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from multiprocessing import Pool, Array
from functools import partial
import ctypes
 
import test
 
class Memory:
    def __init__(self, arg1, arg2):
        self.arg1 = arg1
        self.arg2 = arg2
 
    def do_something_useful(self):
        c = 0
        while c < 10**7:
            c += 1
        print(test.shared_array_base[self.arg1 + self.arg2])
 
def just_do_it(arg1, arg2):
    memory = Memory(arg1, arg2)
    memory.do_something_useful()
 
def _initialize_subprocess(shared_array_base):
    test.shared_array_base = shared_array_base
 
def list_of_list_to_array(data_type, data):
    return Array(data_type, [elt for row in data for elt in row], lock=False)
 
if __name__ == '__main__':
    mylist = [[i+j*5000 for i in range(5000)] for j in range(5000)]
    shared_array_base = list_of_list_to_array(ctypes.c_int, mylist)
 
    with Pool(processes=None,
              initializer=_initialize_subprocess,
              initargs=(shared_array_base,)) as pool:
        pool.starmap(just_do_it, [(5, 10)])

Ma matrice de 1Gb est enfin partager, je sens que mon programme vas énormément y gagner en perf, car mon pc n'a que 4GB de ram et quand sa dépasse l'os swap et le pc lag à mort, voir est carrément inutilisable.

Citation:
Envoyé par sazearte
Je voulais crée un processus après un clique sur une fenêtre tkinter, mais ce nouveau processus, je voulais pouvoir le manipuler depuis le processus parent :

voici le code que j'avais développé:
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 40 # -*- coding: utf-8 -*- from tkinter import * import multiprocessing class NewProcess(): def __init__(self): self.name="mon processus" def mamethode(self): print("hello") def CreateNewProcess(): proc=NewProcess() proc.mamethode() return proc class Window(): def __init__(self): self.fenetre = Tk() self.fenetre.geometry("700x880+100+0") self.fenetre.minsize(840, 70) def startprocess(): proc = multiprocessing.Process(target=CreateNewProcess, args=()) proc.start() #proc.mamethode() button = Button(self.fenetre, text="run", command=lambda: startprocess()) button.pack() self.fenetre.mainloop() if __name__ == '__main__': Window=Window()
Seulement j'ai 2 problème:
Je ne peut pas manipuler mon objet NewProcess depuis l'objet Window
Si je transforme mon code en exécutable avec cx_freeze, quand je clique sur run, ça me crée une nouvelle fenêtre tkinter, ça ne m'affiche pas "hello"
Bonsoir,

si quelqu'un a une explication à ce sujet ça m'intéresse aussi.
J'ai essayé de mon côté avec Python 3.4.4 win x86 et cx_Freeze 4.3.4

Est-ce une limitation / interprétation différente de cx_Freeze lors de la compilation.

Window() s'instancie à chaque fois qu'on clique sur "run" : startprocess()

Très curieux.

J'ai déjà fait l'expérience d'un comportement différent quand le code est compilé sur l'attribut __file__ qui n'existe pas ou retourne None. Ce qui n'est pas pratique pour aller chercher un icône dans un chemin relatif à l'exécutable.

La solution trouvée sur stackoverflow : http://stackoverflow.com/a/404750
Code:

1 2 3 4 5 6 7 8 import os import sys # determine if application is a script file or frozen exe if getattr(sys, 'frozen', False): application_path = os.path.dirname(sys.executable) elif __file__: application_path = os.path.dirname(__file__)
Il y a fort à parier que l'explication se trouve dans une subtilité de ce genre.

23/03/2016, 22h02
RyzenOC
Citation:

si quelqu'un a une explication à ce sujet ça m'intéresse aussi.
J'ai essayé de mon côté avec Python 3.4.4 win x86 et cx_Freeze 4.3.4

Est-ce une limitation / interprétation différente de cx_Freeze lors de la compilation.

Window() s'instancie à chaque fois qu'on clique sur "run" : startprocess()

Très curieux.

J'ai déjà fait l'expérience d'un comportement différent quand le code est compilé sur l'attribut __file__ qui n'existe pas ou retourne None. Ce qui n'est pas pratique pour aller chercher un icône dans un chemin relatif à l'exécutable.

En faite c'est tous simple, il suffit juste de rajouter juste après le if __name__ == '__main__':
Code:

1 2 3 if __name__ == '__main__': multiprocessing.freeze_support()
Cette solution fonctionne chez moi. freeze_support() n'est utile que sur les OS windows, sous linux y'a pas ce genre de problème d'après ce que j'ai compris.

Il parait même que sous linux, une variable global peut même être partager entre plusieurs processus, pas besoin de s'embêter avec tous mon code.
j'ai pas testé, donc à ne pas prendre pour argent comptant.

Enfin sa fait 2 semaines maintenant que je me mets au multi-processing, mais je pense aujourd'hui avoir surmonté toutes les subtilités, entre les comportement étrange de tkinter, le freeze_support(), et la mémoire partagés, je crois avoir fais le tour des problèmes.

En tous cas j'espère que mes bouts de codent vous aiderons.
Dernière chose aussi, si vous voulez utiliser cx_freeze avec python3.5, ne perdez pas votre temps, c'est pas encore compatible. Il vous faudra télécharger le dernier repository et compiler vous même les sources. Vous devrez pour cela télécharger et installer Visual Studio 2015, (les outils de C++ suffirons), ce qui à pris 3H chez moi...

Vous l'aurez compris, pour faire marcher la bestiole, faut pas mal bidouiller.
23/03/2016, 23h03
YCL-1

Merci pour votre retour très utile,
je n'ai jamais eu pour l'instant à utiliser le multiprocessing mais je sais que ça va me servir pour plus tard !

Citation:

Envoyé par sazearte

En tous cas j'espère que mes bouts de codent vous aiderons.
Dernière chose aussi, si vous voulez utiliser cx_freeze avec python3.5, ne perdez pas votre temps, c'est pas encore compatible. Il vous faudra télécharger le dernier répertoire et compiler vous même les sources. Vous devrez pour cela télécharger et installer Visual Studio 2015, (les outils de C++ suffirons), ce qui à pris 3H chez moi...

Vous l'aurez compris, pour faire marcher la bestiole, faut pas mal bidouiller.

C'est souvent ça avec les librairies tierces, NumPy et consorts, il vaut mieux rester à la version Python mineure - 1.

Sinon il existe le site « Unofficial Windows Binaries for Python Extension Packages » qui distribue les librairies compilées pour les dernières versions de Python : http://www.lfd.uci.edu/~gohlke/pythonlibs/
C'est très pratique, surtout sur un poste bureautique (quand on n'a pas toujours le choix), un simple dézip et copie dans site-packages et ça roule. (à défaut d'avoir pip bien entendu)
ou presque : http://stackoverflow.com/a/35706103

Citation:

Envoyé par sazearte

Enfin ça fait 2 semaines maintenant que je me mets au multi-processing, mais je pense aujourd'hui avoir surmonté toutes les subtilités, entre les comportement étrange de tkinter, le freeze_support(), et la mémoire partagés, je crois avoir fais le tour des problèmes.

Au sujet de tkinter il y a une chose à savoir avant de démarrer un projet avec, c'est qu'il n'est pas thread-safe, et la solution de contournement - autre que de passer par la librairie tierce mtTkinter - est d'utiliser des queue pour remonter toutes les actions sur le __main__, ça devient beaucoup plus lourd : http://effbot.org/zone/tkinter-threads.htm (exemple python v2)

je rencontre actuellement un autre problème, avec les arrays, j'arrive a partager ma liste de liste, mais je n'arrive a retrouver sa taille:

Quand je fais appelle a mon array partager, j'obtient un tableau 1D.

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
40
41
42
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from multiprocessing import Pool, Array
from functools import partial
import ctypes
import numpy as np
from time import sleep
 
import test
 
 
def heavy_duty_function(line):
    "La fonction qu'on parallélise"
    # On garde le CPU stupidement occupé...
    # On peut vérifier le nombre de coeur qui travaillent.
    c = 0
    while c < 10**7:
        c += 1
    shared_array = from_array_to_np(test.shared_array_base)
    print(shared_array[line])
 
def _initialize_subprocess(shared_array_base):
    test.shared_array_base = shared_array_base
 
def list_of_list_to_array(data_type, data):
    return Array(data_type, [elt for row in data for elt in row], lock=False)
 
def from_array_to_np(array):
    shared_array = np.frombuffer(array, dtype=float)
    return shared_array
 
 
if __name__=='__main__':
    data = [[0,1,2,3],[4,5,6],[4,5,6,7,9]]
    shared_array_base = list_of_list_to_array(ctypes.c_double, data)
 
    with Pool(processes=4, initializer=_initialize_subprocess, initargs=(shared_array_base,)) as pool:
        pool.map(heavy_duty_function, range(2))
 
    shared_array = from_array_to_np(shared_array_base)

25/03/2016, 09h24
wiztricks

Salut,

Citation:

Envoyé par sazearte

je rencontre actuellement un autre problème, avec les arrays, j'arrive a partager ma liste de liste, mais je n'arrive a retrouver sa taille:

len(array)?

- W
25/03/2016, 09h35
RyzenOC
Code:

len(array)?

Non, t'a pas compris, je convertit une liste 2d en array:

Code:

maliste=[[0,1,2,3,4,5][6,7,8]]

Mais mon array, lui n'a qu'une dimension:
Code:

1 2 print(myarray) 0,1,2,4,5,6,7,8
comment recrée un array 2D ?
25/03/2016, 12h26
wiztricks

Citation:

Envoyé par sazearte

comment recrée un array 2D ?

Côté mémoire partagée, ce ne sont que des tableaux 1D. Si vous voulez utiliser cela comme un tableau 2D il faut écrire le code qui calcule l'index dans le tableau 1D à partir de 2 entiers (i, j) et réciproquement.

- W

Fuseau horaire GMT +2. Il est actuellement 02h45.