Differences between revisions 17 and 18
 ⇤ ← Revision 17 as of 2010-06-02 03:16:27 → Size: 7219 Editor: ZoomQuiet Comment: ← Revision 18 as of 2010-08-25 14:07:58 → ⇥ Size: 7229 Editor: ZoomQuiet Comment: Deletions are marked like this. Additions are marked like this. Line 198: Line 198: {{{import traceback {{{#!pythonimport traceback

Python快速介绍 ::-- ZoomQuiet [2007-03-22 12:02:49]

 CPUG联盟:: CPUG::门户plone BPUG SPUG ZPUG SpreadPython Python宣传

Contents

# 1. s5

## 1.1. 演示备案

• dir()

• help()

### 1.1.2. 高级数据类型

• 单行程序 扫描素数!

```from math import sqrt
# 求N 以内的素数...
from math import sqrt
N = 100
[ p for p in   range(2, N) if 0 not in [ p% d for d in range(2, int(sqrt(p))+1)] ]
^ ^  ^     ^               ^    ^      ^  ^              ^            ^      ^
| |  |     |               |    |      |  |              |            |      +- 弥补
| |  |     |               |    |      |  |              |            +- 通过平方精简尝试
| |  |     |               |    |      |  |              +- 组织所有 2~p 之间可能为公因子的数列
| |  |     |               |    |      |  +- 求余,尝试整除
| |  |     |               |    |      +- 列表运算,直接将以上计算结果组成数组 返回
| |  |     |               |    +- 余数0 不在求余结果列表中
| |  |     |               +- 即2~p 都不能整除 p 的p
| |  |     +- 提取运算
| |  +- for..in 循环取数,从2~p 的连续数组中
| +- 素数!
+- 列表计算组织所有结果为数组返回!
# 优化::N > 10000 时可以使用 xrange() 进行优化生成数列```

```   1 # SOP 式的排版:
2 [ p for p in range(2, N)
3     if 0 not in [ p%d
4         for d in range(2, int(sqrt(p))+1)
5                 ]
6 ]
```
```In [1]: li = range(10)

In [2]: li
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: li[6]
Out[3]: 6

In [4]: li[:6]
Out[4]: [0, 1, 2, 3, 4, 5]

In [5]: li[6:]
Out[5]: [6, 7, 8, 9]

In [6]: li[:-6]
Out[6]: [0, 1, 2, 3]

In [7]: li[-6:]
Out[7]: [4, 5, 6, 7, 8, 9]

In [8]: li[::3]
Out[8]: [0, 3, 6, 9]

In [9]: li[:6:3]
Out[9]: [0, 3]

In [10]: li[6::3]
Out[10]: [6, 9]

In [11]: li[3:9:3]
Out[11]: [3, 6]

In [12]: li[3:9]
Out[12]: [3, 4, 5, 6, 7, 8]```

#### 1.1.2.1. 乘法表

```In [13]: for i in range(1,10,1): [ i*j for j in range(1,i) ]
....:
Out[13]: []
Out[13]: [2]
Out[13]: [3, 6]
Out[13]: [4, 8, 12]
Out[13]: [5, 10, 15, 20]
Out[13]: [6, 12, 18, 24, 30]
Out[13]: [7, 14, 21, 28, 35, 42]
Out[13]: [8, 16, 24, 32, 40, 48, 56]
Out[13]: [9, 18, 27, 36, 45, 54, 63, 72]```

```print "".join([('%s*%s=%s%s' % (y,x,x*y,'\n' if x==y else '\t')) for x
in range(1,10) for y in range(1,10) if x >= y])

1*1=1
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12  4*4=16
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81```

#### 1.1.2.2. 单行素数生成器!

• 展示思路...

```In [154]: a=7
In [156]: [d for d in range(2,a-1)]
Out[156]: [2, 3, 4, 5]
In [155]: [a%d for d in range(2,a-1)]
Out[155]: [1, 1, 3, 2]

In [162]: a=8
In [163]: 0 not in [a%d for d in range(2,a-1)]
Out[163]: False

In [167]: N=10
In [168]: [p for p in range(2,N) if  0 not in [p%d for d in range(2,p-1)]]
Out[168]: [2, 3, 5, 7]```
• 单行程序 扫描素数!

```from math import sqrt
# 求N 以内的素数...
from math import sqrt
N = 100
[ p for p in   range(2, N) if 0 not in [ p% d for d in range(2, int(sqrt(p))+1)] ]
^ ^  ^     ^               ^    ^      ^  ^              ^            ^      ^
| |  |     |               |    |      |  |              |            |      +- 弥补
| |  |     |               |    |      |  |              |            +- 通过平方精简尝试
| |  |     |               |    |      |  |              +- 组织所有 2~p 之间可能为公因子的数列
| |  |     |               |    |      |  +- 求余,尝试整除
| |  |     |               |    |      +- 列表运算,直接将以上计算结果组成数组 返回
| |  |     |               |    +- 余数0 不在求余结果列表中
| |  |     |               +- 即2~p 都不能整除 p 的p
| |  |     +- 提取运算
| |  +- for..in 循环取数,从2~p 的连续数组中
| +- 素数!
+- 列表计算组织所有结果为数组返回!
# 优化::N > 10000 时可以使用 xrange() 进行优化生成数列```

```   1 # SOP 式的排版:
2 [ p for p in range(2, N)
3     if 0 not in [ p%d
4         for d in range(2, int(sqrt(p))+1)
5                 ]
6 ]
```

### 1.1.3. 函式参数

```工厂模式...
In [174]: def doit(do,i,j):
.....:     done = "%s %s %s" % (i,do,j)
.....:     print "want do::",done
.....:     return eval(done)

In [125]: def myfun(*args):
.....:     '''try function def
.....:     '''
.....:     print len(args),args
.....:     return args[0]+args[1]

In [139]: def myfun(**kvar):
.....:     print kvar
.....:     for k in kvar:
.....:         kvar[k]+=2
.....:     print kvar
In [140]: myfun(k1=12,k2=23)
{'k2': 23, 'k1': 12}
{'k2': 25, 'k1': 14}```

### 1.1.4. OOP

• 重载运算符+

```In [15]: class nplus:
....:     def __init__(self,one):
....:         self.one = one
....:         return self.one*two

In [16]: a=nplus(10)

In [17]: a+2
Out[17]: 20```

#### 1.1.4.1. 自省！

```In [19]: def reprself(item):
....:     print "ID   :",id(item)
....:     print "TYPE :",type(item)
....:     print "VALUE:",repr(item)
....:     if hasattr(item,"__name__"):
....:         print "NAME::",item.__name__
....:     if hasattr(item,"__calss__"):
....:         print "CLASS::",item.__calss__.__name__

In [20]: reprself(reprself)
ID   : -1212717100
TYPE : <type 'function'>
VALUE: <function reprself at 0xb7b767d4>
NAME:: reprself

In [21]: reprself(123)
ID   : 136453144
TYPE : <type 'int'>
VALUE: 123

In [22]: reprself("123")
ID   : -1212647168
TYPE : <type 'str'>
VALUE: '123'

In [23]: reprself([1,2,3])
ID   : -1212664436
TYPE : <type 'list'>
VALUE: [1, 2, 3]

In [24]: reprself((1,2,3))
ID   : -1212700676
TYPE : <type 'tuple'>
VALUE: (1, 2, 3)

In [25]: reprself({1:"1","2":2,3:[3,]})
ID   : -1212705004
TYPE : <type 'dict'>
VALUE: {3: [3], 1: '1', '2': 2}```
• 追溯谁父辈:

```   1 import traceback
2 In [200]: def callme():
3    .....:     s = traceback.extract_stack()
4    .....:     print "i'd call by %s !" % s[-2][2]
5
6 In [201]: fun1()
7 i'd call by fun1 !
```
• 谁调用了俺?

```参考下面的例子：
[A.py]
import B

[C.py]
import B

[B.py]
def who_import_me():
import sys
frame = sys._getframe()
importer_name = frame.f_back.f_back.f_code.co_filename
return importer_name[:-3]

print 'Hi module %s' % who_import_me()

D:\Python Program\import>python A.py
Hi module A

D:\Python Program\import>python C.py
Hi module C```

#### 1.1.4.2. Mixin-混入！

```In [202]: class A:
.....:     def __init__(self):
.....:         self.name = "class A"
.....:     def do(self):
.....:         print self.name

In [203]: class B:
.....:     def __init__(self):
.....:         self.name = "class B"
.....:         return a+b
In [212]: A.__bases__ +=(B,)

In [213]: A.
A.__doc__     A.__init__    A.__module__  A.add         A.do```

#### 1.1.4.3. Plugin

```def p2(self,*arg):print "in %s !!!! %s"%(self.name,arg)
setattr(A,"plugin",p2)```

### 1.1.5. 对象序列化

```In [234]: lis=[1,2,"as",[1,2],(2,3,3),{}]
In [235]: pickle.dump(lis,open("lisA.dump","w"))

In [237]: li2 = pickle.load(open("lisA.dump"))
In [238]: li2
Out[238]: [1, 2, 'as', [1, 2], (2, 3, 3), {}]```

### 1.1.6. 编译字节文件

```def myfunc(alist):
return len(alist)
the following command can be used to get the disassembly of myfunc():
import dis
>>> dis.dis(myfunc)
2           0 LOAD_GLOBAL              0 (len)
3 LOAD_FAST                0 (alist)
6 CALL_FUNCTION            1
9 RETURN_VALUE
10 LOAD_CONST               0 (None)
13 RETURN_VALUE```

## 1.2. 函式编程

```map(func, list, …)

In [241]: map((lambda x:x*x),range(10))
Out[241]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
In [254]: map((lambda x,y:x+y),range(0,10,1),range(10,0,-1))
Out[254]: [10, 10, 10, 10, 10, 10, 10, 10, 10, 10]

In [257]: a=range(1,10,2)
In [258]: a
Out[258]: [1, 3, 5, 7, 9]

In [259]: b=range(10,0,-2)
In [260]: b
Out[260]: [10, 8, 6, 4, 2]

In [264]: zip(a,b)
Out[264]: [(1, 10), (3, 8), (5, 6), (7, 4), (9, 2)]

In [101]: [(lambda x,y : x+y)(i,j) for i,j in zip(a,b)]
Out[101]: [11, 11, 11, 11, 11]

In [102]: ["%s-%s "%(i,j) for i,j in zip(a,b)]
Out[102]: ['1-10 ', '3-8 ', '5-6 ', '7-4 ', '9-2 ']```

### 1.2.1. 中蟒

• 打包下载 : :chinesepy051118-cpug.7z

• 命令交互

```#--GBK--
回答 = 读入('你认为中文脚本语言有存在价值嘛 ? (有/沒;y/n)')
如 '有' == 回答 或 'y' == 回答:
写 "好也！ 让我们一起努力!"
不然 '沒' == 回答 或 'n' == 回答:
写 "好吧……我不同意你的意见，但是我坚定的捍卫你发表意见的权力."
否则:
写 "请认真思考后再回答."```
• 直观的组合出一甲子的年份

```#--GBK--
天干=("甲","乙","丙","丁","戊","己","庚","辛","壬","葵")
地支=["子","丑","寅","卯","辰","巳","午","未","申","酉","戌","亥"]
公元 = 2000
天干地支 = ""
取 干 自 天干:
取 支 自 地支:
写 干+支
天干地支 += 干+支+"  "+变字串(公元)+"\n"
公元+=1
打开('天干地支.txt', 'w').输出(天干地支)     ```
• 六十四卦推演

```八卦={
"乾":"111",
"坤":"000",
"震":"001",
"坎":"010",
"兑":"011",
"艮":"100",
"离":"101",
"巽":"110"
}
卦象 = 八卦.索引()
取 阴 自 卦象:
取 阳 自 卦象:
写 阴+阳+"   "+八卦[阴]+八卦[阳]```
• 面向对象

```#--GBK--
概念 编辑部:
定义 __初始__(自己, 名字):
自己.名字 = 名字
自己.稿件 = ""
定义 接稿(自己, 作者,文稿):
写 "由" + 自己.名字 + "接 \""+作者+"\" 稿件:"
自己.稿件 = 打开(文稿,"r").读入()
传回 自己
定义 校对(自己, 编辑):
写 "由" + 编辑.名字 + "校对:"
编辑.文稿 = 自己.稿件
写 "   稿件长度为:", 长度(编辑.文稿)
传回 自己
定义 付印(自己, 编辑):
写 "由"+ 编辑.名字 + "付印:"
编辑.文稿 = 自己.稿件
写 编辑.文稿[:36]+"...\n"
传回 自己
定义 印刷(自己, 编辑):
写 "由" + 编辑.名字 + "最终印刷:\n"
编辑.文稿 = 自己.稿件
写 编辑.文稿
#开始模拟现实情况运行编辑部工作
小王 = 编辑部('王小明')
小李 = 编辑部('李四')
小张 = 编辑部('张大民')
老朱 = 编辑部('朱为民')
作者 = '仨儿'
作品 = "PyZen.txt"

小张.接稿(作者,作品).校对(小李).付印(小王).印刷(老朱)```
• 中蟒内含操作说明书，自省列印

```#--GBK--
正文 = "<h3>中蟒 参考手册(自省生成)</h3>"
正文 +="""<style>table{width : ;}
li{background-color :#eee;font-size:92%;list-style-position : inside ;list-style-type : decimal;}
p{font-size:80%;color:#fff;background-color :#454;margin:4px 0px;}
</style>"""
正文 +="<table><tr>"
# 定义名为汇报() 的函式，自动收集模板信息，组织为页面记录下来
定义 汇报(名字,模块):
正文 = "<td valign=top width=250>"
正文 += "<ul>%s 含操作:</ul><ul>"""%(名字)
表 = 内容(模块)
写 变字串(模块)
取 条目 自 表:
正文 += "<li>%s"%(条目)
说明 = "%s.%s.__说明__"%(名字,条目)
试:
正文 += "<p>%s</p>"%(推算(说明))
失败:
忽略
正文 += "</ul></td>"
传回 正文

正文+=汇报("__內建__ ", __內建__)
正文+=汇报("\'字串\'","字串")
正文+=汇报("['数组']", ['数组'])
正文+=汇报("{'字典':'值'}", {'字典':'值'})
正文+=汇报("('元组')", ('元组'))
载入 系统
正文+=汇报("系统", 系统)
写 长度(正文)
正文+="</tr></table>"

打开("中蟒自省说明.html", 'w').输出(正文)```

# 2. 反馈

IntroPy (last edited 2010-09-09 11:54:24 by ZoomQuiet)

• Page.execute = 0.033s
• getACL = 0.022s
• init = 0.001s
• load_multi_cfg = 0.000s
• run = 0.492s
• send_page = 0.288s
• send_page_content = 0.280s
• send_page_content|1 = 0.147s
• send_page_content|2 = 0.006s
• send_page|1 = 0.188s
• send_page|2 = 0.034s
• total = 0.493s