SoFunction
Updated on 2025-04-14

The difference between Python position parameters and keyword parameters

In the use of Python functions, the function's parameters are a means to let the caller pass information to the function. Functions can receive externally provided values ​​through parameters, thereby performing specific operations based on these values. In this section, we will focus on the two parameter types: positional parameters and keyword parameters. They are the most basic parameter forms when defining and calling functions.

1. Position parameters

Positional Arguments are parameters passed to the function in sequence in the order of parameters when calling a function. The values ​​of these parameters must be passed strictly in the order in the function definition, and the number of position parameters needs to be consistent with the number of parameters when the function definition is defined.

Define and use position parameters

Let’s first look at a simple example, defining a function that calculates the sum of two numbers.add()：

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

result = add(5, 3)
print(result)  # Output: 8

In the above code, the functionadd(a, b)Two positional parameters are definedaandb, when we calladd(5, 3)When Python will select the first parameter5Assign toa, add the second parameter3Assign tob, and calculate their sums. The order of parameters passed when a function is called must be consistent with the order defined by the function, which is the characteristic of positional parameters.

Example: Calculate the area of ​​a rectangle

Here is an example of calculating the area of ​​a rectangle, using positional parameters:

def calculate_area(length, width):
    return length * width

area = calculate_area(10, 5)
print(f"The area of ​​the rectangle is：{area}")  # Output: The area of ​​the rectangle is: 50

In this example, the functioncalculate_area(length, width)Accept two parameterslengthandwidth, when we call it, we passcalculate_area(10, 5)Two positional parameters were passed10and5, respectively represent the length and width of the rectangle.

Characteristics of positional parameters

The main features of positional parameters are:

For example, if a function that requires two parameters is defined and a parameter is passed in, Python will report an error:

result = add(5)  # Error: TypeError: add() missing 1 required positional argument: 'b'
  • The order of parameters is very important and must be passed in the order they are defined.
  • The number of positional parameters passed in when a function is called must be consistent with the number in the function definition, otherwise an error will occur.

2. Keyword parameters

Keyword Arguments are used to avoid positional limitations when calling a function by specifying the parameter name as parameter assignment. The use of this parameter makes function calls clearer and more intuitive, especially when there are many function parameters, the use of keyword parameters helps to improve the readability of the code.

Define and use keyword parameters

Keyword parameters can make it possible for the function to be called without strictly following the defined parameter order, but directly assigning values ​​through the given parameter name. For example:

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

result = add(a=5, b=3)
print(result)  # Output: 8

In the above code, we used keyword parameters when calling the function.a=5andb=3, so that the order of calling functions is no longer important and the code is more readable.

Example: Calculate the volume of a cylinder

Here is an example of calculating the volume of a cylinder using keyword parameters:

def calculate_volume(radius, height):
    pi = 3.14159
    return pi * (radius ** 2) * height

volume = calculate_volume(height=10, radius=3)
print(f"The volume of the cylinder is：{volume:.2f}")  # Output: The volume of the cylinder is: 282.74

In this example, we pass keyword parametersheight=10andradius=3Call the functioncalculate_volume(). Because keyword parameters are used, the order of parameters when called can be different from the order in the function definition, which provides programmers with greater flexibility.

Characteristics of keyword parameters

The main features of keyword parameters are:

Example of keyword parameters:

def display_user_info(name, age, gender):
    print(f"Name：{name}, age：{age}, gender：{gender}")

# Call with keyword parametersdisplay_user_info(age=25, name="Zhang San", gender="male")

In the above code, we used keyword parametersage=25, name="Zhang San", gender="Male", so that the order of parameters when calling a function can be flexibly adjusted. Keyword parameters make the code more readable and can also avoid errors caused by errors in the order of parameters.

  • Assign values ​​can be specified by specifying parameter names, so the order of parameters when called can be different from the order of definition.
  • Using keyword parameters can improve the readability of the code, especially when there are many function parameters or the parameter names have specific meanings.

3. Mix positional parameters and keyword parameters

When calling a function, both positional parameters and keyword parameters can be used. But it should be noted that the positional parameters must be before the keyword parameters, otherwise a syntax error will be raised. Let’s take a look at an example:

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

# Mix positional parameters and keyword parametersgreet("Little Red", message="Hello")  # Output: Hello, Xiaohong!
# The following call will cause an error# greet(name="Xiaohong", "Hello") # Error: SyntaxError: positional argument follows keyword argument

In the above code,greet("Xiaohong", message="Hello")It is a legal call, and if you use the keyword argument first and then pass the position argument, an error will be thrown. Therefore, when mixing positional parameters and keyword parameters, it is necessary to ensure that the positional parameters are in the forefront.

4. Suggestions on using positional parameters and keyword parameters

  • When there are fewer function parameters and the parameters have clear meanings, it is more concise to use positional parameters.
  • When there are many function parameters or the parameter names have specific meanings, using keyword parameters can improve the readability of the code and avoid confusion.
  • When using mixed use, be sure to follow the rule of "positional parameters are in front and keyword parameters are in back" to ensure that the code can be executed correctly.

5. Example: Application in Personal Financial Tools

In the Personal Financial Management Tools project, we can flexibly use positional parameters and keyword parameters to improve the simplicity and readability of the code. For example, in functions that record income and expenses, keyword parameters can be used to improve the readability of the code so that each incoming parameter has a clear meaning.

def add_transaction(amount, transaction_type, description):
    print(f"type：{transaction_type}, Amount：{amount}Yuan, describe：{description}")

# Use position parametersadd_transaction(500, "income", "salary")

# Use keyword parametersadd_transaction(amount=200, transaction_type="expenditure", description="Shopping")

Through the above explanation, we can see the different characteristics and usage scenarios of positional parameters and keyword parameters in function calls. In the subsequent learning, we will further explore the use of default parameters and variable parameters to help everyone more fully understand the definition and calling skills of functions.

This is the end of this article about the difference between Python position parameters and keyword parameters. For more related Python position parameters and keyword parameters, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!