Python - Keyword Arguments

Hello, aspiring Python programmers! Today, we're going to dive into the wonderful world of keyword arguments. As your friendly neighborhood computer science teacher, I'm excited to guide you through this important concept. Trust me, once you master keyword arguments, you'll feel like you've unlocked a new superpower in Python!

What are Keyword Arguments?

Imagine you're ordering a pizza. You could just say "I want a pizza," but that's not very specific, is it? Instead, you might say, "I want a large pizza with extra cheese and pepperoni." In this case, you're specifying exactly what you want - that's the essence of keyword arguments in Python!

Keyword arguments (also known as named arguments) are a way to pass arguments to a function by explicitly stating the parameter name along with the value. This makes your code more readable and flexible.

Let's look at a simple example:

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

greet(name="Alice")
greet(name="Bob", greeting="Hi")

In this example, name and greeting are parameters of the greet function. When we call the function, we can specify which value goes with which parameter.

Output:

Hello, Alice!
Hi, Bob!

Notice how in the first call, we didn't specify a greeting, so it used the default value "Hello". In the second call, we provided both name and greeting.

Calling Functions with Keyword Arguments

Now that we understand the basics, let's explore different ways to use keyword arguments.

1. Mixing Positional and Keyword Arguments

You can mix positional and keyword arguments, but remember: positional arguments must come before keyword arguments.

def describe_pet(animal_type, name, age):
    print(f"I have a {animal_type} named {name}. It's {age} years old.")

describe_pet("cat", name="Whiskers", age=3)
describe_pet("dog", "Buddy", age=5)

Output:

I have a cat named Whiskers. It's 3 years old.
I have a dog named Buddy. It's 5 years old.

2. Default Values

Keyword arguments are especially useful when you have default values:

def make_smoothie(fruit="banana", liquid="milk", protein="whey"):
    return f"Your smoothie contains {fruit}, {liquid}, and {protein}."

print(make_smoothie())
print(make_smoothie(fruit="strawberry", protein="pea protein"))

Output:

Your smoothie contains banana, milk, and whey.
Your smoothie contains strawberry, milk, and pea protein.

This flexibility is like having a smoothie maker that knows your usual order but is happy to accommodate changes!

3. Arbitrary Keyword Arguments

Sometimes, you might not know in advance how many keyword arguments a function will receive. Python has got you covered with the **kwargs syntax:

def build_profile(**user_info):
    profile = {}
    for key, value in user_info.items():
        profile[key] = value
    return profile

user = build_profile(name="Alice", age=30, city="New York", hobby="painting")
print(user)

Output:

{'name': 'Alice', 'age': 30, 'city': 'New York', 'hobby': 'painting'}

This is like having a form where users can fill in as much or as little information as they want!

Order of Keyword Arguments

When it comes to the order of arguments in Python functions, there's a specific rule to follow. It's like arranging books on a shelf - there's a proper way to do it!

Here's the order you should follow:

1. Positional arguments
2. *args (arbitrary positional arguments)
3. Keyword arguments with default values
4. **kwargs (arbitrary keyword arguments)

Let's see this in action:

def complex_function(a, b, *args, option=True, **kwargs):
    print(f"a = {a}")
    print(f"b = {b}")
    print(f"args = {args}")
    print(f"option = {option}")
    print(f"kwargs = {kwargs}")

complex_function(1, 2, 3, 4, 5, option=False, x=10, y=20)

Output:

a = 1
b = 2
args = (3, 4, 5)
option = False
kwargs = {'x': 10, 'y': 20}

In this example, 1 and 2 are positional arguments, 3, 4, and 5 are collected in *args, option is a keyword argument with a default value, and x and y are collected in **kwargs.

Keyword Arguments: Best Practices

To wrap up our lesson, let's discuss some best practices when using keyword arguments:

1. Use keyword arguments for optional parameters.
2. Always provide default values for keyword arguments.
3. Use keyword arguments to make function calls more readable, especially when the function has many parameters.
4. When defining a function, put parameters with default values at the end.

Here's a table summarizing the different types of arguments we've discussed:

Argument Type	Description	Example
Positional	Passed based on their position	func(1, 2, 3)
Keyword	Passed with parameter names	func(a=1, b=2, c=3)
Default	Have a default value in function definition	def func(a=1):
Arbitrary Positional	Collects extra positional arguments	def func(*args):
Arbitrary Keyword	Collects extra keyword arguments	def func(**kwargs):

Remember, using keyword arguments effectively can make your code more readable, flexible, and less prone to errors. It's like giving clear, specific instructions - your future self (and other programmers) will thank you!

That's all for today's lesson on keyword arguments in Python. I hope you've enjoyed this journey as much as I've enjoyed guiding you through it. Keep practicing, stay curious, and happy coding!

Credits: Image by storyset