I have a function that either returns a tuple or None. How is the Caller supposed to handle that condition?
def nontest():
return None
x,y = nontest()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not iterable
EAFP:
try:
x,y = nontest()
except TypeError:
# do the None-thing here or pass
or without try-except:
res = nontest()
if res is None:
....
else:
x, y = res
x, *y = nontest(), then if y is empty do the None-thing, otherwise do y = y[0], which I think isn't as clean as either of the two options. But, more importantly, x, *y = nontest() will still fail on None; you'd have to change nontest to return None,)` instead. At which point you might as well just return None, None and then you don't need extended unpacking.How about:
x,y = nontest() or (None,None)
If nontest returns a two-item tuple like it should, then x and y are assigned to the items in the tuple. Otherwise, x and y are each assigned to none. Downside to this is that you can't run special code if nontest comes back empty (the above answers can help you if that is your goal). Upside is that it is clean and easy to read/maintain.
If you can change the function itself, it's probably a better idea to make it raise a relevant exception instead of returning None to signal an error condition. The caller should then just try/except that.
If the None isn't signalling an error condition, you'll want to rethink your semantics altogether.
(None, None) or some other value that is a 2-tuple, instead of None.try/except, not try/catch.
except. So where a Java/C++ user would say "try it, and catch the error", a Python user has to say "try it, and handle the error with an except". Since that's clumsy, we keep using "catch" as a verb, which means in non-code contexts it's easy to accidentally write try/catch.
(None, None)None? What shouldxbe in that case? What shouldybe in that case? Do you even really want to continue with the current calculation that usesxandy?