dongbei语言咬文嚼字

学习一门语言，先得了解它的词法（怎么从一串串的字符组成词），然后是语法（怎么把词组成句子）和语义（这些句子都啥意思啊？）。
所以，咱们先讲讲 dongbei 语言词汇的构成。

词法

字符串常量

一行代码当中，要是出现配对的中文全角双引号，比如

...“我是一个字符串”...

那么引号当中的内容（我是一个字符串）会被当成一个字符串常量。

注释

一行代码当中，如果在字符串常量外面出现 # 字符，所有从 # 开始的字符都会被当成注释被忽略掉。
比如

唠唠：  # 我是一个注释。
    “嘎哈#？”。  # 我还是一个注释。

跟

唠唠：“嘎哈#？”。

是一样一样的。

分词

大部分的西方语言在书写的时候要用空白字符或者标点把单词隔开，要不就会产生歧义。
比如 therapist（理疗师）和 the rapist（强X犯）就有很大的不同！

所以，西人开发的编程语言也一样啰嗦，动不动就要加空格，忒麻烦了。

dongbei 语言以人为本，适应华人的书写习惯，加不加空格换行都无所谓。
反正加了也白加（除非加在一个字符串常量的内部）。
所以对 dongbei 来说，

唠
  唠
    ：
      “嘎哈？”
        。

跟

唠唠：“嘎哈？”。

是一样一样的。

名字

代码里面除了各种有特俗意义的关键词（keyword），还会有各种用户定义的名字（变量名、函数名、类型名，等等）。
在 dongbei 语言里面，除了关键词、标点符号和常数，剩下的都是名字。
比如，在“张三乘李四”这个 dongbei 语言表达式里，“乘”是一个关键词，“张三”和“李四”是两个不同的名字，

那么问题来了：dongbei 语言是不尿空格的，名字和关键词之间没有明显的隔离。
要是名字里包含关键词怎么办？
比如，我们知道“乘”是一个关键词，那还能用“阶乘”做套路名吗？
系统会不会把它理解成名字“阶”和关键词“乘”？

嫑方！
dongbei 语言允许你用中文全角方括号【】把一串字符标注为名字。
比方说，“【阶乘】”就明明白白地是一个叫“阶乘”的名字，绝对不会被当成是名字“阶”加关键词“乘”。

常数

除了用阿拉伯数字表示的十进制整数（比如 2、42、250，等等），0 到 10 的常数也可以用中文表达：

零一二三四五六七八九十

零也可以写成鸭蛋。
二也可以写成两或者俩。
三也可以写成仨。

比如，

五加二

的意思就是 5 + 2。

除此之外还有表示对错的常数 没毛病（对）和 有毛病（错）。

语句

一个 dongbei 程序是由一串语句组成的。
每个语句以句号（。）结束。
为了表达程序员炽热的感情，也可以用感叹号（！）结束，意思和句号是一样一样的。
请大家根据自己的心情任选使用。

变量

dongbei 语言允许使用任何字符串做变量名。只要记住两点：

1. 变量名里所有的空白字符都会被忽略。
2. 有歧义的时候要把变量名用【】括起来。

定义变量

dongbei 是一门以人为本的语言。
我们知道东北人都是活雷锋。
所以，要定义一个叫 XX 的变量，我们要写......

XX是活雷锋。

比如：

老王是活雷锋。

当然，热情洋溢的

老王是活雷锋！

也是可以的。

给变量赋值

dongbei 语言不整“赋值”这种文绉绉的词儿。
咱们叫“装”。
比如：

老王装二。

可以理解为 C 语言的

lao_wang = 2;

要把一个活雷锋的值清空回到原始状态，可以用削：

削老王。  # 跟 '老王 装 啥也不是。' 意思一样，可是带感啊！

过后老王就啥也不是了，但是名字还在。所以

老张装老王。

还是可以的，结果是老张也变成啥也不是。

更狠的操作捏是 炮决：

炮决老王。

过后老王就香消玉殒，尸骨无存了，连名字都留不下。
这时候，要是再来

老张装老王。

就会爆出一个错（整叉劈了）。

增减变量

活雷锋除了会装，加加减减也是常见的操作。
按没病走两步的规矩，这些操作的名字叫做：走走、稍稍、走X步、稍X步。
比如：

老张装二。  # 现在老张等于2
老张走走。  # 现在老张等于3
老张走两步。  # 现在老张等于5
老张稍稍。  # 现在老张等于4
老张稍五步。  # 现在老张等于-1

