How to perfectly convert one-element list to tuple in Python?

So I am trying to do this:


The output I expect is :


However, I got this:


But if I do this:


It works perfectly! like this:


This is so weird that I don’t know why the tuple function cause this result.

Please help me to fix it.

Enquirer: Mars Lee


Solution #1:

This is such a common question that the Python Wiki has a page dedicated to it:

One Element Tuples

One-element tuples look like:


The essential element here is the trailing comma. As for any
expression, parentheses are optional, so you may also write
one-element tuples like


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

Respondent: Akshat Mahajan

Solution #2:

That is how tuples are formed in python. Using just (1) evaluates to 1, just as much as using (((((((1))))))) evaluates to ((((((1)))))) to (((((1))))) to… 1.

Using (1,) explicitly tells python you want a tuple of one element

Respondent: smac89

Solution #3:

What you are getting is a tuple. When there is only a single element, then it has to be represented with a comma, to show it is a tuple.


>>> a = (1)
>>> type(a)
<type 'int'>
>>> a = (1,)
>>> type(a)
<type 'tuple'>

The reason is, when you do not use a comma when there is only one element, the interpreter evaluates it like an expression grouped by paranthesis, thus assigning a with a value of the type returned by the expression

Respondent: Aswin Murugesh

Solution #4:

From the docs

6.2.3. Parenthesized forms

A parenthesized form is an optional expression list enclosed in parentheses:

parenth_form ::=  "(" [expression_list] ")" 

A parenthesized expression
list yields whatever that expression list yields: if the list contains
at least one comma, it yields a tuple; otherwise, it yields the single
expression that makes up the expression list.

An empty pair of parentheses yields an empty tuple object. Since
tuples are immutable, the rules for literals apply (i.e., two
occurrences of the empty tuple may or may not yield the same object).

Note that tuples are not formed by the parentheses, but rather by use
of the comma operator. The exception is the empty tuple, for which
parentheses are required — allowing unparenthesized “nothing” in
expressions would cause ambiguities and allow common typos to pass

So (1,) really is a tuple

Respondent: John La Rooy

Solution #5:

(1) is just 1 in grouping parentheses – it’s an integer. (1,) is the 1-element tuple you want.

Solution #6:

That is normal behavior in Python. You get a Tuple with one element. The notation (1,) is just a reminder that you got such a tuple.

Respondent: Cyb3rFly3r

Solution #7:

The output (1,) is fine. The , is to mark a single element tuple.


a = (1) 

a is really a integer


a = (1, )

Then a is a tuple.

Respondent: trans1st0r

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Leave a Reply

Your email address will not be published.