Python - Arguments in Functions

Python - Arguments in Functions

Introduction

In Python, functions allow developers to reuse code, maintain clarity, and organize large programs efficiently. Arguments are the means by which data is passed into functions, making them dynamic and flexible. Python supports a variety of argument types such as positional, keyword, default, variable-length (*args, **kwargs), and more.

Understanding Function Arguments

What is a Function Argument?

An argument is a value passed to a function when it is called. In the function definition, these values are received by parameters. While "arguments" refer to the values you supply, "parameters" are the variable names used in the function declaration to accept these values.

def greet(name): 
    print("Hello", name)

greet("Alice")  # "Alice" is the argument

Types of Function Arguments in Python

1. Positional Arguments

These are the most basic type of arguments. Values are assigned to parameters based on their position in the function call.

def add(a, b):
    print("Sum:", a + b)

add(5, 3)  # Output: Sum: 8

2. Keyword Arguments

With keyword arguments, you can explicitly specify which value should go to which parameter, making the function call more readable and reducing the chance of errors due to order mismatch.

def display_info(name, age):
    print("Name:", name)
    print("Age:", age)

display_info(age=30, name="Bob")

3. Default Arguments

Default arguments are used to provide default values to parameters. If the user does not provide a value for that parameter, the default value is used.

def greet(name, msg="Good Morning"):
    print("Hello", name + ", " + msg)

greet("Alice")                  # Uses default message
greet("Bob", "How are you?")    # Overrides default message

4. Variable-length Arguments

Python allows you to define functions that can accept an arbitrary number of arguments using *args for positional and **kwargs for keyword arguments.

*args (Non-keyword Variable Length Arguments)

These arguments are passed as a tuple to the function.

def sum_all(*numbers):
    total = 0
    for number in numbers:
        total += number
    print("Total:", total)

sum_all(1, 2, 3, 4)

**kwargs (Keyword Variable Length Arguments)

These arguments are passed as a dictionary to the function.

def print_info(**details):
    for key, value in details.items():
        print(key + ":", value)

print_info(name="Alice", age=25, city="New York")

Combining Different Types of Arguments

Python allows mixing different types of arguments, but there is a specific order that must be followed:

def example(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
    print(pos1, pos2, pos_or_kwd, kwd1, kwd2)

The general order is:

• Positional-only arguments
• Positional or keyword arguments
• Keyword-only arguments
• Variable-length (*args and **kwargs)

Function with All Types of Arguments

def demo(a, b=2, *args, **kwargs):
    print("a:", a)
    print("b:", b)
    print("*args:", args)
    print("**kwargs:", kwargs)

demo(1, 3, 5, 6, name="Alice", age=30)

Unpacking Arguments

Unpacking Positional Arguments using *

def multiply(x, y):
    return x * y

values = (3, 4)
print(multiply(*values))  # Equivalent to multiply(3, 4)

Unpacking Keyword Arguments using **

def introduce(name, age):
    print(f"My name is {name} and I'm {age} years old.")

info = {"name": "Tom", "age": 40}
introduce(**info)

Positional-Only and Keyword-Only Arguments (Python 3.8+)

Positional-Only Arguments (using /)

The slash `/` is used to indicate that certain parameters must be positional-only.

def f(a, b, /):
    print(a, b)

f(1, 2)       # Valid
f(a=1, b=2)   # Error: positional only

Keyword-Only Arguments (using *)

The asterisk `*` indicates that parameters following it must be specified using keywords.

def f(*, a, b):
    print(a, b)

f(a=1, b=2)   # Valid
f(1, 2)       # Error

Arguments with Mutable Default Values

Be careful when using mutable objects like lists or dictionaries as default argument values. They can lead to unexpected behavior due to their shared state across function calls.

def append_to_list(value, my_list=[]):
    my_list.append(value)
    return my_list

print(append_to_list(1))  # Output: [1]
print(append_to_list(2))  # Output: [1, 2] — reused list!

Correct Way

def append_to_list(value, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(value)
    return my_list

print(append_to_list(1))  # [1]
print(append_to_list(2))  # [2]

Using Arguments in Recursion

Functions with arguments are essential in recursion, allowing data to be passed into each recursive call.

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120

Lambda Functions with Arguments

Lambda (anonymous) functions also accept arguments.

square = lambda x: x ** 2
add = lambda a, b: a + b

print(square(4))   # 16
print(add(3, 5))   # 8

Arguments in Higher-Order Functions

Functions like map, filter, and reduce accept other functions as arguments, often with parameters themselves.

nums = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, nums))
print(squared)  # [1, 4, 9, 16]

Best Practices

• Always specify default values for optional parameters.
• Prefer keyword arguments for better readability.
• Use *args and **kwargs only when necessary.
• Be cautious with mutable default arguments.
• Maintain consistency and clarity in argument naming.

Real-World Example: Logging Function

def log(message, level="INFO", *args, **kwargs):
    print(f"[{level}] {message}")
    if args:
        print("ARGS:", args)
    if kwargs:
        print("KWARGS:", kwargs)

log("System failure", "ERROR", "disk", "memory", code=500)

Understanding arguments in functions is crucial for mastering Python. Whether it’s the basics like positional arguments or advanced features like unpacking and keyword-only parameters, knowing how and when to use them will make your code more efficient, readable, and professional.