blocks|key|1048892|text|虽然没有对列表进行分片的内置函数，但您可以使用drop和take轻松地自己编写一个|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1048893|slice+::+Int+->+Int+->+[a]+->+[a]
slice+from+to+xs+=+take+(to+-+from+%2B+1)+(drop+from+xs)|code-block|syntax|javascript|1048894|应该指出的是，由于Haskell列表是单链表(而python列表是数组)，这样创建的子列表将是O(to)，而不是像python中的O(to+-+from)+(当然，假设整个列表实际上都得到了评估-否则Haskell的惰性会生效)。|1048895|entityMap^0|N|4|S|4|0|0|1B|5|1T|C|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

There's no built-in function to slice a list, but you can easily write one yourself using <code>drop</code> and <code>take</code>:

<pre><code>slice :: Int -&gt; Int -&gt; [a] -&gt; [a]
slice from to xs = take (to - from + 1) (drop from xs)
</code></pre>

It should be pointed out that since Haskell lists are singly linked lists (while python lists are arrays), creating sublists like that will be <code>O(to)</code>, not <code>O(to - from)</code> like in python (assuming of course that the whole list actually gets evaluated - otherwise Haskell's laziness takes effect).

blocks|key|1048951|text|如果您正在尝试匹配Python“列表”(正如其他人所指出的，这不是一个列表)，那么您可能希望使用具有内置slice的Haskell+vector包。另外，Vector可以是evaluated+in+parallel，我认为这很酷。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1048952|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/packages/archive/vector/0.7.0.1/doc/html/Data-Vector.html#v:slice|1|http://hackage.haskell.org/packages/archive/vector/0.7.0.1/doc/html/Data-Vector.html|2|http://hackage.haskell.org/package/vector-strategies^0|25|6|1G|5|0|1U|6|1|2E|L|2|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]|$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]|P|$5|I|J|K|E|$L|Q]]]]

If you are trying to match Python "lists" (which isn't a list, as others note) then you might want to use the Haskell <a href="http://hackage.haskell.org/packages/archive/vector/0.7.0.1/doc/html/Data-Vector.html" rel="noreferrer">vector</a> package which does have a built in <a href="http://hackage.haskell.org/packages/archive/vector/0.7.0.1/doc/html/Data-Vector.html#v:slice" rel="noreferrer">slice</a>. Also, <code>Vector</code> can be <a href="http://hackage.haskell.org/package/vector-strategies" rel="noreferrer">evaluated in parallel</a>, which I think is really cool.

blocks|key|833993|text|没有语法糖。在需要的情况下，您可以只使用take和drop。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|833994|take+2+$+drop+1+$+"abcd"+--+gives+"bc"|code-block|syntax|javascript|833995|entityMap^0|K|4|P|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

No syntactic sugar. In cases where it's needed, you can just <code>take</code> and <code>drop</code>. 

<pre><code>take 2 $ drop 1 $ "abcd" -- gives "bc"
</code></pre>

blocks|key|1048722|text|我不认为其中包含了一个，但您可以非常简单地编写一个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1048723|slice+start+end+=+take+(end+-+start+%2B+1)+.+drop+start|code-block|syntax|javascript|1048724|当然，前提是start和end是边界，并且是end+>=+start。|offset|length|style|CODE|1048725|entityMap^0|0|0|6|5|C|3|M|C|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

I don't think one is included, but you could write one fairly simply:

<pre><code>slice start end = take (end - start + 1) . drop start
</code></pre>

Of course, with the precondition that <code>start</code> and <code>end</code> are in-bounds, and <code>end &gt;= start</code>.

blocks|key|1049017|text|另一种方法是使用Data.List中的函数splitAt+--我发现它比使用take和drop更容易阅读和理解--但这只是个人喜好：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1049018|import+Data.List
slice+::+Int+->+Int+->+[a]+->+[a]
slice+start+stop+xs+=+fst+$+splitAt+(stop+-+start)+(snd+$+splitAt+start+xs)|code-block|syntax|javascript|1049019|例如：|1049020|Prelude+Data.List>+slice+0+2+[1,+2,+3,+4,+5,+6]
[1,2]
Prelude+Data.List>+slice+0+0+[1,+2,+3,+4,+5,+6]
[]
Prelude+Data.List>+slice+5+2+[1,+2,+3,+4,+5,+6]
[]
Prelude+Data.List>+slice+1+4+[1,+2,+3,+4,+5,+6]
[2,3,4]
Prelude+Data.List>+slice+5+7+[1,+2,+3,+4,+5,+6]
[6]
Prelude+Data.List>+slice+6+10+[1,+2,+3,+4,+5,+6]
[]|1049021|这应该等同于|1049022|let+slice'+start+stop+xs+=+take+(stop+-+start)+$+drop+start+xs|1049023|这肯定会更有效率，但我发现这比考虑将列表分为前后半部分的索引更令人困惑。|1049024|entityMap^0|8|9|L|7|12|4|17|4|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1A|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|V|$]]

Another way to do this is with the function <code>splitAt</code> from <code>Data.List</code> -- I find it makes it a little easier to read and understand than using <code>take</code> and <code>drop</code> -- but that's just personal preference:

<pre><code>import Data.List
slice :: Int -&gt; Int -&gt; [a] -&gt; [a]
slice start stop xs = fst $ splitAt (stop - start) (snd $ splitAt start xs)
</code></pre>

For example:

<pre><code>Prelude Data.List&gt; slice 0 2 [1, 2, 3, 4, 5, 6]
[1,2]
Prelude Data.List&gt; slice 0 0 [1, 2, 3, 4, 5, 6]
[]
Prelude Data.List&gt; slice 5 2 [1, 2, 3, 4, 5, 6]
[]
Prelude Data.List&gt; slice 1 4 [1, 2, 3, 4, 5, 6]
[2,3,4]
Prelude Data.List&gt; slice 5 7 [1, 2, 3, 4, 5, 6]
[6]
Prelude Data.List&gt; slice 6 10 [1, 2, 3, 4, 5, 6]
[]
</code></pre>

This should be equivalent to

<pre><code>let slice' start stop xs = take (stop - start) $ drop start xs
</code></pre>

which will certainly be more efficient, but which I find a little more confusing than thinking about the indices where the list is split into front and back halves.

blocks|key|834322|text|我写的这段代码也适用于负数，就像Python的列表切片一样，除了反转列表之外，我发现它与列表切片无关：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|834323|slice+::+Int+->+Int+->+[a]+->+[a]

slice+0+x+arr
++%7C+x+<+0+=+slice+0+((length+arr)%2B(x))+arr
++%7C+x+==+(length+arr)+=+arr
++%7C+otherwise+=+slice+0+(x)+(init+arr)

slice+x+y+arr
++%7C+x+<+0+=+slice+((length+arr)%2Bx)+y+arr+
++%7C+y+<+0+=+slice+x+((length+arr)%2By)+arr
++%7C+otherwise+=+slice+(x-1)+(y-1)+(tail+arr)

main+=+do
++print(slice+(-3)+(-1)+[3,+4,+29,+4,+6])+--+[29,4]
++print(slice+(2)+(-1)+[35,+345,+23,+24,+69,+2,+34,+523])+--+[23,24,69,32,34]
++print(slice+2+5+[34,+5,+5,+3,+43,+4,+23]+)+--+[5,3,43]|code-block|syntax|javascript|834324|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I've wrote this code that works for negative numbers as well, like Python's list slicing, except for reversing lists, which I find unrelated to list slicing:

<pre><code>slice :: Int -&gt; Int -&gt; [a] -&gt; [a]

slice 0 x arr
 | x &lt; 0 = slice 0 ((length arr)+(x)) arr
 | x == (length arr) = arr
 | otherwise = slice 0 (x) (init arr)

slice x y arr
 | x &lt; 0 = slice ((length arr)+x) y arr 
 | y &lt; 0 = slice x ((length arr)+y) arr
 | otherwise = slice (x-1) (y-1) (tail arr)

main = do
 print(slice (-3) (-1) [3, 4, 29, 4, 6]) -- [29,4]
 print(slice (2) (-1) [35, 345, 23, 24, 69, 2, 34, 523]) -- [23,24,69,32,34]
 print(slice 2 5 [34, 5, 5, 3, 43, 4, 23] ) -- [5,3,43]


</code></pre>

blocks|key|1048987|text|显然，我的foldl版本输给了take-drop方法，但也许有人看到了改进它的方法？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1048988|slice+from+to+=+reverse.snd.foldl+build+((from,+to+%2B+1),+[])+where
+++build+res@((_,+0),+_)+_+=+res++
+++build+((0,+to),+xs)+x+=+((0,+to+-+1),+x:xs)++
+++build+((from,+to),+xs)+_+=+((from+-+1,+to+-+1),+xs)|code-block|syntax|javascript|1048989|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Obviously my foldl version loses against the take-drop approach, but maybe someone sees a way to improve it?

<pre><code>slice from to = reverse.snd.foldl build ((from, to + 1), []) where
 build res@((_, 0), _) _ = res 
 build ((0, to), xs) x = ((0, to - 1), x:xs) 
 build ((from, to), xs) _ = ((from - 1, to - 1), xs)
</code></pre>

blocks|key|834289|text|sublist+start+length+=+take+length+.+snd+.+splitAt+start

slice+start+end+=+snd+.splitAt+start+.+take+end|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|834290|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>sublist start length = take length . snd . splitAt start

slice start end = snd .splitAt start . take end
</code></pre>

Does Haskell have similar syntactic sugar to <a href="http://diveintopython.net/native_data_types/lists.html#d0e5623" rel="noreferrer">Python List Slices</a>?

For instance in Python:

<pre><code>x = ['a','b','c','d']
x[1:3] 
</code></pre>

gives the characters from index 1 to index 2 included (or to index 3 excluded):

<pre><code>['b','c']
</code></pre>

I know Haskell has the <code>(!!)</code> function for specific indices, but is there an equivalent "slicing" or list range function?

Does Haskell have List Slices (i.e. Python)?

Python

Haskell的语法糖与相似吗？例如，在Python中：x = ['a','b','c','d']x[1:3] 提供从索引1到索引2包含的字符(或不包括索引3的字符)：['b','c']我知道Haskell有针对特定索引的(!!)函数，但是有没有等效的“切片”或列表范围函数？

问Haskell有列表切片(比如Python)吗？
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Haskell有列表切片(比如Python)吗？EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Haskell有列表切片(比如Python)吗？
EN