<![CDATA[阿粥的博客 - Python]]> http://www.iamwawa.cn/blog/ zh-cn PBlog2 v2.4 阿粥的博客 http://www.iamwawa.cn/blog/images/logos.gif http://www.iamwawa.cn/blog/ 阿粥的博客 http://www.iamwawa.cn/blog/article.asp?id=59 <![CDATA[[PY教程转载]Python for S60 文本内容追加 ]]> azoon@163.com(admin) Mon,08 Sep 2008 19:05:36 +0800 http://www.iamwawa.cn/blog/default.asp?id=59
首先看看源码
复制内容到剪贴板程序代码 程序代码

file=open("e:\\sett1.txt","r")
f=file.read()
file.close()
print f.decode("utf8")
txt=open("e:\\stt.txt","r")
text=txt.read()
txt.close()
print text.decode("utf8")
temp=open("e:\\temp.txt","a")
temp.write(text+","+f)
temp.close()



想在手机上测试的话，复制上面源码到笔记本，并把后缀改为.py。并在E盘创建已下3个文本，sett1.txt ，stt.txt  ， temp.txt ，第1个和第2个文本里面随便写点东西。

需要用到下面的程序
[Python手机软件]更新下载,Ped2.19手机上编辑运行python的程序
http://www.iamwawa.cn/blog/article/31.htm

下面是教程。

#开始前我们要准备两个.txt文件，编码为utf8
file=open("e:\\sett1.txt","r")
#之前说过了open中r的应用,r就是read的意思
f=file.read()
#那么file.read()就是读取file的内容，而file我们在上面看到file=open("e:\\sett1.txt","r")而我们将他付于f
file.close()
#file.close()就是停止使用file中提供的内容，这也是必要的，为什么呢？其实很简单，因为当你open一个文件的时候，如e:\\sett1.txt，他在你的编辑器中的状态是正在使用，如果我们不定义.close()，这个文件也只能在我们当前的编辑器中使用。
print f.decode("utf8")
#print打印的意思，我们可以在这里停停，运行一下，他打印的内容就是他后面跟着的f，而f就是我刚和各位说的f=file.read()，那么f.decode("utf8")是什么意思呢，decode就是编码的意思，我们定义f.decode("utf8")就是定义f的内容通过utf8编码(utf8:是一种，储存存和传送的格式，每个unicode/ucs字符都以2或4个bytes来储存)，而我们想在python/ped中想显示中文，我们就必需定义编码.decode("utf8")，当然还有很多的编码，以后会说到
txt=open("e:\\stt.txt","r")
text=txt.read()
txt.close()
print text.decode("utf8")
#这里的意思和刚说的一样，我们在这里打开了另一个文件e:\\stt.txt
temp=open("e:\\temp.txt","a")
#我们定义temp而我们利利用open打开一个文件，temp.txt,而我们会发觉,我们这时候定义的不是w,r而是a，a的意思就是追加的状态，什么叫追加，它的意思是，打开一个文件，而保持文件中的内容不变的意思而我们添加的内容将会在文件的内容的尾步添加。如果我们这时用w不是用a的话，那么我们就是创建一个文件，不管文件的内容是否已经编辑，都以新建打开
temp.write(text+","+f)
#temp.write()我们发现()中内容是我们刚刚text和f,我们用()将他包括在temp.write中，这里的意思也就是跟w，中的一样()中的内容就是我们要写进去的内容。我们用+将不同的内容分开，我们不能写成temp.write(text","f)，这样的话python会意为text","f是一个已经付于的。
temp.close()
#定义关闭文件的使用
#好了程序写好了，我们打开e:\\temp.txt，我们会发现，temp中的内容就是我们sett.txt和sett1.txt的内容，而且用","分格。]]> http://www.iamwawa.cn/blog/article.asp?id=50 <![CDATA[[PYTHON手机软件]一个python计数器(更新v0.11)]]> azoon@163.com(admin) Sun,02 Mar 2008 14:35:08 +0800 http://www.iamwawa.cn/blog/default.asp?id=50 tcalbert at OPDA
原文：




昨天发了一个功能简陋pyton编写的计算器软件(只能用来解一元二次方程 - - ).但还是得到了大家的热情支持,很是感动.所以奋斗了一个晚上一边学理论,一边进行实践操作.多少还是掌握了点东西.所以也就迫不及待地更新我的软件(simple calc 简单计算器).
以下为更新内容:
加入了一些函数计算功能,支持三角函数,幂指函数及对数函数.
增加了支持方程的种类:一元二次方程(原版本的唯一功能 - - ),一元三次方程(正在调试),二元一次方程组以及三元衣次方程组.增加了软件运行的稳定性:比如,万一输入了不合定义的数据,软件也不会被强行弹出.调整了菜单项.
ps:虽然本"软件"还称不上是软件,但我有信心做好它,不断地更新总会变得越来越完善的.我相信等出到v1.00以上版本时就能说"很好，很强大了!"
您的支持是我前进的最大动力!

还是习惯性的传下源代码吧...


复制内容到剪贴板程序代码 程序代码
# Simple Calc v0.11
# Designed by tcalbert
# 2008.03.02
# The former version was v0.03
# Many more functions have
# been added in this version.

import appuifw
import e32
import math
appuifw.app.title=u'Simple Calc v0.11'
appuifw.app.body=appuifw.Text(u'please press the "Options" ...')
def exit_key_handler():
  app_lock.signal()
app_lock=e32.Ao_lock()
appuifw.app.exit_key_handler=exit_key_handler
def about():
  appuifw.app.body=appuifw.Text(u'Simple Calc v0.11                      Designed by tcalbert, 08.03.02. To see more detailed information, please visit        http://www.opda.net.cn')
