Packing Values Together

1Commas on the right make a tuple

# commas on the right make a tuple

point = 3, 7

print(point)
print(type(point))
print('The first value is', point[0])

(3, 7)
<class 'tuple'>
The first value is 3

And that explains a thing you met in the tuples lesson and probably filed under “odd”: a single value with a trailing comma is a tuple of one, while the same value in brackets with no comma is just the value.

# the comma, not the brackets

a = 5,
b = (5)
c = (5,)

print(a, type(a))
print(b, type(b))
print(c, type(c))

(5,) <class 'tuple'>
5 <class 'int'>
(5,) <class 'tuple'>

2Packing and unpacking, one after the other

# packing and unpacking, one after the other

student = 'Asha', 11, 91

print(student)

name, cls, marks = student

print(name, 'of class', cls, 'scored', marks)

('Asha', 11, 91)
Asha of class 11 scored 91

Three values packed into one name, then unpacked into three names again. Notice what a tuple is good for here: the three belong together — a name, a class and a mark are one student — and packing them says so in a way three separate variables cannot.

3At last: why x, y = y, x works

The Sample Programs chapter showed the swap with a temp variable and mentioned this one-liner as Python's shortcut. The list chapter used it again. Here is what it actually does — and it is nothing new, just one of each idea from these two pages:

# the swap, explained at last

x = 10
y = 20

print('Before: x =', x, 'y =', y)

x, y = y, x

print('After:  x =', x, 'y =', y)

Before: x = 10 y = 20
After:  x = 20 y = 10

Take that middle line in two halves, in the order Python does them:

# what the swap really does, in two halves

x = 10
y = 20

packed = y, x

print('The right side is packed first:', packed)

x, y = packed

print('Then unpacked into the names: x =', x, 'y =', y)

The right side is packed first: (20, 10)
Then unpacked into the names: x = 20 y = 10

x = 10, y = 20
x = y   ->  x is 20, y is 20   (the 10 is gone)
y = x   ->  y is 20            (there is nothing left to swap)

Two things follow from that, and both are worth knowing. The swap works for any number of names — a, b, c = c, a, b rotates three values in one line. And it works with list positions too, which is exactly the swap the reverse-in-place program did the long way:

# rotating three values, and swapping two items of a list

a = 1
b = 2
c = 3

a, b, c = c, a, b

print(a, b, c)

numbers = [10, 20, 30, 40, 50]
numbers[0], numbers[4] = numbers[4], numbers[0]

print(numbers)

3 1 2
[50, 20, 30, 40, 10]

x = 10
y = 20

print('Before: x =', x, 'y =', y)

x, y = y, x

print('After:  x =', x, 'y =', y)

4One thing to watch: a stray comma packs

Because a comma is all it takes, a comma in the wrong place quietly makes a tuple where you wanted a value:

# a trailing comma, and what it does

total = 100
answer = total,

print(answer)
print(answer + 5)

(100,)
Traceback (most recent call last):
  File "stray_comma.py", line 7, in <module>
    print(answer + 5)
          ~~~~~~~^~~
TypeError: can only concatenate tuple (not "int") to tuple

The message is worth reading carefully — it says tuple, which is the clue. Whenever a value you expected to be a number turns out to be a tuple of one, look for a comma at the end of the line that made it.

5Recap