Passing Parameters to a Thread Target in Python

When working with multithreading in Python, a common question is whether you can pass parameters to the function executed by a thread. The short answer is yes — Python’s threading. Thread class provides built-in support for this.

This post walks through the correct and idiomatic ways to pass arguments to a thread target function.

---

The Basic Thread Pattern

A typical thread is created like this:

import threading

 

t = threading.Thread(target=compare_totals)

t.start()

This works only if compare_totals takes no parameters. If your function requires inputs, you must supply them explicitly.

---

Passing Positional Arguments with args

Use the args parameter to pass positional arguments to the target function. args must be a tuple.

def compare_totals(source, target):

print(source, target)

 

t = threading.Thread(

target=compare_totals,

args=(“athena”, “oracle”)

)

t.start()

Each element in the tuple maps to a parameter in the function signature.

---

Passing Keyword Arguments with kwargs

If you prefer named arguments (or want clearer intent), use kwargs:

def compare_totals(source, target):

print(source, target)

 

t = threading.Thread(

target=compare_totals,

kwargs={

“source”: “athena”,

“target”: “oracle”

}

)

t.start()

This approach is especially helpful when a function takes many parameters or optional values.

---

Passing a Single Object (Such as a Dictionary)

A common pattern is to pass a single dictionary containing multiple configuration values:

def compare_totals(params):

print(params)

 

params = {

“engine”: “mysql”,

“schema”: “public”,

“table”: “employees”

}

 

t = threading.Thread(

target=compare_totals,

args=(params,)

)

t.start()

⚠️ Important:
When passing a single argument via args, you must include a trailing comma: (params,). Without it, Python will not treat the value as a tuple.

---

Summary

• Use args for positional arguments
• Use kwargs for named arguments
• Always pass args as a tuple, even for a single value
• Thread targets behave just like normal function calls — the thread simply invokes the function with the supplied parameters

Understanding this pattern makes it much easier to parallelize work cleanly and safely in Python.