注：稍（shào）稍这个词的意思是“退退”。
它具有十分浓厚的地方风味，尤其在东北大老哥向社会小老弟传授人生的经验时，出现得尤为频繁，体现了东北人民的儒雅随和，平易近人。
近年来随着各种视频、社交平台的发展，这个东北词汇也受到了来自社会各界人士的喜爱。

引用变量

变量，呃，活雷锋定义以后就可以引用了。
引用的方法很简单：把活雷锋的名字写出来就成。
比如：

老张是活雷锋。
老王是活雷锋。
老张装250。
老王装老张加13。

定义了两个活雷锋：老张和老王。
老张值250。
老王值263。

交流

dongbei 能说会道。
输出信息咱们得说 唠唠。
假定要说的信息是 YY，就得写

唠唠：YY。

比如说，活雷锋老王的当前值是263，那么

唠唠：老王。

的结果就是打印

263

唠的内容也可以是中文全角双引号括起来的字符串常量，像

唠唠：“诶呀妈呀！”。

的结果就是打印出

诶呀妈呀！

要是等用户输入呢，就整 你吱声：

贵姓 装 整你吱声（“你贵姓？”）  # 打印消息，然后等输入。
唠唠：“名字呢？”
名字 装 整你吱声。  # 不打印消息，等输入。
唠唠：“你揍是传说中的”、贵姓、名字、“啊！”。

字符串运算

顿号（、） 操作符可以把两个值当成字符串拼接起来。
假定活雷锋老王的当前值是字符串“NB”，那么表达式

老王、“A”

的值就是字符串 NBA。而

“老王”、665加一

的值是 老王666。

算术运算

基本的四则运算 dongbei 都是支持的。举例说明：

注意除法运算叫“除以”，不叫“除”。
问问你小学数学老师就知道，“A除B”的意思其实是“B除以A”，也就是说“B/A“。
所以，要是你说“6除2”，数学老师会以为你在说3分之1，而不是3。
你要是跟他讲“6除2得3”，信不信他削你？

跟小学学过的一样，乘除和求余的优先级比加减高。
相同优先级的情况下，运算从左到右。比如说：

3加2乘5

的结果是13，不是25。

括号也是可以的：

唠唠：(五减（四减三）)乘二。

得

8

比大小

dongbei 人讲究分寸，长幼有序。

假定老王装的是5，老张装的是6。
那么

唠唠：老王 比 老张 还大。
唠唠：老王 比 老张 还小。
唠唠：老王 跟 老张 一样一样的。
唠唠：老王 跟 老张 不是一样一样的。

的结果就是

有毛病
没毛病
有毛病
没毛病

除此之外，一个刚刚创建的活雷锋还没有值。
我们就说他啥也不是：

老王是活雷锋。
唠唠：老王。
唠唠：老王啥也不是。

会打印

啥也不是
没毛病

群众

单只单只的活雷锋有的时候略显捉襟见肘。
dongbei 支持“群众”的概念。
就是一个变量里放一群活雷锋。
有学习好的同学可能发觉了：这不就是数组吗！

比如：

张家庄都是活雷锋。  # 张家庄是个群众变量。初始值是「」。

完了吧就可以往里边儿加人了：

张家庄 装 「二加三，“大”」。  # 张家庄现在 = 「5, '大'」
张家庄 来了个 四减一。  # 张家庄现在 = 「5, '大', 3」
张家庄 来了个 “粗”。   # 张家庄现在 = 「5, '大', 3, '粗'」

加完人就可以点名了：

唠唠：张家庄的老大。  # 第一个人（5）。
唠唠：张家庄的老二。  # 第二个人（'大'）。
唠唠：张家庄的老（四减一）。  # 第三个人（3）。
唠唠：张家庄的老四。  # 第四个人（'粗')。
唠唠：张家庄的老一。  # 跟老大一回事。
唠唠：张家庄的老幺。  # 最后一个人（'粗')。

要想无视老大或老幺，可以分别用 掐头 和 去尾 运算。比如：

唠唠：张家庄掐头。  # 「'大', 3, '粗'」
唠唠：张家庄去尾。  # 「5, '大', 3」

注意 掐头 和 去尾 只是运算，它们返回一个新的群体，不会真的去修改 张家庄。
所以，上面的操作弄完后，张家庄 还是 「5, '大', 3, '粗'」，一个也不能少。

既然数组里头可以套数组，那么群众当中也可以套群众：

