2.1 Python 概要

环境信息可视化第二讲 PYTHON2.1 Python 概要

•Python 是一门解释性的、面向对象的、动态语义特征的高层语言。高层次的数据结构，动态类型和动态绑定，使得它非常适合于快速应用开发，也适合于作为胶水语言连接已有的软件部件；• Python 简单的语法强调可读性，降低了程序维护的费用； • Python 支持模块和包，易于实现程序模块化和代码重用；• Python 的解释器和标准扩展库的源码和二进制格式在各个主要平台上都可以免费得到，而且可以免费分发； • Python 没有编译过程，编辑 - 测试 - 调试周期相当快；• 解释器和很多库都是 OpenSource ，但是 License 都比较宽松，可适用于各种情况，解释器非常稳定。

环境信息可视化第二讲 PYTHON

Python 是什么？ Python 是一种开放源代码的脚本编程语言，这种脚本语言特别强调开发速度和代码的清晰程度。它可以用来开发各种程序，从简单的脚本任务到复杂的、面向对象的应用程序都有大显身手的地方。 Python 还被当作一种入门程序员最适合掌握的优秀语言，因为它免费、面向对象、扩展性强同时执行严格的编码标准。

Python 对程序语句的处理首先通过一个解释和编译系统转换成为一系列的字节代码，然后再由 Python 的虚拟机进行处理。 Python 设计得非常有效，主要归功于它庞大的功能库，因此用户不用进入系统环境或是操作系统，也不用引用模块。用 Python 编程，小程序还是小程序，不必劳费太多的成本和时间。


Python 是什么？ * 面向对象 * 解释语言 * 交互式 * 模块化 * 动态性 * 高级语言 * 可移植 * 可用 C 和 C++ 扩展


Python 的历史　　 Python 的创始人为 Guido van Rossum 。 1989 年圣诞节期间，在阿姆斯特丹， Guido 为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，做为 ABC 语言的一种继承。之所以选中 Python（大蟒蛇的意思）作为程序的名字，是因为他是一个 Monty 大蟒蛇飞行马戏团的爱好者。

　　 ABC 是由 Guido 参加设计的一种教学语言（没听说过）。就Guido 本人看来， ABC 这种语言非常优美和强大，是专门为非专业程序员设计的。但是 ABC 语言并没有成功，究其原因， Guido 认为是非开放造成的。 Guido 决心在 Python 中避免这一错误（的确如此， Python 与其它的语言如 C,C++ 和 Java 结合的非常好）。同时，他还想实现在 ABC 中闪现过但未曾实现的东西。　　就这样， Python 在 Guido 手中诞生了（真要感谢他）。实际上，第一个实现是在 Mac 机上。可以说， Python 是从 ABC 发展起来，主要受到了 Modula-3 （另一种相当优美且强大的语言，为小型团体所设计的）的影响。并且结合了 Unix Shell 和 C 的习惯。


运行方式 Python 可以以命令行方式运行，也可以交互式方式运行，还具有图形集成环境，这样开发 Python 就相当方便。现在已经出现了许多用Python 编写的可视化编程软件，用于实现象 Delphi 一样的功能。

面向对象 Python 是一个真正的面向对象语言。它甚至支持异常的处理。如果学过 Java ，应该对这个不陌生。但其它的脚本语言，如 PHP ，好象就没有。这使得程序的编写更加清晰，而不需要许多的错误检查了。

模块和包这一点更象是 Java 。对于 Java 的支持，大家可以了解 JPython 。 JPython 是用 Java写的 Python ，它完全支持 Java ，在这个环境下使用Python 可以随意地使用 Java 的类库。


有趣的语法 Guido 认为 Python 的语法是非常优美的。其中一点就是，块语句的表示不是 C 语言常用的 {} 对，或其它符号对，而是采用缩近表示法！有趣吧。就这一点来说， Guido 的解释是：首先，使用缩近表示法减少了视觉上的混乱，并且使程序变短，这样就减少了需要对基本代码单元注意的范围；其次，它减少了程序员的自由度，更有利于统一风格，使得阅读别人的程序更容易。感觉还是不错的，就C 语言来说，在 if 语句后面大括号的写法就好几种，不同的人喜欢不同的样子，还不如统一起来，都不会看得别扭。

