programmazione multithread in Python

Linguaggi di programmazione: php, perl, python, C, bash e tutti gli altri.
Scrivi risposta
lordalbert
Prode Principiante
Messaggi: 47
Iscrizione: sabato 15 luglio 2006, 22:23
Desktop: Xubuntu
Distribuzione: Ubuntu 14.04 LTS (x86_64)

programmazione multithread in Python

Messaggio da lordalbert »

Ciao ragazzi,
devo realizzare un piccolo programmino che calcoli le derivate. E' un programma semplice, con scopo didattico, quindi la premessa che viene fatta è che accetta espressioni nella forma

Codice: Seleziona tutto

X + X
Cioè, soltanto due operandi con un operatore in mezzo. L'espressione può essere anche ricorsiva, quindi al posto di un operando può essere un'altra espressione, sempre della stessa forma.
Ora, incollo il codice che ho scritto, funzionante:

Codice: Seleziona tutto

#
#  La funzione principale e' derive(). Accetta in ingresso una stringa e una variabile.
#  Trasforma l'espressione da derivare, che e' sottoforma di stringa, in una lista in cui il primo e il terzo elemento sono operandi
#  mentre il secondo e' l'operatore.
#  Chiama poi la funzione di derivazione vera e propria, derivative() che applica le regole di derivazione sugli operatori.
#  Infine, derive_solver() calcola la derivata sui singoli operandi.
#


import string
import re

def exp_split(mystring):   # prende in input una espressione matematica (sottoforma di stringa) e la memorizza in una lista, dividendo gli operandi e operatori
   exp_splitted = re.split("([+-/*])", mystring.replace(" ", ""), maxsplit = 1)
   if len(exp_splitted[0]) > 2:
      exp_splitted[0] = exp_split(exp_splitted[0])
   if len(exp_splitted) > 2:           
      if len(exp_splitted[2]) > 2:
         exp_splitted[2] = exp_split(exp_splitted[2])
   return exp_splitted
      
   
def rimuovi_parentesi(lista):          # da chiamare solo quando l'intera espressione e' gia' scomposta in liste
   lunghezza = len(lista)
   for x in range(lunghezza):
      if type(lista[x]) == type([]):
         rimuovi_parentesi(lista[x])
      else:
         lista[x] = lista[x].replace("(", "")
         lista[x] = lista[x].replace(")", "")
   return lista
            

def derive_solver(elemento, var):
   if type(elemento) == type(0):
      return "0"
   elif elemento == var:
      return "1"
   else:
      return "0"


def derivative(lst, var):
   if len(lst) == 1:      # Se viene chiamata la funzione derivative() su un singolo elemento, quest'ultimo viene passato a derive_solver() e risolto.
      return derive_solver(lst[0], var)
      
   if lst[1] == '+':
      return [derivative(lst[0], var), '+', derivative(lst[2], var)]
      
   if lst[1]  == '*':
      return [[derivative(lst[0], var), '*', lst[2]], '+', [lst[0], '*', derivative(lst[2], var)]]


def lst_to_str(lst):   # prende in input una espressione memorizzata in una lista, e la converte in stringa
   if type(lst) != type([]):
      return lst
   elif type(lst[0]) == type([]):
      lst[0] = lst_to_str(lst[0])
   elif type(lst[2]) == type([]):
      lst[2] = lst_to_str(lst[2])
   return "(" + str(lst[0]) + " " + str(lst[1]) + " " + str(lst[2]) + ")"
      
   
