On Tue, 22 May 2018 18:51:30 +0100, bartc wrote:
> On 22/05/2018 15:25, Chris Angelico wrote:
[...]
>> The tuple has nothing to do with the parentheses, except for the
>> special case of the empty tuple. It's the comma.
>
> No? Take these:
>
> a = (10,20,30)
> a = [10,20,30]
> a = {10,20,30}
>
> If you print type(a) after each, only one of them is a tuple - the one
> with the round brackets.
You haven't done enough testing. All you have done is found that "round
brackets give a tuple, other brackets don't". But you need to test what
happens if you take away the brackets to be sure that it is the round
brackets which create the tuple:
a = 10, 20, 30 # take away the ()
You still get a tuple. Taking away the [] and {} also give tuples.
What happens if you add extra brackets?
a = ((10, 20, 30)) # tuple
b = ([10, 20, 30]) # list
c = ({10, 20, 30}) # set
The round brackets are just used for grouping. In fact, the bytecode
generated is identical:
py> import dis
py> dis.dis("(99, x)")
1 0 LOAD_CONST 0 (99)
3 LOAD_NAME 0 (x)
6 BUILD_TUPLE 2
9 RETURN_VALUE
py> dis.dis("99, x")
1 0 LOAD_CONST 0 (99)
3 LOAD_NAME 0 (x)
6 BUILD_TUPLE 2
9 RETURN_VALUE
What if we take away the commas but leave the brackets? If "brackets make
tuples", then the commas ought to be optional.
a = (10 20 30) # SyntaxError
What if we simple add a single comma to end end, outside of the brackets?
a = (10, 20, 30), # tuple inside tuple
b = [10, 20, 30], # list inside tuple
c = {10, 20, 30}, # set inside tuple
Conclusion: it is the comma, not the round brackets, which defines tuples
(aside from the empty tuple case).
> The 10,20,30 in those other contexts doesn't create a tuple, nor does it
> here:
>
> f(10,20,30)
That's okay. There's no rule that says commas are ONLY used for tuples,
just as there is no rule that says "if" is ONLY be used for if
statements. (It is also used in the ternary if operator, elif, and any
valid identifier which happens to include the letters "if" in that order).
> It's just that special case I
> highlighted where an unbracketed sequence of expressions yields a tuple.
You have that backwards. An unbracketed sequence of expressions yielding
a tuple is not the special case, it is the base case. If you want
something which is not a tuple (a list, a set) you have to use square or
curly brackets.
The round brackets are only neccessary for tuples to group items in case
of ambiguity with other grammar rules. (And the empty tuple.)
> The comma is just generally used to separate expressions, it's not
> specific to tuples.
Nobody said it was specific to tuples. That would be an absurd thing to
say. What was said is that the comma is what makes tuples, not the
brackets.
--
Steve
--
https://mail.python.org/mailman/listinfo/python-list
