blocks|key|2118448|text|slice函数返回切片对象。片对象是Python的内部类型之一，它为读取性能进行了优化--它们的所有属性都是只读的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2118449|如果希望更改默认行为，更改slice可能是有用的。例如，lxml使用片表示法来访问DOM元素(但是，我还没有确认它们是如何做到的)。|2118450|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/functions.html#slice|1|http://docs.python.org/reference/datamodel.html|2|http://codespeak.net/lxml/^0|0|5|0|5|0|9|4|1|0|D|5|S|4|S|4|2|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]|$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]]|E|$]]|$1|H|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]|R|$5|K|L|M|E|$N|S]]]]

The <a href="http://docs.python.org/library/functions.html#slice" rel="nofollow"><code>slice</code></a> function returns <a href="http://docs.python.org/reference/datamodel.html" rel="nofollow">slice objects</a>. Slice objects are one of Python's internal types, which are optimized for read performance - all of their attributes are read-only.

Altering <code>slice</code> could be useful if wish to change the default behaviour. For example, <a href="http://codespeak.net/lxml/" rel="nofollow"><code>lxml</code></a> uses slice notation to access DOM elements (however, I haven't confirmed how they did that myself).

blocks|key|565410|text|通过使用与执行start:end:step表示法使用的相同字段调用片来创建一个片：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|565411|sl+=+slice(0,4)|code-block|syntax|javascript|565412|要使用该切片，只需将其作为索引传递到列表或字符串中：|565413|>>>+s+=+"ABCDEFGHIJKL"
>>>+sl+=+slice(0,4)
>>>+print(s[sl])
'ABCD'|565414|假设您有一个固定长度文本字段的文件。您可以定义一个切片列表，以方便地从该文件中的每个“记录”中提取值。|565415|data+=+"""\
0010GEORGE+JETSON++++12345+SPACESHIP+ST+++HOUSTON+++++++TX
0020WILE+E+COYOTE++++312+ACME+BLVD++++++++TUCSON++++++++AZ
0030FRED+FLINTSTONE++246+GRANITE+LANE+++++BEDROCK+++++++CA
0040JONNY+QUEST++++++31416+SCIENCE+AVE++++PALO+ALTO+++++CA""".splitlines()


fieldslices+=+[slice(*fielddef)+for+fielddef+in+[
++++(0,4),+(4,+21),+(21,42),+(42,56),+(56,58),
++++]]
fields+=+"id+name+address+city+state".split()

for+rec+in+data:
++++for+field,sl+in+zip(fields,+fieldslices):
++++++++print("{}+:+{}".format(field,+rec[sl]))
++++print('')

#+or+this+same+code+using+itemgetter,+to+make+a+function+that
#+extracts+all+slices+from+a+string+into+a+tuple+of+values
import+operator
rec_reader+=+operator.itemgetter(*fieldslices)
for+rec+in+data:
++++for+field,+field_value+in+zip(fields,+rec_reader(rec)):
++++++++print("{}+:+{}".format(field,+field_value))
++++print('')|565416|指纹：|565417|id+:+0010
name+:+GEORGE+JETSON++++
address+:+12345+SPACESHIP+ST+++
city+:+HOUSTON+++++++
state+:+TX

id+:+0020
name+:+WILE+E+COYOTE++++
address+:+312+ACME+BLVD++++++++
city+:+TUCSON++++++++
state+:+AZ

id+:+0030
name+:+FRED+FLINTSTONE++
address+:+246+GRANITE+LANE+++++
city+:+BEDROCK+++++++
state+:+CA

id+:+0040
name+:+JONNY+QUEST++++++
address+:+31416+SCIENCE+AVE++++
city+:+PALO+ALTO+++++
state+:+CA|565418|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

You create a slice by calling slice with the same fields you would use if doing [start:end:step] notation:
<pre><code>sl = slice(0,4)
</code></pre>
To use the slice, just pass it as if it were the index into a list or string:
<pre><code>&gt;&gt;&gt; s = &quot;ABCDEFGHIJKL&quot;
&gt;&gt;&gt; sl = slice(0,4)
&gt;&gt;&gt; print(s[sl])
'ABCD'
</code></pre>
Let's say you have a file of fixed-length text fields. You could define a list of slices to easily extract the values from each &quot;record&quot; in this file.
<pre><code>data = &quot;&quot;&quot;\
0010GEORGE JETSON 12345 SPACESHIP ST HOUSTON TX
0020WILE E COYOTE 312 ACME BLVD TUCSON AZ
0030FRED FLINTSTONE 246 GRANITE LANE BEDROCK CA
0040JONNY QUEST 31416 SCIENCE AVE PALO ALTO CA&quot;&quot;&quot;.splitlines()


fieldslices = [slice(*fielddef) for fielddef in [
 (0,4), (4, 21), (21,42), (42,56), (56,58),
 ]]
fields = &quot;id name address city state&quot;.split()

for rec in data:
 for field,sl in zip(fields, fieldslices):
 print(&quot;{} : {}&quot;.format(field, rec[sl]))
 print('')

# or this same code using itemgetter, to make a function that
# extracts all slices from a string into a tuple of values
import operator
rec_reader = operator.itemgetter(*fieldslices)
for rec in data:
 for field, field_value in zip(fields, rec_reader(rec)):
 print(&quot;{} : {}&quot;.format(field, field_value))
 print('')
</code></pre>
Prints:
<pre><code>id : 0010
name : GEORGE JETSON 
address : 12345 SPACESHIP ST 
city : HOUSTON 
state : TX

id : 0020
name : WILE E COYOTE 
address : 312 ACME BLVD 
city : TUCSON 
state : AZ

id : 0030
name : FRED FLINTSTONE 
address : 246 GRANITE LANE 
city : BEDROCK 
state : CA

id : 0040
name : JONNY QUEST 
address : 31416 SCIENCE AVE 
city : PALO ALTO 
state : CA
</code></pre>

blocks|key|565439|text|序列后面的方括号表示索引或切片，具体取决于括号内的内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|565440|>>>+"Python+rocks"[1]++++#+index
'y'
>>>+"Python+rocks"[1:10:2]++++#+slice
'yhnrc'|code-block|syntax|javascript|565441|这两种情况都由序列的__getitem__()方法处理(如果位于等号的左边，则为__setitem__()+)。索引或切片作为单个参数传递给方法，Python的方法是将片表示法(在本例中为1:10:2)转换为片对象：slice(1,10,2)。|offset|length|style|CODE|565442|因此，如果要定义自己的类似序列的类，或者重写另一个类的__getitem__或__setitem__或__delitem__方法，则需要测试索引参数以确定它是int还是slice，并相应地进行处理：|565443|def+__getitem__(self,+index):
++++if+isinstance(index,+int):
++++++++...++++#+process+index+as+an+integer
++++elif+isinstance(index,+slice):
++++++++start,+stop,+step+=+index.indices(len(self))++++#+index+is+a+slice
++++++++...++++#+process+slice
++++else:
++++++++raise+TypeError("index+must+be+int+or+slice")|565444|slice对象有三个属性：start、stop和step，还有一个方法：indices，它接受一个参数，对象的长度，并返回一个3元组：(start,+stop,+step)。|565445|entityMap^0|0|0|A|D|14|D|2M|6|30|D|0|R|B|13|B|1F|B|27|3|2C|5|0|0|0|5|D|5|J|4|O|4|10|7|1V|J|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@$I|16|J|17|K|L]|$I|18|J|19|K|L]|$I|1A|J|1B|K|L]|$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1H|8|@$I|1I|J|1J|K|L]|$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]|$I|1O|J|1P|K|L]|$I|1Q|J|1R|K|L]|$I|1S|J|1T|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|T|$]]

