了解Python的切片符号
我需要一个很好的解释（引用是加号）Python的切片符号。
对我来说，这个符号需要一点点的提高。
它看起来非常强大，但我还没有把我的脑袋。
这真的很简单：
a[start:end] # items start through end-1 a[start:] # items start through the rest of the array a[:end] # items from the beginning through end-1 a[:] # a copy of the whole array 也有step值，可以用于以上任何一个：
a[start:end:step] # start through not past end, by step
要记住的关键点是:end值代表不在所选切片中的第一个值。 所以， end和start的差异是select的元素的数量（如果step是1，则是默认值）。
另一个特点是start或end可能是一个负数 ，这意味着它从数组的末尾开始而不是开始。 所以：
a[-1] # last item in the array a[-2:] # last two items in the array a[:-2] # everything except the last two items
如果项目比你想要的要less，那么Python对程序员来说是仁慈的。 例如，如果你要求a[:-2]而且只包含一个元素，你会得到一个空列表而不是错误。 有时你会喜欢这个错误，所以你必须意识到这可能会发生。
Python教程会谈到它（向下滚动，直到看到关于切片的部分）。
ASCII艺术图也有助于记忆切片如何工作：
+---+---+---+---+---+---+ | P | y | t | h | o | n | +---+---+---+---+---+---+ 0 1 2 3 4 5 6 -6 -5 -4 -3 -2 -1
记住切片如何工作的一种方式是将索引视为指向字符之间的指针，其中第一个字符的左边缘编号为0.然后， n个string的最后一个字符的右边缘具有索引n 。
列举语法所允许的可能性：
>>> seq[:] # [seq[0], seq[1], ..., seq[-1] ] >>> seq[low:] # [seq[low], seq[low+1], ..., seq[-1] ] >>> seq[:high] # [seq[0], seq[1], ..., seq[high-1]] >>> seq[low:high] # [seq[low], seq[low+1], ..., seq[high-1]] >>> seq[::stride] # [seq[0], seq[stride], ..., seq[-1] ] >>> seq[low::stride] # [seq[low], seq[low+stride], ..., seq[-1] ] >>> seq[:high:stride] # [seq[0], seq[stride], ..., seq[high-1]] >>> seq[low:high:stride] # [seq[low], seq[low+stride], ..., seq[high-1]]
当然，如果(high-low)%stride != 0 ，则终点将比high-1稍低。
如果stride是负数，sorting会有所改变，因为我们正在倒计时：
>>> seq[::-stride] # [seq[-1], seq[-1-stride], ..., seq[0] ] >>> seq[high::-stride] # [seq[high], seq[high-stride], ..., seq[0] ] >>> seq[:low:-stride] # [seq[-1], seq[-1-stride], ..., seq[low+1]] >>> seq[high:low:-stride] # [seq[high], seq[high-stride], ..., seq[low+1]]
扩展切片（带有逗号和省略号）大多数只使用特殊的数据结构（如Numpy）。 基本的序列不支持它们。
>>> class slicee: ... def __getitem__(self, item): ... return `item` ... >>> slicee()[0, 1:2, ::5, ...] '(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'
上面的答案不讨论片分配：
>>> r=[1,2,3,4] >>> r[1:1] [] >>> r[1:1]=[9,8] >>> r [1, 9, 8, 2, 3, 4] >>> r[1:1]=['blah'] >>> r [1, 'blah', 9, 8, 2, 3, 4]
这也可以阐明切片和索引之间的区别。
解释Python的切片符号
简而言之，下标符号（ subscriptable[subscriptarg] ）中的冒号（：）使切片符号 – 具有可选参数start ， stop ， step ：
sliceable[start:stop:step]
Python切片是有条不紊地访问部分数据的计算快速方法。 在我看来，即使是一个中级的Python程序员，这也是需要熟悉的语言的一个方面。
重要的定义
首先，我们定义一些术语：
start：切片的起始索引，它将包含此索引处的元素，除非它与stop相同，默认为0，即第一个索引。 如果是负数，则意味着从最后开始
n项。停止：切片的结束索引，它不包含此索引处的元素，默认为切片序列的长度，即直到包括结束。
步骤：索引增加的数量，默认为1.如果是负数，则反过来切片迭代。
如何索引工作
你可以使任何这些正面或负面的数字。 正数的含义是直接的，但对于负数，就像Python中的索引一样，从开始和结束的倒数开始计算 ，而对于这个步骤 ，只需要减less索引。 这个例子来自文档的教程 ，但是我稍微修改了它，以指示序列中每个索引引用的哪个项目：
+---+---+---+---+---+---+ | P | y | t | h | o | n | +---+---+---+---+---+---+ 0 1 2 3 4 5 -6 -5 -4 -3 -2 -1
如何切片工作
要使用切片符号和支持该切片的序列，必须在顺序括号中包含至less一个冒号（ 根据Python数据模型实际实现序列的__getitem__方法 ）。
切片符号的工作原理是这样的：
sequence[start:stop:step]
回想一下，有开始 ， 停止 ，和步骤的默认值，所以要访问默认值，只需省略参数。
切片符号从列表（或任何其他支持它的序列，如string）中获取最后九个元素将如下所示：
my_list[-9:]
当我看到这个时候，我把括号内的这个部分看成是“从头到尾九点”。 （实际上，我把它缩写为“-9，on”）
说明：
完整的符号是
my_list[-9:None:None]
并replace默认值（实际上，当step是否定的时候， stop的默认值是-len(my_list) - 1 ，所以None停止的意思就意味着它到达最后一步所需的地方）：
my_list[-9:len(my_list):1]
冒号 :是告诉Python你给它一个分片，而不是一个普通的索引。 这就是为什么在Python 2中创build列表的简单拷贝的习惯方式
list_copy = sequence[:]
清理它们是：
del my_list[:]
（Python 3获取list.copy和list.clear方法。）
给你的切片一个描述性的名字！
您可能会发现分割形成切片以将其传递给list.__getitem__方法（ 这就是方括号所做的 ）是有用的。 即使你并不陌生，它也会使你的代码更具可读性，这样其他可能需要阅读代码的人才能更容易地理解你在做什么。
但是，您不能只将一些用冒号分隔的整数分配给一个variables。 您需要使用切片对象：
last_nine_slice = slice(-9, None)
第二个参数None是必需的，所以第一个参数被解释为start参数， 否则就是stop参数 。
然后，您可以将切片对象传递给您的序列：
>>> list(range(100))[last_nine_slice] [91, 92, 93, 94, 95, 96, 97, 98, 99]
内存注意事项：
由于Python列表的片段在内存中创build了新的对象，另一个需要注意的重要函数是itertools.islice 。 通常情况下，您需要遍历一个切片，而不仅仅是在内存中静态创build。 islice是完美的。 一个告诫，它不支持start ， stop或step否定论据，所以如果这是一个问题，你可能需要计算指标或提前扭转迭代。
>>> length = 100 >>> last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1) >>> list_last_nine = list(last_nine) >>> list_last_nine [91, 92, 93, 94, 95, 96, 97, 98, 99]
列表切片制作副本的事实是列表本身的一个特征。 如果您像Pandas DataFrame一样切割高级对象，则可能会返回原始视图，而不是副本。
当我第一次看到切片语法时，有一些事情对我来说并不明显：
>>> 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]
在http://wiki.python.org/moin/MovingToPythonFromOtherLanguagesfind这个伟大的表;
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)
在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结束（不包括第b个索引处的元素）。 使用上面的索引规则，记住你只能find这个范围内的元素：
-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 astring -9 -8 -7 -6 -5 -4 -3 -2 -1
如果你select的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]
使用它之后，我意识到最简单的描述就是它和for循环中的参数完全一样。
(from:to:step)
其中任何一个都是可选的
(:to:step) (from::step) (from:to)
那么负面的索引只是需要你把string的长度加到负面的索引来理解它。
无论如何，这对我来说是有效的
我发现记住它是如何工作的更容易，然后我可以找出任何特定的开始/停止/步骤组合。
首先理解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
从start ，逐步递增，不要stop 。 很简单。
关于负面的步骤要记住的是stop总是排除的结束，无论是更高还是更低。 如果你想以相反的顺序进行同样的切片，那么单独进行反转就会更清晰：例如'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]
不要担心is None细节 – 只要记住，省略start和/或stop总是做正确的事情给你整个序列。
规范化负向指标首先允许独立开始和/或停止从末端开始计算： 'abcde'[1:-2] == 'abcde'[1:3] == 'bc'尽piperange(1,-2) == [] 。 标准化有时被认为是“模数的长度”，但注意它只增加一次的长度：例如'abcde'[-53:42]就是整个string。
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中build立列表。
参考： http : //wiki.python.org/moin/MovingToPythonFromOtherLanguages
Python切片符号：
a[start:end:step]
- 对于
start和end，负值被解释为相对于序列的结尾。 -
end正指数表示最后一个元素被包括之后的位置。 - 空白值默认如下：
[+0:-0:1]。 - 使用负面的步骤反转
start和end的解释
符号扩展到（numpy）matrix和multidimensional array。 例如，要切割整个列，您可以使用：
m[::,0:2:] ## slice the first two columns
切片保存数组元素的引用，而不是副本。 如果你想单独复制一个数组，你可以使用deepcopy() 。
我自己用“元素之间的一个索引点”的方法来思考，但有时帮助别人得到它的一种描述方式是：
mylist[X:Y]
X是你想要的第一个元素的索引。
Y是你不想要的第一个元素的索引。
这只是一些额外的信息…考虑下面的列表
>>> l=[12,23,345,456,67,7,945,467]
很less有其他的技巧来扭转名单：
>>> 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]
请参阅abc上面的答案
您还可以使用切片分配从列表中删除一个或多个元素：
r = [1, 'blah', 9, 8, 2, 3, 4] >>> r[1:4] = [] >>> r [1, 2, 3, 4]
这是我如何教给新手的切片：
了解索引和切片之间的区别：
Wiki有这个惊人的图片，清晰地区分索引和切片。
这是一个包含6个元素的列表。 要更好地理解切片，请将该列表视为一组放在一起的六个框。 每个盒子里面都有一个字母表。
索引就像处理盒子的内容一样。 你可以检查任何框的内容。 但是你不能一次检查多个盒子的内容。 你甚至可以更换盒子的内容。 但是你不能把2个球放在1个盒子里，或者每次换2个球。
In [122]: alpha = ['a', 'b', 'c', 'd', 'e', 'f'] In [123]: alpha Out[123]: ['a', 'b', 'c', 'd', 'e', 'f'] In [124]: alpha[0] Out[124]: 'a' In [127]: alpha[0] = 'A' In [128]: alpha Out[128]: ['A', 'b', 'c', 'd', 'e', 'f'] In [129]: alpha[0,1] --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-129-c7eb16585371> in <module>() ----> 1 alpha[0,1] TypeError: list indices must be integers, not tuple
切片就像处理盒子本身。 你可以拿起第一个盒子放在另一个桌子上。 要拾取盒子所有你需要知道的是盒子的开始和结束的位置。
你甚至可以在1和4之间拾取前3个盒子或后2个盒子或所有盒子。所以，如果你知道开始和结束，你可以select任何一组盒子。 这个职位被称为开始和停止职位。
有趣的是，你可以一次replace多个盒子。 你也可以把多个盒子放在你喜欢的地方。
In [130]: alpha[0:1] Out[130]: ['A'] In [131]: alpha[0:1] = 'a' In [132]: alpha Out[132]: ['a', 'b', 'c', 'd', 'e', 'f'] In [133]: alpha[0:2] = ['A', 'B'] In [134]: alpha Out[134]: ['A', 'B', 'c', 'd', 'e', 'f'] In [135]: alpha[2:2] = ['x', 'xx'] In [136]: alpha Out[136]: ['A', 'B', 'x', 'xx', 'c', 'd', 'e', 'f']
切片步骤：
直到现在你已经连续select了盒子。 但是有些时候你需要分立拾取。 例如，你可以拾取每隔一个箱子。 你甚至可以从最后拿起第三个盒子。 这个值被称为步长。 这代表你的连续皮卡之间的差距。 如果您从头到尾select框，则步长应为正数，反之亦然。
In [137]: alpha = ['a', 'b', 'c', 'd', 'e', 'f'] In [142]: alpha[1:5:2] Out[142]: ['b', 'd'] In [143]: alpha[-1:-5:-2] Out[143]: ['f', 'd'] In [144]: alpha[1:5:-2] Out[144]: [] In [145]: alpha[-1:-5:2] Out[145]: []
Python如何算出缺less的参数：
切片时，如果您遗漏了任何参数，Python会自动找出它。
如果您检查CPython的源代码，您将会find一个名为PySlice_GetIndicesEx的函数，它可以计算出任何给定参数的切片索引。 这是Python中的逻辑等效代码。
此函数采用Python对象和可选参数进行切片，并返回所请求切片的开始，停止，步长和切片长度。
def py_slice_get_indices_ex(obj, start=None, stop=None, step=None): length = len(obj) if step is None: step = 1 if step == 0: raise Exception("Step cannot be zero.") if start is None: start = 0 if step > 0 else length - 1 else: if start < 0: start += length if start < 0: start = 0 if step > 0 else -1 if start >= length: start = length if step > 0 else length - 1 if stop is None: stop = length if step > 0 else -1 else: if stop < 0: stop += length if stop < 0: stop = 0 if step > 0 else -1 if stop >= length: stop = length if step > 0 else length - 1 if (step < 0 and stop >= start) or (step > 0 and start >= stop): slice_length = 0 elif step < 0: slice_length = (stop - start + 1)/(step) + 1 else: slice_length = (stop - start - 1)/(step) + 1 return (start, stop, step, slice_length)
这是切片后面的智力。 由于Python内置了称为slice的函数，因此可以传递一些参数并检查它是如何巧妙地计算缺less的参数的。
In [21]: alpha = ['a', 'b', 'c', 'd', 'e', 'f'] In [22]: s = slice(None, None, None) In [23]: s Out[23]: slice(None, None, None) In [24]: s.indices(len(alpha)) Out[24]: (0, 6, 1) In [25]: range(*s.indices(len(alpha))) Out[25]: [0, 1, 2, 3, 4, 5] In [26]: s = slice(None, None, -1) In [27]: range(*s.indices(len(alpha))) Out[27]: [5, 4, 3, 2, 1, 0] In [28]: s = slice(None, 3, -1) In [29]: range(*s.indices(len(alpha))) Out[29]: [5, 4]
注意：这篇文章最初写在我的博客http://www.avilpage.com/2015/03/a-slice-of-python-intelligence-behind.html
作为一般规则，编写具有大量硬编码索引值的代码会导致可读性和维护混乱。 例如，如果一年后你回到代码中，你会看到它，并想知道你在编写代码时的想法。 显示的解决scheme只是一种更清楚地说明你的代码实际上在做什么的方法。 通常，内置的slice（）会创build一个可以在切片允许的任何位置使用的切片对象。 例如：
>>> 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]
如果你有一个slice实例s，你可以分别查看它的s.start，s.stop和s.step属性来获得更多关于它的信息。 例如：
>>> a = slice(10, 50, 2) >>> a.start 10 >>> a.stop 50 >>> a.step 2 >>>
1.切片符号
为了简单起见，切记切片只有一种forms：
s[start:end:step]
这是它是如何工作的：
-
s：可以切片的物体 -
start：第一个索引开始迭代 -
end：最后一个索引， 注意end索引不会包含在结果片中 -
step：拾取元素的每step索引
另一个重要的事情是： 所有的start ， end ， step都可以省略！ 如果省略，则默认值为： 0 ， len(s) ， 1 。
所以可能的变化是：
# mostly used variations s[start:end] s[start:] s[:end] # step related variations s[:end:step] s[start::step] s[::step] # make a copy s[:]
注意：如果start>=end （只考虑step>0 ），python将返回一个空片段[] 。
2.陷阱
以上部分解释了如何切片的核心function，它将在大多数情况下工作。 然而，你应该注意一些问题，这部分解释了它们。
负面指标
混淆Python学习者的第一件事就是该索引可能是负面的！ 不要惊慌： 负指数意味着倒退。
例如：
s[-5:] # start at the 5th index from the end of array, # thus returns the last 5 elements s[:-5] # start at index 0, end until the 5th index from end of array, # thus returns s[0:len(s)-5]
消极的一步
让事情更混乱的是，这step可以是负面的！
否定步骤意味着向后迭代数组：从结尾到开始，包含结束索引，并从结果中排除开始索引。
注意 ：当步骤为负时， start为len(s)的默认值（while end不等于0 ，因为s[::-1]包含s[0] ）。 例如：
s[::-1] # reversed slice s[len(s)::-1] # same as above, reversed slice s[0:len(s):-1] # empty list
超出范围的错误？
感到惊讶： 当索引超出范围时，切片不会引起IndexError！
如果索引超出范围，python会尽量根据情况将索引设置为0或len(s) 。 例如：
s[:len(s)+5] # same as s[:len(s)] s[-len(s)-5::] # same as s[0:] s[len(s)+5::-1] # same as s[len(s)::-1], same as s[::-1]
3.例子
让我们用完整的例子来解释我们所讨论的一切：
# create our array for demonstration In [1]: s = [i for i in range(10)] In [2]: s Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] In [3]: s[2:] # from index 2 to last index Out[3]: [2, 3, 4, 5, 6, 7, 8, 9] In [4]: s[:8] # from index 0 up to index 8 Out[4]: [0, 1, 2, 3, 4, 5, 6, 7] In [5]: s[4:7] # from index 4(included) up to index 7(excluded) Out[5]: [4, 5, 6] In [6]: s[:-2] # up to second last index(negative index) Out[6]: [0, 1, 2, 3, 4, 5, 6, 7] In [7]: s[-2:] # from second last index(negative index) Out[7]: [8, 9] In [8]: s[::-1] # from last to first in reverse order(negative step) Out[8]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] In [9]: s[::-2] # all odd numbers in reversed order Out[9]: [9, 7, 5, 3, 1] In [11]: s[-2::-2] # all even numbers in reversed order Out[11]: [8, 6, 4, 2, 0] In [12]: s[3:15] # end is out of range, python will set it to len(s) Out[12]: [3, 4, 5, 6, 7, 8, 9] In [14]: s[5:1] # start > end, return empty list Out[14]: [] In [15]: s[11] # access index 11(greater than len(s)) will raise IndexError --------------------------------------------------------------------------- IndexError Traceback (most recent call last) <ipython-input-15-79ffc22473a3> in <module>() ----> 1 s[11] IndexError: list index out of range
我的大脑似乎很高兴接受， lst[start:end]包含start项。 我甚至可以说这是一个“自然的假设”。
但偶尔有一个怀疑悄悄进入，我的大脑要求保证它不包含end元素。
在这些时刻，我依靠这个简单的定理：
for any n, lst = lst[:n] + lst[n:]
这个漂亮的属性告诉我， lst[start:end]不包含end一项，因为它在lst[end:] 。
请注意，这个定理对于任何n都是正确的。 例如，你可以检查
lst = range(10) lst[:-42] + lst[-42:] == lst
返回True 。
上面的答案不讨论可能使用着名的numpy包的multidimensional array切片：
切片也适用于multidimensional 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”。
为了得到一个可迭代的部分（如列表），下面是一个例子：
variable[number1:number2]
在这个例子中，数字1的正数是你从前面拿走了多less个组件。 一个负数是完全相反的，你从底到尾保留多less。 数字2的正数表示您打算从一开始就保留多less个组件，而负数是您打算从最后起飞的数量。 这有点违反直觉，但是假设列表切片是非常有用的。
#!/usr/bin/env python def slicegraphical(s, lista): if len(s) > 9: print """Enter a string of maximum 9 characters, so the printig would looki nice""" return 0; # print " ", print ' '+'+---' * len(s) +'+' print ' ', for letter in s: print '| {}'.format(letter), print '|' print " ",; print '+---' * len(s) +'+' print " ", for letter in range(len(s) +1): print '{} '.format(letter), print "" for letter in range(-1*(len(s)), 0): print ' {}'.format(letter), print '' print '' for triada in lista: if len(triada) == 3: if triada[0]==None and triada[1] == None and triada[2] == None: # 000 print s+'[ : : ]' +' = ', s[triada[0]:triada[1]:triada[2]] elif triada[0] == None and triada[1] == None and triada[2] != None: # 001 print s+'[ : :{0:2d} ]'.format(triada[2], '','') +' = ', s[triada[0]:triada[1]:triada[2]] elif triada[0] == None and triada[1] != None and triada[2] == None: # 010 print s+'[ :{0:2d} : ]'.format(triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]] elif triada[0] == None and triada[1] != None and triada[2] != None: # 011 print s+'[ :{0:2d} :{1:2d} ]'.format(triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]] elif triada[0] != None and triada[1] == None and triada[2] == None: # 100 print s+'[{0:2d} : : ]'.format(triada[0]) +' = ', s[triada[0]:triada[1]:triada[2]] elif triada[0] != None and triada[1] == None and triada[2] != None: # 101 print s+'[{0:2d} : :{1:2d} ]'.format(triada[0], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]] elif triada[0] != None and triada[1] != None and triada[2] == None: # 110 print s+'[{0:2d} :{1:2d} : ]'.format(triada[0], triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]] elif triada[0] != None and triada[1] != None and triada[2] != None: # 111 print s+'[{0:2d} :{1:2d} :{2:2d} ]'.format(triada[0], triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]] elif len(triada) == 2: if triada[0] == None and triada[1] == None: # 00 print s+'[ : ] ' + ' = ', s[triada[0]:triada[1]] elif triada[0] == None and triada[1] != None: # 01 print s+'[ :{0:2d} ] '.format(triada[1]) + ' = ', s[triada[0]:triada[1]] elif triada[0] != None and triada[1] == None: # 10 print s+'[{0:2d} : ] '.format(triada[0]) + ' = ', s[triada[0]:triada[1]] elif triada[0] != None and triada[1] != None: # 11 print s+'[{0:2d} :{1:2d} ] '.format(triada[0],triada[1]) + ' = ', s[triada[0]:triada[1]] elif len(triada) == 1: print s+'[{0:2d} ] '.format(triada[0]) + ' = ', s[triada[0]] if __name__ == '__main__': # Change "s" to what ever string you like, make it 9 characters for # better representation. s = 'COMPUTERS' # add to this list different lists to experement with indexes # to represent ex. s[::], use s[None, None,None], otherwise you get an error # for s[2:] use s[2:None] lista = [[4,7],[2,5,2],[-5,1,-1],[4],[-4,-6,-1], [2,-3,1],[2,-3,-1], [None,None,-1],[-5,None],[-5,0,-1],[-5,None,-1],[-1,1,-2]] slicegraphical(s, lista)
你可以运行这个脚本并进行实验，下面是我从脚本中获得的一些示例。
+---+---+---+---+---+---+---+---+---+ | C | O | M | P | U | T | E | R | S | +---+---+---+---+---+---+---+---+---+ 0 1 2 3 4 5 6 7 8 9 -9 -8 -7 -6 -5 -4 -3 -2 -1 COMPUTERS[ 4 : 7 ] = UTE COMPUTERS[ 2 : 5 : 2 ] = MU COMPUTERS[-5 : 1 :-1 ] = UPM COMPUTERS[ 4 ] = U COMPUTERS[-4 :-6 :-1 ] = TU COMPUTERS[ 2 :-3 : 1 ] = MPUT COMPUTERS[ 2 :-3 :-1 ] = COMPUTERS[ : :-1 ] = SRETUPMOC COMPUTERS[-5 : ] = UTERS COMPUTERS[-5 : 0 :-1 ] = UPMO COMPUTERS[-5 : :-1 ] = UPMOC COMPUTERS[-1 : 1 :-2 ] = SEUM [Finished in 0.9s]
使用负面步骤时，请注意答案右移1。
在Python中，最基本的切片forms如下：
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]
When slicing from start, you can omit the zero index, and when slicing to the end, you can omit the final index since it is redundant, so do not be verbose:
In [5]: l[:3] == l[0:3] Out[5]: True In [6]: l[7:] == l[7:len(l)] Out[6]: True
Negative integers are useful when doing offsets relative to the end of a collection:
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 3 elements Out[8]: [7, 8, 9]
It is possible to provide indices that are out of bounds when slicing such as:
In [9]: l[:20] # 20 is out of index bounds, 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, l[-20] will raise an IndexError exception Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Keep in mind that the result of slicing a collection is a whole new collection. In addition, when using slice notation in assignments, the length of the slice assignment do not need to be the same. The values before and after the assigned slice will be kept, and the collection will shrink or grow to contain the new values:
In [16]: l[2:6] = list('abc') # assigning less 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]
If you omit the start and end index, you will make a copy of the collection:
In [14]: l_copy = l[:] In [15]: l == l_copy and l is not l_copy Out[15]: True
If the start and end indexes are omitted when performing an assignment operation, the entire content of the collection will be replaced with a copy of what is referenced:
In [20]: l[:] = list('hello...') In [21]: l Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']
Besides basic slicing, it is also possible to apply the following notation:
l[start:end:step]
where l is a collection, start is an inclusive index, end is an exclusive index, and step is a stride that can be used to take every nth item in l .
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]
Using step provides a useful trick to reverse a collection in Python:
In [25]: l[::-1] Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
It is also possible to use negative integers for step as the following example:
In[28]: l[::-2] Out[28]: [9, 7, 5, 3, 1]
However, using a negative value for step could become very confusing. Moreover, in order to be Pythonic, you should avoid using start , end , and step in a single slice. In case this is required, consider doing this in two assignments (one to slice, and the other to stride).
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]
The below is the example of index of a string
+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1 str="Name string"
slicing example: [start:end:step]
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
Below is the example usage
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
Most of the above answers clears about Slice notation. Extended indexing syntax used for slicing is aList[start:stop:step] basic examples are
：
More Slicing examples: 15 Extended Slices
