Keyword Arguments In Python: What, Why & How To Use (+Examples)

0 min read

When you call a function in Python, you’re not just tossing values into a black hole– you are giving it instructions. And how you give those instructions matters. Functions accept arguments in different ways, and keyword arguments in Python are one of the most readable and powerful ones. 

Whether you're working with third-party libraries, writing your own reusable Python functions, or debugging a confusing bug caused by misplaced arguments, keyword arguments can be your best friend. In this article, we will discuss what arguments/ function arguments are, they purpose of keyword arguments, where to use them, and more.

What Are Arguments In Python?

In Python language (and most programming languages), arguments are the values you provide to a function when you want it to do something with specific data. But don’t think of them as just inputs, instead, think of them as instructions you're passing to a small, reusable machine.

So in short, arguments (or function arguments) are the values you pass into a function so it can do its job.

Here is how they work:

When you define a function, you declare parameters — placeholders for data. When you call that function, you supply arguments — the actual data.

def greet(name):
    print(f"Hello, {name}!")
greet("Shivani")  # Here "Shivani" is the argument

Here, name is the parameter, and "Shivani" is the argument passed to that parameter.

Real-Life analogy:

Imagine you're at a restaurant and say: “Give me a burger with extra cheese and no onions.”

By doing so, you have just passed arguments to the kitchen:

• burger→ main dish (mandatory argument)
• extra cheese→ a customization (keyword argument, maybe)
• no onions→ another customization (keyword argument)

If you had just said “Food”, the chef might’ve handed you something random. Clear arguments = predictable results. In other words, these arguments help you customize what a function does, just like telling the chef how you want your order.

Why Does Understanding Arguments Matter?

Understanding arguments isn’t just about writing correct syntax — it’s about writing predictable, readable, and reusable code. Once you grasp the different ways you can pass arguments (especially keyword arguments), you unlock a powerful level of control in Python.

Types Of Arguments In Python

Python functions are super flexible — they let you pass arguments in five different ways, depending on how explicit or dynamic you want to be. Here’s a breakdown of all five:

1. Positional Arguments In Python

These are the most common and intuitive type of arguments. When you call a function with positional arguments, Python matches them to parameters in the exact order they are listed in the function definition.

Why use them? They’re great for functions with a small number of parameters where the order is obvious. But they can quickly become confusing when you have many arguments– especially if they’re of the same type.

Code Example:

            def full_name(first, last):
    print(f"{first} {last}")
full_name("Ada", "Lovelace")
          

ZGVmIGZ1bGxfbmFtZShmaXJzdCwgbGFzdCk6CiAgICBwcmludChmIntmaXJzdH0ge2xhc3R9IikKZnVsbF9uYW1lKCJBZGEiLCAiTG92ZWxhY2UiKQ==

Output:

Ada Lovelace

Code Explanation:

• Here, we define a function called full_name which takes two parameters first and last which are positional arguments.
• The f-string inside the function takes and prints them in a specific order.
• When we call the function, the arguments "Ada" and "Lovelace" are matched to the first and last names, respectively, based on position – no names are involved.
• If you swap the values, the output changes accordingly. That’s the limitation you must remember and respect the correct order.

Drawback: Swapping the values can sometimes change the output in ways that are hard to debug.

2. Keyword Arguments In Python

With keyword arguments, you pass values by explicitly stating the name of the parameter, like name="Shivani". This allows you to ignore the order of parameters in the function call.

Why use them? They make your code more readable and reduce the chances of bugs– especially in functions with optional or many parameters. They’re also essential when working with third-party libraries or APIs where you might not remember the exact order.

Code Example:

            def full_name(first, last):
    print(f"{first} {last}")
full_name(last="Lovelace", first="Ada")
          

ZGVmIGZ1bGxfbmFtZShmaXJzdCwgbGFzdCk6CiAgICBwcmludChmIntmaXJzdH0ge2xhc3R9IikKZnVsbF9uYW1lKGxhc3Q9IkxvdmVsYWNlIiwgZmlyc3Q9IkFkYSIp

Output:

Ada Lovelace

Code Explanation:

In this function, we once again define the same function, but here when we call it, we pass the parameter name and then assign values.

• So here, the position doesn’t matter as Python matches values to parameter names.
• Even though last comes first in the call, Python knows exactly where to plug each value because you’ve used key=value syntax.

It improves clarity, avoids positional errors, and is especially useful in functions with many optional or similarly-typed arguments.

3. Default Arguments In Python

Default arguments let you pre-define values for parameters so that callers can choose to skip them. If no value is provided, Python uses the default.