在每个类或函数的定义后面，第一行可以是说明语句，根本不需要注释符标记。对于后面跟块语句的语句，后面应跟上一个冒号 (:) 。一行语句不能太长，因为没有行结束符，如果超长则要使用续行符(\) 。


Python 品质超群虽然 Python 常用来创建简单的脚本，但它采用的编程技术可不简单，比如面向对象编码、套接字、线程和 GUI等等。假如你是一位刚入流的程序员，这些特性显然对你太有帮助了，因为你可以很快熟悉有益的编程语法和编码实践，之后再学习其他语言，比如 Java 或者C++等引入的技术概念就容易多了。脚本可以单独执行，不过，你还可以通过类文件和各类对象类型以充分利用这种语言的强大功能。

Python区别于其他面向对象语言的关键有两点。首先， Python 强调空格和编码结构，从而令开发者的代码具有良好的重用性。其次，执行脚本之前无须编译 Python 代码，这就是它为什么被当作脚本语言的原因。


Python 易于扩展Python 语言有一个引人注目的优势，它可以针对语言无法完成功能的函数调用函数库。 Python 还具有有些相当有用的工具帮助开发出复杂的应用程序。其中最常用的就是 Tkinker ，这种工具可以实现跨平台的 GUI 开发。另一种 wxPython工具则是对 wxWidgets跨平台 C++框架的扩展。 WxPython目前已经支持Windows 和 Linux平台。 Python Imaging Library 可以让 Python 创建、打开、编辑和修改图象，包括 .gif 、 .jpeg 和 .png等。为了了解常用的 Python 扩展和应用，你不妨访问下 The Vaults of Parnassus。

Python自身还可以嵌入到其他编程语言中。最常见的就是 Jython，这是一种用 Java 编写的 Python 解释器。这样你就可以同时利用两种语言的优点。你还可以在强大的 Java 应用程序框架中结合 Python清晰的语法来创建出依赖于两种语言库的应用程序。


