阅读任何一个module_*.py文件,最重要的是看文件头的注释部分,这实质说明了后面代码的一个模板.
例子:module_mission_templates.py文件开始部分的注释是:
# Each mission-template is a tuple that contains the following fields:
# 1) Mission-template id (string): used for referencing mission-templates in other files.
# The prefix mt_ is automatically added before each mission-template id
#
# 2) Mission-template flags (int): See header_mission-templates.py for a list of available flags
# 3) Mission-type(int): Which mission types this mission template matches.
# For mission-types to be used with the default party-meeting system,
# this should be 'charge' or 'charge_with_ally' otherwise must be -1.
#
# 4) Mission description text (string).
# 5) List of spawn records (list): Each spawn record is a tuple that contains the following fields:
# 5.1) entry-no: Troops spawned from this spawn record will use this entry
# 5.2) spawn flags.
# 5.3) alter flags. which equipment will be overriden
# 5.4) ai flags.
# 5.5) Number of troops to spawn.
# 5.6) list of equipment to add to troops spawned from here (maximum 8).
# 6) List of triggers (list).
# See module_triggers.py for infomation about triggers.
#
# Please note that mission templates is work in progress and can be changed in the future versions.
Python 2.4.2 (#67, Sep 28 2005, 12:41:11) [MSC v.1310 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> print "Hello World"
Hello World
>>>
切换行号显示
1 principal = 1000 # Initial amount (本金)
2 rate = 0.05 # Interest rate (利率)
3 numyears = 5 # Number of years (期数,年)
4 year = 1
5 while year <= numyears:
6 principal = principal*(1+rate)
7 print year, principal
8 year += 1
程序输出:
这个语句计算表达式的值，然后将计算结果赋给 principal 变量做为它的新值。当赋值动作发生时,principal最初绑定的值1000被丢弃。赋值结束，不但 principal 绑定的值发生了变化，它的类型也随着赋值动作发生了相应的变化。在这个例子中，由于rate是一个浮点数,所以在赋值完成后,principal也变成一个浮点数。
while 语句首先检查在它后边的循环条件,若条件表达式为真,它就执行冒号后面的语句块，然后再次测试循环条件，直至为假。冒号后面的缩近语句块为循环体。注意，Python语言使用缩进块来表示程序逻辑（其它大多数语言使用大括号等）。在Listing 1.1中while语句后的三条语句为循环体，在每次循环中均执行。Python并未指定缩进的空白(空格和制表符)数目，唯一的要求是同一层次的语句必须有相同的缩进空白。（注意，要么都是空格，要是么都制表符，千万别混用)
切换行号显示
1 # Compute the maximum (z) of a and b (得到a与b中较大的一个)
2 if a < b:
3 z = b
4 else:
5 z = a
if和else的语句块用缩近来表示，else从句在某些情况下可以省略。 如果if或else语句块只有一个语句，也可以不使用缩近。也就是说:
切换行号显示
1 if a<b: z=a
2 else: z=b
这样的写法也是合法的，但这不是推荐的作法。一直使用缩近可以让你方便的在语句体中添加一个语句，而且读起来更清晰。 若某个子句不需任何操作,就使用pass语句，如:
切换行号显示
1 if a < b:
2 pass # Do nothing
3 else:
4 z = a
通过使用 or,and 和 not 关键字你可以建立任意的条件表达式:
切换行号显示
1 if b >= a and b <= c:
2 print "b is between a and c"
3 if not (b < a or b > c):
4 print "b is still between a and c"
用 elif 语句可以检验多重条件(用于代替其它语言中的switch语句):
切换行号显示
1 if a == '+':
2 op = PLUS
3 elif a == '-':
4 op = MINUS
5 elif a == '*':
6 op = MULTIPLY
7 else:
8 raise RuntimeError, "Unknown operator"
1.4. 文件输入/输出
下面的程序打开一个文件,然后一行行地读出并显示文件内容:
切换行号显示
1 f = open("foo.txt") # Returns a file object
2 line = f.readline() # Invokes readline() method on file
3 while line:
4 print line, # trailing ',' omits newline character
5 line = f.readline()
6 f.close()
open()函数返回一个新文件对象(file object)。通过调用此对象的不同方法可以对文件进行不同的操作。readline()方法读取文件的一行(包括换行符'\n')。如果读到文件末尾，就返回一个空字符串。要将程序的输出内容由屏幕重定向到文件中，可以使用'>>'运算符，如下例:
切换行号显示
1 f = open("out","w") # Open file for writing
2 while year <= numyears:
3 principal = principal*(1+rate)
4 print >>f,"%3d %0.2f" % (year,principal) #将格式文本输出到文件对象 f
5 year += 1
6 f.close()
当然,文件对象也拥有write()方法，通过它可以向文件对象写入新的数据。例如上边例子中的print的语句也可以写成这样:
f.write("%3d %0.2f\n" % (year,principal))
1.5. 字符串
要创建一个字符串，你使用单引号,双引号或三引号将其引起来，如下例:
切换行号显示
1 a = 'Hello World'
2 b = "Python is groovy"
3 c = """What is footnote 5?"""
一个字符串用什么引号开头，就必须用什么引号结尾。两上三引号之间的一切都作为字符串的内容,对应的单引号与双引号却只能创建单行字符串。如下例：
切换行号显示
1 a = "Hello World"
2 b = a[4] # b = 'o'
要获得一个子串,使用切片运算符 s[i:j]。 它返回字符串 s 中从索引 i (包括i)到 j (不包括 j)之间的子串。若 i 被省略，python就认为 i=0，若 j 被省略，python就认为 j=len(s)-1:
切换行号显示
1 c = a[0:5] # c = "Hello"
2 d = a[6:] # d = "World"
3 e = a[3:8] # e = "lo Wo"
可以用加(+)运算符来连结字符串:
g = a + " This is a test"
通过使用str()函数,repr()函数或向后的引号(`)可以将其他类型的数据转换为字符串:
切换行号显示
1 s = "The value of x is " + str(x)
2 s = "The value of y is " + repr(y)
3 s = "The value of y is " + `y`
repr()函数用来取得对象的规范字符串表示，向后的引号(`)是repr()函数的快捷版。
切换行号显示
1 import sys # Load the sys module (导入sys模块)
2 f = open(sys.argv[1]) # Filename on the command line (从命令行读取文件名)
3 svalues = f.readlines() # Read all lines into a list (读出所有行到一个列表)
4 f.close()
5
6 # Convert all of the input values from strings to floats (把输入的值转换为浮点数)
7 fvalues = [float(s) for s in svalues]
8
9 # Print min and max values (输出最大值和最小值)
10 print "The minimum value is ", min(fvalues)
11 print "The maximum value is ", max(fvalues)
程序第一行用import语句从Python library中导入sys模块。
表达式 [float(s) for s in svalues] 通过循环列表svalues中的所有字符串并对每个元素运行函数float()来建立一个新的列表,这种特殊的建立列表的方法叫做列表包含( list comprehension)。 在列表中所有的字符串都转换为浮点数之后,内建函数min()和max()计算出列表中的最大值及最小值。
元组(tuple)类型和列表关系很密切,通过用圆括号中将一系列逗号分割的值括起来可以得到一个元组:
切换行号显示
1 a = (1,4,5,-9,10)
2 b = (7,) # 一个元素的元组 (注意一定要加一个额外的逗号！)
3 person = (first_name, last_name, phone)
在某些时候，即使没有圆括号, Python仍然可以根据上下文认出这是一个元组，如: (为了写出更清晰可读的程序，建议你不要依赖 Python 的智能)
a = 1,4,5,-9,10
b = 7,
person = first_name, last_name, phone
元组支持大多数列表的操作,比如索引,切片和连结。一个关键的不同是你不能在一个tuple创建之后修改它的内容。也就是说,你不能修改其中的元素,也不能给tuple添加新的元素。
1.7. 循环
通过使用while语句，我们在前面已经简单介绍了 while 循环。在Python中另一种循环结构是 for 循环，它通过 迭代 一个序列(例如字符串,列表,或者tuple等)中的每个元素来建立循环。下边是一个例子:
for i in range(1,10):
print "2 to the %d power is %d" % (i, 2**i)
range(i,j)函数建立一个整数序列,这个序列从第 i 数开始(包括 i )到第 j 数为止(不包括 j)。若第一个数被省略，它将被认为是0。该函数还可以有第三个参数，步进值，见下面的例子:
a = range(5) # a = [0,1,2,3,4]
b = range(1,8) # b = [1,2,3,4,5,6,7]
c = range(0,14,3) # c = [0,3,6,9,12]
d = range(8,1,-1) # d = [8,7,6,5,4,3,2]
for语句可以迭代任何类型的序列:
a = "Hello World"
# Print out the characters in a
for c in a:
print c
b = ["Dave","Mark","Ann","Phil"]
# Print out the members of a list
for name in b:
print name
range()函数根据起始值，终止值及步进值三个参数在内存中建立一个列表，当需要一个很大的列表时,这个既占内存又费时间。为了克服它的缺点,Python提供了xrange()函数:
for i in xrange(1,10):
print "2 to the %d power is %d" % (i, 2**i)
a = xrange(100000000) # a = [0,1,2, ..., 99999999]
b = xrange(0,100000000,5) # b = [0,5,10, ...,99999995]
xrange()函数只有在需要值时才临时通过计算提供值，这大大节省了内存。
if a.has_key("username"):
username = a["username"]
else:
username = "unknown user"
上边的操作还可以用更简单的方法完成:
username = a.get("username", "unknown user")
字典的keys() 方法返回由所有关键字组成的列表:
k = a.keys() # k = ["username","home","uid","shell"]
del语句可以删除字典中的特定元素:
del a["username"]
1.9. 函数
在Python中，使用def语句来创建函数，如下例:
def remainder(a,b):
q = a/b
r = a - q*b
return r
要调用一个函数，只要使用函数名加上用括号括起来的参数就可以了。比如result = remainder(37,15),如果你打算让函数返回多个值，就让它返回一个元组好了。（当然，只要你愿意，让它返回一个列表我们也不会介意)
def divide(a,b):
q = a/b # If a and b are integers, q is an integer
r = a - q*b
return (q,r)
当返回一个 tuple 时，你会发现象下面这样调用函数会很有用:
quotient, remainder = divide(1456,33)
你也可以象下面这样给函数的参数指定一个默认值:
def connect(hostname,port,timeout=300):
# Function body
若在函数定义的时候提供了默认参数，那么在调用函数时就允许省略这个参数：
切换行号显示
1 s = Stack() # Create a stack (创建)
2 s.push("Dave") # Push some things onto it (写入)
3 s.push(42)
4 s.push([3,4,5])
5 x = s.pop() # x gets [3,4,5] (读取)
6 y = s.pop() # y gets 42
7 del s # Destroy s (删除)
切换行号显示
1 # file : div.py
2 def divide(a,b):
3 q = a/b # If a and b are integers, q is an integer
4 r = a - q*b
5 return (q,r)
要在其它的程序中使用这个模块，使用import语句:
import div
a, b = div.divide(2305, 29)
import语句创建一个新的名字空间，该空间包含模块中所有定义对象的名称。要访问这个名字空间，把模块名作为一个前缀来使用这个模块内的对象，就像上边例子中那样:div.divide()
如果你希望使用一个不同的模块名字访问这个模块，给import语句加上一个 as 模块名 部分就可以了:
import div as foo
a,b = foo.divide(2305,29)
如果你只想导入指定的对象到当前的名称空间,使用 from 语句:
from div import divide
a,b = divide(2305,29) # No longer need the div prefix (不再需要div前缀)