李家村都是活雷锋。  # 李家村也是个群众变量。初始值是「」。
李家村来了个三。  # 李家村现在 = 「3」。
李家村来了个张家庄。  # 李家村现在 = 「3, 「5, '大', 3, '粗'」」。
唠唠：李家村的老幺的老大。  # 5。

也可以用 来了群 一次把一个村庄的群众挨个加入到另一个村庄：

李家村 来了群 张家庄。
# 李家村现在 = 「3, 「5, '大', 3, '粗'」, 5, '大', 3, '粗'」。
# 张家庄现在还 = 「5, '大', 3, '粗'」。
# 一次加多个群众。
李家村 来了群 「9，2，3」。  # 也可以说： 李家村 来了群 路银「9，2，3」。
# 李家村现在 = 「3, 「5, '大', 3, '粗'」, 5, '大', 3, '粗', 9, 2, 3」。

要数数一个数组里有几个元素，用XX有几个坑：

唠唠：张家庄有几个坑。  # 4
唠唠：李家村有几个坑。  # 9

注意这李家村有九个坑，第一个装的是3，第二个装的是「5, '大', 3, '粗'」，......

国有国法，村有村规。
在村子里要干掉某人，可以炮决：

# 一开始张家庄 = 「5, '大', 3, '粗'」。
炮决张家庄的老三。  # 张家庄现在 = 「5, '大', '粗'」。

要想团灭群众，只需要削他们：

削张家庄。  # 张家庄现在啥也不是。

抱团

和参加群众性活动类似，活雷锋们还可以抱团。
一个群的成员数可以是0，1，2，3......
同样的，一个团的成员数也可以是0, 1, 2, 3......

用 X 跟 Y 跟 Z 抱团 这个操作，可以把 0 到多个活雷锋抱成一团：

圣人团 装 抱团。  # ()
独孤求败团 装 西门吹雪 抱团。  # (西门吹雪,)
二人转团 装 赵英俊 跟 高老师 抱团。  # (赵英俊, 高老师)
桃园社 装 老刘 跟 老关 跟 老张 抱团。  # (老刘, 老关, 老张)
唠唠：桃园社 有几个坑。  # 3

抱团之后，可以用 老几 操作访问团员：

唠唠：桃园社 的老大。  # 老刘
唠唠：桃园社 的老二。  # 老关
唠唠：桃园社 的老幺。  # 老张

那么你要问了：这个群和团到底有啥不一样？说叨说叨？

问得好！

群众是来去自由的，还可以变来变去：

张家庄装「5，3，2，4」。
张家庄来了个7。    # 变多了：「5, 3, 2, 4, 7」
炮决张家庄的老大。  # 变少了：「3, 2, 4, 7」
张家庄的老二装九。  # 变节了：「3, 9, 4, 7」

团就不一样了。一朝入团，终身不悔。

啥 XX团 来了个 YY，XX团 来了群 YYY，炮决 XX团的老二，XX团的老幺 装 YY，......这些妄想改变团成员的操作，整个儿都是徒劳的。

切记，切记。

磨叽

所谓磨叽，就是一遍一遍循环。
所以，在 dongbei 语言里循环的写法是：

变量名 从 X 到 Y 磨叽：
  ...  # 需要重复做的事
磨叽完了。

举例说明：

老王从一到五磨叽：  # 老王从1走到5。
  唠唠：老王！  # 打印老王的当前值。
磨叽完了！  # 循环结束。

运行的结果是：

1
2
3
4
5

磨叽的范围也可以是群众。比如，要是张家庄装的是「3,1,5,2」，那么

老王在张家庄磨叽：
  唠唠：老王。
磨叽完了。

的结果就是

3
1
5
2

磨叽是可以嵌套的。比如：

老张从一到二磨叽：
  唠唠：“老张：”、老张。
  老王从老张到四磨叽：  # 内层磨叽可以引用外层磨叽变量
    唠唠：“老王：”、老王。
  磨叽完了。  # 内层磨叽结束。
磨叽完了。  # 外层磨叽结束。

运行出来是这样的：

老张：1
老王：1
老王：2
老王：3
老王：4
老张：2
老王：2
老王：3
老王：4

要是磨叽到半拉儿就不想再磨叽了咋办咧？那就 尥蹶子。
要是想跳过从当前到 磨叽完了 中间的所有操作，就说 接着磨叽。
比如这个：

老张从一到十磨叽：
  寻思：老张跟二一样一样的？
  要行咧就接着磨叽。
  唠唠：“老张是”、老张。
  寻思：老张比五还大？
  要行咧就尥蹶子。
