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.

You can find it on 5. Data Structures - Python 3.6.3 documentation

A tuple consists of a number of values separated by commas
[...]
Tuples are immutable, and usually contain a heterogeneous sequence of elements that are accessed via unpacking or indexing

It is the commas, not the parentheses, which are significant. The Python tutorial says:

A tuple consists of a number of values separated by commas

Parentheses are used for disambiguation in other places where commas are used, for example, enabling you to nest or enter a tuple as part of an argument list.

See the Python Tutorial section on Tuples and Sequences

ax.plot() returns a tuple which contains only one element. If you assign it without the comma, you just assign the tuple.

>>> t = (1,)
>>> a = t
>>> a
(1,)

But if you assign it with the comma, you unpack it.

>>> t = (1,)
>>> a, = t
>>> a
1

What you describe is tuple assignment:

a, b = 0, 1

is equivalent to a = 0 and b = 1.

It can however have interesting effects if you for instance want to swap values. Like:

a,b = b,a

will first construct a tuple (b,a) and then untuple it and assign it to a and b. This is thus not equivalent to:

#not equal to
a = b
b = a

but to (using a temporary):

t = a
a = b
b = t

In general if you have a comma-separated list of variables left of the assignment operator and an expression that generates a tuple, the tuple is unpacked and stored in the values. So:

t = (1,'a',None)
a,b,c = t

will assign 1 to a, 'a' to b and None to c. Note that this is not syntactical sugar: the compiler does not look whether the number of variables on the left is the same as the length of the tuple on the right, so you can return tuples from functions, etc. and unpack them in separate variables.

d2, = values[s] is just like a,b=f(), except for unpacking 1 element tuples.

>>> T=(1,)
>>> a=T
>>> a
(1,)
>>> b,=T
>>> b
1
>>> 

a is tuple, b is an integer.

The problem is pretty straightforward, and your solution is as well. I have only a couple of small comments:

1. The pop method in Python removes and returns the last item in a list, which can replace two lines.
2. You don't have to new_string = '' when you set new_string on the next line. As a result, things can be shortened a bit.
3. Personally, since str1 is only used once, I would personally just do it inline and not save it to a variable. The only time I save something to a variable, if it is only used once, is to shorten an otherwise-long line.
4. Concatenating two hard-coded strings should be put in one operation (i.e. ' and' + ' ' => ' and '
5. Guards! They're the best way to check input before executing.

My recommended version:

def items(some_list):
    if not some_list:
        return ''

    string_end = some_list.pop()
    if not some_list:
        return string_end

    and_display = ' and ' if len(some_list) == 1 else ', and '
    new_string = ', '.join(some_list) + and_display + string_end
    return new_string

print(items(['apples', 'kittens', 'tofu', 'puppies']))

This works fine as long as you are working with a list of strings. It will crash if you pass in an int or something that can't auto-convert to a string. That may or may not be a problem, depending on your perspective. Trying to make your code auto-convert things to strings, if they aren't strings, can be a very error-prone process. As a result, I think it is perfectly fine to write this the easy way, and let it be the developer's problem if it crashes due to non-string arguments.

Docstrings are usually helpful for this kind of thing.

Note on pass-by-reference

Hat tip to TheEspinosa: Python uses a pass-by-reference style for its arguments. As a result, modifying arguments (which is especially easy for lists, as is the case here) can result in unintentional side-effects. The use of pop (or del in your original code) results in the last entry being removed from the list, not just inside the function, but also in the variable passed in to the function. For your example usage, which calls this function with a constant value, this behavior doesn't matter. But it may as part of a larger application. There are three ways to handle this:

1. Adjust your algorithm so you don't make any changes to any arguments being passed in (@Richard Nemann's answer works that way)
2. Copy the list before using it inside your function. A simple shorthand to copy a list is: new_copy = old_copy[:]. There is also a copy module.
3. Ignore it and let it be the caller's problem.

I use all three solutions depending on the circumstances or my mood. A copy operation obviously involves some overhead, but unless you know that performance is a problem, I would still do a copy if the algorithm that avoids the need for the copy is harder to understand.

To be clear about the problem the current code can potentially introduce, try running my implementation (or yours) like this:

vals = ['apples', 'bananas', 'grapes']
items(vals)
print(len(vals))

If you run this code the last line will print 2, because in your calling scope the variable has been modified-by-reference: grapes is no longer in the list.

I said at the beginning that this was a straightforward problem. At this point in time though I think it's fair to say that the devil is in the details :)