Square brackets following a sequence denote either indexing or slicing depending on what's inside the brackets:

<pre><code>&gt;&gt;&gt; "Python rocks"[1] # index
'y'
&gt;&gt;&gt; "Python rocks"[1:10:2] # slice
'yhnrc'
</code></pre>

Both of these cases are handled by the <code>__getitem__()</code> method of the sequence (or <code>__setitem__()</code> if on the left of an equals sign.) The index or slice is passed to the methods as a single argument, and the way Python does this is by converting the slice notation, (<code>1:10:2</code>, in this case) to a slice object: <code>slice(1,10,2)</code>.

So if you are defining your own sequence-like class or overriding the <code>__getitem__</code> or <code>__setitem__</code> or <code>__delitem__</code> methods of another class, you need to test the index argument to determine if it is an <code>int</code> or a <code>slice</code>, and process accordingly:

<pre><code>def __getitem__(self, index):
 if isinstance(index, int):
 ... # process index as an integer
 elif isinstance(index, slice):
 start, stop, step = index.indices(len(self)) # index is a slice
 ... # process slice
 else:
 raise TypeError("index must be int or slice")
</code></pre>

A <code>slice</code> object has three attributes: <code>start</code>, <code>stop</code> and <code>step</code>, and one method: <code>indices</code>, which takes a single argument, the length of the object, and returns a 3-tuple: <code>(start, stop, step)</code>.

