blocks|key|1806821|text|(map+vector+'(1+2+3)+'(4+5+6))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1806822|做你想做的事：|unstyled|1806823|=>+([1+4]+[2+5]+[3+6])|1806824|Haskell需要一个zipWith+(zipWith3，zipWith4，...)集合函数，因为它们都需要是特定类型的；特别是，它们接受的输入列表的数量需要固定。(+zip，zip2，zip3，...系列可以被看作是zipWith系列的一个特化)。|offset|length|style|CODE|1806825|相比之下，Clojure和其他Lisp对可变参数函数有很好的支持；map就是其中之一，可以用类似于Haskell的方式用于“元组”|1806826|zipWith+(\x+y+->+(x,+y))|1806827|在Clojure中构建"tuple“的惯用方法是构造一个简短的向量，如上所示。|1806828|(为了完整起见，请注意，具有一些基本扩展的Haskell确实允许使用可变的are函数；不过，使用它们需要对语言有很好的理解，而普通的Haskell+98可能根本不支持它们，因此固定的are函数对于标准库是更好的。)|1806829|entityMap^0|0|0|0|B|7|K|8|T|8|2C|3|2G|4|2L|4|31|7|0|X|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|11|8|@$K|12|L|13|M|N]|$K|14|L|15|M|N]|$K|16|L|17|M|N]|$K|18|L|19|M|N]|$K|1A|L|1B|M|N]|$K|1C|L|1D|M|N]|$K|1E|L|1F|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|1G|8|@$K|1H|L|1I|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$B|C]]|$1|S|3|T|5|F|7|1K|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1L|8|@]|9|@]|A|$]]|$1|W|3|-4|5|F|7|1M|8|@]|9|@]|A|$]]]|X|$]]

<pre><code>(map vector '(1 2 3) '(4 5 6))
</code></pre>

does what you want:

<pre><code>=&gt; ([1 4] [2 5] [3 6])
</code></pre>

Haskell needs a collection of <code>zipWith</code> (<code>zipWith3</code>, <code>zipWith4</code>, ...) functions, because they all need to be of a specific type; in particular, the number of input lists they accept needs to be fixed. (The <code>zip</code>, <code>zip2</code>, <code>zip3</code>, ... family can be regarded as a specialisation of the <code>zipWith</code> family for the common use case of tupling).

In contrast, Clojure and other Lisps have good support for variable arity functions; <code>map</code> is one of them and can be used for "tupling" in a manner similar to Haskell's

<pre><code>zipWith (\x y -&gt; (x, y))
</code></pre>

The idiomatic way to build a "tuple" in Clojure is to construct a short vector, as displayed above.