def help():
  appuifw.app.body=appuifw.Text(u'I think there is no problem for you to use such a simple software.But if you do have problems, please write to me. My e-mail address is                     694169531@qq.com                     And also, I am waiting for your good ideas and valuable suggestions.')
def eqsubitem1():
  a=appuifw.query(u'a','float')
  if a==None:
    a=0
  if a==0:
    appuifw.note(u'a=0 is not permitted!','error')
  else:
    b=appuifw.query(u'b','float')
    c=appuifw.query(u'c','float')
    if b==None:
      b=0
    if c==None:
      c=0
    delta=math.pow(b,2)-4*a*c
    if delta<0:
      appuifw.note(u'no real root','info')
    else:
      x1=(0-b+math.sqrt(delta))/(2*a)
      x2=(0-b-math.sqrt(delta))/(2*a)
      appuifw.app.body=appuifw.Text(u'x1='+str(x1)+u'    '+u'x2='+str(x2))
def eqsubitem2():
  appuifw.note(u'not available now','info')
def eqsubitem3():
  a1=appuifw.query(u'a1','float')
  b1=appuifw.query(u'b1','float')
  c1=appuifw.query(u'c1','float')
  a2=appuifw.query(u'a2','float')
  b2=appuifw.query(u'b2','float')
  c2=appuifw.query(u'c2','float')
  if a1==None:
    a1=0.0
  if b1==None:
    b1=0.0
  if c1==None:
    c1=0.0
  if a2==None:
    a2=0.0
  if b2==None:
    b2=0.0
  if c2==None:
    c2=0.0
  delta=a1*b2-b1*a2
  if delta==0:
    appuifw.note(u'error','error')
  else:
    x=(c1*b2-b1*c2)/delta
    y=(a1*c2-c1*a2)/delta
    appuifw.app.body=appuifw.Text(u'x='+str(x)+u'    '+u'y='+str(y))
def eqsubitem4():
  a1=appuifw.query(u'a1','float')
  b1=appuifw.query(u'b1','float')
  c1=appuifw.query(u'c1','float')
  d1=appuifw.query(u'd1','float')
  a2=appuifw.query(u'a2','float')
  b2=appuifw.query(u'b2','float')
  c2=appuifw.query(u'c2','float')
  d2=appuifw.query(u'd2','float')
  a3=appuifw.query(u'a3','float')
  b3=appuifw.query(u'b3','float')
  c3=appuifw.query(u'c3','float')
  d3=appuifw.query(u'd3','float')
  if a1==None:
    a1=0.0
  if b1==None:
    b1=0.0
  if c1==None:
    c1=0.0
  if d1==None:
    d1=0.0
  if a2==None:
    a2=0.0
  if b2==None:
    b2=0.0
  if c2==None:
    c2=0.0
  if d2==None:
    d2=0.0
  if a3==None:
    a3=0.0
  if b3==None:
    b3=0.0
  if c3==None:
    c3=0.0
  if d3==None:
    d3=0.0
  delta=a1*b2*c3+a2*b3*c1+a3*c2*b1-c1*b2*a3-c2*b3*a1-c3*a2*b1
  if delta==0:
    appuifw.note(u'error','error')
  else:
    x=(d1*b2*c3+d2*b3*c1+d3*c2*b1-c1*b2*d3-c2*b3*d1-c3*d2*b1)/delta
    y=(a1*d2*c3+a2*d3*c1+a3*c2*d1-c1*d2*a3-c2*d3*a1-c3*a2*d1)/delta
    z=(a1*b2*d3+a2*b3*d1+a3*d2*b1-d1*b2*a3-d2*b3*a1-d3*a2*b1)/delta
    appuifw.app.body=appuifw.Text(u'x='+str(x)+u'    '+u'y='+str(y)+u'    '+u'z='+str(z))

def funcsubitem1():
  sin_in1=appuifw.query(u'sin','float')
  if sin_in1==None:
    print
  else:
    sin_in2=(math.pi)*(sin_in1/180)
    sin_out=math.sin(sin_in2)
    appuifw.app.body=appuifw.Text(u'sin'+str(sin_in1)+u'='+str(sin_out))
def funcsubitem2():
  cos_in1=appuifw.query(u'cos','float')
  if cos_in1==None:
    print
  else:
    cos_in2=(math.pi)*(cos_in1/180)
    cos_out=math.cos(cos_in2)
    appuifw.app.body=appuifw.Text(u'cos'+str(cos_in1)+u'='+str(cos_out))
def funcsubitem3():
  tan_in1=appuifw.query(u'tan','float')
  if tan_in1==None:
    print
  else:
    tan_in2=(math.pi)*(tan_in1/180)
    tan_out=math.tan(tan_in2)
    appuifw.app.body=appuifw.Text(u'tan'+str(tan_in1)+u'='+str(tan_out))
def funcsubitem4():
  log_e=appuifw.query(u'ln','float')
  if log_e==None:
    print
  if log_e<=0:
    appuifw.note(u'error','error')
  else:
    log_e_out=math.log(log_e)
    appuifw.app.body=appuifw.Text(u'ln'+str(log_e)+u'='+str(log_e_out))
def funcsubitem5():
  log_10=appuifw.query(u'lg','float')
  if log_10==None:
    print
  if log_10<=0:
    appuifw.note(u'error','error')
  else:
    log_10_out=(math.log(log_10))/(math.log(10))
    appuifw.app.body=appuifw.Text(u'lg'+str(log_10)+u'='+str(log_10_out))
def funcsubitem6():
  log_a=appuifw.query(u'a','float')
  if log_a==None:
    print
  if log_a<=0:
    appuifw.note(u'error','error')
  else:
    log_b=appuifw.query(u'b','float')
    if log_b==None:
      print
    if log_b<=0:
      appuifw.note(u'error','error')
    else:
      log_a_b_out=(math.log(log_b))/(math.log(log_a))
    appuifw.app.body=appuifw.Text(u'log'+u'('+str(log_a)+u')'+str(log_b)+u'='+str(log_a_b_out))
