返回信息流http://www.chinesepython.org/
# 中蟒是一套基于 Python 即译语言 2.1.3 版的中文编程语言. 除了保留字, 变数名称可用中文外, 很多内建数据型的操作都可用中文来进行.
# 中蟒加入了对中文字编码的内部支援, 现在可以顺利运行于大五及国标编码的中文系统中. 同时用这两种编码系统所写的程式不必进行编码转换可分享共用.
# 由于 Python 语言的发展已相当成熟, 也有许多第三方扩展模组广泛流通着, 完全中文化将会是一个很浩大的工程. 提早释出版本是为了让更多有兴趣的人加入我们的行列, 进行这项有趣的工作.
# 中蟒兼容 Python 2.1.3 的程式, 因此大量的扩展模组可以直接拿来使用.
# 中蟒和 Python 2.1.3 同样, 是开放源码的.
# 进来玩吧, 都是你的了.
这是一条镜像帖。来源：北邮人论坛 / soft-design / #23770同步于 2008/1/2
该镜像源已超过 30 天没有更新，可能在源站已被删除。
SoftDesign机器人发帖
中蟒 - 又一个中文编程语言。好玩
wks
2008/1/2镜像同步11 回复
订阅后，新回复会通过你的通知中心匿名送达。
9 条回复
2 基本操作: 基本功能和内建数据的使用方法
当计算机: 进入中蟒互动环境后, 你可以当它是一部现成的计算机来用:
>>> 12 + 3
15
>>> 15 * 2
30
>>> 21%2 #(取余数)
1
>>> 12/13 #(因为答案要取整数值, 0.923... 会变成 0)
0
>>> 12.0 / 13 #(这样就没问题了, 因为中蟒明白你现在要小数
0.92307692307692313
>>> 12 + 3 * 3 #(先乘除, 后加减)
21
>>> 2 ** 4
16
>>> 2 ** 64 #(超出了最大整数上限)
OverflowError: integer exponentiation
>>> 2L ** 64 #(用了 2L, 中蟒知道你要用大整数, 就没问题了)
18446744073709551616L
变量: 你可以在中蟒中定义一些变量, 并为给它们指定值
>>> 甲 = 12
>>> 乙 = 3
>>> 甲 + 乙
15
>>> 甲 + 乙**乙
39
>>> 甲 = 0 #(可以重新指定值)
>>> 乙 = 甲 + 1
>>> 写 乙
1
>>> 删除 甲 # 从变数表中除去 '甲', 共空出记忆体
字串: 字串是指一串的文字符. 如 "This is a test", 或 "这个也算 1 个"
中蟒内建了许多字串的操作. 其中特别针对中文做了几个常用到的函数. 包括:
\begin{verbatim}
>>> 甲 = "这是this字串"
>>> 甲.中英文字数()
8
>>> 甲.中文字数()
4
>>> 甲.英文字数()
4
>>> 甲.拆字()
[ '这', '是', 't', 'h', 'i', 's', '字', '串' ]
>>> 甲.字串编码() #传回该字串的编码
'国标'
>>> 乙 = 甲.强设编码('大五') # 不做变换, 只改变编码代号
>>> 丙 = 甲.国标变大五() # 做编码变换
>>> 甲.十六进() # 以十六进位代表字串内容
'\\xb3\\x6f\\xac\\x4f\\x74\\x68\\x69\\x73\\xa6\\x72\\xa6\\xea'
>>> 长度(甲) # 记住中文字是占两个位元的
12
>>> 甲[0:2] # 抽出'甲'中的第 0 位到第 2 个子字串
'这'
>>> 写 '这也' + 甲[2:] # 产生一个新字串
'这也是this字串'
有几件事要留心:
抽取子字串时, 甲[始, 终] 里 '始' 是从 '0 位' 开始算的, 而 '终' 则是指到第几 '个'. 像上面字串中首字 '这' 的第位元是 '甲' 字串中的第 '0' 位, 但算是第 '1' 个字元. 如果不给出 '始', '终' 则暗示从字串的头, 尾开始数.
如果 '始', '终' 是负数的话, 则表示从字串的右面开始数起. '甲[-1]' 其实就是指最尾的字元
字串在中蟒属于不可变型态. 你不能做 "甲[0] = 't'" 这样的操作. 你只能利用字串中的值来产生新的字串, 像 " 甲 = 't' + 甲[1:] " 就没问题了.
序列: 你可以把序列想像成是阵列. 分别是你可以用任何型态的值放到序列中. 同样你可以抽取子序列. 和字串不同的是序列是可变的.
>>> 甲 = [ 'a', 12.5, 3, '你好' ]
>>> 长度(甲)
4
>>> 甲[0] = 'wah'
>>> 写 甲
[ 'wah', 12.5, 3, '你好' ]
>>> 甲[2] = [ 3, 4, 5 ]
>>> 写 甲
[ 'wah', 12.5, [ 3, 4, 5], '你好' ]
>>> 删除 甲[0], 甲[1], 甲[2] # 或者也可以用 "删除 甲[0:3]"
>>> 写 甲
[ '你好' ]
>>> 甲[:0] = [ 12 ] # 插入一个序列
>>> 写 甲
[ 12, '你好' ]
字典: 字典其实也可以想像成一个阵列, 不过除了阵列中的元素可以是任何值外, 连阵列的索引也可以是任意字串或数字. 因为用起来很像字典的用法, 所以就叫字典型态了. 学术名字大概叫 "关键字索引式阵列".
>>> 甲 = { '我': 12, '你': 13, '他': 18 }
>>> 写 甲 # 注意字典中各条的先后次序是不定的 !
{ '你' : 13, '我': 12, '他': 18 }
>>> 甲['我']
12
>>> 甲['我们'] = 22 # 可以随时加入新条
>>> 甲.索引() # 取出字典中的所有条目
[ '我们', '我', '你', '他' ]
>>> 甲.值() # 取出字典中所有的值
[ 22, 12 ,13, 18 ]
另外一个学名是 '拼揍表'. 字典类是无法直接做子项抽取的, 必须先取出索引值. 意思就是如果 '甲' 是一个字典类, '甲[1]' 这样句法是错的, 要用 '甲.索引()[1]' 才行.
输入输出: 写 变量: 把变量显示到萤幕上, 另起一行
写 变量1, 变量2, 变量3: 依之写出变量组
写 变量1, 变量2, : 如果最后加上 ',', 则不另起新一行
读入(指示字串): 读取用户的键盘输入
文件 = 打开(档案名, 'r'): 打开文件档以备读取资料
文章 = 文件.读(): 将文件内容全部读入, 资料为字串型态
文章 = 文件.读一行(): 依次读取文件中的一行, 资料为字串型态
文章 = 文件.读多行(): 全部读入, 依 '回车' 键分成多行, 资料为序列型态
文件 关闭(): 关闭文件.
文件 = 打开(档案名, 'w'): 打开文件档以备写出资料
文件.写(字串): 把字串内容写到档案中去
文件.关闭(): 关闭文件. 注意文件书写完, 很多时只是写到暂存区中,
有时要关闭文件才能把资料真正存到档案中.
熟悉你的周围: 中蟒提供了一些功能让你检视整个中蟒即译器的状态. 例如定义了哪些变量, 载入了什么模组, 内建函数的用法等. 这些功能被唤做 '自省' 功能. 可用的主要有
内容(): 目前的变量表里都有什么
内容(变量): 在 '变量' 中都定义了些什么
总内容: 和 '内容' 是一样的不过同时也显示英文项. 因为中蟒尚未完全翻译完,
所有有些功能必须参考英文版.
共用变数(): 整个程式中的全局变量表
私有变数(): 目前执行域的变量表
代号(变量): 中蟒为 '变量' 指派的代号, 如两个变量代号一样则两变量是完全相同的.
(在记忆体中占相同的地址)
3 流程控制: 判别式和回圈
判别式: 在程式的运行中, 很多时需要根据不同的情况做相应的运算. 为了处理这些不同的情况, 我们需要把每个情况下应做的操作全部写好. 这些称为程式中的分枝. 中蟒提供了判别式 "如 .. 不然 .. 否则" 来让程式决定该执行哪一条分枝.
例子:
答 = 整数(输入("请告诉我你的年纪: "))
如 答 == 0:
写 "别开玩笑了, 你刚出生吗 ?"
不然 答 < 0:
写 "哇! 妖怪!"
不然 答 > 200:
写 "哇! 妖怪!"
写 "不! 是老妖怪!"
不然 答 < 40:
写 "嘿! 小伙子"
否则:
相差 = 答 - 1
写 "你好, 你的年纪比中蟒大", 相差 , '岁.'
"如" 后面要跟着一个判别项, 判别项可以是任何能化简的表达式. 如该表达式为真的话则执行冒号后面的指令.
冒号 ":" 中蟒用来区分判别式的终了, 因此不要忘了加.
注意执行多少行指令是由程式码的缩排来决定的. 也就是说:
如 2 < 1:
写 "2<1",
写 "当然了"
和
如 2 < 1:
写 "2<1",
写 "当然了"
这两个程式段的结果是不同的. 第二个例子中 '写 "当然了"' 是属于 '如' 的码区中, 所以 '如' 判别失败后该指令不会被执行.
'如' 判别失败后, 程式会继续判别之后的 '不然' 语句. 如有匹配的话则会执行其下的指令. 当所有判别都失败后程式的流程会分枝到 '否则' 之下.
'不然' 和 '否则' 判别式都是可有可无的. 但要注意是判别式中随便一项为真, 则程式执行完其下的指令后会直接跳到整个判别区之下继续运行下面的程式码. 就是说
甲 = 20
如 甲 > 1:
写 '甲大于 1'
不然 甲 > 2:
写 '甲大于 2'
不然 甲 > 3:
写 '甲大于 3'
写 '完成'
这个程式写完 '甲大于 1' 后就直接跳去写 '完成' 了.
判别式容许嵌套形式, 就是说你可以在 '如' 之下的码段中用第二个, 第三个 '如' 语句, 只要你的程式书写依照合理的缩排.
回圈式: 程式有时需要重复执行同一运算许多次. 比如计算从 1 加 到 100 的和, 就要算 100 次加法. 这个情况可利用回圈运算来完成. 中蟒有两类回圈: '取 .. 自 ..' 和 '只要 ..'
和 = 0
循环子 = 0
只要 循环子 < 100:
和 = 和 + 循环子
循环子 = 循环子 + 1
写 和
和 = 0
取 循环子 自 范围(0, 100, 1):
和 = 和 + 循环子
写 和
上面示范了两种方法. 留意上面只是算从 0 加到 99 的值而不是 1 到 100.
第一种结合了判别方式, 程式员需要在回圈中调整 "循环子" 的值. 如果程式中漏了 "循环子 + 1" 这句, 那程式会一直不停地运算下去.
第二种则给出循环范围是从 0 到 100 每次递增 1. 范围是中蟒的内建函数, 它可以产生一个数列.
两种方法都各有长处. '只要' 回圈中循环子的值可以随便更改, 因此可以任意决定何时跳出回圈. '取 ..' 回圈则可以取值自任何序列, 对遍历序列很有用, 如:
取 算子 自 [0, 25, 3, 19, '完']:
写 算子,
跳出回圈: 中蟒提供了 '下一个' 和 '中断' 两个指令. '下一个' 更新目前回圈的循环子值再重新执行, '中断' 则干脆跳离回圈.
回圈也是可以嵌套的.
orz……
【 在 wks (cloverprince) 的大作中提到: 】
: 2 基本操作: 基本功能和内建数据的使用方法
: 当计算机: 进入中蟒互动环境后, 你可以当它是一部现成的计算机来用:
: >>> 12 + 3
: ...................
4 定义函数: 结构化编程概念
中蟒有 '定义' 和 '函数' 两个关键字来定义函数. 这两个字是通用的.
很多人都爱把常用的指令组用一个代号(函数名)表示, 当程式需要该项功能时便只需调用该函数. 多用函数可以养成编写结构化程式的习惯.
例子:
定义 问电话(人名, 关系 = '朋友'):
"""这里是说明文件, 随便你打什么. 不写也行
如果写了的话会成为 "问电话.__说明___" """
问句 = "请问你中蟒的" + 关系 + 人名 + "家的电话是多少号 ? ")
答 = 输入(问句)
传回 人名 + 关系 + 答
电话1 = 问电话('青竹蛇')
电话2 = 问电话('大蟒', '爸爸')
电话本 = [ 电话1, 电话2 ]
取 名字 自 [ '腹蛇', '响尾蛇', '大懒蛇']:
电话本.附加(问电话(名字))
(记住要加冒号)
每个函数在调用时可以用不同的参数, 像上面那样. 不用参数也行, 不过函数的弹性也较低.
中蟒允许预设参数. 像上面的 '关系' 值, 如果调用时不给出该参数值则会使用预设的值.
有时候函数需要用任意数量的参数, 简单的做法是把所有参数包在一个元组或序列中传递.
嵌套函数也可以, 不过通常情况下并不需要这样做.
不过要记住, 因为中蟒是即译语言, 用太多函数会造成系统的负担, 这是因为每次调用函数都要经过一输寻找, 运行域转换等的工作. 其实就算是编译语言, 函数最好也不要用的太滥.
5 类别/对象: 用概念为主的编程法代替以功能为主的编程
这里必须要指出, '概念' 其实就是面向对象中的对象, 也就是物件导向中的物件. 中蟒有两个互通的保留字 "概念" 和 "类别", 它们是一样的.
为什么要另外用一个新名字? 我认为无论是面向对象还是物件导向的说法都会令初学者摸不着头脑. 好像我当初听了半天都不明白, 于是以为是很深奥的东西. 现在有机会重新弄一套程式语言了, 我研究了一下, 觉得 '概念' 的讲法比较浅白. 当然这个名字会太笼统了, 因此保留了 '类别' 这个保留字, 如果你丝毫不觉得 '概念' 是个好主意的话, 当它不存在好了.
这是一个不算深, 但很烦的题目. 我还没想好该怎样表达. 因此暂时只好用一些例子, 希望你能掌握到其中的要点.
#定义一个概念
概念 印刷员:
#定义这个概念的初始动作, '__初始__'是中蟒的特别函数.
#而 '自己' 则是概念本身, 中蟒规定概念中的函数 (称为方法)
#的第一个参数一定是概念本身. 至于叫什么名字可以随便改,
#一般叫做 '自己'. ('我' 也不错)
定义 __初始__(自己, 名字):
自己.名字 = 名字
#定义本概念的某个功能
定义 印刷(自己, 稿件):
写 "由" + 自己.名字 + "印"
写 "<html>" + 稿件 + "</html>;"
#定义另一个功能
定义 检查(自己, 稿件):
写 "稿件长度为:", 长度(稿件)
#开始操作
小王 = 印刷员('王小明')
小李 = 印刷员('李四')
小王.印刷('这是一份广告')
写 '完成'
小李.检查('论文一篇')
执行结果:
由王小明印
<html>;这是一份广告</html>;
完成
稿件长度为: 8
可以看到所谓的概念, 其实像是一整套完整的, 自给自足的小程式. 它包括了自己的变数 (称为属性), 自己的函数 (称为方法).
用概念的方法来为程式进行分工往往有很好的成效. 尤其是所写的功能可以很容易的重用. 这是因为在分析的过程中, 互相牵连的部份己经尽量分开了.
在上面的方法定义中, 我们并没有传回任何值. 一个更好的做法是传回概念本身:
...
#定义另一个功能
定义 检查(自己, 稿件):
写 "稿件长度为:", 长度(稿件)
传回 自己
...
我们可以这样调用: 小王.检查(稿).印刷(稿)
或者我们传回稿件:
...
#定义另一个功能
定义 检查(自己, 稿件):
写 "稿件长度为:", 长度(稿件)
传回 稿件
...
这样我们又可以用
小王.印刷(小王.检查(稿))
一个是以工作人员的动作为主, 一个是以稿件的流程为主. 这样写传回值, 实际操作时会带来很大方便
如果按上面的写法再写多几个概念出来, 写程式就可以更加接近日常的操作:
#假设己定义好概念
小王 = 印刷员('王小明')
小张 = 外勤('张三')
段总 = 编辑('段正淳')
老朱 = 会计('朱子柳')
#实际操作
作者 = '老粗'
老朱.开稿费(小张,500).拿稿件(作者).交编辑(段总).正稿().付印(小王).印刷()
哈, 好玩吗 ?
6 写作模组: 让你的编程工具箱功能倍增
模组其实就是存成 .py 档的函数定义或概念定义. 中蟒鼓励重用你已写好的代码, 模组的设计使这项工作变的很容易.
假设你写了这样两个函数并把它存成 "费氏.py"
定义 数项(上限):
""" 本函数计算不大于 '上限' 值的费氏级数项, 传回该项值. """
甲, 乙 = 0, 1
只要 乙 < 上限:
甲, 乙 = 乙, 甲 + 乙
传回 乙
定义 数列(上限):
""" 本函数计算不大于 '上限' 值的费氏级数列, 传回该级数列 """
甲, 乙 = 0, 1
答 = []
只要 乙 < 上限:
答.附加(乙)
甲, 乙 = 乙, 甲 + 乙
传回 答
你可以在别的程式中调用这两个函数了:
>>> 载入 费氏
>>> 内容(费氏)
['__档案__', '__名称__', '__说明__', '__内建__', 数项, 数列 ]
>>> 费氏.数项(100)
89
>>> 费氏.数列(100)
1 1 2 3 5 8 13 21 34 55 89
>>> 费氏.数列.__说明__
'本函数计算不大于 '上限' 值的费氏级数, 传回该级数列'
>>> 费氏.__档案__
'费氏.py'
>>> 甲 = 费氏.数项
>>> 写 "黄金比例接近于: " , (浮点数)(甲(60)) / 甲(100)
黄金比例接近于: 0.6179775280898876
"载入" 是中蟒的保留字, 用来读取模组档的内容. 模组档其实和普通中蟒程式档没分别. 中蟒会把该模组档中的函数, 变量等指派到模组名下. 用的时候把该模组当成是一个概念就行了, 它也有自己的成员函数, 属性等. 中蟒这样做, 大大简化了扩展的步骤, 再也不用为占用了相同的函数名称而头痛了.
除了 "载入" 外, 还有别的载入方法:
>>> 载入 费氏 名 无名氏
>>> 无名氏.数项(100)
89
>>> 从 费氏 载入 数项
>>> 数项.(100)
89
注意! 用 "从 模组 载入 名称" 的方法, 函数会被加到目前的名称空间中. 也就是说, 你不会看到 '费氏' 这个名字而只会算到 '数项'. 另外, "从 模组 载入 *" 的意思是说载入该模组中所有的东西. 可以想像成把模组中的程式码搬到目前的码段中再执行一遍 (事实上有些分别, 但无妨).
话说这语言的介绍好像是用蹩脚的翻译软件把python的介绍给机译过来一样……
【 在 wks (cloverprince) 的大作中提到: 】
: http://www.chinesepython.org/
: # 中蟒是一套基于 Python 即译语言 2.1.3 版的中文编程语言. 除了保留字, 变数名称可用中文外, 很多内建数据型的操作都可用中文来进行.
: # 中蟒加入了对中文字编码的内部支援, 现在可以顺利运行于大五及国标编码的中文系统中. 同时用这两种编码系统所写的程式不必进行编码转换可分享共用.
: ...................