基本切片技术是定义起点，终点和步长-也称为步幅。

首先，我们将创建一个值列表以用于切片。

创建两个要切片的列表。第一个是从1到9的数字列表（列表A）。第二个也是一个数字列表，从0到9（列表B）：

A = list(range(1, 10, 1)) # Start, stop, and step
B = list(range(9))

print("This is List A:", A)
print("This is List B:", B)

从A索引数字3，从B索引数字6。

print(A[2])
print(B[6])

基本切片

用于切片的扩展索引语法为aList [start：stop：step]。start参数和step参数都默认为none-唯一需要的参数是stop。您是否注意到这类似于使用范围定义列表A和B的方式？这是因为slice对象代表由range（开始，停止，步进）指定的索引集。Python 3.4文档。

如您所见，仅定义stop将返回一个元素。由于开始默认为无，因此这意味着只检索一个元素。

重要的是要注意，第一个元素是索引0，而不是索引1。这就是为什么我们在此练习中使用2个列表的原因。列表A的元素根据顺序位置编号（第一个元素为1，第二个元素为2，依此类推），而列表B的元素为将用于为其编号的数字（第一个元素为[0]，第一个元素为[0]，等等。）。

使用扩展的索引语法，我们检索值的范围。例如，所有值都用冒号检索。

A[:]

要检索元素的子集，需要定义开始位置和停止位置。

给定模式aList [start：stop]，从列表A中检索前两个元素。

如果您认为切片中的负索引令人困惑，这是一种很简单的思考方法：只需将替换为负索引len - index。因此，例如，将-3替换为len(list) - 3。

说明内部切片功能的最佳方法是在实现此操作的代码中显示它：

def slice(list, start = None, end = None, step = 1):
  # Take care of missing start/end parameters
  start = 0 if start is None else start
  end = len(list) if end is None else end

  # Take care of negative start/end parameters
  start = len(list) + start if start < 0 else start
  end = len(list) + end if end < 0 else end

  # Now just execute a for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]

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

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

我的大脑似乎很高兴接受lst[start:end]包含start-th项的内容。我什至可以说这是一个“自然的假设”。

但是偶尔会有一个疑问浮出水面，我的大脑要求确保它不含end-th元素。

在这些时刻，我依靠这个简单的定理：

for any n,    lst = lst[:n] + lst[n:]

这个漂亮的属性告诉我，lst[start:end]它不包含end-th项，因为它在中lst[end:]。

注意，该定理对任何一个n都成立。例如，您可以检查

lst = range(10)
lst[:-42] + lst[-42:] == lst

返回True。

我认为，如果以以下方式（继续阅读）看待它，您将更好地理解和记住Python字符串切片表示法。

让我们使用以下字符串...

azString = "abcdefghijklmnopqrstuvwxyz"

对于那些不知道的人，您可以azString使用符号来创建任何子字符串azString[x:y]

来自其他编程语言的那是常识受到损害的时候。x和y是什么？

在寻求一种记忆技术时，我不得不坐下来并运行几种方案，该技术将帮助我记住x和y是什么，并帮助我在第一次尝试中正确地分割字符串。

我的结论是，x和y应该被视为包围我们要附加的字符串的边界索引。因此，我们应该将表达式视为azString[index1, index2]或什至更清晰azString[index_of_first_character, index_after_the_last_character]。

这是该示例的可视化示例...

Letters   a b c d e f g h i j ...
         ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑
             ┊           ┊
Indexes  0 1 2 3 4 5 6 7 8 9 ...
             ┊           ┊
cdefgh    index1       index2

因此，您要做的就是将index1和index2设置为所需子字符串周围的值。例如，要获取子字符串“ cdefgh”，可以使用azString[2:8]，因为“ c”左侧的索引是2，而在“ h”右侧的索引是8。

请记住，我们正在设定界限。这些边界是您可以放置​​一些括号的位置，这些括号将像这样围绕子字符串...

ab [ cdefgh ] ij

该技巧始终有效，并且易于记忆。

我个人认为它像一个for循环：

a[start:end:step]
# for(i = start; i < end; i += step)

此外，请注意，对于负值start和end相对于所述列表的末尾和上述通过计算在示例given_index + a.shape[0]。

先前的大多数答案都清除了有关切片符号的问题。

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

：

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

As a general rule, writing code with a lot of hardcoded index values leads to a readability and maintenance mess. For example, if you come back to the code a year later, you’ll look at it and wonder what you were thinking when you wrote it. The solution shown is simply a way of more clearly stating what your code is actually doing. In general, the built-in slice() creates a slice object that can be used anywhere a slice is allowed. For example:

>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]
>>> del items[a]
>>> items
[0, 1, 4, 5, 6]

If you have a slice instance s, you can get more information about it by looking at its s.start, s.stop, and s.step attributes, respectively. For example:

>>> a = slice(10, 50, 2)
>>> a.start
10
>>> a.stop
50
>>> a.step
2
>>>

先前的答案没有讨论使用著名的NumPy包可以实现的多维数组切片：

切片也可以应用于多维数组。

# Here, a is a NumPy array

>>> a
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> a[:2, 0:3:2]
array([[1, 3],
       [5, 7]])

的“ :2”逗号在第一维和操作之前，“ 0:3:2”逗号在第二维操作之后。

Index:
      ------------>
  0   1   2   3   4
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
  0  -4  -3  -2  -1
      <------------

Slice:
    <---------------|
|--------------->
:   1   2   3   4   :
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
:  -4  -3  -2  -1   :
|--------------->
    <---------------|

我希望这将帮助您在Python中为列表建模。

参考：http : //wiki.python.org/moin/MovingToPythonFromOtherLanguages

Python切片符号：