语言扩展可以用 C 、 C++ 或 Java 为 Python 编写新的新言模块，如函数。或者与 Python直接编译在一起，或者采用动态库装入方式实现。也专门有人编写了一个工具，可以实现为 Python自动实现函数接口封装，这就是 SWIG （ Simplified Wrapper and Interface Generator) ，或称做简单封装和接口生成器 ( 可以在 http://www.cs.utah.edu/~beazley/SWIG自由获得 ) 。


互联网程序设计

Python 带有的标准模块可以对网络插槽进行初级和协议级别的通讯，比如，如果要从 POP 服务器上读取电子邮件， Python 随带的库模块可以做到。另外， Python 还支持 XML 、 HTML 和 CGI 库文件，所以利用它可以解析用户输入的需求，并通过网络服务器产生最佳质量的成果。程序员还可为拥有 Python 内置解释器的 Apache 、 Unix 和 Windows 网络服务器编译模块。基于 CGI 程序的功效，可以很方便地执行 Python 语句而不用单独装载。


数据库编程

Python 中有无数的扩充模块可以连接如 Orcle 、 Informix 、 mySOL 和 PostgreSql等通用的数据库系统；还有称作 Gadfly 的工具可以独立 Python 提供完全的 SQL 环境。 Python 有强大的文本和数据处理能力，可以用它作为不同数据库间的连接，比起那些数据库附带的总结和汇报工具显得更有优势。同时，由于它支持不同系统，用同样的接口也可以连接任何数据库。可以用 Tk 在支持平台上建立前端，马上就可获得高速跨平台、独立数据库的查询工具。


跨平台开发

Python 以中立方式支持不同的一系列平台，如果用户使用的系统包含不同的平台，使用 Python 开发应用程序则再好不过；它这种适应性也可以为系统预留使用其它工具的可能。对于频繁更换平台用户， Python 是个理想的选择。

为最终用户提供软件服务时， Python 也是个备选方案，可以避免同时用不同应用软件编程的时间和费用。


编码标准

严格的 Python 语法是初级程序员忽略这一强大编程语言的最主要原因。和大多数的其他面向 Web 脚本语言不同的是， Python 的空白排版不依赖于括号或者分号来表示语句结束，换行和占位符用来描述代码的可视结果。这种编程方式乍看之下令人感到厌烦，但却对你另有莫大的好处，这就是代码的可靠性。 Python 这种结构化是建立在下面的理论之上：开发者的工作时间机构财产中最有价值的财富。一旦你习惯了编写 Python 代码的规则。实际上你就习惯了一种内建的编码标准。这也正是大多数 Python 开发者所依赖的标准。

获取 Python

你可以从 http://www.python.org或者各类平台上的 Python版本。ActiveState网站也发布用于 Windows 、 Linux 和 Solaris等平台的 Python 库。


最简单的 Python 代码

下面我们举例说明 Python 。假设你目前使用的是 Windows 系统，而且已经安装了 Python ，请首先启动 IDLE ，也就是 Python 的 GUI 。现在处于 Python Shell 中（如果你在 UNIX类型的系统上就需要键入 python类型指示你的 Python 可执行文件）。接着在“ >>>”提示符下键入：>>>print “Hello World”

这个大家耳熟能详的程序就在屏幕上显示出结果，你还可以如下所示给变量赋值：>>>myvar = 42>>>print myvar

在上例中会显示结果 42。

环境信息可视化第二讲 PYTHONPython 相关连接

中文http://www.sunistudio.com/lythm/docs/boost/Python/index.html http://dohao.org/python/ http://python123.yeah.net http://diveintopython.org/cn/ http://www.cngnu.org/technology/05974786f6e6.html http://www.csdn.net/expert/Forum.asp?roomid=92&typenum=2 http://www.math.pku.edu.cn/teachers/lidf/docs/Python/python-tutorial.html http://youwu.51.net/minimal.html http://python.3322.net/ 英文http://www.python.org/ http://www.pythonware.com http://www.onlamp.com/python/ http://diveintopython.org/ http://www.stackless.com/ http://www.ddj.com/topics/pythonurl/ http://www.devshed.com/Server_Side/Python http://www.jython.org/ http://www.vex.net/parnassus/ http://py-howto.sourceforge.net/ http://www.uselesspython.com/ http://www.boost.org/libs/python/doc/ http://pygame.org/

环境信息可视化第二讲 PYTHONPython 相关书藉

• Python 语言入门 (Learnig Python ) • Python 核心编程 (Core Python Programming )• 深入学习： Python 程序开发 (Python Developer’s Handbook )• Python 程序员指南 • Python 编程指南• Python 2.1 宝典 • Python技术参考大全 • XML 与 Perl 、 Python 和 PHP 编程指南 • Zope指南

环境信息可视化第二讲 PYTHONPython 相关程序

• Zope 对象发布环境 :对象发布允许你生成动态内容。不象 HTML 页面或 CGI 程

序， Zope 是以对象的方式来看待一个 web 应用的。对象是小的内容与行为的混合体。 Zope 允许你将对象编写在一起来生成强大而又灵活的对象集。这些对象集可以对 web请求进行应答。结果就是动态内容。每个 Zope 对象感觉上是“聪明的”，它们是自适应的并且可以同其它对象进行通信。 Zope 对象是协同工作的。对象可以从其它的对象获得信息和行为。将对象联系在一起的方式决定了对于它们哪些服务和内容是有效的。对象适当地根据给定的上下文对象和内容表现自已。这就是发布 (publishing) 处理。

每一个 Zope 对象都是动态的，并且可以使用不同的方式来发布，从而展现不同的行为。


2.2 Python 快速入门2.2.0 安装与运行

python-2.4.2.exe


2.2.1 基本的运算式下面是 python 的简单例子，如果你学过其它的语言(如 C/C++, Java)，就能很容易的了解。

PYTHON提供了基本的数字类型，包括 integers , long integers , reals , 和 complex numbers

1 a = 02 b = 73 a = a + 14 a = b * a5 print a 结果显示 : 7

A+B A 加 B

A-B A 减 B

A*B A 乘 B

A/B A 除 B

A%B 取 A/B 的馀数 ( 如 8 % 3 == 2)

-A 取 A 的反数( 若 A == 7, -A == -7)

环境信息可视化第二讲 PYTHON2.2.2 基本数据类型与操作

（ 1 ） String

string 可以使用 ' 或 " 符号括起来表示。例 3是合并四个 string对象的例子，将四个 string 依顺连接成单一的 string。

1 a = 'hello'

2 b = "world"

3 c = a + ' ' + b + '!!'

4 print c

结果显示: hello world!!


1 a = '%s=%d' % ('test',16)

2 print a

结果显示: test=16

在例 1 ，类似於 C/C++ 的 printf 或 sprintf ， python 提供 string format 的功能。字串 '%s=%d' 指定 string 的 format ，而後在字串後接着 % 然後是 format 的参数，这些参数会依序取代 format 里的 %s 和 %d 。 %s 代表要取代字串， %d 则是取代成整数。


A = 'This is a rather long string containing\n\

several lines of text just as you would do in C.\n\

Note that whitespace at the beginning of the\n\

line is significant.\n'

string 可以延伸到数行，但在每一行的最後必需要有 escape \ 以忽略掉 newline 。另外也可以使用 """ 或 '''

a = '''This is a rather long string containing

several lines of text just as you would do in C.

Note that whitespace at the beginning of the line is

significant.'''

使用 ''' 或 """ 就不需要在每一行结数时附加 escape ，但在 string 内容中包含了 newline 。

环境信息可视化第二讲 PYTHON（ 2 ） List

1 a = [9] 2 a[0] = 'aoo' 3 a[1:3] = [10, 11] 4 b = [1, 2, 3, 'foo'] 5 print a, b, b[:3], b[1:] 结果显示 : [‘aoo’, 10, 11] [1, 2, 3, 'foo'] [1, 2, 3] [2, 3, 'foo']

上上面是 list 的使用范例。 list 是一个 sequence data type ，类於 C/C++ 的 array ，但 array 是 fixed length 而 list 不是，其长度是可以随时改变的。例 1 把变量 a 初始化为一个 list 。例 2 则指定 index 0 为 'aoo'的 string object 。例 3 为 list 的 slice 的使用范例。将 index 1 和 index 3 之间的 item(index 1 和 2) 代换成 10 和 11。例 5 的 b[:3] 则相当於 b[0:3]，而 b[1:] 相当於 b[1:4]。 list 内的 item 不需是相同的 type ，如上例在一个 list object 里可以同时包含整数和 string 不同 type 的 item 。


1 a = [1, 2, 3] + [4, 5, 6]

2 print a

结果显示 : [1, 2, 3, 4, 5, 6]

和 string 一样， list 也可以进行合并操作 (concatenate)。

环境信息可视化第二讲 PYTHONSlice

1 a = [ 1, 2, 3, 4, 5]

2 print a[3], a[3:], a[:2], a[:-1], a[-2]

结果显示 : 4 [4, 5] [1, 2] [1, 2, 3, 4] 4

index 可为负数，负数则从 list 的结束位置往回数。 list 的 index 可以比作下图，每一个 item 指 list 里的一个 object 。而 | 则为 item 之间的分界，其下方则为其 index 。 | item 0 | item 1 | item 2 | .... | item n | 0 1 2 3 n n+1 -n-1 -n -n+1 -n+2 -1

当指定 item k (0 <= k < n+1) ，则 index 设为 item k 的前一个分界 index k 。当指定 item k ～ item p (0 <= k <= p < n+1) 时，则 slice 指定为 [k:p+1] ( 意指 index k 和 index p+1 两个分界之间所有的 item) 或 [k:p-n]( 注 : p < n, p - n < 0 为负数 ) 。

环境信息可视化第二讲 PYTHONMethods for List

1 a = []

2 a.append(1)

3 a.append(2)

4 a.insert(1, 3)

5 print a

结果显示 : [1, 3, 2]

上面是 list 的 append() 和 insert() 两个 method 的使用范例。append 用以新增一个 item 到 list 的最後面。 insert 用以在指定的位置插入一个新的 item 。行 4即在 list 的 index 1 的位置 (即 item 0 和 item 1 之间 )插入一个新 item 。


1 a = [1, 3, 2]

2 a.sort()

3 print a,

4 a.reverse()

5 print a

结果显示 : [1, 2, 3] [3, 2, 1]

sort() method 能将 list 进行从小到大的排序， reverse() method 则进行从大至小的反向排序。


String vs liststring 也和 list 同为 sequence data type ，也可作 slice operator ，但 string 为 immutable object ，不可修改其内容。

1 a = 'hello world!!'

2 print a[-7:], a[:5]

结果显示 : world!! hello


1 a = 'hello'

2 print a[1]

结果显示 : e

string 也和 list 一样，可以 subscript (index) 其中的 item。python 并不像 C/C++ 般， python 没有独立的 character type ， string 的 subscripted item 为一长度为 1 的 string。


Nested listlist 里的 item 可以为另一个 list object ，成一个巢状的结构。

1 a = [ 1, 2, 3, [ 'abc', 'cde', 3, 2], 5]

2 print a[3][1]

结果显示 : cde


1 a = [1, 2, 3]

2 print len(a)

结果显示 : 3

len() 函数返回 sequence type object 的 size 。


（ 3 ） Tuple & multiple assignment

1 a = 'foo'

2 a, b, c = 9, 8, a

3 print a, b, c

结果显示 9 8 foo

行 2 称为 multiple assignment ，可以同时指定多个变量的内容。


1 a = 1, 2, 3, 4, 5

2 b = 1, 2, a[:3]

3 print a, b

结果显示 : (1, 2, 3, 4, 5) (1, 2, (1, 2, 3))

行 1 将变量 a赋值为 (1, 2, 3, 4, 5) 。 python 定义 (1, 2, 3, 4, 5) 为 tuple ，与 string 一样是 immutable sequence data type ，不能改变 tuple object 的内容。


a = 1, 2, 3, 4, 5 和 a = (1, 2, 3, 4, 5) 是相同的，称之为 tuple packing ，把 1, 2, 3, 4, 5 这几个 object 包成一个 tuple object 。

1 a, b, c = 1, 2, 3

2 (e, f, g) = 5, 6, 7

3 print a, b, c, d, e

结果显示 : 1 2 3 5 6 7

上面的操作称之为 tuple unpacking ，将等号右边的 sequence type object 解开成数个 object ，赋值给等号左边的变量。左边变量的个数必需和右边的 item 数目相同。


1 a = 'hello'

2 a, b, c, d, e = a

3 print d, e, a, b, c

结果显示 : l o h e l

在 multiple assignment 的右边可以为任何 sequence type 。


（ 4 ） Dictionary

1 tel = { 'tony': '111234', 988: 'common' }

2 print tel[988], tel['tony']

结果显示 : common 111234

这是 dictionary (assocative array) 的使用范例。可使用任一 immutable type object 为 key ，用以映射 (mapping)与之相关的 object 。


1 a = (1, 2)

2 b = (3, 4)

3 c = (1, 2)

4 d = { a: 'aaa', b: 'bbb' }

5 print d[a], d[b], d[c]

结果显示 : aaa bbb aaa

tuple 也为 immutable object ，所以也可作为 key 。因为 a 和 c 所 bind 的 object 为相同 value 的 immutable type object ，因此得到的结果是相同的。 tuple 为 key 时，其内容不可包含任何 mutable type object 。


1 a = { 'foo': 'aaa', 'boo': 999, 'coo': 887} 2 print a.keys() 结果显示 : ['boo', 'foo', 'coo']

keys() 为 dictionary 的 method ，传回包含所有 key 的 list object 。 key 的放置不依其次序。


1 a = { 'aaa': 9999, 'bbb', 8888 }

2 for i in 'aaa', 'bbb', 'ccc':

3 if a.has_key(i):

4 print a[i],

结果显示 : 9999 8888

has_key() 为 dictionary 的 method function ，用以判断 dictionary 是否包含某 key 。


1 a = { 1: 'aaa', 2: 'bbb', 3: 'ccc'}

2 del a[2]

3 b = ['aaa', 'bbb', 'ccc']

4 del b[1]

3 print a, b

结果显示 : { 1:'aaa', 3:'ccc'}

['aaa', 'ccc']

del 指含可以打断 object 和 key 之间的 binding ，并将 key 从 dictionary 去除。可以将 list 中的 elemnet 去除。


2.2.3 控制流程、函数与模块(1) 控制流程 IF 语句

1 if a <= b: 2 if c == d: 3 foo() 4 aoo() 5 else: 6 boo()

上面一个 if 的使用范例，在行 1，如果 a 小於等於 b 行 2～4 会被执行，否则行 6 会被执行。 python 并没有像 Pascal 使用 begin ... end 定义 block，也没有像 C 使用 { ... } 定义 block， python 直接使用缩排决定 statement 是否属於同一个 block。如行 1-4 因为缩排而成为一个 block，而行 2-3 也因为缩排而成为一个 block，每一个 block 则成为一个 compound statement 。


if statement 的语法规式为 :

if <expression>: .....

elif <expression>: ......

elif <expression>: ....

else: .......

如其它语言， elif 和 else 为选择性功能，elif => else if 。


WHILE 语句

1 while a >= b: 2 foo() 3 boo() 4 if c != d: break 5 if c >= d: continue 6 coo() 7 else: 8 doo() 9 eoo()

上面是 while loop 的使用范例，当 a >= b 时，行 2-6 会不断的一再执行，直到 a >= b 不成立时 (false) ，则执行行 8 ，然後继续往下执行 eoo() 。但，如果执行行 4 的 break ，则会无条件直接跳离 while loop ，不再执行 while loop 的任何内容 ( 包含 else 的部分 ) ，直接执行行 9 。若 while loop 中， continue 被执行，则程式会直接跳过後面的指令回到行 1 ，进行条件判断。


FOR 语句

1 for i in 1, 7, 3, 9:

2 print i,

结果显示 : 1 7 3 9

上面为 for loop 的使用法， for <name> in <sequence type object>: ....in 後面可为任何 sequence type object 。


1 for i in range(3):

2 print i,

3 print range(3)

结果显示 : 0 1 2 [0, 1, 2]

range(x) 会产生一个包含 0 ～ x-1 的 list 。


(2) 函数

1 def foo(a, b):

2 return a+b

3 print foo(3, 4)

结果显示 : 7

上面为 function 的定义方式，return 可返回 function 的执行结果。当行 3 执行 foo(3, 4) ， function foo 会被执行，然後返回 3+4 (a+b) 的结果。


1 def foo(a, b=2):

2 return a+b

3 print foo(3), foo(3,4)

结果显示 : 5 7

function 的参数可以定义预设值，设立预设值的参数如果调用时不给予，那麽会使用预设值。


1 def foo(a = []):

2 a.append(7)

3 return a

4 print foo(),

5 print foo()

结果显示 : [7] [7, 7]

预设值只会在 function 定义指令第一次被执行时进行计算，因此上例的 a 参数在第一次执行定义指令时，就将预设值 bind 到一个 list object ，之後使用预设值时就会 bind 到同一个 object ，因而产生记忆的现象，使第二次执行 foo() 所得到的结果受第一次执行的影向。


(3) 模块Python 的 source file 为 *.py 这样的形式，如 : foo.py, boo.py 。 Python 定义每一个 source file 为一个 Module 。下面两个 module : --- a.py ----

def foo():

return action+1

action = 9

--- a.py end ---

--- b.py ---

import a

print a.foo(), a.action

--- b.py ---

执行 'python b.py' ，结果显示 :

10 9


当需要使用到其它 module 时，可以使用 import 命令，将该 module import 到你的 name space 里。上例 b modlue 就 import a 这个 modlue ，当 b 执行 import 指令时，在 b 的 name space 里， a 这个 name 就会 bind 到一个 module object 。module 一但 load 进 memory 时，就以 module object 代表，以供进一步的使用。所有 module 里定义的 name(function ， object 或后面会介绍的 class)都会成为 module object 的 attribute 。透过使用 module object attribute ，我们可以 access module 内所定义之 name 。module attribute 的使用方式如上例， module 的 name 接着 '.' 接着 attribute 的 name 。每个 module 都有自己的 name space, 透过 module attribute ，我们可以 access 到其它 module 的 name space 。当 module 头一次被 load 进 memory 时， module 会被从头到尾执行一次。其执行的结果则定义了 module 的 name space ，使 name 和 object bind 在一起。如上例执行 a.py 中的 def foo(): .... 这个指令时，定义一个 function object ，并使之和 foo 这个 name 进行 binding 。


--- a.py ----

def foo():

return action+1

action = 9

--- a.py end ---

--- b.py ---

from a import *

print foo(), action

--- b.py ---

上例和前一个例子是相同的，但使用 from import * ，这个指令的作用是，把 module name space 里所有的 name ， import 到目前的 name space 里。 '*' 是指所有的 name ，如果只是要 import 特定的 name ，那麽你可以指定 name 替代 '*' ，如 from a import foo 。


2.2.4 类

(1) 类定义

用关键字 'class' 定义类：

class myclass: body

body 包含 Python 语句 , 一般是变量赋值和函数定义 . 类的实例对象通过直接调用类名函数创建 : instance = myclass()


Class instances can be used as structures or records. Unlike C structures, the fields of an instance do not need to be declared ahead of time, but can be created on the fly. The following short example defines a class called "circle", creates a circle instance, assigns to the "radius" field of the circle, and then uses that field to calculate the circumference of the circle.

>>> class circle: >>> pass >>> myCircle = circle() >>> myCircle.radius = 5 >>> print 2 * 3.14 * myCircle.radius

Like C and many other languages, the fields of an instance/structure are accessed and assigned to using "dot" notation.


成员的初始化：

Fields (and other aspects) of a newly created object can be initialized by defining an '__init__' method in the class. Fields of an instance can be initialized automatically by including an __init__ initialization function in the class body. This function is run every time a new instance of the class is created, with that new instance as its first argument. This example creates circles with a radius of 1 by default.


class circle: def __init__ (self):

self.radius = 1

myCircle = circle() print 2 * 3.14 * myCircle.radius. myCircle.radius = 5 print 2 * 3.14 * myCircle.radius


继承

class P: def setitP(self):

self.x = "Class P" def printitP(self):

print self.x class C(P):

def setitC(self): self.x = "Class C"

def printitC(self): print self.x


小结• 缩进特性• import 语句 import myMod ; from myMod import * • 赋值语句 aVar=123• 属性引用语句 obj.aData• 函数、方法调用语句 myFunc(...); obj.myMethod(...)

• 函数、方法定义 def myFunc(aParam):• 类定义 class myClass(aParentClass):

环境信息可视化第二讲 PYTHON特性描述

缩排 Python 格式中最有特色的东西，有了它风格统一，而且减少了不毕要的块包围符号

多种序列有列表，序组 (tuple) ，和字典（字符串可以看做序组）

序列乘法序列可以进行乘法，表示多个序列的组合。如： s=[1];s*3 为 [1,1,1]

序列分片序列可以通过分片进行切割，而且还可以进行序列的复制： s[:]

序列的负索引序列的索引可以为负数，表示后最后向前数。如： s=[1,2,3];s[-1]表示 3

动态语义这个特性大部分脚本语言都有，就是通过赋值来决定变量的类型。而且通过赋值可以改变变量的类型。

连续比较可以如下进行比较： 2< x< y<3

超长整数在整数后面加上 'l' 或 'L' 可以使用很大的整数，比 C 语言的整数还大。如 a=999999999999999999999L

同时赋值在 Python 中，可以一次给多个变量赋值，如： a,b=1,2

循环中的 else 在 Python 的循环语句中，可以有 else 字句，表示没有使用 break 语句退出循环，即循环正常结束时，要执行的语句。在 for,while 中均有。

异常中的 else 异常中也可有 else子句，表示未出现异常时执行的语句。与 finally 不一样， finally 是必需要执行的，而 else则是有条件执行的

格式输出中的关键字在 Python 的格式输出格式中，格式符可以用关键字参数。如 :"%(table)s" % {'table':'hello'}

模块、包 Python 中可以有模块，还可以有包。可以象 Java 一样导入。

语句动态生成可以写一个字符串，然后运行它。如： exec "x=2" 。还可以执行一个文件（动态生成） execfile() 。表达式使用 :eval() 。

属性的动态变化可以使用 getattr() 得到一个对象的属性，可以使用 setattr() 来修改过设置对象的新属性，使用 delattr() 删除对象的属性。有时还可以： a.newattr=attr 来设置新属性

真正的面象对象可以多态继承（有多个基类），可以有私有属性，类公共属性

基类的动态改变如果愿意你可以增加新的基类，从而使一个类拥有新的基类方法，而不用修改原来的基类

缺省参数值 Python 的函数可以使用缺省参数

关键字参数还支持关键字参数，如 a(name='abc')

函数的不定参数 Python 的函数支持不定参数。可以使用关键字参数，也可以不使用。

特殊的类方法类可以定义特殊的方法，支持逻辑操作，如 '+','*',[ i ]等

单行函数 Python支持单行函数： lambda x:x+1

列表映射对列表可以进行映射操作，如 ["%d" % x for x in range(10)]

嵌套函数可以象 pascal 一样写嵌套的函数，到了 2.1 以上变量的作用域也可以嵌套

对象的持续性一个对象可以保存起来，在需要时恢复

可编译成字节码象 Java 一样，可以将 Python 程序编译成字节码。

Documents

2.1 Python 概要