Introduction

The most idiomatic way to convert None to an empty string depends on what you want to preserve. If you want only None to become "", use an explicit is None check. If you want every falsy value to collapse to "", then value or "" is shorter. The important part is not the syntax length; it is whether the semantics match your data.

The Explicit And Safest Form

If the requirement is literally “convert None to an empty string,” the clearest answer is:

1def none_to_empty(value):
2    return "" if value is None else value
3
4print(none_to_empty(None))
5print(none_to_empty("hello"))
6print(none_to_empty(0))

This preserves values like 0, False, and empty lists instead of accidentally converting them.

That is why many Python programmers prefer the explicit form when correctness matters more than brevity.

The Short Form: value or ""

You will also see this pattern:

1def falsy_to_empty(value):
2    return value or ""
3
4print(falsy_to_empty(None))
5print(falsy_to_empty("hello"))
6print(falsy_to_empty(0))

This is concise, but it does more than convert None. It also turns these into "":

• '0'
• 'False'
• '[]'
• '""'

So it is only appropriate when all falsy values should be treated as empty output.

Why str(value) Is Usually Wrong Here

A tempting mistake is:

value = None
print(str(value))

That produces the literal string "None", which is usually not what people want in UI output, CSV export, or templating. Converting None to text is not the same as replacing missing data with an empty string.

Choose Based On Output Semantics

There are really two common requirements.

Requirement A: only missing values should become "".

text = "" if value is None else value

Requirement B: anything falsy should become "".

text = value or ""

These are not interchangeable. The second one is shorter, but the first one is usually more precise.

A Common Formatting Example

Suppose you are building display text from partially missing user data.

1def display_name(first_name):
2    return "" if first_name is None else first_name
3
4print(display_name(None))
5print(display_name("Ana"))

If later the input might be 0 or False, the explicit form remains correct. That is one reason it ages better in evolving codebases.

Working With Dictionaries Or External Data

When data comes from APIs or parsed payloads, None can be semantically different from other falsy values.

1row = {"nickname": None, "score": 0}
2
3nickname = "" if row["nickname"] is None else row["nickname"]
4score = row["score"]
5
6print(nickname)
7print(score)

Using or "" carelessly here could erase a meaningful zero.

The Idiomatic Rule Of Thumb

A good Python rule is:

• use value or "" when you intentionally want any falsy value to become empty,
• use "" if value is None else value when you mean only None.

Idiomatic Python is not just short Python. It is code whose behavior is obvious and correct for the data model.

Common Pitfalls

• Using value or "" when 0 or False are valid values that must be preserved.
• Using str(value) and getting the literal text "None".
• Choosing the shorter expression without checking the actual semantics of the input data.
• Forgetting that empty strings are already falsy and will remain unchanged with or "".
• Hiding missing-data logic in helpers that do more than their names suggest.

Summary

• If only None should become empty, use "" if value is None else value.
• If every falsy value should become empty, value or "" is concise and fine.
• 'str(None) gives "None", not an empty string.'
• The idiomatic choice depends on the meaning of falsy values in your data.
• Precision is usually better than cleverness for small data-cleaning transforms.