Parallel(?) programming with python

[Andreas Croci]

Thanks for your reply.

On 08.08.22 13:20, Stefan Ram wrote:

>    Yes, but this is difficult. If you ask this question here,
>    you might not be ready for this.

Indeed.

> 
>    I haven't learned it yet myself, but nevertheless tried to
>    write a small example program quickly, which might still
>    contain errors because of my lack of education.
> 
> import threading
> import time
> 
> def write_to_list( list, lock, event ):
>      for i in range( 10 ):
>          lock.acquire()
>          try:
>              list.append( i )
>          finally:
>              lock.release()
>          event.set()
>          time.sleep( 3 )
> 
> def read_from_list( list, lock, event ):
>      while True:
>          event.wait()
>          print( "Waking up." )
>          event.clear()
>          if len( list ):
>              print( "List contains " + str( list[ 0 ]) + "." )
>              lock.acquire()
>              try:
>                  del list[ 0 ]
>              finally:
>                  lock.release()
>          else:
>              print( "List is empty." )
> 
> list = []
> lock = threading.Lock()
> event = threading.Event()
> threading.Thread( target=write_to_list, args=[ list, lock, event ]).start()
> threading.Thread( target=read_from_list, args=[ list, lock, event ]).start()

If I understand some things correctly, a "lock" would be something that, 
as the name says, locks, meaning prevents parts of the program from 
executing on the locked resource until ohter parts have finished doing 
their things and have released the lock. If this is correct, it's not 
exactly what I wanted, because this way "parts of the program" would not 
"keep doing their things, while other parts do other things on the same 
data".

I'm in principle ok with locks, if it must be. What I fear is that the 
lock could last long and prevent the function that writes into the list 
from doing so every second. With an FFT on a list that contains a few 
bytes taken every second over one week time (604.800 samples), I believe 
it's very likely that the FFT function takes longer than a second to return.

Then I would have to import all the data I have missed since the lock 
was aquired, which is doable, but I would like to avoid it if possible.

> 
>    In basketball, first you must learn to dribble and pass,
>    before you can begin to shoot.

Sure.

> 
>    With certain reservations, texts that can be considered
>    to learn Python are:
> 
> "Object-Oriented Programming in Python Documentation" - a PDF file,
> Introduction to Programming Using Python - Y Daniel Liang (2013),
> How to Think Like a Computer Scientist - Peter Wentworth (2012-08-12),
> The Coder's Apprentice - Pieter Spronck (2016-09-21), and
> Python Programming - John Zelle (2009).
> 

Thank you for the list. I an currently taking a Udemy course and at the 
same time reading the tutorials on python.org. I hope I will some day 
come to any of the books you suggest (I'm doing this only in my spare 
time and it will take forever).