提问



我需要一个很好的解释(引用是一个加号)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值表示所选切片中不的第一个值。因此,endstart之间的差异是所选元素的数量(如果step为1,则为默认值)。


另一个特性是startend可能是负数字,这意味着它从数组的末尾而不是从开头开始计数。所以:


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只包含一个元素,则会得到一个空列表而不是错误。有时您会更喜欢错误,因此您必须意识到这可能会发生。

其它参考1


Python教程讨论它(向下滚动一下,直到你到达关于切片的部分)。[227]


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


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



  记住切片如何工作的一种方法是将索引视为指向字符之间的,第一个字符的左边缘编号为0.然后是字符串的最后一个字符的右边缘> n 个字符的索引为 n 。


其它参考2


列举语法允许的可能性:


>>> 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为负数,则排序会有所改变,因为我们正在倒计时:


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

其它参考3


上面的答案不讨论切片分配:


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


这也可以澄清切片和索引之间的区别。

其它参考4



  

解释Python的切片符号




简而言之,下标符号(subscriptable[subscriptarg])中的冒号(:)会产生切片符号 - 它具有可选参数,startstopstep:


sliceable[start:stop:step]


Python切片是一种有条不紊地访问部分数据的计算速度快的方法。在我看来,即使是一个中级Python程序员,它也是必须熟悉的语言的一个方面。


重要定义



首先,让我们定义一些术语:



   start:切片的起始索引,它将包含此索引处的元素,除非它与 stop 相同,默认为0,即第一个索引。如果它是否定的,则意味着从最后开始n项。

  
  停止:切片的结束索引,它不包含此索引处的元素,默认为被切片序列的长度,即最多包括结束。

  
  步骤:索引增加的数量,默认为1.如果为负数,则反向切换迭代。



索引如何工作



您可以制作任何正数或负数。正数的含义很简单,但对于负数,就像Python中的索引一样,从开始和停止的结尾向后计数,对于< em> step ,您只需递减索引即可。这个例子来自文档的教程,但我稍微修改了它,以指示每个索引引用的序列中的哪个项目:[228]


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


切片如何工作



要使用带有支持它的序列的切片表示法,必须在序列后面的方括号中包含至少一个冒号(根据Python数据模型实际实现序列的__getitem__方法。)[[[229]


切片表示法的工作方式如下:


sequence[start:stop:step]


并且回想一下 start , stop 和 step 都有默认值,因此要访问默认值,只需省略参数即可。


从列表中获取最后九个元素的切片表示法(或任何其他支持它的序列,如字符串)将如下所示:


my_list[-9:]


当我看到这个时,我将括号中的部分读作从结尾到结尾的第9个。 (实际上,我在精神上将其缩写为-9,on)


说明:



完整的符号是


my_list[-9:None:None]


并且替换默认值(实际上当step为负时,stop的默认值为-len(my_list) - 1,因此停止的None实际上只意味着它会转到任何结束步骤至):


my_list[-9:len(my_list):1]


冒号:,告诉Python你给它一个切片而不是常规索引。这就是为什么在Python 2中制作浅表列表的惯用方法是


list_copy = sequence[:]


清除它们是:


del my_list[:]


(Python 3获得list.copylist.clear方法。)


step为负时,startstop的默认值会改变



默认情况下,当step参数为空(或None)时,将其分配给+1


但是你可以传入一个负整数,并且列表(或大多数其他标准的可切片)将从末尾切换到开头。


因此,负片会改变startstop的默认值!


在源

中确认

我想鼓励用户阅读源代码和文档。切片对象的源代码和此逻辑可在此处找到。首先,我们确定step是否为负数:[230]



 step_is_negative = step_sign < 0;



如果是这样,下限是-1意味着我们一直切到包括开头,上限是长度减去1,这意味着我们从最后开始。 (注意,-1的语义与-1的不同,用户可以在Python中传递指示最后一项的索引。)



if (step_is_negative) {
    lower = PyLong_FromLong(-1L);
    if (lower == NULL)
        goto error;

    upper = PyNumber_Add(length, lower);
    if (upper == NULL)
        goto error;
}



否则step为正,并且下限将为零和上限(我们上升但不包括)切片列表的长度。



else {
    lower = _PyLong_Zero;
    Py_INCREF(lower);
    upper = length;
    Py_INCREF(upper);
}



然后,我们可能需要应用startstop的默认值 - start的默认值被计算为step为负时的上限:



if (self->start == Py_None) {
    start = step_is_negative ? upper : lower;
    Py_INCREF(start);
}



stop,下限:



if (self->stop == Py_None) {
    stop = step_is_negative ? lower : upper;
    Py_INCREF(stop);
}



为您的切片指定一个描述性名称!



您可能会发现将切片与将其传递给list.__getitem__方法(即方括号的方法)分开是很有用的。即使您不是新手,它也会使您的代码更具可读性,以便其他可能需要阅读您的代码的人可以更容易地理解您正在做的事情。[231]


但是,您不能只将一些由冒号分隔的整数分配给变量。您需要使用切片对象:


last_nine_slice = slice(-9, None)


第二个参数None是必需的,因此第一个参数被解释为start参数,否则它将是stop参数。 [232]


然后,您可以将切片对象传递给序列:


>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]


有趣的是,范围也采取切片:


>>> range(100)[last_nine_slice]
range(91, 100)


内存注意事项:



由于Python列表的切片在内存中创建了新对象,因此需要注意的另一个重要功能是itertools.islice。通常你会想要迭代一个切片,而不是仅仅在内存中静态创建它。islice是完美的。一个警告,它不支持startstop的负面论据。]],或step,所以如果这是一个问题,你可能需要提前计算指数或反转可迭代。