def calculate_result(lst):   # data in input una espressione (sottoforma di lista) gia' derivata, effettua i calcoli per semplificarla
   if len(lst) == 1:      # Se e' gia' un singolo elemento, restituisce l'elemento stesso senza fare nulla.
      return lst
   letter = string.lowercase + string.uppercase  # creo una stringa contenente tutte le lettere (maiuscole e minuscole). La usero' dopo per verificare che l'operando sia un simbolo
   if type(lst[0]) == type([]):      # Se il primo operando e' una lista, prima risolvo quella
      lst[0] = calculate_result(lst[0])
   if type(lst[2]) == type([]):
      lst[2] = calculate_result(lst[2])   # Se il secondo operando e' una lista, prima risolvo quella
   if lst[1] == '+':
      if (string.find(string.digits, str(lst[0])) != -1) and (string.find(string.digits, str(lst[2])) != -1):  # vero se gli operandi della lista sono numeri
            return int(lst[0]) + int(lst[2])
      if lst[0] == '0':
         return lst[2]
      if lst[2] == '0':
         return lst[0]
      if (string.find(letter, str(lst[0])) != -1) or (string.find(letter, str(lst[2])) != -1):  # vero se almeno un operando e' un simbolo
         return [lst[0], lst[1], lst[2]]
      if type(lst[0]) == type([]):   # se il primo operando e' una lista, valuto solo il secondo
         if lst[2] == '0':
            return lst[0]
         else:
            return [lst[0], lst[1], lst[2]]
      if type(lst[2]) == type([]):   # se il secondo operando e' una lista, valuto solo il primo
         if lst[0] == '0':
            return lst[2]
         else:
            return [lst[0], lst[1], lst[2]]

   if lst[1] == '*':
      if (string.find(string.digits, str(lst[0])) != -1) and (string.find(string.digits, str(lst[2])) != -1):  # vero se gli operandi della lista sono numeri
            return int(lst[0]) * int(lst[2])
      if (lst[0] == '0') or (lst[2] == '0'):   # se un operando e' 0, ritorna 0
         return 0
      if (lst[0] == '1'):   # se il primo operando e' 1, ritorna il secondo
         return lst[2]
      if (lst[2] == '1'):   # se il secondo operando e' 1, ritorna il primo
         return lst[0]
      if (string.find(letter, str(lst[0])) != -1) or (string.find(letter, str(lst[2])) != -1):  # vero se almeno un operando e' un simbolo
         return [lst[0], lst[1], lst[2]]
      if type(lst[0]) == type([]):   # se il primo operando e' una lista, valuto solo il secondo
         if lst[2] == '0':
            return '0'
         else:
            return [lst[0], lst[1], lst[2]]
      if type(lst[2]) == type([]):   # se il secondo operando e' una lista, valuto solo il primo
         if lst[0] == '0':
            return '0'
         else:
            return [lst[0], lst[1], lst[2]]
         
def derive(exp_raw, var):
   lst = exp_split(exp_raw)    # Prende la stringa dell'espressione in input e la converte in una lista
   lst = rimuovi_parentesi(lst)   # Rimuove le parentesi tonde
   risultato_lista = derivative(lst, var)   # Effettua la funzione di derivazione vera e propria
   return lst_to_str(calculate_result(risultato_lista))
   

  
print derive('1 + (3 * x)', 'x')
Ora il problema è che devo modificarlo per fare in modo che venga eseguito in multithread.
L'idea è che, essendo due operatori, essi vengano derivati in modo parallelo.

Io non ho alcuna esperienza di programmazione multithread. Ho provato a cercare informazioni in rete e ad applicarle, ma con scarso risultato, poichè il codice modificato mi restituisce errore.

Provo a copiare qua sotto la prova che ho fatto io.

Qualcuno riuscirebbe a darmi qualche dritta, a indicarmi dove sbaglio ed eventualmente come correggere?

