Is except: ... pass bad style?

[marduk]

I commonly use code like this

try:
# call optional method
myobj.method()
except AttributeError:
# no biggie
pass
Occasionally I use pylint, which is a good tool, but in the above
snippet pylint will complain that 'Except doesn't do anything'. True,
but is that bad style? I know there are other ways of doing it, but
of all the other "obvious" ones, this appears the most straight
forward.

Should I ignore pylint or is there a more Pythonic way to do this?

[Michael Hudson]

marduk <ma****@python.net> writes:

I commonly use code like this

try:
# call optional method
myobj.method()
except AttributeError:
# no biggie
pass
Occasionally I use pylint, which is a good tool, but in the above
snippet pylint will complain that 'Except doesn't do anything'. True,
but is that bad style? I know there are other ways of doing it, but
of all the other "obvious" ones, this appears the most straight
forward.
Sounds like a dubious warning to me.
Should I ignore pylint or is there a more Pythonic way to do this?

Well,

try:
meth = myobj.method
except AttributeError:
pass
else:
meth()

is possibly better (your version might hide bugs in the method). It's
a pain to do this all the time, though.

Come to think of it

getattr(myobj, "method", lambda :None)()

also acheives the same thing. Bit inscrutable, though.

Cheers,
mwh

--
<thirmite> what's a web widget??
<glyph> thirmite: internet on a stick, on fire
<Acapnotic> with web sauce! -- from Twisted.Quotes

[Alex Martelli]

marduk <ma****@python.net> wrote:

I commonly use code like this

try:
# call optional method
myobj.method()
except AttributeError:
# no biggie
pass
Occasionally I use pylint, which is a good tool, but in the above
snippet pylint will complain that 'Except doesn't do anything'. True,
but is that bad style? I know there are other ways of doing it, but
of all the other "obvious" ones, this appears the most straight
forward.

Should I ignore pylint or is there a more Pythonic way to do this?

I would prefer:

try: themethod = myobj.method
except AttributeError: pass
else: themethod()

but this, too, has an empty except body, which IS pretty normal...
Alex

[Aahz]

In article <pa****************************@python.net>,
marduk <ma****@python.net> wrote:

I commonly use code like this

try:
# call optional method
myobj.method()
except AttributeError:
# no biggie
pass

Occasionally I use pylint, which is a good tool, but in the above
snippet pylint will complain that 'Except doesn't do anything'. True,
but is that bad style? I know there are other ways of doing it, but
of all the other "obvious" ones, this appears the most straight
forward.

Should I ignore pylint or is there a more Pythonic way to do this?

Neither. It's a perfectly good Pythonic idiom, but it's also likely to
be programmer error (mocking up the try/except structure and forgetting
to fill in the blanks later). So you should ignore pylint when it's
code you're familiar with (and have already double-checked your
intentions), but you should pay attention to pylint when you're writing
new code and checking it.
--
Aahz (aa**@pythoncraft.com) <*> http://www.pythoncraft.com/

"A foolish consistency is the hobgoblin of little minds, adored by little
statesmen and philosophers and divines." --Ralph Waldo Emerson

[Thomas Heller]

marduk <ma****@python.net> writes:

I commonly use code like this

try:
# call optional method
myobj.method()
except AttributeError:
# no biggie
pass
Occasionally I use pylint, which is a good tool, but in the above
snippet pylint will complain that 'Except doesn't do anything'. True,
but is that bad style? I know there are other ways of doing it, but
of all the other "obvious" ones, this appears the most straight
forward.

Should I ignore pylint or is there a more Pythonic way to do this?

It's better to write it this way, imo:

try:
mth = myobje.method
except AttributeError:
pass
else:
mth()

Otherwise you cannot determine whether myobj doesn't have this method,
or the method call is raising an exception.

Thomas

[Peter Otten]

marduk wrote:

I commonly use code like this

try:
# call optional method
myobj.method()
except AttributeError:
# no biggie
pass
Occasionally I use pylint, which is a good tool, but in the above
snippet pylint will complain that 'Except doesn't do anything'. True,
but is that bad style? I know there are other ways of doing it, but
of all the other "obvious" ones, this appears the most straight
forward.

Should I ignore pylint or is there a more Pythonic way to do this?

If the class of myobj is under your control you could do

class MyObj:
def method(self):
pass

and then later just call

myobj.method()

Result: cleaner client code :-)

Peter

[marduk]

Based on all the responses received thus far, I thought of a way of
doing it without an exception:

myobj.__dict__.get('method', lambda : None)()

Which is okay if you don't care about the return value of the
method (in my examples I'm assuming .method() just does something
(and returns None). But it's a lot uglier I think than the try/except
block.


----== Posted via Newsfeed.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeed.com The #1 Newsgroup Service in the World! >100,000 Newsgroups
---= 19 East/West-Coast Specialized Servers - Total Privacy via Encryption =---

[Michael Hudson]

marduk <ma****@python.net> writes:

Based on all the responses received thus far, I thought of a way of
doing it without an exception:

myobj.__dict__.get('method', lambda : None)()

Uh, I'd say that's pretty unlikely to work. What's wrong with
getattr()?

Cheers,
mwh

--
<dash> wow. this code does something highly entertaining, but
nowhere near correct -- from Twisted.Quotes

[Chris Cioffi]

I think that the getattr option would be your best/cleanest option.
For best results, combine with the Null object pattern.
http://aspn.activestate.com/ASPN/Coo...n/Recipe/68205

getattr(myobj, 'method', Null)()

Clean, concise, and clear. Just like most of the rest of Python. ;-)

Chris
On Thu, 09 Sep 2004 12:56:55 -0500, marduk <ma****@python.net> wrote:

Based on all the responses received thus far, I thought of a way of
doing it without an exception:

myobj.__dict__.get('method', lambda : None)()

Which is okay if you don't care about the return value of the
method (in my examples I'm assuming .method() just does something
(and returns None). But it's a lot uglier I think than the try/except
block.

----== Posted via Newsfeed.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeed.com The #1 Newsgroup Service in the World! >100,000 Newsgroups
---= 19 East/West-Coast Specialized Servers - Total Privacy via Encryption =---
--
http://mail.python.org/mailman/listinfo/python-list

--
Still searching for an even prime > 2!

[Istvan Albert]

marduk wrote:

try:
# call optional method
myobj.method()
except AttributeError:
# no biggie
pass
Occasionally I use pylint, which is a good tool, but in the above
snippet pylint will complain that 'Except doesn't do anything'. True,
but is that bad style?

I personally don't like this, not because of pylint but because
it feels like using the wrong solution for the problem.
You could create a base class that has a method that
does nothing and have all your objects inherit from that.

This solution does properly communicate
that the method is optional. Not to mention that you need
to repeat the whole thing if used again in a different
circumstance. Plus something could go wrong inside
existing methods and you'd never know about it.

Why risk all that?

Istvan.

[Donn Cave]

In article <m3************@pc150.maths.bris.ac.uk>,
Michael Hudson <mw*@python.net> wrote:
....

Well,

try:
meth = myobj.method
except AttributeError:
pass
else:
meth()

is possibly better (your version might hide bugs in the method). It's
a pain to do this all the time, though.

Come to think of it

getattr(myobj, "method", lambda :None)()

also acheives the same thing. Bit inscrutable, though.

Along the same lines,

if hasattr(myobj, 'method'):
myobj.method()

That's not uncommon usage, and has the advantage
of more directly and economically saying what the
try/except block is trying to say.

Donn Cave, do**@u.washington.edu

[Brandon Craig Rhodes]

Michael Hudson <mw*@python.net> writes:

marduk <ma****@python.net> writes:

I commonly use code like this

try:
# call optional method
myobj.method()
except AttributeError:
# no biggie
pass

try:
meth = myobj.method
except AttributeError:
pass
else:
meth()

I'm confused - why not

meth = getattr(myobj, method)
if meth:
meth()

--
Brandon Craig Rhodes br*****@rhodesmill.org http://rhodesmill.org/brandon

[Brandon Craig Rhodes]

I carelessly wrote:

meth = getattr(myobj, method)
if meth:
meth()

but in fact intended the first line to be

meth = getattr(myobj, method, None)

Sorry for any confusion. :-)

--
Brandon Craig Rhodes br*****@rhodesmill.org http://rhodesmill.org/brandon

[Brandon Craig Rhodes]

Brandon Craig Rhodes <br*****@ten22.rhodesmill.org> writes:

...but in fact intended the first line to be
meth = getattr(myobj, method, None)

.... where `method' holds the method name, of course. <sigh>

--
Brandon Craig Rhodes br*****@rhodesmill.org http://rhodesmill.org/brandon

[JCM]

Peter Otten <__*******@web.de> wrote:
....

If the class of myobj is under your control you could do class MyObj:
def method(self):
pass and then later just call myobj.method()

Yes. This also avoids running into trouble by catching an exception
you didn't mean to ignore.

[Alex Martelli]

marduk <ma****@python.net> wrote:

Based on all the responses received thus far, I thought of a way of
doing it without an exception:

myobj.__dict__.get('method', lambda : None)()

Have you TRIED this? most likely, myobj.method is NOT reaching into
myobj.__dict__, but rather into type(myobj). getattr is WAY superior!
Alex

[marduk]

On Thu, 09 Sep 2004 15:29:08 -0400, Istvan Albert wrote:

I personally don't like this, not because of pylint but because
it feels like using the wrong solution for the problem.
You could create a base class that has a method that
does nothing and have all your objects inherit from that.

This solution does properly communicate
that the method is optional. Not to mention that you need
to repeat the whole thing if used again in a different
circumstance. Plus something could go wrong inside
existing methods and you'd never know about it.

Why risk all that?

This is probably overkill for my current circumstance, but I may consider
it in the future. Besides, the class in question is third-party and I'm
merely trying to call method if it exists (version n) and do nothing if it
doesn't exist (version n-1). Although I could subclass the third-party
class and override method()... but as I said, overkill for me right now as
I'm only using the object/method once.

I really liked the getattr suggestion. Thanks to all who responded.

----== Posted via Newsfeed.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeed.com The #1 Newsgroup Service in the World! >100,000 Newsgroups
---= 19 East/West-Coast Specialized Servers - Total Privacy via Encryption =---

[Heiko Wundram]

Am Donnerstag, 9. September 2004 19:56 schrieb marduk:

myobj.__dict__.get('method', lambda : None)()

This won't work when inheritance is in play. See for yourself:

class x(object): .... def method(self):
.... return "I was called!"
.... class y(x): .... pass
.... a = y()
a.method() 'I was called!' a.__dict__.get("method",lambda: None)()
a.__dict__.get("method")
So, use getattr, which properly walks the inheritance tree:
getattr(a,"method",lambda: None)()

'I was called!'

Heiko.

[Andrew Dalke]

Michael Hudson wrote:

Come to think of it

getattr(myobj, "method", lambda :None)()

also acheives the same thing. Bit inscrutable, though.

Who needs a lambda?

getattr(myobj, "method", Exception)()

Even works for multiple arguments. Now if only
Exception took kwargs...

Still inscrutable, or at least distracting.

(In other words, don't use this.)

Andrew
da***@dalkescientific.com