下图是“冒泡排序”的一个示例，其中：

1. 折线表示了各个元素的位置变化。
2. 折线的深浅表示了元素的大小。越深则越大。

同样，还有其它一些排序算法的图片：

堆排序（Heap Sort）

选择排序（Selection）

快速排序（Quick）

Shell排序

插入排序（Insertion）

你可以使用如下的Python代码来制作这些图片：（需要 Cairo图片库支持）

Python 排序脚本

这个脚本参数如下：

• -a 表示使用什么样的算法，取值为"quick", "heap", "selection", "insertion", "bubble", "shell"。
• -n 表示要排序的数据个数。
• -f 表示输入文件。
• -p 表示文件前缀。
• -d 表示输出顺序。
• -x 图片宽度。
• -y 图片高度。
• -l 所有线的宽度。
• -b 边界宽度。

使用示例如下：

./visualise.py -l 6 -x 700 -y 300 -n 15

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 递归－三角数字
• 用PHP数组对百万数据进行排重
• 浅谈递归过程以及递归的优化
• 检查素数的正则表达式
• 排序－选择
• 排序－插入
• 排序－冒泡
• 排序算法汇总
• 国外PHP开发者放弃PHP而改用Python
• 全文检索中近义词、关联词的解决方案

Feed enhanced by Better Feed from Ozh

Python 的中文意思是巨蟒，大蟒蛇。

• 快速 Python 语言入门教学，课程，课件，教材，自学，概念
  • 计算机编程主要概念
    • 基本编程
    • 定义函数
    • 循环 (loop)

  • Python 数据概念
    • 列表 (list)
    • 元组 (tuple)
    • 字典 (dict)
    • 集合 (set)
    • 模块 (module)
    • 类 (class)
    • 字符串的对象性质
  • Python 程序员编程习惯
  • 参考资料

计算机编程主要概念¶

计算机语言编程的主要内容就这些：数字，文字，循环，公式，变量

• 数字: 1, 2, 3, 5.6, 120, 32.4, 3.1415926, -3, -0.123

• 文字: 你好，我好，你太牛了，很黄很暴力，这类的文字。一般用双引号(“)或者单引号(‘)括起来。术语叫字符串 ，就是一堆字符，串起来。

• 循环: 循环(loop)就是重复的做一件事。计算机是一个很笨的机器，基本上只会做加，减，乘，除，大于，小于，等于和循环这种简单的工作。编程就是把复杂的问题，拆成简单的单元让它重复。

幸亏有下面讲到的公式，所以很多较复杂的问题已经有了解决方法，我们只是重复的套用别人的解决公式就可以了，不用拆得太细。

Python 语言最大的优势，就是这个语言中包含了大量解决常见问题的公式，你想干的事，基本上都有人帮你干了，你只是需要把他们组织，捆绑起来就可以了。比如下载文件的公式，分析网页内容的公式，压缩文件的公式，处理电子邮件的公式等等。

• 公式: 就像数学公式 (a+b)²= a² + 2ab + b² 这种。算的时候带入具体数值，比如：(3+4)² = 3² + 2*3*4 + 4² = 9+24+16 = 49 。前面的 (a+b)² 就是我们的公式名（当然编程时，我们会用一些比较容易明白的词组做为公式名，比如“和的平方”这种，英语或者拼音都可以），他需要两个参数a，b；后面的 a² + 2ab + b² 是具体怎么算出来的步骤，这就是我们的公式内容。

在计算机里，公式的术语叫“函数”或者“方法”。我们定义一个函数，就是定义一条公式，用的时候，拿来参数a,b什么的，套一下公式就行了。

为了程序的结构清晰，我们往往会定义很多函数。把复杂的问题分成很多小问题，每个小问题放到一个函数里，然后在解决复杂问题的函数里，使用这些小问题函数解决大问题。更重要的是我们可以大量的使用别人写好的函数来解决自己的问题。

函数的作用是让程序结构清晰，而且可以在不同的地方重复套用。

• 变量: 就是上面的a，b这种可以代表任何值，可以放进不定值的单词，变量，变量，它代表的量可能会改变。我们用变量来存储我们程序中用到的各种数字，文字，公式。所谓参数，就是定义公式时候用到的变量，就叫参数，换个马甲而已。

换成术语，我们有：

到这里，基本上编程就没什么可学得了。剩下的就是掌握各种编程语言特定的函数和循环的书写格式，再掌握了别人已经写好的函数的用法，组合起来就得了。

基本编程¶

最基本的python程序：

print ("世界，你好！")

存到文件 hello.py 里，然后命令行下输入 python hello.py 就可以看到结果了。

这里就用到了函数和字符串，在屏幕上输出一行：世界，你好！

Python 里函数的用法是：函数名(参数1, 参数2)

这里 print 是函数；在屏幕上打印内容，”世界，你好！”是参数，套 print 这个公式用的。

学会怎么用函数了，再学会定义函数的格式，就差不多了。

Python 里注释符号是”#”。就是说，在 # 符号后的那一行文字，都当做解释，不做为程序的命令。

print ("打酱油！") # print ("关我屁事")

只打印出 “打酱油”，剩下的，因为是在 # 后面，所以程序把他们当做注释语言自动忽略了。

定义函数¶

def a_b_pingfang(a, b):
    c = a**2 + 2*a*b + b**2
    return c

我们定义一个(a+b)²的函数，def 是英语 define 的缩写，意思是定义函数，定义公式。

第 1 行就是说我们要定义一个函数名叫 a_b_pingfang 的函数，用它的时候，需要两个参 数 a 和 b。尾巴上有个冒号，冒号的意思是说：“下面的一段话就是公式定义了，要注意了”。

计算机编程里，* 代表乘法，/代表除法，** 代表乘方， b**2 就是 b 的二次方。

注意： Python 是用 缩进空格 来表示段落的，冒号(:)来表示段落开始。

第 2 行先缩进4个空格，说明下面缩进4格的，都是同一段落，用来具体计算上面定义的公式的。把 a2+2*a*b+b2 的计算结果，放到c里。

c类似于a，b，都是表示一个变量，它可以用来存放数字，文字，甚至函数。这里它存放的是用a，b计算后得到的结果。因为不是在函数名里，所以术语叫做“变量”，用在函数名里，就叫参数了。

“变量”就是用一个单词来代表一个可以变化的量的。单词里可以有字母，数字和下加线(_)，数字不能打头。

第 3 行，把存在c里的结果，传回给函数的使用者。

return 命令的意思，就是立即结束函数的执行，把return后面的值传给调用者，可以传回多个值。

现在可以使用这个公式了，我们把套公式叫调用函数 ：

ping2 = a_b_pingfang(2, 3)

ping2 里存放了 a_b_pingfang(2, 3)得到的结果，也就是上面 return c 这句，把 c 的内容，传给了外面的ping2。

把结果打印出来：

print(ping2)

全部程序就是：

def a_b_pingfang(a, b):
    c = a**2 + 2*a*b + b**2
    return c
ping2 = a_b_pingfang(2, 3)
print(ping2)

存到 test2.py ，跑 python test2.py 就可以看到输出 25。

循环 (loop)¶

当然还有循环，怎么让程序重复的做事？我们有 while(当…), for(对于…) 命令来进行循环控制。

a = 0
while a < 100:
   a = a + 1
   print a

这个循环说，当 a < 100 的时候，把 a 增加 1，再把它打印出来，然后重复。当 a 等于100了，条件不符合了，就结束了。

我们有 <, >, ==, <=, >=, != 来判断大于，小于，等于，小于等于，大于等于，不等于。

还有 and(并且), or(或者), not(不是) 来进行逻辑运算，所谓逻辑运算，就是测试多个不同判断之间的关系的：

