blocks|key|1415777|text|我是Clojure的n00b，所以可能会有更优雅的解决方案。这是我的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1415778|(def+example+{:a+1+:b+2+:c+3+:d+4})
(def+func+#(*+%25+%25))

(prn+example)

(defn+remap+[m+f]
++(apply+hash-map+(mapcat+#(list+%25+(f+(%25+m)))+(keys+m))))

(prn+(remap+example+func))|code-block|syntax|javascript|1415779|anon函数从每个键和它的f‘’ed值生成一个小的2-list。Mapcat在map的键序列上运行此函数，并将整个工作连接到一个大列表中。"apply+hash-+map“从该序列创建一个新的映射。(%25+m)可能看起来有点奇怪，它是用于将键应用于map以查找关联值的惯用Clojure。|1415780|最强烈推荐的读物:+The+Clojure+Cheat+Sheet。|offset|length|1415781|entityMap|0|LINK|mutability|MUTABLE|url|http://clojure.org/cheatsheet^0|0|0|0|E|J|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|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

I'm a Clojure n00b, so there may well be much more elegant solutions. Here's mine:

<pre><code>(def example {:a 1 :b 2 :c 3 :d 4})
(def func #(* % %))

(prn example)

(defn remap [m f]
 (apply hash-map (mapcat #(list % (f (% m))) (keys m))))

(prn (remap example func))
</code></pre>

The anon func makes a little 2-list from each key and its f'ed value. Mapcat runs this function over the sequence of the map's keys and concatenates the whole works into one big list. "apply hash-map" creates a new map from that sequence. The (% m) may look a little weird, it's idiomatic Clojure for applying a key to a map to look up the associated value.

Most highly recommended reading: The <a href="http://clojure.org/cheatsheet" rel="nofollow noreferrer">Clojure Cheat Sheet</a> .

blocks|key|1200741|text|这是一种相当典型的变换地图的方法。zipmap获取一个键列表和一个值列表，然后“做正确的事情”，生成一个新的Clojure+map。您也可以将map放在关键点周围以更改它们，或者同时更改它们。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1200742|(zipmap+(keys+data)+(map+#(do-stuff+%25)+(vals+data)))|code-block|syntax|javascript|1200743|或者将其封装在函数中：|1200744|(defn+map-function-on-map-vals+[m+f]
++++(zipmap+(keys+m)+(map+f+(vals+m))))|1200745|entityMap^0|H|6|1Z|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

Here is a fairly typical way to transform a map.
<code> zipmap </code> takes a list of keys and a list of values and "does the right thing" producing a new Clojure map. You could also put the <code>map</code> around the keys to change them, or both. 

<pre><code>(zipmap (keys data) (map #(do-stuff %) (vals data)))
</code></pre>

or to wrap it up in your function:

<pre><code>(defn map-function-on-map-vals [m f]
 (zipmap (keys m) (map f (vals m))))
</code></pre>

blocks|key|1415903|text|我很喜欢你的reduce版本。我认为这是惯用的。这是一个使用列表理解的版本。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1415904|(defn+foo+[m+f]
++(into+{}+(for+[[k+v]+m]+[k+(f+v)])))|code-block|syntax|javascript|1415905|entityMap^0|6|6|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|$]]

I like your <code>reduce</code> version just fine. I think it's idiomatic. Here's a version using list comprehension anyways.

<pre><code>(defn foo [m f]
 (into {} (for [[k v] m] [k (f v)])))
</code></pre>

blocks|key|1200815|text|下面是一种相当惯用的方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1200816|(defn+map-function-on-map-vals+[m+f]
++++++++(apply+merge
+++++++++++++++(map+(fn+[[k+v]]+{k+(f+v)})
++++++++++++++++++++m)))|code-block|syntax|javascript|1200817|示例：|1200818|user>+(map-function-on-map-vals+{1+1,+2+2,+3+3}+inc))
{3+4,+2+3,+1+2}|1200819|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's a fairly idiomatic way to do this:

<pre><code>(defn map-function-on-map-vals [m f]
 (apply merge
 (map (fn [[k v]] {k (f v)})
 m)))
</code></pre>

Example:

<pre><code>user&gt; (map-function-on-map-vals {1 1, 2 2, 3 3} inc))
{3 4, 2 3, 1 2}
</code></pre>

blocks|key|1415948|text|您可以使用clojure.algo.generic.functor/fmap|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1415949|user=>+(use+'[clojure.algo.generic.functor+:only+(fmap)])
nil
user=>+(fmap+inc+{:a+1+:b+3+:c+5})
{:a+2,+:b+4,+:c+6}|code-block|syntax|javascript|1415950|entityMap|0|LINK|mutability|MUTABLE|url|https://clojure.github.io/algo.generic/clojure.algo.generic.functor-api.html#clojure.algo.generic.functor/fmap^0|5|X|5|X|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

You can use the <a href="https://clojure.github.io/algo.generic/clojure.algo.generic.functor-api.html#clojure.algo.generic.functor/fmap" rel="noreferrer"><code>clojure.algo.generic.functor/fmap</code></a>:

<pre><code>user=&gt; (use '[clojure.algo.generic.functor :only (fmap)])
nil
user=&gt; (fmap inc {:a 1 :b 3 :c 5})
{:a 2, :b 4, :c 6}
</code></pre>

blocks|key|1416000|text|map-map、map-map-keys和map-map-values|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1416001|我知道Clojure中没有这样的函数，但是这里有一个函数的map-map-values实现，您可以随意复制它。它附带了两个密切相关的函数，map-map和map-map-keys，这两个函数也是标准库中缺少的：|1416002|(defn+map-map
++++"Returns+a+new+map+with+each+key-value+pair+in+`m`+transformed+by+`f`.+`f`+takes+the+arguments+`[key+value]`+and+should+return+a+value+castable+to+a+map+entry,+such+as+`{transformed-key+transformed-value}`."
++++[f+m]
++++(into+(empty+m)+(map+#(apply+f+%25)+m))+)

(defn+map-map-keys+[f+m]
++++(map-map+(fn+[key+value]+{(f+key)+value})+m)+)

(defn+map-map-values+[f+m]
++++(map-map+(fn+[key+value]+{key+(f+value)})+m)+)|code-block|syntax|javascript|1416003|用法|1416004|您可以这样调用map-map-values：|1416005|(map-map-values+str+{:a+1+:b+2})
;;+++++++++++=>+{:a+"1",+:b+"2"}|1416006|另外两个函数如下所示：|1416007|(map-map-keys+str+{:a+1+:b+2})
;;+++++++++=>+{":a"+1,+":b"+2}
(map-map+(fn+[k+v]+{v+k})+{:a+1+:b+2})
;;++++=>+{1+:a,+2+:b}|1416008|可选的实现|1416009|如果您只需要map-map-keys或map-map-values，而不需要更通用的map-map函数，则可以使用这些不依赖于map-map的实现|1416010|(defn+map-map-keys+[f+m]
++++(into+(empty+m)
++++++++(for+[[key+value]+m]
++++++++++++{(f+key)+value}+)))

(defn+map-map-values+[f+m]
++++(into+(empty+m)
++++++++(for+[[key+value]+m]
++++++++++++{key+(f+value)}+)))|1416011|另外，如果你喜欢这种说法，这里有一个基于clojure.walk/walk而不是into的map-map的替代实现：|1416012|(defn+map-map+[f+m]
++++(clojure.walk/walk+#(apply+f+%25)+identity+m)+)|1416013|并行版本-+pmap-map等。|1416014|如果您需要的话，也有这些函数的并行版本。他们简单地使用pmap而不是map。|1416015|(defn+pmap-map+[f+m]
++++(into+(empty+m)+(pmap+#(apply+f+%25)+m))+)
(defn+pmap-map-keys+[f+m]
++++(pmap-map+(fn+[key+value]+{(f+key)+value})+m)+)
(defn+pmap-map-values+[f+m]
++++(pmap-map+(fn+[key+value]+{key+(f+value)})+m)+)|1416016|entityMap|0|LINK|mutability|MUTABLE|url|http://clojuredocs.org/clojure_core/clojure.walk/walk|1|http://clojuredocs.org/clojure_core/clojure.core/into|2|http://clojuredocs.org/clojure_core/clojure.core/pmap|3|http://clojuredocs.org/clojure_core/clojure.core/map^0|0|7|8|C|L|E|0|T|E|1X|7|25|C|0|0|0|7|E|0|0|0|0|0|6|C|J|E|16|7|1R|7|0|0|K|H|14|4|19|7|K|H|0|14|4|1|0|0|6|8|0|R|4|Y|3|R|4|2|Y|3|3|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|24|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|25|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|26|8|@$9|27|A|28|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|29|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|2A|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|2B|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|2C|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2D|8|@$9|2E|A|2F|B|C]|$9|2G|A|2H|B|C]|$9|2I|A|2J|B|C]|$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|10|3|11|5|J|7|2M|8|@]|D|@]|E|$K|L]]|$1|12|3|13|5|6|7|2N|8|@$9|2O|A|2P|B|C]|$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]]|D|@$9|2U|A|2V|1|2W]|$9|2X|A|2Y|1|2Z]]|E|$]]|$1|14|3|15|5|J|7|30|8|@]|D|@]|E|$K|L]]|$1|16|3|17|5|6|7|31|8|@$9|32|A|33|B|C]]|D|@]|E|$]]|$1|18|3|19|5|6|7|34|8|@$9|35|A|36|B|C]|$9|37|A|38|B|C]]|D|@$9|39|A|3A|1|3B]|$9|3C|A|3D|1|3E]]|E|$]]|$1|1A|3|1B|5|J|7|3F|8|@]|D|@]|E|$K|L]]|$1|1C|3|-4|5|6|7|3G|8|@]|D|@]|E|$]]]|1D|$1E|$5|1F|1G|1H|E|$1I|1J]]|1K|$5|1F|1G|1H|E|$1I|1L]]|1M|$5|1F|1G|1H|E|$1I|1N]]|1O|$5|1F|1G|1H|E|$1I|1P]]]]

<h1><code>map-map</code>, <code>map-map-keys</code>, and <code>map-map-values</code></h1>

I know of no existing function in Clojure for this, but here’s an implementation of that function as <code>map-map-values</code> that you are free to copy. It comes with two closely related functions, <code>map-map</code> and <code>map-map-keys</code>, which are also missing from the standard library:

<pre><code>(defn map-map
 "Returns a new map with each key-value pair in `m` transformed by `f`. `f` takes the arguments `[key value]` and should return a value castable to a map entry, such as `{transformed-key transformed-value}`."
 [f m]
 (into (empty m) (map #(apply f %) m)) )

(defn map-map-keys [f m]
 (map-map (fn [key value] {(f key) value}) m) )

(defn map-map-values [f m]
 (map-map (fn [key value] {key (f value)}) m) )
</code></pre>

<h2>Usage</h2>

You can call <code>map-map-values</code> like this:

<pre><code>(map-map-values str {:a 1 :b 2})
;; =&gt; {:a "1", :b "2"}
</code></pre>

And the other two functions like this:

<pre><code>(map-map-keys str {:a 1 :b 2})
;; =&gt; {":a" 1, ":b" 2}
(map-map (fn [k v] {v k}) {:a 1 :b 2})
;; =&gt; {1 :a, 2 :b}
</code></pre>

<h2>Alternative implementations</h2>

If you only want <code>map-map-keys</code> or <code>map-map-values</code>, without the more general <code>map-map</code> function, you can use these implementations, which don’t rely on <code>map-map</code>:

<pre><code>(defn map-map-keys [f m]
 (into (empty m)
 (for [[key value] m]
 {(f key) value} )))

(defn map-map-values [f m]
 (into (empty m)
 (for [[key value] m]
 {key (f value)} )))
</code></pre>

Also, here’s an alternative implementation of <code>map-map</code> that is based on <a href="http://clojuredocs.org/clojure_core/clojure.walk/walk" rel="noreferrer"><code>clojure.walk/walk</code></a> instead of <a href="http://clojuredocs.org/clojure_core/clojure.core/into" rel="noreferrer"><code>into</code></a>, if you prefer this phrasing:

<pre><code>(defn map-map [f m]
 (clojure.walk/walk #(apply f %) identity m) )
</code></pre>

<h2>Parellel versions – <code>pmap-map</code>, etc.</h2>

There are also parallel versions of these functions if you need them. They simply use <a href="http://clojuredocs.org/clojure_core/clojure.core/pmap" rel="noreferrer"><code>pmap</code></a> instead of <a href="http://clojuredocs.org/clojure_core/clojure.core/map" rel="noreferrer"><code>map</code></a>.

<pre><code>(defn pmap-map [f m]
 (into (empty m) (pmap #(apply f %) m)) )
(defn pmap-map-keys [f m]
 (pmap-map (fn [key value] {(f key) value}) m) )
(defn pmap-map-values [f m]
 (pmap-map (fn [key value] {key (f value)}) m) )
</code></pre>

blocks|key|1416055|text|取自Clojure+Cookbook，有reduce-kv：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1416056|(defn+map-kv+[m+f]
++(reduce-kv+#(assoc+%251+%252+(f+%253))+{}+m))|code-block|syntax|javascript|1416057|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|$]]

Taken from the Clojure Cookbook, there is reduce-kv:

<pre><code>(defn map-kv [m f]
 (reduce-kv #(assoc %1 %2 (f %3)) {} m))
</code></pre>

blocks|key|1200935|text|(defn+map-vals
++"Map+f+over+every+value+of+m.
+++Returns+a+map+with+the+same+keys+as+m,+where+each+of+its+values+is+now+the+result+of+applying+f+to+them+one+by+one.
+++f+is+a+function+of+one+arg,+which+will+be+called+which+each+value+of+m,+and+should+return+the+new+value.
+++Faster+then+map-vals-transient+on+small+maps+(8+elements+and+under)"
++[f+m]
++(reduce-kv+(fn+[m+k+v]
+++++++++++++++(assoc+m+k+(f+v)))
+++++++++++++{}+m))

(defn+map-vals-transient
++"Map+f+over+every+value+of+m.
+++Returns+a+map+with+the+same+keys+as+m,+where+each+of+its+values+is+now+the+result+of+applying+f+to+them+one+by+one.
+++f+is+a+function+of+one+arg,+which+will+be+called+which+each+value+of+m,+and+should+return+the+new+value.
+++Faster+then+map-vals+on+big+maps+(9+elements+or+more)"
++[f+m]
++(persistent!+(reduce-kv+(fn+[m+k+v]
++++++++++++++++++++++++++++(assoc!+m+k+(f+v)))
++++++++++++++++++++++++++(transient+{})+m)))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1200936|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>(defn map-vals
 "Map f over every value of m.
 Returns a map with the same keys as m, where each of its values is now the result of applying f to them one by one.
 f is a function of one arg, which will be called which each value of m, and should return the new value.
 Faster then map-vals-transient on small maps (8 elements and under)"
 [f m]
 (reduce-kv (fn [m k v]
 (assoc m k (f v)))
 {} m))

(defn map-vals-transient
 "Map f over every value of m.
 Returns a map with the same keys as m, where each of its values is now the result of applying f to them one by one.
 f is a function of one arg, which will be called which each value of m, and should return the new value.
 Faster then map-vals on big maps (9 elements or more)"
 [f m]
 (persistent! (reduce-kv (fn [m k v]
 (assoc! m k (f v)))
 (transient {}) m)))
</code></pre>

blocks|key|1416127|text|Clojure+1.7+(released，2015年6月30日)通过update提供了一个优雅的解决方案|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1416128|(defn+map-function-on-map-vals+[m+f]
++++(->>+(map+#(update+%25+1+f)+m)
+++++++++(into+{})))

(map-function-on-map-vals+{:a+"test"+:b+"testing"}+#(.toUpperCase+%25))
;;+=>+{:a+"TEST",+:b+"TESTING"}|code-block|syntax|javascript|1416129|entityMap|0|LINK|mutability|MUTABLE|url|https://clojure.org/news/2015/06/30/clojure-17|1|http://clojuredocs.org/clojure.core/update^0|Z|6|D|8|0|Z|6|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

Clojure 1.7 (<a href="https://clojure.org/news/2015/06/30/clojure-17" rel="nofollow noreferrer">released</a> June 30, 2015) provides an elegant solution for this with <a href="http://clojuredocs.org/clojure.core/update" rel="nofollow noreferrer"><code>update</code></a>:
<pre class="lang-clj prettyprint-override"><code>(defn map-function-on-map-vals [m f]
 (-&gt;&gt; (map #(update % 1 f) m)
 (into {})))

(map-function-on-map-vals {:a &quot;test&quot; :b &quot;testing&quot;} #(.toUpperCase %))
;; =&gt; {:a &quot;TEST&quot;, :b &quot;TESTING&quot;}
</code></pre>

I want to transform one map of values to another map with the same keys but with a function applied to the values. I would think there was a function for doing this in the clojure api, but I have been unable to find it. 

Here's an example implementation of what I'm looking for

<pre><code>(defn map-function-on-map-vals [m f]
 (reduce (fn [altered-map [k v]] (assoc altered-map k (f v))) {} m))
(println (map-function-on-map-vals {:a "test" :b "testing"} #(.toUpperCase %)))
{:b TESTING, :a TEST}
</code></pre>

Does anybody know if <code>map-function-on-map-vals</code> already exists? I would think it did (probably with a nicer name too).

Mapping a function on the values of a map in Clojure

我希望将一个值映射转换为另一个映射，使用相同的键，但对值应用一个函数。我认为在clojure api中有一个函数可以做到这一点，但我一直找不到它。下面是我正在寻找的实现示例(defn map-function-on-map-vals [m f]  (reduce (fn [altered-map [k v]] (ass...

问在Clojure中将函数映射到map的值上
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Clojure中将函数映射到map的值上EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Clojure中将函数映射到map的值上
EN