Codice: Seleziona tutto

    #
    #  La funzione principale e' derive(). Accetta in ingresso una stringa e una variabile.
    #  Trasforma l'espressione da derivare, che e' sottoforma di stringa, in una lista in cui il primo e il terzo elemento sono operandi
    #  mentre il secondo e' l'operatore.
    #  Chiama poi la funzione di derivazione vera e propria, derivative() che applica le regole di derivazione sugli operatori.
    #  Infine, derive_solver() calcola la derivata sui singoli operandi.
    #


    import string
    import re
    import threading

    def exp_split(mystring):   # prende in input una espressione matematica (sottoforma di stringa) e la memorizza in una lista, dividendo gli operandi e operatori
       exp_splitted = re.split("([+-/*])", mystring.replace(" ", ""), maxsplit = 1)
       if len(exp_splitted[0]) > 2:
          exp_splitted[0] = exp_split(exp_splitted[0])
       if len(exp_splitted) > 2:           
          if len(exp_splitted[2]) > 2:
             exp_splitted[2] = exp_split(exp_splitted[2])
       return exp_splitted
          
       
    def rimuovi_parentesi(lista):          # da chiamare solo quando l'intera espressione e' gia' scomposta in liste
       lunghezza = len(lista)
       for x in range(lunghezza):
          if type(lista[x]) == type([]):
             rimuovi_parentesi(lista[x])
          else:
             lista[x] = lista[x].replace("(", "")
             lista[x] = lista[x].replace(")", "")
       return lista
                

    def derive_solver(elemento, var):
       if type(elemento) == type(0):
          return "0"
       elif elemento == var:
          return "1"
       else:
          return "0"


    def derivative(lst, var):
       t1 = threading.Thread(target = derivative,  args=(lst[0], var))
       t2 = threading.Thread(target = derivative,  args=(lst[2], var))
       if len(lst) == 1:      # Se viene chiamata la funzione derivative() su un singolo elemento, quest'ultimo viene passato a derive_solver() e risolto.
          return derive_solver(lst[0], var)
          
       if lst[1] == '+':
          return [t1.start(), '+', t2.start()]
          
       if lst[1]  == '*':
          return [[t1.start(), '*', lst[2]], '+', [lst[0], '*', t2.start()]]


    def lst_to_str(lst):   # prende in input una espressione memorizzata in una lista, e la converte in stringa
       if type(lst) != type([]):
          return lst
       elif type(lst[0]) == type([]):
          lst[0] = lst_to_str(lst[0])
       elif type(lst[2]) == type([]):
          lst[2] = lst_to_str(lst[2])
       return "(" + str(lst[0]) + " " + str(lst[1]) + " " + str(lst[2]) + ")"
          
       
    def calculate_result(lst):   # data in input una espressione (sottoforma di lista) gia' derivata, effettua i calcoli per semplificarla
       if len(lst) == 1:      # Se e' gia' un singolo elemento, restituisce l'elemento stesso senza fare nulla.
          return lst
       letter = string.lowercase + string.uppercase  # creo una stringa contenente tutte le lettere (maiuscole e minuscole). La usero' dopo per verificare che l'operando sia un simbolo
       if type(lst[0]) == type([]):      # Se il primo operando e' una lista, prima risolvo quella
          lst[0] = calculate_result(lst[0])
       if type(lst[2]) == type([]):
          lst[2] = calculate_result(lst[2])   # Se il secondo operando e' una lista, prima risolvo quella
       if lst[1] == '+':
          if (string.find(string.digits, str(lst[0])) != -1) and (string.find(string.digits, str(lst[2])) != -1):  # vero se gli operandi della lista sono numeri
                return int(lst[0]) + int(lst[2])
          if lst[0] == '0':
             return lst[2]
          if lst[2] == '0':
             return lst[0]
          if (string.find(letter, str(lst[0])) != -1) or (string.find(letter, str(lst[2])) != -1):  # vero se almeno un operando e' un simbolo
             return [lst[0], lst[1], lst[2]]
          if type(lst[0]) == type([]):   # se il primo operando e' una lista, valuto solo il secondo
             if lst[2] == '0':
                return lst[0]
             else:
                return [lst[0], lst[1], lst[2]]
          if type(lst[2]) == type([]):   # se il secondo operando e' una lista, valuto solo il primo
             if lst[0] == '0':
                return lst[2]
             else:
                return [lst[0], lst[1], lst[2]]

       if lst[1] == '*':
          if (string.find(string.digits, str(lst[0])) != -1) and (string.find(string.digits, str(lst[2])) != -1):  # vero se gli operandi della lista sono numeri
                return int(lst[0]) * int(lst[2])
          if (lst[0] == '0') or (lst[2] == '0'):   # se un operando e' 0, ritorna 0
             return 0
          if (lst[0] == '1'):   # se il primo operando e' 1, ritorna il secondo
             return lst[2]
          if (lst[2] == '1'):   # se il secondo operando e' 1, ritorna il primo
             return lst[0]
          if (string.find(letter, str(lst[0])) != -1) or (string.find(letter, str(lst[2])) != -1):  # vero se almeno un operando e' un simbolo
             return [lst[0], lst[1], lst[2]]
          if type(lst[0]) == type([]):   # se il primo operando e' una lista, valuto solo il secondo
             if lst[2] == '0':
                return '0'
             else:
                return [lst[0], lst[1], lst[2]]
          if type(lst[2]) == type([]):   # se il secondo operando e' una lista, valuto solo il primo
             if lst[0] == '0':
                return '0'
             else:
                return [lst[0], lst[1], lst[2]]
             
    def derive(exp_raw, var):
       lst = exp_split(exp_raw)    # Prende la stringa dell'espressione in input e la converte in una lista
       lst = rimuovi_parentesi(lst)   # Rimuove le parentesi tonde
       t = threading.Thread(target = derivative,  args=(lst, var))
       risultato_lista = derivative(lst, var)   # Effettua la funzione di derivazione vera e propria
       return lst_to_str(calculate_result(risultato_lista))
       
       
       
    print derive('1 + (3 * x)', 'x')