(a == 1) and (b != 2) 来测试这两个判断是否同时成立：a 等于 1 并且 b 不等于 2。 (a == 1) or (b != 2) 来测试这两个判断里是否有至少一个成立：a 等于 1 或者 b 不等于 2。 not a == 1 来测试这个判断是否是错的。错的就是对的，对的就是错的，颠倒黑白：不是 a 等于 1，那就是 a 不等于 1 了，好像有点脱裤子放屁。其实在别的更复杂的判断组合里更有用些。

我们还有 break(中断) 来打断循环，和 continue(继续) 来立刻回到循环开始，也可以用 if(如果) 命令来进行判断：

a = 0
while True:
    a = a + 1
    if a >= 100:
        break
    print a

这里 True(正确) 表示永远正确，相对的是 False(错误) 表示永远错误。这一段是说一直执行，因为 while 的条件总是正确，就是说“当符合总是正确的条件的时候，不断重复”，当然是永远正确，永远重复了。下面在 if 处判断如果a大于等于100，如果是，那么执行 if 下的段落，这里我们打断了循环。如果条件不符，就跳过 if 下面的小段落，该干嘛干嘛，具体到这里就是打印 a 然后继续执行循环。

for 循环是利用下面介绍的的列表数据结构对列表进行循环。

Python 数据概念¶

下面具体说到python特异功能，它有几个特殊的存储数据的格式。

• 列表: list
• 元组: tuple
• 字典: dict (dictionary)
• 集合: set

列表 (list)¶

列表：把很多变量存进一个列表里，叫列的意思，就因为他像列车一样，一节一节车厢，每厢放一个变量。格式为 b, c, 1, 3, 5, ‘葡萄’, ‘葡萄皮儿’，可以看到，方括号里，可以放具体的数字，文字，也可以放变量，用逗号分隔。

这些内容是在固定位置上，可以通过他们的位置，来提取：

alist = [1, 3, 5, '很傻', '葡萄', '葡萄皮儿', a, var1]
print (alist[0]) # 打印 1
print (alist[3]) # 打印 "很傻"

在 python里，次序是从0开始数的，开始是0，然后是1，2，3，4，5，所以上面的列表 alist的第一个内容，可以用alist[0]来提取，第二个用alist[1]来提取。就像年龄一样，一生下来是零岁，一年以后才是一岁，不是中国传统那样，生下来就一岁，那是虚岁。蟒蛇语言它只认准确的东西，不玩儿虚的。

print (alist[4]) # 打印 '葡萄'

这里，我们可以介绍用 for 循环来访问这个列表里的所有内容：

for me in alist:
    print (me)

上面这一段，打印所有alist里的内容。

这个循环是，对于列表 alist ，从 0 位置开始，访问它的每一个位置，把这个位置上的值， 放到 me 里，然后针对不同的 me 值，重复执行下面段落的内容。

in 表示 me 在 alist 里，也可以用来判断：

  if "葡萄" in alist:
     print "葡萄在alist里！"

列表的内容是可以改变的，我们可以把第4个位置设为”很天真”:

alist[3] = alist[3] + ' 很天真'
print (alist[3]) # 打印 '很傻 很天真'

下面说道的元组的内容就不能改变了。

元组 (tuple)¶

元组：元组就是列表，但是他的内容是不能改变的，用圆括号()来表示。 他的内容只能一开始就设定。但是，元组和列表之间是可以用函数互相转变的，转成列表就可以改变内容，转回元组就不能改了。

元组是用圆括号来表示，所以叫元组嘛。

atuple = (2, 3, "老子")
alist = list(atuple) # 变成 [2, 3, "老子"]
alist[0] = 0
tuple2 = tuple(alist) # 变回 (0, 3, "老子")

在 python 里，字符串也是一种特殊的元组，也就是内容不可变的字符列表。

txt = 'abcdefg'
print(txt[1]) # 打印 b

字典 (dict)¶

字典：字典就像一般的字典，一个字，一个解释，再一个字，再一个解释。用大括号表示：

adict = {1: "我是解释",
  2: "我是解释2",
  "我是3": 3,
  "我是4": 4
  }

前面的字叫钥匙(key)或者索引，后面的解释，叫”值”。索引不能重复，必须是唯一的。

我们可以看到，前面的字，和后面的解释可以是数字，文字，还可以是函数或者元组。但是前面的字，不能是列表，因为列表内容是可变的，可变的东西都不能做索引。

我们用索引来提取，设定或者增加值，而不是用位置：

adict[1] # "我是解释"
adict["我是3"] # 3
adict[1] = 2 # 设定新的值
adict["新索引"] = "没头脑和不高兴" # 增加一个新索引和值

集合 (set)¶

集合: 集合就是数学上用的集合，把一堆东西放到一起，类似列表，不同的地方是内容不重复，而且也没有次序。

aset = set([1, 2, 3, 2, 4, 6]) # 去掉重复内容，所以是 1,2,3,4,6

可以看出，建立一个集合的方式，是使用set()函数，函数的参数可以是列表，或者元祖，反正是一串儿的都可以。

集合的用处是利用他内容不可重复的特性，来去掉重复的内容。至于其他的合集，交集也是这个特性的延伸。

集合也是可以变成列表的，利用 list() 函数。

alist = list(aset) # 内容 [1,2,3,4,6]

模块 (module)¶

Python 里包涵了很多别人写好的函数、方法让我们直接利用。譬如写网络程序的函数，数 学计算的函数，分析电邮文件的函数，加密的函数。我们要做的就是套公式！

这些函数分门别类的放到叫“模块”的东西里。一个模块里，包括很多功能相类的函数。而具体实现上，一个模块，就是一个python的程序文件。

如果模块还需要细分更多层，那么每层就是一个文件目录。里面有很多做为模块的python文件。

要使用模块，我们用“进口”这个命令: import

import time
now = time.clock()
print (now)

这里，我们先进口 time 模块，然后使用 time 模块里的函数 clock() ，得到当前时间，打印出来。

用个英文句点表示模块 time里的clock函数: 模块名.函数名

在 python 里，我们会用到很多别人写的模块，能自己少写点儿源码，尽量少写，懒不是？

类 (class)¶

其实编程来说，类并不是必须的，但是因为很多python提供的模块，里面的函数都是包在类里面的，所以我们需要介绍一下类。

面向对象编程，是现在比较流行的编程方式，是个人都得用“面像对象”的思路来编程，来显得自己跟得上形式。其实面对对象并不是必须的，光棍并不可耻。

类就是种类的意思。

基本上面对对象就是把同类的函数，变量打包放到一个包袱里，这个包袱就叫“类”。挺土气是吧？其实面对对象也并不就一定时髦，也可以俗不可耐，就看你包袱打的怎么样了。

这个 “类”一般上是以具体的东西为模板，譬如物种：人类，猫类；物品：家俱类，电器类。他里面打包的函数，基本上是针对这个类进行操作的，譬如人说话，人吃饭，人的鼻子人的嘴，猫逮耗子，家居磨损。

使用类的时候，我们先具体化他，把种类变成个体。人类变成某人，猫类变成某猫，家俱变成某件家俱。这个具体化的类，就是所谓的“对象(object)”。然后我们就可以使用这个具体人，猫，家居的函数，针对具体的人，物进行操作了，所谓操作对象。

定义类¶

class RenLei:
    def __init__(self, mingzi):  # self 是一个固定参数名，代表这个对象自己。
        self.mingzi = mingzi     # 把名字存到对象自己的 mingzi 变量上。
    def shui2(self):             # 谁函数
        return self.mingzi

上面的例子，一开始就要求给这个对象一个名字。

