Clojure数据转换map和reduce

最新推荐文章于 2024-05-10 18:41:19 发布

追梦青春09

最新推荐文章于 2024-05-10 18:41:19 发布

阅读量831

点赞数 1

分类专栏：一起学clojure 文章标签： clojure map reduce for clojure map reduce

本文链接：https://blog.csdn.net/iceyung/article/details/86162241

版权

一起学clojure 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

推荐：平凡的你我
推荐语：一首歌，一段故事，一份平凡，蕴含着少许的伟大

说到map和reduce，想到的是著名的MapReduce架构，Clojure的map和reduce在使用上有一定的相似性，但使用更加方便，简洁。

map

map接收一个函数和一个collection作为参数，map的结果是对每一个元素应用到这个函数的一个collection¹：

(println (map #(str %) [:a :b :c :d]))
;;-> (:a :b :c :d)
;;-> 使用匿名函数将关键字转换为字符，map应用到了每一个元素中，即每一个元素都执行了一遍(#(str %) :a)

(println (class (map #(str %) [:a :b :c :d])))
;;-> clojure.lang.LazySeq

如上显示返回的不是一个向量，而是一个惰性序列，所以我们的map可以处理无穷序列：

(println (take 10(map #(str %) (range))))
;;-> (0 1 2 3 4 5 6 7 8 9)
;;-> 输出的元素为字符

注意我们使用take获取到前十个元素，因为不设定个数就会参数无穷序列。

当函数为println时，执行下列代码并不会打印出数据，这就是惰性，不会立马运算出，可以理解为接受参数并打印出来是一个副作用，惰性会使得不会触发这个副作用，可能不太好理解，该部分先记清就行，带副作用的函数和惰性结合需要小心，副作用有可能不被执行。

(def aa (map #(println %) ["aa" "bb" "cc"]))

此时，使用doall可以强制化执行：

(def aa (doall (map #(println %) ["aa" "bb" "cc"])))
;;-> aa
;;-> bb
;;-> cc

map可以接收不止一个collection，如果有多个collection，就会分别取一个元素作为函数的参数：

(defn example [a b]
  (str "a is " a ";b is " b))
(println (map example ["vv" "cc"] ["dd" "gg"]))
;;-> (a is vv;b is dd a is cc;b is gg)

程序的结束根据短的collection长度。

reduce

先看一个经典的例子：

(println (reduce + [1 2 3 4 5 6 7 8]))
;;-> 36

(println (reduce (fn [r x] (+ r (* x x))) [2 3 4]))
;;-> 27

首先将后续的向量中的第一个元素作为初始元素，即2赋值给r，然后再将r+3x3+4x4，结果等于27。

(println (reduce
            (fn [r x]
              (if (nil? x) r (conj r x)))
            []
            [:a nil :b nil :c]))
;;-> [:a :b :c]

同上一个类似，r初始赋值为[]，将[:a nil :b nil :c]中的nil过滤掉，输出结果为新的向量。

其它一些函数

complement

返回相反的布尔值

(println ((complement nil?) nil))
;;-> false

filter

真的结果输出

(println (filter #(> 3 %) [1 2 3 4 5]))
;;-> (1 2)
(println (filter (complement nil?) [:a :b :c nil]))
;;-> (:a :b :c)
(println (filter keyword? [:a :b :c 1 2]))
;;-> (:a :b :c)

remove

剔除结果为真的元素

(println (remove nil? [:a nil :b nil :c]))
;;-> (:a :b :c)

for

有点类似foreach，先绑定参数，再依次输出collection的元素：

(println (for [s [:a :b :c :d :e]]
           (str "str = " s)))
;;-> (str = :a str = :b str = :c str = :d str = :e)
;;-> 多参数类似多层循环
(println (for [s1 [:a :b :c :d :e]
              s2 [:xx :zz :vv]]
           (str " s1=" s1 " s2=" s2)))
;;-> ( s1=:a s2=:xx  s1=:a s2=:zz  s1=:a s2=:vv  s1=:b s2=:xx  s1=:b s2=:zz  s1=:b s2=:vv  s1=:c s2=:xx  s1=:c s2=:zz  s1=:c s2=:vv  s1=:d s2=:xx  s1=:d s2=:zz  s1=:d s2=:vv  s1=:e s2=:xx  s1=:e s2=:zz  s1=:e s2=:vv)

在for[]内部还可以使用:let 和:when，:let是用来绑定数据的，:when是用来说明执行条件，为真时下方的语句才会被执行²。

(for [x [0 1 2 3 4 5]
      :let [y (* x 3)]
      :when (even? y)]
  y)
;;=> (0 6 12)
(filter even? (range 10))
;;-> (0 2 4 6 8)
;;-> 返回偶数

vec

生成新的向量

(println (vec '(1 2 3)))
;;-> [1 2 3]

into

加入元素到[]向量

(println (into [] '(1 2 3)))
;;-> [1 2 3]

partition

分割一个collection的函数

(println (partition 2 [1 2 3 4 5 6]))
;;-> ((1 2) (3 4) (5 6))
(println (partition 3 [1 2 3 4 5 6 7]))
;;-> ((1 2 3) (4 5 6))
;;-> 使用partition-all不会丢弃元素
(println (partition-all 3 [1 2 3 4 5 6 7]))
;;-> ((1 2 3) (4 5 6) (7))
;;-> partition-by [f] 输入函数，满足函数的地方进行分割
(println (partition-by #(= 3 %) [1 2 3 4 5 6 7]))