磨叽完了。

结果就是

老张是1
老张是3
老张是4
老张是5
老张是6

要是想 死磨叽，可以 从一而终：

老王装一。
老张从一而终磨叽：  # 磨叽无穷次，每次的值都是一。
唠唠：老张、“和”、老王。
老王装老王加一。
寻思：老王比三还大？
要行咧就尥蹶子。
磨叽完了。

结果就是

1和1
1和2
1和3

讲条件

虽然 dongbei 人都是活雷锋，干活的时候该讲条件还是要讲条件的。
寻思 是一项很有用的技能！

一般来讲，要是俺们有件事情（不妨叫做 XXX）只想在某个条件（不妨叫 CCC）成立的时候再做，就写：

寻思： CCC ？
要行咧就 XXX

要是 CCC 不成立的时候俺们有另外一件事情 YYY 要做，那就写：

寻思： CCC ？
要行咧就 XXX
要不行咧就 YYY

比如说吧，要是俺们瞅着老王比老张还大就想夸夸老王，那就这么写：

寻思：老王比老张还大？
要行咧就唠唠：“老王比较牛叉！”。

再复杂一点的：

寻思：老王比老张还大？
要行咧就唠唠：“老王比较牛叉！”。
要不行咧就寻思：老张比老王还大？
要行咧就唠唠：“老张比较牛叉！”。
要不行咧就唠唠：“老王老张共同牛叉。”。

看懂了？要是老王是3老张是2，那么这段代码就会打印

老王比较牛叉！

要是老王2老张3咧，就会打印

老张比较牛叉！

要是老王老张都2咧，打印的就是

老王老张共同牛叉。

叉劈

很多的时候，要是一个前提条件不成立，咱们就想立马尥蹶子退出整个程序，因为它意味着上游提了个不合理的要求。
虽然理论上说寻思可以处理这种情况，实际用起来相当啰嗦。
这时候咱们就可以用保准CCC，非常精炼。
比如：

保准老王比五还大。

要是老王的值比五还大咧，这句话没毛病，程序接着往下跑。
如若不然，程序立马退出，而且打印出一条错误：

整叉劈了：该着 【老王】比5还大，咋有毛病了咧？

还有的时候咧，咱们要保准某个条件不成立。跟保准相对的是辟谣：

老王装二。
辟谣老王比五还大。  # 没毛病
辟谣五比老王还大。  # 整叉劈了：5比【老王】还大不应该啊，咋有毛病了咧？

严格来说“辟谣”并不是东北特有的词汇，但是东北人民对它可以说是相当的熟悉了。
所以把它收入 dongbei 编程语言是相当和谐的。
你明白了吗？

善用保准和辟谣，保准臭虫在你代码里藏不住。

要是写 整叉劈了：XXX。 咧，就会让程序马上打印 XXX 然后退出。比如：

寻思：小王比18还小？
要行咧就 整叉劈了：“小王只有”、小王、“，小朋友请回避！”。

会在小王装16的时候打出消息

整叉劈了：小王只有16。小朋友请回避！

然后立马退出。

组合拳

你有没有想过：要是俺们在某个条件成立的时候想做两件事而不是一件事，该咋办咧？
要是写

寻思：CCC ？
要行咧就
   XXX。
   YYY。

成嘛？

不成。

前面俺们说过咧，dongbei 语言里面字符串常量外边儿的空白是不作数的。
写了也瞎掰活。
所以，按上面这种写法，XXX 倒是只有 CCC 成立的时候才会做，可 YYY 是无论如何都会做的。
相当于：

# 先讲条件：
寻思：CCC ？
要行咧就XXX。
# 这个不讲条件。
YYY。

要解决这个问题，咱得上 组合拳：把一串操作整合成一个操作。
组合拳的写法是：

开整：
  XXX。
  YYY。
  ...
  ZZZ。
整完了。

尽管整了一串，在 dongbei 语言看来这是一个操作。
所以，

寻思：CCC ？
要行咧就开整：
   XXX。
   YYY。
整完了。

就能达到俺们的目的了！

套路

“套路”这名字听着吓人，其实就是给一串常用的组合拳取一个名字，然后吧需要做这些操作的时候提一下这个名字就OK了。

定义套路

要定义一个套路，用这个格式：

套路名字 咋整：
  ...  # 爱做的事儿
整完了。

还是举例说明：