在类的定义里，每一个函数，他的第一个参数，都是规定死的，必须是self。self代表这个对象自己。在对象内部，这个对像本身的变量，函数，都是通过这个self来存取的。

在调用类里的函数时，不用提供 self 这个参数，程序自动提供 self，让我们使用它其他的函数，变量。我们只要提供其他参数即可。

__init__() 这个函数是一个特殊的函数，他代表从类具体化到对象的时候，需要套用的公式。

通过类建立对象的时候，程序会自动调用 __init__()函数。所以它叫做初始化函数。建立对象的时候，有什么一开始的要求，都可以通过它来指定，比如要求“脚不大好头发没有麻子”。

当然如果没有初始要求，也可以不定义这个函数，那么程序就不会自动调用它了。

具体化类，建立对象¶

# 建立对象，提供的函数对应__init__() 函数，self 这个参数程序会自动提供，不用我们提供。
xiaozhang1 = RenLei("小张")
mingzi = xiaozhang1.shui2()  # 使用“对象名.函数名()”的格式来调用类里的函数。
print mingzi <-- "小张"

字符串的对象性质¶

Python 里的字符串，列表，元组，字典，它们本身都是面对对象的类，所以带有很多函数可以对自己进行操作，譬如：

a = "脚不大好 头发没有 麻子".split()

split 是字符串这个类的函数，他可以把字符串在给定位置分割，当我们不给他参数的时候，会在所有空白位置分割，然后返回一个列表，里面是被割裂的字符串。

结果，a 的内容是 ["脚不大好", "头发没有", "麻子"]，这是一个有3个元素的列表。

对于字符串，列表，字典之类的操作，请熟读说明手册对他们的说明，python编程，主要就靠字符串，列表和字典了。

Python 程序员编程习惯¶

重中之重: 大量的使用 list 这个列表方式来存储、操作数据。一字长蛇阵是蟒蛇的绝招，多用没错。

写一个 Python 程序，我们一般的步骤是：

1. 进口所有会用到到模块 import
2. 定义我们自己的类和函数。对于每个函数里要用到的函数，被调用的函数一般放在调用函数的前面定义。这样我们读程序的时候，如果从上到下，就知道调用的函数，在前面是怎么定义的，有什么功能，需要什么参数，返回什么值。
3. 在文件的最下面，调用上面定义的函数和类，开始工作。
4. 命令行的选项是通过 sys.argv 这个列表得到的。
5. 尽量使用 python提供的内建函数和模块里的函数，所以我们对Python的模块说明手册要很熟悉。

Python 运行，是从文件的上面往下走的，看到一条命令执行一条命令，一直到最后一行。当我们定义函数和类的时候，他们只是定义，而没有执行，所以Python 看到他们，先存起来，直到看到定义外的具体命令，才真正的执行。如果这个命令调用上面的函数，那么就把存起来的函数执行一下。

完整例子： 把一个两列的文件input.txt，分割成两个文件col1.txt, col2.txt，一个文件一列。 input.txt 内容:

a1 啊阿
ai1 挨埃哀
ao2 熬鳌翱獒

程序内容：

def split_file(filename): # 把文件分成两列
    col1 = [] # 存储第一列
    col2 = []
    fd = open(filename) # open 函数用来打开文件，返回一个文件对象
    text = fd.read() # fd.read 读入文件fd 的内容。
    lines = text.splitlines() # 把读入的内容分行
    for line in lines: # 循环每一行
        part = line.split(None, 1) # 分割一行。
        col1.append(part[0]) # 把分割的第一部分放到col1后面。
        col2.append(part[1])

    return col1, col2 # 返回 col1, col2

def write_list(filename, alist): # 把文字列表内容写入文件
    fd = open(filename, 'w') # 打开输出文件col1.txt，'w'指定使用写入模式。
    for line in alist:
         fd.write(line + '\n')

def main(): # 主函数，程序进入点，习惯性叫他 main()
    filename = 'input.txt'            # 把输入文件名 input.txt 放进一个变量
    col1, col2 = split_file(filename) # 调用分割函数，结果存入 col1, col2
    write_list('col1.txt', col1)      # 调用写入函数
    write_list('col2.txt', col2)

main() # 唯一的函数外命令，程序开始执行，调用上面的 main() 函数数。

这里，输入的文件名是写死的 input.txt ，我们可以使用模块 optparse 来通过命令行读取用户提供的文件，会更灵活些，那些就是你研究过 optparse 以后的事了。

参考资料¶

更多的功能，函数，请参考python的官方教学和手册。

先熟悉:

• 内建函数
• 内建数据类型 (字符串，数字，列表，字典，文件对象)
• sys 模块
• re 模块
• os 模块
• optparse 模块

熟悉这些，基本上编程没问题了。

深入 Python是一本经典的参考书，虽然没有涵盖所有python模块的内容，但是对初学者基本够用。而且它是一个自由文件，说俗了就是合法免费的，又有中文翻译版，难得。

也可以参考 Python 绝对简明手册这个中文说明。

如果需要网络编程，还要熟悉网络相关的模块，urllib2，socket，xml.etree.elementtree。

如果想要图形界面，建议使用pygtk或者pyqt图形界面函数库，这时候，也需要熟悉面对对象编程的概念。

对于英文不好的人，建议买一本有Python函数模块介绍的中文书，作为参考书，在编程的时候，边编边翻书。

Python 的中文意思是巨蟒，大蟒蛇。但是这个语言的具体出处是一个叫Monty Python的英 国电视剧。

© 我想网 Akon 所有 , 2010. | 永久链接 | 1条评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• Python 3 系列教程 – developerWorks 中国
• 解密CSS Sprites：技巧、工具和教程
• 简单的JQuery聚光灯效果教程
• 用jQuery和CSS构建下拉菜单
• 掌握强大的WordPress的子主题
• 国外PHP开发者放弃PHP而改用Python
• 制作jquery文字提示插件
• 使用Photoshop制作 Web 2.0 布局的网站 [4]
• 使用Photoshop制作 Web 2.0 布局的网站 [3]
• 使用Photoshop制作 Web 2.0 布局的网站 [2]

Feed enhanced by Better Feed from Ozh

我之所以放弃PHP，原因首先是语言。PHP实际上不是一种语言，而是一种巨大的插件结构，以一种高层的形式来展示低层的库。而大部分开发者使 用的 语言实际上是对C功能 (curl, mysql, gd, etc.)的包装，通常情况下它们的库展示得很简单。因而这导致了PHP的API不一致。

PHP语言的第二个问题是语言的管理问题。PHP语言实际上是由委员会来设计的，而且没有人来制定任何共识性的标准。PEAR有自己的标准，PHP有自己 的标准，这导致SPL classes更具Java风格，而PEAR却截然不同。

从事PHP开发11年来，我认识了很多PHP领域的专家级开发者，它们对PHP也有很多看法。除了上文提到的委员会问题以及标准混乱问题之外，由于PHP 的使用范围非常广，向后的不兼容对代码造成了很大的破坏。

还要提到的一点是PHP缺乏很多现代语言的特性。现在再来说说Python：

Python语言的创建方法几乎与PHP的完全相反。首先，Python是由Benevolent Dictator和Guido van Rossum领导的，语言的开发由单一的人员主导，因此它的开发、管理以及长期运营会保持很好的连续性。Guido和Python的核心开发者通过PEP 创建标准，而且通过公共接口展示标准是如何创建的。而且，Guido如果想到的语言特性不够好，也不会出现在语言层中（如没有++运算符，而且比较符中没 有分配）。

延续性的特点也延伸到了整个Python社区，所以你很难发现不同项目中的Python截然不同。

我最喜欢的Python的一个特点就是它的清晰。当打开Python中的一个文件的时候，我会清楚地知道里面大概有什么样子的代码，联想到很多次我被 PHP的这一点搞得焦头烂额，我觉得这个特性非常有用。

