Is there a Python equivalent of the C# null-coalescing operator?

Strictly,

other = s if s is not None else "default value"

Otherwise, s = False will become "default value", which may not be what was intended.

If you want to make this shorter, try:

def notNone(s,d):
    if s is None:
        return d
    else:
        return s

other = notNone(s, "default value")

Note, though, that since that's a function, it won't short-circuit like the conditional operator would if the first value isn't None; instead, it will evaluate both arguments even through the second one doesn't end up being used. For example, if a is not None, notNone(a, get_some_value()) will still call get_some_value, but a if a is not None else get_some_value() won't (operators can short-circuit, and the conditional operator does).

Here's a function that will return the first argument that isn't None:

def coalesce(*arg):
  return reduce(lambda x, y: x if x is not None else y, arg)

# Prints "banana"
print coalesce(None, "banana", "phone", None)

reduce() might needlessly iterate over all the arguments even if the first argument is not None, so you can also use this version:

def coalesce(*arg):
  for el in arg:
    if el is not None:
      return el
  return None

In case you need to chain more than one null-conditional operation such as:

model?.data()?.first()

This is not a problem easily solved with or. It also cannot be solved with .get() which requires a dictionary type or similar (and cannot be nested anyway) or getattr() which will throw an exception when NoneType doesn't have the attribute.

The relevant PEP considering adding null-aware operators to the language is PEP 505 and the discussion relevant to the document is in the python-ideas thread.

I realize this is answered, but there is another option when you're dealing with dict-like objects.

If you have an object that might be:

{
   name: {
      first: "John",
      last: "Doe"
   }
}

You can use:

obj.get(property_name, value_if_null)

Like:

obj.get("name", {}).get("first", "Name is missing") 

By adding {} as the default value, if "name" is missing, an empty object is returned and passed through to the next get. This is similar to null-safe-navigation in C#, which would be like obj?.name?.first.

Addionally to @Bothwells answer (which I prefer) for single values, in order to null-checking assingment of function return values, you can use new walrus-operator (since python3.8):

def test():
    return

a = 2 if (x:= test()) is None else x

Thus, test function does not need to be evaluated two times (as in a = 2 if test() is None else test())

For anyone still in need of a null coalescing for functions in 2024:

def null_coalesce(*args):
    return getattr(args[0], args[1], None) if len(args) == 2 else null_coalesce(getattr(args[0], args[1], None), *args[2:])

worked for me. This variant works if you want to access a field that may or may not exist. E.g. for foo.bar._name_ you would execute null_coalesce(foo, 'bar', '__name__') and would either receive the name of the function or if this field does not exist, you would get None and NOT an AttributeError.

In addition to Juliano's answer about behavior of "or": it's "fast"

>>> 1 or 5/0
1

So sometimes it's might be a useful shortcut for things like

object = getCachedVersion() or getFromDB()

to take care of possible exceptions:

def default_val(expr, default=None):
    try:
        tmp = expr()
    except Exception:
        tmp = default
    return tmp

use it like that:

default_val(lambda: some['complex'].expression('with', 'possible')['exceptions'], '')

I had a similar issue, but none of the solution above were quite satisfactory for me. I did some tests, then a nice idea came to my mind ... and it works !

it is at the same time elegant and 'descriptive' enough according to Python standards I think. I'll let you the judge of it.

First the issue:

I have a class Completion which has either a reference to sequence_type1 or sequence_type2

I want to define a property such as this:

@property
def seq_pk(self):
    return self.sequence_type1.seq_pk if self.sequence_type1 else self.sequence_type2.seq_pk
    

That's not really nice looking, takes a lot of space ... and I will need to do the same for all the properties of Completion !

I cannot simply do

return self.sequence_type1.seq_pk or self.sequence_type2.seq_pk

because if self.sequence_type1 does not exist, an exception will be raised, instead of giving me self.sequence_type2.seq_pk

But what I discovered works nicely is the following:

return (self.sequence_type1 or self.sequence_type2).seq_pk

simple, descriptive, elegant I think

Rather than explain what the or operator does, and how it is not a useful null-coalescing operator, I propose a pragmatic coalesce function.

def coalesce(*args):
    '''
    Returns the first non-None argument,
    or None if all arguments are None.
    If an argument is a function,
    it is called and its result is used instead.
    '''
    for arg in args:
        if callable(arg):
            arg = arg()
        if arg is not None:
            return arg

Verify it works:

print(f'Should be None: { coalesce(None) }')
print(f'Should be 0: { coalesce(0) }')
print(f'Should be 1: { coalesce(None, 1) }')
print(f'Should be 0: { coalesce(0, 1) }')
print(f'Should be 1: { coalesce(None, lambda: None, 1) }')
print(f'Should be 1: { coalesce(None, lambda: 1) }')
print(f'Should be "": "{ coalesce("", 1) }"')
print(f'Should be False: { coalesce(False, 1) }')

To improve performance one would supply a lambda function instead of a constant when the value is expensive to compute, and that way the expense can be avoided if an earlier argument is not None at runtime.

Regarding answers by @Hugh Bothwell, @mortehu and @glglgl.

Setup Dataset for testing

import random

dataset = [random.randint(0,15) if random.random() > .6 else None for i in range(1000)]

Define implementations

def not_none(x, y=None):
    if x is None:
        return y
    return x

def coalesce1(*arg):
  return reduce(lambda x, y: x if x is not None else y, arg)

def coalesce2(*args):
    return next((i for i in args if i is not None), None)

Make test function

def test_func(dataset, func):
    default = 1
    for i in dataset:
        func(i, default)

Results on mac i7 @2.7Ghz using python 2.7

>>> %timeit test_func(dataset, not_none)
1000 loops, best of 3: 224 µs per loop

>>> %timeit test_func(dataset, coalesce1)
1000 loops, best of 3: 471 µs per loop

>>> %timeit test_func(dataset, coalesce2)
1000 loops, best of 3: 782 µs per loop

Clearly the not_none function answers the OP's question correctly and handles the "falsy" problem. It is also the fastest and easiest to read. If applying the logic in many places, it is clearly the best way to go.

If you have a problem where you want to find the 1st non-null value in a iterable, then @mortehu's response is the way to go. But it is a solution to a different problem than OP, although it can partially handle that case. It cannot take an iterable AND a default value. The last argument would be the default value returned, but then you wouldn't be passing in an iterable in that case as well as it isn't explicit that the last argument is a default to value.

You could then do below, but I'd still use not_null for the single value use case.

def coalesce(*args, **kwargs):
    return next((a for a in args if a is not None), kwargs.get('default'))

There's no ?? operator in Python but the usual approach is:

# Using 'or'
s = None
other = s or "default"

# Using conditional expression
other = s if s is not None else "default"

If you want a helper function similar to SQL’s NVL or COALESCE, you can use pynvl-lib (disclaimer: I’m the author):

from pynvl import nvl, coalesce

print(nvl(None, 5))      # 5

print(nvl("hello", 99))  # 'hello'

#Coalesce is there too:

port_address = None
ip_address = None
mac_address = "A1:B2:C3:D4:E5:F6"
print(coalesce(port_address, ip_address, mac_address)) # "A1:B2:C3:D4:E5:F6"