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

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

以下是字符串索引的示例：

 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

str="Name string"

切片示例：[开始：结束：步骤]

str[start:end] # Items start through end-1
str[start:]    # Items start through the rest of the array
str[:end]      # Items from the beginning through end-1
str[:]         # A copy of the whole array

以下是示例用法：

print str[0] = N
print str[0:2] = Na
print str[0:7] = Name st
print str[0:7:2] = Nm t
print str[0:-1:2] = Nm ti

如果我们可以将切片与范围联系起来，这很容易理解，因为范围给出了索引。我们可以将切片分为以下两类：

---

1.无台阶或台阶>0。例如，[i:j]或[i:j:k]（k>0）

假设序列为s=[1,2,3,4,5]。

如果0<i<len（s）和0<j<len，则[i:j:k]->范围（i，j，k）

例如，[0:3:2]->范围（0,3,2）->0，2

如果i>len或j>len，则i=len或j=len

例如，[0:100:2]->范围（0，len（s），2）->范围（0,5,2）->0，2，4

如果i＜0或j＜0，则i＝max（0，len（s）+i）或j＝max

例如，[0:-3:2]->范围（0，len（s）-3,2）->范围（0,2,2）->0

例如，[0:-1:2]->范围（0，len（s）-1,2）->范围（0,4,2）->0，2

如果未指定i，则i=0

例如，[：4:2]->范围（0,4,2）->范围（4,2）->0，2

如果未指定j，则j=len（s）

例如，[0:：2]->范围（0，len（s），2）->范围（0,5,2）->0，2，4

---

2.步骤<0。例如，[i:j:k]（k<0）

假设序列为s=[1,2,3,4,5]。

如果0<i<len（s）和0<j<len，则[i:j:k]->范围（i，j，k）

例如，[5:0:-2]->范围（5,0，-2）->5，3，1

如果i>len或j>len，则i=len（s）-1或j=len（s）-1

例如，[100:0:-2]->范围（len（s）-1,0，-2）->范围（4,0，-2）->4，2

如果i＜0或j＜0，则i＝max（-1，len（s）+i）或j＝max（-1len（s）+j）

例如，[-2:-10:-2]->range（len（s）-2，-1，-2）->range（3，-1，-1）->3，1

如果未指定i，则i=len（s）-1

例如，[：0:-2]->范围（len（s）-1,0，-2）->范围（4,0，-2）->4，2

如果未指定j，则j=-1

例如，[2:：-2]->范围（2，-1，-2）->2，0

例如，[：：-1]->range（len（s）-1，-1，-1）->range（4，-1，1）->4，3，2，1，0

---

总而言之

关于序列的索引，需要记住的重要思想是

非负指数从序列中的第一项开始；负索引从序列的最后一项开始（因此仅适用于有限序列）。

换言之，负索引右移序列长度：

              0   1   2   3   4   5   6   7   ...
            -------------------------
            | a | b | c | d | e | f |
            -------------------------
...  -8  -7  -6  -5  -4  -3  -2  -1

考虑到这一点，订阅和切片很简单。

订阅

订阅使用以下语法：*

sequence[index]

订阅在索引处选择序列中的单个项目：

>>> 'abcdef'[0]
'a'
>>> 'abcdef'[-6]
'a'

订阅引发超出范围的索引的IndexError：

>>> 'abcdef'[100]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

切片

切片使用以下语法：**

sequence[start:stop:step]

切片选择序列中的一系列项目，从包含开始到不包含结束：

>>> 'abcdef'[0:2:1]
'ab'
>>> 'abcdef'[0:-4:1]
'ab'
>>> 'abcdef'[-6:-4:1]
'ab'
>>> 'abcdef'[-6:2:1]
'ab'
>>> 'abcdef'[1:-7:-1]
'ba'
>>> 'abcdef'[-5:-7:-1]
'ba'

切片默认为序列中最完整的项目范围，因此它对省略或等于“无”的任何开始、停止或步骤使用以下默认值：***

步骤默认为1；如果步骤为正start默认为0（第一项索引），stop默认为start+len（序列）（最后一项索引加一）；如果步骤为负start默认为-1（最后一项索引），stop默认为start-len（序列）（第一项索引减一）。

>>> 'abcdef'[0:6:1]
'abcdef'
>>> 'abcdef'[::]
'abcdef'
>>> 'abcdef'[-1:-7:-1]
'fedcba'
>>> 'abcdef'[::-1]
'fedcba'

切片为等于零的步骤引发ValueError：

>>> 'abcdef'[::0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: slice step cannot be zero

切片不会为超出范围的开始或停止引发IndexError（与订阅相反）：

>>> 'abcdef'[-100:100]
'abcdef'

---

*表达式sequence[index]和sequence__getitem_（索引）是等效的。

**表达式sequence[start:stop:step]、sequence[Sslice（start，stop，step）]和sequence__getitem_（slice（start，stop，step））是等效的，其中内置类slice实例包start，stop和step。

***表达式sequence[：]、sequence[：：]和sequence[None:None:None]使用start、stop和step的默认值。

我自己使用“元素之间的索引点”方法来思考它，但描述它的一种方式有时有助于其他人获得它：

mylist[X:Y]

X是所需的第一个元素的索引。Y是不需要的第一个元素的索引。

在找到这张很棒的桌子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)