总之，Python的系统级特性非常不错。

Python另外一个很棒的特性是直白性。需要namespace(命名空间)？文件的名字就是命名空间；需要模块？只需要用一个__init__.py 文件代替；需要重命名功能？只需要new_func = old_func。

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 10个免费开源微博客程序
• 设计模式之单例模式
• 论述PHP开发框架: What, When, Why and Which?
• 腾讯PHP程序员面试题目
• 简易Wordpress模板代码帮助手册中文版
• 用PHP数组对百万数据进行排重
• 用 PHP 读取和编写 XML DOM
• 深入理解PHP之匿名函数
• 最快的 PHP 模板引擎 Blitz Templates
• 开发者不可不知的PHP框架深度解析

Feed enhanced by Better Feed from Ozh

新手程序员

def factorial(x):
    if x == 0:
        return 1
    else:
        return x * factorial(x - 1)
print factorial(6)

第一年的刚学完Pascal的新手

def factorial(x):
    result = 1
    i = 2
    while i <= x:
        result = result * i
        i = i + 1
    return result
print factorial(6)

第一年的刚学完C语言的新手

def fact(x): #{
    result = i = 1;
    while (i <= x): #{
        result *= i;
        i += 1;
    #}
    return result;
#}
print(fact(6))

第一年刚学完SICP的新手

@tailcall
def fact(x, acc=1):
    if (x > 1): return (fact((x - 1), (acc * x)))
    else:       return acc
print(fact(6))

第一年刚学完Python的新手

def Factorial(x):
    res = 1
    for i in xrange(2, x + 1):
        res *= i
    return res
print Factorial(6)

爱偷懒的程序员

def fact(x):
    return x > 1 and x * fact(x - 1) or 1
print fact(6)

更懒的 Python 程序员

f = lambda x: x and x * f(x - 1) or 1
print f(6)

Python 专家

import operator as op
import functional as f
fact = lambda x: f.foldl(op.mul, 1, xrange(2, x + 1))
print fact(6)

Python 黑客

import sys
@tailcall
def fact(x, acc=1):
    if x: return fact(x.__sub__(1), acc.__mul__(x))
    return acc
sys.stdout.write(str(fact(6)) + '\n')

专家级程序员

import c_math
fact = c_math.fact
print fact(6)

英语系的专家级程序员

import c_maths
fact = c_maths.fact
print fact(6)

Web 设计者

def factorial(x):
    #-------------------------------------------------
    #--- Code snippet from The Math Vault          ---
    #--- Calculate factorial (C) Arthur Smith 1999 ---
    #-------------------------------------------------
    result = str(1)
    i = 1 #Thanks Adam
    while i <= x:
        #result = result * i  #It's faster to use *=
        #result = str(result * result + i)
           #result = int(result *= i) #??????
        result str(int(result) * i)
        #result = int(str(result) * i)
        i = i + 1
    return result
print factorial(6)

Unix 程序员

import os
def fact(x):
    os.system('factorial ' + str(x))
fact(6)

Windows 程序员

NULL = None
def CalculateAndPrintFactorialEx(dwNumber,
                                 hOutputDevice,
                                 lpLparam,
                                 lpWparam,
                                 lpsscSecurity,
                                 *dwReserved):
    if lpsscSecurity != NULL:
        return NULL #Not implemented
    dwResult = dwCounter = 1
    while dwCounter <= dwNumber:
        dwResult *= dwCounter
        dwCounter += 1
    hOutputDevice.write(str(dwResult))
    hOutputDevice.write('\n')
    return 1
import sys
CalculateAndPrintFactorialEx(6, sys.stdout, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)

公司里的程序员

def new(cls, *args, **kwargs):
    return cls(*args, **kwargs)

class Number(object):
    pass

class IntegralNumber(int, Number):
    def toInt(self):
        return new (int, self)

class InternalBase(object):
    def __init__(self, base):
        self.base = base.toInt()

    def getBase(self):
        return new (IntegralNumber, self.base)

class MathematicsSystem(object):
    def __init__(self, ibase):
        Abstract

    @classmethod
    def getInstance(cls, ibase):
        try:
            cls.__instance
        except AttributeError:
            cls.__instance = new (cls, ibase)
        return cls.__instance

class StandardMathematicsSystem(MathematicsSystem):
    def __init__(self, ibase):
        if ibase.getBase() != new (IntegralNumber, 2):
            raise NotImplementedError
        self.base = ibase.getBase()

    def calculateFactorial(self, target):
        result = new (IntegralNumber, 1)
        i = new (IntegralNumber, 2)
        while i <= target:
            result = result * i
            i = i + new (IntegralNumber, 1)
        return result

print StandardMathematicsSystem.getInstance(new (InternalBase, new (IntegralNumber, 2))).calculateFactorial(new (IntegralNumber, 6))

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 国外PHP开发者放弃PHP而改用Python
• 一个显示排序过程的Python脚本
• QCon北京报道：豆瓣首席架构师洪强宁谈Python语言
• Python语言入门
• python中的编码
• Python 语言快速入门教学
• Python 3 系列教程 – developerWorks 中国
• Google将限制Python语言的应用 开发社区热议
• 10个免费开源微博客程序

Feed enhanced by Better Feed from Ozh

如在windows环境下的以下示例代码：

#!/usr/bin/env python
import sys
import os
def do():
    f = open('./ansi.txt')
    for a in [x.strip() for x in f]:
        print a
if __name__=='__main__':
    do()

此时的ansi.txt编码为ansi,我们在cmd窗口执行，看到如下结果：

此时一切正常，但，如果还是用上面的脚本去读取utf8.txt，文件是utf8编码，就会得到下面的结果：

经典的“乱码”出现了，有朋友可能会说了，我在python脚本里指定编码应该就解决了，于是：

#!/usr/bin/env python
#coding=utf-8     #在这里指定编码
import sys
import os

def do():

    f = open('./utf8.txt')
    for a in [x.strip() for x in f]:
        print a
if __name__=='__main__':
    do()

再次运行：

OMG，还是乱码。。。。

能不能正常输出中文不取决于#coding=utf-8，也不取决于目标文件的编码，而是取决于你的终端输出设备，这里就是CMD窗口，CMD窗口 是不支持UTF-8的，它只支持GBK，所以，我们要转码。

那为什么第一个示例中，它能正确输出？因为目标文件本身就是GBK编码，所以不需要做任何转码就能正常输出。

在第二个示例中，我们只需要做一个小的改动，就可输出UTF8编码的文件：

#!/usr/bin/env python
#coding=utf-8
import sys
import os

def do():

    f = open('./utf8.txt')
    for a in [x.strip() for x in f]:
        print a.decode('UTF-8').encode('GBK')      #在这里转码
if __name__=='__main__':
    do()

结果：

正常输出。

做一个小结：

1. python脚本中的#coding=utf-8并不是决定最终输出的编码，而是指定python脚本本身使用的编码；如果你的脚本本身内部有非 ASCII码，那就应该指定编码#coding=gbk
2. 如果文件的编码是GBK，你操作的终端也是支持GBK的，那就不需要编码，直接输出即可。
3. 如果文件的编码不是GBK，但你的操作终端只支持GBK，不支持UTF-8，那么，你就需要对这些字符做转码操作。如文件编码是UTF-8，就需 要先decode成UNICODE编码再encode成GBK

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 国外PHP开发者放弃PHP而改用Python
• 一个显示排序过程的Python脚本
• QCon北京报道：豆瓣首席架构师洪强宁谈Python语言
• Python语言入门
• Python程序员的进化
• Python 语言快速入门教学
• Python 3 系列教程 – developerWorks 中国
• Google将限制Python语言的应用 开发社区热议
• 10个免费开源微博客程序

