关于Python的切片符号,我需要一个很好的解释(引用是一个加号)。
对我来说,此表示法需要一些注意。
它看起来非常强大,但是我还没有完全了解它。
这真的很简单:
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
值表示所选切片中的第一个值为 not 的值。因此,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
仅包含一个元素,则会得到一个空列表而不是错误。有时您会更喜欢该错误,因此您必须意识到这可能会发生。
slice()
对象的关系切片代码[]
实际上在上面的代码中与slice()
对象一起使用,使用:
表示法(即仅在[]
内有效),即:
a[start:stop:step]
等效于:
a[slice(start, stop, step)]
Slice对象的行为也取决于参数的数量,与range()
类似,即slice(stop)
和slice(start,支持stop [,step])
。要跳过指定给定参数的操作,可以使用None
,例如a[start:]
等效于a[slice(start,None)]
或a[::-1]
等效于< code> a [slice(None,None,-1)] 。
虽然基于:
的表示法对于简单切片非常有用,但是显式使用slice()
对象简化了切片的程序化生成。
Python教程对此进行了讨论(向下滚动直到获得到切片的内容。
ASCII艺术图对于记住切片的工作方式也很有帮助:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
记住切片工作方式的一种方法是将索引视为指向 字符之间,第一个字符的左边缘编号为0。然后,字符串的最后一个字符的右侧边缘的 n 个字符的索引为 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
为负,则由于我们递减计数,因此顺序有一些变化:
>>> 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 repr(item)
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'
以上答案未讨论切片分配。要了解切片分配,在ASCII艺术中添加另一个概念很有帮助:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
Slice position: 0 1 2 3 4 5 6
Index position: 0 1 2 3 4 5
>>> p = ['P','y','t','h','o','n']
# Why the two sets of numbers:
# indexing gives items, not lists
>>> p[0]
'P'
>>> p[5]
'n'
# Slicing gives lists
>>> p[0:1]
['P']
>>> p[0:2]
['P','y']
一种启发式方法是,对于从零到n的切片,请考虑:"零是开始,从开始开始,并在列表中包含n个项目。"
>>> p[5] # the last of six items, indexed from zero
'n'
>>> p[0:5] # does NOT include the last item!
['P','y','t','h','o']
>>> p[0:6] # not p[0:5]!!!
['P','y','t','h','o','n']
另一种启发式方法是:"对于任何切片,将起始位置替换为零,应用先前的启发式方法以获取列表的末尾,然后将第一个数字向上计数以从开始处切掉项目"
>>> p[0:4] # Start at the beginning and count out 4 items
['P','y','t','h']
>>> p[1:4] # Take one item off the front
['y','t','h']
>>> p[2:4] # Take two items off the front
['t','h']
# etc.
切片分配的第一个规则是,由于切片返回一个列表,因此切片分配需要一个列表(或其他可迭代的):
>>> p[2:3]
['t']
>>> p[2:3] = ['T']
>>> p
['P','y','T','h','o','n']
>>> p[2:3] = 't'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable
切片分配的第二条规则(您也可以在上方看到)是:切片索引会返回列表的任何部分,而切片分配会更改该部分:
>>> p[2:4]
['T','h']
>>> p[2:4] = ['t','r']
>>> p
['P','y','t','r','o','n']
切片分配的第三个规则是,分配的列表(可迭代)不必具有相同的长度;只需将索引切片切成薄片,然后全部替换为分配的内容:
>>> p = ['P','y','t','h','o','n'] # Start over
>>> p[2:4] = ['s','p','a','m']
>>> p
['P','y','s','p','a','m','o','n']
最难处理的部分是分配给空片。使用启发式1和2可以很容易地将 indexing 索引为空片段:
>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
['P','y','t','h']
>>> p[1:4]
['y','t','h']
>>> p[2:4]
['t','h']
>>> p[3:4]
['h']
>>> p[4:4]
[]
然后,一旦您看到了,将切片分配给空切片也很有意义:
>>> p = ['P','y','t','h','o','n']
>>> p[2:4] = ['x','y'] # Assigned list is same length as slice
>>> p
['P','y','x','y','o','n'] # Result is same length
>>> p = ['P','y','t','h','o','n']
>>> p[3:4] = ['x','y'] # Assigned list is longer than slice
>>> p
['P','y','t','x','y','o','n'] # The result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
['P','y','t','h','x','y','o','n'] # The result is longer still
请注意,由于我们没有更改分片的第二个数字(4),因此即使我们分配给空分片,插入的项目也总是与'o'相对堆积。因此,空切片分配的位置是非空切片分配的位置的逻辑扩展。
备份一点,当您继续进行我们从头开始计算切片的游行时会发生什么?
>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
['P','y','t','h']
>>> p[1:4]
['y','t','h']
>>> p[2:4]
['t','h']
>>> p[3:4]
['h']
>>> p[4:4]
[]
>>> p[5:4]
[]
>>> p[6:4]
[]
使用切片,一旦完成,就完成了;它不会开始向后切片。在Python中,除非您使用负数明确要求它们,否则您不会获得负面的进步。
>>> p[5:3:-1]
['n','o']
"一旦完成,就完成了"规则会有一些奇怪的后果:
>>> p[4:4]
[]
>>> p[5:4]
[]
>>> p[6:4]
[]
>>> p[6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
事实上,与索引相比,Python切片具有出色的防错能力:
>>> p[100:200]
[]
>>> p[int(2e99):int(1e99)]
[]
有时这会派上用场,但也会导致一些奇怪的行为:
>>> p
['P', 'y', 't', 'h', 'o', 'n']
>>> p[int(2e99):int(1e99)] = ['p','o','w','e','r']
>>> p
['P', 'y', 't', 'h', 'o', 'n', 'p', 'o', 'w', 'e', 'r']
取决于您的应用程序,这可能……或可能不是……您所希望的!
下面是我原始答案的文本。它对很多人都有用,所以我不想删除它。
>>> 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,
停止
,步骤
:
sliceable[start:stop:step]
Python切片是一种计算快速的方法,可以有条不紊地访问数据的一部分。我认为,即使是一名中级Python程序员,这也是该语言必须要熟悉的一个方面。
重要定义
首先,让我们定义一些术语:
开始:切片的开始索引,它将包括此索引处的元素,除非它与 stop 相同,默认为0,即第一个索引。如果为负,则表示从头开始n
个项目。
停止:切片的结束索引,它不在该索引处不包含元素,默认为要切片的序列的长度,即最大并包括结尾。
步骤:索引增加的数量,默认为1。如果为负数,则将反向迭代切片。
索引工作原理
您可以使用这些正数或负数中的任何一个。正数的含义很简单,但是对于负数,就像Python中的索引一样,对于 start 和 stop ,对于< em> step ,您只需减少索引。这个示例是来自文档教程的,但我对其进行了一些修改以表明每个索引引用序列中的哪个项目:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
切片方式
要在支持切片的序列中使用切片符号,必须在序列后的方括号中至少包含一个冒号(实际上根据Python数据模型实施序列的__getitem__
方法。)
切片符号的工作方式如下:
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.copy
和list.clear
方法。)
当step
为负数时,start
和stop
的默认值会更改
默认情况下,当step
参数为空(或None
)时,会将其分配给+1
。
但是您可以传入一个负整数,列表(或大多数其他标准可切片)将从头到尾切片。
因此,负片将更改start
和stop
的默认值!
在源代码中确认这一点
我希望鼓励用户阅读源和文档。 切片对象的源代码,此逻辑在此处。首先,我们确定step
是否为负:
step_is_negative = step_sign < 0;
如果是这样,则下限为-1
,这意味着我们将一直切到起点,包括起点,上限为长度减去1,这意味着我们从终点开始。 (请注意,此-1
的语义与-1
的不同,用户可以在Python中传递表示最后一项的索引。)< / p>
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);
}
然后,我们可能需要应用start
和stop
的默认值-然后,将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__
方法分开有用(方括号就是这样)。即使您不是新手,它也可以使您的代码更具可读性,以便其他可能需要阅读代码的人可以更轻松地了解您的操作。
但是,您不能仅将一些用冒号分隔的整数分配给变量。您需要使用slice对象:
last_nine_slice = slice(-9, None)
第二个参数None
是必需的,因此第一个参数被解释为start
参数否则,它将是stop
参数。
然后可以将切片对象传递给序列:
>>> 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
非常适合此操作。请注意,它不支持start
,stop
或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),则它可能会返回原始视图,而不是副本。
当我第一次看到切片语法时,有几件事对我来说并不立即显而易见:
>>> 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]
在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]
在 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)
然后,负索引仅需要您将字符串的长度添加到负索引即可理解。
反正这对我有用...
我发现更容易记住它是如何工作的,然后我可以找出任何特定的开始/停止/步骤组合。
首先了解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
从开始
开始,以step
递增,没有达到stop
。很简单。
要记住的负面步骤是,stop
始终是被排除的端点,无论它是高还是低。如果您想要相反顺序的同一片,单独进行逆转会更清洁:例如'abcde'[1:-2][::-1]
从左边切一个字符,从右边切两个字符,然后反转。 (另请参见 reversed()
。)< / p>
序列切片是相同的,只是它首先对负索引进行规范化,并且永远不能超出序列:
待办事项:当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]
不必担心是None
的详细信息-请记住,省略start
和/或stop
总是可以正确地解决问题您整个序列。
首先对负索引进行规范化,就可以独立地从头开始计算开始和/或停止:'abcde'[1:-2]=='abcde'[1:3]=='bc'
,尽管
range(1,-2)==[]
。规范化有时被认为是"对长度取模",但请注意,它仅将长度增加一次: 'abcde'[-53:42]
只是整个字符串。
我自己使用"元素之间的索引点"方法来思考它,但是描述它有时可以帮助他人获得它的一种方法是:
mylist[X:Y]
X是您想要的第一个元素的索引。
Y是您不需要的第一个元素的索引。
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()
。
您还可以使用切片分配从列表中删除一个或多个元素:
r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]
这只是一些额外的信息...请考虑下面的列表
>>> 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]
这是我向新手教切片的方法:
了解索引编制和切片之间的区别:
Wiki Python的这张惊人图片清楚地区分了索引编制和切片。
这是一个包含六个元素的列表。为了更好地了解切片,请将该列表视为一组六个盒子放在一起。每个盒子中都有一个字母。
索引就像处理box的内容。您可以检查任何框的内容。但是您不能一次检查多个框的内容。您甚至可以替换包装箱中的物品。但是您不能将两个球放在一个盒子中,也不能一次更换两个球。
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_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的内置函数,因此您可以传递一些参数并检查其计算缺失参数的技巧。
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 Slice背后的情报 。
通常,编写带有很多硬编码索引值的代码会导致可读性和维护混乱。例如,如果一年后返回代码,您将对其进行查看,并想知道编写代码时的想法。显示的解决方案只是一种更清晰地说明代码实际运行方式的方式。通常,内置slice()创建一个slice对象,该对象可在允许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,则可以分别通过查看其s.start,s.stop和s.step属性来获取有关它的更多信息。例如:
>>> a = slice(10, 50, 2) >>> a.start 10 >>> a.stop 50 >>> a.step 2 >>>
为简单起见,请记住切片只有一种形式:
s[start:end:step]
这是它的工作方式:
s
:可以切片的对象start
:开始迭代的第一个索引end
:最后一个索引,请注意,end
索引将不包含在结果切片中 step
:在每个step
索引另一种导入方式:所有开始
,结束
,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将返回一个空切片[]
。< / p>
以上部分说明了切片如何工作的核心功能,并且在大多数情况下都可以使用。但是,您可能需要注意一些陷阱,这部分将对它们进行解释。
让Python学习者困惑的第一件事是索引可能为负!不要惊慌:负索引意味着倒数。
例如:
s[-5:] # Start at the 5th index from the end of array,
# thus returning the last 5 elements.
s[:-5] # Start at index 0, and end until the 5th index from end of array,
# thus returning s[0:len(s)-5].
让事情更令人困惑的是, step
也可能是负面的!
否定步骤意味着向后迭代数组:从头到尾,包括结束索引,并且从结果中排除开始索引。
注意:当步长为负数时,start
的默认值为len
(而end
>不等于0
,因为s[::-1]
包含s[0]
)。例如:
s[::-1] # Reversed slice
s[len(s)::-1] # The same as above, reversed slice
s[0:len(s):-1] # Empty list
很惊讶:当索引超出范围时,切片不会引发IndexError!
如果索引超出范围,Python将根据情况尽最大努力将索引设置为0
或len.例如:
s[:len(s)+5] # The same as s[:len(s)]
s[-len(s)-5::] # The same as s[0:]
s[len(s)+5::-1] # The same as s[len(s)::-1], and the 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, and 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 an IndexError
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-15-79ffc22473a3> in <module>()
----> 1 s[11]
IndexError: list index out of range
以前的答案没有讨论使用著名的 NumPy 可能进行的多维数组切片a>包:
切片也可以应用于多维数组。
# 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
"。 >
#!/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。
我的大脑似乎很高兴接受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
。
在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 three elements
Out[8]: [7, 8, 9]
切片时可以提供超出范围的索引,例如:
In [9]: l[:20] # 20 is out of index bounds, and 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, and 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 fewer 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
是一个大步,可用于获取l
中的每个 n 个项目。
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
使用负值可能会造成混乱。此外,为了成为 Python ,您应避免使用start,
结束
和步骤
在单个切片中。如果需要这样做,请考虑分两次进行(一次为切片,另一次为大步)。
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]
我想添加一个 Hello,World!示例,为初学者介绍切片的基本知识。这对我有很大帮助。
我们有一个包含六个值的列表['P','Y','T','H','O','N']
:
+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
0 1 2 3 4 5
现在,该列表中最简单的部分是其子列表。表示法是[
,关键是要这样读取它:
[ 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']
。
我认为,如果以下列方式(继续阅读)来了解它,将会更好地理解和记住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,而在" c"右侧的索引为h"是8。
请记住,我们正在设置边界。这些边界就是您可以在其中放置一些括号的位置,这些括号将像这样围绕子字符串...
a b [ c d e f g h ] i j
该技巧始终有效,并且易于记忆。
以下是字符串索引的示例:
+---+---+---+---+---+
| 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
我个人认为它就像一个for
循环:
a[start:end:step]
# for(i = start; i < end; i += step)
此外,请注意,start
和end
的负值是相对于列表末尾的,并在上例中由given_index+a.shape计算得出[0]
。
如果您认为切片中的负索引会造成混淆,这是一种很简单的思考方式:只需将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)]
基本切片技术是定义起点,终点和步长-也称为步幅。
首先,我们将创建一个用于切片的值列表。
创建两个要切片的列表。第一个是从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中检索前两个元素。
我认为 Python教程图(在其他各种答案中引用)是很好的,因为此建议可用于积极的进步,但不适用于消极的进步。
这是示意图:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
从图中,我希望a[-4,-6,-1]
是yP
,但它是ty
。< / p>
>>> a = "Python"
>>> a[2:4:1] # as expected
'th'
>>> a[-4:-6:-1] # off by 1
'ty'
始终起作用的是思考字符或空位并将索引用作半开间隔-如果正向跨步则向右打开,如果负向跨步则向左打开。
这样,我可以将a[-4:-6:-1]
视为间隔术语中的a(-6,-4]
。
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
+---+---+---+---+---+---+---+---+---+---+---+---+
| P | y | t | h | o | n | P | y | t | h | o | n |
+---+---+---+---+---+---+---+---+---+---+---+---+
-6 -5 -4 -3 -2 -1 0 1 2 3 4 5