a[start:end:step]

• 对于start和end，负值被解释为相对于序列的末尾。
• 正索引用于end表示要包含的最后一个元素之后的位置。
• 空白值的默认设置如下：[+0:-0:1]。
• 使用否定步骤会颠倒对start和的解释。end

该符号扩展到（numpy）个矩阵和多维数组。例如，要切片整个列，可以使用：

m[::,0:2:] ## slice the first two columns

切片包含数组元素的引用，而不是副本。如果要为数组创建单独的副本，可以使用deepcopy()。

这只是一些额外的信息...请考虑以下列表

>>> 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 2.7中

用Python切片

[a:b:c]

len = length of string, tuple or list

c -- default is +1. The sign of c indicates forward or backward, absolute value of c indicates steps. Default is forward with step size 1. Positive means forward, negative means backward.

a --  When c is positive or blank, default is 0. When c is negative, default is -1.

b --  When c is positive or blank, default is len. When c is negative, default is -(len+1).

了解索引分配非常重要。

In forward direction, starts at 0 and ends at len-1

In backward direction, starts at -1 and ends at -len

当您说[a：b：c]时，您要说的是根据c的符号（向前或向后），从a开始并在b结束（不包括位于bth索引处的元素）。使用上面的索引规则，请记住，您只会在此范围内找到元素：

-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1

但是这个范围在两个方向上都可以无限地继续：

...,-len -2 ,-len-1,-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1, len, len +1, len+2 , ....

例如：

             0    1    2   3    4   5   6   7   8   9   10   11
             a    s    t   r    i   n   g
    -9  -8  -7   -6   -5  -4   -3  -2  -1

如果您对a，b和c的选择允许您在上方使用a，b，c的规则遍历时与上述范围重叠，则您将获得一个包含元素的列表（遍历过程中触碰过）或一个空列表。

最后一件事：如果a和b相等，那么您还会得到一个空列表：

>>> l1
[2, 3, 4]

>>> l1[:]
[2, 3, 4]

>>> l1[::-1] # a default is -1 , b default is -(len+1)
[4, 3, 2]

>>> l1[:-4:-1] # a default is -1
[4, 3, 2]

>>> l1[:-3:-1] # a default is -1
[4, 3]

>>> l1[::] # c default is +1, so a default is 0, b default is len
[2, 3, 4]

>>> l1[::-1] # c is -1 , so a default is -1 and b default is -(len+1)
[4, 3, 2]


>>> l1[-100:-200:-1] # Interesting
[]

>>> l1[-1:-200:-1] # Interesting
[4, 3, 2]


>>> l1[-1:-1:1]
[]


>>> l1[-1:5:1] # Interesting
[4]


>>> l1[1:-7:1]
[]

>>> l1[1:-7:-1] # Interesting
[3, 2]

>>> l1[:-2:-2] # a default is -1, stop(b) at -2 , step(c) by 2 in reverse direction
[4]

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

mylist[X:Y]

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

真的很简单：

a[start:stop]  # items start through stop-1
a[start:]      # items start through the rest of the array
a[:stop]       # items from the beginning through stop-1
a[:]           # a copy of the whole array

还有一个step值，可以与以上任何一种一起使用：

a[start:stop:step] # start through not past stop, by step

要记住的关键点是该:stop值表示不在所选切片中的第一个值。所以，之间的差stop和start是选择的元素的数量（如果step是1，默认值）。

另一个功能是start或stop可能是负数，这意味着它从数组的末尾而不是开头开始计数。所以：

a[-1]    # last item in the array
a[-2:]   # last two items in the array
a[:-2]   # everything except the last two items

同样，step可能为负数：

a[::-1]    # all items in the array, reversed
a[1::-1]   # the first two items, reversed
a[:-3:-1]  # the last two items, reversed
a[-3::-1]  # everything except the last two items, reversed

如果项目数量少于您的要求，Python对程序员很友好。例如，如果您要求a[:-2]并且a仅包含一个元素，则会得到一个空列表，而不是一个错误。有时您会更喜欢该错误，因此您必须意识到这种情况可能会发生。

Relation to slice() object

The slicing operator [] is actually being used in the above code with a slice() object using the : notation (which is only valid within []), i.e.:

a[start:stop:step]

is equivalent to:

a[slice(start, stop, step)]

Slice objects also behave slightly differently depending on the number of arguments, similarly to range(), i.e. both slice(stop) and slice(start, stop[, step]) are supported. To skip specifying a given argument, one might use None, so that e.g. a[start:] is equivalent to a[slice(start, None)] or a[::-1] is equivalent to a[slice(None, None, -1)].

While the :-based notation is very helpful for simple slicing, the explicit use of slice() objects simplifies the programmatic generation of slicing.

在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)

使用了一点之后，我意识到最简单的描述是它与for循环中的参数完全相同...

(from:to:step)

它们都是可选的：

(:to:step)
(from::step)
(from:to)

然后，负索引只需要您将字符串的长度添加到负索引即可理解。

无论如何这对我有用...

在Python的教程谈论它（稍微向下滚动，直到你得到关于切片的部分）。

ASCII艺术图也有助于记住切片的工作方式：

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

记住分片工作方式的一种方法是将索引视为指向字符之间的指针，第一个字符的左边缘编号为0。然后，一串n个字符的最后一个字符的右侧边缘具有索引n。

当我第一次看到切片语法时，有几件事对我来说并不立即显而易见：

>>> x = [1,2,3,4,5,6]
>>> x[::-1]
[6,5,4,3,2,1]

反转序列的简单方法！

如果出于某种原因，您想要按相反的顺序进行第二个项目：

>>> x = [1,2,3,4,5,6]
>>> x[::-2]
[6,4,2]