def funcsubitem7():
  base_a1=appuifw.query(u'a','float')
  base_a2=base_a1*1.0
  power_b1=appuifw.query(u'b','float')
  power_b2=power_b1*1.0
  result=math.pow(base_a2,power_b2)
  appuifw.app.body=appuifw.Text(u'('+str(base_a2)+u')'+u'^'+str(power_b2)+u'='+str(result))
appuifw.app.menu=[(u'Function',((u'sin',funcsubitem1),(u'cos',funcsubitem2),(u'tan',funcsubitem3),(u'(a)^b',funcsubitem7),(u'log',funcsubitem6),(u'ln',funcsubitem4),(u'lg',funcsubitem5))),(u'Equation',((u'x^2',eqsubitem1),(u'x^3',eqsubitem2),(u'xy',eqsubitem3),(u'xyz',eqsubitem4))),(u'help',help),(u'about',about)]
app_lock.wait()

# To be updated ...
#


更多的功能,敬请期待下一版本......

原文件下载：这里]]> http://www.iamwawa.cn/blog/article.asp?id=41 <![CDATA[[PYTHON代码]Python Keygen Ver:080124]]> azoon@163.com(admin) Thu,24 Jan 2008 19:50:16 +0800 http://www.iamwawa.cn/blog/default.asp?id=41 下面这个PY程序是OPDA的一个朋友写的。大家可以学一下PY的算法。

下面是作者的话。
绰号：Cater  
Q Q：24882688
爱好：软件解密
隶属：OPDA、一品堂[Y.P.T]
关于本软件：
    写这个软件是学习Python For s60过程中的产物，以后我会陆续不定期加入新的注册机。
声明：本程序逆向修改时请注明作者，不可用于商用。

Python Keygen Ver:080124

当前版本仅包含：
Smart Movie 3.x PC Keygen
USBKiller Keygen

算法分析及py代码由Cater制作


这个程序可以在装有PY的S60手机上运行。

复制内容到剪贴板程序代码 程序代码
import appuifw

def cn(x):return x.decode("utf-8")
def exit():
    appuifw.app.set_exit()
def About_Me():
    appuifw.app.body = m = appuifw.Text()
    m.color=0x0000ff
    appuifw.app.body = m = appuifw.Text()
    m.set(cn("\t    About Me\n"))
    m.add(cn("\n绰号：Cater  QQ:24882688\n爱好：软件解密\n隶属：OPDA、一品堂[Y.P.T]\n关于本软件：\n    写这个软件是学习Python For s60过程中的产物，以后我会陆续不定期加入新的注册机。\n声明：本程序逆向修改时请注明作者，不可用于商用\n\nPython Keygen Ver:080124"))
    appuifw.app.exit_key_handler=alist


############################
#Keygen Code Module

#========================
def keygen():
    appuifw.app.body = m = appuifw.Text()
    m.set("")
    appuifw.app.exit_key_handler=alist
#========================



def USBKiller_keygen():
#USBKiller Keygen

    appuifw.app.title = cn("USBKiller 注册机 - Cater")
    appuifw.app.body = m = appuifw.Text()
    m.set("")
    m.add(cn('\n\n\n\n\n\n\n\n\n USBKiller Keygen - PyS60\n\n介绍\n    USBKiller是一款针对移动硬盘、U盘杀毒防毒的强劲软件，支持在线升级。软件官方地址：\n   WwW.EasySoft.CoM.Cn\n\n          Make By Cater\n   一品堂[Y.P.T]荣誉出品\n\t2008年01月21日'))
    if appuifw.query(cn('USBKiller 注册机\nMake By Cater\n\n 一品堂[Y.P.T]荣誉出品\n\t\t\t\t\t2008年01月21日'), "query"):
        code=appuifw.query(cn("请输入机器码："),'text')
        sn=u""
        for i in range(0,len(code)):
            key=ord(code[i]) + 2 + 2 * i
            if key <48 or key > 90 or (key > 57 and key < 65):
                continue
            sn=sn+chr(key)
        serial=sn
        appuifw.query(cn('USBKiller - 注册机\n注册码：\n') + serial + cn('\n\tMake By Cater [Y.P.T]\n\t\t\t\t\t2008年01月21日\n'), "query")
        m.add(cn("=====================\n\t注册信息\n机器码：") + code + cn("\n注册码：")+ serial + cn("\n====================="))
    else:
        appuifw.note(cn('USBKiller 注册机\n\t\t\t\t\t\t感谢您的使用\n\tCater QQ:24882688\n 一品堂[Y.P.T]荣誉出品\n\t\t\t\t\t2008年01月21日'), "conf")
    appuifw.app.exit_key_handler=alist


