Just use the *args parameter, which allows you to pass as many arguments as you want after your a,b,c. You would have to add some logic to map args->c,d,e,f but its a "way" of overloading.
Copydef myfunc(a,b, *args, **kwargs):
for ar in args:
print ar
myfunc(a,b,c,d,e,f)
And it will print values of c,d,e,f
Similarly you could use the kwargs argument and then you could name your parameters.
Copydef myfunc(a,b, *args, **kwargs):
c = kwargs.get('c', None)
d = kwargs.get('d', None)
#etc
myfunc(a,b, c='nick', d='dog', ...)
And then kwargs would have a dictionary of all the parameters that are key valued after a,b
Top answer 1 of 8
467
Just use the *args parameter, which allows you to pass as many arguments as you want after your a,b,c. You would have to add some logic to map args->c,d,e,f but its a "way" of overloading.
Copydef myfunc(a,b, *args, **kwargs):
for ar in args:
print ar
myfunc(a,b,c,d,e,f)
And it will print values of c,d,e,f
Similarly you could use the kwargs argument and then you could name your parameters.
Copydef myfunc(a,b, *args, **kwargs):
c = kwargs.get('c', None)
d = kwargs.get('d', None)
#etc
myfunc(a,b, c='nick', d='dog', ...)
And then kwargs would have a dictionary of all the parameters that are key valued after a,b
2 of 8
331
Try calling it like: obj.some_function( '1', 2, '3', g="foo", h="bar" ). After the required positional arguments, you can specify specific optional arguments by name.
Mimo
mimo.org › glossary › python › optional-arguments
Python Optional Argument: Syntax, Usage, and Examples
An optional argument in Python is a function parameter that has a default value, so you can call the function with or without passing that value.
Videos
Optional Arguments in Python Functions - YouTube
00:57
How To Add Optional Parameter In Python Function - YouTube
01:04
Defining Python Functions With Optional Arguments (Overview) (Video) ...
04:04
The Best Way to Check for Optional Arguments in Python - YouTube
05:50
Python Programming Tutorial #17 - Optional Parameters - YouTube
00:58
Master Optional Arguments in Python - YouTube
Real Python
realpython.com › python-optional-arguments
Using Python Optional Arguments When Defining Functions – Real Python
October 27, 2025 - You can assign default values to parameters so that arguments become optional · You should avoid mutable data types like lists or dictionaries as default values to prevent unexpected behavior · You can use *args to collect any number of positional ...
GeeksforGeeks
geeksforgeeks.org › python › how-to-pass-optional-parameters-to-a-function-in-python
How to Pass Optional Parameters to a Function in Python - GeeksforGeeks
July 23, 2025 - In Python, functions can have optional parameters by assigning default values to some arguments. This allows users to call the function with or without those parameters, making the function more flexible.
The Python Coding Book
thepythoncodingbook.com › home › blog › optional arguments with default values in python functions [intermediate python functions series #3]
Optional Arguments with Default Values in Python Functions
January 18, 2023 - You achieve this by adding an equals after the parameter name followed by the default value · When you call the function, the corresponding argument is optional. If the argument is not present in the function call, the default value is used ...
Medium
medium.com › @laurentkubaski › python-type-hints-how-many-ways-can-you-say-optional-a940f7ef03e2
Python Type Hints: How Many Ways Can You Say ‘Optional’? | by Laurent Kubaski | Medium
September 2, 2025 - I personally find the first “Optional[str]” notation to be confusing since it can be interpreted in two different ways: Interpretation #1 (the correct one): “When calling a function, the parameter needs to be provided, but the parameter value is Optional (ie: the parameter value can be None)”
Python.org
discuss.python.org › core development
Should `None` defaults for optional arguments be discouraged? - Core Development - Discussions on Python.org
February 5, 2023 - I recently merged a PR authored by Sergey Kirpichev that fixes inspect.signature (which previously failed with a ValueError) for math.log and cmath.log. A side-effect of that change is that math.log and cmath.log now accept the Python value None for the base argument.
Reddit
reddit.com › r/learnpython › adding optional arguments to a function
r/learnpython on Reddit: Adding optional arguments to a function
September 8, 2021 -
I am working on a project where I'm supposed to add new features to an existing codebase. As part of this, I need to add an optional argument to one of the functions but just adding the optional argument is causing some of my unit tests to fail.
The function looks like the following initially:
def function(data1: list,
data2: list,
opt1: Optional[list],
) After adding another optional argument it looks like this:
def function(
data1: list,
data2: list,
opt1: Optional[list],
new: Optional[dict],
)The only change I'm making in the codebase is adding this optional argument and it is causing some of my unit tests to fail. I was wondering if someone knows what might be the reason ?
Top answer 1 of 2
6
Type hints are ignored by the interpreter. You still need to provide a default value for the argument if one isn't provided in the function call. The appropriate default value to use with the Optional type hint is None, so: def function( data1: list, data2: list, opt1: Optional[list] = None, new: Optional[dict] = None, )
2 of 2
4
Just to add on to Binary, Optional, despite its name, has nothing to do with optional arguments (although they're often used together). Optional represents an " option type ". It's a type that could be a usable type, or NoneType.
University of Toronto
teach.cs.toronto.edu › ~csc110y › fall › notes › 12-interlude-nifty-python-features › 03-functions-with-optional-parameters.html
12.3 Functions with Optional Parameters
Suppose we want to define a function that takes a number n and by default returns n + 1, but allows the caller to specify an optional step amount to increase by. def increment(n: int, step: int = 1) -> int: """Return n incremented by step. If the step argument is omitted, increment by 1 instead. """ return n + step · Let’s experiment with this function in the Python console: >>> increment(10, 2) # n = 10, step = 2 12 >>> increment(10) # n = 10 11 · In the latter case, no argument is passed for the step parameter, and so the default value 1 is used instead, causing 10 + 1 == 11 to be returned.
Codecademy
codecademy.com › learn › learn-intermediate-python-3 › modules › int-python-function-arguments › cheatsheet
Learn Intermediate Python 3: Function Arguments Cheatsheet | Codecademy
In Python, a default parameter is defined with a fallback value as a default argument. Such parameters are optional during a function call.
Reddit
reddit.com › r/learnpython › am i wrong in thinking that optional arguments *should* be allowed to precede required arguments?
r/learnpython on Reddit: Am I wrong in thinking that optional arguments *should* be allowed to precede required arguments?
June 3, 2022 -
The mapping of the arguments can presumably be determined based simply on the number of arguments you pass. For example, let's say you had the following, with the "middle" argument being optional/default:
def format_name(first, middle='', last):
return first + ' ' + middle + ' ' + lastIf you passed
format_name('John', 'Smith')the interpreter should be able to deduce that the second argument is referring to the parameter *last*, not the optional parameter *middle*, since there's only two arguments passed. Is this not allowed simply because of the overhead that would be required in implementing this consideration?
Many thanks for your help!
Top answer 1 of 5
6
How would it "be able to deduce that the second argument is referring to the parameter last"? What about the 'Smith' argument prevents it from being for the middle name parameter? Edit: Keep in mind default argument != keyword argument. I've seen people here conflate the two. A parameter that has a default argument is still allowed to be accessed positionally.
2 of 5
2
You are wrong. But if you really don't want to just to force all the args to be keyword args (or just last), or give defaults to first and last too, you can achieve what you want using an arbitrary number of positional args (you should really process mutable default args in this way already): def format_name(**kwargs): first = kwargs['first'] middle = kwargs.get('middle', '') last = kwargs['last'] return ' '.join(first, middle, last) def format_name(*args): if len(args) == 2: first, last = args middle = '' else: first, middle, last = args return ' '.join(first, middle, last)
Leapcell
leapcell.io › blog › understanding-optional-arguments-in-python
Understanding Optional Arguments in Python | Leapcell
July 25, 2025 - Optional arguments are function parameters that are not required when the function is called. They are defined with default values in the function signature.
Replit
replit.com › discover › how-to-make-a-parameter-optional-in-python
How to make a parameter optional in Python
April 6, 2026 - Build and deploy software collaboratively with the power of AI without spending a second on setup.
Medium
medium.com › @khanfarazahmed7 › difference-between-required-optional-positional-and-keyword-arguments-in-python-functions-1fa9cd6a46c4
Difference between Required, Optional, Positional and Keyword arguments in Python functions | by Faraz Khan | Medium
November 15, 2023 - Optional arguments make function calls easier by letting you define a function that can be called with fewer arguments than it is defined to allow. Keyword arguments, on the other hand, offer flexibility in the way you pass parameters to a function while calling it. Python ·
Python documentation
docs.python.org › 3 › library › typing.html
typing — Support for type hints
Changed in version 3.10: Optional can now be written as X | None. See union type expressions. ... Special form for annotating higher-order functions. Concatenate can be used in conjunction with Callable and ParamSpec to annotate a higher-order callable which adds, removes, or transforms parameters of another callable.
GoLinuxCloud
golinuxcloud.com › home › programming › master python optional arguments usage [tutorial]
Master Python Optional Arguments Usage [Tutorial] | GoLinuxCloud
January 9, 2024 - Optional arguments in Python are function parameters that have default values specified.
Index.dev
index.dev › blog › default-vs-optional-parameters-python
Default vs Optional Parameters in Python Functions: Key Differences
October 31, 2024 - Default parameters are those that have a default value if the caller does not specify one. Optional parameters: Parameters that accept a variable number of arguments via *args and **kwargs.
TutorialsPoint
tutorialspoint.com › article › how-to-make-the-argument-optional-in-python
How to make the argument optional in Python
March 25, 2026 - In Python functions, you can make ... Hi, Bob! The argparse module handles optional command-line arguments. Parameters starting with dashes (--) are optional and can have default values ?...
Pydantic
pydantic.dev › docs › validation › latest › concepts › fields
Fields | Pydantic Docs
By default, Pydantic will not validate default values. The validate_default field parameter (or the validate_default configuration value) can be used to enable this behavior:
Tech with Tim
techwithtim.net › tutorials › python-programming › intermediate-python-tutorials › optional-parameters
Python Tutorial - Optional Parameters
This python tutorial covers optional paramaters in python. Optional paramaters allow you to set a default value for a parameter if it is not given from the call.