Slice lists and extended slicing

[Emile van Sebille]

On 1/26/2011 9:20 AM Gerald Britton said...
> I'm looking at extended slicing and wondering when and how to use slice lists:

I think the use of the term slice_list below is simply as the content 
between the encompassing brackets, eg in mylist[1:2:3] slice_list refers 
to 1:2:3.  So, you don't actually 'use' a slice_list - that's what the 
passed in value is called.

So, here are some example of how slicing is used:

 >>> a = range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 >>> a[:3] # the first three
[0, 1, 2]
 >>> a[-3:] # the last three
[7, 8, 9]
 >>> a[3:-3] # start and stop
[3, 4, 5, 6]
 >>> a[::2] # take every other
[0, 2, 4, 6, 8]
 >>> a[::-2] # take every other from the end
[9, 7, 5, 3, 1]
 >>> a[3:-3:2] # take every other within start stop
[3, 5]
 >>> a[3:-3:-2] # I'm not sure exactly why I didn't get something here
[]
 >>> a[-3:3:-2] # but apparently the polarity of stride within start 
stop matters
[7, 5]
 >>>


HTH

Emile






>
> 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?
>