# USBKiller KeyGen
# Python S60 Version
# Make By Cater
# QQ:24882688
# 一品堂[Y.P.T]荣誉出品
#    2008.01.21
#========================
def SM_keygen():
#Smart Movie 3.X PC端注册机

    appuifw.app.title = cn("Smart Movie 3.x PC端注册机OPDA")
    appuifw.app.body = m = appuifw.Text()
    m.set("")
    m.add(cn("Smart Movie 3.x PC KeyGen\n\n介绍\n    大家都知道吧，不过感觉CorePlayer，DivxPlayer在视频播放上非常棒。\n\n          Make BY Cater\n    OPDA-2008 荣誉出品\n     WwW.Opda.Net.Cn\n"))
    if appuifw.query(cn('Smart Movie 3.X PC端注册机-OPDA\n\nOPDA-2008 荣誉出品\n\tWwW.Opda.Net.Cn'), "query"):
        applycode=appuifw.query(cn("请输入PC端申请码："),'number')
        a=0
        for i in range(0,len(str(applycode))):
            a = 3468 - i + ord(str(applycode)[i] ) * 1438 - a * 13
        tem=u''
        sn=a % 65536
        if 5-len(str(sn))>0:
            for f in range(0,5-len(str(sn))):
                tem=tem+ u'0'
        sn=tem+str(sn)
        appuifw.query(cn('Keygen - OPDA\n注册码：') + str(sn) + cn('\n请拷贝注册码到电脑端\nMake BY Cater [OPDA]\nQQ:24882688 08.01'), "query")
        m.add(cn("\n申请码：") + str(applycode) +cn("\n注册码：")+ str(sn)+cn("\n     请拷贝注册码到电脑端"))
    else:
        appuifw.note(cn('Smart Movie 3.x 注册机 For PyS60\n\t\t\t\t\t感谢您的使用\nOPDA-2008 荣誉出品\n\tWwW.Opda.Net.Cn'), "conf")
    appuifw.app.exit_key_handler=alist

#========================

#END Keygen Module
############################


def alist():
    def press():
        cater=3
        index =  listbox.current()
        if index == 0:
            About_Me()
        else:
            id=cater-index
            if id==2:
                USBKiller_keygen()
            if id == 1:
                SM_keygen()  

    list = [cn("About Me"),cn("[PC] USBKiller - KG"),cn("Smart Movie 3.x - KG")]
    appuifw.app.body = listbox = appuifw.Listbox(list,press)
    appuifw.app.menu = [(cn("退出"),exit)]
    appuifw.app.exit_key_handler = exit

appuifw.app.screen='full'

alist()


OPDA上的原贴 点这里]]> http://www.iamwawa.cn/blog/article.asp?id=37 <![CDATA[[Python软件汉化]mbmtool1.00,手机上的MBMTOOL工具]]> azoon@163.com(admin) Fri,21 Dec 2007 13:48:59 +0800 http://www.iamwawa.cn/blog/default.asp?id=37
引用内容 引用内容
软件：mbmtool1.00
平台：python for s60
支持手机：s60第三版，例如N73，E50，N95等

引用内容 引用内容
软件说明：大家应该都清楚电脑上的MBMTOOL工具，可以很方便的转换MBM格式。现在只要你有一台S60手机就可以帮你在手机上方便的转换MBM了。

使用说明：
          将MBM文件放在e:/python/mbmtool/mbm/
          将PNG文件放在e:/python/mbmtool/png/
汉化说明：这个软件是我在手机上汉化的，用smartsis打包。

汉化作者：azoon--www.iamwawa.cn
软件截图：



引用内容 引用内容
下载：
已签名版：点击下载
未签名版：点击下载
]]> http://www.iamwawa.cn/blog/article.asp?id=34 <![CDATA[[python手机软件][附下载]手机上的解包打包工具SmartSIS 1.81汉化版更新]]> azoon@163.com(admin) Sun,16 Dec 2007 23:50:58 +0800 http://www.iamwawa.cn/blog/default.asp?id=34
截图预览：



引用内容 引用内容
主要功能:
主程序和插件要签名安装
安装次序,首先删除C盘的所有PY相关程序,然后安装插件,跟着装平台,最后装主程序...
本次更新终于可以打包了,不过比较遗憾的是还不支持中文名称,而且打包较大文件时会很慢....
打包方法很简单,到C盘smartSIS文件夹,找到sis.pkg,用文本编辑打开,选择ANSII编码...按照原来格式,不要改动..

引用内容 引用内容
第一行,打包文件路径
第二行,安装时显示的程序名称
第三行,软件的版本
第四行,软件UID
第五行,作者
第六行,安装时的提示信息,一样只能使用ANSII编辑,即是不支持中文名
你可以按上面提示改动相应内容
先把程序解包,获取相应的打包信息,然后把解包的文件移进比如:C:\myprogram目录,然后编写好PKG,就可以打包了,会有相关信息出现...
1.081更新支持签名功能:
签证自用,要到设置里设置...支持去除签名,支持密码功能....
完美支持中文名打包！


引用内容 引用内容
英文名称：SmartSIS
中文名称：智能解包
授权方式：请签名
软件版本：1.81
软件类型：工具
测试机型：3250
测试人员：龙飞飞龙
汉化人员：龙飞飞龙
软件支持机型：只支持S60三版机型


引用内容 引用内容
要先安装python for s60。按安装插件，然后再安装smartsis！如果你以前装过PY的程序请删除，否则将出现更新失败的提示！安装完smartsis后可以安装你原理的PY程序！
1.PythonForS60_1_4_1_3rdEd
2.插件下载
3.smartsis1.81下载
]]> http://www.iamwawa.cn/blog/article.asp?id=32 <![CDATA[[python程序]附下载,函数绘图,可在手机上输入函数,并画出函数图像]]> azoon@163.com(admin) Thu,13 Dec 2007 00:07:13 +0800 http://www.iamwawa.cn/blog/default.asp?id=32 虽然作者是为S60V2的，不过S60V3的朋友可以用ped打开程序再运行，效果是一样的。
引用内容 引用内容
说明：
画多函数，最多五条
快速移动，查看函数
放大缩小（重绘图像比较慢）
最有用的功能！移动一个点可以查看坐标！
完美支持三角正弦函数，余弦函数，不完美支持正切函数…
输入格式：x^2+sin(x)+cos(x)+tan(x)-1/x+x*5