length = 100
last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1)
list_last_nine = list(last_nine_iter)


现在:


>>> list_last_nine
[91, 92, 93, 94, 95, 96, 97, 98, 99]


列表切片复制的事实是列表本身的一个特征。如果您像Pandas DataFrame一样切换高级对象,它可能会返回原始视图,而不是副本。

其它参考5


当我第一次看到切片语法时,有些事情对我来说并不是很明显:


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

其它参考6


在http://wiki.python.org/moin/MovingToPythonFromOtherLanguages [233]找到这个伟大的表


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)

其它参考7


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

其它参考8


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


(from:to:step)


其中任何一个都是可选的


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


那么负索引只需要你将字符串的长度添加到负索引来理解它。


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

其它参考9


我发现它更容易记住它是如何工作的,然后我可以找出任何特定的开始/停止/步骤组合。


首先理解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开始,按step递增,不到stop。很简单。


关于消极步骤要记住的事情是stop始终是被排除的结束,无论它是高还是低。如果你想要相反的相同切片,那么单独进行反转会更加清晰:例如'abcde'[1:-2][::-1]从左边切掉一个焦,从右边切下两个,然后反转。 (另见reversed()。)[234]


序列切片是相同的,除了它首先标准化负索引,并且永远不会超出序列:


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'尽管range(1,-2) == []
归一化有时被认为是模数长度,但请注意它只增加一次长度:例如'abcde'[-53:42]就是整个字符串。

其它参考10


我自己使用元素之间的索引点方法来思考它,但是一种描述它的方法有时会帮助其他人得到它是这样的:


mylist[X:Y]


X是您想要的第一个元素的索引。

Y是您 想要的第一个元素的索引。

其它参考11


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

其它参考12


Python切片表示法:


a[start:end:step]



  • 对于startend,负值被解释为相对于序列的结尾。

  • end的正指数表示在中包含的最后一个元素之后的位置。

  • 空白值默认如下:[+0:-0:1]

  • 使用否定步骤会反转startend
  • 的解释


符号扩展到(numpy)矩阵和多维数组。例如,要切片整列,您可以使用:


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


切片保存数组元素的引用,而不是副本。如果要单独复制数组,可以使用deepcopy()

其它参考13


您还可以使用切片分配从列表中删除一个或多个元素:


r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]

其它参考14


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


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


见上面的abc回答

其它参考15


这就是我向新手教授切片的方法:


了解索引和切片之间的区别:


Wiki Python有这个惊人的图片,清楚地区分索引和切片。





它是一个包含6个元素的列表。要更好地理解切片,请将该列表视为一组放在一起的六个框。每个方框都有一个字母。


索引就像处理框的内容一样。您可以查看任何框的内容。但你不能一次检查多个盒子的内容。你甚至可以更换盒子的内容。但是你不能将2个球放在一个盒子里或一次更换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和1之间拾取前3个盒子或最后2个盒子或所有盒子。所以,如果你知道开头和那么,你可以挑选任何一套盒子。结尾。这个位置叫做start&停止位置。


有趣的是,您可以一次更换多个盒子。您也可以在任何地方放置多个盒子。


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_GetIndicesEx的函数,它为任何给定参数的切片计算索引。这是Python中的逻辑等效代码。


这个函数需要一个Python对象&切片的可选参数和返回start,stop,step&请求切片的切片长度。


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]


注意:这篇文章最初写在我的博客http://www.avilpage.com/2015/03/a-slice-of-python-intelligence-behind.html[237]

其它参考16


作为一般规则,编写具有大量硬编码索引值的代码会导致可读性
和维护混乱。例如,如果你在一年后回到代码,你会
看看它并想知道你在写它的时候在想什么。显示的解决方案
只是一种更清楚地说明代码实际执行情况的方法。
通常,内置slice()创建一个切片对象,可以在切片的任何位置使用
被允许。例如:


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


如果您有切片实例,则可以通过查看切片实例获得更多相关信息
分别是s.start,s.stop和s.step属性。例如:



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


其它参考17


1。切片表示法



为简单起见,请记住切片只有一种形式:


s[start:end:step]


以下是它的工作原理:



  • s:可以切片的对象

  • start:开始迭代的第一个索引

  • end:最后一个索引请注意end索引不会包含在结果切片中

  • step:每step索引
  • 选择元素


另一个重要的事情:所有startendstep可以省略!如果省略它们,将使用它们的默认值: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。陷阱



上面的部分解释了切片如何工作的核心功能,它将在大多数情况下工作。然而,你应该注意可能存在的缺陷,这部分解释了它们。


负指数



困扰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也可能是否定的!


否定步骤意味着向后迭代数组:从开头到开始,包括结束索引,并从结果中排除开始索引。


注意:当步为负时,startlen(s)的默认值(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将根据情况尝试将索引设置为0len(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

其它参考18


上面的答案不讨论使用着名的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在逗号在第二个维度上运行后。

其它参考19


要获得某个可迭代的部分(如列表),这是一个示例:


variable[number1:number2]


在此示例中,数字1的正数是您从前面取出的组件数量。负数是完全相反的,你从最后保留了多少。数字2的正数表示您打算从头开始保留多少个组件,而负数表示您打算从结尾处开始的数量。这有点违反直觉,但你认为列表切片非常有用是正确的。

其它参考20


我的大脑似乎很高兴接受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

其它参考21


#!/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。

其它参考22


在Python中,切片的最基本形式如下:


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]


从开始切片时,可以省略零索引,当切片到最后时,可以省略最终索引,因为它是多余的,所以不要冗长:


In [5]: l[:3] == l[0:3]
Out[5]: True

In [6]: l[7:] == l[7:len(l)]
Out[6]: True


当相对于集合的末尾进行偏移时,负整数很有用:


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]


切片时可以提供超出界限的索引,例如:


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]


请记住,切片集合的结果是一个全新的集合。此外,在分配中使用切片表示法时,切片分配的长度不必相同。将保留指定切片之前和之后的值,并且收集将缩小或增长以包含新值:


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]


如果省略开始和结束索引,则将复制该集合:


In [14]: l_copy = l[:]

In [15]: l == l_copy and l is not l_copy
Out[15]: True


如果在执行赋值操作时省略了开始和结束索引,则集合的整个内容将替换为引用的内容的副本:


In [20]: l[:] = list('hello...')

In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']


乙如果是基本切片,也可以应用以下表示法:


l[start:end:step]