blocks|key|2118474|text|>>>+class+sl:
...++def+__getitem__(self,+*keys):+print+keys
...+++++
>>>+s+=+sl()
>>>+s[1:3:5]
(slice(1,+3,+5),)
>>>+s[1:2:3,+1,+4:5]
((slice(1,+2,+3),+1,+slice(4,+5,+None)),)
>>>|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2118475|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>&gt;&gt;&gt; class sl:
... def __getitem__(self, *keys): print keys
... 
&gt;&gt;&gt; s = sl()
&gt;&gt;&gt; s[1:3:5]
(slice(1, 3, 5),)
&gt;&gt;&gt; s[1:2:3, 1, 4:5]
((slice(1, 2, 3), 1, slice(4, 5, None)),)
&gt;&gt;&gt;
</code></pre>

blocks|key|565464|text|在尝试回答基于变量的字符串子集时，我记得numpy有一种语法上很好的方法来定义片对象：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|565465|>>>+import+numpy+as+np
>>>+s+=+"The+long-string+instrument+is+a+musical+instrument+in+which+the+string+is+of+such+a+length+that+the+fundamental+transverse+wave+is+below+what+a+person+can+hear+as+a+tone."
>>>+z+=+np.s_[18:26]++#+in+this+case+same+as+slice(18,+26,+None)
>>>+s[z]
'strument'|code-block|syntax|javascript|565466|这里解决的问题是如何将切片存储在变量中供以后使用，np.s_允许这样做。是的，这不是内置的，但由于原来的问题在这里重定向，我觉得我的答案也属于这里。此外，numpy也是将如此先进的切片功能添加到Python，IIRC的原因之一。|style|CODE|565467|一个更复杂的“切片”的例子：|565468|>>>+data+=+np.array(range(6)).reshape((2,+3))
>>>+z+=+np.s_[:1,+1:2]
>>>+data[z]
array([[1]])
>>>+data
array([[0,+1,+2],
+++++++[3,+4,+5]])
>>>+z
(slice(None,+1,+None),+slice(1,+2,+None))|565469|其中z现在是切片的元组。|565470|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/57546334/subset-a-string-based-on-variable^0|5|A|0|0|0|P|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@$A|16|B|17|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|19|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1A|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

While trying to answer <a href="https://stackoverflow.com/questions/57546334/subset-a-string-based-on-variable">Subset a string based on variable</a> , I recalled that numpy has a syntactically nice way to define slice objects:

<pre><code>&gt;&gt;&gt; import numpy as np
&gt;&gt;&gt; s = "The long-string instrument is a musical instrument in which the string is of such a length that the fundamental transverse wave is below what a person can hear as a tone."
&gt;&gt;&gt; z = np.s_[18:26] # in this case same as slice(18, 26, None)
&gt;&gt;&gt; s[z]
'strument'
</code></pre>

The problem solved here is how to store the slice in a variable for later use, and <code>np.s_</code> allows to do just that. Yes, it's not built-in, but as that original question was redirected here I feel like my answer belong here as well. Also, numpy was one of the reasons why so advanced slicing abilities were added to Python, IIRC.

An example of a more complex "slicing":

<pre><code>&gt;&gt;&gt; data = np.array(range(6)).reshape((2, 3))
&gt;&gt;&gt; z = np.s_[:1, 1:2]
&gt;&gt;&gt; data[z]
array([[1]])
&gt;&gt;&gt; data
array([[0, 1, 2],
 [3, 4, 5]])
&gt;&gt;&gt; z
(slice(None, 1, None), slice(1, 2, None))
</code></pre>

where z is now a tuple of slices.

