Python的切片表示法是如何工作的？也就是说：当我编写[x:y:z]、a[：]、a]：：2]等代码时，我如何理解哪些元素最终会出现在切片中？请在适当的地方附上参考资料。
另请参见：为什么切片和范围上限是互斥的？
当前回答
如果我们可以将切片与范围联系起来，这很容易理解，因为范围给出了索引。我们可以将切片分为以下两类：
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
总而言之
其他回答
这是我教新手切片的方法：
理解索引和切片之间的区别：
WikiPython有一幅惊人的图片，它清楚地区分了索引和切片。
这是一个包含六个元素的列表。为了更好地理解切片，请将该列表视为一组放在一起的六个框。每个盒子里都有一个字母表。
索引就像处理盒子的内容。您可以检查任何框的内容。但是你不能同时检查多个盒子的内容。你甚至可以替换盒子里的东西。但你不能在一个盒子里放两个球，也不能一次换两个球。
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之间的所有框。所以，如果你知道开始和结束，你可以选择任何一组框。这些位置称为开始和停止位置。
有趣的是，您可以同时替换多个框。此外，您可以在任何地方放置多个盒子。
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']
切片步骤：
到目前为止，您已连续拾取箱子。但有时你需要单独拾取。例如，您可以每隔一秒钟拾取一个盒子。你甚至可以从最后每隔三个盒子取一个。该值称为步长。这代表了您连续拾取之间的差距。如果您从开始到结束拾取框，则步长应为正值，反之亦然。
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如何找出缺少的参数：
切片时，如果忽略了任何参数，Python会尝试自动计算。
如果您检查CPython的源代码，您会发现一个名为PySlice_GetIndices Ex（）的函数，它计算出任何给定参数的切片索引。下面是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的内置函数，您可以传递一些参数，并检查它如何巧妙地计算缺少的参数。
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]
注：这篇文章最初写在我的博客《Python切片背后的智能》中。
使用一点后，我意识到最简单的描述是它与for循环中的参数完全相同。。。
(from:to:step)
其中任何一项都是可选的：
(:to:step)
(from::step)
(from:to)
然后，负索引只需要将字符串的长度添加到负索引中即可理解它。
不管怎样，这对我来说都很有效。。。
枚举序列x语法允许的可能性：
>>> x[:] # [x[0], x[1], ..., x[-1] ]
>>> x[low:] # [x[low], x[low+1], ..., x[-1] ]
>>> x[:high] # [x[0], x[1], ..., x[high-1]]
>>> x[low:high] # [x[low], x[low+1], ..., x[high-1]]
>>> x[::stride] # [x[0], x[stride], ..., x[-1] ]
>>> x[low::stride] # [x[low], x[low+stride], ..., x[-1] ]
>>> x[:high:stride] # [x[0], x[stride], ..., x[high-1]]
>>> x[low:high:stride] # [x[low], x[low+stride], ..., x[high-1]]
当然，如果（高低）%步幅！=0，则终点将略低于高1。
如果步幅为负，则由于我们正在倒计时，顺序会有点改变：
>>> x[::-stride] # [x[-1], x[-1-stride], ..., x[0] ]
>>> x[high::-stride] # [x[high], x[high-stride], ..., x[0] ]
>>> x[:low:-stride] # [x[-1], x[-1-stride], ..., x[low+1]]
>>> x[high:low:-stride] # [x[high], x[high-stride], ..., x[low+1]]
扩展切片（带逗号和省略号）通常仅用于特殊数据结构（如NumPy）；基本序列不支持它们。
>>> class slicee:
... def __getitem__(self, item):
... return repr(item)
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'
如果我们可以将切片与范围联系起来，这很容易理解，因为范围给出了索引。我们可以将切片分为以下两类：
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
总而言之
#!/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。
推荐文章
- 证书验证失败:无法获得本地颁发者证书
- 当使用pip3安装包时，“Python中的ssl模块不可用”
- 无法切换Python与pyenv
- Python if not == vs if !=
- 如何从scikit-learn决策树中提取决策规则?
- 为什么在Mac OS X v10.9 (Mavericks)的终端中apt-get功能不起作用?
- 将旋转的xtick标签与各自的xtick对齐
- 为什么元组可以包含可变项?
- 如何合并字典的字典?
- 如何创建类属性?
- 不区分大小写的“in”
- 在Python中获取迭代器中的元素个数
- 解析日期字符串并更改格式
- 使用try和。Python中的if
- 如何在Python中获得所有直接子目录