写九九表咋整：  # 定义套路 写九九表。
  老王从1到9磨叽：
    老张从老王到9磨叽：
      唠唠：老王、“*”、老张、“=”、老王乘老张。  # 打印 X*Y=Z
    磨叽完了。
    唠唠：“”。  # 空一行。
  磨叽完了。
整完了。  # 结束套路定义。

定义了一个叫“写九九表”的套路。
注意定义套路本身不会让这个套路真的跑起来。
所以上面这段程序跑的结果是啥也不做。

使用套路

要把一个套路代表的操作跑一遍，得写：

整 套路名。

比如说，上面这个“写九九表”的套路定义好了过后，你只要写：

整写九九表。

就可以打印出一份浓眉大眼的九九表了：

1*1=1
1*2=2
1*3=3
...
8*8=64
8*9=72
9*9=81

带参数的套路

有的时候，我们希望通过一个参数去控制一个套路的行为。
比如，我们要教会电脑算一个数的阶乘（就是123*… 一直乘到这个数）。
在定义这个“阶乘”套路的时候，我们并不知道以后会用它来算哪个数的阶乘。
所以，我们要把这个数定义成这个套路的一个参数。

那就要这样写：

套路名（参数名）咋整：
  ...  # 爱做的事
整完了。

具体到这个“阶乘”套路，就是这样的：

【阶乘】（那啥）咋整：  # 定义套路 阶乘，有一个参数 那啥
  ...  # 阶乘的操作步骤
整完了。  # 定义结束。

注意这里我们把套路名“阶乘”用方括号【】括起来，因为“乘”本身是个关键词，不括起来容易引起误会。

这个套路有一个参数，名字叫“那啥”。
“【阶乘】（那啥）”就是算那啥的阶乘。

要是一个套路有多个参数，那就得把它们一个一个列出来，中间用逗号隔开：

求和（甲，乙）咋整：
  滚犊子吧 甲加乙。
整完了。

调用这种套路的时候咧，相应地要把参数的值一个一个列出来：

唠唠：整求和（五，七）。

会打印出 12。

从套路返回值

在“写九九表”这个例子里，套路本身是不返回任何值的。
它要做的事都通过“唠唠”打印出来了。

而对于“阶乘”来说，我们并不想打印这个阶乘的结果。
我们只想把结果返回给整这个套路的人，爱咋用咋用。

在 dongbei 里边儿，从套路里返回一个值X，得说“滚犊子吧X。”

这个阶乘的完整定义，可以是这样的：

【阶乘】（那啥）咋整：  # 定义套路 阶乘，有一个参数 那啥
  老王是活雷锋。
  老王装一。
  老李从一到那啥磨叽：
    老王装老王乘老李。
  磨叽完了。
  滚犊子吧老王！  # 返回值。
整完了。  # 定义结束。

写完这个，再来一句

唠唠：整【阶乘】（五）。

就可以看到打印结果

120

了！

套路套套路

一个套路里面可以定义别的套路。
这个内层的套路只在外层套路的范围内看得见。
内层套路可以引用外层套路的活雷锋。

比如，这是九九表的另一种写法：

写九九表咋整：
  老王从一到九磨叽：
    王九表咋整：  # 定义一个套在“写九九表”套路里的套路。
      老张从老王到九磨叽：  # 内层套路可以引用外层套路的活雷锋。
        唠唠：老王、“*”、老张、“=”、老王乘老张。
      磨叽完了。
    整完了。  # 内层套路定义结束。
    整王九表。  # 使用内层套路。
    唠唠：“”。
  磨叽完了。
整完了。

自推

每个程序员在学习编程的时候都要翻一个坎儿，这就是 递归 。

在 dongbei 语言里面，咱不整这些虚头八脑的概念。
咱就叫“自推”。

啥意思？
就是说在做一个操作的时候调用这个操作自己。
有点循环定义的意思。

其实这就是俺们中学老师讲过的数学归纳法：欲求 f(n)，先求 f(n-1)。
然后如果从 f(n-1) 的值可以推算出 f(n) 的值，不就搞定了吗？
当然，前提是这个自推不能无穷无尽地整下去，到某一步得停下来。

举个例子。
求 n 的阶乘 f(n) 可以这么搞：
要是 n 是 0 的话，结果就是 1。
要是 n 比 0 大的话，就给就是 n * f(n-1)。

这里，在算 f(n) 的时候，我们先算 f(n-1)，再从 f(n-1) 算出 f(n)。
这就是自推大法的精髓。

把上面的思路用 dongbei 语言写出来，就是：