其中l是一个集合,start是一个包含索引,end是一个独占索引,step是一个可以用来取每个 nth的步幅<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]


使用step提供了一种在Python中反转集合的有用技巧:


In [25]: l[::-1]
Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]


对于step也可以使用负整数,如下例所示:


In[28]:  l[::-2]
Out[28]: [9, 7, 5, 3, 1]


但是,使用step的负值可能会变得非常混乱。此外,为了成为Pythonic,您应该避免在单个切片中使用startendstep。如果需要这样做,请考虑在两个分配中执行此操作(一个用于切片,另一个用于步长)。


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]

其它参考23


以下是字符串索引的示例


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

str="Name string"


切片示例:[[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


以下是示例用法


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

其它参考24


关于Slice符号,上述大部分答案都清楚了。
用于切片的扩展索引语法是aList[start:stop:step]
基本的例子是


:[238]


更多切片示例:15个扩展切片[239]

其它参考25


我想添加一个Hello world示例,为初学者解释切片的基础知识。这对我帮助很大。


让我们有一个包含六个值的列表['P', 'Y', 'T', 'H', 'O', 'N']:


+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
  0   1   2   3   4   5 


现在,该列表中最简单的切片是其子列表。符号是[<index>:<index>],关键是要这样读:


[ start cutting before this index : end cutting before this index ]


现在,如果您对上面的列表进行切片[2:5],则会发生以下情况:


        |           |
+---+---|---+---+---|---+
| P | Y | T | H | O | N |
+---+---|---+---+---|---+
  0   1 | 2   3   4 | 5 


您使用索引2在之前剪切了,并在具有索引5的元素之前剪切了之前的。因此,结果将是这两个切割之间的切片,列表['T', 'H', 'O']

其它参考26


呵呵呵,看到自己试图在2600多张选票之后提供一个更好更简单的解释,并且被Grew Hewgill标记为正确答案,这有点奇怪。


开始了 ...


在我看来,如果你按照以下方式查看它,你将更好地理解和记住Python字符串切片符号(继续阅读)。


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


azString = "abcdefghijklmnopqrstuvwxyz"


对于那些不知道的人,你可以使用符号azString[x:y]azString创建任何子串。


来自其他编程语言,当常识受到损害时。什么是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。


请记住,我们正在设定界限。


这个技巧一直有效,很容易记忆。


希望这会有所帮助。

其它参考27


切片: - 蛇出现在你的脚附近。它从不可见变为可见。我们的愿景(如片)只是世界的一部分。
类似地,Python切片基于开始和停止提取元素。我们在Python中使用许多类型的切片。我们指定可选的第一个索引,可选的最后一个索引和一个可选步骤。


values[1:3]  Index 1 through index 3.
values[2:-1] Index 2 through index one from last.
values[:2]   Start through index 2.
values[2:]   Index 2 through end.
values[::2]  Start through end, skipping ahead 2 places each time.


你可以在下面的链接中找到好的例子: -
python切片表示法示例[240]

其它参考28


如果你觉得切片中的负面指数令人困惑,这就是思考它的非常简单的方法:只需用len - index替换负指数。例如,用len(list) - 3替换-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 for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]

其它参考29


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


首先,我们将创建一个值列表,以便在切片中使用。


创建两个要切片的列表,第一个是1到9的数字列表(列表A)。
第二个也是数字列表,从0到9(列表B)


A = list(range(1,10,1)) # start,stop,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?这是因为切片对象表示由范围(开始,停止,步骤)指定的索引集。 Python 3.4文档


如您所见,仅定义stop会返回一个元素。由于开始默认为none,因此转换为仅检索一个元素。


需要注意的是,第一个元素是索引0,而不是索引1.这就是我们在本练习中使用2个列表的原因。列表A的元素根据序数位置编号(第一个元素是1,第二个元素是2等),而列表B的元素是用于索引它们的数字(

其它参考30

表示第一个元素元素0等)。


使用扩展索引语法,我们检索一系列值。例如,使用冒号检索所有值。


A[:]


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


给定模式aList [[start:stop]],从List A中检索前两个元素