Published on

Python Walrus Operator: An Introduction to the Assignment Expression in Python

  • avatar
    Josh Di Mella
  1. What is the Walrus Operator?
  2. Benefits and Usage of the Walrus Operator
  3. Benefits of the Walrus Operator
  4. Caveats
  5. Conclusion

As a Python developer, you are always looking for ways to write more concise and expressive code. One of the exciting features introduced in Python 3.8 is the Walrus Operator, also known as the Assignment Expression. In this blog post, we'll explore the walrus operator, its usage, benefits, drawbacks, and best practices for using assignment expressions in your Python code.

What is the Walrus Operator?

The walrus operator (:=) is a new syntax introduced in Python 3.8 through PEP 572 that allows you to assign a value to a variable as part of an expression. The operator gets its name from the eyes and tusks of a walrus, resembling the shape of :=.

Before the introduction of the walrus operator, you would need to assign a value to a variable before using it in an expression. With the walrus operator, you can perform the assignment and expression evaluation in a single step. This simplifies your code and makes it more concise and readable.

Benefits and Usage of the Walrus Operator

The walrus operator offers several benefits and can be used in various scenarios to improve code clarity and efficiency.

Examples of How to Use the Walrus Operator

The walrus operator can be used in different contexts, such as loops, conditional statements, and dictionary construction. Here are a few examples:

In a Loop:

# Read lines until an empty line is encountered
lines = []
while line := input("Enter a line (empty to exit): "):

In this example, the walrus operator is used to simultaneously read a line from the user and check if it's empty. The loop continues until the user enters an empty line, and each non-empty line is added to the lines list.

In a Conditional Statement:

# Check if a string exceeds a maximum length
max_length = 10
string = "Hello, world!"
if (length := len(string)) > max_length:
    print(f"The string exceeds the maximum length by {length - max_length} characters.")

In this case, the walrus operator is used to compute the length of the string and store it in the length variable. The length is then compared to max_length to determine if it exceeds the limit. If it does, a message is printed.

Lists and Dictionaries:

numbers = [6, 4, 8, 9, 3, 1]
data = {
    "sum": (num_sum := sum(numbers)),
    "length": (num_length := len(numbers)),
    "mean": num_sum / num_length

This section demonstrates the utilization of the walrus operator to efficiently compute statistical measures for a list of numbers and construct a dictionary. By employing the walrus operator, the code succinctly assigns the sum and length of the numbers list to variables num_sum and num_length respectively, while simultaneously creating the corresponding key-value pairs in the data dictionary. This concise approach simplifies the code structure, enhances readability, and eliminates the need for separate variable assignments.

Benefits of the Walrus Operator

The walrus operator provides several benefits:

  1. Concise and Readable Code: With the walrus operator, you can perform assignments within expressions, reducing the need for separate lines of code. This results in more concise and readable code, especially in scenarios where you need to use a variable immediately after assigning a value to it.

  2. Improved Performance: By combining assignment and expression evaluation, you avoid redundant computations. This can be particularly useful when working with expensive function calls or complex expressions.


Despite the value provided by the walrus operator, it is important to carefully consider its usage due to a factors like Python version compatibility and support for type hints.

Python version Compatibility

The walrus operator was introduced in Python 3.8. If you are working on a project that needs to support earlier versions of Python, it's crucial to consider compatibility and provide fallback solutions when necessary.

Type Hints

When using the walrus operator, the assigned value is determined dynamically at runtime, making it challenging to provide type hints directly for the assigned value. The walrus operator is primarily designed to improve code readability and simplify expressions by allowing variable assignment within an expression itself.

However, it's worth noting that you can still use type hints for the variables that are assigned using the walrus operator. For example, you can annotate the variable before the assignment statement, and the type hint will be applicable to the variable:

result: int
if (result := calculate_result()) > 0:
    print("Positive result:", result)
    print("Non-positive result:", result)

In the above example, the type hint int is provided for the variable result before the assignment statement using the walrus operator. Although the walrus operator itself doesn't directly support type hints, you can apply type hints to variables in the surrounding context.


The walrus operator, or assignment expression, introduced in Python 3.8, provides a powerful and concise way to assign values to variables as part of an expression. By using the walrus operator, you can simplify your code, improve its readability, and eliminate redundant computations.

Python's walrus operator offers a valuable tool for streamlining your code and making it more expressive. By using it judiciously and in alignment with best practices, you can take advantage of its benefits and enhance your Python programming experience.

If you have any questions or would like to discuss this topic further, feel free to connect with me on LinkedIn. I would be happy to hear your thoughts and continue the conversation! 😊