Why single element tuple is interpreted as that element in python?

倾然丶 夕夏残阳落幕 提交于 2019-12-02 01:40:38

A single element tuple is never treated as the contained element. Parentheses are mostly useful for grouping, not for creating tuples; a comma does that.

Why don't they just print (1,) as (1)?

Probably because printing a builtin container type gives a representation that can be used to recreate the container object via , say eval:

The docs for __repr__ provides some clarity on this:

If at all possible, this should look like a valid Python expression that could be used to recreate an object with the same value

Answering your question, (1) is just integer 1 with a grouping parenthesis. In order to recreate the singleton tuple via its representation, it has to be printed as (1,) which is the valid syntax for creating the tuple.

>>> t = '(1,)'
>>> i = '(1)'
>>> eval(t)
(1,) # tuple
>>> eval(i)
1    # int

Because only (1, ) in your examples is tuple. The rest are expressions.

In [4]: type(1,)
Out[4]: int

In [5]: type((1,))
Out[5]: tuple

In [6]: type((1))
Out[6]: int

It's because (1) is not a tuple. (1) is 1 with parentheses surrounding it. As the python documentation states

it is the comma, not the parentheses, that define the tuple.

Source

The only tuple without a comma is a 0-tuple, which is (). Note, you can check this by running type((1)) and seeing that it returns <type 'int'> not <type 'tuple'>.

(1) is not a tuple, it's just parentheses around a number. This is because sometimes you want to use parentheses to indicate order of operations, for example: (x+y)*z. This obviously doesn't refer to a tuple containing x+y, it's just to show that the addition should happen before the multiplication.

(((1))) is not a tuple for the same reason, the parentheses are just saying "evaluate what's inside before moving on".

print(1,) is just calling the print function on the number 1. When calling a function, a trailing comma is allowed. However, in python2, this will probably pring (1,), because print isn't a function.

print((1,)) is the only thing that prints a tuple, because we are now actually passing a tuple into the function.

transang

This is very detailed answer from @Ray Total

Sure, in general parentheses don't change the meaning of an expression. For example you can say 4+(1) and it will be 5, the same way 4*(2-1) would be 4. Because the convention is to use parentheses for grouping of subexpressions, the designer of Python thought it would be too confusing to overload the meaning to mean both grouping and single-element tuples. Also Python has a type function. In fact type((2)) is int and type((2,)) is tuple. We don't want there to be any ambiguity, which there would be if (2) were treated as a tuple

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!