LISP语言教程
Scheme 语言是LISP语言的一个方言(或说成变种)，它诞生于1975年的MIT，对于这个有近三十年历史的编程语言来说，它并没有象C++，java，C#那样受到商业领域的青睐，在国内更是显为人知。但它在国外的计算机教育领域内却是有着广泛应用的，有很多人学的第一门计算机语言就是Scheme语言。
Scheme 语言概要
Author: 宋国伟吉林省德惠市信息中心
Date: 2003 年 12 月 01 日
Scheme 语言是LISP语言的一个方言(或说成变种)，它诞生于1975年的MIT，对于这个有近三十年历史的编程语言来说，它并没有象C++，java，C#那样受到商业领域的青睐，在国内更是显为人知。但它在国外的计算机教育领域内却是有着广泛应用的，有很多人学的第一门计算机语言就是Scheme语言。
作为Lisp 变体，Scheme 是一门非常简洁的计算语言，使用它的编程人员可以摆脱语言本身的复杂性，把注意力集中到更重要的问题上，从而使语言真正成为解决问题的工具。本文分为上、下两部分来介绍 scheme 语言。
一．Scheme语言的特点
Scheme 语言是LISP语言的一个方言(或说成变种)，它诞生于1975年的MIT，对于这个有近三十年历史的编程语言来说，它并没有象C++，java，C#那样受到商业领域的青睐，在国内更是显为人知。但它在国外的计算机教育领域内却是有着广泛应用的，有很多人学的第一门计算机语言就是Scheme语言。
它是一个小巧而又强大的语言，作为一个多用途的编程语言，它可以作为脚本语言使用，也可以作为应用软件的扩展语言来使用，它具有元语言特性，还有很多独到的特色,以致于它被称为编程语言中的"皇后"。
下面是洪峰对Scheme语言的编程特色的归纳：
?词法定界（Lexical Scoping）
?动态类型（Dynamic Typing）
?良好的可扩展性
?尾递归（Tail Recursive）
?函数可以作为值返回
?支持一流的计算连续
?传值调用（passing-by-value）
?算术运算相对独立
本文的目的是让有编程基础（那怕是一点点）的朋友能尽快的掌握Scheme语言的语法规则，如果您在读完本文后，发现自己已经会用Scheme语言了，那么我的目的就达到了。
二．Scheme语言的标准与实现
R5RS (Revised(5) Report on the Algorithmic Language Scheme)
Scheme语言的语法规则的第5次修正稿，1998年制定，即Scheme语言的现行标准，目前大多数Scheme语言的实现都将达到或遵循此标准，并且几乎都加入了一些属于自己的扩展特色。
Guile (GNU's extension language)
Guile是GNU工程的一个项目，它是GNU扩展语言库，它也是Scheme语言的一个具体实现；如果你将它作为一个库打包，可以把它链接到你的应用程序中去，使你的应用程序具有自己的脚本语言，这个脚本语言目前就是Scheme语言。
Guile可以在LINUX和一些UNIX系统上运行，下面是简单的安装过程：
下载guile-1.6.4版，文件名为guile-1.6.4.tar.gz，执行下面的命令：
tar xvfz guile-1.6.4.tar.gz
cd guile-1.6.4
./configure
make
make install
如此，即可以执行命令guile，进入guile>提示符状态，输入调试Scheme程序代码了，本文的所有代码都是在guile下调试通过。
其它实现
除了Guile外，Scheme语言的实现还有很多，如：GNU/MIT-Scheme， SCI，Scheme48，DrScheme等，它们大多是开源的，可以自由下载安装使用，并且跨平台的实现也很多。你会发现既有象basic的 Scheme语言解释器，也有将Scheme 语言编译成C语言的编译器，也有象JAVA那样将Scheme语言代码编译成虚拟机代码的编译器。
三．基本概念
注释
Scheme语言中的注释是单行注释，以分号[;]开始一直到行尾结束，其中间的内容为注释，在程序运行时不做处理，如：
; this is a scheme comment line.
标准的Scheme语言定义中没有多行注释，不过在它的实现中几乎都有。在Guile 中就有多行注释，以符号组合"#!"开始，以相反的另一符号组合"!#"结束，其中内容为注释，如：
#!
there are scheme comment area.
you can write mulity lines here .
!#
注意的是，符号组合"#!"和"!#"一定分做两行来写。
Scheme用做脚本语言
Scheme语言可以象sh，perl，python等语言那样作为一种脚本语言来使用，用它来编写可执行脚本，在Linux中如果通过Guile用Scheme语言写可执行脚本，它的第一行和第二行一般是类似下面的内容：
#! /usr/local/bin/guile -s
!#
这样的话代码在运行时会自动调用Guile来解释执行，标准的文件尾缀是
".scm"。
块(form)
块(form)是Scheme语言中的最小程序单元，一个Scheme语言程序是由一个或多个form构成。没有特殊说明的情况下 form 都由小括号括起来，形如：
(define x 123)
(+ 1 2)
(* 4 5 6)
(display "hello world")
一个 form 也可以是一个表达式，一个变量定义，也可以是一个过程。
form嵌套
Scheme语言中允许form的嵌套，这使它可以轻松的实现复杂的表达式，同时也是一种非常有自己特色的表达式。下图示意了嵌套的稍复杂一点的表达式的运算过程：
变量定义
可以用define来定义一个变量，形式如下：
(define 变量名值)
如： (define x 123) ，定义一个变量x，其值为123。
更改变量的值
可以用set!来改变变量的值，格式如下：
(set! 变量名值)
如： (set! x "hello") ，将变量x的值改为"hello" 。
Scheme语言是一种高级语言，和很多高级语言(如python，perl)一样，它的变量类型不是固定的，可以随时改变。
四．数据类型
1. 简单数据类型
逻辑型(boolean)
最基本的数据类型，也是很多计算机语言中都支持的最简单的数据类型，只能取两个值：#t，相当于其它计算机语言中的 TRUE；#f，相当于其它计算机语言中的 FALSE。
Scheme语言中的boolean类型只有一种操作：not。其意为取相反的值，即：
(not #f) => #t
(not #t) => #f
not的引用，与逻辑非运算操作类似
guile> (not 1)
#f
guile> (not (list 1 2 3))
#f
guile> (not 'a)
#f
从上面的操作中可以看出来，只要not后面的参数不是逻辑型，其返回值均为#f。数字型(number)
它又分为四种子类型：整型(integer)，有理数型(rational)，实型(real)，复数型(complex)；它们又被统一称为数字类型(number)。
如：复数型(complex) 可以定义为 (define c 3+2i) 实数型（real）可以定义为 (define f 22/7) 有理数型（rational）可以定义为 (define p 3.1415) 整数型(integer) 可以定义为 (define i 123)
Scheme 语言中，数字类型的数据还可以按照进制分类，即二进制，八进制，十进制和十六进制，在外观形式上它们分别以符号组合 #b、 #o、 #d、 #x 来作为表示数字进制类型的前缀，其中表示十进制的#d可以省略不写，如：二进制的 #b1010 ，八进制的 #o567，十进制的123或 #d123，十六进制的 #x1afc 。
Scheme语言的这种严格按照数学定理来为数字类型进行分类的方法可以看出Scheme语言里面渗透着很深的数学思想，Scheme语言是由数学家们创造出来的，在这方面表现得也比较鲜明。
字符型(char)
Scheme语言中的字符型数据均以符号组合 "#\" 开始，表示单个字符，可以是字母、数字或"[ ! $ % & * + - . / : < = > ? @ ^ _ ~ ]"等等其它字符，如：#\A 表示大写字母A，#\0表示字符0，其中特殊字符有：#\space 表示空格符和 #\newline 表示换行符。
符号型(symbol)
符号类型是Scheme语言中有多种用途的符号名称，它可以是单词，用括号括起来的多个单词，也可以是无意义的字母组合或符号组合，它在某种意义上可以理解为C中的枚举类型。看下面的操作：
guile> (define a (quote xyz)) ; 定义变量a为符号类型，值为xyz
guile> a
xyz
guile> (define xyz 'a) ; 定义变量xyz为符号类型，值为a
guile> xyz
a
此处也说明单引号' 与quote是等价的，并且更简单一些。符号类型与字符串不同的是符号类型不能象字符串那样可以取得长度或改变其中某一成员字符的值，但二者之间可以互相转换。
2. 复合数据类型
可以说复合数据类型是由基本的简单数据类型通过某种方式加以组合形成的数据类型，特点是可以容纳多种或多个单一的简单数据类型的数据，多数是基于某一种数学模型创建的。
字符串(string) 由多个字符组成的数据类型，可以直接写成由双引号括起的内容，如："hello" 。下面是Guile中的字符串定义和相关操作：
guile> (define name "tomson")
guile> name
"tomson"
guile> (string-length name) ; 取字符串的长度
6
guile> (string-set! name 0 #\g) ; 更改字符串首字母(第0个字符)为小写字母g (#\g)
guile> name
"gomson"
guile> (string-ref name 3) ; 取得字符串左侧第3个字符（从0开始）
#\s
字符串还可以用下面的形式定义：
guile> (define other (string #\h #\e #\l #\l #\o ))
guile> other
"hello"
字符串中出现引号时用反斜线加引号代替，如："abc\"def" 。
点对(pair)
我把它译成"点对"，它是一种非常有趣的类型，也是一些其它类型的基础类型，它是由一个点和被它分隔开的两个所值组成的。形如： (1 . 2) 或 (a . b) ，注意的是点的两边有空格。
这是最简单的复合数据类型，同是它也是其它复合数据类型的基础类型，如列表类型（list）就是由它来实现的。
按照Scheme语言说明中的惯例，以下我们用符号组合 "=>" 来表示表达式的值。
它用cons来定义，如： (cons 8 9) =>(8 . 9)
其中在点前面的值被称为 car ，在点后面的值被称为 cdr ，car和cdr同时又成为取pair的这两个值的过程，如：
(define p (cons 4 5)) => (4 . 5)
(car p) => 4
(cdr p) => 5
还可以用set-car! 和 set-cdr! 来分别设定这两个值：
(set-car! p "hello")
(set-cdr! p "good")
如此，以前定义的 p 又变成了 ("hello" . "good") 这个样子了。
列表(list)
列表是由多个相同或不同的数据连续组成的数据类型，它是编程中最常用的复合数据类型之一，很多过程操作都与它相关。下面是在Guile中列表的定义和相关操作：
guile> (define la (list 1 2 3 4 ))
guile> la
(1 2 3 4)
guile> (length la) ; 取得列表的长度
4
guile> (list-ref la 3) ; 取得列表第3项的值（从0开始）
4
guile> (list-set! la 2 99) ; 设定列表第2项的值为99
99
guile> la
(1 2 99 4)
guile> (define y (make-list 5 6)) ;创建列表
guile> y
(6 6 6 6 6)
make-list用来创建列表，第一个参数是列表的长度，第二个参数是列表中添充的内容；还可以实现多重列表，即列表的元素也是列表，如：(list (list 1 2 3) (list 4 5 6))。
列表与pair的关系
回过头来，我们再看看下面的定义：
guile> (define a (cons 1 (cons 2 (cons 3 '()))))
guile> a
(1 2 3)
由上可见，a本来是我们上面定义的点对，最后形成的却是列表。事实上列表是在点对的基础上形成的一种特殊格式。
再看下面的代码：
guile> (define ls (list 1 2 3 4))
guile> ls
(1 2 3 4)
guile> (list? ls)
#t
guile> (pair? ls)
#t
由此可见，list是pair的子类型，list一定是一个pair，而pair不是list。
guile> (car ls)
1
guile> (cdr ls)
(2 3 4)
其cdr又是一个列表，可见用于pair的操作过程大多可以用于list。
guile> (cadr ls) ; 此"点对"对象的cdr的car
2
guile> (cddr ls) ; 此"点对"对象的cdr的cdr
(3 4)
guile> (caddr ls) ; 此"点对"对象的cdr的cdr的car
3
guile> (cdddr ls) ; 此"点对"对象的cdr的cdr的cdr
(4)
上在的操作中用到的cadr，cdddr等过程是专门对PAIR型数据再复合形成的数据操作的过程，最多可以支持在中间加四位a或d，如cdddr，caaddr等。
下图表示了由pairs定义形成的列表：
这个列表可以由pair定义为如下形式：
(define x (cons 'a (cons 'b (cons 'c (cons 'd '())))))
而列表的实际内容则为：(a b c d)
由pair类型还可以看出它可以轻松的表示树型结构，尤其是标准的二叉树。
向量（vector）
可以说是一个非常好用的类型，是一种元素按整数来索引的对象，异源的数据结构，在占用空间上比同样元素的列表要少，在外观上：
列表示为： (1 2 3 4) VECTOR表示为： #(1 2 3 4) 可以正常定义：(define v (vector 3 4 5)) 也可以直接定义：(define v #(3 4 5))
vector是一种比较常用的复合类型，它的元素索引从0开始，至第 n-1 结束，这一点有点类似C语言中的数组。
关于向量表（vector）的常用操作过程：
guile> (define v (vector 1 2 3 4 5))
guile> v
#(1 2 3 4 5)
guile> (vector-ref v 0) ; 求第n个变量的值
1
guile> (vector-length v) ; 求vector的长度
5
guile> (vector-set! v 2 "abc") ; 设定vector第n个元素的值
guile> v
#(1 2 "abc" 4 5)
guile> (define x (make-vector 5 6)) ; 创建向量表
guile> x
#(6 6 6 6 6)
make-vector用来创建一个向量表，第一个参数是数量，后一个参数是添充的值，这和列表中的make-list非常相似。
我们可以看出，在Scheme语言中，每种数据类型都有一些基本的和它相关的操作过程，如字符串，列表等相关的操作，这些操作过程都很有规律，过程名的单词之间都用-号隔开，很容易理解。对于学过C++的朋友来说，更类似于某个对象的方法，只不过表现的形式不同了。
3. 类型的判断、比较、运算、转换与方法
类型判断
Scheme语言中所有判断都是用类型名加问号再加相应的常量或变量构成，形如：
(类型? 变量)
Scheme语言在类型定义中有比较严格的界定，如在C语言等一些语言中数字0
来代替逻辑类型数据False，在Scheme语言中是不允许的。
以下为常见的类型判断和附加说明：
逻辑型：
(boolean? #t) => #t
(boolean? #f) => #t 因为#t和#f都是boolean类型，所以其值为#t (boolean? 2) => #f 因为2是数字类型，所以其值为 #f
字符型：
(char? #\space) => #t
(char? #\newline) => #t 以上两个特殊字符：空格和换行
(char? #\f) => #t 小写字母 f
(char? #\;) => #t 分号 ;
(char? #\5) => #t 字符 5 ，以上这些都是正确的，所以返回值都是 #t
(char? 5) => #f 这是数字 5 ，不是字符类型，所以返回 #f
数字型：
(integer? 1) => #t
(integer? 2345) => #t
(integer? -90) => #t 以上三个数均为整数
(integer? 8.9) => #f 8.9不整数
(rational? 22/7) => #t
(rational? 2.3) => #t
(real? 1.2) => #t
(real? 3.14159) => #t
(real? -198.34) => #t 以上三个数均为实数型
(real? 23) => #t 因为整型属于实型
(number? 5) => #t
(number? 2.345) => #t
(number? 22/7) => #t
其它型：
(null? '()) => #t ; null意为空类型，它表示为 '() ，即括号里什么都没有的符号
(null? 5) => #f
(define x 123) 定义变量x其值为123
(symbol? x) => #f
(symbol? 'x) => #t ; 此时 'x 为符号x，并不表示变量x的值
在Scheme语言中如此众多的类型判断功能，使得Scheme语言有着非常好的自省功能。即在判断过程的参数是否附合过程的要求。
比较运算
Scheme语言中可以用<，>，<=，>=，= 来判断数字类型值或表达式的关系，如判断变量x是否等于零，它的形式是这样的：(= x 0) ，如x的值为0则表达式的值为#t，否则为#f。
还有下面的操作：
(eqv? 34 34) => #t
(= 34 34) => #t
以上两个form功能相同，说明 eqv? 也可以用于数字的判断。
在Scheme语言中有三种相等的定义，两个变量正好是同一个对象；两个对象具有相同的值；两个对象具有相同的结构并且结构中的内容相同。除了上面提到的符号判断过程和eqv?外，还有eq?和equal?也是判断是否相等的过程。
eq?，eqv?，equal?
eq?，eqv?和equal?是三个判断两个参数是否相等的过程，其中eq?和eqv?的功能基本是相同的，只在不同的Scheme语言中表现不一样。
eq?是判断两个参数是否指向同一个对象，如果是才返回#t；equal?则是判断两个对象是否具有相同的结构并且结构中的内容是否相同，它用eq?来比较结构中成员的数量；equal?多用来判断点对，列表，向量表，字符串等复合结构数据类型。
guile> (define v (vector 3 4 5))
guile> (define w #(3 4 5)) ; w和v都是vector类型，具有相同的值#(3 4 5)
guile> (eq? v w)
#f ; 此时w和v是两个对象
guile> (equal? v w)
#t ; 符合equal?的判断要求
以上操作说明了eq? 和equal? 的不同之处，下面的操作更是证明了这一点：
guile> (define x (make-vector 5 6))
guile> x
#(6 6 6 6 6)
guile> (eq? x x) ; 是同一个对象，所以返回#t
#t
guile> (define z (make-vector 5 6))
guile> z
#(6 6 6 6 6)
guile> (eq? x z) ; 不是同一个对象
#f
guile> (equal? x z) ; 结构相同，内容相同，所以返回#t
#t
算术运算
Scheme语言中的运算符有： + , - , * , / 和 expt (指数运算) 其中 - 和 / 还可以用于单目运算，如：
(- 4) => -4
(/ 4) => 1/4
此外还有许多扩展的库提供了很多有用的过程，
max 求最大 (max 8 89 90 213) => 213
min 求最小 (min 3 4 5 6 7) => 3
abs 求绝对值 (abs -7) ==> 7
除了max，min，abs外，还有很多数学运算过程，这要根据你用的Scheme语言的运行环境有关，不过它们大多是相同的。在R5RS中规定了很多运算过程，在R5RS的参考资料中可以很容易找到。
转换
Scheme语言中用符号组合"->"来标明类型间的转换（很象C语言中的指针）的过程，就象用问号来标明类型判断过程一样。下面是一些常见的类型转换过程：
guile> (number->string 123) ; 数字转换为字符串
"123"
guile> (string->number "456") ; 字符串转换为数字
456
guile> (char->integer #\a) ;字符转换为整型数，小写字母a的ASCII码值为96
97
guile> (char->integer #\A) ;大写字母A的值为65
65
guile> (integer->char 97) ;整型数转换为字符
#\a
guile> (string->list "hello") ;字符串转换为列表
(#\h #\e #\l #\l #\o)
guile> (list->string (make-list 4 #\a)) ; 列表转换为字符串
"aaaa"
guile> (string->symbol "good") ;字符串转换为符号类型
good
guile> (symbol->string 'better) ;符号类型转换为字符串
"better"
五．过程定义
过程（Procedure）
在Scheme语言中，过程相当于C语言中的函数，不同的是Scheme语言过程是一种数据类型，这也是为什么Scheme语言将程序和数据作为同一对象处理的原因。如果我们在Guile提示符下输入加号然后回车，会出现下面的情况：
guile> +
#
这告诉我们"+"是一个过程，而且是一个原始的过程，即Scheme语言中最基础的过程，在GUILE中内部已经实现的过程，这和类型判断一样，如 boolean?等，它们都是Scheme语言中最基本的定义。注意：不同的Scheme语言实现环境，出现的提示信息可能不尽相同，但意义是一样的。
define不仅可以定义变量，还可以定义过程，因在Scheme语言中过程（或函数）都是一种数据类型，所以都可以通过define来定义。不同的是标准的过程定义要使用lambda这一关键字来标识。
Lambda关键字
Scheme语言中可以用lambda来定义过程，其格式如下： (define 过程名
( lambda (参数 ...) (操作过程 ...)))
我们可以自定义一个简单的过程，如下：
::
(define add5 (lambda (x) (+ x 5)))
此过程需要一个参数，其功能为返回此参数加5 的值，如：
(add5 11) => 16
下面是简单的求平方过程square的定义：
(define square (lambda (x) (* x x)))
与lambda相同的另一种方式
在Scheme语言中，也可以不用lambda，而直接用define来定义过程，它的格式为： (define (过程名参数) (过程内容…))
如下面操作：
(define (add6 x) (+ x 6))
add6
#
(add6 23) => 29
再看下面的操作：
guile> (define fun
(lambda(proc x y)
(proc x y)))
guile> fun
#
guile> (fun * 5 6)
30
guile> (fun / 30 3)
10
更多的过程定义
上面定义的过程fun有三个参数，其中第一个参数proc也是一个操作过程（因为在Scheme语言中过程也是一种数据，可以作为过程的参数），另外两个参数是数值，所以会出现上面的调用结果。
guile> (define add
(lambda (x y)
(+ x y)))
guile> add
#
guile> (fun add 100 200)
300
继续上面操作，我们定义一个过程add，将add作为参数传递给fun过程，得出和(fun + 100 200)相同的结果。
guile> ((lambda (x) (+ x x)) 5)
10
上面的 (lambda(x) (+ x x)) 事实上是简单的过程定义，在后面直接加上操作参数5，得出结果10，这样实现了匿名过程，直接用过程定义来操作参数，得出运算结果。
通过上面的操作，相信你已初步了解了过程的用法。既然过程是一种数据类型，所以将过程作为过程的参数是完全可以的。以下过程为判断参数是否为过程，给出一个参数，用 procedure? 来判断参数是否为过程，采用if结构（关于if
结构见下面的介绍）：
guile> (define isp
(lambda (x)
(if (procedure? x) 'isaprocedure 'notaprocedure))) guile> isp
#
guile> (isp 0)
notaprocedure
guile> (isp +)
isaprocedure
上面的过程就体现了Scheme语言的参数自省（辨别）能力，'0'是数字型，所以返回notaprocedure；而'+'是一个最基础的操作过程，所以返回isaprocedure。
过程的嵌套定义
在Scheme语言中，过程定义也可以嵌套，一般情况下，过程的内部过程定义只有在过程内部才有效，相当C语言中的局部变量。
如下面的代码的最终结果是50：
(define fix
(lambda (x y z)
(define add
(lambda (a b) (+ a b)))
(- x (add y z))))
(display (fix 100 20 30))
此时过程add只在fix过程内部起做用，这事实上涉及了过程和变量的绑定，可以参考下面的关于过程绑定（let，let* 和letrec）的介绍。
过程是初学者难理解的一个关键，随着过程参数的增加和功能的增强，过程的内容变得越来越复杂，小括号也会更多，如果不写出清晰的代码的话，读代码也会成为一个难题。
熟悉了 scheme 基本概念、数据类型和过程（函数）后，下一部分我们来学习scheme 的结构、递归调用和其他扩展功能。
六．常用结构
顺序结构
也可以说成由多个form组成的form，用begin来将多个form放在一对小括号内，最终形成一个form。格式为：(begin form1 form2 …)
如用Scheme语言写成的经典的helloworld程序是如下样子的：
(begin
(display "Hello world!") ; 输出"Hello world!"
(newline)) ; 换行
if结构
Scheme语言的if结构有两种格式，一种格式为：(if 测试过程1 过程2)，即测试条件成立则执行过程1，否则执行过程2。例如下面代码：
(if (= x 0)
(display "is zero")
(display "not zero"))
还有另一种格式：(if 测试过程) ，即测试条件成立则执行过程。例如下面代码：
(if (< x 100) (display "lower than 100"))
根据类型判断来实现自省功能，下面代码判断给定的参数是否为字符串：
(define fun
(lambda ( x )
(if (string? x)
(display "is a string")
(display "not a string"))))
如执行 (fun 123) 则返回值为"not a string"，这样的功能在C++或JAVA中实现的话可能会很费力气。
cond结构
Scheme语言中的cond结构类似于C语言中的switch结构，cond的格式为：
(cond ((测试) 操作) … (else 操作))
如下是在Guile中的操作：
guile> (define w (lambda (x)
(cond ((< x 0) 'lower)
((> x 0) 'upper)
(else 'equal))))
guile> w
#
guile> (w 9)
upper
guile> (w -8)
lower
guile> (w 0)
equal
上面程序代码中，我们定义了过程w，它有一个参数x，如果x的值大于0，则返回符号upper，如x的值小于0则返回符号lower，如x 的值为0则返回符号equal。
下载已做成可执行脚本的例程。
cond可以用if形式来写，上面的过程可以如下定义：
guile> (define ff
(lambda (x)
(if (< x 0) 'lower
(if (> x 0) 'upper 'zero))))
guile> ff
#
guile> (ff 9)
upper
guile> (ff -9)
lower
guile> (ff 0)
这在功能上是和cond一样的，可以看出cond实际上是实现了if的一种多重嵌套。
case结构
case结构和cond结构有点类似，它的格式为：
(case (表达式) ((值) 操作)) ... (else 操作)))
case结构中的值可以是复合类型数据，如列表，向量表等，只要列表中含有表达式的这个结果，则进行相应的操作，如下面的代码：
(case (* 2 3)
((2 3 5 7) 'prime)
((1 4 6 8 9) 'composite))
上面的例子返回结果是composite，因为列表(1 4 6 8 9)中含有表达式(* 2 3)的结果6；下面是在Guile中定义的func过程，用到了case结构：
guile> (define func
(lambda (x y)
(case (* x y)
((0) 'zero)
(else 'nozero))))
guile> func
#
guile> (func 2 3)
nozero
guile> (func 2 0)
zero
guile> (func 0 9)
zero
guile> (func 2 9)
nozero
可以下载另一个脚本文件 te.scm，参考一下。
and结构
and结构与逻辑与运算操作类似，and后可以有多个参数，只有它后面的参数的表达式的值都为#t时，它的返回值才为#t，否则为#f。看下面的操作：
guile> (and (boolean? #f) (< 8 12))
guile> (and (boolean? 2) (< 8 12))
#f
guile> (and (boolean? 2) (> 8 12))
#f
如果表达式的值都不是boolean型的话，返回最后一个表达式的值，如下面的操作：
guile> (and (list 1 2 3) (vector 'a 'b 'c))
#(a b c)
guile> (and 1 2 3 4 )
4
guile> (and 'e 'd 'c 'b 'a)
a
or结构
or结构与逻辑或运算操作类似，or后可以有多个参数，只要其中有一个参数的表达式值为#t，其结果就为#t，只有全为#f时其结果才为#f。如下面的操作：
guile> (or #f #t)
#t
guile> (or #f #f)
#f
guile> (or (rational? 22/7) (< 8 12))
#t
guile> (rational? 22/7)
#t
guile> (real? 22/7)
#t
guile> (or (real? 4+5i) (integer? 3.22))
#f
我们还可以用and和or结构来实现较复杂的判断表达式，如在C语言中的表达式：
((x > 100) && (y < 100)) 和 ((x > 100) || (y > 100))
在Scheme中可以表示为：
guile> (define x 123)
guile> (define y 80)
guile> (and (> x 100) (< y 100))
#t
guile> (or (> x 100) (> y 100))
#t
Scheme语言中只有if结构是系统原始提供的，其它的cond，case，and，or，另外还有do，when，unless等都是可以用宏定义的方式来定义的，这一点充分体现了Scheme的元语言特性，关于do，when等结构的使用可以参考R5RS。
七．递归调用
用递归实现阶乘
在Scheme语言中，递归是一个非常重要的概念，可以编写简单的代码很轻松的实现递归调用，如下面的阶乘过程定义：
(define factoral (lambda (x)
(if (<= x 1) 1
(* x (factoral (- x 1))))))
我们可以将下面的调用(factoral 4)，即4的阶乘的运算过程图示如下：
以下为factoral过程在Guile中的运行情况：
guile> (define factoral (lambda (x) (if (<= x 1) 1 (* x (factoral (- x 1))))))
guile> factoral
#
guile> (factoral 4)
24
语言学教程笔记 第一章语言学导论 语言的定义特征：从本质上将人类语言与动物语言区分开的人类语言的区别性特点。 1. 任意性：任意性是指语言符号的形式与所表示的意义没有天然的联系，任意性是语言的核 心特征。例如，我们无法解释为什么一本书读作 a /buk/，一支钢笔读作a /pe n/。 任意性具有不同层次：（1）语素音义关系的任意性。（2）句法层面上的任意性。 （3） 任意性和规约性。 2. 二层性：二层性是指拥有两层结构的这种特性，上层结构的单位由底层结构的元素构成， 每层都有自身的组合规则。话语的组成元素是本身不传达意义的语音，语音的唯一作用就是 相互组合构成有意义的单位，比如词。因为底层单位是无意的，而上层单位有明确的意义，所以我们把语音叫做底层单位，与词等上层单位相对。二层性使语言拥有了一种强大的能产 性。 3. 创造性：创造性指语言的能产性，指语言有制造无穷长句的潜力，这来源于语言的二层性 和递归性。利用二重性说话者可以通过组合基本语言单位，无止境地生成句子，大多数都是以前没有过的或没有听过的。 4. 移位性：是指人类语言可以让使用者在交际时用语言符号代表时间上和空间上并不可及的 物体、时间或观点。因此我们可以提及孔子或北极，虽然前者已经去世两千五百五十多年而 后者位置距我们非常之远。语言使我们能够谈及已不存在或还未出现的事物。移位性赋予人 们的概括与抽象能力使人类受益无穷。词在指称具体物体时，并不总是出现在即时、形象化 的语境中。他们通常为了体现指称含义而被使用。 5. 文化传递性：语言不是靠遗传，而是通过文化传递的。 6. 互换性：指人可以是信息的发出者，也可以是信息的接受者，即人作为说话者和听话者的 角色是可以随意更换的。 元语言功能：我们的语言可以用来讨论语言本身。比如说，我可以用“书”指代一本书，也可以用“书这个词”来指代“书”这个词本身。这使语言具有无限的自我反身性：人类可以谈论“说话”，也可以思考“思考"。所以只有人类才能提问：元语言功能对交际、思考及人类的意义是什么？
将英语译成中文(简体)胡壮麟“语言学教程”课后答案 定义以下条款： 1。设计特点：是他们的特点来定义，如任意性，双重性，创造性，位移，文化传播等，我们人类的语言， 2。功能：语言的使用ommunicate，思考，等anguage功能inclucle imformative 功能，人际功能，表演功能，人际功能，表演功能，情感功能，寒暄交流，娱乐功能和工具功能。 3。客位：在与主位是从美国语言学家派克的语音和音位的区别源于长期的对比。作为客位芒作出太多，以及behaviously无关紧要，鉴别，就像是多嚼不语言学与语音正确vx.phonemic分析实例。 4。主位：在与客位的是从美国语言学家派克的语音和音位的区别源于长期的对比。作者：主位言语行为和事件必须被作为一个有意义的资源，验证通过的最后一次演说communith本地成员，而不是通过qppeal到研究者的ingenuith或直觉孤单。‘ 5。同步：一类是描述以一个固定的瞬间（通常，但不一定，目前的）作为观察点。大多数语法是这样的。 6。历时：一种语言的研究是通过其进行的历史过程。 7。规范：一种语言的研究是通过其进行的历史过程。 8。规范：这类研究的语言，一切事都应该是如何规定的，ielaying下来的语言使用规则。 9。描述：这类研究的语言，一切事都只是描述。 10。独断性：一种人类的语言，这是指语言符号的脸，不承担任何形式的关系，其意义自然的设计特点。11。对偶：一种人类的语言，这是指有两对是二次元素组成的各级物业设计功能。水平和两级各有自己的组织原则。12。排量：一种人类的语言，这意味着人类语言的设计特点，使他们的用户，象征着在目前的通信对象，事件和概念并不在时间和空间目前?。13。寒暄交流：人类语言的一种功能，它是指语言的社会互动。14。元语言：语言符号或特定的分析和研究方面的某些种类的描述。15。macrolinguistics：他的语言之间的相互作用，如心理学，社会学，人种学，法学和人工智能等门类的
logo语言教程 LOGO是一种计算机程序设计语言，LOGO源自希腊文，原意为思想，最初的LOGO语言是由一名叫佩伯特的心理学家设计的。他在从事人工智能的研究中，一个像海龟的机械装置，触发了他的灵感。他利用广博的知识及聪明的才智完成了LOGO语言的设计。佩伯特希望孩子不要机械地记忆事实，强调创造性的探索。他说：“学校的多数课程是记忆一些数据和科学事实，却很少着眼于真正意义上的学习与思考。”他用LOGO语言启发孩子们学会学习，一些孩子用LOGO语言设计出了真正的程序。 LOGO语言是一种结构化程序设计语言。它是交互式的，为人们提供了良好的编程环境；它是模块化的，便于程序的修改与扩充；它是过程化的，包含了过程、参数、变量等重要概念，并允许递归调用；它有丰富的数据结构类型；有生动的图形处理功能；。它不仅具备多种优秀程序设计语就能掌握LOGO的基本绘图指令，高年级学LOGO程序设计自然不是难事。 LOGO语言是中小学生十分喜爱的一种计算机程序设计语言，它里面有一个绘画能手——小海龟。小海龟本领高强，会唱歌、会画画，多才多艺。我们可以指挥小海龟在屏幕上画出丰富多彩的图画，奏出美妙动听的音乐。你是不是想和神通广大的小海龟交朋友? 对于在LOGO语言中，输入命令就被立即执行，我们通常称之为“立即方式”，或“命令方式”。 1．前进命令FORWARD（简写FD） 【格式】 FD 步长 【功能】命令小海龟按当前方向前进指定的步长。 【说明】 ⑴ 在LOGO语言中，命令与数据之间是以空格分隔的。如，在输入的前进命令和步长之间必须用空格分隔。 ⑵ 小海龟移动时，要特别注意它的当前位置和方向，当前方向就是它的头所指的方向。 ⑶ 让小海龟移动时，是通过步长的长短来控制机器人前进的距离。 ⑷ 步长的具体值就是指距离的长短(小海龟的默认值为每1个步长为0.5厘米)。如FD 100中步长值为 100，是让小海龟前进50厘米。 ⑸ 输入的LOGO命令既可以是大写字母，也可以是小写字母，例如，“fd 100”命令，也可以写成“FD 100”，两种输入方式的执行效果相同 2．后退命令BACK（简写BK） 【格式】 BK 步长 【功能】命令小海龟按当前方向后退指定的步长。 【说明】 ⑴ 让小海龟移动时，是通过步长来控制小海龟后退的距离。 ⑵ 小海龟移动时，要特别注意它的当前位置和方向，后退方向就是它的头所指的反方向。⑶ 步长的具体值就是指步长的长短(小海龟的默认值为每一步长为
4.2练习题 一、选择题 1．D 2.B 3.A 4.B和D 5.C 6.A 7.B 二、填空题 1．//或/* */ 2.主或main 3.函数首部和函数体 4..编译和连接 5.分号6.传统的程序流程图和N-S图 5.2练习题 一、选择题 1．A 2.D 3.B 4.B 5.C 6.C 7 D 8.A 9.B 10.B 11.D 12.B 13A或B 14.C 15.B 16.B 17.D 18.D 19. C 20.D 21.B 22.A 23.D 24.C 25.C 26.B 27.C 28.D 29.A 30.B 二、填空题 1．102，10 2.#define 宏名字符串 3.1 4.. n=1 5.-4 6.a=1,b= ,c=2 7. c=A 8.n1=%d\nn2=%d 9.a+b>c&&a+c>b&&b+c>a 10.ch>=’a’&&ch<=’z’|| ch>=’A’&&ch<=’Z’11.7 12.0 13.11110000 14.8,4 6.2练习题 一、选择题 1．A 2.C 3.D 4.C 5.A 6.B 7. A 8.D 9.B 10.C 11.A 12.A 13. C 14.B 15.正确答案为：12345678
二、填空题 1．10 2.y=1 x%i==0 3.屏幕中间输出一个由星号组成的菱形4. 1 5.13 6.(cx=getchar())!=-1 front=cx; 7. m%n 8.4 9.*p px=&x py=&y 三、读程序，写结果 1．-1 2.3,1,-1, 3.a=16,y=60 4.x=12,y=4 5.59 7.2练习题 一、选择题 1．B 2.C 3.C 4.A 5.D 6.C 7. D 8.D 9.C 10.D 11.D 12.D 13 A 14.B 15.C 16.B 17.B 18.A 19 A 20.D 21.B 22.D 23.C 24.D 25. D 26.C 二、填空题 1．‘a’0 2.a[k] a[k] a[k] 3.0 6 4….A B C D E 5. 1,6 6.k=p; A 7. i 绍兴县教研室试点教材汉语编程工具易语言 易语言教程――初级版 目录 目录.......................................................................................................................... - 2 - 第一部分易语言入门.................................................................................................... - 3 - 第一课走进“易”世界........................................................................................ - 3 - 一、打开“易语言”设计窗口 ........................................................................ - 3 - 二、认识“易语言”........................................................................................ - 3 - 三、第一个易程序............................................................................................ - 5 - 四、小结............................................................................................................ - 6 - 第二课简单的人机交互........................................................................................ - 7 - 一、第一个交互程序........................................................................................ - 7 - 二、小结............................................................................................................ - 9 - 第三课按钮与标签的综合运用 .......................................................................... - 10 - 第四课图文并茂.................................................................................................. - 12 - 第五课看看计算机的计算能力 .......................................................................... - 14 - 第六课让世界丰富多彩...................................................................................... - 16 - 第七课顺序程序结构.......................................................................................... - 18 - 第八课猜数（选择程序结构） .......................................................................... - 21 - 第九课多分支控制结构语句 .............................................................................. - 25 - 第十课练习.......................................................................................................... - 27 - 一、选择题：.................................................................................................. - 27 - 二、编程题：.................................................................................................. - 27 - 第十一课循环程序结构...................................................................................... - 29 - 第十二课循环程序结构练习 .............................................................................. - 33 - 一、选择题...................................................................................................... - 33 - 二、编程题...................................................................................................... - 34 - 第十三课菜单的设计.......................................................................................... - 36 - 一、菜单的基本概念...................................................................................... - 36 - 二、菜单编辑器的打开 .................................................................................. - 36 - 三、设计下拉式菜单...................................................................................... - 37 - 第十四课对话框.................................................................................................. - 41 - 一、提示类对话框.......................................................................................... - 41 - 二、自定义对话框.......................................................................................... - 42 - 三、通用对话框.............................................................................................. - 43 - 附录实例应用荟萃.............................................................................................. - 45 - 语言入门教程(一) ?什么是HTML语言 HTML(HyperText MarkUp Language)是使用特殊标记来描述文档结构和表现形式的一种语言，由W3C(World Wide Web Consortium)所制定和更新。我们可以用任何一种文本编译起来编辑HTML文件，因为它就是一总纯文本文件。 ?HTML语言的基本结构 下面我们来看一小段HTML语言的代码，来了解HTML语言的基本结构： 易语言中文编程,从入门到精通【菜鸟基础教程】
HTML语言入门教程
C语言视频教程 C语言全套视频教程c语言入门，c语言视频教程的在线学习,相关课件软件的下载，知识点讲解入门,是您学习c语言程序设计教程的最佳选择。 1第一讲iOS开发必备之C语言基础--进制转换 包含知识点：进制定义、程序开发中常用进制介绍、n进制转换10进制、10进制转换n进制。 2第二讲iOS开发必备之C语言基础--数据类型、运算符 数据类型分类、常量、变量、运算符、表达式、语句、输入输出函数。 3第三讲iOS开发必备之C语言基础--分支结构-if 程序结构概述、关系运算符、逻辑运算符、if的三种形式、条件运算符。
4第四讲iOS开发必备之C语言基础--分支结构-switch...case switch case，if与switch case区别，break关键字 5第五讲iOS开发必备之C语言基础--循环结构 while、do while、for循环，三种循环的区别 6第六讲iOS开发必备之C语言基础--循环嵌套 循环的嵌套使用、break关键字、continue关键字。 7第七讲iOS开发必备之C语言基础--一维数组 构造数据类型、一维数组定义、数组元素使用、冒泡排序。 8第八讲iOS开发必备之C语言基础--字符数组 字符数组、字符数组的输入输出、字符数组常用函数(strlen、strcpy、strcat、strcmp等)。 9第九讲iOS开发必备之C语言基础--二维数组 二维数组定义、二维数组元素使用、二维数组与循环结构结合使用、二维数组使用场景。 10第十讲iOS开发必备之C语言基础--字符串数组
字符串数组定义、二维数组操作每个字符串、二维数组操作每个字符、字符串排序、多维数组。 11第十一讲iOS开发必备之C语言基础--函数定义 函数意义、函数分类、函数定义、函数使用、函数举例。 12第十二讲iOS开发必备之C语言基础--函数嵌套 形参、实参、数组名作为函数参数，函数嵌套调用，递归函数，变量作用域。 13第十三讲iOS开发必备之C语言基础--结构体 结构体特点、结构体定义、结构体变量、typedef关键字、结构体成员访问，结构体使用。 14第十四讲iOS开发必备之C语言基础--结构体与数组混合使用 结构体嵌套结构体、结构体作为数组成员、结构体数组冒泡排序。 15第十五讲iOS开发必备之C语言基础--指针初级 内存的两种方式、指针、指针变量、指针的类型、指针的重指向 16第十六讲iOS开发必备之C语言基础--指针作为函数参数
LISP语言教程 作者：牛魔王 — 上次修改时间: 2007-03-22 13:13 Scheme 语言是LISP语言的一个方言(或说成变种)，它诞生于1975年的MIT，对于这个有近三十年历史的编程语言来说，它并没有象C++，java，C#那样受到商业领域的青睐，在国内更是显为人知。但它在国外的计算机教育领域内却是有着广泛应用的，有很多人学的第一门计算机语言就是Scheme语言。Scheme 语言概要 Author:宋国伟吉林省德惠市信息中心 Date:2003 年12 月01 日 Scheme 语言是LISP语言的一个方言(或说成变种)，它诞生于1975年的MIT，对于这个有近三十年历史的编程语言来说，它并没有象C++，java，C#那样受到商业领域的青睐，在国内更是显为人知。但它在国外的计算机教育领域内却是有着广泛应用的，有很多人学的第一门计算机语言就是Scheme语言。 作为Lisp 变体，Scheme 是一门非常简洁的计算语言，使用它的编程人员可以摆脱语言本身的复杂性，把注意力集中到更重要的问题上，从而使语言真正成为解决问题的工具。本文分为上、下两部分来介绍scheme 语言。一．Scheme语言的特点
Scheme 语言是LISP语言的一个方言(或说成变种)，它诞生于1975年的MIT，对于这个有近三十年历史的编程语言来说，它并没有象C++，java，C#那样受到商业领域的青睐，在国内更是显为人知。但它在国外的计算机教育领域内却是有着广泛应用的，有很多人学的第一门计算机语言就是Scheme语言。 它是一个小巧而又强大的语言，作为一个多用途的编程语言，它可以作为脚本语言使用，也可以作为应用软件的扩展语言来使用，它具有元语言特性，还有很多独到的特色,以致于它被称为编程语言中的"皇后"。 下面是洪峰对Scheme语言的编程特色的归纳： ?词法定界（Lexical Scoping） ?动态类型（Dynamic Typing） ?良好的可扩展性 ?尾递归（Tail Recursive） ?函数可以作为值返回 ?支持一流的计算连续 ?传值调用（passing-by-value） 术运对 ?算算相独立 本文的目的是让有编程基础（那怕是一点点）的朋友能尽快的掌握Scheme语言语规则读发现经Scheme语言了，那么我的的法，如果您在完本文后，自己已会用 目的就达到了。
软件简介： 1 C语言概述2 1.1 Ｃ语言的发展过程2 1.2 当代最优秀的程序设计语言2 1.3 Ｃ语言版本2 1.4 Ｃ语言的特点3 1.5 面向对象的程序设计语言3 1.6 Ｃ和Ｃ＋＋3 1.7 简单的Ｃ程序介绍4 1.8 输入和输出函数5 1.9 Ｃ源程序的结构特点6 1.10 书写程序时应遵循的规则6 1.11 Ｃ语言的字符集6 1.12 Ｃ语言词汇7 1.13 Turbo C 2.0集成开发环境的使用8 1.1 3.1 Turbo C 2.0简介和启动8 1.13.2 Turbo C 2.0集成开发环境8 1.13.3 File菜单9 1.13.4 Edit菜单10 1.13.5 Run菜单11 1.13.6 Compile菜单12 1.13.7 Project菜单13 1.13.8 Options菜单14 1.13.9 Debug菜单18 1.13.10 Break/watch菜单19 1.13.11 Turbo C 2.0的配置文件20 2 程序的灵魂—算法1 2.1 算法的概念1 2.2 简单算法举例1 2.3 算法的特性4 2.4 怎样表示一个算法4 2.4.1 用自然语言表示算法4 2.4.2 用流程图表示算法4 2.4.3 三种基本结构和改进的流程图8 2.4.4 用N-S流程图表示算法9 2.4.5 用伪代码表示算法10 2.4.6 用计算机语言表示算法11 2.5 结构化程序设计方法11 2 3 数据类型、运算符与表达式1 3.1 Ｃ语言的数据类型1 3.2 常量与变量3
3.2.1 常量和符号常量3 3.2.2 变量3 3.3 整型数据4 3.3.1 整型常量的表示方法4 3.3.2 整型变量5 3.4 实型数据7 3.4.1 实型常量的表示方法7 3.4.2 实型变量8 3.4.3 实型常数的类型9 3.5 字符型数据9 3.5.1 字符常量9 3.5.2 转义字符9 3.5.3 字符变量10 3.5.4 字符数据在内存中的存储形式及使用方法10 3.5.5 字符串常量11 3.5.6 符号常量12 3.6 变量赋初值12 3.7 各类数值型数据之间的混合运算13 3.8 算术运算符和算术表达式14 3.8.1 C运算符简介14 3.8.2 算术运算符和算术表达式15 3.9 赋值运算符和赋值表达式17 3.10 逗号运算符和逗号表达式18 3.11 小结19 3.11.1 Ｃ的数据类型19 3.11.2 基本类型的分类及特点19 3.11.3 常量后缀19 3.11.4 常量类型19 3.11.5 数据类型转换19 3.11.6 运算符优先级和结合性20 3.11.7 表达式20 4 最简单的C程序设计—顺序程序设计1 4.1 Ｃ语句概述1 4.2 赋值语句3 4.3 数据输入输出的概念及在C语言中的实现4 4.4 字符数据的输入输出4 4.4.1 putchar 函数（字符输出函数）4 4.4.2 getchar函数（键盘输入函数）5 4.5 格式输入与输出5 4.5.1 printf函数（格式输出函数）5 4.5.2 scanf函数(格式输入函数) 8 4.6 顺序结构程序设计举例12 4 5 分支结构程序1
易语言入门教程:易语言入门！ 如果你是一个刚接触易语言或者是一个连编程都没有接触过的顶级菜鸟、超级新手的话，那么你千万不要错过以下的内容哦！！ 以下内容是“易语言菜鸟之家”结合了众多新手朋友们的困惑和疑问而整理出的经典问题集，如果你刚接触易语言，还不知道自己如何入门，不清楚自己如何去学习这们编程语言，或者你对编程一窍不通的话，看了以下的内容，应该可以让你找到自己的入门路口！ 1、什么是易语言？它和VB、C语言、C++等有什么区别和相同点？答：易语言是中国人自己开发的一种编程语言，是一款全中文程序代码的编程语言，和VB、C语言、C++、C#等都属于同一性质，都是用来开发程序和编写软件用的。易语言的内核由C++编写而成，与前面说的几种语言一样，都属于运行于操作系统平台上的高级编程语言。易语言与其他几种语言的不同点在于：易语言采用的是全中文的程序代码，不需要英语基础即可学习使用，和其他几种编程语言相比，易语言更简单易学，入门更快，编写软件变的更加简单化。 2、什么是软件编程，应用程序与操作系统之间有什么关系？ 答：对于一个从来没有接触过编程的新手来说，这个问题显得很抽象，无法用准确的语言来表达，简单的可以理解为用相关的编程语言通过一系列的组合，设计出能够运行在操作系统上的相关应用程序，这个过程就是我们平时所听到的“程序设计”，或者说叫“编程”。易语言就属于为了实现“程序设计”而提供的一计算机编程语言。应用程序基于操作系统平台开发，与操作系统紧密结合，程序在开发过程中，用到了很多由操作系统直接提供的资源和功能。应用程序不需要关心硬件（CPU、内存等）如何工作，因为有操作系统在中间作为信息传递的平台，通常情况下，应用程序一但脱离了操作系统将无法与计算机硬件进行直接沟通，也就无法正常运行，作为应用程序与计算机硬件之间为沟通平台的操作系统，在其中扮演着重要的角色，它为应用程序的运行提供了平台支持，我们平时所使用的类似与QQ，迅雷这类应用程序，也必须依赖操作系统才能工作，一但脱离了widows系统，他们都将无法运行。▲注明：除了驱动级的程序以外（如硬件设备的驱动程序），通常的应用程序都是无法直接与计算机硬件进行沟通的，都必须将要做的工作先告诉给操作系统，然后再由操作系统告诉计算机硬件（CPU、内存等），才能完成一系列的操作。 3、什么是“高级语言”？什么是“低级语言”？两者有什么区别？ 答：很多新手们对“高级语言”和“低级语言”这两个名词感到很陌生：到底什么样的编程语言才算是“高级”，而什么样的语言又算是“低级”呢？ 简单的可以这样理解： 能够直接运行在操作系统之上，不用关心硬件如何工作，将主要精力集中在程序的开发设计上的语言都称为高级语言。 反过来，需要考虑到硬件如何工作，需要与计算机硬件进行直接沟通的语言则称为低级语言。如：汇编语言就是典型的与对硬件进行操作的低级语言。 例如：VB、C#、C++、易语言、Delphi这些都属于高级语言。汇编则属于低级语言。 4、什么是“面向过程”和“面向对象”，他们有什么区别？ 答：这两个概念性的词想必很多新人都不能很彻底的理解吧。举两个简单的例子来说明一下吧：比如你饿了，想吃面包，你可以自己找来面，找来鸡蛋，找来糖等等，然后自己一点点动手，做出来，放在烤箱里考熟，然后拿出来吃。这个可以理解为“面向过程”；但是你还
易语言教程-从入门到精通 第一课．计算机的一般知识 1.1电子计算机的发展及其基本结构 1.1.1电子计算机的发展史 1945年底，在美国首次研制成功人类第一台计算机，这台机器重30吨，占地面积达167平方米，加之它的工作原理，因此，人类后来的计算机并不是在这台机器的基础上发展起来的。 现代计算机理论的奠基人是图灵。在美国数学家冯．诺伊曼的主持下，1949年诞生了第一台存储程序的计算机，又称第一代机，这台计算机为后来的计算机发展奠定了基础。1959年，第一台晶体管计算机问世，由此，计算机进入了第二代。1964年，IBM第一代360系列计算机问世，这是第一代通用计算机，为研制这种计算机，IBM投资50亿美元，比二战期间美国政府投入到原子弹研究的钱(20亿美元)还要多；由此，计算机进入了第三代。 进入到80年代以后，中大型计算机问世，于是开始了第四代计算机的时代。70年代以后，出现了计算速度更快、存储量更大的巨型机。 70年代微处理器的问世，标志着计算机的发展开始了又一场革命。1977年3月苹果公司的个人用计算机问世，自此，计算机开始进入千家万户。 1.1.2电子计算机的基本结构 计算机由硬件和软件组成。而硬件是由主机和外部设备组成；软件由系统软件和应用软件组成。 计算机硬件是软件的基础，是软件发挥功能的工作环境，而软件则是管理和利用硬件资源来实现计算机的功能，软件和硬件是相互促进和发展的。 硬件大体上有以下几个部分：控制器，运算器，内存储器（RAM、ROM），输入设备和输出设备。前三者又合称主机，后两者又称作外部设备。现在就这五个部分的功能，作一些简要说明。 1．输入设备。输入设备是用来向主机输入原始数据和处理这些数据所使用的计算程序列的设备。输入设备的种类很多，但在微型机上不外乎下列几种： （1）终端键盘。利用手指击键方法向计算机输入信息。用户自己写的程序列化和准备处理的数据，都可由键盘上敲入。 （2）磁盘。磁盘，实际上也是存储信息的，因为它们都是主机之外的设备，所以也称为外存储器。外存储器上的信息，也可以输入到机器中去。 （3）模—数(A/D)转换器。它可以将连续变化的模拟量（如电压、电流、长度、角度等）转换为数字量，送入到机器中去。 此外，图形输入板、声音输入装置等，实际上是专用的模数转换器，同样可以为计算机输入信息。 2．输出设备。输出设备是用来输出计算结果或其它信息的。常用的输出设备有： （1）显示终端。用以显示计算机的有关信息，占用户从键盘上敲入并为机器接收的字
第一章：表演的要求 小朋友们你们知道我们站在舞台上应该用什么状态表演吗？ 一、最基本的要求 1.对于学龄前的儿童，首先要启发和鼓励他们喜欢张嘴，愿意朗诵。 2.通过练习，是他们朗诵能够达到：大声、清楚。自然，流畅。 二、声音洪亮 1.声音洪亮，就是大声。 2.在鼓励幼儿大声朗诵的同时，要注意不要让幼儿声带过于用力，造成声音尖细、声嘶力竭，甚至造 成声带疲劳、病变，毁坏嗓音。 3.要知道幼儿试着把注意力放在肚脐下的丹田部位，气往下沉；努力提起上颚，打开后牙。其实，这 就是丹田用气和制造共鸣的初步尝试和训练。 三、口齿清楚 许多幼儿说话时懒得张嘴，懒得用力气，所以造成说话不清楚，甚至有些声母、韵母含混或不能区分。例如有些幼儿，并不是受地方语言习惯的影响，而纯粹是舌头懒得用力，所以造成n-l部分，甚至把ge 说成了zhe，er字发不清楚。我们也曾听到个别人直到成年都说不清“来了”的“了”字。其实很多人并不是口舌的生理问题造成的，更多的是从小没有注意语言的训练，而形成了不良的语言习惯。 1.要想把话说清楚，唇齿口舌颚都要用力。只要不偷懒，认真练习，除了个别存在生理缺陷的幼儿， 都可以做到发音清晰，口齿清楚。 2.为了使幼儿做到发音清晰，口齿清楚，要让幼儿多练习绕口令。它可以训练口清各个部位的功能， 并可以训练幼儿清晰准确地读出每个字的声母、韵母的读音。 3.幼儿级主要考查考生的声母读音是否清楚有力，特别是n-l、g-k、d-t及平翘舌音必须分清。 四、正确的舞台站立姿势 抬头，脸自然的面向正面前方，头顶持平，下巴微收；双肩放松，略向下压，头颈伸直，是人体有
一种向上的感觉；挺胸，收腹，立腰，提臀，躯干直立，不向左、右偏斜和晃动；双臂自然下垂，手掌自然弯曲放在大腿两侧裤缝处；双腿并拢挺直，两个膝盖和两个脚跟分别靠拢，角尖分开，是双脚从自己的角度看成八字形。站立时也可以两腿略微分开，两个脚尖比脚跟并拢时略微向回收一点，但两腿分开的距离不要超过肩宽。 第二章：课前小运动 课前小运动可以帮助小朋友训练肢体的每一个部分。 每次做的时候要认真哦！ 语言表演艺术是一门自然、真实的艺术。面对艺术作品所蕴含的自然，观赏者也必然会产生情感的陶冶和观感的陶醉。表演艺术就是这样，观众要相信舞台上所发生的一切，要跟随演员所扮演的角色去同喜同悲，对舞台上发生的一切产生思考等等，这些都需要表演者运用技巧，真实、自然的把人物、故事展现给观众，“牵住”观众的眼睛、心灵，使观众产生“这就是”的欣赏心理。要做到这些就需要演员掌握天性的创作规律，在完全恢复第一自然天性的状态下，开启创作的第二自然天性的大门。作为主持人、朗诵者，其实他也是演员，在主持朗诵过程中，要机智的应对舞台上发生的种种问题，让整个表演过程成为一个整体，加入你的智慧，让整个表演出彩，达到预期的目的。 为了提高孩子的自信度，锻炼孩子良好的台风。在正式上课之前进行肢体的运动，让孩子身体的每个关节都运动一下，可以令其在进行表演时达到肢体灵活。在各种表演中像声乐、主持、朗诵、演讲都要求体态自然，协调舒展，举止优雅，所以每次上课前要让孩子释放天性。 这里我们释放天性让孩子做一些运动： 1、《小木偶》 我是快乐的小木偶，我伸伸胳膊，我踢踢腿，我点点头来我弯弯腰，我扭扭屁股我探探身，我要给大家表演了。 《大力士》
软件简介： 1C语言概述2 1.1Ｃ语言的发展过程2 1.2当代最优秀的程序设计语言2 1.3Ｃ语言版本2 1.4Ｃ语言的特点3 1.5面向对象的程序设计语言3 1.6Ｃ和Ｃ＋＋3 1.7简单的Ｃ程序介绍4 1.8输入和输出函数5 1.9Ｃ源程序的结构特点6 1.10书写程序时应遵循的规则6 1.11Ｃ语言的字符集6 1.12Ｃ语言词汇7 1.13Turbo C 2.0集成开发环境的使用8 1.1 3.1Turbo C2.0简介和启动8 1.13.2Turbo C 2.0集成开发环境8 1.13.3File菜单9 1.13.4Edit菜单10 1.13.5Run菜单11 1.13.6Compile菜单12 1.13.7Project菜单13 1.13.8Options菜单14 1.13.9Debug菜单18 1.13.10Break/watch菜单19 1.13.11Turbo C 2.0的配置文件20 2程序的灵魂—算法1 2.1算法的概念1 2.2简单算法举例1 2.3算法的特性4 2.4怎样表示一个算法4 2.4.1用自然语言表示算法4 2.4.2用流程图表示算法4 2.4.3三种基本结构和改进的流程图8 2.4.4用N-S流程图表示算法9 2.4.5用伪代码表示算法10 2.4.6用计算机语言表示算法11 2.5结构化程序设计方法11 2 3数据类型、运算符与表达式1 3.1Ｃ语言的数据类型1 3.2常量与变量3
3.2.1常量和符号常量3 3.2.2变量3 3.3整型数据4 3.3.1整型常量的表示方法4 3.3.2整型变量5 3.4实型数据7 3.4.1实型常量的表示方法7 3.4.2实型变量8 3.4.3实型常数的类型9 3.5字符型数据9 3.5.1字符常量9 3.5.2转义字符9 3.5.3字符变量10 3.5.4字符数据在内存中的存储形式及使用方法10 3.5.5字符串常量11 3.5.6符号常量12 3.6变量赋初值12 3.7各类数值型数据之间的混合运算13 3.8算术运算符和算术表达式14 3.8.1C运算符简介14 3.8.2算术运算符和算术表达式15 3.9赋值运算符和赋值表达式17 3.10逗号运算符和逗号表达式18 3.11小结19 3.11.1Ｃ的数据类型19 3.11.2基本类型的分类及特点19 3.11.3常量后缀19 3.11.4常量类型19 3.11.5数据类型转换19 3.11.6运算符优先级和结合性20 3.11.7表达式20 4最简单的C程序设计—顺序程序设计1 4.1Ｃ语句概述1 4.2赋值语句3 4.3数据输入输出的概念及在C语言中的实现4 4.4字符数据的输入输出4 4.4.1putchar函数（字符输出函数）4 4.4.2getchar函数（键盘输入函数）5 4.5格式输入与输出5 4.5.1printf函数（格式输出函数）5 4.5.2scanf函数(格式输入函数)8 4.6顺序结构程序设计举例12 4 5分支结构程序1
汇编语言入门教程2007-04-29 22:04对初学者而言，汇编的许多命令太复杂，往往学习很长时间也写不出一个漂漂亮亮的程序，以致妨碍了我们学习汇编的兴趣，不少人就此放弃。所以我个人看法学汇编，不一定要写程序，写程序确实不是汇编的强项，大家不妨玩玩DEBUG，有时CRACK出一个小软件比完成一个程序更有成就感（就像学电脑先玩游戏一样）。某些高深的指令事实上只对有经验的汇编程序员有用，对我们而言，太过高深了。为了使学习汇编语言有个好的开始，你必须要先排除那些华丽复杂的命令，将注意力集中在最重要的几个指令上（CMP LOOP MOV JNZ……）。但是想在啰里吧嗦的教科书中完成上述目标，谈何容易，所以本人整理了这篇超浓缩（用WINZIP、WINRAR…依次压迫，嘿嘿！）教程。大言不惭的说，看通本文，你完全可以“不经意”间在前辈或是后生卖弄一下DEBUG，很有成就感的，试试看！那么――这个接下来呢？――Here we go！（阅读时看不懂不要紧，下文必有分解） 因为汇编是通过CPU和内存跟硬件对话的，所以我们不得不先了解一下CPU和内存：（关于数的进制问题在此不提） ＣＰＵ是可以执行电脑所有算术╱逻辑运算与基本I/O 控制功能的一块芯片。一种汇编语言只能用于特定的CPU。也就是说，不同的CPU其汇编语言的指令语法亦不相同。个人电脑由1981年推出至今，其CPU发展过程为：8086→80286→80386→80486→PENTIUM →……，还有AMD、CYRIX等旁支。后面兼容前面CPU的功能，只不过多了些指令（如多能奔腾的MMX指令集）、增大了寄存器（如386的32位EAX）、增多了寄存器（如486的FS）。为确保汇编程序可以适用于各种机型，所以推荐使用8086汇编语言，其兼容性最佳。本文所提均为8086汇编语言。寄存器（Register）是CPU内部的元件，所以在寄存器之间的数据传送非常快。用途：1.可将寄存器内的数据执行算术及逻辑运算。2.存于寄存器内的地址可用来指向内存的某个位置，即寻址。3.可以用来读写数据到电脑的周边设备。8086 有8个8位数据寄存器，这些8位寄存器可分别组成16位寄存器：ＡＨ&ＡＬ＝ＡＸ：累加寄存器，常用于运算；ＢＨ&ＢＬ＝ＢＸ：基址寄存器，常用于地址索引；ＣＨ&ＣＬ＝ＣＸ：计数寄存器，常用于计数；ＤＨ&ＤＬ＝ＤＸ：数据寄存器，常用于数据传递。为了运用所有的内存空间，8086设定了四个段寄存器，专门用来保存段地址：ＣＳ（Code Segment）：代码段寄存器；ＤＳ（Data Segment）：数据段寄存器；ＳＳ（Stack Segment）：堆栈段寄存器；ＥＳ（Extra Segment）：附加段寄存器。当一个程序要执行时，就要决定程序代码、数据和堆栈各要用到内存的哪些位置，通过设定段寄存器CS，DS，SS 来指向这些起始位置。通常是将DS固定，而根据需要修改CS。所以，程序可以在可寻址空间小于64K的情况下被写成任意大小。所以，程序和其数据组合起来的大小，限制在DS 所指的64K内，这就是COM文件不得大于64K 的原因。8086以内存做为战场，用寄存器做为军事基地，以加速工作。除了前面所提的寄存器外，还有一些特殊功能的寄存器：IP（Intruction Pointer）：指令指针寄存器，与CS配合使用，可跟踪程序的执行过程；SP（Stack Pointer）：堆栈指针，与SS配合使用，可指向目前的堆栈位置。BP（Base Pointer）：基址指针寄存器，可用作SS的一个相对基址位置；SI（Source Index）：源变址寄存器可用来存放相对于DS段之源变址指针；DI（Destination Index）：目的变址寄存器，可用来存放相对于ES 段之目的变址指针。还有一个标志寄存器FR（Flag