Grazie mille!! :)
Avatar utente
crap0101
Rampante Reduce
Rampante Reduce
Messaggi: 8242
Iscrizione: martedì 30 ottobre 2007, 6:33
Desktop: LXDE
Distribuzione: Ubuntu 18.04.1 LTS
Sesso: Maschile
Località: TO
Contatti:

Re: programmazione multithread in Python

Messaggio da crap0101 »

il metodo start() non ritorna nulla, cioè ritorna None, serve solo a far partire l'esecuzione del callable che hai passato al thread.
http://www.gnu.org/ http://boinc.berkeley.edu/ http://www.python-it.org/
- Ricorda le ultime parole di suo padre: «Sta' alla larga dalle chiese, figlio. La sola cosa per cui hanno la chiave è il merdaio. E giurami che non porterai mai un distintivo della legge» - W.S. Burroughs
lordalbert
Prode Principiante
Messaggi: 47
Iscrizione: sabato 15 luglio 2006, 22:23
Desktop: Xubuntu
Distribuzione: Ubuntu 14.04 LTS (x86_64)

Re: programmazione multithread in Python

Messaggio da lordalbert »

e quindi devo sostituirlo? Mi sapresti per caso dire se c'è un metodo migliore per far partire il thread e ottenere poi il risultato della computazione di tale thread?
Avatar utente
Claudio_F
Entusiasta Emergente
Entusiasta Emergente
Messaggi: 1463
Iscrizione: lunedì 28 maggio 2012, 18:49
Desktop: Mate/Gnome
Distribuzione: Ubu22.04

Re: programmazione multithread in Python

Messaggio da Claudio_F »

Normalmente è consigliabile far comunicare un thread tramite una queue. Il processo principale crea una queue e la passa come argomento al thread, poi fa un join sul thread per attenderne la fine. Il thread scrive il risultato nella queue e termina. Il processo principale legge la queue.

Sarebbe anche possibile usare una struttura dati condivisa come una lista, ma in tal caso l'accesso alla lista va "arbitrato" tramite un oggetto lock in modo che un solo thread alla volta (compreso il processo principale) possa accedere alla lista. Chi vuole usare la risorsa condivisa fa un acquire sull'oggetto lock e quando ha finito lo rilascia con release.

In ogni caso i thread Python usati per compiti cpu bound (come il caso in questione) sono inefficienti, suddividono le operazioni dal punto di vista logico, ma vengono tutte elaborate in modo seriale all'interno di un unico processo, richiedendo anche molto più tempo rispetto alla loro esecuzione non "parallela".

In alternativa esiste il modulo multiprocessing che si usa praticamente [1] nello stesso modo, che crea veri e propri processi indipendenti sparsi su tutti i core disponibili, quindi parallelismo reale.


