当 Python 语法似乎支持它时，为什么我不能用元组对列表进行切片？

Question

I've been learning Python for awhile using official Python site tutorial/library/reference. Today I just accidentally stumbled across formal slicing reference and can't figure out why nobody tells about one possible scenario that should work but unfortunately it doesn't.

Namely, according tothis document it should be possible to select elements from the sequence using tuple of indexes and slices:

lst = list(range(1, 100, 2))
slc = slice(10, 20, 3)
print( lst[ 1, 5, 8, slc, 30:40:5, 49 ] )

But as many of you might expect error pops-up

Traceback (most recent call last): File "./slice-test.py", line 68, in print( lst[ 1, 5, 8, slc, 30:40:5, 49 ] ) TypeError: list indices must be integers or slices, not tuple

This notation have been present in Python for a long time. At least the same document for Python 2.x mentions this term as a "extended slicing"here

What am I missing here? I probably misinterpret this notation but I can't figure out where is the catch(except the fact that this is not supported by interpreter of course).

PS I've looked up for an answer elsewhere including this question .

PPS This question is not about indexing or start:end:step slicing per se, so examples of these are not needed.

Answer 1

Namely, according to this document it should be possible to select elements from the sequence using tuple of indexes and slices

The document tells you about what is syntactically valid Python code, that can be bytecode-compiled into a .pyc file. It does not tell you about what is semantically valid Python code, that will run without any errors.

Only SyntaxError can be raised by syntactically invalid code. The language grammar only explains how to avoid those exceptions, not any others.

It is allowed to use a tuple of indexes and slices to slice a Python object. It is up to the object's type to define what happens as a result, or if an exception should occur instead.

Python objects handle slicing (and subscription) using the magic method __getitem__ . In older versions, this was only for subscription, and a separate __getslice__ would be used for slicing. Either way, if there is only one item between the [] (ie, no commas in the code), it is passed directly - not as a 1-element tuple. (As explained there: everything that would be a valid subscription is also a valid slicing; these are read by the grammar as subscriptions instead of slicings.) Each slice - written using the special slice syntax, only valid in this slicing context - becomes a slice object, which is passed to __getitem__ just like anything else.

We can make our own class to test it:

>>> class Tester:
...     def __getitem__(self, x):
...         return x
...
>>> t = Tester()
>>> t[0]
0
>>> t['test']
'test'
>>> t[1:2:3]
slice(1, 2, 3)
>>> t[::-1]
slice(None, None, -1)
>>> t[1,2]
(1, 2)
>>> t[(1,2)]
(1, 2)
>>> t[[1,2]]
[1, 2]
>>> t[::-1, ::-1]
(slice(None, None, -1), slice(None, None, -1))
>>> t[1, 5, 8, slice(10, 20, 3), 30:40:5, 49]
(1, 5, 8, slice(10, 20, 3), slice(30, 40, 5), 49)