Loops Clojure-使用过滤器

我试图遍历一个映射来计算单个事件的具体发生率，尽管我在使用下面的过滤器时遇到了一些问题。我想做的是过滤和统计每个“订单类别”的特定实例，这些实例出现在多个级别中-1、2等等。我可以迭代几个月并打印，但我对订单类别的筛选和计数似乎对我不起作用

 GROUPED_BY_MONTH(group-by :MONTH CON)

 ALL (for [flop GROUPED_BY_MONTH] {
    :MONTH  (:MONTH (first (second flop)))
    :ORDER1 (count (filter #(= "1" (:ORDER_CATEGORY %)) flop))
    :ORDER2 (count (filter #(= "2" (:ORDER_CATEGORY %)) flop))
})

我正在处理XML文件，我已成功地将其管理到一个串联列表中，并按如下方式分组：

[“01”[{：月份“01”，“订单”类别“1”}{：月份“01”，“订单”类别“1”}{：月份“01”，“订单”类别“2”}] [“02”[{：月份“02”，“订单”类别“1”}{：月份“02”，“订单”类别“2”}{：月份“02”，“订单”类别“2”}]

因此，我希望：

月订单1订单2

01-------2-------1

02--------1--------2

---

这可能是我忽略的一个相对简单的修复，所以提前感谢您的帮助

我首先将数据转换为：

user=> (pprint x)
[{:MONTH "01", :ORDER_CATEGORY "1"}
 {:MONTH "01", :ORDER_CATEGORY "1"}
 {:MONTH "01", :ORDER_CATEGORY "2"}
 {:MONTH "02", :ORDER_CATEGORY "1"}]

和使用功能：

user=> (defn inc1 [x] (if x (inc x) 1))
user=> (reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
                     (update-in acc [[MONTH ORDER_CATEGORY]] inc1)) {} x)
{["02" "1"] 1, ["01" "2"] 1, ["01" "1"] 2}

---

键是[月份类别]，值是订单数。

我首先将数据转换为：

user=> (pprint x)
[{:MONTH "01", :ORDER_CATEGORY "1"}
 {:MONTH "01", :ORDER_CATEGORY "1"}
 {:MONTH "01", :ORDER_CATEGORY "2"}
 {:MONTH "02", :ORDER_CATEGORY "1"}]

和使用功能：

user=> (defn inc1 [x] (if x (inc x) 1))
user=> (reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
                     (update-in acc [[MONTH ORDER_CATEGORY]] inc1)) {} x)
{["02" "1"] 1, ["01" "2"] 1, ["01" "1"] 2}

---

键是[月份类别]，值是订单数。

我首先将数据转换为：

user=> (pprint x)
[{:MONTH "01", :ORDER_CATEGORY "1"}
 {:MONTH "01", :ORDER_CATEGORY "1"}
 {:MONTH "01", :ORDER_CATEGORY "2"}
 {:MONTH "02", :ORDER_CATEGORY "1"}]

和使用功能：

user=> (defn inc1 [x] (if x (inc x) 1))
user=> (reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
                     (update-in acc [[MONTH ORDER_CATEGORY]] inc1)) {} x)
{["02" "1"] 1, ["01" "2"] 1, ["01" "1"] 2}

---

键是[月份类别]，值是订单数。

我首先将数据转换为：

user=> (pprint x)
[{:MONTH "01", :ORDER_CATEGORY "1"}
 {:MONTH "01", :ORDER_CATEGORY "1"}
 {:MONTH "01", :ORDER_CATEGORY "2"}
 {:MONTH "02", :ORDER_CATEGORY "1"}]

和使用功能：

user=> (defn inc1 [x] (if x (inc x) 1))
user=> (reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
                     (update-in acc [[MONTH ORDER_CATEGORY]] inc1)) {} x)
{["02" "1"] 1, ["01" "2"] 1, ["01" "1"] 2}

---

键是[Month Category]，值是订单数。

您的for循环不起作用，因为您已将这样的映射条目绑定到

flop

[“01”[{:MONTH“01”，ORDER_CATEGORY“1”}…]

过滤器表达式将其作为输入：

（filter#（=“1”（：ORDER#u CATEGORY%））触发器）

这将不起作用，因为

:ORDER\u CATEGORY

既不会为

“01”

返回某物，也不会为序列

[{:MONTH…}…]

返回某物

假设绑定到

flop

的是一个映射条目，您可以使用

val

来修复此问题：

（filter#（=“1”（：ORDER_CATEGORY%））（val-flop））

例如：

(for [flop GROUPED_BY_MONTH]
  {:MONTH  (:MONTH (first (second flop)))
   :ORDER1 (count (filter #(= "1" (:ORDER_CATEGORY %)) (val flop)))
   :ORDER2 (count (filter #(= "2" (:ORDER_CATEGORY %)) (val flop)))})
=> ({:MONTH "01", :ORDER1 2, :ORDER2 1} {:MONTH "02", :ORDER1 1, :ORDER2 0})

您还可以使用析构函数，使代码更加清晰：

(for [[month maps] GROUPED_BY_MONTH]
  {:MONTH month
   :ORDER1 (count (filter #(= "1" (:ORDER_CATEGORY %)) maps))
   :ORDER2 (count (filter #(= "2" (:ORDER_CATEGORY %)) maps))})
=> ({:MONTH "01", :ORDER1 2, :ORDER2 1} {:MONTH "02", :ORDER1 1, :ORDER2 0})

请注意，通常情况下，此解决方案更有利：

(reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
          (update-in acc [MONTH ORDER_CATEGORY] 
                     (fnil inc 0)))
        {} CON)
=> {"02" {"1" 1}, "01" {"2" 1, "1" 2}}

它返回

month->order category->count

的映射，该映射独立于输入集中存在的订单类别和月份的种类和类型

例如

(reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
          (update-in acc [MONTH ORDER_CATEGORY]
                     (fnil inc 0)))
        {} (conj CON
                 {:MONTH "01" :ORDER_CATEGORY "foo"}
                 {:MONTH "02" :ORDER_CATEGORY "foo"}
                 {:MONTH "02" :ORDER_CATEGORY "bar"}
                 {:MONTH "02" :ORDER_CATEGORY "1"}))
=> {"02" {"bar" 1, "foo" 1, "1" 2}, "01" {"foo" 1, "2" 1, "1" 2}}

---

但是，您应该注意，如果订单类别的计数为0，则结果中没有相关值

for循环不起作用，因为您已将这样的映射条目绑定到

flop

[“01”[{:MONTH“01”，ORDER_CATEGORY“1”}…]

过滤器表达式将其作为输入：

（filter#（=“1”（：ORDER#u CATEGORY%））触发器）

这将不起作用，因为

:ORDER\u CATEGORY

既不会为

“01”

返回某物，也不会为序列

[{:MONTH…}…]

返回某物

假设绑定到

flop

的是一个映射条目，您可以使用

val

来修复此问题：

（filter#（=“1”（：ORDER_CATEGORY%））（val-flop））

例如：

(for [flop GROUPED_BY_MONTH]
  {:MONTH  (:MONTH (first (second flop)))
   :ORDER1 (count (filter #(= "1" (:ORDER_CATEGORY %)) (val flop)))
   :ORDER2 (count (filter #(= "2" (:ORDER_CATEGORY %)) (val flop)))})
=> ({:MONTH "01", :ORDER1 2, :ORDER2 1} {:MONTH "02", :ORDER1 1, :ORDER2 0})

您还可以使用析构函数，使代码更加清晰：

(for [[month maps] GROUPED_BY_MONTH]
  {:MONTH month
   :ORDER1 (count (filter #(= "1" (:ORDER_CATEGORY %)) maps))
   :ORDER2 (count (filter #(= "2" (:ORDER_CATEGORY %)) maps))})
=> ({:MONTH "01", :ORDER1 2, :ORDER2 1} {:MONTH "02", :ORDER1 1, :ORDER2 0})

请注意，通常情况下，此解决方案更有利：

(reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
          (update-in acc [MONTH ORDER_CATEGORY] 
                     (fnil inc 0)))
        {} CON)
=> {"02" {"1" 1}, "01" {"2" 1, "1" 2}}

它返回

month->order category->count

的映射，该映射独立于输入集中存在的订单类别和月份的种类和类型

例如

(reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
          (update-in acc [MONTH ORDER_CATEGORY]
                     (fnil inc 0)))
        {} (conj CON
                 {:MONTH "01" :ORDER_CATEGORY "foo"}
                 {:MONTH "02" :ORDER_CATEGORY "foo"}
                 {:MONTH "02" :ORDER_CATEGORY "bar"}
                 {:MONTH "02" :ORDER_CATEGORY "1"}))
=> {"02" {"bar" 1, "foo" 1, "1" 2}, "01" {"foo" 1, "2" 1, "1" 2}}

---

但是，您应该注意，如果订单类别的计数为0，则结果中没有相关值

for循环不起作用，因为您已将这样的映射条目绑定到

flop

[“01”[{:MONTH“01”，ORDER_CATEGORY“1”}…]

过滤器表达式将其作为输入：

（filter#（=“1”（：ORDER#u CATEGORY%））触发器）

这将不起作用，因为

:ORDER\u CATEGORY

既不会为

“01”

返回某物，也不会为序列

[{:MONTH…}…]

返回某物

假设绑定到

flop

的是一个映射条目，您可以使用

val

来修复此问题：

（filter#（=“1”（：ORDER_CATEGORY%））（val-flop））

例如：

(for [flop GROUPED_BY_MONTH]
  {:MONTH  (:MONTH (first (second flop)))
   :ORDER1 (count (filter #(= "1" (:ORDER_CATEGORY %)) (val flop)))
   :ORDER2 (count (filter #(= "2" (:ORDER_CATEGORY %)) (val flop)))})
=> ({:MONTH "01", :ORDER1 2, :ORDER2 1} {:MONTH "02", :ORDER1 1, :ORDER2 0})

您还可以使用析构函数，使代码更加清晰：

(for [[month maps] GROUPED_BY_MONTH]
  {:MONTH month
   :ORDER1 (count (filter #(= "1" (:ORDER_CATEGORY %)) maps))
   :ORDER2 (count (filter #(= "2" (:ORDER_CATEGORY %)) maps))})
=> ({:MONTH "01", :ORDER1 2, :ORDER2 1} {:MONTH "02", :ORDER1 1, :ORDER2 0})

请注意，通常情况下，此解决方案更有利：

(reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
          (update-in acc [MONTH ORDER_CATEGORY] 
                     (fnil inc 0)))
        {} CON)
=> {"02" {"1" 1}, "01" {"2" 1, "1" 2}}

它返回

month->order category->count

的映射，该映射独立于输入集中存在的订单类别和月份的种类和类型

例如

(reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
          (update-in acc [MONTH ORDER_CATEGORY]
                     (fnil inc 0)))
        {} (conj CON
                 {:MONTH "01" :ORDER_CATEGORY "foo"}
                 {:MONTH "02" :ORDER_CATEGORY "foo"}
                 {:MONTH "02" :ORDER_CATEGORY "bar"}
                 {:MONTH "02" :ORDER_CATEGORY "1"}))
=> {"02" {"bar" 1, "foo" 1, "1" 2}, "01" {"foo" 1, "2" 1, "1" 2}}

---

但是，您应该注意，如果订单类别的计数为0，则结果中没有相关值

for循环不起作用，因为您已将这样的映射条目绑定到

flop

[“01”[{:MONTH“01”，ORDER_CATEGORY“1”}…]

过滤器表达式将其作为输入：

（filter#（=“1”（：ORDER#u CATEGORY%））触发器）

这将不起作用，因为

:ORDER\u CATEGORY

既不会为

“01”

返回某物，也不会为序列

[{:MONTH…}…]

返回某物

假设绑定到

flop

的是一个映射条目，您可以使用

val

来修复此问题：

（filter#（=“1”（：ORDER_CATEGORY%））（val-flop））

例如：

(for [flop GROUPED_BY_MONTH]
  {:MONTH  (:MONTH (first (second flop)))
   :ORDER1 (count (filter #(= "1" (:ORDER_CATEGORY %)) (val flop)))
   :ORDER2 (count (filter #(= "2" (:ORDER_CATEGORY %)) (val flop)))})
=> ({:MONTH "01", :ORDER1 2, :ORDER2 1} {:MONTH "02", :ORDER1 1, :ORDER2 0})

您还可以使用析构函数，使代码更加清晰：

(for [[month maps] GROUPED_BY_MONTH]
  {:MONTH month
   :ORDER1 (count (filter #(= "1" (:ORDER_CATEGORY %)) maps))
   :ORDER2 (count (filter #(= "2" (:ORDER_CATEGORY %)) maps))})
=> ({:MONTH "01", :ORDER1 2, :ORDER2 1} {:MONTH "02", :ORDER1 1, :ORDER2 0})

请注意，通常情况下，此解决方案更有利：

(reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
          (update-in acc [MONTH ORDER_CATEGORY] 
                     (fnil inc 0)))
        {} CON)
=> {"02" {"1" 1}, "01" {"2" 1, "1" 2}}

它返回

month->order category->count

的映射，该映射独立于输入集中存在的订单类别和月份的种类和类型

例如

(reduce (fn [acc {:keys [MONTH ORDER_CATEGORY]}]
          (update-in acc [MONTH ORDER_CATEGORY]
                     (fnil inc 0)))
        {} (conj CON
                 {:MONTH "01" :ORDER_CATEGORY "foo"}
                 {:MONTH "02" :ORDER_CATEGORY "foo"}
                 {:MONTH "02" :ORDER_CATEGORY "bar"}
                 {:MONTH "02" :ORDER_CATEGORY "1"}))
=> {"02" {"bar" 1, "foo" 1, "1" 2}, "01" {"foo" 1, "2" 1, "1" 2}}

但是，您应该注意，如果订单类别的计数为0，则n