第三部分python的语句与语法
目录
Breank, continue, pass 和循环else. 9
第10章 python语句简介
要点
l Python中新的语法成分是冒号（：）
l 一行的结束会自动终止现在该行的语句
l 缩进的结束就是代码块的结束。
l 当一行中出现多行语句时用分号(;)隔开。
l 如果一条语句横跨多行，你只需用一对 括号，方括号，大括号 括起来就行了。
例如：
| if(x<y and y<z): Print('true') | If[x<y and y<z]: Print('true') | If{x<y and y<z}: Print('true') |
l 复合语句的主体可以出现在python的首先冒号之后，但只有当复合语句本身不包含任何复合语句的时候才能这样做，也就是单语句。例如 if x>y : print(x)
| while True: reply = raw_input('Enter text:') if reply == 'stop': break elif not reply.isdigit(): print('Bad!' * 8) else: print(int(reply) ** 2)
| while True: reply = raw_input("Enter text:") if reply == 'stop' : break try: num = int(reply) except: print('bad!' * 8) else: print(num ** 2) |
由上例，从语句嵌套观点来看，因为try, except以及else这些关键字全都缩进在同一层次上，它们全都被视为单个try语句的一部分。注意：else部分是和try结合，而不是和if结合。在python中， else可出现在if 语句中，也可以出现在try语句以及循环中----其缩进会告诉你它属于哪个语句。
第11 章 赋值，表达式和打印
赋值语句
特性：
1. 赋值语句总是建立对象的引用值而不是复制对象，因此python变量更像是指针，而不是数据存储区域。
2. 变量名首次赋值时会被创建。
3. 变量名在引用前必须先被赋值
4. 隐式赋值语句import, from, def, class, for, 函数参数。
举例
>>> a, b = 'a', 'b'
>>> [x, y] = ['x','y']
>>> e, f, m, n ='spam'
#将序列'spam'中每一项分别赋值给变量名的元组（e, f, m, n）
#注意=号左右变量名与序列长度要相一致，否则出错。
>>> z1 = z2 = 'zzz'
>>> a, b, e, f, m, n,z1, z2
('a', 'b', 's', 'p', 'a', 'm','zzz', 'zzz')
高级序列赋值语句模式
>>> string = 'SPAM'
>>> a, b, c =string[0], string[1], string[2:] #分解序列stirng为三个元素
>>> a, b, c
('S', 'P', 'AM')
>>> a, b, c =list(string[:2]) + [string[2:]]
#用list内置函数将序列前2个元素转换为列表，再加上用[]转换的列表(元素是string[2:])，然后组成一个三个元素的列表赋值给变量组a, b, c
>>> a, b, c
('S', 'P', 'AM')
>>> a, b = string[:2]
>>> c = string[2:]
>>> a, b, c
('S', 'P', 'AM')
>>> (a, b), c =string[:2], string[2:]
>>> a, b, c
('S', 'P', 'AM')
列表分解赋值
>>> l = [ 1,2,3,4]
>>> while l:
front, l = l[0], l[1:] #每次循环都会重新分配列表l，这其实等于 front= l[0] ; l = l[1:]
print(front, l)
(1, [2, 3, 4])
(2, [3, 4])
(3, [4])
(4, [])
>>> range(3) #range内置函数会产生连续的整数列表。
[0, 1, 2]
# 以上这个程序使用列表作为一种堆栈的数据结构。也可通过列表对象的append和pop方法来实现。在这里front = l.pop(0)
多目标赋值语句以及共享引用
>>> a = b = c ='spam' #这里只有一个对象'spam' 由三个变量共享
>>> a, b, c
('spam', 'spam', 'spam')
>>> a = b = 0 #因为数字不支持在原处修改，只要赋值的对象是不可变的，即使有一个以上的变量名使用该对象也无所谓。
>>> b = b + 1
>>> a, b
(0, 1)
>>> a = b = [] #因为[]列表对象是可变的, 所以b发生了改变，a 由于引用了,所以也变了
>>> b.append(28)
>>> a, b
([28], [28])
>>> a = [] # a和b分别创建不同的对象，所以一方改变不影响另一方。
>>> b = []
>>> b.append(32)
>>> a, b
([], [32])
增强赋值语句
>>> l = l + [5,6] #合并运算必须建立新的对象，赋值给l
>>> l
[5, 6]
>>> l.extend([7, 8]) #extend会在原处内存块的末尾增加元素
#Python会自动调用较快的extend方法来完成合并操作。
>>> l
[5, 6, 7, 8]
>>> l += [1, 2] # +=隐含了对列表进行原处修改的意思。
>>> l
[5, 6, 7, 8, 1, 2]
>>> m = l
>>> l = l + [3,4] #因为使用了合并操作会创建新的对象赋给l，而m还引用原先的没改变
>>> m
[5, 6, 7, 8, 1, 2]
>>> l
[5, 6, 7, 8, 1, 2, 3, 4]
变量命名规则
区分大小写，以下划线和字母开头。只能由下划线，字母，数字组成。
命名惯例
1， 以单下划线开头的变量名( _X )不会被from module import * 语句导入
2, 前后有下划线的变量名( __X__ )是系统定义的变量名,对解释器有特殊意义.
3, 以两下划线开头,但结尾没有的变量名( __X ) 是类的本地变量
4, 通过交互模式运行时,只有单个下划线的变量名( _ )会保存最后表达式的结果.
5, 类变量名通常以一个大写字母开头, 而模块名以小写字母开头.
6, 变量名 self 虽然并非保留字,但类中一般都有特殊的角色.Open = 2是可以的但不要用
7, 变量名没有类型, 但对象有, 在不同的时刻把相同变量名赋值给不同类型的对象,是允许
表达式
通常两种情况下表达式作语句使用:
调用函数和方法
在交互模式提示符下打印值
>>> L = L.append(4)
对列表调用append, sort或reverse这类原处修改的运算后,这些方法在列表修改后并不会把列表返回,事实上,它们返回的是None对象 .
新的内建函数sorted会排序任何序列，并传回有排序结果的新列表因为这并不是在原处修改，将其结果赋值给变量名。
打印语句
Print语句只是python的人性化的特性,提供了sys.stdout对象的简接口, 再加上一些默认的格式设置.
>>> import sys
>>> sys.stdout.write('helloworld\n')
hello world
重定向输出流
通常print和sys.stdou的关系如下:
>>>print( x )
等于:
Import sys
Sys.stdout.write(str(x) + '\n')
当把sys.stdou重新赋值给标准输出流以外的东西时,就可以让print语句将文字传送到你指定的位置.
>>>import sys
>>>sys.stdout = open('c:\\log.txt', 'a')
>>>print('kangqiao') #这时你的c盘下就存在了一个log.txt文件,里面保存了kangqiao
当print语句以>>开始,后面再跟着输出的文件对象时,该print语句可以将其文字传给该对象的write方法,但是不用重设sys.stdout, 因为这种重定向是暂时的.
>>> log =open('c:\\log.txt', 'a')
>>> x, y = 'spam','bad'
>>> print >> log,x, y
>>> print(x, y)
('spam', 'bad')
>>> log.close()
这种pirnt的扩展形式通常也用于把错误讯息打印到标准错误流sys.stderr
>>> import sys
>>>sys.stderr.write(('Bad!' * 8) + '\n')
Bad!Bad!Bad!Bad!Bad!Bad!Bad!Bad!
>>> print >>sys.stderr, 'Bad!' * 8
Bad!Bad!Bad!Bad!Bad!Bad!Bad!Bad!
注意: 在python 3.0中, print语句将变为内置函数,功用相同, 但语法略有不同,目标谁的和列结尾行为是由关键词参数赋值的,例如 : 语句print x, y 会变成调用 print(x, y), 而print >> f, 会变成print(x, file=f, end=' ').
Python中的raw_input()函数会从sys.stdin文件中读入，所以可以用类似的方法拦截对输入的请求
>>> raw_input()
nihao
'nihao'
第12章 if测试
实际上, elif和else部分可以省略，而且每一段中可以嵌套一个以上的语句。注意if，elif以及else结合在一起的原因在于它们垂直对齐， 具有相同 的缩进。
Python中没有switch或case语句。
x = 'killerrabbit'
if x == 'roger':
print("how's jessica?")
elif x == 'bugs':
print("what's up doc?")
else:
print('Run away! Run away!')
Run away! Runaway!
>>> choice = 'ham'
>>> print{'spam': 1.25,
'ham':1.99,
'eggs':0.99,
'bacon': 1.10}[choice] #这有些像switch，这个字典是多路分支，根据键的选择进行索引。
1.99
>>> branch = {'sapm': 1,
'ham': 2,
'eggs': 3}
>>> print(branch.get('spam', 'Badchoice'))
#字典默认值能够通过has_key测试， get方法调用或异捕捉来处理。
Bad choice
>>> print(branch.get('bacon', 'Badchoice'))
Bad choice
Python语法规则
1. 语句是逐个运行的，除非你不这样编写
2. 块和语句的边界会自动被检测
3. 复合语句=首行+ “：”+缩进语句
4. 空白行，空格以及注释通常都会被忽略。
5. 文档字符串(docstring)会被忽略，但会被保存并由工具显示
代码块分隔符与语句的分隔符
任何特定单一块中的所有 语句都必须缩进到时相同的层次否则python会报告错误
如果 使用语法括号对，语句就可以横跨数行。() [] {}
如果语句以反斜线结尾，就可以横跨数行
三重引号字符串常量可以横跨数行。
其他规则: 用分号终止语句，注释和空白行可以出现在文件的任意之处。
特殊情况：
if a == b and c == d and \
d == e andf == g:
print('olde')
if(a == b and c == d and
d == e ande ==f):
print('new')
>>> x = 1; y = 2; print(x)
1
>>> if 1: print('hello')
hello
>>>
任何非零数字或非空对象都是真
数字零，空对象以及特殊对象None都被认为是假
比较和相等测试会递归地应用在数据结构中
比较和相等测试会返回True或False（1和0的特殊版本）
布尔and和or 运算会返回真或假的操作对象 。
Python中有三种布尔运算符： and or not
And和or运算符总会返回对象，不是运算符左侧的就是右侧的。
>>> 2 or 3, 3 or 2
(2, 3)
>>> [] or 3
3
>>> [] or {}
{}
>>> {} or []
[]
>>> 2 and 3, 3 and 2
(3, 2)
>>> [] and {}
[]
>>> 3 and []
[]
从上面我们看到and和or总是返回那个导致结果 的对象。
If / else 三元表达式
>>> x, y, z = 0, 1, 2
>>> a = y if xelse z
>>> a
2 # 这是三元的结果，它等同于下面的判断。
>>> if x:
a = y
else:
a = z
bool函数总是会把一个表达式或对象返回1或0
>>> ['f', 't'][bool('sapm')]
't'
>>> ['f', 't'][bool('')]
'f'
x = a or bor c or None
由于 or 的短路特性，x 总是返回a, b, c中第一个非空的值，当a, b, c 都为空时它就取最后的None作为默认值。这是python中相当决的编码手法。
第13章 while和for 循环
While循环
一般格式
While<test>:
<statements1>
Else:
<statemnets2>
举例：
>>> a = 0; b = 10
>>> while a < b:
printa,
a +=1
0 1 2 3 4 5 6 7 8 9
Breank, continue, pass 和循环else
| Break: 跳出最近所在的循环(跳出整个循环) |
| Continue：跳出最近所在循环的开头处(来到时循环的道行) |
| Pass: 什么事也不做，只是空占位符 |
| 循环else块：只有当循环正常离开时都会执行（也就是没有碰到break语句） |
一般格式：
While<test1>:
<statements1>
If<test2>: break
If<test3>: continue
Else:
<statements2>
举例:
如果想写个无限循环,每次迭代时什么也不做,就写个pass.
>>> x
0
while x > 1:
if y% x == 0:
print(y,'has factor', x)
break
x = x- 1
else:
print(y,'is prime')
(1, 'is prime')
#######################
>>> x = 2
>>> while x :
print(x)
x = x- 1
else:
print("else")
2
1
Else #因为循环中没有碰到break语句所以会打印else部分.
简而言之, 如果循环文体没有执行过,循环else分句也会执行, 因为你没有其中执行break语句,在while循环中,如果执行的测试一开始就是假,就会发生这种问题.
For循环
For循环是一个通用的序列迭代器,: 可以遍历任何有序的序列对象内的元素, for语句可用于字符串, 列表, 元组, 其他内置可迭代对象以及之后我们能够通过类所创建的对象 .
格式 :
For <target> in <object>:
<statements>
If<test>: break
If<test>: continue
Else:
<statements>
举例:
>>>prod = 1
>>>for item in [1, 2, 3, 4] : prod *= item
>>>prod
24
>>> sum = 0
>>> for x in [1, 2, 3, 4]:
sum =sum + x
>>> sum
10
在for循环中的元组赋值
如果迭代元组序列,循环目标本身实际上可以是目标元组.
>>> t = [(1, 2), (3, 4), (5, 6)]
>>> for (a, b) in t:
print(a,b)
(1, 2)
(3, 4)
(5, 6)
嵌套for循环
>>> tests = [(4, 5), 3.14]
>>> items = ['aaa', 111, (4, 5), 2.01]
>>> for key in tests:
foritem in items:
ifitem == key:
print(key,'was found')
break
else:
print(key,'not found')
((4, 5), 'was found')
(3.14, 'not found')
################
>>> for key in tests:
ifkey in items:
print(key,'was found')
else:
print(key,'not found')
((4, 5), 'was found')
(3.14, 'not found')
迭代器: 初探
For循环可以用于python中任何序列类型, 包括,元组以及字符串
For 循环甚至比这还要更为通用:可用于任何可迭代的对象.
文件迭代器
每次调用readline方法时，就会前进到时下一列，到达文件末尾时就会返回空字符串，我们可通过 它来检测，从而跳出循环。
Next方法：与readline一样每次调用时都会返回文件中的下一行，唯一的区别在于, 当到达文件末尾时，next是引发内置的StopIteration异常，而不是返回空字符串。
值得注意的是这个next接口就是python中所谓的迭代协议：有next方法的对象会前进到下一个结果，而在一系列结果的末尾时， 会引发StopIteration，在python中任何这类对象都认为是可迭代的。任何这类对象也能以for循环或其他迭代工具遍历，因为所有迭代工具内部工作起来都是在每次迭代中调用next，并且捕捉StopIteration异常来确定何时离开。
>>> for line in open('c:\\log.txt'):
printline.upper(), #注意这后面有个逗号，当不加时输出会导致每行之间都有个空行, 不解
KANGQIAO
ABC KANGQIAO
45676
HELLO WORLDHW
上述方式是读取文件的最佳方式,
当你使用readlines()方法时,也能用,但这个版本其实是一次把整个文件加载到内存,如果文件太大,以至于计算机内存空间不够,甚至不能够工作,
其他内置迭代器
>>> l = [1, 2, 3]
>>> I = iter(l)
>>> I.next(), I.next(), I.next()
(1, 2, 3)
>>> I.next() #已经没有下一个元素了，所以抛出异常
Traceback (most recent call last):
File"<pyshell#13>", line 1, in <module>
I.next()
StopIteration
>>> D = {'a': 1, "b": 2, 'c': 3}
>>> for key in D.keys():
printkey, D[key]
a 1
c 3
b 2
#字典有一个迭代器，在迭代环境中，会自动返回一个键。所以不需要keys()，
这也是字典优化后的最佳迭代方案
>>> for key in D:
printkey, D[key]
a 1
c 3
b 2
其他迭代环境
每一种由左至右扫描对象的工具都会使用迭代协议。
>>> for line in open('c:\\log.txt'): #原始输出
printline,
kangqiao
abc 126.com
45676
hello worldhw
>>> uppers = [line.upper() for line inopen('c:\\log.txt')] #用方括号组成列表。
>>> uppers
['KANGQIAO\n', 'ABC 126.COM\n', '45676\n', 'HELLOWORLDHW\n']
>>> map(str.upper, open('c:\\log.txt')) #map函数的第一个参数为一个函数指针。
['KANGQIAO\n', 'ABC 126.COM\n', '45676\n', 'HELLOWORLDHW\n']
>>> 'kangqiao\n' in open('c:\\log.txt') #判断文件中’c:\\log.txt’是否存在字符’kangqiao’
True
>>> 'HELLO WORLDHW\n' in open('c:\\log.txt')
False
>>> sorted(open('c:\\log.txt')) #排序c:\\log.txt文件中的每一行.
['45676\n', 'abc 126.com\n', 'hello worldhw\n','kangqiao\n']
>>> list(open('c:\\log.txt')) #用list函数组成列表
['kangqiao\n', 'abc 126.com\n', '45676\n', 'helloworldhw\n']
>>> tuple(open('c:\\log.txt')) #用tuple组成元组
('kangqiao\n', 'abc 126.com\n', '45676\n', 'helloworldhw\n')
>>> '&&'.join(open('c:\\log.txt')) #用’&&’字符串的join方法连接文件中的每一行.
'kangqiao\n&&abc126.com\n&&45676\n&&hello worldhw\n'
>>> a, b, c, d = open('c:\\log.txt') #将文件中的每一行分别赋值给变量a, b, c, d.但要注意一一对应啊.
>>> a, b
('kangqiao\n', 'abc 126.com\n')
循环计数器 while和range
>>> range(5), range(2, 5), range(0, 10, 2)#当有三个参数时,第三个参数代表步进.
([0, 1, 2, 3, 4], [2, 3, 4], [0, 2, 4, 6, 8])
>>> range(-5, 5)
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
>>> range(5, -5, -1)
[5, 4, 3, 2, 1, 0, -1, -2, -3, -4]
>>> for i in range(3): #迭代三次
printi, 'pythons'
0 pythons
1 pythons
2 pythons
>>> x = 'spam'
>>> for item in x: print item, #遍历序列中的第一个元素
s p a m
>>> i = 0
>>> while i < len(x): #变通的下标迭代
printx[i], ; i += 1
s p a m
>>> x
'spam'
>>> len(x)
4
>>> range(len(x))
[0, 1, 2, 3]
>>> for i in range(len(x)): print x[i], #迭代长度为len(x)
s p a m
>>> for item in x: print item,
s p a m
>>> s = 'abcdefghijk'
>>> range(0, len(s), 2)
[0, 2, 4, 6, 8, 10]
>>> for x in s[::2]: print x, #首先改变列表,然后打印每一个元素
a c e g i k
>>>
并行遍历 zip 和 map
内置函数zip让我们使用for循环来并行使用多个序列. Zip会取得一个或多个序列为参数, 然后返回元组的列表, 将这些序列中的并排的元素配成对.
>>> L1 = [1, 2, 3, 4]
>>> L2 = [5, 6, 7, 8]
>>> zip(L1, L2)
[(1, 5), (2, 6), (3, 7), (4, 8)]
>>> for (x, y) in zip(L1, L2): #这个for循环在这里使用元组赋值运算以分解zip结果中的每个元组.
printx, y, '--', x + y
1 5 -- 6
2 6 -- 8
3 7 -- 10
4 8 – 12
# zip可以接受任何类型的序列(也就是任何可迭代对象,包括文件)并且可以有两个以上的参数.
>>> T1, T2, T3 = (1, 2, 3), (4, 5, 6), (7,8, 9)
>>> zip(T1, T2, T3)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> s1 = 'abc'; s2 = 'xyz123'
>>> zip(s1, s2)
[('a', 'x'), ('b', 'y'), ('c', 'z')]
#当参数长度不同时, zip会以最短序列的长度为准来截断所得到的元组. 相比较旧的内置map函数, 用类似方式把序列元素配对起来, 但是如果参数长度不同,则会以较短的序列用None补齐.
>>> map(None, s1, s2)
[('a', 'x'), ('b', 'y'), ('c', 'z'), (None, '1'),(None, '2'), (None, '3')]
使用zip构造字典
>>> keys = ['sapm', 'egggs', 'toast']
>>> vals = [1, 3, 5]
>>> zip(keys, vals)
[('sapm', 1), ('egggs', 3), ('toast', 5)]
>>> D2 = {}
>>> for(k, v)in zip(keys, vals): D2[k] = v#用列表keys做键, 用vals做值
>>> D2
{'egggs': 3, 'sapm': 1, 'toast': 5}
>>> D3 = dict(zip(keys, vals)) #内置变量名dict其实是python中的类型名称
>>> D3
{'egggs': 3, 'sapm': 1, 'toast': 5}
产生偏移和元素: enumerate
Enumerate函数返回一个生成器对象: 这种对象支持本章前面提过的迭代协议.
这个对象有个next方法, 每次遍历列表时, 会返回一个(index, value)的元组, 而我们能在for中通过元组赋值运算将其分解(这很像使用zip).
>>> s = 'spam'
>>> for (offset, item) in enumerate(s):
printitem,'appears at offfset', offset
s appears at offfset 0
p appears at offfset 1
a appears at offfset 2
m appears at offfset 3
>>> E = enumerate(s)
>>> E.next()
(0, 's')
>>> E.next()
(1, 'p')
>>> [ c * i for (i, c) in enumerate(s)]
['', 'p', 'aa', 'mmm']
列表解析:初探
note: 列表解析是写在方括号中的.
>>>L = [1, 2, 3, 4]
>>>L = [x + 10 for x in L]
>>>L
[11, 12, 13,14]
列表解析基础
列表解析语法是从集合理论表示法中的一种结构中衍生出来的, 也就是对集合中的每个元素应用某一种运算, 但不需要懂得集合理论就能运用.
Python会在解释器内通过列表来执行迭代, 依次把item赋值给每个元素, 然后通过左侧的表达式运行每一个元素并且存储其结果 .
对文件使用列表解析
>>> lines = [ line.rstrip() for line inopen('c:\\log.txt')]
>>> lines
['kangqiao', 'abc 126.com', '45676', 'helloworldhw']
列表解析会自动使用前面提到过的迭代协议，也就是调用文件的next方法，一次从文件中读取一行，再通过rstrip表达示执行这行，再将其加到结果列表中。
扩展列表解析语法
>>> lines = [line.rstrip() for line inopen('c:\\log.txt') if line[0] == 'k']
#if过滤分句会检查每行第一个字母如果为’k’才会将这一行加入列表。
>>> lines
['kangqiao']
复杂形式的双重循环。
>>> [x + y for x in 'abc' for y in 'lmn']
['al', 'am', 'an', 'bl', 'bm', 'bn', 'cl', 'cm','cn']
#下面是其展开的形式，
>>> res = []
>>> for x in 'abc':
for yin 'lmn':
res.append(x+ y)
>>> res
['al', 'am', 'an', 'bl', 'bm', 'bn', 'cl', 'cm','cn']
上面使列表解析表达式本身的优点变得过于紧凑。一般来说，列表解析都是用在简单的迭代类型上
第14章Python文档资源
#注释 文件中的文档 只能在源码文件中看到
Dir函数 对象中可用属性的列表
文档字符串：__doc__ 附加在对象上的文件中的文档
PyDoc：help函数 对象的交互帮助
PyDoc: HTML报表 浏览器中的模块文档
标准手册 正式的语言和库的说明
网站资源 在线教程，例子等
#注释最适用于较小功能的文档， 而文档字符串最适于较大型功能的文档。
Dir函数是抓取对象内可用所有属性列表的简单方式，
>>> import sys
>>> dir(sys) #找出标准库中sys模块有什么可以用的属性
['__displayhook__', '__doc__', '__excepthook__','__name__', '__package__', '__stderr__', '__stdin__', '__stdout__','_clear_type_cache', '_current_frames', '_getframe', '_mercurial','api_version', 'argv', 'builtin_module_names', 'byteorder', 'call_tracing','callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode','exc_clear', 'exc_info', 'exc_traceback', 'exc_type', 'exc_value','excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info','float_repr_style', 'getcheckinterval', 'getdefaultencoding','getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount','getsizeof', 'gettrace', 'getwindowsversion', 'hexversion', 'long_info','maxint', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path','path_hooks', 'path_importer_cache', 'platform', 'prefix', 'py3kwarning','setcheckinterval', 'setprofile', 'setrecursionlimit', 'settrace', 'stderr','stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoptions','winver']
任何内置类型的dir结果都包含了一组属性，这些属性和该类型的实现相关(从技术角度来讲，就是运算符重载的方法)
文档字符串 __doc__
这类注释是写成字符串，放在模块文件，函数以及类语句的顶端，就在任何可执行程序代码前（#注释在其前也没问题）。Python会自动封装这个字符串，也就是成为所谓的文档字符串，使其成为相应对象的__doc__属性。例如：docstrings.py源码如下：
############docstring.py-20121127-begin###############
"""
Module documentation
Words Go Here
"""
spam = 40
def square(x):
"""
functiondocumentation
can wehave your liver then?
"""
return x**2
class employee:
"class documentation"
pass
print square(4)
print square.__doc__
############ docstring.py-20121127-end###############
>>> import docstring
16
functiondocumentation
can wehave your liver then?
>>> print docstring.__doc__
Module documentation
Words Go Here
>>> print docstring.square.__doc__
functiondocumentation
can wehave your liver then?
>>> print docstring.employee.__doc__
class documentation
>>>
要取出模块中类的方法函数的文档字符串, 可以通过路径访问类:module.class.method.__doc__
内置文档字符串
>>> import sys
>>> print sys.__doc__ #查看内置sys模块文档注释
This module provides access to some objects used ormaintained by the
interpreter and to functions that interact stronglywith the interpreter.
Dynamic objects:
……
>>> print open.__doc__ #查看open函数的文档注释.
open(name[, mode[, buffering]]) -> file object
Open a file using the file() type, returns a fileobject. This is the
preferred way to open a file. See file.__doc__ for further information.
>>>
PyDoc: help函数
Help函数会启用PyDoc从而产生简单的文字报表(这看地来就像是类UNIX系统上的message)
>>> import sys
>>> help(sys.getrefcount)
Help on built-in function getrefcount in modulesys:
getrefcount(...)
getrefcount(object) -> integer
Returnthe reference count of object. The countreturned is generally
onehigher than you might expect, because it includes the (temporary)
referenceas an argument to getrefcount().
>>>
注意: 调用help时, 不用导入sys, 但是要取得 sys的辅助信息时,就得导入sys
>>>help(docstring.square) #显示docstrign.py文件中的文档.
Help on function square in module docstring:
square(x)
functiondocumentation
can wehave your liver then?
#如下会显示整个docstring.py文件中的所有文档
>>> help(docstring)
Help on module docstring:
NAME
docstring
FILE
c:\python27\docstring.py
DESCRIPTION
Moduledocumentation
Words GoHere
CLASSES
employee
classemployee
| class documentation
FUNCTIONS
square(x)
function documentation
canwe have your liver then?
DATA
spam = 40
执行PyDoc GUI接口, 保持模块名称空白, 伏兵选择”open browser”, 这样会打开一个网页,其中包含了程序中每个可用模块的链接.
常见编写代码的陷阱
1. 别忘了冒号: 在复合语句道行末尾输入”:”
2. 从第1行开始: 要确定顶层程序从代码第1行第1格开始,这包括在交互模式下
>>> print 'abc'
File "<pyshell#30>", line 1
print 'abc'
^
IndentationError: unexpected indent
>>>
3. 空白行在交互模式提示符下很重要: 模块文件中的复合语句内的空白行会被忽视, 但交互模式下会认为是结束语句
4. 缩进要一致: 避免在块缩进中混合制表符和空格, 建议全都使用空格
5. 不要在python中写c代码,
a) 不要在if和while首行测试语句中使用括号, 例如if(x ==1): 建议用if x == 1:
b) 不要以分号终止所有的语句,
c) 不要在while循环测试中嵌入赋值语句,
d) 不要在块周围使用{}要改用一致的缩进.
6. 使用简单的for循环,而不是while或range:
a) 比起while或者range式的计数器循环来讲,简单for循环总是容易写,运行也更快.
7. 要注意赋值语句中的可变对象:
a) 在( a = b = [])以及增强指定语句( a += [1, 2]) , 使用可变对象时,要小心一点.在这两种情况下,在原处修改会影响其他变量.
8. 不要期待进行在原处的修改的函数会返回结果
a) List.append和list.sort方法这种修改运算, 并不会有返回值,
当初学者使用mylist= mylist.append(x) 这样的语句时, 实际是把mylist指定为None了
b) 你可以使用如下方法
i. 使用sorted内置函数来返回排序后的列表,
ii. 先执行ks = D.keys() 然后执行 ks.sort() 最后执行 k in ks :
9. 一定要使用括号调用函数 其实函数也是对象,只是有特殊的运算.你通过括号触发对它的调用
10. 不要在导入和重载中使用扩展名或路径 在import语句中省略目录路径和文件字尾
>>> map(lambda x: 2 **x, range(7))
[1, 2, 4, 8, 16, 32, 64]
扫一扫
2113
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
