Default Parameter Values
In Python, you can assign default values to function parameters. This feature allows arguments to be optional when calling a function. If an argument is not provided during the function call, the default value is used instead.
Defining Default Values
To assign a default value to a parameter, you specify the value in the function definition. The syntax involves using the assignment operator (=) in the function signature.
Syntax:
def function_name(param1=default_value1, param2=default_value2): # Function body
Example:
def greet(name="stranger", greeting="Hello"):
print(f"{greeting}, {name}!")
# Function calls with and without arguments
greet() # Uses default values: "Hello, stranger!"
greet("Alice") # Uses default value for greeting: "Hello, Alice!"
greet("Bob", "Hi") # Uses provided values: "Hi, Bob!"
In this example:
- name has a default value of “stranger”.
- greeting has a default value of “Hello”.
Order of Parameters with Default Values
Parameters with default values must always come after parameters without default values in the function signature. This ensures that positional arguments are correctly assigned to parameters without default values.
Syntax:
def function_name(param1, param2=default_value2): # Function body
Example:
def configure(param1, option1=True, option2="default"):
print(f"Parameter 1: {param1}")
print(f"Option 1: {option1}")
print(f"Option 2: {option2}")
# Function calls
configure("test") # Uses default values for option1 and option2
configure("test", False) # Changes value of option1, uses default value for option2
configure("test", False, "custom") # Changes both options
In this example:
- param1 has no default value and must be provided.
- option1 and option2 have default values.
Modifications to Default Values
Default values are evaluated only once when the function is defined, not each time the function is called. This means that if the default value is a mutable object (such as a list or a dictionary), modifications to this object will affect all future calls that use the default value.
Example:
def add_element(element, my_list=[]): my_list.append(element) return my_list # Function calls print(add_element(1)) # Output: [1] print(add_element(2)) # Output: [1, 2]
In this example, the default list my_list is modified with each function call. To avoid this issue, use None as a default value and create a new mutable object inside the function if needed.
Fix:
def add_element(element, my_list=None): if my_list is None: my_list = [] my_list.append(element) return my_list # Function calls print(add_element(1)) # Output: [1] print(add_element(2)) # Output: [2]
Here, each call creates a new list if my_list is None.
Default Values for Named Arguments
Default values can also be specified for named arguments when using arbitrary arguments (*args and **kwargs). Parameters with default values should be specified after positional arguments and before arbitrary keyword arguments.
Example:
def display_message(message, *, punctuation=".", uppercase=False):
message = message.upper() if uppercase else message
print(f"{message}{punctuation}")
# Function calls
display_message("Hello") # Uses default values: "Hello."
display_message("Hello", punctuation="!") # Changes punctuation: "Hello!"
display_message("Hello", uppercase=True) # Changes case: "HELLO."
Importance of Default Values
Default values are useful for:
- Simplifying Function Calls: Users of the function can omit arguments to use default values.
- Facilitating Configuration: Providing a simple way to specify common configurations while allowing customization.
- Handling Optional Parameters: Managing parameters that are not always required.
Summary
Default parameter values in Python enable functions to have optional arguments. Understanding and using default values appropriately can enhance the flexibility and usability of your functions. Here are the key points:
- Defining Default Values: Use = to set a default value in the function signature.
- Order: Default value parameters must follow parameters without default values.
- Mutable Defaults: Be cautious with mutable default values like lists or dictionaries. Use None as a default and create a new object within the function if necessary.
- Named Arguments: Default values can also be applied to named arguments.