-------
[1] c'è qualche differenza, ad esempio una queue deve essere letta completamente dal processo principale per far si che il processo secondario termini, in questo caso quindi non si usa join per attendere la fine dei processi secondari.
:ciao:
lordalbert
Prode Principiante
Messaggi: 47
Iscrizione: sabato 15 luglio 2006, 22:23
Desktop: Xubuntu
Distribuzione: Ubuntu 14.04 LTS (x86_64)

Re: programmazione multithread in Python

Messaggio da lordalbert »

Claudio_F [url=http://forum.ubuntu-it.org/viewtopic.php?p=4625560#p4625560][img]http://forum.ubuntu-it.org/images/icons/icona-cita.gif[/img][/url] ha scritto:Normalmente è consigliabile far comunicare un thread tramite una queue. Il processo principale crea una queue e la passa come argomento al thread, poi fa un join sul thread per attenderne la fine. Il thread scrive il risultato nella queue e termina. Il processo principale legge la queue.

Sarebbe anche possibile usare una struttura dati condivisa come una lista, ma in tal caso l'accesso alla lista va "arbitrato" tramite un oggetto lock in modo che un solo thread alla volta (compreso il processo principale) possa accedere alla lista. Chi vuole usare la risorsa condivisa fa un acquire sull'oggetto lock e quando ha finito lo rilascia con release.

In ogni caso i thread Python usati per compiti cpu bound (come il caso in questione) sono inefficienti, suddividono le operazioni dal punto di vista logico, ma vengono tutte elaborate in modo seriale all'interno di un unico processo, richiedendo anche molto più tempo rispetto alla loro esecuzione non "parallela".

In alternativa esiste il modulo multiprocessing che si usa praticamente [1] nello stesso modo, che crea veri e propri processi indipendenti sparsi su tutti i core disponibili, quindi parallelismo reale.


-------
[1] c'è qualche differenza, ad esempio una queue deve essere letta completamente dal processo principale per far si che il processo secondario termini, in questo caso quindi non si usa join per attendere la fine dei processi secondari.

Si lo so che solitamente bisogna regolare l'esecuzione dei processi, solitamente mediante dei semafori, degli "arbitri" che regolano l'esecuzione per evitare che più processi cercano in contemporanea di usare la stessa risorsa.

In questo caso però non serve. Non ci sono risorse da dividere fra più processi. Devo solo splittare il flusso di esecuzione in più thread. E fare in modo che funzioni :)

Al di là del fatto che sia efficiente o meno, devo farlo come esercizio, e la consegna è quella :)
Avatar utente
Claudio_F
Entusiasta Emergente
Entusiasta Emergente
Messaggi: 1463
Iscrizione: lunedì 28 maggio 2012, 18:49
Desktop: Mate/Gnome
Distribuzione: Ubu22.04

Re: programmazione multithread in Python

Messaggio da Claudio_F »

In questo caso però non serve. Non ci sono risorse da dividere fra più processi.
Se usi delle queue no. Siccome però una funzione avviata sotto thread ( con oggettothread.start() ) non può ritornare direttamente un valore (almeno mi sembra), l'altra via è di restituire i risultati scrivendo su qualche variabile condivisa dal processo principale, e qui si che abbiamo due processi diversi.
:ciao:
lordalbert
Prode Principiante
Messaggi: 47
Iscrizione: sabato 15 luglio 2006, 22:23
Desktop: Xubuntu
Distribuzione: Ubuntu 14.04 LTS (x86_64)

Re: programmazione multithread in Python

Messaggio da lordalbert »

boh, io in tutti gli esempi che ho visto, usano oggetto.start() come chiamata, il quale restituisce il risultato.

Esempio: http://www.devshed.com/c/a/Python/Basic ... in-Python/

oppure qua: http://www.scribd.com/doc/233197414/Mul ... -in-Python

Nello specifico:

Codice: Seleziona tutto

# Create new threads
thread1 = myThread(1, "Thread-1", 1) 
thread2 = myThread(2, "Thread-2", 2) 