Feed enhanced by Better Feed from Ozh

Python语法简明，具备很强的易用性，能够帮助开发团队以最为高效率的速度完成工作任务。对于刚开始使用Python工作的程序员，完成Hello World例子不会超过1分钟，学习编写文本处理工具用一个下午的时间即可，而完成一个实用程序的编写，即便是新手，也仅需要一周的时间。

我在2002年开始接触Python，从2004年到现在基本完全使用Python进行工作。Python语言在降低工作成本方面有着显著的效果，同时，由于Python语言存在如强制缩进这样的约定，能够在一定程度上避免程序员编写代码的个人风格化，以保证代码始终具备良好的可读性。目前，豆瓣网目前约有近六成的代码是使用Python语言编写，另外不到三成使用C语言，其次是JavaScript代码，还有少量代码使用 C++，Erlang，Go，Pyrex，R以及Shell编写。

在QCon演讲中，洪强宁和观众分享了Python语言的特点及优势，并结合豆瓣开发过程中的多个实际案例，阐述Python如何做到简化常见的开发场景，并使豆瓣网能够充分适应Web 2.0时代所带来的快速变化。就Python语言的适用范围，洪强宁谈到：

Python 具有非常宽广的适用面，对于Web 2.0网站来说，从Web应用开发到离线计算，从运维脚本到数据分析，都能够使用Python来完成。同时Python具有非常丰富的资源，其标准库所包含的内置模块超过200个，Pyhton的包索引PyPI中包含接近一万个Packages，面向的领域包含网络处理、数据库、桌面开发、游戏、科学计算、安全、文本处理等在内的各个层面，同时语言本身具备很好的拓展性，能够在Python脚本中调用c/c++的库，对语言功能进行扩充。

对于Web开发来说，Python有着众多的框架，往往让刚开始上手的开发者难以选择。对与网站Web开发框架的选择，洪强宁谈到：

由于Python社区的历史问题，积累了众多Python语言实现的Web开发框架，如Django、TurboGears、Quixote等，这些Web 开发框架各有自己独到的优势，同时也各自吸引了一批坚定的开发者为其不断添砖加瓦，从某种程度上，削弱了Python社区的凝聚力。相对于Ruby社区，几乎所有的Web开发都使用Ruby on Rails完成，凝聚了开发者的力量。但Python不乏功能强大的基础框架，在Python语言实现的WSGI（Web服务网关接口）帮助下，开发人员甚至可以在数小时之内编码实现一个自己的Web框架，来完成最大自主程度的Web开发工作。

近期豆瓣网将基于Dynamo简化开发的BeansDB贡献给开源社区。BeansDB提供高可用性的分布式KeyValue存储系统，采用HashTree和简化的版本号来快速同步保证最终一致性。就BeansDB的技术实现和应用场景，洪强宁谈到：

BeansDB采用类似Memcached的去中心化结构，在客户端实现数据路由。目前提供了Python版本的客户端，其它语言的客户端可以由Memcached的客户端改造得到。同时提供BeansDB状态查看，以及各个节点的数据分布和同步进度查询功能。BeansDB的典型应用体现在图片文件、小媒体文件、大文本字段等多媒体数据的存储。BeansDB的易用性和高可用性体现在部分节点出现故障时不影响数据服务的正常访问，同时通过哈希树实现快速完整数据同步。

豆瓣网以多年Python开发的实践经验，为Python语言在国内Web 2.0站点开发中的应用给出了最佳成功案例，也吸引了一批Web 2.0站点的开发者将Python列为首选语言。期待明年的QCon大会，来自豆瓣网的工程师能够为开发者分享更有价值的开发经验。

© 我想网 Akon 所有 , 2010. | 永久链接 | 1条评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 国外PHP开发者放弃PHP而改用Python
• 一个显示排序过程的Python脚本
• Python语言入门
• Python程序员的进化
• python中的编码
• Python 语言快速入门教学
• Python 3 系列教程 – developerWorks 中国
• Google将限制Python语言的应用 开发社区热议
• 10个免费开源微博客程序

Feed enhanced by Better Feed from Ozh

Jaiku是一个基于Python的微博客平台，2007年被Google收购，不过之后并没有对其成功运营，只好在2009年宣布对其停止维护， 稍后Google就将Jaiku完全开源，并切换到AppEngine上运行，目前Jaiku完全开源并提供用户免费下载，大家可以到Jaiku源代码项 目地址。

查 看演示 代码下 载

2、Laconica / StatusNet

Laconica / StatusNet是一个基于PHP和MySQL的开源微型博客系统，也是一个Twitter克隆，可以实现Microblog的常用功能，国外不少微博 客系统都是通过这个开源系统架设的。Laconica得到大量应用系统的支持，包括Twitterfeed、Hellotxt和Gravity等，成熟且 稳定。

最 新版本代码下载 StatusNet官方网址

3、Sweetter

Sweetter是一个开源的微博客项目，具有一定的投票机制，基于Python。

查 看演示 代码下载

4、Jisko

Jisko的界面和Twitter很像，能够自动通过AJAX更新，也是基于PHP和MySQL的，这个系统可能是西班牙人开发的，使用SVN到这 里下载其源代码。

查看演示 代 码下载

5、Yonkly

Yonkly是基于Asp.Net的开源微博客，除了开放源码的版本，它还有一个用于托管的高级独立版本。

6、PageCookery

是国内的一款开源代码，也是基于PHP和MySQL，支持和叽歪的同步，大家可以到PageCookery主站去下载代 码。

7、Asaph

也是一款PHP+Mysql的，其下载代码下载地址：http://www.phoboslab.org/projects/asaph

8、Floopo

Floopo是基于PHP和MySQL的免费的微博客系统，它的功能非常类似Twitter，并且提供了强大的后台管理系统。

9、TypePad Motion

TypePad Motion是一个多媒体微博客，除了文字内容，您还可以分享图片（GIF/JPE/PNG）、视频（YouTube/Vimeo）和音频（MP3），附 属媒体文件均可以在线播放。

TypePad Motion基于TypePad的API，不论任人通过TypePad Motion架设的网站，其数据都是统一存贮在TypePad的数据库。

软件主页： http://www.typepad.com/go/motion/
下载地址： http://developer.typepad.com/motion/create-motion.html

10、Sharetronix

Sharetronix是一款基于PHP和MySQL的免费的微博客系统。

查看演示 代 码下载

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 国外十大开源的PHP应用服务
• 国外PHP开发者放弃PHP而改用Python
• 国内开源的PHP应用程序
• PHP获取字符串编码类型
• php 加密解密类(含公钥)
• 9个PHP库简介和下载
• 21个实用便利的PHP代码
• 高效互联网营销的18种技巧
• 雅虎发布网站性能监测工具：从用户角度衡量
• 陈光锋[访谈]：地方新站如何做运营推广

Feed enhanced by Better Feed from Ozh

Collin Winter：的确，Google将限制Python的应用因为：Python不如Java和C++快，线程占有、内存使用都很高在使用Python开发 新系统的时候，我们深知如果负载增加了10倍或者100倍系统会怎样，开发出的服务会有多糟糕我想Python已经发展到了一个狭缝中，因此在选择时我们 应当权衡其优点和缺点，也许开发人员使用Python会很有效率，但随着系统的增大却会遇到许多平台级的性能限制。

K：Unladen Swallow会改变这一切么？你的期望是什么呢？

Collin Winter：Unladen Swallow旨在尽可能地将Python用在更多它现在尚未涉足的地方，而且Unladen Swallow也并非包治百病的灵丹妙药。如果没有人给Python注入投资，Python将仍旧比C和Java慢、占用更多的内存和线程。我希望开发者 对Python的关注能够形成一个良性循环：越多的开发者感兴趣、越多的公司干兴趣，就有越多的投资注入，从而开发出更多的Python资源。

