Python is renowned for its simplicity and flexibility, which often comes from its ability to handle functions with variable numbers of arguments.

Two special symbols, *args and **kwargs, play a pivotal role in this flexibility.

In this article, we'll explore what these symbols mean, how to use them, and why they're so powerful.

The Basics of *args

The *args parameter allows a function to accept any number of positional arguments.

The asterisk (*) is a signal to Python that all positional arguments should be collected into a tuple.

Example of *args in Action

def greet(*args):
    for name in args:
        print(f"Hello, {name}!")

greet('Alice', 'Bob', 'Charlie')

Output:

Hello, Alice!
Hello, Bob!
Hello, Charlie!

Explanation:

  • The function greet accepts any number of positional arguments.
  • Inside the function, args is a tuple containing all the arguments passed.
  • We iterate over args to print a greeting for each name.

When I first learned about *args, it felt like unlocking a new level in a video game. So much simpler to define a function.

Ready to enhance your coding skills? Check out Developer Service Blog Courses for beginner-friendly lessons on core programming concepts.

Check Out Developer Service Blog Courses

Start learning today and build your path to becoming a confident developer! 🚀

Diving into **kwargs

Similarly, **kwargs allows a function to accept any number of keyword arguments.

The double asterisks (**) tell Python to collect all keyword arguments into a dictionary.

Example of **kwargs in Action

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

display_info(name='Alice', age=30, city='New York')

Output:

name: Alice
age: 30
city: New York

Explanation:

  • The function display_info accepts any number of keyword arguments.
  • Inside the function, kwargs is a dictionary containing all the keyword arguments.
  • We iterate over kwargs.items() to print each key-value pair.

Using **kwargs has been a lifesaver when dealing with functions that require a flexible set of named parameters. It keeps my code clean and organized.

Combining *args and **kwargs

You can use both *args and **kwargs in the same function to accept all types of arguments.

Example of Combined Usage

def make_sentence(*args, **kwargs):
    sentence = ' '.join(args)
    for key, value in kwargs.items():
        sentence += f" {key} {value}"
    print(sentence)

make_sentence('I', 'love', 'Python', exclamation='!', emoji='😊')

Output:

I love Python exclamation ! emoji 😊

Explanation:

  • *args collects positional arguments into a tuple.
  • **kwargs collects keyword arguments into a dictionary.
  • We build a sentence by joining positional arguments and appending keyword arguments.

Mixing *args and **kwargs feels like cooking with all the right ingredients—you can adjust the recipe as you like without breaking the dish.

The Order of Parameters

When using *args and **kwargs, the order in which you place them in the function definition matters:

  1. Regular positional arguments
  2. *args
  3. Keyword arguments (those without default values)
  4. Keyword arguments with default values
  5. **kwargs

Correct Order Example

Tagged in:

Python