# Start new Threads
thread1.start() 
thread2.start()
Avatar utente
crap0101
Rampante Reduce
Rampante Reduce
Messaggi: 8242
Iscrizione: martedì 30 ottobre 2007, 6:33
Desktop: LXDE
Distribuzione: Ubuntu 18.04.1 LTS
Sesso: Maschile
Località: TO
Contatti:

Re: programmazione multithread in Python

Messaggio da crap0101 »

lordalbert ha scritto:boh, io in tutti gli esempi che ho visto, usano oggetto.start() come chiamata, il quale restituisce il risultato.

Esempio: http://www.devshed.com/c/a/Python/Basic ... in-Python/

oppure qua: http://www.scribd.com/doc/233197414/Mul ... -in-Python

Nello specifico:

Codice: Seleziona tutto

# Create new threads
thread1 = myThread(1, "Thread-1", 1) 
thread2 = myThread(2, "Thread-2", 2) 

# Start new Threads
thread1.start() 
thread2.start()
ripeto: il metodo start() non restituisce nulla di utile, tanto meno il risultato... restituisce *sempre* None.
E lo fa anche in quegli esempi, in cui NON viene restituito il risultato della computazione, ma semplicemente stampato qualcosa.
Tra l'altro la prima "guida", quella di devshed, è decisamente scadente e superficiale, con _errori_ grossolani che mi fanno pensare che l'autore non ci abbia capito nulla, nè di thread nè di come funzionano nello specifico in python.
http://www.gnu.org/ http://boinc.berkeley.edu/ http://www.python-it.org/
- Ricorda le ultime parole di suo padre: «Sta' alla larga dalle chiese, figlio. La sola cosa per cui hanno la chiave è il merdaio. E giurami che non porterai mai un distintivo della legge» - W.S. Burroughs
lordalbert
Prode Principiante
Messaggi: 47
Iscrizione: sabato 15 luglio 2006, 22:23
Desktop: Xubuntu
Distribuzione: Ubuntu 14.04 LTS (x86_64)

Re: programmazione multithread in Python

Messaggio da lordalbert »

Ok. Prendiamo il pezzo di codice in esame:

Codice: Seleziona tutto

def derivative(lst, var):
	t1 = threading.Thread(target = derivative,  args=(lst[0], var))
	t2 = threading.Thread(target = derivative,  args=(lst[2], var))
	if len(lst) == 1:		# Se viene chiamata la funzione derivative() su un singolo elemento, quest'ultimo viene passato a derive_solver() e risolto.
		return derive_solver(lst[0], var)
		
	if lst[1] == '+':
		return [t1.start(), '+', t2.start()]
		
	if lst[1]  == '*':
		return [[t1.start(), '*', lst[2]], '+', [lst[0], '*', t2.start()]]
SInceramente, non ho capito come modificarlo.
Da quanto ho capito, all'interno della funzione chiamata del socket deve esserci un assegnamento di una variabile condivisa, visibile all'esterno. Piccolo dubbio: come faccio per rendere la variabile visibile al'esterno?

Ma in ogni modo, io modificherei in questo modo:

Codice: Seleziona tutto

def derivative(lst, var):
	t1 = threading.Thread(target = derivative,  args=(lst[0], var))
	t2 = threading.Thread(target = derivative,  args=(lst[2], var))
        t1.start()
        t2.start()
	if len(lst) == 1:	
		a = derive_solver(lst[0], var)    ### !!! MODIFICATO QUA !!!!!
		
	if lst[1] == '+':
		return [t1.start(), '+', t2.start()]
		
	if lst[1]  == '*':
		return [[t1.start(), '*', lst[2]], '+', [lst[0], '*', t2.start()]]