我认为Python及其他动态语言最好的一点就是：许多开发者工作于不同的子系统，但都为同一个代码基工作。而C或者C++语言则不同，参与的开发 者越多，代码基就越支离破碎。从这个角度来说动态语言更加易于sandbox操作。这种敏捷和灵活是Python语言的重要特性。

K：Python的确是比C和Java慢，但它比较起v8 JavaScript引擎如何，是否会是后者的竞争对手呢？

Collin Winter：我认为像CPython之类的应用不可能像V8或者SquirrelFish Extreme那样快，毕竟后两者是专为速度而生的。我们也曾遇到一些高速性能方面的优化却很难配置到CPython中，因而只能放弃。作为开源项目的志 愿者，CPython跟V8的侧重点不一样：CPython强调的是简单，也即简单、稍慢的内核便于人们在业余时间维护。

对于Python的另一个项目PyPy我倒是有很高的期望，希望它能摆脱C-level向后兼容的束缚而提供长久的性能解决方案。但这个愿望可能需要十年来实现。

K：CPython为什么考虑的是人们在业余时间的维护？

Collin Winter：CPython开发人员很少是有报酬的，几乎全部是志愿者，而Ruby开发者却能够从EngineYard等赞助商那里获得基金，因而当他 们意识到MRI伺服web应用很慢时，他们可以更好地开发他们的VM。这也决定了我们开发的东西更加照顾大多数人的需求。

一位名叫Leon Sit的开发者在这里补充道：我认为当系统增大时，CPython除了在数字码方面表现不错之外其他的都差强人意。而且，CPython依赖C编辑器而 Windows系统根本没有C编辑器。为了提高CPython的速度，就需要添加打印信息而它们涉及的语法却非Python的标准语法。

K：那么Jython呢？

Collin Winter： Unladen Swallow的另一个主要目标是维护与C扩展模块的兼容性，后者被Google广泛使用。使用Jython需要将基础架构从SWIG移植到JNI，这是 一项很痛苦的工作，而且几乎会无可避免地带来非常繁琐的bug。这是我们为什么没有选择Jython作为baseline的首要原因。

Jython是一部分全职的有薪开发者。但到目前为止，IronPython和Jython不得不将大部分的开发精力放在与CPython的兼容 上，只有很少的精力放在性能优化方面。也由此可见支持Python 3多么影响Jython,IronPython, PyPy等项目。

网友Tom Machinski认为：CPython并非与低阶虚拟机（LLVM）相兼容。Unladen Swallow项目组提高五倍性能的承诺并没有真正意义上的实现。如果CPU耗用至少90%的执行时间用以运行一小段循环，CPython无疑可以将这段 程序提高100倍甚至更多。但如果是大的应用呢？而且不要忘了，这种加速往往只是针对程序的某个点，也即热点优化（hot spot optimization）。

不要误会我的意思，我当然对Unladen Swallow项目很感兴趣而且希望它能够真正地实现目标。但我也绝对认同Collin的意思：即便Unladen Swallow项目所有的目标都能真正实现，Python也不是Java或者C++的对手。

有开发者问：像Google这样的公司为什么不用Python编写一个原型，然后逐渐将核心部分转化为Cyhton，这样以来既能利用Python的优势，也可以获得C的效率和优化性能？

Craig Citro答道：我认为对Google而言这是发展Python的新计划：用Python写代码、做测试，然后将重要部分转化为CPython以提高速 度。然而这无疑是一项巨大的工作，而Collin Winter在上文中谈到的也不过是提高Python的运行速度、让Python在Google中继续保留下去。

而且目前CPython与Unladen Swallow的目标有很多矛盾之处，比如在低阶虚拟机（LLVM）方面，Unladen Swallow希望引入许多runtime优化和特性，而CPython却无法做到。

但是正如HotSpot JVM在一些标准方面可以打败g++一样，CPython击败单纯的Python代码静态编辑也不是什么难事。比如，如果你想写一个特殊的应用而你又很在 乎性能，CPython就是很棒的选择。你可以将对象转化为本地的C数据类型，如果你嫌麻烦而将Python代码转为CPython，JIT编辑器会很好 地优化这些纯Python代码。

注释： Unladen Swallow是Python的一个分支，由Google的一组开发人员组成。由于Google 在很多的应用项目中使用了Python，例如内部的服务器监控以及对外的Google Groups等。 所以Google很自然地希望提高Python的性能。该项目致力于改善Python的执行效率。Unladen Swallow的目标是将Python的性能提高五倍。为了实现该目标，将增加JIT的支持，并对虚拟机进行重新设计。在性能提升的同时，依旧会与 CPython保证源代码级别的兼容。

Unladen Swallow 的项目领导者及核心开发人员包括： Collin Winter、Jeffrey Yasskin、Thomas Wouters ，均为长期从事 CPython 的核心开发人员。他们贡献自己的20%的自由工作时间给Unladen Swallow。但是这个组织坚持认为这是一个Python项目，而非Google所有。

© 我想网 Akon 所有 , 2009. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 国外PHP开发者放弃PHP而改用Python
• 一个显示排序过程的Python脚本
• QCon北京报道：豆瓣首席架构师洪强宁谈Python语言
• Python语言入门
• Python程序员的进化
• python中的编码
• Python 语言快速入门教学
• Python 3 系列教程 – developerWorks 中国
• 10个免费开源微博客程序

Feed enhanced by Better Feed from Ozh

Jaiku（演示地址）是一个基于Python的微博客平台，2007年被Google收购，不过之后并没有对其成功运营，只好在2009年宣布对其停止维护，稍后Google就将Jaiku完全开源，并切换到AppEngine上运行，目前Jaiku完全开源并提供用户免费下载，大家可以到Jaiku源代码项目地址，使用一个SVN工具下载其源代码。

Laconica

Laconica（演示地址） 是一个基于PHP和MySQL的开源微型博客系统，也是一个Twitter克隆，可以实现Microblog的常用功能，国外不少微博客系统都是通过这个 开源系统架设的。Laconica得到大量应用系统的支持，包括Twitterfeed、Hellotxt和Gravity等。点这里下载其源代码。

Sweetter

Sweetter是一个开源的微博客项目，具有一定的投票机制，基于Python，点这里可下载其源程序代码。

Jisko

Jisko的界面和Twitter很像，能够自动通过AJAX更新，也是基于PHP和MySQL的，这个系统可能是西班牙人开发的，使用SVN到这里下载其源代码。

最后介绍两个国内中文的开源微博客系统。

EasyTalk

界面挺像饭否的，API接口也和饭否类似，基于PHP和MySQL，点这里下载源代码。

PageCookery

也是基于PHP和MySQL，支持和叽歪的同步，点这里下载源代码。

好了，以上就是我介绍的一些免费开源微博客系统，通过这些程序，我们可以搭建一个自己的饭否或Twitter，是不是很酷啊。如果大家知道什么更好的开源系统，请留言和大家分享。

© 我想网 Akon 所有 , 2009. | 永久链接 | 1条评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 网页鼠标点击轨迹热图跟踪软件-ClickHeat
• 游戏开发者必需知道的5个开源游戏引擎
• 开源射击游戏Warsow 0.5版发布
• 50个非常出色的开源博客
• 50款流行安全软件的开源替代品

Feed enhanced by Better Feed from Ozh

Python 3 初探，第 2 部分：Python 3 高级主题

占位方便日后的学习！