Why use them? They simplify function calls by avoiding the need to always provide every argument. Think of them as sensible fallbacks — ideal when your function usually behaves the same way but occasionally needs customization.

You can define default values for parameters. If the caller skips that argument, the default is used.

Code Example:

            def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")
greet("Aman")
greet("Aman", greeting="Hi")
          

ZGVmIGdyZWV0KG5hbWUsIGdyZWV0aW5nPSJIZWxsbyIpOgogICAgcHJpbnQoZiJ7Z3JlZXRpbmd9LCB7bmFtZX0hIikKZ3JlZXQoIkFtYW4iKQpncmVldCgiQW1hbiIsIGdyZWV0aW5nPSJIaSIp

Output:

Hello, Aman!
Hi, Aman!

Code Explanation:

• Here, we define the function greet, that takes two parameters, name, and greeting and assign a default string value to the second parameter.
• Inside, we use the print() function with f-string to display a message inputting the arguments passed.
• In the first function call, we pass only one value and it uses the default "Hello".
• In the second function call, we pass the argument value for both parameter, and hence “Hi” overrides the default value.

✅ Benefit: Cleaner function calls when some parameters usually have the same value.

4. Variable-Length Positional Arguments (*args) In Python

Sometimes, you won’t know in advance how many values a function needs to accept. That’s where *args comes in– it allows you to pass an arbitrary number of positional arguments. They are also known as arbitrary positional arguments.

Why use them? They’re perfect for functions that need to process lists of inputs, like summing numbers or joining strings, without limiting the function to a fixed number of parameters.

Code Example:

            def add_numbers(*numbers):
    total = sum(numbers)
    print(f"Total: {total}")
add_numbers(10, 20, 30)
          

ZGVmIGFkZF9udW1iZXJzKCpudW1iZXJzKToKICAgIHRvdGFsID0gc3VtKG51bWJlcnMpCiAgICBwcmludChmIlRvdGFsOiB7dG90YWx9IikKYWRkX251bWJlcnMoMTAsIDIwLCAzMCk=

Output:

Total: 60

Code Explanation:

• Here, the function add_numbers() takes an arbitrary number of parameters, represented by *numbers.
• We use the built-in Python function sum() to calculate the sum of all arguments.
• All values passed to the function are collected into the numbers tuple: (10, 20, 30)
• You can then loop, sum, or process them however you like.

✅ *args is your go-to for flexible, Python list-like input when argument count isn’t fixed.

5. Variable-Length Keyword Arguments (**kwargs) In Python

Just like *args collects excess positional arguments, **kwargs collects excess keyword arguments into a dictionary. It is also known as arbitrary keyword arguments.

Why use them? They give you maximum flexibility. Great for configuration-heavy functions, plugin systems, or passing optional features. You can accept and handle dynamic sets of named inputs cleanly.