Praticamente, all'inizio, invece di usare il return uso un assegnamento, alla variabile a. Poi chiamo subito i thread dell'oggetto in questione (t1 e t2).
Ora al posto delle "vecchie chiamate" al thread, all'interno della lista, dovrei metterci la variabile (a). Però... come faccio a dire "il valore della variabile a del thread 1" piuttosto che il valore della variabile a del thread2? Perchè in questo caso il valore si sdoppia...
Avatar utente
crap0101
Rampante Reduce
Rampante Reduce
Messaggi: 8242
Iscrizione: martedì 30 ottobre 2007, 6:33
Desktop: LXDE
Distribuzione: Ubuntu 18.04.1 LTS
Sesso: Maschile
Località: TO
Contatti:

Re: programmazione multithread in Python

Messaggio da crap0101 »

lordalbert ha scritto:[...]
Ma in ogni modo, io modificherei in questo modo:

Codice: Seleziona tutto

def derivative(lst, var):
	t1 = threading.Thread(target = derivative,  args=(lst[0], var))
	t2 = threading.Thread(target = derivative,  args=(lst[2], var))
        t1.start()
        t2.start()
	if len(lst) == 1:	
		a = derive_solver(lst[0], var)    ### !!! MODIFICATO QUA !!!!!
		
	if lst[1] == '+':
		return [t1.start(), '+', t2.start()]
		
	if lst[1]  == '*':
		return [[t1.start(), '*', lst[2]], '+', [lst[0], '*', t2.start()]]
imho devi chiarirti un paio di concetti fondamentali, tipo cosa sono le funzioni e come si restituiscono i valori _normalmente_, poi puoi incominciare a complicare le cose con i thread.
Voglio dire, oltre agli errori già segnalati e non corretti, la modifica che proponi cambia proprio la *semantica* della funzione... è diventata un'altra cosa, se prima svolgeva un certo compito ora ne svolge un altro; e poi di 'a' che intendi farne?

Come diceva Claudio_F, dai un'occhiata anche alla doc del modulo multiprocessing che è abbastanza simile nel funzionamento e ci sono più esempi (e più chiari).
http://www.gnu.org/ http://boinc.berkeley.edu/ http://www.python-it.org/
- Ricorda le ultime parole di suo padre: «Sta' alla larga dalle chiese, figlio. La sola cosa per cui hanno la chiave è il merdaio. E giurami che non porterai mai un distintivo della legge» - W.S. Burroughs
lordalbert
Prode Principiante
Messaggi: 47
Iscrizione: sabato 15 luglio 2006, 22:23
Desktop: Xubuntu
Distribuzione: Ubuntu 14.04 LTS (x86_64)

Re: programmazione multithread in Python

Messaggio da lordalbert »

crap0101 [url=http://forum.ubuntu-it.org/viewtopic.php?p=4626064#p4626064][img]http://forum.ubuntu-it.org/images/icons/icona-cita.gif[/img][/url] ha scritto: imho devi chiarirti un paio di concetti fondamentali, tipo cosa sono le funzioni e come si restituiscono i valori _normalmente_,
Eh si, l'avevo detto di stare imparando ora a programmare, soprattutto in python :)
Ad ogni modo, da quel che so, i valori _normalmente_ si restituiscono con l'apposita direttiva *return*. O almeno, all'uni ci hanno insegnato così.
Avatar utente
crap0101
Rampante Reduce
Rampante Reduce
Messaggi: 8242
Iscrizione: martedì 30 ottobre 2007, 6:33
Desktop: LXDE
Distribuzione: Ubuntu 18.04.1 LTS
Sesso: Maschile
Località: TO
Contatti:

Re: programmazione multithread in Python

Messaggio da crap0101 »

quindi concordi che cercare di restituire il risultato di un metodo che ritorna *sempre* lo stesso valore è perfettamente inutile?
http://www.gnu.org/ http://boinc.berkeley.edu/ http://www.python-it.org/
- Ricorda le ultime parole di suo padre: «Sta' alla larga dalle chiese, figlio. La sola cosa per cui hanno la chiave è il merdaio. E giurami che non porterai mai un distintivo della legge» - W.S. Burroughs
Scrivi risposta

Ritorna a “Programmazione”

Chi c’è in linea

Visualizzano questa sezione: 0 utenti iscritti e 13 ospiti