© 我想网 Akon 所有 , 2009. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• Python 语言快速入门教学
• 解密CSS Sprites：技巧、工具和教程
• 简单的JQuery聚光灯效果教程
• 用jQuery和CSS构建下拉菜单
• 掌握强大的WordPress的子主题
• 国外PHP开发者放弃PHP而改用Python
• 制作jquery文字提示插件
• 使用Photoshop制作 Web 2.0 布局的网站 [4]
• 使用Photoshop制作 Web 2.0 布局的网站 [3]
• 使用Photoshop制作 Web 2.0 布局的网站 [2]

Feed enhanced by Better Feed from Ozh

print 'helloworld'

1.2    Python数学计算

print 'helloworld'
print 3 + 5
x = 2 ** 2.5 #次方
y = 0
print x, y
from math import * #引入math包
print sqrt(3.0)
print log10(2)
print sin(pi / 3)

1.3    斐波那契数列

a, b = 0, 1
while b < 1000:
    print b,
    a, b = b, a + b

第2章    数据类型
2.1    数字
1、    Python支持的数字类型包括：浮点数、整数、长整数等。
2、    算数运算符包括:+、-、*、/、%等。
3、    负号运算符 –。
4、    位运算符 <<、>>、&、^等。

2.2    字符串
1、    单引号

print 'this is a "single-quoted" string,\n don\'t you like it?'

2、    双引号

print "this is a 'double-quoted' string"

3、    三引号

print '''this is a triply-quoted string
字串中可以換行, 也可以用單引號和雙引號'''

注：使用三引号字符可以换行，并可以添加单引号和双引号

2.2.1    字符处理

s1 = 'Hello'
s2 = 'World'
print s1 + ',' + s2 #重复打印10个*

print '*' * 10 #重复打印10个*

print 'Hello,World!'[3]  #取char

for c in 'hello,world!':print c #循环查询char

print 'world' in 'hello,world!' #判断字符串是否包含子串，返回true/false

print 'Hello,World!'[0:5] #类似java的substring()

print len('Hello,World!') #字符串长度

n = 10
print '学生人数为%d' % n #格式化字符串

2.3    List

m = [1, 5, 7, -3, -1, 0]
m.append(3) #添加一个元素
m.extend([1, 0, -1, -2]) #添加一批元素
del m[1:3] #删除元素
m[1] = -1 #换掉一个元素
m.insert(-1, 3.5) #插入元素参数1：位置，参数2为元素
m[2:4] = [3, 4, 5] #换掉一批元素
m.sort() #排序
m.reverse() #翻转
m.len() #长度

listone = [2, 3, 4]
listtwo = [2 * i for i in listone if i > 2]
print listtwo #输出结果为6,8
#为满足条件(if i > 2)的数指定了一个操作(2*i)

2.4    字典Directory

prices = { 'apple': 7.5, 'orange': 4.5, 'banana': 2}
prices['orange'] # 根据键获值
prices.has_key('tomato')
prices.keys() # 获取键集合
prices['guava'] = 6.7 # 添加元素

第3章    流程控制
3.1    流程控制

a = 'wangtong'
if a == 'wang':
    print '[%s]' % a
elif not a == 'tong': #没有或者有多个
    print '[%s]' % a
else:
print '[%s]' % a

3.2    逻辑表达式

a, b = 5, 1
def func(x):
    print 'x=%s in func' % x
    return 1
print a == 5 or func(a) #先判断a=5、再判断func(a)、最后是or
print a > b and func(b) #判断a>b、func(b)、最后and

?    逻辑非 not、和 and 、或 or
?    在 in 、 不在 not in
?    比较运算符: 相等 == 不相等 != 大於 > 小於 < 不小於 >= 不大於 <=
可串接: 如 a < b < c != d > g 即等同于 a < b and b < c and c != d and d > g
?    优先順序: 在、不在 > 比较 > 非 > 和 > 或

3.3    循环
3.3.1    For循环

array = ['apple', 'tangerine', 'banana']
print array
for fruit in array: #for循环
    print fruit, len(fruit)
    if fruit[0] > 'p':
        break
3.3.2    For分叉
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print n, 'equals', x, '*', n / x
            break
    else:# not for "if", but for end-of-for-loop
            print n, 'is a prime number'

?    break: 跳出循环
?    continue: 略过区块的以下部分、从循环的下一次继续
?    else: 在循环走到底时执行

3.3.3    For小技巧
3.3.3.1    遍历字典

prices = { 'apple': 7.5, 'orange': 4.5, 'banana': 2}
for stuff, price in prices.items():
 print stuff, '价格是', price

3.3.3.2    列出序列索引

prices = { 'apple': 7.5, 'orange': 4.5, 'banana': 2}
m = prices.keys()
m.sort()
for i, v in enumerate(m):
    print i, v

输出结果：
0 apple
1 banana
2 orange

3.3.3.3    同时循环2个序列

questions = [ 'name' , 'quest' , 'favorite color' ]
answers = [ 'lancelot' , 'the holy grail' , 'blue']
for q, a in zip(questions, answers):
print 'What is your %s? It is %s.' % (q, a)

3.3.4    While循环

i = 7
while i > 0:
    print i
    i = i -1

3.3.5    Range范围函数

print range(10) #0 - 10 循环10次
print range(3, 6) # 包括 3, 不包括 6
print range(2, 8, 2)  # 每步加 2
m = [x * x for x in range(4)] #  (list comprehension)
print m
for i in range(len(m)):
    print i, m[i]

第4章    函数
4.1    函数基础

def distance(v0,a,t):
    return v0*t + a/2.0 * t*t
print distance(1, 2, 3)

4.2    预设参数值

def eat(maxprice, lunch='chickenrice', soup='no'):
    print 'will eat', lunch, 'for lunch with', soup, 'soup for less than', maxprice
eat(150, '天丼', '味噌')
eat(130, '天丼')
eat(130, soup='羅宋')
eat(150, soup='羅宋', lunch='pasta')

在定义函数时: 有预设的参数必须在位置参数的后面
4.3    DocString

def printMax(x, y):
    '''Prints the maximum of two numbers.
    The two values must be integers.'''
    x = int(x) # convert to integers, if possible
    y = int(y)
    if x > y:
        print x, 'is maximum'
    else:
        print y, 'is maximum'
printMax(3, 5)
print printMax.__doc__ #使用__doc__实现docString 实现打印文档字符串

输出结果：
5 is maximum
Prints the maximum of two numbers.
The two values must be integers.

第5章    模块
5.1    使用SYS模块

import sys  #引入sys模块,sys模块包含了与Python解释器和它的环境有关的函数
print 'The command line arguments are:'
for i in sys.argv:
    print i
print '\n\nThe PYTHONPATH is', sys.path, '\n'

5.2    From …import
from math import * #引入math包
注:从代码可读性考虑，尽量避免使用from…import方式导入模块，推荐使用import方式
5.3    模块的__name__

if __name__ == '__main__':
    print 'This program is being run by itself'
else:
    print 'I am being imported from another module'

5.4    创建模块

def sayhi():
    print 'Hi, this is mymodule speaking.'
version = '0.1'

import module #导入模块
module.sayhi() #调用模块的方法
print 'Version', module.version

5.5    Dir函数
可以使用内建的dir()来列出模块定义的标识符。标识符有函数、类和变量。
当你为dir()提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。

import sys
print dir(sys) # get list of attributes for sys module

第6章    面向对象编程
6.1    Self
在Python的Self相当于Java的this指针。
6.2    Class

class Person:
    pass # An empty block

p = Person()
print p # 返回结果为<__main__.Person instance at 1>

6.3    __Init__方法
注：__Init__方法就是Python的构造器，用于初始化值和对象

class Person:
    def __init__(self, name): #初始化方法
        self.name = name
    def sayHi(self):
        print 'Hello, my name is', self.name

