Python - Calling the Function with Arguments

Calling the Function with Arguments in Python

In Python, functions are reusable blocks of code that are called when we need to perform a specific task. Arguments are values passed to functions when calling them, and they enable the function to work on dynamic input. Mastering the various ways of calling functions with arguments is essential for writing efficient and maintainable Python code. This guide covers all aspects of calling functions with arguments in Python, including positional arguments, keyword arguments, default parameters, variable-length arguments, unpacking, type annotations, and best practices.

1. Introduction to Function Arguments

1.1 What Are Arguments?

Arguments are values passed to a function when it is called. These values are assigned to the function’s parameters and are used within the function body to perform operations or logic.

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

greet("Alice")

1.2 Purpose of Using Arguments

• To provide input data for the function
• To make the function dynamic and reusable
• To avoid hardcoding values inside the function

2. Types of Arguments in Python

Python supports multiple types of arguments that you can pass when calling a function:

• Positional Arguments
• Keyword Arguments
• Default Arguments
• Variable-Length Arguments (*args and **kwargs)

3. Calling Functions with Positional Arguments

3.1 What Are Positional Arguments?

These are the most common type of arguments. Their values are assigned to parameters based on their position in the function call.

def add(a, b):
    return a + b

print(add(5, 10))  # Output: 15

3.2 Characteristics

• Order matters
• Each parameter must receive a value

4. Calling Functions with Keyword Arguments

4.1 What Are Keyword Arguments?

Keyword arguments are passed by explicitly naming each parameter and assigning a value using the = operator.

def profile(name, age, city):
    print(f"{name}, {age}, lives in {city}")

profile(name="Bob", age=28, city="Delhi")

4.2 Advantages

• Order of arguments doesn’t matter
• Improves readability
• Useful with functions that take many parameters

4.3 Mixing Positional and Keyword Arguments

def profile(name, age, city):
    print(f"{name}, {age}, lives in {city}")

profile("Alice", age=30, city="Paris")

Note: Positional arguments must come before keyword arguments.

5. Calling Functions with Default Arguments

5.1 Using Default Values

When a function parameter has a default value, the caller can choose to omit that argument.

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

greet()            # Hello, Guest!
greet("John")      # Hello, John!

5.2 Best Practices with Default Arguments

• Place parameters with default values after parameters without default values
• Do not use mutable objects (e.g., lists) as default values

6. Variable-Length Arguments

6.1 Positional Variable-Length (*args)

Use *args  to pass a variable number of non-keyword arguments.

def total_sum(*args):
    print("Arguments received:", args)
    return sum(args)

print(total_sum(1, 2, 3, 4))  # 10

6.2 Keyword Variable-Length (**kwargs)

Use **kwargs to pass a variable number of keyword arguments.

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

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

6.3 Combining *args and **kwargs

def show_details(*args, **kwargs):
    print("Positional:", args)
    print("Keyword:", kwargs)

show_details(1, 2, name="Alice", age=30)

7. Argument Unpacking in Function Calls

7.1 Unpacking Tuples and Lists

def multiply(a, b):
    return a * b

nums = (3, 4)
print(multiply(*nums))  # Output: 12

7.2 Unpacking Dictionaries

def person_info(name, age, city):
    print(f"{name} is {age} years old from {city}")

data = {"name": "Charlie", "age": 35, "city": "London"}
person_info(**data)

8. Enforcing Argument Type (Positional-Only, Keyword-Only)

8.1 Positional-Only Arguments (Python 3.8+)

def divide(a, b, /):
    return a / b

print(divide(10, 2))
# divide(a=10, b=2)  # TypeError

8.2 Keyword-Only Arguments

def user_info(name, *, age, country):
    print(f"{name} is {age} and from {country}")

user_info("Eve", age=29, country="USA")

9. Type Hints for Function Arguments

9.1 Using Type Annotations

def greet(name: str, age: int) -> str:
    return f"{name} is {age} years old"

print(greet("Alice", 30))

9.2 Advantages of Type Hints

• Improves code readability
• Helps with static analysis tools (like mypy)
• Better autocompletion in IDEs

10. Real-World Use Cases

10.1 API Data Handler

def handle_request(endpoint, **params):
    print(f"Request to {endpoint}")
    for key, val in params.items():
        print(f"{key} = {val}")

handle_request("/users", id=101, name="Alice")

10.2 Flexible Logging Function

def log_event(event_name, *args, **kwargs):
    print(f"Event: {event_name}")
    for arg in args:
        print(f"- {arg}")
    for key, val in kwargs.items():
        print(f"{key}: {val}")

log_event("UserLogin", "Success", user="admin", time="10:30 AM")

11. Common Mistakes and Pitfalls

11.1 Incorrect Ordering of Arguments

Always follow this order when defining parameters:

def func(positional, /, positional_or_keyword, *, keyword_only):
    ...

11.2 Mutable Default Arguments

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

print(append_to_list(1))  # [1]
print(append_to_list(2))  # [1, 2] - problem!

Fix: Use None and initialize inside the function.

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

12. Best Practices

• Use keyword arguments when a function has many parameters
• Use *args and **kwargs only when necessary
• Avoid using mutable default values
• Use type hints for clarity and maintainability
• Always validate inputs if required

13. Summary

Calling functions with arguments is one of the most fundamental concepts in Python. Understanding the different types of arguments and how to use them properly can drastically improve the quality and flexibility of your code. You can pass data to functions in a variety of ways: using positional arguments, keyword arguments, default parameters, or even with *args and **kwargs for dynamic input handling. Python’s flexibility in calling functions makes it a powerful tool for building scalable and clean programs.

With this knowledge, you're now better equipped to:

• Write modular and reusable code
• Build functions that are flexible and easy to use
• Handle optional and variable input gracefully
• Apply type annotations for better maintainability

In real-world applications, mastering function arguments leads to better APIs, cleaner interfaces, and fewer bugs. Whether you’re building scripts, tools, or full-scale applications, understanding how to call functions with arguments is essential to becoming an effective Python programmer.