blocks|key|1763290|text|片对象允许您以编程方式生成和操作片。特别是对于多维numpy数组，尤其是如果您事先不知道维度，您可能需要动态构造切片来指定所需的轴或尺寸。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763291|import+numpy+as+np
dimension+=+np.random.randint(10)+#+Might+have+up+to+10+dimensions
shape+=+[]
for+d+in+range(dimension):
++++shape.append(np.random.randint(10))
zz+=+np.random.rand(tuple(shape))
print(zz)
>>>+array([[0.68379351,+0.50854469,+0.64578775,+0.73441699,+0.28977396],
+++++++++++[0.88797164,+0.81603025,+0.63978659,+0.22677299,+0.93455738],
+++++++++++[0.0892855+,+0.28048706,+0.04262895,+0.9353467+,+0.13062249],
+++++++++++[0.88561035,+0.93378367,+0.12124208,+0.25600301,+0.96035638]])|code-block|syntax|javascript|1763292|在这里，我们的数据最终是二维的(4乘5)，但不能保证这一点。您将如何从zz请求切片|offset|length|style|CODE|1763293|一个问题是，我不能操作Python的片表示法。它不是切片操作之外的有效语法。|1763294|my_slice+=+2:3:1
>>>+SyntaxError:+Invalid+Syntax|1763295|如果我只需要在一个循环中构建我想要的确切的切片请求，那么我可以构建一个字符串呢？那不是很棒吗？我的意思是，你当然可以用一个字符串来做它，但它将是混乱的，需要eval。|1763296|your_slice_definitions+=+[(2,3,1),+*[(None,+None,+None)]*(zz.ndim+-+1)]+
my_slice_str+=+""
for+slice_start,+slice_end,+slice_step+in+your_slice_definitions:
++++my_slice_str+%2B=+"{}:{}:{},".format(slice_start,+slice_end,+slice_step)
eval("zz["%2Bmy_slice_str%2B"])|1763297|所以我们来看看：slice对象允许您这样做。您可以动态地组装列表和元组，将它们作为函数参数传递，对它们进行排序和洗牌，等等。|1763298|my_slices+=+[]
for+slice_start,+slice_end,+slice_step+in+your_slice_definitions:
++++my_slices+%2B=+slice(slice_start,+slice_end,+slice_step)
print(zz[my_slices])
>>>+array([[0.0892855+,+0.28048706,+0.04262895,+0.9353467+,+0.13062249]])|1763299|entityMap^0|0|0|Z|2|0|0|0|26|4|0|0|8|5|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|17|8|@$I|18|J|19|K|L]]|9|@]|A|$]]|$1|S|3|T|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1B|8|@$I|1C|J|1D|K|L]]|9|@]|A|$]]|$1|W|3|X|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|Z|$]]

Slice objects let you programmatically generate and manipulate slices. Especially for multidimensional numpy arrays, and especially if you don't know the dimensionality in advance, you might want to construct slices on-the-fly to specify the axes or dimensions that you want.
<pre><code>import numpy as np
dimension = np.random.randint(10) # Might have up to 10 dimensions
shape = []
for d in range(dimension):
 shape.append(np.random.randint(10))
zz = np.random.rand(tuple(shape))
print(zz)
&gt;&gt;&gt; array([[0.68379351, 0.50854469, 0.64578775, 0.73441699, 0.28977396],
 [0.88797164, 0.81603025, 0.63978659, 0.22677299, 0.93455738],
 [0.0892855 , 0.28048706, 0.04262895, 0.9353467 , 0.13062249],
 [0.88561035, 0.93378367, 0.12124208, 0.25600301, 0.96035638]])
</code></pre>
Here our data ended up being two dimensional (4-by-5), but there was no guarantee of that. How will you request slices from <code>zz</code>?
One problem is that I can't manipulate Python's slice notation. It's not valid syntax outside of a slicing operation.
<pre><code>my_slice = 2:3:1
&gt;&gt;&gt; SyntaxError: Invalid Syntax
</code></pre>
What if I could just build up the exact slice request I wanted in a loop, the way I can build up a string? Wouldn't that be great? I mean, sure you can use a string to do it, but it would be messy and requires <code>eval</code>.
<pre><code>your_slice_definitions = [(2,3,1), *[(None, None, None)]*(zz.ndim - 1)] 
my_slice_str = &quot;&quot;
for slice_start, slice_end, slice_step in your_slice_definitions:
 my_slice_str += &quot;{}:{}:{},&quot;.format(slice_start, slice_end, slice_step)
eval(&quot;zz[&quot;+my_slice_str+&quot;])
</code></pre>
So here we are: <code>slice</code> objects let you do this. You can assemble lists and tuples of them on-the-fly, pass them as function parameters, sort them, shuffle them, and so on.
<pre><code>my_slices = []
for slice_start, slice_end, slice_step in your_slice_definitions:
 my_slices += slice(slice_start, slice_end, slice_step)
print(zz[my_slices])
&gt;&gt;&gt; array([[0.0892855 , 0.28048706, 0.04262895, 0.9353467 , 0.13062249]])
</code></pre>

What's the use of built-in function <code>slice</code> and how can I use it? 
The direct way of Pythonic slicing I know - <code>l1[start:stop:step]</code>. I want to know if I have a slice object, then how do I use it?

Python slice how-to, I know the Python slice but how can I use built-in slice object for it?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

内置函数slice的用途是什么?我如何使用它？我所知道的毕达通切片的直接方法- l1[start:stop:step]。我想知道我是否有一个片对象，那么我如何使用它呢？

问Python切片-to，我知道Python片，但是我如何使用内置的片对象呢？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python切片-to，我知道Python片，但是我如何使用内置的片对象呢？EN