一、LISP—决策
Construct | 描述 |
---|---|
cond | 这个结构是用于用于检查多个测试行动作条件。它可以嵌套if或其他编程语言语句。 |
if | if结构有多种形式。在最简单的形式,它后面跟着一个测试条,测试操作和一些其它相应措施(次)。如果测试子句的值为true,那么测试的动作被执行,否则,由此产生的子句求值。 |
when | 在最简单的形式,它后面跟着一个测试条和测试操作。如果测试子句的值为true,那么测试的动作被执行,否则,由此产生的子句求值。 |
case | 这种结构实现了像cond 构造多个测试行动语句。但是,它会评估的关键形式,并允许根据该键的形式评价多个行动语句。 |
cond结构允许实现分支,可以看出其中的条件测试和执行动作是一个整体,条件测试为真,则执行对应的动作。反之,~~
;决策——cond结构
(setq a 30)
(cond ((> a 20) (format t "~%a is less than 20"))
(t (format t "~%value of a is ~d" a)));如果前一句执行,则不执行这一句,直接默认条件成立
if语句就是最基本的条件判断了,这里需要注意的是if-then和if-then-else的结构情况,具体看下面的例子。
;决策——if结构
(setq b 15)
(if (> b 20)
(format t "~%b is more than 20");if语句满足时执行
(format t "~%value of b is ~d" b))
; ;——if-then结构
(setq b 15)
(if (> b 20)
then (format t "~%b is less than 20"));if语句不满足时,执行then后的语句~~
(format t "~%value of b is ~d" b)
;——if-then-else结构
(setq c 30)
(if (> c 20 );这里的结构并没有then和else的关键字
(format t "~%c is greater than 20")
(format t "~%c is less than 20"))
(format t "~%value of c is ~d" c)
当没有循环时,when的作用类似于if的功能。
; ;决策——when结构
(setq d 100)
(when (> d 20)
(format t "~%d is greater than 20"))
(format t "~%value of d is ~d" d)
这里没有提到缺省情况下的结果,尝试了(setq day 8),结果没有输出也不报错~~
; ;决策——case结构
(setq day 6)
(case day
(1 (format t "~% Monday"))
(2 (format t "~% Tuesday"))
(3 (format t "~% Wednesday"))
(4 (format t "~% Thursday"))
(5 (format t "~% Friday"))
(6 (format t "~% Saturday"))
(7 (format t "~% Sunday")))
二、LISP—循环
Construct | 描述 |
---|---|
loop | 循环loop结构是迭代通过LISP提供的最简单的形式。在其最简单的形式,它可以重复执行某些语句(次),直到找到一个return语句。 |
loop for | loop结构可以实现一个for循环迭代一样作为最常见于其他语言。 |
do | do 结构也可用于使用LISP进行迭代。它提供了迭代的一种结构形式。 |
dotimes | dotimes构造允许循环一段固定的迭代次数。 |
dolist | dolist来构造允许迭代通过列表的每个元素。 |
loop就是最基本的迭代形式,但它自身没有终止的功能,需要借助when 、for和if等来实现迭代的终止。下面的这段代码,其中的when可以用if替换,正如我之前所说,when的功能类似于if。
;loop结构,其中利用when作为循环判断
(setq a 10)
(print a)
(loop
(setq a (+ a 1))
(print a)
;(terpri);作为一次换行
(when (> a 20) (return a))
)
loop-for可以理解为其他高级语言的for语句。下面的代码可以看出来,for-in语句是Python中的语法,所以说LISP是Python的祖师爷一点也不过分,Python还参考了LISP很多特性,就我目前发现的举一个例子。LISP中定义一个函数,可以在函数内部用两个双引号“ ”来包围该函数的特性及功能说明,这种设计在Python中也存在,即Python的__doc__方法,在IDLE中可以调用某类的__doc__方法,打印出对该类的说明。
;loop-for结构
;利用loop-for和do的循环结构
(loop for x in ' (study hard!)
do(format t "~s" x))
;使用from-to结构
(loop for a from 10 to 20
do(print a));print会自动换行,write不会
;假如if语句,增加条件
(loop for b from 10 to 30
if(evenp b)
do(print b))
这里看上去似乎没有终止的关键字,实际上,do之后的第二部分就是条件测试部分,(= x y),判断x和y是否相等。
;do结构
(do ((x 0 (+ x 2))
(y 20 (- y 2)));变量与变量的迭代过程需要再用括号括起来,以便区分测试中断的代码
((= x y)(- x y));似乎后面的(- x y)并没有什么作用~~
(format t "~%x = ~d y = ~d" x y))
既然给出了固定的迭代次数,也就没必要有终止的条件测试了。
;dotimes结构,给出固定的循环次数
(dotimes (n 10)
(write n)
(format t " ")
(write (* n n))
(terpri))
dolist构造的目的是将列表中元素逐一进行运算。不知道有没有注意到下面的注释,元素之间区分用空格,为什么会是这样呢?其他语言不都是用逗号吗?不要用“约翰·麦卡锡就是这样设计的”这种无脑的答案。好吧,其实这样的答案也没错,但再回想一下,之前定义名字(变量名、函数名等)时说了,可以使用特殊字符,那么逗号“,”也算咯,所以不小心用Python的编程思维将元素用逗号隔开,对于LISP编译器来说其实是一个原子(元素),这样想,以后应该也就不会再犯这样的错误了。
;dolist结构,逐个迭代列表中的元素,元素之间的区分用空格
(dolist (a ' (1 2 3 4 5 6 7 8 9))
(format t "~%Number = ~d , Square = ~d" a (* a a)))
下面的这段程序刚开始看感觉有点懵,不过认真一读,其实就是几个知识点的融合,block 、if 和函数定义defun。
;块返回,从允许从正常情况下的任何错误的任何嵌套块退出。
(defun demo-function (flag)
(print 'entering-outer-block)
(block outer-block
(print 'entering-inner-block)
(print (block inner-block
(if flag
(return-from outer-block 3);返回到外部块,返回3,但并不输出
(return-from inner-block 5));退出内部块,返回5,其外层为print,故将5打印出来
(print 'This-wil--not-be-printed)))
(print 'left-inner-block)
(print 'leaving-outer-block)
t))
(demo-function t)
(terpri)
(terpri)
(demo-function nil)
输出结果为:
ENTERING-OUTER-BLOCK ENTERING-INNER-BLOCK ENTERING-OUTER-BLOCK ENTERING-INNER-BLOCK 5 LEFT-INNER-BLOCK LEAVING-OUTER-BLOCK
正如第七行的注释所说,虽然返回到外部块为3,但并没有打印,所以输出不会显示3,如果修改为如下代码,增加了print,自然会打印出3。但是又会在最后一行增加打印了一个“T”。其实原本的代码中,外部块的最后一个“t”,我的理解是类似于“return 0”的功能,之后外部块被print包围,那么“t”就相当于一个字符被打印出来。其实这里有点模糊,打印出的字面字符,需要在前面加上一个单引号,但是实际上没有,尝试着加上单引号,结果还是一样。那么可以认为这个打印出的“T”不是字面意义上的字符,而是“TRUE”的意思。
(defun demo-function (flag)
(print 'entering-outer-block)
(print (block outer-block
(print 'entering-inner-block)
(print (block inner-block
(if flag
(return-from outer-block 3)
(return-from inner-block 5))
(print 'This-wil--not-be-printed)))
(print 'left-inner-block)
(print 'leaving-outer-block)
t)))
(demo-function t)
(terpri)
(demo-function nil)
输出结果为:
ENTERING-INNER-BLOCK
3
ENTERING-OUTER-BLOCK
ENTERING-INNER-BLOCK
5
LEFT-INNER-BLOCK
LEAVING-OUTER-BLOCK
T
三、LISP—函数
这里给出的&optional,&rest,&key都是基于实参的灵活设定。函数最后一个表达式的结果作为函数的返回值,实际就是简化了函数的运算量,return-from的偏执我先不聊,以后发现了它的优点再说。
lambda函数在我看来应该很重要,如果没记错的话,Java的jdk1.8中就添加了lambda这一特性,Python中当然也有。Python中的解释就是匿名函数,只是简单或是不常重复使用的函数运算,那么用匿名函数来代替函数的定义显得更加高效。时间和空间上的简化肯定是每个人都期望的。在维基百科中,LISP的闭包概念(词法闭包,或函数闭包)中,有一种说法是“闭包用来指代某些其开放绑定(自由变量)已经由其语法环境完成闭合(或者绑定)的lambda表达式,从而形成闭合的表达式”。所以单纯以匿名函数的概念来定义lambda函数,似乎有些肤浅了。
而映射函数,我的注释应该可以说清楚了。
;函数——可选参数,&optional之后的形参对应的实参可有可无
(defun show-members (a b &optional c d) (write (list a b c d)));这里&optional的作用是如若之后的实参没有,则返回NIL
(show-members 1 2 3)
(terpri)
(show-members 'a 'b 'c 'd)
(terpri)
(show-members 'a 'b)
(terpri)
(show-members 1 2 3 4)
(terpri)
;(show-members 'a );这个就会报错,说至少应该有两个参数
;函数——其余部分参数,&rest之后的形参对应的实参可以为空,或者为单个、多个元素,总之以列表形式得出
(defun show-members(a b &rest c) (write(list a b c)))
(show-members 1 2 3)
(terpri)
(show-members 'a 'b)
(terpri)
(show-members 'a 'b 'c 'd 'e)
(terpri)
(show-members 1 2 3 4 5 6 7 8 9)
;关键字参数,可以将实参与指定的形参对应,很强势
(defun show-members(&key a b c d) (write (list a b c d)))
(show-members :a 3 :b "asa" :d 'k );单个字符值需要在前面加上单引号,不然编译器会以为是变量名
;;(show-members :a (1 2) );尝试过了,编译器要求实参为符号,不能是列表
;函数的最后一个表达式作为函数返回值的值
(defun add-all(a b c d)
(+ a b c d))
(setq sum (add-all 10 20 30 40))
(write sum)
(terpri)
(write (add-all 23.4 56.7 34.9 10.0))
;通过return-from强势返回其要求的返回值
(defun my-fun(num)
(return-from my-fun 10)
(write 20));当有return-from时,这一句就不会被执行
(write (my-fun 30))
;lambda函数
(write ((lambda (a b c d)
(+ (* a b) (/ c d))
)
2 3 10 5));lambda表达式和实参是分离的,各自用括号括起来
;映射函数,将实参列表逐一进行运算,若在函数内部运算的另一部分也是列表,
;那么运算结果以实参列表与内部运算列表的一一映射的结果为准
(write (mapcar '1+ '(1 2 3)))
(terpri)
(write (mapcar '+ '(1 2 3 4 5 6) '(1 2 3)))
(terpri)
(defun cube-my-list(num)
(mapcar #' (lambda(x) (* x x x x)) num));强调,lambda与传入的参数是分离的,分离的,分离的
(write (cube-my-list '(1 2 3 4 5)))