p = Person('Swaroop') #实例化
p.sayHi()

6.4    类与对象方法
类的变量:由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以

class Person:
    '''Represents a person.'''
    population = 0 #类变量

    def __init__(self, name):
        '''Initializes the person's data.'''
        self.name = name
        print '(Initializing %s)' % self.name
        #When this person is created, he/she adds to the population
        Person.population += 1

    def __del__(self):
        '''I am dying.'''
        print '%s says bye.' % self.name

        Person.population -= 1

        if Person.population == 0:
            print 'I am the last one.'
        else:
            print 'There are still %d people left.' % Person.population

    def sayHi(self):
        '''Greeting by the person.

        Really, that's all it does.'''
        print 'Hi, my name is %s.' % self.name

    def howMany(self):
        '''Prints the current population.'''
        if Person.population == 1:
            print 'I am the only person here.'
        else:
            print 'We have %d persons here.' % Person.population

swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()

kalam = Person('Abdul Kalam')
kalam.sayHi()
kalam.howMany()

swaroop.sayHi()
swaroop.howMany()

当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。
对象的变量:由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。

注：Python中所有的类成员（包括数据成员）都是 公共的 ，所有的方法都是有效的 。
6.5    继承

class SchoolMember:
    '''Represents any school member.'''
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print '(Initialized SchoolMember: %s)' % self.name

    def tell(self):
        '''Tell my details.'''
        print 'Name:"%s" Age:"%s"' % (self.name, self.age),

class Teacher(SchoolMember): #继承自SchoolMember类
    '''Represents a teacher.'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print '(Initialized Teacher: %s)' % self.name

    def tell(self):
        SchoolMember.tell(self)
        print 'Salary: "%d"' % self.salary

class Student(SchoolMember):
    '''Represents a student.'''
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks = marks
        print '(Initialized Student: %s)' % self.name

    def tell(self):
        SchoolMember.tell(self)
        print 'Marks: "%d"' % self.marks

t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 22, 75)

print # prints a blank line

members = [t, s]
for member in members:
    member.tell() # works for both Teachers and Students

第7章    输入与输出
7.1    文件

poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
    use Python!
'''

f = file('poem.txt', 'w') # open for writing
f.write(poem) # write text to file
f.close() # close the file

f = file('poem.txt')
# if no mode is specified,read mode is assumed by default
while True:
    line = f.readline()
    if len(line) == 0: # Zero length indicates EOF
        break
    print line,
    # Notice comma to avoid automatic newline added by Python
f.close() # close the file

7.2    存储器
Python提供一个标准的模块，称为pickle。使用它你可以在一个文件中储存任何Python对象，之后你又可以把它完整无缺地取出来。这被称为持久地储存对象。
另一个模块称为cPickle，它的功能和pickle模块完全相同，只不过它是用C语言编写的，因此要快得多（比pickle快1000倍）。你可以使用它们中的任一个，而我们在这里将使用cPickle模块。
注：类似于Java的串行化和反串行化

import cPickle as p
#import pickle as p

shoplistfile = 'shoplist.data'
# the name of the file where we will store the object

shoplist = ['apple', 'mango', 'carrot']

# Write to the file
f = file(shoplistfile, 'w')
p.dump(shoplist, f) # dump the object to a file
f.close()

del shoplist # remove the shoplist

# Read back from the storage
f = file(shoplistfile)
storedlist = p.load(f)
print storedlist

第8章    异常
8.1    Try/Exception

import sys

try:
    s = raw_input('Enter something --> ')
except EOFError:
    print '\nWhy did you do an EOF on me?'
    sys.exit() # exit the program
except:
    print '\nSome error/exception occurred.'

print 'Done'

8.2    引发异常 Raise

class ShortInputException(Exception):
    '''A user-defined exception class.'''
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

try:
    s = raw_input('Enter something --> ')
    if len(s) < 3:
        raise ShortInputException(len(s), 3) #抛出异常
    # Other work can continue as usual here
except EOFError:
    print '\nWhy did you do an EOF on me?'
except ShortInputException, x:
    print 'ShortInputException: The input was of length %d, \
was expecting at least %d' % (x.length, x.atleast)
else:
    print 'No exception was raised.'

注：类似于Java的throw抛出异常

8.3    Try/Exception/Finally

import time

try:
    f = file('poem.txt')
    while True: # our usual file-reading idiom
        line = f.readline()
        if len(line) == 0:
            break
        time.sleep(2)
        print line,
finally:
    f.close()
    print 'Cleaning up...closed the file'

第9章    Python标准库
9.1    Sys模块
Sys模块包含系统对应的功能。

import sys

def readfile(filename):
    '''Print a file to the standard output.'''
    f = file(filename)
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print line, # notice comma
    f.close()

# Script starts from here
if len(sys.argv) < 2:
    print 'No action specified.'
    sys.exit()

if sys.argv[1].startswith('--'):
    option = sys.argv[1][2:]
    # fetch sys.argv[1] but without the first two characters
    if option == 'version':
        print 'Version 1.2'
    elif option == 'help':
        print '''\
This program prints files to the standard output.
Any number of files can be specified.
Options include:
  --version : Prints the version number
  --help    : Display this help'''
    else:
        print 'Unknown option.'
    sys.exit()
else:
    for filename in sys.argv[1:]:
        readfile(filename)

9.2    OS模块
这个模块包含普遍的操作系统功能。如果你希望你的程序能够与平台无关的话，这个模块是尤为重要的。即它允许一个程序在编写后不需要任何改动，也不会发生任何问题，就可以在Linux和Windows下运行。

常用的函数如下：
os.name字符串指示你正在使用的平台。比如对于Windows，它是’nt’，而对于Linux/Unix用户，它是’posix’。
os.getcwd()函数得到当前工作目录，即当前Python脚本工作的目录路径。
os.getenv()和os.putenv()函数分别用来读取和设置环境变量。
os.listdir()返回指定目录下的所有文件和目录名。
os.remove()函数用来删除一个文件。
os.system()函数用来运行shell命令。
os.linesep字符串给出当前平台使用的行终止符。例如，Windows使用’\r\n’，Linux使用’\n’而Mac使用’\r’。
os.path.split()函数返回一个路径的目录名和文件名。

第10章    Python常用技巧
10.1    特殊方法
__init__(self,…) 这个方法在新建对象恰好要被返回使用之前被调用。
__del__(self) 恰好在对象要被删除之前调用。
__str__(self) 在我们对对象使用print语句或是使用str()的时候调用。
__lt__(self,other) 当使用 小于 运算符（<）的时候调用。类似地，对于所有的运算符（+，>等等）都有特殊的方法。
__getitem__(self,key) 使用x[key]索引操作符的时候调用。
__len__(self) 对序列对象使用内建的len()函数的时候调用。

10.2    Lambda形式
lambda语句被用来创建新的函数对象，并且在运行时返回它们。个人感觉lambda有点像函数指针。

def make_repeater(n):
    return lambda s: s * n

twice = make_repeater(2)  #将make_repeater赋值给变量twice

print twice('word') #调用make_reoeater函数
print twice(5)

10.3    Exec/Eval
exec语句用来执行储存在字符串或文件中的Python语句。
eval语句用来计算存储在字符串中的有效Python表达式。

© 我想网 Akon 所有 , 2009. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 国外PHP开发者放弃PHP而改用Python
• 一个显示排序过程的Python脚本
• QCon北京报道：豆瓣首席架构师洪强宁谈Python语言
• Python程序员的进化
• python中的编码
• Python 语言快速入门教学
• Python 3 系列教程 – developerWorks 中国
• Google将限制Python语言的应用 开发社区热议
• 10个免费开源微博客程序

Feed enhanced by Better Feed from Ozh