tuple.index()

[Nick Maclaren]

Why doesn't the tuple type have an index method? It seems such a
bizarre restriction that there must be some reason for it. Yes,
I know it's a fairly rare requirement.
Regards,
Nick Maclaren.

[Fredrik Lundh]

Nick Maclaren wrote:

Why doesn't the tuple type have an index method? It seems such a
bizarre restriction that there must be some reason for it.

hah! not being able to remove or add things to tuples is an even
bizarrer restriction!

</F>

[Nick Maclaren]

In article <ma************ *************** ************@py thon.org>,
Fredrik Lundh <fr*****@python ware.comwrites:
|>
| Why doesn't the tuple type have an index method? It seems such a
| bizarre restriction that there must be some reason for it.
|>
|hah! not being able to remove or add things to tuples is an even
|bizarrer restriction!

Eh? Why?

My understanding of the difference between a tuple and a list is
PRECISELY that the former is immutable and the latter mutable.
But an index method makes precisely as much sense on an immutable
sequence as it does on a mutable one.
Regards,
Nick Maclaren.

[Glenn Hutchings]

Nick Maclaren wrote:

Why doesn't the tuple type have an index method? It seems such a
bizarre restriction that there must be some reason for it.

In fact, tuples have no non-__underscored__ methods at all. The list
count() method would also be useful for tuples, since it doesn't modify
anything. I have no idea why they aren't implemented either.

Glenn

[Fredrik Lundh]

Nick Maclaren wrote:

My understanding of the difference between a tuple and a list is
PRECISELY that the former is immutable and the latter mutable.

while tuples can be used as "frozen lists", that's definitely not what
they are, from a design perspective.

just like in math [1], a Python tuple is a heterogeneous sequence where
the position implies type and usage. in contrast, a list is a homo-
geneous collection where all the items are "the same" in some sense,
no matter where they are. if you sort or otherwise reorder a list
of things, it's still a list of the same things. if you sort a tuple,
you'll break it.

in other words, you're supposed to know what the individual items are in
a tuple; if you feel the need to search for things by value in a tuple,
you're using the wrong container type.

</F>

1) http://en.wikipedia.org/wiki/Tuple

[Simon Brunning]

On 14 Dec 2006 11:24:04 GMT, Nick Maclaren <nm**@cus.cam.a c.ukwrote:

>
Why doesn't the tuple type have an index method? It seems such a
bizarre restriction that there must be some reason for it. Yes,
I know it's a fairly rare requirement.

It's because, philosophically , a Python tuple isn't just a read-only list.

Lists are for homogeneous data, all entries being of the same 'type'.
('Type' here doesn't refer to class or anything like that - just
conceptual type - what kind of thin g it is.) So, you can infer no
semantic meaning from an items position in the list. Sorting makes
sence,m and does looking though a list to find something - hence
index().

A tuple, on the other hand, is heterogeneous. The fact that an item is
the nth item is a tuple *means* something. Sorting a tuple would make
no sense, even if it were possible, and you are supposed to know where
in the tuple things are, so it makes no sense to search for it.

--
Cheers,
Simon B
si***@brunningo nline.net
http://www.brunningonline.net/simon/blog/

[Glenn Hutchings]

Simon Brunning wrote:

It's because, philosophically , a Python tuple isn't just a read-only list.

But there are situations where you might want to treat it as a
read-only list. E.g., an argument to a function, so that you can
guarantee the function won't modify it. In that case, it makes sense
for the non-modifying methods (index() and count()) to be available.

[Roberto Bonvallet]

Glenn Hutchings wrote:

But there are situations where you might want to treat it as a
read-only list. E.g., an argument to a function, so that you can
guarantee the function won't modify it. In that case, it makes sense
for the non-modifying methods (index() and count()) to be available.

list(my_arg).in dex(...)

--
Roberto Bonvallet

[Glenn Hutchings]

Roberto Bonvallet wrote:

list(my_arg).in dex(...)

Absolutely -- you can work around the limitation without any problems.
But the question is, why doesn't the list type share all its
non-modifying methods with the tuple type? All the previous arguments
about "homogenous " and "heterogeno us" in this thread sound bogus to me.
Python is first and foremost a practical language; what lists and
tuples are supposedly "for" strikes me as being irrelevant.

Glenn

[Glenn Hutchings]

Fredrik Lundh wrote:

if you cannot trust your own code not to modify objects you pass to it,
I'm not sure Python's the right language for you.

It's not my own code I'm worried about. :-)