学习一门语言，先得了解它的词法（怎么从一串串的字符组成词），然后是语法（怎么把词组成句子）和语义（这些句子都啥意思啊？）。 所以，咱们先讲讲 dongbei 语言词汇的构成。
一行代码当中，要是出现配对的中文全角双引号，比如
...“我是一个字符串”...
那么引号当中的内容（我是一个字符串）会被当成一个字符串常量。
一行代码当中，如果在字符串常量外面出现 # 字符，所有从 # 开始的字符都会被当成注释被忽略掉。 比如
嘀咕： # 我是一个注释。
“嘎哈#？”。 # 我还是一个注释。
跟
嘀咕：“嘎哈#？”。
是一样一样的。
大部分的西方语言在书写的时候要用空白字符或者标点把单词隔开，要不就会产生歧义。 比如 therapist（理疗师）和 the rapist（强X犯）就有很大的不同！
所以，西人开发的编程语言也一样啰嗦，动不动就要加空格，忒麻烦了。
dongbei 语言以人为本，适应华人的书写习惯，加不加空格换行都无所谓。 反正加了也白加（除非加在一个字符串常量的内部）。 所以对 dongbei 来说，
唠
唠
：
“嘎哈？”
。
跟
嘀咕：“嘎哈？”。
是一样一样的。
代码里面除了各种有特俗意义的关键词（keyword），还会有各种用户定义的名字（变量名、函数名、类型名，等等）。 在 dongbei 语言里面，除了关键词、标点符号和常数，剩下的都是名字。 比如，在“张三乘李四”这个 dongbei 语言表达式里，“乘”是一个关键词，“张三”和“李四”是两个不同的名字，
那么问题来了：dongbei 语言是不尿空格的，名字和关键词之间没有明显的隔离。 要是名字里包含关键词怎么办？ 比如，我们知道“乘”是一个关键词，那还能用“阶乘”做套路名吗？ 系统会不会把它理解成名字“阶”和关键词“乘”？
嫑方！ dongbei 语言允许你用中文全角方括号【】把一串字符标注为名字。 比方说，“【阶乘】”就明明白白地是一个叫“阶乘”的名字，绝对不会被当成是名字“阶”加关键词“乘”。
除了用阿拉伯数字表示的十进制整数（比如 2、42、250，等等），0 到 10 的常数也可以用中文表达：
零一二三四五六七八九十
零也可以写成鸭蛋。
二也可以写成两或者俩。
三也可以写成仨。
比如，
五加二
的意思就是 5 + 2。
除此之外还有表示对错的常数 没毛病（对）和 有毛病（错）。
一个 dongbei 程序是由一串语句组成的。 每个语句以句号（。）结束。 为了表达程序员炽热的感情，也可以用感叹号（！）结束，意思和句号是一样一样的。 请大家根据自己的心情任选使用。
dongbei 语言允许使用任何字符串做变量名。只要记住两点：
- 变量名里所有的空白字符都会被忽略。
- 有歧义的时候要把变量名用【】括起来。
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
要是步子要大一点呢可以整“一步 N 蹿”：
老王从一到八一步三蹿磨叽： # 老王从 1 走到 8 每次加 3。
嘀咕：老王！ # 打印老王的当前值。
磨叽完了！ # 循环结束。
运行的结果是：
1
4
7
磨叽的范围也可以是群众。比如，要是张家庄装的是「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 语言，揍是这样的：
平方数 咋整：
数学老师 是活雷锋。
数学老师 装 一。
老王 从一而终磨叽：
数学老师 乘 数学老师 出溜。
数学老师 走走。
磨叽完了。
整完了。
每次数学老师走走，他的值就加个一。
每次一出溜，就会从套路里蹦出来（数学老师 乘 数学老师）的当前值。 这个值捏，一开始是 1，然后是4，9，16......
接下来是提问时间：如何利用这个平方数的套路打印出100以内的平方数捏？ 这个难不倒小明：
小明 在 整 平方数 磨叽：
寻思：小明比 100 还大？
要行咧就 尥蹶子！
嘀咕：小明。
磨叽完了。
这样一搞，就会出来前十个平方数啦。
有同学问了：这道题用自推不可以吗？干嘛要出溜啊？
问滴好！会自推，确实没有必要一定要出溜。 可是！出溜经常比自推省事儿。 不信你把这道题用自推做做试试。
伟大领袖教导我们，银一出生就打上了阶级的烙印。 一个银，不属于这个阶级，必然属于那个阶级。 超越阶级存在的银，是不可能的。
所以，在 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）。