复制内容到剪贴板程序代码 程序代码
部分代码预览：
import appuifw
import graphics
import e32
import math
from key_codes import *
#==========定义函数
#==========定义按键事件
class Keyboard(object):
    def __init__(self,onevent=lambda:None):
        self._keyboard_state={}
        self._downs={}
        self._onevent=onevent
    def handle_event(self,event):
        if event['type'] == appuifw.EEventKeyDown:
            code=event['scancode']
            if not self.is_down(code):
                self._downs[code]=self._downs.get(code,0)+1
            self._keyboard_state[code]=1
        elif event['type'] == appuifw.EEventKeyUp:
            self._keyboard_state[event['scancode']]=0
        self._onevent()
    def is_down(self,scancode):
        return self._keyboard_state.get(scancode,0)
    def pressed(self,scancode):
        if self._downs.get(scancode,0):
            self._downs[scancode]-=1
            return True
        return False
keyboard=Keyboard()


复制内容到剪贴板程序代码 程序代码
原贴地址：这里
完整代码下载：draw 1.5.py
]]> http://www.iamwawa.cn/blog/article.asp?id=31 <![CDATA[[Python手机软件]更新下载,Ped2.19手机上编辑运行python的程序]]> azoon@163.com(admin) Wed,12 Dec 2007 23:27:02 +0800 http://www.iamwawa.cn/blog/default.asp?id=31
引用内容 引用内容
英文名称：Ped          中文名称：脚本编辑
授权方式：直装      软件版本：2.19   软件类型：工具
测试机型：3250        测试人员：龙飞飞龙
汉化人员：龙飞飞龙  
软件支持机型：只支持S60三版机型


软件截图：



引用内容 引用内容
主要特点：
超强的手机编程序工具和文本编辑工具
支持浏览打开任何文件夹文件
完美支持中文文件名
支持编辑纯文本文件和python脚本，
可以对python脚本资源包文件进行修改（汉化）
具体请看汉化python教程


引用内容 引用内容
常规设置：
可字体/文本：类型．颜色．页面大小．缩放．编码．自动保存．


引用内容 引用内容
更新:
- 视图更改:待机屏幕是一个特别窗口(根目录窗口),可以轻易添加热键,也允许在组件中清除
- 新建热键: 绿键+*,打开脚本解释器
- 新建热键: 绿键+0,打开文件对话框和运行标记脚本
- 新建热键: 绿键+#,打开文件对话框和读取文件编辑器
- 新建热键: 绿键+9,保存当前文件
- 新建热键: 绿键+1,运行当前脚本
- 更改热键: 绿键+8,浏览代码(之前为绿键+0)


引用内容 引用内容
下载：先安装PythonForS60_1_4_1_3rdEd.SIS，再安装ped
  pythonfors60下载
  ped下载
]]> http://www.iamwawa.cn/blog/article.asp?id=13 <![CDATA[看了两天的python，于是在手机上用ped写了几个简单的脚本]]> azoon@163.com(admin) Wed,14 Nov 2007 10:49:47 +0800 http://www.iamwawa.cn/blog/default.asp?id=13
1.1加到50

HTML代码


[Ctrl+A 全部选择 提示：你可先修改部分代码，再按运行]


2.简单计算

HTML代码


[Ctrl+A 全部选择 提示：你可先修改部分代码，再按运行]


3.显示中文

HTML代码


[Ctrl+A 全部选择 提示：你可先修改部分代码，再按运行]


4.弹出提示信息

HTML代码


[Ctrl+A 全部选择 提示：你可先修改部分代码，再按运行]

注意：这个只能在s60系统手机上才能运行。

5.for循环测试

HTML代码


[Ctrl+A 全部选择 提示：你可先修改部分代码，再按运行]


HTML代码


[Ctrl+A 全部选择 提示：你可先修改部分代码，再按运行]


复制内容到剪贴板程序代码 程序代码
上面所有的原程序下载：点这里


复制内容到剪贴板程序代码 程序代码
如果你想在电脑上运行，请到http://python.org/download/    ，下载你所需要的版本。windos的下载Python 2.5.1 Windows installer 。

如果你想在你的s60v3手机上编辑,运行，请按序安装下列文件：

PythonForS60_1_4_1_3rdEd
PythonScriptShell_1_4_1_3rdEd
Ped2.17

http://webdisk.cech.com.cn/download/7899181/949975d23765ac0c8b12/Python.rar
]]> http://www.iamwawa.cn/blog/article.asp?id=12 <![CDATA[课上偷偷看python教程]]> azoon@163.com(admin) Mon,12 Nov 2007 22:47:07 +0800 http://www.iamwawa.cn/blog/default.asp?id=12      上物理导论课，实在是一生的一大折磨，老师用纯正的四川口音给我们上课，我们似乎听他在念咒语。我为了不浪费时间，我多数自己在看书。而今天我足足看了两节课的python教程，我深深的被这种语言迷住了。这种编程语言简单，就像读普通英语那样，但是功能却很强大。看过资料，google的内核也用到了python。这种语言有很大的优势。相比Perl，python更惹人喜欢。

写一个由1加到50的程序。

在VB下要这样写：

复制内容到剪贴板程序代码 程序代码
Dim a As Integer, sum As Integer
sum = 0
For a = 0 To 50
sum = a + sum
Next a
Print ; sum


在python下只有这样就行了：

复制内容到剪贴板程序代码 程序代码
sum_=0
for i in range(1,51):sum_=sum_+i
print sum_


(注：是sum_)

我只看了两节课，已经对python有了很好的理解，可想而知，这种语言是很容易学会的，很适合新手。

下面这个网址是简明 Python 教程（Swaroop, C. H. 著）

复制内容到剪贴板程序代码 程序代码
http://www.woodpecker.org.cn:9081/doc/abyteofpython_cn/chinese/index.html


