这只是为了一些额外的信息。。。考虑以下列表

>>> l=[12,23,345,456,67,7,945,467]

反转列表的其他几个技巧：

>>> l[len(l):-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]

>>> l[:-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]

>>> l[len(l)::-1]
[467, 945, 7, 67, 456, 345, 23, 12]

>>> l[::-1]
[467, 945, 7, 67, 456, 345, 23, 12]

>>> l[-1:-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]

在Python中，最基本的切片形式如下：

l[start:end]

其中l是一些集合，start是一个包含索引，end是一个独占索引。

In [1]: l = list(range(10))

In [2]: l[:5] # First five elements
Out[2]: [0, 1, 2, 3, 4]

In [3]: l[-5:] # Last five elements
Out[3]: [5, 6, 7, 8, 9]

当从开始切片时，可以省略零索引，而当切片到结束时，可以忽略最终索引，因为它是冗余的，所以不要冗长：

In [5]: l[:3] == l[0:3]
Out[5]: True

In [6]: l[7:] == l[7:len(l)]
Out[6]: True

负整数在相对于集合结尾进行偏移时非常有用：

In [7]: l[:-1] # Include all elements but the last one
Out[7]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [8]: l[-3:] # Take the last three elements
Out[8]: [7, 8, 9]

切片时可以提供超出范围的索引，例如：

In [9]: l[:20] # 20 is out of index bounds, and l[20] will raise an IndexError exception
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]: l[-20:] # -20 is out of index bounds, and l[-20] will raise an IndexError exception
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

请记住，分割集合的结果是一个全新的集合。此外，当在赋值中使用切片表示法时，切片赋值的长度不需要相同。将保留分配切片之前和之后的值，集合将收缩或增长以包含新值：

In [16]: l[2:6] = list('abc') # Assigning fewer elements than the ones contained in the sliced collection l[2:6]

In [17]: l
Out[17]: [0, 1, 'a', 'b', 'c', 6, 7, 8, 9]

In [18]: l[2:5] = list('hello') # Assigning more elements than the ones contained in the sliced collection l [2:5]

In [19]: l
Out[19]: [0, 1, 'h', 'e', 'l', 'l', 'o', 6, 7, 8, 9]

如果忽略开始索引和结束索引，则将创建集合的副本：

In [14]: l_copy = l[:]

In [15]: l == l_copy and l is not l_copy
Out[15]: True

如果在执行赋值操作时省略了开始和结束索引，则集合的整个内容将替换为引用内容的副本：

In [20]: l[:] = list('hello...')

In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']

除了基本切片外，还可以应用以下符号：

l[start:end:step]

其中l是一个集合，start是一个包含索引，end是一个排他索引，step是一个步长，可以用来获取l中的每n个项目。

In [22]: l = list(range(10))

In [23]: l[::2] # Take the elements which indexes are even
Out[23]: [0, 2, 4, 6, 8]

In [24]: l[1::2] # Take the elements which indexes are odd
Out[24]: [1, 3, 5, 7, 9]

使用step提供了在Python中反转集合的有用技巧：

In [25]: l[::-1]
Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

也可以使用负整数作为步骤，如下例所示：

In[28]:  l[::-2]
Out[28]: [9, 7, 5, 3, 1]

然而，使用负值作为步长可能会变得非常混乱。此外，为了成为Pythonic，您应该避免在单个切片中使用start、end和step。如果需要这样做，可以考虑在两个任务中完成（一个任务是切片，另一个任务则是跨步）。

In [29]: l = l[::2] # This step is for striding

In [30]: l
Out[30]: [0, 2, 4, 6, 8]

In [31]: l = l[1:-1] # This step is for slicing

In [32]: l
Out[32]: [2, 4, 6]

在找到这张很棒的桌子http://wiki.python.org/moin/MovingToPythonFromOtherLanguages

Python indexes and slices for a six-element list.
Indexes enumerate the elements, slices enumerate the spaces between the elements.

Index from rear:    -6  -5  -4  -3  -2  -1      a=[0,1,2,3,4,5]    a[1:]==[1,2,3,4,5]
Index from front:    0   1   2   3   4   5      len(a)==6          a[:5]==[0,1,2,3,4]
                   +---+---+---+---+---+---+    a[0]==0            a[:-2]==[0,1,2,3]
                   | a | b | c | d | e | f |    a[5]==5            a[1:2]==[1]
                   +---+---+---+---+---+---+    a[-1]==5           a[1:-1]==[1,2,3,4]
Slice from front:  :   1   2   3   4   5   :    a[-2]==4
Slice from rear:   :  -5  -4  -3  -2  -1   :
                                                b=a[:]
                                                b==[0,1,2,3,4,5] (shallow copy of a)

这里有一个简单的记忆方法，可以记住它是如何工作的：

S L*I*C*E*切片的“i”位于第一位，代表包容，“e”排在最后，代表独占。

所以array[j:k]将包括第j个元素，并排除第k个元素。

前面的大多数答案都解决了有关切片表示法的问题。

用于切片的扩展索引语法是aList[start:stop:step]，基本示例如下：

:

更多切片示例：15个扩展切片

我发现更容易记住它是如何工作的，然后我可以找出任何特定的开始/停止/步骤组合。

首先了解range（）是很有启发性的：

def range(start=0, stop, step=1):  # Illegal syntax, but that's the effect
    i = start
    while (i < stop if step > 0 else i > stop):
        yield i
        i += step

从起点开始，一步一步递增，不要到达终点。非常简单。

关于消极步骤，需要记住的一点是，停止总是被排除的终点，无论它是高还是低。如果您希望相同的切片以相反的顺序进行，则单独进行反转会更为简单：例如，“abcde”[1:-2][:：-1]从左侧切下一个字符，从右侧切下两个字符，然后反转。（另请参见reversed（）。）

序列切片是相同的，只是它首先规范了负索引，并且它永远不能超出序列：

TODO:当abs（step）>1时，下面的代码出现了一个错误：“从不超出序列”；我认为我修补了它是正确的，但很难理解。

def this_is_how_slicing_works(seq, start=None, stop=None, step=1):
    if start is None:
        start = (0 if step > 0 else len(seq)-1)
    elif start < 0:
        start += len(seq)
    if not 0 <= start < len(seq):  # clip if still outside bounds
        start = (0 if step > 0 else len(seq)-1)
    if stop is None:
        stop = (len(seq) if step > 0 else -1)  # really -1, not last element
    elif stop < 0:
        stop += len(seq)
    for i in range(start, stop, step):
        if 0 <= i < len(seq):
            yield seq[i]

不要担心“无”的细节——只需记住，省略开始和/或停止总是正确的做法，以提供整个序列。

首先规范化负索引允许开始和/或停止从结尾独立计数：'abcde'[1:-2]=='abcde'[1:3]=='bc'，尽管范围（1，-2）==[]。标准化有时被认为是“对长度取模”，但注意它只增加了一次长度：例如，“abcde”[-53:42]只是整个字符串。