(Just for completeness, note that Haskell with some basic extensions does allow variable arity functions; using them requires a good understanding of the language, though, and the vanilla Haskell 98 probably doesn't support them at all, thus fixed arity functions are preferrable for the standard library.)

blocks|key|1806837|text|(map+vector+[1+2+3]+[4+5+6])|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1806838|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>(map vector [1 2 3] [4 5 6])
</code></pre>

blocks|key|1806889|text|为了确切地满足您的需求，在两个列表之间映射list将为您提供一个列表列表，如您的示例所示。我认为许多克洛乔斯人倾向于使用向量来实现这一点，尽管它适用于任何东西。并且输入不需要是相同的类型。map从它们创建seq，然后映射seq，因此任何可排序的输入都将正常工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1806890|(map+list+'(1+2+3)+'(4+5+6))
(map+list++[1+2+3]+'(4+5+6))
(map+hash-map++'(1+2+3)+'(4+5+6))
(map+hash-set++'(1+2+3)+'(4+5+6))|code-block|syntax|javascript|1806891|entityMap^0|L|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

to give you exactly what you wanted, mapping <code>list</code> across the two lists will give you a list of lists like in your example. I think that many Clojurians would tend to use vectors for this though it will work with anything. and the inputs do not need to be the same type. map creates seqs from them and then maps the seqs so any seq'able input will work fine. 

<pre><code>(map list '(1 2 3) '(4 5 6))
(map list [1 2 3] '(4 5 6))
(map hash-map '(1 2 3) '(4 5 6))
(map hash-set '(1 2 3) '(4 5 6))
</code></pre>

blocks|key|2020457|text|内置的方法是简单地使用函数'interleave'：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2020458|(interleave+[1+2+3+4]+[5+6+7+8])+=>+[1+5+2+6+3+7+4+8]|code-block|syntax|javascript|2020459|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|$]]

The built-in way would simply be the function 'interleave':

<pre><code>(interleave [1 2 3 4] [5 6 7 8]) =&gt; [1 5 2 6 3 7 4 8]
</code></pre>

blocks|key|2020461|text|(partition+2+(interleave+'(1+2+3)+'(4+5+6)))+
=>+((1+4)+(2+5)+(3+6))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2020462|或者更一般地说|unstyled|2020463|(defn+zip+[&+colls]
++(partition+(count+colls)+(apply+interleave+colls)))

(zip+'(+1+2+3)+'(4+5+6))+++++++++++;=>+((1+4)+(2+5)+(3+6))

(zip+'(+1+2+3)+'(4+5+6)+'(2+4+8))++;=>+((1+4+2)+(2+5+4)+(3+6+8))|2020464|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>(partition 2 (interleave '(1 2 3) '(4 5 6))) 
=&gt; ((1 4) (2 5) (3 6))
</code></pre>

or more generally

<pre><code>(defn zip [&amp; colls]
 (partition (count colls) (apply interleave colls)))

(zip '( 1 2 3) '(4 5 6)) ;=&gt; ((1 4) (2 5) (3 6))

(zip '( 1 2 3) '(4 5 6) '(2 4 8)) ;=&gt; ((1 4 2) (2 5 4) (3 6 8))
</code></pre>

blocks|key|2020521|text|#(应用映射列表%25)转置矩阵，就像Python+zip*函数一样。作为宏定义：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2020522|user=>+(定义宏py-zip+lst+`(应用映射列表~lst))|2020523|#'user/py-zip|2020524|user=>+(py-zip+'((1+2+3+4)+(9+9+9)+(5+6+7+8)|2020525|((195)(296)(397)(498))|2020526|user=>+(py-zip‘((19+5)+(2+9+6)+(3+9+7)+(4+9+8)|2020527|((1+2+3+4)+(9+9+9)+(5+6+7+8))|2020528|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

#(apply map list %) transposes a matrix just like the Python zip* function. As a macro definition:

user=> (defmacro py-zip [lst] `(apply map list ~lst))

#'user/py-zip

user=> (py-zip '((1 2 3 4) (9 9 9 9) (5 6 7 8)))

((1 9 5) (2 9 6) (3 9 7) (4 9 8))

user=> (py-zip '((1 9 5) (2 9 6) (3 9 7) (4 9 8)))

((1 2 3 4) (9 9 9 9) (5 6 7 8))

blocks|key|2020655|text|有一个叫做zipmap的函数，可能有类似的效果，(zipmap+(1+2+3)(4+5+6))输出如下：{3+6，2+5，1+4}|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2020656|entityMap^0|W|7|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

There is a function called zipmap, that may have the similar effect,
 (zipmap <code>(1 2 3)</code>(4 5 6))
The ouput is as fllows:
 {3 6, 2 5, 1 4}

In Clojure, I want to combine two lists to give a list of pairs, 

<pre><code>&gt; (zip '(1 2 3) '(4 5 6)) 
((1 4) (2 5) (3 6))
</code></pre>

In Haskell or Ruby the function is called zip. Implementing it is not difficult, but I wanted to make sure I wasn't missing a function in Core or Contrib.

There is a <a href="http://richhickey.github.com/clojure/clojure.zip-api.html" rel="noreferrer">zip</a> namespace in Core, but it is <a href="http://clojure.org/other_libraries" rel="noreferrer">described</a> as providing access to the Zipper functional technique, which does not appear to be what I am after.

Is there an equivalent function for combining 2 or more lists, in this way, in Core? 

If there is not, is it because there is an idiomatic approach that renders the function unneeded?

Is there an equivalent for the Zip function in Clojure Core or Contrib?

在Clojure中，我想组合两个列表来给出一个配对列表，> (zip '(1 2 3) '(4 5 6))  ((1 4) (2 5) (3 6))在Haskell或Ruby中，该函数称为zip。实现它并不困难，但我想确保我没有遗漏Core或Contrib中的一个函数。核心中有一个名称空间，但它是 as，提供对Zipp...

问在Clojure Core或Contrib中是否有对应的Zip函数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Clojure Core或Contrib中是否有对应的Zip函数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Clojure Core或Contrib中是否有对应的Zip函数？
EN