1. You can use print() in expressions for debugging by leveraging its side effect while ensuring the expression evaluates to a useful value, such as using print(...) or value to both log and return a result; 2. In list comprehensions, embedding print() within a condition like x > 0 and print(f"Processing {x}") or True allows inspection of filtered values without breaking the comprehension; 3. In lambda functions, where statements are disallowed, lambda x: print(f"Input: {x}") or x * 2 enables logging because function calls are expressions; 4. With the walrus operator, combining assignment and print() directly is tricky due to None return, but using a helper like debug(value, label) that prints and returns the value safely enables non-disruptive inspection in expressions; the key is exploiting print()’s None with logical operators to maintain flow while gaining visibility during development.

You might never think to use print() in an expression — after all, it’s a function that outputs text and returns None. But despite its seemingly useless return value, there are a few practical (and at least one clever) ways to leverage print() inside expressions, especially during debugging or data exploration.

Let’s look at when and why you might actually want to use print() where you’d normally expect a value — not just for side effects, but as part of logic flow.

1. Debugging in List Comprehensions and Generators

List comprehensions are concise, but hard to debug with traditional print() calls because you can’t insert statements inside them. That’s where embedding print() in an expression comes in handy.

data = [1, -2, 3, -4, 5]
squares = [x**2 for x in data if x > 0]

Want to see which values pass the filter? Just insert print():

squares = [x**2 for x in data if x > 0 and print(f"Processing {x}") or True]

Wait — how does this work?

• print() returns None, which is falsy.
• So x > 0 and print(...) or True ensures the condition is always True after printing.
• The or True makes the filter pass regardless of print()’s return.

Yes, it’s a hack — but a quick one for debugging without breaking the comprehension.

?? Don’t leave this in production code. It’s purely for temporary inspection.

2. Logging Values in lambda Functions

lambda functions can only contain expressions, not statements — so you can’t write:

lambda x: print(x); x * 2  # SyntaxError

But you can sneak in print() because it’s a function call (an expression):

debug_double = lambda x: print(f"Input: {x}") or x * 2

Again, print() returns None, so None or x * 2 evaluates to x * 2. The side effect is logging.

Useful for:

• Debugging map() or filter() pipelines
• Inspecting intermediate values in functional chains

Example:

list(map(lambda x: print(f"Mapping {x}") or x ** 2, [1, 2, 3]))
# Output:
# Mapping 1
# Mapping 2
# Mapping 3
# Result: [1, 4, 9]

3. Default Arguments for Debugging

Sometimes you want to know when a default argument is used. You can use print() in the default expression:

def greet(name, debug=print("Using default name"))):
    if not name:
        name = "Anonymous"
    return f"Hello, {name}"

Now, every time the function is defined (or the default is evaluated), it prints. Note: this only prints once at definition time, not call time — so it’s limited.

A better version using None and checking inside:

def greet(name=None):
    if name is None:
        name = "Anonymous"
        print("Warning: Using default name")
    return f"Hello, {name}"

Still, the expression-based version shows how print() can be embedded where only expressions are allowed.

4. Walrus Operator Print: Inspect Without Breaking Flow

With the walrus operator (:=), you can assign and print in one expression — great for debugging complex expressions:

if (response := input("Enter 'quit' to exit: ")) == 'quit':
    print("Goodbye!")

Add logging without extra lines:

if (response := print(f"DEBUG: Input was {input('Enter: ')}") or input('Enter: ')) == 'quit':
    # Wait — no, this would ask twice!
    pass

Oops — that’s dangerous. Instead, capture first, then print:

while (user_input := input("Enter: ")) != "quit":
    user_input = print(f"Got: {user_input}") or user_input  # Nope, now it's None!

Also broken — because print() returns None.

Correct way:

while True:
    if (user_input := input("Enter: ")) == "quit":
        break
    _ = print(f"Processing: {user_input}")  # Just for debug
    # Continue processing

Or better — wrap in a helper:

def debug(value, label="Value"):
    print(f"{label}: {value}")
    return value

# Now use safely in expressions
data = [debug(x**2, "Squared") for x in range(5)]

This is cleaner than relying on print()'s None — but shows why print() alone is risky.

Bottom Line

print() returns None — always. But in contexts where you need an expression (comprehensions, lambdas, defaults), you can exploit that fact:

• Use print(...) or value to log and return value
• Embed in lambda for quick debug output
• Combine with or/and to control flow without altering logic
• Prefer wrapper functions for clarity

It’s not about clean design — it’s about practical, temporary tools when you’re exploring code.

Basically: yes, print() returns None, but sometimes None is enough — as long as something gets printed.

The above is the detailed content of The Forgotten Return Value: Practical Use Cases for `print` in Expressions. For more information, please follow other related articles on the PHP Chinese website!