如何遍历Clojure中的嵌套dict / hash-map自定义拼合/转换我的数据结构？

Question

I have something that looks like this:

{:person-123 {:xxx [1 5]
              :zzz [2 3 4]}
 :person-456 {:yyy [6 7]}}

And I want to transform it so it looks like this:

[{:person "123" :item "xxx"}
 {:person "123" :item "zzz"}
 {:person "456" :item "yyy"}]

This is a flatten -like problem, and I know I can convert the keywords into strings by calling name on them, but I couldn't come across a convenient way to do this.

This is how I did it, but it seems inelegant (nested for loops, I'm looking at you):

(require '[clojure.string :refer [split]])
(into [] 
      (apply concat
             (for [[person nested-data] input-data]
                  (for [[item _] nested-data]
                       {:person (last (split (name person) #"person-"))
                        :item (name item)}))))

Answer 1

Your solution is not too bad, as for the nested for loops, well for actually supports nested loops, so you could write it as:

(vec 
  (for [[person nested-data] input-data
       [item _] nested-data]
    {:person (last (clojure.string/split (name person) #"person-"))
     :item   (name item)}))

personally, I tend to use for exclusively for that purpose (nested loops), otherwise I am usually more comfortable with map et al. But thats just a personal preference.

I also very much agree with @amalloy's comment on the question, I would put some effort into having a better looking map structure to begin with.

Answer 2

(let [x {:person-123 {:xxx [1 5]
                              :zzz [2 3 4]}
                 :person-456 {:yyy [6 7]}}]

            (clojure.pprint/pprint
                (mapcat
                    (fn [[k v]]
                        (map (fn [[k1 v1]]
                                 {:person (clojure.string/replace (name k) #"person-" "") :item (name k1)}) v))
                    x))
            )

I am not sure if there is a single high-order function, at least in the core, that does what you want in one go.

On the other hand, similar methods exist in GNU R reshape library, which, by the way, has been recreated for clojure: https://crossclj.info/ns/grafter/0.8.6/grafter.tabular.melt.html#_melt-column-groups which might interest you.

This is how it works in Gnu R: http://www.statmethods.net/management/reshape.html

Answer 3

Lots of good solutions so far. All I would add is a simplification with keys :

(vec
     (for [[person nested-data] input-data
           item (map name (keys nested-data))]
       {:person (clojure.string/replace-first
                  (name person)
                  #"person-" "")
        :item   item}))

Note btw the near universal preference for replace over last/split. Guessing the spirit of the transformation is "lose the leading person- prefix", replace says that better. If OTOH the spirit is "find the number and use that", a bit of regex to isolate the digits would be truer.

Answer 4

(reduce-kv (fn [ret k v]
             (into ret (map (fn [v-k]
                              {:person (last (str/split (name k) #"-"))
                               :item   (name v-k)}) 
                            (keys v))))
           []
           {:person-123 {:xxx [1 5] :zzz [2 3 4]}
            :person-456 {:yyy [6 7]}})

=> [{:person "123", :item "xxx"} 
    {:person "123", :item "zzz"} 
    {:person "456", :item "yyy"}]

Answer 5

Here are three solutions.

The first solution uses Python-style lazy generator functions via lazy-gen and yield functions from the Tupelo library . I think this method is the simplest since the inner loop produces maps and the outer loop produces a sequence. Also, the inner loop can run zero, one, or multiple times for each outer loop. With yield you don't need to think about that part.

(ns tst.clj.core
  (:use clj.core clojure.test tupelo.test)
  (:require
    [clojure.string :as str]
    [clojure.walk :as walk]
    [clojure.pprint :refer [pprint]]
    [tupelo.core :as t]
    [tupelo.string :as ts]
  ))
(t/refer-tupelo)

(def data
  {:person-123 {:xxx [1 5]
                :zzz [2 3 4]}
   :person-456 {:yyy [6 7]}})

(defn reformat-gen [data]
  (t/lazy-gen
    (doseq [[outer-key outer-val] data]
      (let [int-str (str/replace (name outer-key) "person-" "")]
        (doseq [[inner-key inner-val] outer-val]
          (let [inner-key-str (name inner-key)]
            (t/yield {:person int-str :item inner-key-str})))))))

---

If you really want to be "pure", the following is another solution. However, with this solution I made a couple of errors and required many, many debug printouts to fix. This version uses tupelo.core/glue instead of concat since it is "safer" and verifies that the collections are all maps, all vectors/list, etc.

(defn reformat-glue [data]
  (apply t/glue
    (forv [[outer-key outer-val] data]
      (let [int-str (str/replace (name outer-key) "person-" "")]
        (forv [[inner-key inner-val] outer-val]
          (let [inner-key-str (name inner-key)]
            {:person int-str :item inner-key-str}))))))

Both methods give the same answer:

(newline) (println "reformat-gen:")
(pprint (reformat-gen data))
(newline) (println "reformat-glue:")
(pprint (reformat-glue data))

reformat-gen:
({:person "123", :item "xxx"}
 {:person "123", :item "zzz"}
 {:person "456", :item "yyy"})

reformat-glue:
[{:person "123", :item "xxx"}
 {:person "123", :item "zzz"}
 {:person "456", :item "yyy"}]

---

If you wanted to be "super-pure", here is a third solution (although I think this one is trying too hard!). Here we use the ability of the for macro to have nested elements in a single expression. for can also embed let expressions inside itself, although here that leads to duplicate evaluation of int-str .

(defn reformat-overboard [data]
  (for [[outer-key outer-val] data
        [inner-key inner-val] outer-val
        :let [int-str       (str/replace (name outer-key) "person-" "") ; duplicate evaluation
              inner-key-str (name inner-key)]]
    {:person int-str :item inner-key-str}))
(newline)
(println "reformat-overboard:")
(pprint (reformat-overboard data))

reformat-overboard:
({:person "123", :item "xxx"}
 {:person "123", :item "zzz"}
 {:person "456", :item "yyy"})

I would probably stick with the first one since it is (at least to me) much simpler and more bulletproof. YMMV.

---

Update:

Notice that the 3rd method yields a single sequence of maps, even though there are 2 nested for iterations happening. This is different than having two nested for expressions, which would yield a sequence of a sequence of maps.