How should I put try/except in a single line?

You mentioned that you’re using django. If it makes sense for what you’re doing you might want to use:

my_instance, created = MyModel.objects.get_or_create()

created will be True or False. Maybe this will help you.

You can do it by accessing the namespace dict using vars(), locals(), or globals(), whichever is most appropriate for your situation.

>>> b = 'some variable'
>>> a = vars().get('c', b)

This is terribly hackish, but I’ve used it at the prompt when I wanted to write up a sequence of actions for debugging:

exec "try: some_problematic_thing()nexcept: problem=sys.exc_info()"
print "The problem is %s" % problem[1]

For the most part, I’m not at all bothered by the no-single-line-try-except restriction, but when I’m just experimenting and I want readline to recall a whole chunk of code at once in the interactive interpreter so that I can adjust it somehow, this little trick comes in handy.

For the actual purpose you are trying to accomplish, you might try locals().get('c', b); ideally it would be better to use a real dictionary instead of the local context, or just assign c to None before running whatever may-or-may-not set it.

Another way is to define a context manager:

class trialContextManager:
    def __enter__(self): pass
    def __exit__(self, *args): return True
trial = trialContextManager()

Then use the with statement to ignore errors in one single line:

>>> with trial: a = 5      # will be executed normally
>>> with trial: a = 1 / 0  # will be not executed and no exception is raised
>>> print a
5

No exception will be raised in case of a runtime error. It’s like a try: without the except:.

The problem is that its actually a django model.objects.get query i am trying to test. the .get returns an error if no data is found… it doesn’t return None (which annoys me)

Use something like this:

print("result:", try_or(lambda: model.objects.get(), '<n/a>'))

Where try_or is an utility function defined by you:

def try_or(fn, default):
    try:
        return fn()
    except:
        return default

Optionally you can restrict the accepted exception types to NameError, AttributeError, etc.

parse_float = lambda x, y=exec("def f(s):n try:n  return float(s)n except:  return None"): f(x)

There is always a solution.

if you need to actually manage exceptions:
(modified from poke53280’s answer)

>>> def try_or(fn, exceptions: dict = {}):
    try:
        return fn()
    except Exception as ei:
        for e in ei.__class__.__mro__[:-1]:
            if e in exceptions: return exceptions[e]()
        else:
            raise


>>> def context():
    return 1 + None

>>> try_or( context, {TypeError: lambda: print('TypeError exception')} )
TypeError exception
>>> 

note that if the exception is not supported, it will raise as expected:

>>> try_or( context, {ValueError: lambda: print('ValueError exception')} )
Traceback (most recent call last):
  File "<pyshell#57>", line 1, in <module>
    try_or( context, {ValueError: lambda: print('ValueError exception')} )
  File "<pyshell#38>", line 3, in try_or
    return fn()
  File "<pyshell#56>", line 2, in context
    return 1 + None
TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'
>>> 

also if Exception is given, it will match anything below.
(BaseException is higher, so it will not match)

>>> try_or( context, {Exception: lambda: print('exception')} )
exception

In python3 you can use contextlib.suppress:

from contextlib import suppress

d = {}
with suppress(KeyError): d['foo']

Version of poke53280 answer with limited expected exceptions.

def try_or(func, default=None, expected_exc=(Exception,)):
    try:
        return func()
    except expected_exc:
        return default

and it could be used as

In [2]: try_or(lambda: 1/2, default=float('nan'))
Out[2]: 0.5

In [3]: try_or(lambda: 1/0, default=float('nan'), expected_exc=(ArithmeticError,))
Out[3]: nan

In [4]: try_or(lambda: "1"/0, default=float('nan'), expected_exc=(ArithmeticError,))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
[your traceback here]
TypeError: unsupported operand type(s) for /: 'str' and 'int'

In [5]: try_or(lambda: "1"/0, default=float('nan'), expected_exc=(ArithmeticError, TypeError))
Out[5]: nan

Works on Python3, inspired by Walter Mundt

exec("try:some_problematic_thing()nexcept:pass")

For mulitiples lines into one line

exec("try:ntprint('FirstLineOk')ntsome_problematic_thing()ntprint('ThirdLineNotTriggerd')nexcept:pass")

Ps: Exec is unsafe to use on data you don’t have control over.

How about using two lines. is it ok ?

>>> try: a = 3; b= 0; c = a / b
... except : print('not possible'); print('zero division error')
...
not possible
zero division error

Here is a simpler version of the answer provided by @surendra_ben

a = "apple"
​
try: a.something_that_definitely_doesnt_exist
except: print("nope")

...

nope

Use with syntax in one line:

class OK(): __init__ = lambda self, *isok: setattr(self, 'isok', isok); __enter__ = lambda self: None; __exit__ = lambda self, exc_type, exc_value, traceback: (True if not self.isok or issubclass(exc_type, self.isok) else None) if exc_type else None

Ignore any errors:

with OK(): 1/0

Ignore specified errors:

with OK(ZeroDivisionError, NameError): 1/0

The two-liner version doesn’t work me. I use VSCode on ubuntu 20.04 x64.It only works if I move the exception statements to a new line. The try can remain a single line. So minimally I would need 3 lines. Don’t know if this is a bug or feature.

An actual clean oneliner that reads (somewhat) like the try-except block and is not super dirty would be as follows:

val = (lambda: dictionary["wrong key"]) % cept(KeyError) % (lambda: "default value")

This needs a setup like this

from infix import mod_infix

def cept(*args, as_exc=False):
    if not args:
        args = Exception

    @mod_infix
    def _cept(f1, f2):
        try:
            return f1()
        except args as e:
            if as_exc:
                return f2(e)
            else:
                return f2()
    return _cept

I wish I could do away with the lambdas, but there is no way.

I personally find the rejection notice for https://peps.python.org/pep-0463/ unsatisfying. Guido, if you are reading this (yea, I wish), please let us know.

I see multiple examples here using try..except for handling dictionary keys. In those instances, the appropriate way would be to use the .get method which will return None when it is not available. Example

my_dict = {'a': 1, 'b': 2}
print(my_dict.get('c'))
# Output: None