大家可以上去学习一下。]]> http://www.iamwawa.cn/blog/article.asp?id=27 <![CDATA[[python教程]Python开发编码规范]]> azoon@163.com(admin) Thu,08 Nov 2007 10:53:10 +0800 http://www.iamwawa.cn/blog/default.asp?id=27    这篇文档改编自Guido最初的《Python风格指南》一文，并从《Barry's style guide》中添加了部分内容。在有冲突的地方，Guide的风格规则应该是符合本PEP的意图(译注：指当有冲突时，应以Guido风格为准)。这篇PEP仍然尚未完成(实际上，它可能永远都不会完成)。
   在这篇风格指导中的一致性是重要的。在一个项目内的一致性更重要。在一个模块或函数内的一致性最重要。但最重要的是：知道何时会不一致——有时只是没有实施风格指导。当出现疑惑时，运用你的最佳判断，看看别的例子，然后决定怎样看起来更好。并且要不耻下问！
   打破一条既定规则的两个好理由：
(1)     当应用这个规则是将导致代码可读性下降，即便对某人来说，他已经习惯于按这条规则来阅读代码了。
(2)     为了和周围的代码保持一致而打破规则(也许是历史原因)，虽然这也是个清除其它混乱的好机会(真正的XP风格)。

          代码的布局
缩进
   使用Emacs的Python-mode的默认值：4个空格一个缩进层次。对于确实古老的代码，你不希望产生混乱，可以继续使用8空格的制表符(8-space tabs)。Emacs Python-mode自动发现文件中主要的缩进层次，依此设定缩进参数。
制表符还是空格
  永远不要混用制表符和空格。最流行的Python缩进方式是仅使用空格，其次是仅使用制表符，混合着制表符和空格缩进的代码将被转换成仅使用空格。(在Emacs中，选中整个缓冲区，按ESC-x去除制表符。)调用Python命令行解释器时使用-t选项，可对代码中不合法得混合制表符和空格发出警告，使用-tt时警告将变成错误。这些选项是被高度推荐的。
  对于新的项目，强烈推荐仅使用空格而不是制表符。许多编辑器拥有使之易于实现的功能(在Emacs中，确认indent-tabs-mode是nil)。
行的最大长度
  周围仍然有许多设备被限制在每行80字符：而且，窗口限制在80个字符。使将多个窗口并排放置成为可能。在这些设备上使用默认的折叠方式看起来有点丑陋。因此，请将所有行限制在最大79字符(Emacs准确得将行限制为长80字符)，对顺序排放的大块文本(文档字符串或注释)，推荐将长度限制在72字符。
  折叠长行的首选方法是使用Pyhon支持的圆括号，方括号和花括号内的行延续。如果需要，你可以在表达式周围增加一对额外的圆括号，但是有时使用反斜杠看起来更好，确认恰当得缩进了延续的行。
  Emacs的Python-mode正确得完成了这些。一些例子：
#!Python
  class Rectangle(Blob)：
    def __init__(self，width，height，color='black'，emphasis=None，highlight=0)：
        if width == 0 and height == 0 and \
          color == 'red' and emphasis == 'strong' or \
          highlight > 100：
          raise ValueError， "sorry， you lose"
        if width == 0 and height == 0 and (color == 'red' or
                              emphasis is None)：
          raise ValueError，"I don't think so"
        Blob.__init__(self，width，height，color，emphasis，highlight)

  空行
  用两行空行分割顶层函数和类的定义，类内方法的定义用单个空行分割，额外的空行可被用于(保守的)分割相关函数组成的群，在一组相关的单句中间可以省略空行。(例如：一组哑元素)。
  当空行用于分割方法的定义时，在‘class'行和第一个方法定义之间也要有一个空行。在函数中使用空行时，请谨慎的用于表示一个逻辑段落。Python接受contol-L(即^L)换页符作为空格：Emacs(和一些打印工具)，视这个字符为页面分割符，因此在你的文件中，可以用他们来为相关片段分页。
编码
  Python核心发布中的代码必须始终使用ASCII或Latin-1编码(又名 ISO-8859-1)，使用ASCII的文件不必有编码cookie，Latin-1仅当注释或文档字符串涉及作者名字需要Latin-1时才被使用：
  另外使用\x转义字符是在字符串中包含非ASCII(non-ASCII)数据的首选方法。
  作为PEP 263实现代码的测试套件的部分文件是个例外。
导入
  通常应该在单独的行中导入(Imports)，例如：
No：import sys， os
Yes：import sys
    import os
  但是这样也是可以的：
  from types import StringType， ListType
  Imports 通常被放置在文件的顶部，仅在模块注释和文档字符串之后，在模块的全局变量和常量之前。Imports应该有顺序地成组安放：
1、标准库的导入(Imports )
  2、相关的主包(major package)的导入(即，所有的email包在随后导入)
  3、特定应用的导入(imports)
  你应该在每组导入之间放置一个空行，对于内部包的导入是不推荐使用相对导入的，对所有导入都要使用包的绝对路径。
  从一个包含类的模块中导入类时，通常可以写成这样：
    from MyClass import MyClass
    from foo.bar.YourClass import YourClass
  如果这样写导致了本地名字冲突，那么就这样写
    import MyClass
    import foo.bar.YourClass
  即使用"MyClass.MyClass"和"foo.bar.YourClass.YourClass"
表达式和语句中的空格
  Guido不喜欢在以下地方出现空格：
  紧挨着圆括号，方括号和花括号的，如："spam( ham[ 1 ]，{ eggs：2 } )"。要始终将它写成"spam(ham[1]，{eggs： 2})"。
  紧贴在逗号，分号或冒号前的，如：
    "if x == 4：print x，y：x，y = y，x"。要始终将它写成
    "if x == 4：print x，y：x，y = y，x"。
紧贴着函数调用的参数列表前开式括号(open parenthesis )的，如"spam (1)"。要始终将它写成"spam(1)"。
紧贴在索引或切片，开始的开式括号前的，如：
  "dict ['key'] = list [index]"。要始终将它写成"dict['key'] = list[index]"。
  在赋值(或其它)运算符周围的用于和其它并排的一个以上的空格，如：
