Steve Holden wrote: > Hey, I have an idea, why don't we look at the language reference manual > instead of imagining how we think it might work!
I don't know. Sounds risky. > In section 3.2 we find: > > > """ > Tuples > The items of a tuple are arbitrary Python objects. Tuples of two or more > items are formed by comma-separated lists of expressions. A tuple of one > item (a `singleton') can be formed by affixing a comma to an expression > (an expression by itself does not create a tuple, since parentheses must > be usable for grouping of expressions). An empty tuple can be formed by > an empty pair of parentheses. > """ > > So it seems that your speculation is false. Section 2.6 specifically > defines "[" and "]" as delimiters. Section 5.3.2 defines a subscription > (a term I've not really grown to love, but what the heck) as > > subscription ::= primary "[" expression_list "]" > > and section 5.12, which defines expression_list, explicitly says > > """An expression list containing at least one comma yields a tuple.""". > > So it would appear that while your change might be very convenient to > allow you to refer to scalar values as zero-dimensional arrays, it > doesn't really fit into Python's conceptual framework. Sorry. Yes, that would appear to be so. You would have a point... if the documentation were correct. Only it's not. According to the reference manual, the rule for an expression_list is: expression_list ::= expression ( "," expression )* [","] But take the following legal Python subscripted array: a[1:2,...,3:4] Is "1:2" an expression? How about "..."? When I enter 1:2 at the Python prompt, I get a syntax error. The fact is, the documentation here is either wrong or simplified or both. (I don't think it's a big deal, actually: the real grammar has lots of complexity to handle tricky cases that would needlessly complicate the reference manual for a human reader.) So let's look at an excerpt the actual Python grammar (from 2.4.3). You'll be happy to know subscription isn't used. :) trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME subscriptlist: subscript (',' subscript)* [','] sliceop: ':' [test] subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop] testlist: test (',' test)* [','] Clearly, the grammar rule used for list subscript is different from the one used for list of expressions (for some reason, what an ordinary person would call an expression is called a "test" in the grammar, whereas "expr" is a non-short-circuiting expression). So there's a regular way to create non-empty tuples, and a subscript way. And there's a regular way to create an empty tuple... but not a subscript way. So I'd say this change fits the conceptual framework of the tuple quite well; in fact, it makes subscript tuples more parallel to their regular counterparts. > One further point: if you really do conceptualize scalars as > zero-dimensional arrays, where is the value conceptually stored? Think of it this way: an array with n-dimensions of length 3 would have 3**n total entries. How many entries would a 0-dimensional array have? 3**0 == 1. Numeric has had zero-dimensional arrays for a long time, and has had no problem storing them. Think of the rule for accessing an element of an array: it's a base pointer + sum (indices*stride) for all indices. Now generalize it down to zero: there are no indices, so the scalar is stored at the base pointer. Carl Banks -- http://mail.python.org/mailman/listinfo/python-list