On Tue, 09 Jun 2009 09:43:45 +1000, Ben Finney wrote: > Use a list when the semantic meaning of an item doesn't depend on all > the other items: it's “only” a collection of values. > > Your list of message codes is a good example: if a value appears at > index 3, that doesn't make it mean something different from the same > value appearing at index 2.
That advice would seem to imply that lists shouldn't be ordered. If a list of values has an order, it implies that "first place" (index 0) is different from "second place", by virtue of the positions they appear in the list. The lists: presidential_candidates_sorted_by_votes = ['Obama', 'McCain'] presidential_candidates_sorted_by_votes = ['McCain', 'Obama'] have very different meanings. Prohibiting the use of lists in the context of ordered data is surely is an unfortunate consequence of your advice. > James Tauber explains this at > <URL:http://jtauber.com/blog/2006/04/15/ > python_tuples_are_not_just_constant_lists/>. He doesn't really explain anything though, he merely states it as revealed wisdom. The closest he comes to an explanation is to declare that in tuples "the index in a tuple has an implied semantic. The point of a tuple is that the i-th slot means something specific. In other words, it's a index-based (rather than name based) datastructure." But he gives no reason for why we should accept that as true for tuples but not lists. It may be that that's precisely the motivation Guido had when he introduced tuples into Python, but why should we not overload tuples with more meanings than Guido (hypothetically) imagined? In other words, why *shouldn't* we treat tuples as immutable lists, if that helps us solve a problem effectively? To put it another way, I think the question of whether or not tuples are immutable lists has the answer Mu. Sometimes they are, sometimes they're not. I have no problem with the title of the quoted blog post -- that tuples are not *just* constant lists -- but I do dispute that there is any reason for declaring that tuples must not be used as constant lists. As tuples are defined in Python, they quack like immutable lists, they walk like immutable lists, and they swim like immutable lists. Why shouldn't we treat them as immutable lists? Phillip Eby states that "Lists are intended to be homogeneous sequences, while tuples are heterogeneous data structures." (Notice the subtle shift there: lists are "intended", while tuples "are". But in fact, there's nothing to stop you from putting homogeneous data into a tuple, so Eby is wrong to say that tuples *are* heterogeneous.) Perhaps Eby intends lists to be homogeneous, perhaps Guido does too, but this is Python, where we vigorously defend the right to shoot ourselves in the foot. We strongly discourage class creators from trying to enforce their intentions by using private attributes, and even when we allow such a thing, the nature of Python is that nothing is truly private. Why should homogeneity and heterogeneity of lists and tuples be sacrosanct? Nothing stops me from putting hetereogeneous data into a list, or homogeneous data into a tuple, and there doesn't appear to be any ill- effects from doing so. Why give lose sleep over the alleged lack of purity? -- Steven -- http://mail.python.org/mailman/listinfo/python-list