 # I think it is a threading solution problem but I don't know how to programming it

Hello, I was running a for loop which contains two part. I want the second part of the loop can continue to run because it receive the data from first part, and I can run the first part of the next loop. So I represent number as loop number, and A B two part.

1A->(1B, 2A)->(2B, 3A)->…->((n-1)B, nA)–>nB

Can threading module achieve my concept? Thanks.

Probably.

The simplest approach probably looks like this: write your loop body to
do the first part of the loop, and put the logic for the second part in
a function. Now your loop looks like:

``````from threading import Thread

def second(x):
do the second part here using x (and whatever else you need)

for x in something:
# first part
... do the first part with x
T.start()
``````

That will dispatch a call to second(x) after the first part, and then

This has various potential issues, depending on what you want to do:

• races: if the for-loop and second() access common dat a structures you
need to ensurre that they do this in a thread-safe manner, for example
by taking locks around the code working on them
• limit the number of threads - maybe only 1 instance of second() should
run at a time, or maybe there is a performance limit on the number of
instances of second() which should run

But it would be a start.

Depending on what you need/want to do you might need a different
approach.

Cheers,
Cameron Simpson cs@cskk.id.au

I’m sorry, I don’t understand why you want threading here.

I don’t fully understand your loop logic, but I think all you want is
to interleave two sequences A and B, like this:

``````A = [1, 2, 3, 4, 5, 6]
B = ['a', 'b', 'c', 'd', 'e', 'f']

# process 1, 'a', 2, 'b', 3, 'c', etc in that order.
``````

Is that what you want? You don’t need threads for that. Threads will
just add a HUGE amount of complexity and non-determinism (you can’t
control the order that the threads run) and hurt performance a lot.

If you want something different, please explain in more detail what you
want, but here is how you can interleave two lists like A and B.

``````# stop on the shortest list
def interleave(a, b):
for x, y in zip(a, b):
yield x
yield y

# A shorter version of the above:
from itertools import chain
def interleave(a, b):
return chain.from_iterator(zip(a, b))

# Now process the items.
for item in interleave(alist, blist):
process(item)
``````

If you want to pad the shorter list with a pad value, so that they are
the same length, change the call to “zip” to “zip_longest” like this:

``````from itertools import zip_longest
def interleave(a, b):
for x, y in zip_longest(a, b, fillvalue='padding'):
yield x
yield y``````

Why I want to do this is because I define a function and in this function I can separate it into two part and the second part takes time over my expectation so I want to try when executing second part I can go to next loop and run the same function at the same time. Hope I clarify my need clear enough.

No, sorry, I still don’t understand. Can you give a specific example?

If you are expecting to process items in a specific order:

``````1, 2, 3, 4, 5, ...
``````

then you can’t use one thread to do the odd numbers and another thread

to do the even numbers:

``````# thread A

1, 3, 5, 7, ...

2, 4, 6, 8, ...
``````

because you cannot control the order that A and B will run. So you might

see:

``````1, 2, 4, 3, 6, 5, 7, 9, 8, ...
``````

If you don’t care about the order that the calculation is done, then

But threading in Python is very unlikely to speed up your code,