Python的切片表示法是如何工作的?也就是说:当我编写[x:y:z]、a[:]、a]::2]等代码时,我如何理解哪些元素最终会出现在切片中?请在适当的地方附上参考资料。


另请参见:为什么切片和范围上限是互斥的?


当前回答

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

(from:to:step)

其中任何一项都是可选的:

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

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

不管怎样,这对我来说都很有效。。。

其他回答

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


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


总而言之

简单易懂:

在Python中,切片符号a[start:stop:step]可以用于从序列中选择一系列元素(例如列表、元组或字符串)。

起始索引是包括在切片中的第一个元素,

停止索引是从切片中排除的第一个元素,也是最后一个元素

步长值是切片元素之间的索引数。

例如,考虑以下列表:

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

如果要选择a的所有元素,可以使用切片符号a[:]:

>>> a[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

如果我们想选择a的所有元素,但跳过其他元素,我们可以使用切片符号a[::2]:

>>> a[::2]
[0, 2, 4, 6, 8]

如果我们想选择从第三个元素(索引2)到第七个元素(索引号6)的所有元素,我们可以使用切片符号a[2:7]:

>>> a[2:7]
[2, 3, 4, 5, 6]

如果我们想选择从第三个元素(索引2)到第七个元素(索引号6)的所有元素,但跳过其他元素,我们可以使用切片符号a[2:7:2]:

>>> a[2:7:2]
[2, 4, 6]

如果我们想选择从第三个元素(索引2)到列表末尾的所有元素,我们可以使用切片符号a[2:]:

>>> a[2:]
[2, 3, 4, 5, 6, 7, 8, 9]

如果我们想选择从列表开头到第七个元素(索引6)的所有元素,我们可以使用切片符号a[:7]:

>>> a[:7]
[0, 1, 2, 3, 4, 5, 6]

如果您想了解有关切片表示法的更多信息,可以参考Python官方文档:链接1链接2

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

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

:

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

切片规则如下:

[lower bound : upper bound : step size]

I-将上限和下限转换为公共符号。

II-然后检查步长是正值还是负值。

(i) 如果步长为正值,则上限应大于下限,否则将打印空字符串。例如:

s="Welcome"
s1=s[0:3:1]
print(s1)

输出:

Wel

但是,如果我们运行以下代码:

s="Welcome"
s1=s[3:0:1]
print(s1)

它将返回一个空字符串。

(ii)如果步长为负值,则上限应小于下限,否则将打印空字符串。例如:

s="Welcome"
s1=s[3:0:-1]
print(s1)

输出:

cle

但如果我们运行以下代码:

s="Welcome"
s1=s[0:5:-1]
print(s1)

输出将为空字符串。

因此,在代码中:

str = 'abcd'
l = len(str)
str2 = str[l-1:0:-1]    #str[3:0:-1] 
print(str2)
str2 = str[l-1:-1:-1]    #str[3:-1:-1]
print(str2)

在第一个str2=str[l-1:0:-1]中,上限小于下限,因此打印dcb。

然而,在str2=str[l-1:-1:-1]中,上限不小于下限(将下限转换为负值,即-1:因为最后一个元素的索引是-1和3)。

已经有很多答案了,但我想添加一个性能比较

~$ python3.8 -m timeit -s 'fun = "this is fun;slicer = slice(0, 3)"' "fun_slice = fun[slicer]" 
10000000 loops, best of 5: 29.8 nsec per loop
~$ python3.8 -m timeit -s 'fun = "this is fun"' "fun_slice = fun[0:3]" 
10000000 loops, best of 5: 37.9 nsec per loop
~$ python3.8 -m timeit -s 'fun = "this is fun"' "fun_slice = fun[slice(0, 3)]" 
5000000 loops, best of 5: 68.7 nsec per loop
~$ python3.8 -m timeit -s 'fun = "this is fun"' "slicer = slice(0, 3)" 
5000000 loops, best of 5: 42.8 nsec per loop

因此,如果您重复使用同一个切片,使用切片对象将有益并提高可读性。然而,如果您只进行了几次切片,则应首选[:]表示法。