### Question :

I don’t understand what does comma after variable **lines,** means: http://matplotlib.org/examples/animation/simple_anim.html

```
line, = ax.plot(x, np.sin(x))
```

If I remove comma and variable “line,” becomes variable “line” then program is broken. Full code from url given above:

```
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
fig = plt.figure()
ax = fig.add_subplot(111)
x = np.arange(0, 2*np.pi, 0.01) # x-array
line, = ax.plot(x, np.sin(x))
def animate(i):
line.set_ydata(np.sin(x+i/10.0)) # update the data
return line,
#Init only required for blitting to give a clean slate.
def init():
line.set_ydata(np.ma.array(x, mask=True))
return line,
ani = animation.FuncAnimation(fig, animate, np.arange(1, 200), init_func=init,
interval=25, blit=True)
plt.show()
```

According to http://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences comma after variable seems to be related to tuples containing only one item.

##
Answer #1:

`ax.plot()`

returns a *tuple* with *one* element. By adding the comma to the assignment target list, you ask Python to unpack the return value and assign it to each variable named to the left in turn.

Most often, you see this being applied for functions with more than one return value:

```
base, ext = os.path.splitext(filename)
```

The left-hand side can, however, contain any number of elements, and provided it is a tuple or list of variables the unpacking will take place.

In Python, it’s the comma that makes something a tuple:

```
>>> 1
1
>>> 1,
(1,)
```

The parenthesis are optional in most locations. You could rewrite the original code *with* parenthesis without changing the meaning:

```
(line,) = ax.plot(x, np.sin(x))
```

Or you could use list syntax too:

```
[line] = ax.plot(x, np.sin(x))
```

Or, you could recast it to lines that do *not* use tuple unpacking:

```
line = ax.plot(x, np.sin(x))[0]
```

or

```
lines = ax.plot(x, np.sin(x))
def animate(i):
lines[0].set_ydata(np.sin(x+i/10.0)) # update the data
return lines
#Init only required for blitting to give a clean slate.
def init():
lines[0].set_ydata(np.ma.array(x, mask=True))
return lines
```

For full details on how assignments work with respect to unpacking, see the Assignment Statements documentation.

##
Answer #2:

If you have

```
x, = y
```

you unpack a list or tuple of length one.

e.g.

```
x, = [1]
```

will result in `x == 1`

, while

```
x = [1]
```

gives `x == [1]`