Path: csiph.com!x330-a1.tempe.blueboxinc.net!usenet.pasdenom.info!weretis.net!feeder1.news.weretis.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed6.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail
Content-Type: text/plain; charset=us-ascii
Mime-Version: 1.0 (Apple Message framework v1084)
Subject: Re: except clause syntax question
From: Charles Yeomans <charles@declareSub.com>
In-Reply-To: <4f272f1f$0$29989$c3e8da3$5496439d@news.astraweb.com>
Date: Tue, 31 Jan 2012 08:57:31 -0500
Content-Transfer-Encoding: quoted-printable
References: <mailman.5218.1327946109.27778.python-list@python.org> <4f272f1f$0$29989$c3e8da3$5496439d@news.astraweb.com>
To: Python <python-list@python.org>
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.5243.1328018257.27778.python-list@python.org>
Lines: 111
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: x330-a1.tempe.blueboxinc.net comp.lang.python:19637


On Jan 30, 2012, at 7:00 PM, Steven D'Aprano wrote:

> On Mon, 30 Jan 2012 12:41:00 -0500, Charles Yeomans wrote:
>=20
>> To catch more than one exception type in an except block, one writes
>>=20
>> except (A, B, C) as e:
>>=20
>> I'm wondering why it was decided to match tuples, but not lists:
>>=20
>> except [A, B, C] as e:
>=20
> Simplicity.
>=20
> If you also allow lists, then why not allow arbitrary sequences? What=20=

> about iterators, do you allow them? That could be awkward, because=20
> iterators can only be run through once. Dictionaries are also =
iterable,=20
> so once you allow arbitrary iterables, you get dicts. The whole thing=20=

> becomes a mess. Better to keep it simple and only allow a single=20
> canonical collection type, and in Python, that type is tuple, not =
list.
>=20
> Tuples are that canonical collection type because they have a number =
of=20
> desirable properties:
>=20
> - Tuples are small and memory efficient, using the smallest amount of
>  memory needed to hold their items. Lists typically carry a block of
>  spare memory, to make insertions fast.
>=20
> - Consequently the Python virtual machine can create them rapidly and
>  efficiently.
>=20
> - Tuples are immutable, so you don't have to worry about passing one =
to a
>  function and having the function modify it behind your back.
>=20
> - Tuples are ordered, for the times where that matters.
>=20
> - Since the typical use-case is to iterate over the items in fixed =
order,
>  there's no need to pay the extra expense for a dict or set.
>=20
> - Tuples are simple to write: in general you only need commas between
>  items. Sometimes, to avoid ambiguity or change the precedence of
>  calculation, you also need round brackets (parentheses for =
Americans).
>  Except clauses are one of those times.
>=20
> - Frozensets and sets are ruled out for historical reasons: they =
didn't
>  exist until Python 2.3. Besides, which would you rather write?
>=20
>      ("abc", "def")
>      frozenset([abc", "def"])
>=20
> - Sets and lists are ruled out because they are mutable, both require
>  much more memory, and sets have a heavier computational burden.
>=20
>=20
>=20
>> The latter makes more sense semantically to me -- "catch all =
exception
>> types in a list" as opposed to "catch this single thing composed of
>> three exception types".
>=20
> Then you are labouring under a misunderstanding. You're not catching a=20=

> tuple, because tuples are never thrown. You're catching any of the=20
> exceptions that are contained in that tuple.
>=20
> Both lists and tuples *are* single things in themselves. Both lists =
and=20
> tuples are containers:
>=20
> A list is a single thing that contains other things.=20
>=20
> A tuple is a single thing that contains other things.
>=20

I don't think of a tuple as a container, and I don't think it a =
misunderstanding on my part to think this.  But I am aware that it is =
common to use tuples as immutable lists. =20

I don't see that performance was really a consideration, given that one =
can use any expression in an except statement --

except IOError if today =3D=3D 'Monday' else OSError as e

or=20

L =3D []
try:
    #code

except tuple(L) as e:
    pass

except Exception, e:
    L.append(e.__class__)

In any case, though I appreciate your attempt at a post hoc =
justification, I was hoping for a positive explanation.=20

Charles Yeomans