#!Python
      x= 1
      y= 2
      long_variable = 3
要始终将它写成
#!Python
      x = 1
      y = 2
      long_variable = 3
  (不要对以上任意一条和他争论——Guido 养成这样的风格超过20年了。)
其它建议
  始终在这些二元运算符两边放置一个空格：赋值(=)， 比较(==，<，>，!=，<>，<=，     >=，in，not in，is，is not)，布尔运算 (and，or，not)。
  按你的看法在算术运算符周围插入空格。 始终保持二元运算符两边空格的一致。
  一些例子：
#!Python
      i = i+1
      submitted = submitted + 1
      x = x*2 - 1
      hypot2 = x*x + y*y
      c = (a+b) * (a-b)
      c = (a + b) * (a - b)
  不要在用于指定关键字参数或默认参数值的'='号周围使用空格，例如：
#!Python
      def complex(real， imag=0。0)：
        return magic(r=real， i=imag)
  不要将多条语句写在同一行上：
      No： if foo == 'blah'：do_blah_thing()
      Yes：if foo == 'blah'：
            do_blah_thing()
      No：do_one()：do_two()：do_three()
      Yes： do_one()
          do_two()
          do_three()
  
    注释
同代码不一致的注释比没注释更差。当代码修改时，始终优先更新注释!注释应该是完整的句子，如果注释是一个短语或句子，首字母应该大写，除非他是一个以小写字母开头的标识符(永远不要修改标识符的大小写)。
  如果注释很短，最好省略末尾的句号。注释块通常由一个或多个由完整句子构成的段落组成，每个句子应该以句号结尾。你应该在句末，句号后使用两个空格，以便使Emacs的断行和填充工作协调一致。
  用英语书写时，断词和空格是可用的。非英语国家的Python程序员：请用英语书写你的注释，除非你120%的确信这些代码不会被不懂你的语言的人阅读。
注释块
  注释块通常应用于跟随着一些(或者全部)代码并和这些代码有着相同的缩进层次。注释块中每行以‘#'和一个空格开始(除非他是注释内的缩进文本)。注释块内的段落以仅含单个‘#'的行分割。注释块上下方最好有一空行包围(或上方两行下方一行，对一个新函数定义段的注释)。
行内注释
  一个行内注释是和语句在同一行的注释，行内注释应该谨慎适用，行内注释应该至少用两个空格和语句分开，它们应该以'#'和单个空格开始。
    x = x+1           # Increment x
  如果语意是很明了的，那么行内注释是不必要的，事实上是应该被移除的。不要这样写：
    x = x+1           # Increment x
    x = x+1           # Compensate for border
  但是有时，这样是有益的：
    x = x+1           # Compensate for border

   文档字符串
  应该一直遵守编写好的文档字符串的约定PEP 257 [3]。为所有公共模块，函数，类和方法编写文档字符串。文档字符串对非公开的方法不是必要的，但你应该有一个描述这个方法做什么的注释。这个注释应该在"def"这行后。
PEP 257 描述了好的文档字符串的约定。一定注意，多行文档字符串结尾的"""应该单独成行，例如：
    """Return a foobang
    Optional plotz says to frobnicate the bizbaz first。
    """
对单行的文档字符串，结尾的"""在同一行也可以。

   版本注记
   如果你要将RCS或CVS的杂项(crud)包含在你的源文件中，按如下做。
#!Python
    __version__ = "$Revision： 1。4 $"
    # $Source： E：/cvsroot/Python_doc/pep8。txt，v $
这个行应该包含在模块的文档字符串之后，所有代码之前，上下用一个空行分割。
命名约定
  Python库的命名约定有点混乱，所以我们将永远不能使之变得完全一致，不过还是有公认的命名规范的。新的模块和包(包括第三方的框架)必须符合这些标准，但对已有的库存在不同风格的，保持内部的一致性是首选的。
