由上例，从语句嵌套观点来看，因为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)

>>> 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

>>> [] 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>:

Else:

举例：

>>> 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>:

If<test2>: break

If<test3>: continue

Else:

举例:

如果想写个无限循环,每次迭代时什么也不做,就写个pass.

>>> x

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")

Else #因为循环中没有碰到break语句所以会打印else部分.

简而言之, 如果循环文体没有执行过,循环else分句也会执行, 因为你没有其中执行break语句,在while循环中,如果执行的测试一开始就是假,就会发生这种问题.

For循环

For循环是一个通用的序列迭代器,: 可以遍历任何有序的序列对象内的元素, for语句可用于字符串, 列表, 元组, 其他内置可迭代对象以及之后我们能够通过类所创建的对象 .

格式 :

For <target> in <object>:

If<test>: break

If<test>: continue

Else:

举例:

>>>prod = 1

>>>for item in [1, 2, 3, 4] : prod *= item

>>>prod

>>> sum = 0

>>> for x in [1, 2, 3, 4]:

sum =sum + x

>>> sum

在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)

>>> 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

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]

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

文字变语音插件合成WAV文件超级强大,多语言支持,本例按键调用COM DLL
//初始化Plugin.DL_Speak.ini("Yxme64utTBJHV0R620180302005400")//获取系统中存在的发音员ss = Plugin.DL_Speak.GetLanguageMessageBox ss//设置系统语音库的发音员 0 1 2 3Plugin.DL_Speak.SetLanguage 0//设置发音语速+50Plugin.DL_Speak.Rate 50//朗读自定义文字…...
2024/4/17 8:46:08
Android Studio安装配置(详细版)
Android studio安装配置（相关介绍）一. 前景介绍：在开发Android程序之前，首先要在系统中搭建开发环境。Google公司已经发出声明，到2015年年底不再对Ecplise提供支持服务，Android Studio将全面取代Ecplise。出于开发者角度，我会把两种开发方式（Ecplise和Android stud…...
2024/4/12 17:10:18
JavaWeb开发Eclipse环境配置--史上最详细的教程
【前言】 JSP本身是JavaWeb中的知识，但是在学习Android网络时，必然要涉及到与服务器之间的交互，所以学一下JSP以及其他JavaWeb的内容还是很有必要的，至少能明白程序在访问服务器时，整个过程的原理。其实，在学习Android之前，Java和JavaWeb的知识都是要先学习的。本人是在…...
2024/4/15 10:25:35
Heritrix3.3.0源码阅读允许重复下载
Heritrix3.3.0的org.archive.crawler.datamodel.UriUniqFilter接口提供对下载的uri的唯一性保证，它的子类org.archive.crawler.util.SetBasedUriUniqFilter实现了保证发送到下载队列的uri的是唯一的方法：public void add(String key, CrawlURI value) {profileLog(key);if (s…...
2024/4/12 17:10:33
python 入门简明教程
python 入门简明教程http://sebug.net/paper/python/ch03s04.html#howposted on 2011-09-22 17:37 linyawen 阅读(...) 评论(...) 编辑收藏转载于:https://www.cnblogs.com/linyawen/archive/2011/09/22/2185361.html...
2024/4/12 17:10:28
寒假训练基础组(一)B
计算a+b Input 输入第一行是一个整数N，代表接下来N行会有N组样例输入。 Output 每组输出占一行。 Sample Input 2 1 5 10 20 Sample Output 6 30这也是一道水题注意条件基本上会对 #include<stdio.h> int main() {int n; int a,b; scanf("%d",&n); w…...
2024/4/14 18:20:28
android学习五---OpenCV for android环境搭建
学习android的目的是想在手机上实现计算机视觉的算法。一般算法的研究都是在Matlab上进行，但是手机平台没有那么多的计算资源，用matlab显然是不太现实的。而OpenCV是基于C++语言编写的，可用于开发实时的图像处理、计算机视觉以及模式识别程序。一：需要的工具在前面的章节中…...
2024/4/15 7:43:07
菜鸟入门 JavaWeb-Servlet-HelloWorld 编程
菜鸟编程JavaWeb-Servlet-HelloWorld首先用eclipse集成开发工具，创建一个web工程，然后建立一个叫Text01的包。然后再建一个叫Text01的java类结构目录如下： Text01.java在web工程下的WEB-INF下的web.xml进行设置：然后再部署Tomcat，右键tomcat，有个add，把工程添加进去…...
2024/4/13 8:09:45
学习SQL语句的经验与体会
最近在开发项目的时候, 发现应对与多张表格的查询,使用sql语句的拼接来实现多张表格的拼接查询,更加的方便与有意思. 同时基于hibernate的数据关联性的设计也是一个非常重要的部分.在这里暂时还不是特别的熟悉,也不是很会使用.现在开始进行SQL拼装语句的学习. 1,首先 SQL语言…...
2024/4/5 0:56:56
2013.01.16 Python的面向对象编程
看起来貌似我的接收能力貌似很差劲，看了一个多星期才看到Python简明教程的第十三章（面向对象编程）。回想一下前面看的内容，大部分都已经忘了，随便写几句代码还得回过头去翻教程，怎么办？是好还是坏？求指导，求帮助，求明路。看了一遍教程中的面向对象编程的例子代码，都…...
2024/4/15 3:25:40
JavaWeb系列教程|第二篇:JavaWeb开发目录结构
1、构成一个 web 应用程序是由一组 Servlet、Html 页面、类，以及其它的资源组成的运行在 web 服务器上的完整的应用程序，以一种结构化的有层次的目录形式存在。组成 web 应用程序的这些文件要部署在相应的目录层次中，根目录代表整个 web 应用程序的”根”。通常将 w…...
2024/4/12 17:11:24
微软语音引擎 TTS 最基本使用
TTS(TextToSpeak) 需求：需要借助程序实现文字合成语音/语音识别。 TTS 介绍就不说了，这里介绍非常详细 >>> TTS详细介绍 + SAPI（微软的TTS语音合成和识别接口，可在程序中直接调用）下面介绍一下，怎么来使用它 1. 下载安装TTS引擎到微软的官方网站上去下载一…...
2024/4/18 7:46:53
和Android的第一次美丽邂逅
Android是谷歌推出的基于Linux的手机平台，作为开源的移动操作系统，不存在任何阻碍移动产业创新和发展的专利权障碍，因此Android一经面世就获得了空前的发展，在移动操作系统市场份额一度达到80%多，处于绝对的垄断地位。现如今Android已经不局限于手机系统，越来越多的车载、…...
2024/4/12 17:11:19
简明Python教程学习笔记_1_基本
参考：http://www.kuqin.com/abyteofpython_cn/index.html Learn Python in Y minutes：http://www.jianshu.com/p/1062bdd071cc python 部落：https://python.freelycode.com/简介Python语言是少有的一种可以称得上即简单又功能强大的编程语言。你将惊喜地发现Python语言是多么…...
2024/4/18 7:44:52
系统学习NLP（二）--语音合成的计算机处理综述
参考：https://blog.csdn.net/zlj925/article/details/79061900 略删改。语音合成跟语音识别，自然语音理解，作为人机交互的基础模块，加上对话管理器，形成人机语音对话系统。语音合成原理语音合成（Text to Speech，TTS）是指将文本通过一系列的信号处理转换为“人造”语音（…...
2024/4/12 17:11:19
2020最新JavaWeb_IDEA视频教程（带完整资料）
目录： ┣━━视频 ┃ ┣━━01-html&CSS ┃ ┃ ┣━━01HTML和CSS-引课 .avi ┃ ┃ ┣━━02HTML和CSS-BS软件的结构 .avi ┃ ┃ ┣━━03HTML和CSS-前端的开发流程 .avi ┃ ┃ ┣━━04HTML和CSS-网页的组成部分 .avi ┃ ┃ ┣━━05HT…...
2024/4/18 15:25:03
BufferedReader.readLine()读取文件第一行会出现bug，首行第一个字符会是一个空字符...
BufferedReader.readLine()读取第一行会出现bug，首行第一个字符会是一个空字符BufferedReader is =new BufferedReader(new InputStreamReader(new ileInputStream(file)));String str =is.readLine()char c = str.charAt(0);这时你会发现并不是你文件第一行的首个字符，而是一…...
2024/4/12 17:11:34
Heritrix下拉选择不出现的解决办法
按照书上所说的一步一步配置Heritrix爬虫，结果发现配置任务的时候竟然不能选择那些下拉列表，结果看了牛人debug跟踪了原因，是因为配置文件路径没有指定，所以取不到下拉列表的数据，按照如下所说修改一下，果然下拉列表内容出来了。[b]在Heritrix的run configuration中，cla…...
2024/4/20 5:58:43
Android O 8.0 通知(Notification)更新后的简单兼容写法
我是Android初学者，在看第一行代码学习自学时，其中通知用到NotificationCompat()这个V4库中的方法。但是在实际使用时发现书上的代码已经过时并且Android8.0已经不支持这种写法，经过几天的研究终于写出一个可以同时兼容Android8.0及以下的通知写法再此把我的研究过程写给大家…...
2024/4/9 11:00:31
python3简明教程--字符串
注：本实验来源于实验楼：python3简明教程作者: FrostSigh 索引：项目 Value1,字符串的方法字符串操作的各种内建方法（split()）2,字符串剥离 strip()3，文本搜索 find()4，回文检查什么是回文5，单词计数格式化操作符（%）和单词计数1.字符串的方法每个字符串对象都有…...
2024/4/13 8:10:30

第三部分 python的语句与语法

第10章 python语句简介

要点

第11 章 赋值，表达式和打印

赋值语句

特性：

高级序列赋值语句模式

列表分解赋值

多目标赋值语句以及共享引用

增强赋值语句

变量命名规则

命名惯例

表达式

打印语句

重定向输出流

第12章 if测试

Python语法规则

代码块分隔符与语句的分隔符

If / else 三元表达式

第13章 while和for 循环

While循环

一般格式

Breank, continue, pass 和循环else

举例:

For循环

格式 :

举例:

迭代器: 初探

文件迭代器

其他内置迭代器

其他迭代环境

循环计数器 while和range

并行遍历 zip 和 map

使用zip构造字典

产生偏移和元素: enumerate

列表解析基础

对文件使用列表解析

扩展列表解析语法

第14章Python文档资源

文档字符串 __doc__

内置文档字符串

PyDoc: help函数

常见编写代码的陷阱

相关文章

最新文章

第11 章赋值，表达式和打印

文档字符串 doc