Slice lists and extended slicing

[Gerald Britton]

I'm looking at extended slicing and wondering when and how to use slice lists:

slicing          ::=  simple_slicing | extended_slicing
simple_slicing   ::=  primary "[" short_slice "]"
extended_slicing ::=  primary "[" slice_list "]"
slice_list       ::=  slice_item ("," slice_item)* [","]
slice_item       ::=  expression | proper_slice | ellipsis
proper_slice     ::=  short_slice | long_slice
short_slice      ::=  [lower_bound] ":" [upper_bound]
long_slice       ::=  short_slice ":" [stride]
lower_bound      ::=  expression
upper_bound      ::=  expression
stride           ::=  expression
ellipsis

The semantics for an extended slicing are as follows. The primary must
evaluate to a mapping object, and it is indexed with a key that is
constructed from the slice list, as follows. If the slice list
contains at least one comma, the key is a tuple containing the
conversion of the slice items; otherwise, the conversion of the lone
slice item is the key. The conversion of a slice item that is an
expression is that expression. The conversion of an ellipsis slice
item is the built-in Ellipsis object. The conversion of a proper slice
is a slice object (see section The standard type hierarchy) whose
start, stop and step attributes are the values of the expressions
given as lower bound, upper bound and stride, respectively,
substituting None for missing expressions.

I'd thought that I could do this:

>>> l = [1,2,3,4,5]
>>> l[0:1, 3:4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list indices must be integers, not tuple

but that clearly doesn't work!  So, when and how can one use slice lists?

-- 
Gerald Britton