Code Example:

            def print_profile(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
print_profile(name="Geeta", field="Computing", award="Gold Medal")
          

ZGVmIHByaW50X3Byb2ZpbGUoKiprd2FyZ3MpOgogICAgZm9yIGtleSwgdmFsdWUgaW4ga3dhcmdzLml0ZW1zKCk6CiAgICAgICAgcHJpbnQoZiJ7a2V5fToge3ZhbHVlfSIpCnByaW50X3Byb2ZpbGUobmFtZT0iR2VldGEiLCBmaWVsZD0iQ29tcHV0aW5nIiwgYXdhcmQ9IkdvbGQgTWVkYWwiKQ==

Output:

name: Geeta
field: Computing
award: Gold Medal

Code Explanation:

• We define a function which takes arbitrary keyword arguments, and inside all key-value pairs are collected into the kwargs dictionary.
• You can then access or iterate over them dynamically.

✅ **kwargs is especially handy in cases like API configurations, optional settings, or extensible plugin-like systems.

Summary Table

Also read: Python Keywords | All 39 Reserved & Soft Explained +Code Examples

What Are Keyword Arguments In Python?

In Python, keyword arguments let you call a function by explicitly naming each parameter using the key=value format. This removes any dependence on the order of arguments — and boosts both clarity and reliability.

Syntax of Keyword Arguments in Python

function_call (key1=value1, key2=value2,....)

Here, the function_call refers to the function name which we are calling and the key and value terms refers to the name of the parameter and value being passed in its place.

Code Example:

            def describe_pet(animal, name):
    print(f"{name} is a {animal}.")
describe_pet(animal="dog", name="Buddy")
          

ZGVmIGRlc2NyaWJlX3BldChhbmltYWwsIG5hbWUpOgogICAgcHJpbnQoZiJ7bmFtZX0gaXMgYSB7YW5pbWFsfS4iKQpkZXNjcmliZV9wZXQoYW5pbWFsPSJkb2ciLCBuYW1lPSJCdWRkeSIp

Output:

Buddy is a dog.

What’s happening here?
Instead of relying on position (describe_pet("dog", "Buddy")), we clearly tell Python:

• animal = "dog"
• name = "Buddy"

This avoids mix-ups and makes the call self-documenting.

How Python Handles Keyword Arguments

When you call a function with keyword arguments:

• Python matches each key=value pair to the function’s parameter list.
• Parameters not explicitly passed with a keyword will either need to be supplied positionally or have a default value.

This flexibility means:

• You can mix positional and keyword arguments in the same call — but positional ones must come first.
• You can skip optional keyword arguments if they have default values.

🍕 Real-Life Analogy: Custom Pizza Order

Imagine calling a pizza place. You say: “Give me a pizza with mushrooms, jalapeños, and no cheese.”
If you don’t specify which is the topping and which is the base, the chef might get confused.

Now say: “base=thin crust, cheese=none, toppings=[mushrooms, jalapeños]”
Boom. No confusion. No surprise cheese.

That’s exactly what keyword arguments do: They make your intentions explicit, especially when functions have many, optional, or similar-looking parameters.

Quick Knowledge Check!

Why Use Keyword Arguments In Python?

Keyword arguments are not just a nice-to-have — they can dramatically improve how your functions are called, understood, and maintained. Here's why they matter:

1. Clarity and Self-Documentation

Function calls become more readable because the argument names tell you what each value is meant for. You don’t need to memorize parameter positions or re-read the function definition.

def create_user(name, age, role, is_active):
    …
# Compare these:
create_user("Alex", 30, "editor", True)                     # confusing
create_user(name="Alex", age=30, role="editor", is_active=True)  # clear

2. Safe Reordering and Partial Use

You can pass arguments out of order, or skip some altogether (if defaults are defined), as long as you use the parameter names. They are especially useful in large functions or dynamically generated inputs.

def send_email(to, subject, body="No content"):
    print(f"To: {to}\nSubject: {subject}\nBody: {body}")
send_email(subject="Meeting Reminder", to="team@example.com")

3. Fewer Bugs with Similar-Type Parameters

When you have multiple parameters of the same type, using keyword arguments ensures you don’t accidentally assign the wrong value to the wrong parameter.

def resize_image(width, height, keep_aspect):
    …
resize_image(1080, 720, True)                      # Could be wrong order!
resize_image(width=1080, height=720, keep_aspect=True)  # precise

4. Better Compatibility with Defaults

Functions with default arguments become more flexible when you pass only the ones you care about. You don’t have to pass all arguments, just the ones you want to override.

def connect(host, port=8080, use_ssl=True):
    …
connect(host="localhost", use_ssl=False)

5. Scales Better in API Design and Libraries

When you're writing functions others will use (e.g., in APIs or libraries), keyword arguments make your interface easier to use and more maintainable.

# From Python's built-in 'open' function:
open(file="example.txt", mode="r", encoding="utf-8")

Quick Knowledge Check!

Where To Use Keyword Arguments In Python

Now that you know why keyword arguments matter, let’s look at some of the most useful places to use them in real-world code.

These aren’t just theoretical– these are patterns you’ll see (and write) all the time.

1. Functions with Many Parameters

When a function has 3+ parameters, especially if some are optional, keyword arguments improve clarity.

Why keyword arguments?
They prevent errors and make the call readable without checking the function definition.

2. Working with Default Arguments

If you're only changing one or two default parameters, keyword arguments let you skip the rest.

Why keyword arguments? You don’t need to specify host or port unless you want to change them.

3. Calling Built-in or Third-Party Library Functions

Many Python library functions accept keyword arguments for customization.

Why keyword argument? You don’t need to remember argument order– just pass what you need.

4. Web Development / Form Data Handling

When handling user inputs or form fields, mapping them using keyword arguments makes your code clean and dynamic.

Why keyword arguments? This works well when the number of fields is dynamic or passed as a dictionary.

5. Class Constructors with Optional Features

Keyword arguments make constructors easier to manage when creating objects with multiple optional configurations.

Why keyword argument? Clean, flexible, and avoids constructor overload mess.

6. When Wrapping or Extending Functions

If you’re writing decorators or wrapper functions, keyword arguments let you pass through options cleanly.

Why keyword arguments? **kwargs ensures all named arguments are forwarded properly — we’ll dive into this more in the **kwargs section.

Summary Table

Arbitrary Arguments Vs. Keyword Arguments

In this section we will clear up a common confusion: What’s the actual difference between arbitrary arguments (like *args) and keyword arguments (like **kwargs)?

What do we mean by "arbitrary"?

"Arbitrary arguments" is a broad term that refers to arguments that aren't fixed in number.
This includes both:

• *args – arbitrary positional arguments
• **kwargs – arbitrary keyword arguments

So when people say arbitrary arguments, they often mean *args, but the term technically includes both.

*args vs **kwargs– The Real Difference

Code Comparison

            def demo_args(*args):
    print("args:", args)

def demo_kwargs(**kwargs):
    print("kwargs:", kwargs)

demo_args(1, 2, 3)
demo_kwargs(a=1, b=2, c=3)
          

ZGVmIGRlbW9fYXJncygqYXJncyk6CiAgICBwcmludCgiYXJnczoiLCBhcmdzKQoKZGVmIGRlbW9fa3dhcmdzKCoqa3dhcmdzKToKICAgIHByaW50KCJrd2FyZ3M6Iiwga3dhcmdzKQoKZGVtb19hcmdzKDEsIDIsIDMpCmRlbW9fa3dhcmdzKGE9MSwgYj0yLCBjPTMp

Output:

args: (1, 2, 3)
kwargs: {'a': 1, 'b': 2, 'c': 3}

Using Them Together

            def mixed_example(a, b, *args, **kwargs):
    print(f"a: {a}, b: {b}")
    print(f"args: {args}")
    print(f"kwargs: {kwargs}")

mixed_example(10, 20, 30, 40, name="Neo", role="One"
          

ZGVmIG1peGVkX2V4YW1wbGUoYSwgYiwgKmFyZ3MsICoqa3dhcmdzKToKICAgIHByaW50KGYiYToge2F9LCBiOiB7Yn0iKQogICAgcHJpbnQoZiJhcmdzOiB7YXJnc30iKQogICAgcHJpbnQoZiJrd2FyZ3M6IHtrd2FyZ3N9IikKCm1peGVkX2V4YW1wbGUoMTAsIDIwLCAzMCwgNDAsIG5hbWU9Ik5lbyIsIHJvbGU9Ik9uZSI=

Output:

a: 10, b: 20
args: (30, 40)
kwargs: {'name': 'Neo', 'role': 'One'}

This pattern gives you maximum flexibility– great for API design, wrappers, logging, and extensibility.

Quick Knowledge Check!

Conclusion

Keyword arguments in Python offer a simple yet powerful way to make your code more expressive, flexible, and bug-resistant. By letting you call functions with key=value pairs, they free you from relying on strict positional order, make function calls self-explanatory, and work beautifully with default parameters.

From reducing errors in large codebases to making external APIs easier to use, keyword arguments are a key part of writing clean, scalable Python code. Add to that the flexibility of **kwargs, and you’re now equipped to write functions that can adapt to nearly anything.

As you continue your Python journey, mastering when and how to use keyword arguments will make your code easier to understand — for both your future self and everyone else reading it.

Frequently Asked Questions 

Q1. Are keyword arguments mandatory in Python?

No, they’re optional. You can use positional arguments, keyword arguments, or a mix — as long as you follow the rule that positional arguments come first.

Q2. Can I use both positional and keyword arguments in one function call?

Yes! You can mix them, but positional arguments must come before keyword arguments in the function call.

func("hello", name="Python")  ✅
func(name="Python", "hello")  ❌

Q3. What happens if I pass the same argument as both positional and keyword?

Python will throw a TypeError saying the argument was given multiple times.

def greet(name):
    print(f"Hello, {name}!")
greet("Shivani", name="Shiv")  # ❌ TypeError

4. When should I use keyword arguments instead of positional ones?

Use keyword arguments when:

• The function has many parameters
• You’re working with optional/default values
• You want to make the call self-explanatory
• You want to avoid mix-ups between similar-looking parameters

5. What’s the difference between **kwargs and keyword arguments?

• Keyword arguments are named values passed in a function call (like name="John").
• **kwargs is a parameter that lets you accept an arbitrary number of keyword arguments in the function definition.

This compiles our discussion on keyword arguments in Python. Do check the following out:

• Python Variables | A Comprehensive Guide With Code Examples
• Python IDLE | The Ultimate Beginner's Guide With Images & Codes!
• Python Logical Operators, Short-Circuiting & More (With Examples)
• Python Modules | Definition, Usage, Lists & More (+Code Examples)
• Classes In Python | Objects, Creation, Working, & More (+Examples)