Q:

Create a single element tuple of tuple

I just noticed that if you want to create a tuple with single element, being a tuple itself, you cannot do it with constructor tuple only with (,) syntax. Why is that? 
Example:
>>> tuple(list('abc'))
('a', 'b', 'c')
>>> tuple(tuple(list('abc')))
('a', 'b', 'c')
>>> (tuple(list('abc')),)
(('a', 'b', 'c'),)

But then it holds for a list
>>> tuple([1],)
(1,)
>>> tuple([1])
(1,)

A:

I don't really see the issue, this adheres to the documentation:

class tuple(object)
 |  tuple() -> empty tuple
 |  tuple(iterable) -> tuple initialized from iterable's items
 |  
 |  If the argument is a tuple, the return value is the same object.

So, list('abc') always evaluates to ['a', 'b', 'c'] which is an iterable.
So in the first example (tuple(['a', 'b', 'c'])), the result is a tuple initialised from the iterable's items. I.e. ('a', 'b', 'c').
The second example takes the result of the first example (a tuple) and passes it into the tuple() function once more. As the documentation states (last line), the return value when passed a tuple is the same object which matches with our result.
And for the third, once more, the docs tell us what we need to know:

A special problem is the construction of tuples containing 0 or 1 items: the syntax has some extra quirks to accommodate these. Empty tuples are constructed by an empty pair of parentheses; a tuple with one item is constructed by following a value with a comma (it is not sufficient to enclose a single value in parentheses).

Finally, your last two examples (tuple([1]) and tuple([1],)) both produce a one-element tuple, because you are passing an iterable of length one. The docs once again state (at top): a tuple is initialized from iterable's items.
So, to conclude, the case where you need a comma is when you want to create a tuple with one element. However, if passing an iterable of length one, this is not necessary as Python understands that you are not evaluating an expression.

For completeness, the reason this awkward syntax is unavoidable is because  statements like: (1 + 2) * 3 would evaluate to (3, 3, 3) rather than the expected 9. So instead, you must go out of your way through adding a comma: (1 + 2,) * 3 to get the result of (3, 3, 3) which makes perfect sense.