【阶乘】（那啥）咋整：  # 定义套路 阶乘，有一个参数 那啥。
  寻思：那啥比一还小？ # 需要自推吗？
  要行咧就 滚犊子吧 一。  # 不需要。
  要不行咧就 滚犊子吧 那啥乘整【阶乘】（那啥减一）。  # 需要。自推吧。
整完了。  # 定义结束。

阶级

伟大领袖教导我们，银一出生就打上了阶级的烙印。
一个银，不属于这个阶级，必然属于那个阶级。
超越阶级存在的银，是不可能的。

所以，在 dongbei，所有的活雷锋都可以根据他们拥有的财产（洋文叫 properties）划分成不同的阶级（class）。

银的财产是可以继承的。
老子的财产，儿子都可以有。
按照这个财产继承的关系，不同的阶级可以分出三六九等。

最高高在上的，是无产阶级。
顾名思义，无产阶级没有任何财产（properties）。

在 dongbei，我们可以用

XX 阶级的接班银 YY 阶级咋整：
  ...
整完了。

来定义一个叫 YY 的新阶级。
每个 YY 阶级的成员，都继承了 XX 阶级的全部财产。

比如：

无产阶级的接班银 YY 阶级咋整：
  ...
整完了。

要给一个阶级创造一个新的对象，先定义如何初始化这个对象：

无产阶级的接班银 有名 阶级咋整：
  新对象（名字）咋整：  # 要初始化一个有名的对象，得提供一个参数（名字）。
    俺的名字 装 名字。  # 把这个对象的名字设成提供的参数。
  整完了。
整完了。

完了吧就可以按需分配对象了：

# 创建一个有名阶级的对象，他的名字参数是“林蛋大”。
老林 装 有名的新对象（“林蛋大”）。

然后咧就可以使用这个对象的财产了：

唠唠：老林的名字。  # 打印：林蛋大

前面说过，阶级之间是有继承关系的。
要是阶级乙是从阶级甲继承来的，那么在创建阶级乙的新对象的时候，可以先创建阶级甲的对象：

有名 阶级的接班银 特有名 阶级咋整：
  新对象咋整：
    # 先按 有名 阶级的方法初始化这个对象。
    整 领导的新对象（“赵英俊”）。
    # 再加一些 特有名 阶级的操作。
    俺的 年龄 装 25。
  整完了。
整完了。
老赵 装 特有名 的新对象。
唠唠：老赵 的 名字。  # 赵英俊
唠唠：老赵 的 年龄。  # 25

一个阶级的成员除了有财产，还可以有自己的套路。
定义阶级套路的办法跟定义普通套路是一样的，只要把它的定义放在一个阶级内部就好了。
在阶级套路里面，可以直接使用一个叫 俺 的特殊活雷锋。
俺 指代当前对象。
比如：

有名 阶级的接班银 特有名 阶级咋整：
  ...
  公岁咋整：
    滚犊子吧 俺的年龄除以二！
  整完了。
  显呗咋整：
    唠唠：“我你都不认识啊？我是那啥”、俺的名字、“！”。
  整完了。
整完了。

定义完阶级套路过后，只要有一个这个阶级的对象，就可以整这个套路了：

老赵 装 特有名 的新对象。
唠唠：老赵 整 公岁。  # 12.5
老赵 整 显呗。  # 我你都不认识啊？我是那啥赵英俊！

帮衬

在家啃父母，出门靠姐妹儿。
甭管你多大能耐，没人帮衬也不成。
所以咱们写 dongbei 程序得借力，憋啥玩意儿都自己从头整。
比如翠花蛇家宝贝不少，咱就借来用用呗。

举例说明，

翠花，上 re。  # 导入 python 的正则表达式 re 模块。
老王装“abd”。
寻思：整re.match（“a.*”，老王）？  # 调用 re.match()。
要行咧就唠唠：“OK！”。
要不行咧就唠唠：“砸了！”。

跑出来结果

OK！

特殊名字

最高指示 是一个特殊的名字。
它是一个群众变量，装的是当前运行的命令行。比如有一个程序是这样的：

# a.dongbei
唠唠：最高指示。  # 打印当前命令行。

那么

src/dongbei.py a.dongbei 今天 风大

的结果就是

「'a.dongbei', '今天', '风大'」

要是想歇两秒再接着干，就

整 打个盹（二）。

以此类推，多歇几秒也是可以的：

# 睡个半小时。
整 打个盹（30 乘 60）。