Why do we have to add comma ',' in args in python multithreading?-CodePudding

I am new to python and I am not sure why we use Comma ',' in args for Thread Eg:

import threading
import time

semaphore = threading.BoundedSemaphore(value=5)

def access(thread_number):
    print("{}: Trying access...".format(thread_number))

    semaphore.acquire()

    print("{}: Access granted!".format(thread_number))

    print("{}: waiting 5 seconds...".format(thread_number))

    time.sleep(5)
    semaphore.release()

    print("{}: Releasing!...".format(thread_number))


for thread_number in range(10):
    t = threading.Thread(target=access, args=(thread_number,))
    t.start()

Why is it valid? how does "args = (thread_number,)" need comma at the end?

CodePudding user response：

Alas, this isn't especially easy - it's at the intersection of some dark corners of Python's syntax.

First, the comma is needed to make a tuple, with a single element, containing the thread number:

>>> 6
6
>>> 6,
(6,)
>>> (6,)
(6,)
>>> (6)
6

See? Without a comma, or with just parentheses, 6 is just the int 6. But with a comma - and with or without parentheses - it becomes a tuple containing the int 6 as its only element.

Why does it need to be a tuple? You're soon going to be told that it actually doesn't ;-) , but before then consider that you may need to pass any number of arguments to a thread. So the expression after args= must yield a sequence.

But if the appearance of comma makes a tuple, why do you also need parentheses? That's an "intersection of some dark corners": a comma in an argument list also seperates arguments, and that takes precedence in this context. So the parentheses are needed to enforce the intent: "this comma doesn't mean the next argument is starting - this comma means I want a tuple".

To avoid having to think about all that, you can use a list as a sequence instead in this context:

    t = threading.Thread(target=access, args=[thread_number])

The implementation of Thread couldn't care less which kind of sequence is passed as the value of args=, and lots of code actually uses a list instead of a tuple. However, last time I looked, that had not been documented, so it's a bit risky.

CodePudding user response：

If you add comma then for python it's a tuple and empty parentheses is also tuple

>>> type( (1,) )
<class 'tuple'>
>>> type( (1) )
<class 'int'>
>>> type( (1,2))
<class 'tuple'>
>>> type( () )
<class 'tuple'>