描述：命名风格
  有许多不同的命名风格。以下的有助于辨认正在使用的命名风格，独立于它们的作用。   以下的命名风格是众所周知的：
  b (单个小写字母)
  B (单个大写字母)
  Lowercase（小写）
  lower_case_with_underscores（有下划线的小写）
  UPPERCASE（大写）
  UPPER_CASE_WITH_UNDERSCORES（有下划线的大写）
  CapitalizedWords (或 CapWords，CamelCase这样命名是因为可从字母的大小写分出单词。这有时也被当作StudlyCaps。
  mixedCase (与CapitalizedWords的不同在于首字母小写!)
  Capitalized_Words_With_Underscores（有下划线的首字母大写） (丑陋!)
  还有用短的特别前缀将相关的名字聚合在一起的风格。这在Python中不常用，但是出于完整性要提一下，例如，os.stat()函数返回一个元组，他的元素传统上说名如st_mode， st_size，st_mtime等等。
  X11库的所有公开函数以X开头。(在Python中，这个风格通常认为是不必要的，因为属性和方法名以对象作前缀，而函数名以模块名作前缀。)
另外，以下用下划线作前导或结尾的特殊形式是被公认的(这些通常可以和任何习惯组合)：
_single_leading_underscore(单个下划线作前导)：弱的“内部使用(internal use)”标志。 (例如，“from M import *”不会导入以下划线开头的对象)。
single_trailing_underscore_(单个下划线结尾)： 用于避免与Python关键词的冲突，例如：“Tkinter.Toplevel(master，class_='ClassName')”。
  _double_leading_underscore(双下划线)：从Python 1.4起为类私有名。
  _double_leading_and_trailing_underscore_：“magic”对象或属性，存在于用户控制的(user-controlled)名字空间，例如：_init_， _import_ 或_file_。有时它们被用户定义用于触发某个魔法行为(例如：运算符重载)：有时被构造器插入，以便自己使用或为了调试。因此，在未来的版本中，构造器(松散得定义为Python解释器和标准库)可能打算建立自己的魔法属性列表，用户代码通常应该限制将这种约定作为己用。欲成为构造器的一部分的用户代码可以在下滑线中结合使用短前缀，例如：
_bobo_magic_attr__。
说明：命名约定
应避免的名字。永远不要用字符‘l'(小写字母el(就是读音，下同))，‘O'(大写字母oh)，或‘I'(大写字母eye)作为单字符的变量名。在某些字体中这些字符不能与数字1和0分辨。试着在使用‘l'时用‘L'代替。

   模块名
  模块应该是不含下划线的，简短的，小写的名字。因为模块名被映射到文件名，有些文件系统大小写不敏感并且截短长名字，模块名被选为相当短是重要的，这在Unix上不是问题，但当代码传到Mac或Windows上就可能是个问题了。
当用C或C++编写的扩展模块有一个伴随Python模块提供高层(例如进一步的面向对象)接口时，C/C++模块有下划线前导(如：_socket)。Python包应该是不含下划线的，简短的，全小写的名字。
类名
几乎不出意料，类名使用CapWords约定。内部使用的类外加一个前导下划线。
异常名
如果模块对所有情况定义了单个异常，它通常被叫做“error”或“Error”。似乎内建(扩展)的模块使用“error”(例如：os.error)，而Python模块通常用“Error” (例如：xdrlib.Error)。趋势似乎是倾向使用CapWords异常名。

  全局变量名
(让我们祈祷这些变量仅在一个模块的内部有意义)
  这些约定和在函数中的一样。模块是被设计为通过“from M import *”来使用的，必须用一个下划线作全局变量(及内部函数和类)的前缀防止其被导出(exporting)。

   函数名
函数名应该为小写，可能用下划线风格单词以增加可读性。mixedCase仅被允许用于这种风格已经占优势的上下文(如：threading.py)，以便保持向后兼容。
方法名和实例变量
这段大体上和函数相同：通常使用小写单词，必要时用下划线分隔增加可读性。仅为不打算作为类的公共界面的内部方法和实例使用一个前导下划线，Python不强制要求这样：它取决于程序员是否遵守这个约定。
使用两个前导下划线以表示类私有的名字，Python将这些名字和类名连接在一起：
如果类Foo有一个属性名为_a，它不能以Foo._a访问。(固执的用户还是可以通过Foo._Foo__a得到访问权。)
通常双前导下划线仅被用于避免含子类的类中的属性名的名字冲突。
继承的设计
始终要确定一个类中的方法和实例变量是否要被公开。通常，永远不要将数据变量公开，除非你实现的本质上只是记录，人们几乎总是更喜欢代之给出一个函数作为类的界面(Python 2.2 的一些开发者在这点上做得非常漂亮)。
同样，确定你的属性是否应为私有的。私有和非私有的区别在于模板将永远不会对原有的类(导出类)有效，而后者可以。你应该在大脑中就用继承设计好了你的类，私有属性必须有两个前导下划线，无后置下划线，非公有属性必须有一个前导下划线，无后置下划线，公共属性没有前导和后置下划线，除非它们与保留字冲突，在此情况下，单个后置下划线比前置或混乱的拼写要好，例如：class_优于klass。
最后一点有些争议：如果相比class_你更喜欢klass，那么这只是一致性问题。

   设计建议
单个元素(singletons)的比较，如None 应该永远用：‘is'或‘is not'来做。当你本意是“if x is not None”时，对写成“if x”要小心。例如当你测试一个默认为None的变量或参数是否被设置为其它值时，这个值也许在布尔上下文(Boolean context)中是false！
基于类的异常总是好过基于字符串的异常。模块和包应该定义它们自己的域内特定的基异常类，基类应该是内建的Exception类的子类。还始终包含一个类的文档字符串。例如：
#!Python
    class MessageError(Exception)：
        """Base class for errors in the email package。"""
使用字符串方法(methods)代替字符串模块，除非必须向后兼容Python 2.0以前的版本。字符串方法总是非常快，而且和unicode字符串共用同样的API(应用程序接口)在检查前缀或后缀时避免对字符串进行切片。用startswith()和endswith()代替，因为它们是明确的并且错误更少。例如：
    No： if foo[：3] == 'bar'：
    Yes： if foo。startswith('bar')：
例外是如果你的代码必须工作在Python 1.5.2 (但是我们希望它不会发生！)，对象类型的比较应该始终用isinstance()代替直接比较类型，例如：
    No： if type(obj) is type(1)：
    Yes： if isinstance(obj， int)：
检查一个对象是否是字符串时，紧记它也可能是unicode字符串！在Python 2.3，str和unicode有公共的基类，basestring，所以你可以这样做：
    if isinstance(obj， basestring)：
在Python 2.2类型模块为此定义了StringTypes类型，例如：
#!Python
    from types import StringTypes
    if isinstance(obj， StringTypes)：
在Python 2.0和2.1，你应该这样做：
#!Python
    from types import StringType， UnicodeType
    if isinstance(obj， StringType) or \
      isinstance(obj， UnicodeType) ：
对序列，(字符串，列表，元组)，使用空列表是false这个事实，因此“if not seq”或“if seq”比“if len(seq)”或“if not len(seq)”好。书写字符串文字时不要依赖于有意义的后置空格。这种后置空格在视觉上是不可辨别的，并且有些编辑器(特别是近来，reindent.py)会将它们修整掉。不要用==来比较布尔型的值以确定是True或False(布尔型是Pythn 2.3中新增的)
    No： if greeting == True：
    Yes： if greeting：
    No： if greeting == True：
    Yes： if greeting：]]>