Glossary

6.6 Keyword arguments

2 min read•june 24, 2024

Python functions offer versatile ways to pass arguments. rely on order, while use parameter names. This flexibility allows for clearer, more readable code and easier function calls with multiple parameters.

Default parameter values provide convenience and flexibility in function calls. They allow and can be overridden when needed. Keyword arguments enhance readability, flexibility, and maintainability, making complex function calls more manageable and intuitive.

Function Arguments in Python

Positional vs keyword arguments

Top images from around the web for Positional vs keyword arguments

  • 3 features released in Python 3.1 you should use in 2021 | Opensource.com View original

    Is this image relevant?

  • GMD - fv3gfs-wrapper: a Python wrapper of the FV3GFS atmospheric model View original

    Is this image relevant?

  • 3 features released in Python 3.1 you should use in 2021 | Opensource.com View original

    Is this image relevant?

1 of 3

Top images from around the web for Positional vs keyword arguments

  • 3 features released in Python 3.1 you should use in 2021 | Opensource.com View original

    Is this image relevant?

  • GMD - fv3gfs-wrapper: a Python wrapper of the FV3GFS atmospheric model View original

    Is this image relevant?

  • 3 features released in Python 3.1 you should use in 2021 | Opensource.com View original

    Is this image relevant?

1 of 3
  • passed to a function based on their position or order
    • Order of arguments in must match order of parameters in ()
    • def greet(name, age):
      calling 
      greet("Alice", 25)
      assigns 
      "Alice"
      to 
      name
      and 
      25
      to 
      age
  • Keyword arguments passed to a function using parameter names along with corresponding values
    • Order of arguments doesn't matter as long as parameter names are specified
    • def greet(name, age):
      calling 
      greet(age=25, name="Alice")
      achieves same result as 
      greet("Alice", 25)
  • Mixing positional and keyword arguments allowed
    • Positional arguments must come before keyword arguments
    • greet("Alice", age=25)
      is valid, but 
      greet(name="Alice", 25)
      is not

Default parameter values

  • Specify default value for a parameter in function definition
    • If argument not provided for that parameter when function is called, default value is used
    • def greet(name, age=18):
      if 
      age
      not provided when calling 
      greet()
      , it defaults to 
      18
  • Calling functions with default parameter values
    • Omit arguments for parameters with (
      greet("Alice")
      uses default value of 
      18
      for 
      age
      )
    • Override default values by providing arguments (
      greet("Alice", 25)
      overrides default 
      age
      with 
      25
      )
    • Use keyword arguments to specify only parameters you want to override (
      greet("Alice", age=25)
      overrides default 
      age
      while keeping positional argument for 
      name
      )
  • Default values create optional parameters in the function definition

Benefits of keyword arguments

  • Improved readability
    • Make purpose of each argument clear in function call
    • draw_rectangle(width=10, height=5)
      more readable than 
      draw_rectangle(10, 5)
    • Especially useful when function has many parameters or purpose of each argument not immediately clear
  • Flexibility in argument order
    • Allow specifying arguments in any order
    • draw_rectangle(height=5, width=10)
      equivalent to 
      draw_rectangle(width=10, height=5)
    • Helpful when function has many optional parameters
  • Selective argument overriding
    • Override only specific default values
    • def create_user(name, age=18, email=None):
      can call 
      create_user("Alice", email="alice@example.com")
      to override only 
      email
      parameter while keeping default 
      age
  • Improved maintainability
    • If function definition changes to add, remove, or reorder parameters, existing function calls with keyword arguments may not need to be updated
    • Makes code more maintainable and less prone to errors when refactoring

Function Definition and Calling

  • Function definition establishes the parameters and their order
  • Function call involves to match the defined parameters
  • The relationship between definition and call determines how arguments are interpreted

Key Terms to Review (16)

**kwargs: **kwargs is a special syntax in Python used in function definitions to allow the passing of a variable number of keyword arguments. This enables functions to accept any number of additional arguments without requiring a specific parameter for each one, making code more flexible and easier to manage. When using **kwargs, the additional arguments are captured as a dictionary within the function, where the keys are the argument names and the values are the corresponding values passed in.
Arbitrary Arguments: Arbitrary arguments refer to the ability to pass an unspecified number of arguments to a function in Python. This feature allows for flexibility and dynamic function calls, where the number of arguments can vary based on the specific use case.
Argument Passing: Argument passing refers to the mechanism in programming where data is transferred from one part of a program, such as a function or method, to another. It allows the receiving entity to access and manipulate the passed data as part of its execution.
Default Values: Default values refer to the predetermined values that are assigned to parameters or variables when they are not explicitly provided. These default values serve as fallback options, ensuring that the code can still function even when certain inputs are missing.
Dict(): dict() is a built-in function in Python that creates a new dictionary object. Dictionaries are data structures that store key-value pairs, allowing for efficient storage and retrieval of data.
Dictionary: A dictionary in Python is a collection of key-value pairs where each key is unique. It allows for efficient data retrieval based on the keys.
Dictionary: A dictionary in Python is an unordered collection of key-value pairs, where each key is unique and is associated with a corresponding value. Dictionaries provide a flexible and efficient way to store and retrieve data, making them a fundamental data structure in the language.
Flexible Function Design: Flexible function design refers to the ability to create functions in programming that can adapt to different input parameters and scenarios, allowing for more versatile and reusable code. This concept is particularly important in the context of keyword arguments, which enable functions to accept a variable number of arguments and handle them dynamically.
Function Call: A function call is an expression that executes a named function, passing any required arguments to it. It allows a programmer to invoke a specific piece of code to perform a desired task or operation.
Function Definition: A function definition is the process of creating a named block of code that performs a specific task or operation. It allows programmers to encapsulate and reuse logic, improving code organization and readability.
Keyword Arguments: Keyword arguments are a way of passing arguments to a function in Python where the arguments are identified by the parameter name rather than their position in the function call. This allows for more flexible and readable function calls.
Optional Parameters: Optional parameters are function parameters that are not required to be provided when the function is called. They allow for more flexible and versatile function usage by enabling the caller to decide which parameters to include or exclude based on their specific needs.
Parameter Order: Parameter order refers to the sequence in which arguments are passed to a function or method when it is called. The order of the parameters is crucial, as it determines how the function will interpret and use the provided values.
Positional arguments: Positional arguments are arguments that are passed to a function in a specific order. The position of each argument determines which parameter it corresponds to.
Positional Arguments: Positional arguments refer to the order in which arguments are passed to a function in programming. The position of the arguments determines how they are interpreted and mapped to the corresponding parameters in the function definition.
Unpacking: Unpacking is the process of extracting individual elements from a collection, such as a tuple or a dictionary, and assigning them to separate variables. It allows for efficient and concise handling of data structures in Python.
© 2024 Fiveable Inc. All rights reserved.
AP® and SAT® are trademarks registered by the College Board, which is not affiliated with, and does not endorse this website.
Back
Practice QuizGlossary
Practice QuizGlossary
Next guide