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

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

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

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

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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