The World of Python Programming

Python Arguments: Positional, Keyword, *args & **kwargs

Functions & Classes
目次

1. What Are Arguments in Python?

In Python, arguments are the means by which functions and methods receive data from outside and perform specific operations. By passing arguments to a function, flexible data processing becomes possible, improving the reusability and extensibility of the program. This article will explain Python arguments step by step, from basics to advanced usage.

Basic Roles of Functions and Arguments

A function is a collection of commands that perform a specific task. Arguments are the input data passed to a function, used as follows.
def greet(name):
    print(f"Hello, {name}!")
In this example, by passing any name to the argument name, you can display a personalized message.
greet("Sagawa")  # Output: Hello, Sagawa!

2. Basics of Arguments in Python

Next, we’ll look at how to use arguments in Python from the perspectives of positional arguments, keyword arguments, and default arguments.

Positional Arguments and Their Importance

Positional arguments are passed to the function’s parameters in the order they are specified when the function is called.
def add(a, b):
    return a + b
result = add(5, 3)  # Result: 8

Using Keyword Arguments

With keyword arguments, you can explicitly pass values to a function without worrying about the order of arguments.
def introduce(name, age):
    print(f"I am {name}. I am {age} years old.")
introduce(age=25, name="Sagawa")  # Output: I am Sagawa. I am 25 years old.

Using Default Arguments

By setting default arguments, you can use a default value when an argument is omitted.
def greet(name="Guest"):
    print(f"Hello, {name}!")
greet()  # Output: Hello, Guest!

Argument Order

When using positional and keyword arguments together, you must specify positional arguments first and keyword arguments afterward. Getting the order wrong will result in an error.
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール

3. Python’s variable-length arguments (*args and **kwargs)

How to use *args

*args is used to pass an arbitrary number of positional arguments to a function. This allows you to make the function more generic.
def print_numbers(*args):
    for number in args:
        print(number)
print_numbers(1, 2, 3)

How to use **kwargs

By using **kwargs, you can receive arbitrary keyword arguments as a dictionary.
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
print_info(name="Sagawa", age=30, job="writer")

Combining *args and **kwargs

By combining *args and **kwargs, you can create flexible functions that accept both positional and keyword arguments.
def process_data(*args, **kwargs):
    total = sum(args)
    print(f"Total: {total}")
    for key, value in kwargs.items():
        print(f"{key}: {value}")
process_data(1, 2, 3, name="Sagawa", age=30)

4. Argument Applications and Use Cases

Practical Application Example: API Parameter Handling

API calls require handling dynamic parameters. By using *args and **kwargs, you can flexibly manage multiple parameters.
def api_call(endpoint, **params):
    print(f"API endpoint: {endpoint}")
    for key, value in params.items():
        print(f"{key}: {value}")
api_call("/user", id=123, action="view")

Application to Large-Scale Data Processing

Even in functions that process massive amounts of data, you can efficiently handle variable-length arguments using *args.
侍エンジニア塾

5. Argument Error Handling and Validation

Error Handling for Argument Count

If the function receives fewer arguments than expected, handling errors can prevent the program from crashing.
def add_numbers(*args):
    if len(args) < 2:
        raise ValueError("At least two arguments are required")
    return sum(args[:2])

Type Validation

Checking the argument types can prevent unexpected errors.
def multiply(a, b):
    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
        raise TypeError("Arguments must be numbers")
    return a * b

Error handling using try-except

Using the try-except construct allows you to catch errors and handle them appropriately.
def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        return "Cannot divide by zero"
    except TypeError:
        return "Please enter numeric values"
    return result

6. Summary

Through this article, we covered a wide range from the basics to advanced topics of Python arguments. In particular, we want to emphasize flexible function definitions using *args and **kwargs, as well as the importance of error handling and validation.

Key Points:

  • Basics of positional arguments, keyword arguments, and default arguments
  • Flexible function definitions using *args and **kwargs
  • Importance of error handling and validation for arguments
Based on this knowledge, you will be able to create flexible and robust Python code that is useful in real-world work.
侍エンジニア塾