5 Best Ways to Write Functions in Python That Accept Any Number of Arguments

Rate this post

πŸ’‘ Problem Formulation: In Python development, situations often arise where you need a flexible function that can handle varying numbers of input arguments. For instance, you may want to create a function calculate_sum() that should be able to add any number of numbers together, regardless of whether it’s 2 or 20 numbers in the input.

Method 1: Using *args for Variable Number of Positional Arguments

This method involves defining a function that includes *args as a parameter. The *args will capture any additional positional arguments passed to the function as a tuple. It’s flexible and commonly used for functions that operate on sequences of inputs.

Here’s an example:

def adder(*args):
    return sum(args)

print(adder(1, 2, 3, 4, 5))

Output: 15

In this snippet, the adder() function takes any number of positional arguments, collectively referred to as args. It returns the sum of all the input numbers using Python’s built-in sum() function, which perfectly handles a tuple of numbers.

Method 2: Using **kwargs for Variable Number of Keyword Arguments

The **kwargs parameter allows a function to accept any number of keyword arguments, which it stores in a dictionary. This is particularly useful for functions that need to handle named parameters dynamically.

Here’s an example:

def greet(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} : {value}")

greet(Hello='World', Greetings='Earthlings')


Hello : World
Greetings : Earthlings

In the code above, the greet() function can accept any number of keyword arguments. The kwargs.items() method is used to iterate over the dictionary of keyword arguments, allowing the function to handle them as needed.

Method 3: Combining *args and **kwargs

Python allows the use of both *args and **kwargs simultaneously in order to accept an arbitrary number of both positional and keyword arguments. This provides maximum flexibility for parameter passing.

Here’s an example:

def mixer(*args, **kwargs):

mixer(1, 2, fruit='apple', vegetable='carrot')


(1, 2)
{'fruit': 'apple', 'vegetable': 'carrot'}

The mixer() function demonstrates how to combine positional and keyword arguments. Positional arguments are available as a tuple called args, and keyword arguments as a dictionary called kwargs.

Method 4: Default Parameters for Optional Arguments

Sometimes, functions can have optional parameters with default values. If an argument for a parameter with a default value is not provided, the function uses the default.

Here’s an example:

def profile(name, age, city='Unknown'):
    print(f'Name: {name}, Age: {age}, City: {city}')

profile('Alice', 30)
profile('Bob', 25, city='New York')


Name: Alice, Age: 30, City: Unknown
Name: Bob, Age: 25, City: New York

In the above function profile(), the parameter city has a default value. Thus, it is optional when calling the function.

Bonus One-Liner Method 5: Using Lambda Functions

Lambda functions in Python can also accept any number of arguments by using *args and **kwargs. They are useful for short, one-off functions that don’t need explicit naming.

Here’s an example:

power_sum = lambda *args: sum(i**2 for i in args)
print(power_sum(1, 2, 3))

Output: 14

This one-liner lambda function named power_sum accepts any number of positional arguments, squares each one, and returns their sum.


  • Method 1: *args. Strengths: Straightforward for positional arguments. Weaknesses: Cannot handle keyword arguments.
  • Method 2: **kwargs. Strengths: Handles keyword arguments well. Weaknesses: Not suitable for positional arguments.
  • Method 3: Combining *args and **kwargs. Strengths: Highly flexible. Weaknesses: Can be confusing at times due to the mixture of input types.
  • Method 4: Default Parameters. Strengths: Simplifies function calls with fewer arguments. Weaknesses: Limited flexibility compared to *args and **kwargs.
  • Bonus Method 5: Lambda Functions. Strengths: Concise syntax for simple functions. Weaknesses: Can be less readable and harder to debug.