Hinzufügen von Schlüssel- Wert-Paaren Karten in einer Liste von Karten aus einer anderen Liste von Karten in clojure

Question

Ich habe eine Liste von Karten

({:path "first" :size "1 gb"} 
    {:path "second" :size "500 mb"} 
    ...) 

und eine weitere Liste von Karten

({:path "first" :size "1 gb" :date "1"} 
    {:path "second" :size "500 mb" :date "1"} 
    {:path "first" :size "0.9 gb" :date "2"}... 
    {:path "second" :size "400 mb" :date "2"}... 
...) 

Ich mag holen Sie sich die erste Liste der Karten zu etwas verwandelt wie

({:path "first" :sizeon1 "1 gb" :sizeon2 "0.9 gb"...} 
    {:path "second" :sizeon1 "500 mb" :sizeon2 "400 mb"...} 
    ....) 

ich bin ein noob Clojure und eine harte Zeit, dies zu tun haben. Kannst du mir bitte helfen?

Answer 1

Was würde ich tun, ist die resultierende Datenstruktur zu überdenken: Ich weiß nicht, wie würden Sie möglicherweise die resultierende Sammlung verwenden, aber die Benennung Schlüssel :sizeonX, vor allem, wenn es potenziell variable Menge der registrierten Daten oder einige von ihnen fehlen vielleicht (wie zum Beispiel, wenn Sie Termine 1 und 3 für den ersten Weg haben, und 1235 für die zweite) führt zu einem Durcheinander von unvorhersehbar benannten Schlüsseln in resultierenden Karten, die es Art und Weise machen würde schwieriger, wenn es darum geht, diese Schlüssel abzurufen. ich es sieht so aus, dass es besser wäre, diese Struktur zu verwenden:

{:path "first" :sizes {"1" "500" "2" "1g" "10" "222"}} 

so Größen dieser Karte leicht iterativ und verarbeitet wird.

das ist, wie würde ich das tun:

(def data '({:path "first" :size "1 gb" :date "1"} 
      {:path "first" :size "0.9 gb" :date "3"} 
      {:path "second" :size "500 mb" :date "1"} 
      {:path "second" :size "700 mb" :date "2"} 
      {:path "second" :size "400 mb" :date "3"} 
      {:path "second" :size "900 mb" :date "5"})) 

(map (fn [[k v]] {:path k 
        :sizes (into {} (map (juxt :date :size) v))}) 
    (group-by :path data)) 

;; ({:path "first", :sizes {"1" "1 gb", "3" "0.9 gb"}} 
;; {:path "second", :sizes {"1" "500 mb", 
;;       "2" "700 mb", 
;;       "3" "400 mb", 
;;       "5" "900 mb"}}) 

Update

aber wie Sie noch die Struktur von der Frage brauchen, ich es so tun würde:

(map (fn [[k v]] 
     (into {:path k} 
      (map #(vector (keyword (str "sizeon" (:date %))) 
          (:size %)) 
       v))) 
    (group-by :path data)) 

;;({:path "first", :sizeon1 "1 gb", :sizeon3 "0.9 gb"} 
;; {:path "second", 
;; :sizeon1 "500 mb", :sizeon2 "700 mb", 
;; :sizeon3 "400 mb", :sizeon5 "900 mb"}) 

das ist im Grunde ähnlich zu @superkonduktr Variante.

Answer 2

Alles wird klar, wenn Sie Ihre Aufgabe in kleinere Teile zerlegen.

Zunächst definiert einen Helfer diese :sizeon1 Schlüssel im Ergebnisdatensatz zu erstellen:

(defn date-key 
    [date] 
    (keyword (str "sizeon" date))) 

Als nächstes wollen Sie eine Sammlung von einzelnen Pfaddaten in aggregierter Karte zu reduzieren, wie eine Sammlung unter der Annahme, sieht aus, als Sie beschrieben:

[{:path "first" :size "1 gb" :date "1"} 
{:path "first" :size "0.9 gb" :date "2"} 
;; ... 
] 

reduce ist nur das Werkzeug dafür:

(defn reduce-path 
    [path-data] 
    (reduce 
    ;; A function that takes an accumulator map and an element in the collection 
    ;; from which you take date and size and assoc them under the appropriate keys 
    (fn [acc el] 
     (let [{:keys [date size]} el] 
     (assoc acc (date-key date) size))) 
    ;; A starting value for the accumulator containing the common path 
    ;; for this collection 
    {:path (:path (first path-data))} 
    ;; The collection of single path data to reduce 
    path-data)) 

Schließlich nehmen Sie das Raw-Dataset mit verschiedenen Pfaden, partitionieren Sie es nach Pfad und ordnen Sie ihm die reduce-path-Funktion zu.

(def data 
    [{:path "first" :size "1 gb" :date "1"} 
    {:path "first" :size "0.9 gb" :date "2"} 
    {:path "second" :size "500 mb" :date "1"} 
    {:path "second" :size "400 mb" :date "2"}]) 

(->> data 
    (partition-by :path) 
    (map reduce-path)) 

Beachten Sie, dass dieser Code geht davon aus, dass Ihre anfängliche data Sammlung bereits von :path sortiert ist. Andernfalls funktioniert partition-by nicht wie erwartet, und die Daten müssen entsprechend vorbereitet werden.

Answer 3

(def data '({:path "first" :size "1 gb" :date "1"} 
      {:path "second" :size "500 mb" :date "1"} 
      {:path "first" :size "0.9 gb" :date "2"} 
      {:path "second" :size "400 mb" :date "2"})) 

(defn- reduce-group [g] 
    (reduce (fn [acc m] (assoc acc 
          (keyword (str "sizeon" (:date m))) 
          (:size m))) 
      (first g) g)) 

(let [groups (group-by :path data)] 
    (map reduce-group (vals groups)))