python学习笔记

>>> print unicode('\xb0\xa1', 'gb2312')//将机器内码转换为unicode码
啊
>>> print unicode(chr(0xb0)+chr(0xa1), 'gb2312')
啊
luther@gliethttp:~$ vim utf8.c
然后输入：luther中国
保存,查看保存后,utf8.c的hex：
0000000: 6c 75 74 68 65 72 e4 b8 ad e5 9b bd 0a           luther.......
使用python进一步分析查看：
>>> ord('\n')
10
>>> a='中国' //使用python默认编码方案对汉字执行赋值存储操作
>>> a
'\xe4\xb8\xad\xe5\x9b\xbd'  //这就是utf-8编码,所以这也就是我的ubutun下python默认编码方案
>>> a=u'中国'//使用unicode编码
>>> a
u'\u4e2d\u56fd' //这就是unicode编码值
>>> a.encode('gb2312') //转成gb2312的区位码编码值
'\xd6\xd0\xb9\xfa'
>>> a.encode('utf-8')   //转成utf-8编码
'\xe4\xb8\xad\xe5\x9b\xbd' //和上面python的默认编码值相同
>>> a=u'中国'
u'\u4e2d\u56fd'
>>> b=a.encode('gb2312')//unicode转为gb2312
>>> b
'\xd6\xd0\xb9\xfa'
>>> unicode(b, 'gb2312')//将gb2312转为unicode
u'\u4e2d\u56fd'
显示unicode字符的utf8码
>>> u'葛'
u'\u845b'
打印utf8码为可视字符
>>> print u'\u845b'
葛
>>> print chr(65)
>>> print unichr(0x8089)

Python基础篇：
==========================================================
pow(x,y[,z])
pow()函数返回以x为底，y为指数的幂。如果给出z值，该函数就计算x的y次幂值被z取模的值。
>>> pow(3,4) 计算3^4数值

>>> 2**3  计算2^3幂数值8

取模运算
>>> 12 % 5

左右移位运算
>>> 0x01 << 2
>>> 0x80 >> 2

异或运算
>>> 3 ^ 4

否运算、位取反、或运算和与运算
>>> not 1
False
>>> not ""
True
>>> ~0x80
>>> 1 | 2
>>> 1 & 2

>>> import math
>>> dir(math)
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']
执行sin函数
>>> math.sin(弧度),所以如果想计算sin(90度),那么需要将90度转换为相应的弧度

把弧度转为角度

>>> math.degrees(math.pi)
180.0
>>> math.degrees(math.pi/2)
90.0
>>> math.degrees(math.pi/4)
45.0
>>> math.degrees(2*math.pi)
360.0

所以sin(90度)就是
math.sin((math.pi/180)*90)
所以sin(45度)就是
math.sin((math.pi/180)*45)

>>> import os
>>> dir(os)
['abort', 'access', 'altsep', 'chdir', 'chmod', 'chown', 'chroot', 'close', 'confstr', 'confstr_names', 'ctermid', 'curdir', 'defpath', 'devnull', 'dup', 'dup2', 'environ', 'errno', 'error', 'execl', 'execle', 'execlp', 'execlpe', 'execv', 'execve', 'execvp', 'execvpe', 'extsep', 'fchdir', 'fdatasync', 'fdopen', 'fork', 'forkpty', 'fpathconf', 'fstat', 'fstatvfs', 'fsync', 'ftruncate', 'getcwd', 'getcwdu', 'getegid', 'getenv', 'geteuid', 'getgid', 'getgroups', 'getloadavg', 'getlogin', 'getpgid', 'getpgrp', 'getpid', 'getppid', 'getsid', 'getuid', 'isatty', 'kill', 'killpg', 'lchown', 'linesep', 'link', 'listdir', 'lseek', 'lstat', 'major', 'makedev', 'makedirs', 'minor', 'mkdir', 'mkfifo', 'mknod', 'name', 'nice', 'open', 'openpty', 'pardir', 'path', 'pathconf', 'pathconf_names', 'pathsep', 'pipe', 'popen', 'popen2', 'popen3', 'popen4', 'putenv', 'read', 'readlink', 'remove', 'removedirs', 'rename', 'renames', 'rmdir', 'sep', 'setegid', 'seteuid', 'setgid', 'setgroups', 'setpgid', 'setpgrp', 'setregid', 'setreuid', 'setsid', 'setuid', 'spawnl', 'spawnle', 'spawnlp', 'spawnlpe', 'spawnv', 'spawnve', 'spawnvp', 'spawnvpe', 'stat', 'stat_float_times', 'stat_result', 'statvfs', 'statvfs_result', 'strerror', 'symlink', 'sys', 'sysconf', 'sysconf_names', 'system', 'tcgetpgrp', 'tcsetpgrp', 'tempnam', 'times', 'tmpfile', 'tmpnam', 'ttyname', 'umask', 'uname', 'unlink', 'unsetenv', 'urandom', 'utime', 'wait', 'wait3', 'wait4', 'waitpid', 'walk', 'write']


chr()函数返回ASCII码对应的字符串。
>>> chr(0x30)

ord()函数返回一个字符串参数的ASCII码或Unicode值。
>>> ord("a")

hex()函数可把整数转换成十六进制数。
>>> hex(123)


oct()函数可把给出的整数转换成八进制数。
>>> oct(8)

int(x)
long(x)函数把数字和字符串转换成长整数，base为可选的基数。
>>> long("123")

float()函数把一个数字或字符串转换成浮点数。
>>> float("12")
==========================================================
20081121
Python命令行选项

选项	作用
-c cmd	在命令行直接执行python代码。如python -c 'print "hello world"'。
-d	脚本编译后从解释器产生调试信息。同PYTHONDEBUG=1。
-E	忽略环境变量。
-h	显示python命令行选项帮助信息。
-i	脚本执行后马上进入交互命令行模式。同PYTHONINSPECT=1。
-O	在执行前对解释器产生的字节码进行优化。同 PYTHONOPTIMIZE=1。
-OO	在执行前对解释器产生的字节码进行优化，并删除优化代码中的嵌入式文档字符串。
-Q arg	除法规则选项，-Qold(default)，-Qwarn，-Qwarnall，-Qnew。
-S	解释器不自动导入site.py模块。
-t	当脚本的tab缩排格式不一致时产生警告。
-u	不缓冲stdin、stdout和stderr，默认是缓冲的。同PYTHONUNBUFFERED=1。
-v	产生每个模块的信息。如果两个-v选项，则产生更详细的信息。同PYTHONVERBOSE=x。
-V	显示Python的版本信息。
-W arg	出错信息控制。(arg is action:message:category:module:lineno)
-x	忽略源文件的首行。要在多平台上执行脚本时有用。
file	执行file里的代码。

Python运算符列表

运算符	名称	说明	例子
+	加	两个对象相加	3 + 5得到8。'a' + 'b'得到'ab'。
-	减	得到负数或是一个数减去另一个数	-5.2得到一个负数。50 - 24得到26。
*	乘	两个数相乘或是返回一个被重复若干次的字符串	2 * 3得到6。'la' * 3得到'lalala'。
**	幂	返回x的y次幂	3 ** 4得到81（即3 * 3 * 3 * 3）
/	除	x除以y	4/3得到1（整数的除法得到整数结果）。4.0/3或4/3.0得到1.3333333333333333
//	取整除	返回商的整数部分	4 // 3.0得到1.0
%	取模	返回除法的余数	8%3得到2。-25.5%2.25得到1.5
<<	左移	把一个数的比特向左移一定数目（每个数在内存中都表示为比特或二进制数字，即0和1）	2 << 2得到8。——2按比特表示为10
>>	右移	把一个数的比特向右移一定数目	11 >> 1得到5。——11按比特表示为1011，向右移动1比特后得到101，即十进制的5。
&	按位与	数的按位与	5 & 3得到1。
|	按位或	数的按位或	5 | 3得到7。
^	按位异或	数的按位异或	5 ^ 3得到6
~	按位翻转	x的按位翻转是-(x+1)	~5得到6。
<	小于	返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	5 < 3返回0（即False）而3 < 5返回1（即True）。比较可以被任意连接：3 < 5 < 7返回True。
>	大于	返回x是否大于y	5 > 3返回True。如果两个操作数都是数字，它们首先被转换为一个共同的类型。否则，它总是返回False。
<=	小于等于	返回x是否小于等于y	x = 3; y = 6; x <= y返回True。
>=	大于等于	返回x是否大于等于y	x = 4; y = 3; x >= y返回True。
==	等于	比较对象是否相等	x = 2; y = 2; x == y返回True。x = 'str'; y = 'stR'; x == y返回False。x = 'str'; y = 'str'; x == y返回True。
!=	不等于	比较两个对象是否不相等	x = 2; y = 3; x != y返回True。
not	布尔“非”	如果x为True，返回False。如果x为False，它返回True。	x = True; not y返回False。
and	布尔“与”	如果x为False，x and y返回False，否则它返回y的计算值。	x = False; y = True; x and y，由于x是False，返回False。在这里，Python不会计算y，因为它知道这个表达式的值肯定是False（因为x是False）。这个现象称为短路计算。
or	布尔“或”	如果x是True，它返回True，否则它返回y的计算值。	x = True; y = False; x or y返回True。短路计算在这里也适用。

运算符	描述
x+y，x-y	加、减，“+”号可重载为连接符
x*y，x**y，x/y，x%y	相乘、求平方、相除、求余，“*”号可重载为重复，“%”号可重载为格式化
<，<=，>，>=，==，<>，!=	比较运算符
+=，-=，*=，/=，%=，**=，<<=，>>=，&=，^=，|=	自变运算符
x|y	按位或
x^y	按位异或
x&y	按位与
~x	按位取反
x<<，x>>y	x向左或向右移y位
is, is not	等同测试
in, not in	是否为成员测试
or，and，not	逻辑运算符
x[i]，x[i:j]，x.y，x(...)	索引，分片，限定引用，函数调用
(...)，[...]，{...}，'...'	元组，列表，字典，转化为字符串

Table 2.2. 运算符优先顺序列表(从最高到最低)

运算符	描述
'expr'	字符串转换
{key:expr,...}	字典
[expr1,expr2...]	列表
(expr1,expr2,...)	元组
function(expr,...)	函数调用
x[index:index]	切片
x[index]	下标索引取值
x.attribute	属性引用
~x	按位取反
+x，-x	正，负
x**y	幂
x*y，x/y，x%y	乘，除，取模
x+y，x-y	加，减
x<>y	移位
x&y	按位与
x^y	按位异或
x|y	按位或
x=y，x>y	比较
x is y，x is not y	等同测试
x in y，x not in y	成员判断
not x	逻辑否
x and y	逻辑与
x or y	逻辑或
lambda arg,...:expr	Lambda匿名函数

2.3.3. 真值表

Table 2.3. 

对象/常量	值
""	假
"string"	真
0	假
>=1	真
<=-1	真
()空元组	假
[]空列表	假
{}空字典	假
None	假

==========================================================

数学函数

函数	返回类型	描述	例子	结果
abs(x)	（和x类型相同）	绝对值	abs(-17.4)	17.4
cbrt(dp)	dp	立方根	cbrt(27.0)	3
ceil(dp 或者 numeric)	与输入相同	不小于参数的最小的整数	ceil(-42.8)	-42
ceiling(dp or numeric)	（与输入相同）	不小于参数的最小整数（ceil 的别名）	ceiling(-95.3)	-95
degrees(dp)	dp	把弧度转为角度	degrees(0.5)	28.6478897565412
exp(dp 或 numeric)	与输入相同	自然指数	exp(1.0)	2.71828182845905
floor(dp 或 numeric)	与输入相同	不大于参数的最大整数	floor(-42.8)	-43
ln(dp 或 numeric)	与输入相同	自然对数	ln(2.0)	0.693147180559945
log(dp 或 numeric)	与输入相同	10 为底的对数	log(100.0)	2
log(b numeric, x numeric)	numeric	指定底数的对数	log(2.0, 64.0)	6.0000000000
mod(y, x)	(和参数类型相同)	除法 y/x 的余数（模）	mod(9,4)	1
pi()	dp	"π" 常量	pi()	3.14159265358979
power(a dp, b dp)	dp	求a的 b 次幂	power(9.0, 3.0)	729
power(a numeric, b numeric)	numeric	求a的 b 次幂	power(9.0, 3.0)	729
radians(dp)	dp	把角度转为弧度	radians(45.0)	0.785398163397448
random()	dp	0.0 到 1.0 之间的随机数值	random()
round(dp 或者 numeric)	（与输入相同）	圆整为最接近的整数	round(42.4)	42
round(v numeric, s int)	numeric	圆整为s位小数数字	round(42.4382, 2)	42.44
setseed(dp)	int	为随后的 random() 调用设置种子	setseed(0.54823)	1177314959
sign(dp 或者 numeric)	（和输入相同）	参数的符号（-1, 0, +1）	sign(-8.4)	-1
sqrt(dp 或者 numeric)	（和输入相同）	平方根	sqrt(2.0)	1.4142135623731
trunc(dp 或者 numeric)	（和输入相同）	截断（向零靠近）	trunc(42.8)	42
trunc(v numeric, s int)	numeric	截断为 s 小数位置的数字	trunc(42.4382, 2)	42.43
width_bucket(op numeric, b1 numeric, b2 numeric, count in)	int	返回一个桶，这个桶是在一个有 count 个桶， 上界为 b1，下界为 b2 的等深柱图中 operand 将被赋予的那个桶。	width_bucket(5.35, 0.024, 10.06, 5)	3

 三角函数

函数	描述
acos(x)	反余弦
asin(x)	反正弦
atan(x)	反正切
atan2(x, y)	正切 y/x 的反函数
cos(x)	余弦
cot(x)	余切
sin(x)	正弦
tan(x)	正切

==========================================================
输入需要获取帮助的函数名
>>> help()
定义一个dictionary
>>> d = {"server":"mpilgrim", "database":"master"}
显示
>>> d
{'database': 'master', 'server': 'mpilgrim'}
删除一个元素
>>> del d["server"]
清空所有元素
>>> d.clear()
>>> d
{}
==========================================================
list是Python中使用最频繁的数据类型,Python中的list更像Java中的数组
>>> li = ["a", "b", "mpilgrim", "z", "example"]
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[0]   以0索引为开始
'a'
>>> li[4]
'example'
>>> li[-1]  负数索引表示从后边开始的第几个元素
'example'
>>> li[-3]
'mpilgrim'
>>> li[1:3] 不包括最大值[1,3)
['b', 'mpilgrim']
>>> li[-1:1]
[]
>>> li[1:-1]
['b', 'mpilgrim', 'z']
可以通过指定2个索引得到list的子集,叫做一个“slice” 。返回值是一个新的list
>>> li[:3]  //默认以0开始
['a', 'b', 'mpilgrim']
>>> li[3:]  //默认以最大结束
['z', 'example']
>>> li[:]   //默认从0到最大
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[-2:] //返回最后2个元素
['z', 'example']
li[:n] 总是返回前 n 个元素,而 li[n:]
将返回剩下的元素,不管 list 有多长。
>>> li.append("new") //追加新元素"new"到list结尾
>>> li.insert(2, "new") //在以0为索引开头的2索引处,插入该元素,其他元素索引加1
>>> li.insert(-2, "new") //在倒数第2个元素之前插入该元素
>>> li.extend(["two", "elements"])  //在list结尾追加该组list
可以使用
>>> help()
help> list //获取list的帮助内容
>>> li.index("new") //显示第一次出现"new"的索引
>>> 'luther' in li  //查看字符串luther是否在list中
True
>>> li.remove("z")  //从list中删除元素,从0索引开始顺序查找,如果找到,那么删除
>>> li.pop()
pop 是一个有趣的东西。它会做两件事:删除 list 的最后一个元素,然后
返回删除元素的值。请注意,这与 li[-1] 不同,后者返回一个值但不改变
list 本身。也不同于 li.remove(value),后者改变 list 但并不返回值。
>>> li += ['two']   //添加'two'到list
>>> li = [1, 2] * 3 //重复添加3组[1,2]

>>> li = [1, 9, 8, 4]
>>> [elem*2 for elem in li]
[2, 18, 16, 8]
>>> li
[1, 9, 8, 4]
>>> li = [elem*2 for elem in li]
>>> li
[2, 18, 16, 8]
为了便于理解它,让我们从右向左看li 是一个将要映射的list.Python
循环遍历 li 中的每个元素。对每个元素均执行如下操作:首先临时将其值
赋给变量 elem,然后 Python 应用函数 elem*2 进行计算,最后将计算结果
追加到要返回的 list 中。

==========================================================
Tuple 是不可变的 list。一旦创建了一个 tuple,就不能以任何方式改变它
>>> t = ("a", "b", "mpilgrim", "z", "example")
>>> t 或 t[0] 或 t[-1] 或t[1:3]
(1) 定义 tuple 与定义 list 的方式相同,但整个元素集是用小括号包围的,而
    不是方括号。
(2) Tuple 的元素与 list 一样按定义的次序进行排序。Tuples 的索引与 list 一
    样从 0 开始,所以一个非空 tuple 的第一个元素总是 t[0]。
(3) 负数索引与 list 一样从 tuple 的尾部开始计数。
(4) 与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时,会得到一个
    新的 list ;当分割一个 tuple 时,会得到一个新的 tuple。

(1) 您不能向 tuple 增加元素。Tuple 没有 append 或 extend 方法。
(2) 您不能从 tuple 删除元素。Tuple 没有 remove 或 pop 方法。
(3) 您不能在 tuple 中查找元素。Tuple 没有 index 方法。
(4) 然而,您可以使用 in 来查看一个元素是否存在于 tuple 中。
那么使用 tuple 有什么好处呢?
      Tuple 比 list 操作速度快。如果您定义了一个值的常量集,并且唯一要
   •
      用它做的是不断地遍历它,请使用 tuple 代替 list。
      如果对不需要修改的数据进行 “写保护”,可以使代码更安全。使用
   •
      tuple 而不是 list 如同拥有一个隐含的 assert 语句,说明这一数据是常
      量。如果必须要改变这些值,则需要执行 tuple 到 list 的转换 (需要使
      用一个特殊的函数)。
      还记得我说过 dictionary keys 可以是字符串,整数和 “其它几种类型”吗?
   •
      Tuples 就是这些类型之一。Tuples 可以在 dictionary 中被用做 key,但
      是 list 不行。实际上,事情要比这更复杂。Dictionary key 必须是不可变
      的。Tuple 本身是不可改变的,但是如果您有一个 list 的 tuple,那就认
      为是可变的了,用做 dictionary key 就是不安全的。只有字符串、整数
      或其它对 dictionary 安全的 tuple 才可以用作 dictionary key。
      Tuples 可以用在字符串格式化中,我们会很快看到。
   •
Note: Tuple 到 list 再到 tuple
Tuple 可以转换成 list,反之亦然。内置的 tuple 函数接收一个 list,并返回一
个有着相同元素的 tuple。而 list 函数接收一个 tuple 返回一个 list。从效果上
看,tuple 冻结一个 list,而 list 解冻一个 tuple。
==========================================================
变量声明
现在您已经了解了有关 dictionary、tuple、和 list 的相关知识,
Python 与大多数其它语言一样有局部变量和全局变量之分,但是它没有明显
的变量声明。变量通过首次赋值产生,当超出作用范围时自动消亡。
if __name__ == "__main__":
    myParams = {"server":"mpilgrim", \
           "database":"master", \
           "uid":"sa", \
           "pwd":"secret" \
           }
首先注意缩进。if 语句是代码块,需要像函数一样缩进。
其次,变量的赋值是一条被分成了多行的命令,用反斜线 (“\”) 作为续行符。

一次赋 多值
Python 中比较 “酷” 的一种编程简写是使用序列来一次给多个变量赋值。
Example 3.19. 一次赋 多值
>>> v = ('a', 'b', 'e')
>>> (x, y, z) = v    (1)
>>> x
'a'
>>> y
'b'
>>> z
'e'
(1) v 是一个三元素的 tuple,并且 (x, y, z) 是一个三变量的 tuple。将一个 tuple
    赋值给另一个 tuple,会按顺序将 v 的每个值赋值给每个变量。
这种用法有许多种用途。我经常想要将一定范围的值赋给多个变量。在 C 语
言中,可以使用 enum 类型,手工列出每个常量和其所对应的值,当值是连续
的时候这一过程让人感到特别繁琐。而在 Python 中,您可以使用内置的 range
函数和多变量赋值的方法来快速进行赋值。

连续值 赋值
>>> a = range(7)
>>> a
[0, 1, 2, 3, 4, 5, 6]
>>> range(7)                                     (1)
[0, 1, 2, 3, 4, 5, 6]
>>> (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)
(2)
>>> MONDAY                                         (3)
0
>>> TUESDAY
1
>>> SUNDAY
6
(1) 内置的 range 函数返回一个元素为整数的 list。这个函数的简化调用形式是
     接收一个上限值,然后返回一个初始值从 0 开始的 list,它依次递增,直
     到但不包含上限值。(如果您愿意,您可以传入其它的参数来指定一个非 0
     的初始值和非 1 的步长。也可以使用 print range.__doc__ 来了解更多的细
     节。)

==========================================================
字符串 格式化与字符串连接的比较
>>> uid = "sa"
>>> pwd = "secret"
>>> print "%s is not a good password for %s" % (pwd, uid)
3.2.1. 字符串的格式化

象C 中的sprintf函数一样，可以用“%”来格式化字符串。

Table 3.1. 字符串格式化代码
格式     描述
%%     百分号标记
%c     字符及其ASCII码
%s     字符串
%d     有符号整数(十进制)
%u     无符号整数(十进制)
%o     无符号整数(八进制)
%x     无符号整数(十六进制)
%X     无符号整数(十六进制大写字符)
%e     浮点数字(科学计数法)
%E     浮点数字(科学计数法，用E代替e)
%f     浮点数字(用小数点符号)
%g     浮点数字(根据值的大小采用%e或%f)
%G     浮点数字(类似于%g)
%p     指针(用十六进制打印值的内存地址)
%n     存储输出字符的数量放进参数列表的下一个变量中
[Note]     

%格式化符也可用于字典，可用%(name)引用字典中的元素进行格式化输出。
[Note]     

负号指时数字应该是左对齐的，“0”告诉Python用前导0填充数字，正号指时数字总是显示它的正负(+，-)符号，即使数字是正数也不例外。
[Note]     

可指定最小的字段宽度，如："%5d" % 2。也可用句点符指定附加的精度，如："%.3d" % 3。
3.2.2. 转义字符

在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：

Table 3.2. python支持的转义字符表
转义字符     描述
\(在行尾时)     续行符
\\     反斜杠符号
\'     单引号
\"     双引号
\a     响铃
\b     退格(Backspace)
\e     转义
\000     空
\n     换行
\v     纵向制表符
\t     横向制表符
\r     回车
\f     换页
\oyy     八进制数yy代表的字符，例如：\o12代表换行
\xyy     十进制数yy代表的字符，例如：\x0a代表换行
\other     其它的字符以普通格式输出"
>>> a = (800,)*3
>>> a
(800, 800, 800)
>>> print "%x,%x,%x" % a
320,320,320
>>> print "%x" % 2368899
242583
>>> 0x56989
354697
==========================================================
join合并list中的字符串
join 只能用于元素是字符串的 list;它不进行任何的强制类型转换。连接一个
存在一个或多个非字符串元素的 list 将引发一个异常。
>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> ["%s=%s" % (k, v) for k, v in params.items()] //确实像阅读英文文章
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;uid=sa;database=master;pwd=secret'
您将会看到字符串 ";" 本身就是一个对象,您在调用它的 join 方法。

split分割字符串到list
>>> li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s = ";".join(li)//元素之间使用";"字符串分割
>>> s
'server=mpilgrim;uid=sa;database=master;pwd=secret'
>>> s.split(";")
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s.split(";", 1)
['server=mpilgrim', 'uid=sa;database=master;pwd=secret']
==========================================================
本章论述了 Python 众多强大功能之一:自省。正如你所知道的,Python 中万
物皆对象,自省是指代码可以查看内存中以对象形式存在的其它模块和函数,
获取它们的信息,并对它们进行操作。用这种方法,你可以定义没有名称的
函数,不按函数声明的参数顺序调用函数,甚至引用事先并不知道名称的函
数。


type 函数返回任意对象的数据类型。在 types 模块中列出了可能的数据类型。
这对于处理多种数据类型的帮助者函数非常有用。
type 可以接收任何东西作为参数――我的意思是任何东西――并返回它的
数据类型。整型、字符串、列表、字典、元组、函数、类、模块,甚至类
型对象都可以作为参数被 type 函数接受。
>>> type(1)

>>> li = []
>>> type(li)


str 将数据强制转换为字符串。每种数据类型都可以强制转换为字符串。
>>> str(1)
'1'
>>> horsemen = ['war', 'pestilence', 'famine']
>>> horsemen
['war', 'pestilence', 'famine']
>>> horsemen.append('Powerbuilder')
>>> str(horsemen) (2)
"['war', 'pestilence', 'famine', 'Powerbuilder']"

dir 函数返回任意对象的属性和方法列表,
包括模块对象、函数对象、字符串对象、列表对象、字典对象 ...... 相当多的东西。
>>> li=[]
>>> dir(li) 或者
>>> dir([])
['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> d = {}
>>> dir(d)  或者
>>> dir({})
[clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
(1) li 是一个列表,所以 dir(li) 返回一个包含所有列表方法的列表。注意返回的
    列表只包含了字符串形式的方法名称,而不是方法对象本身。
(2) d 是一个字典,所以 dir(d) 返回字典方法的名称列表。其中至少有一个方法,
    keys,看起来还是挺熟悉的。
>>> dir("")
['capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

type、str、dir 和其它的 Python 内置函数都归组到了 __builtin__ (前后分别是双下
划线) 这个特殊的模块中。
>>> import __builtin__
>>> dir(__builtin__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__', '__name__', 'abs', 'all', 'any', 'apply', 'basestring', 'bool', 'buffer', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'min', 'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
==========================================================
>>> li = ["Larry", "Curly"]
>>> li.pop                      (1)

>>> getattr(li, "pop")          (2)

>>> getattr(li, "append")("Moe") (3) //getattr(li, "append")表示获取li对应的append方法地址,就像void (*func)(void*);函数指针一样
getattr(li, "append")就是返回这个append,func对应的函数地址,func("Moe"),就是调用li.append("Moe");
>>> li
["Larry", "Curly", "Moe"]
>>> getattr({}, "clear")       (4)

>>> getattr((), "pop")         (5)
(1) 该语句获取列表的 pop 方法的引用。注意该语句并不是调用 pop 方法;调
    用 pop 方法的应该是 li.pop()。这里指的是方法对象本身。
(2) 该语句也是返回 pop 方法的引用,但是此时,方法名称是作为一个字符串
    参数传递给 getattr 函数的。getattr 是一个有用到令人无法致信的内置函数,
    可以返回任何对象的任何属性。在这个例子中,对象是一个 list,属性是
    pop 方法。
(3) 如果不确信它是多么的有用,试试这个:getattr 的返回值是 方法,然后你
    就可以调用它,就像直接使用 li.append("Moe") 一样。但是实际上你没有直
    接调用函数;只是以字符串形式指定了函数名称。
(4) getattr 也可以作用于字典。
(5) 理论上,getattr 可以作用于元组,但是由于元组没有方法,所以不管你指
    定什么属性名称 getattr 都会引发一个异常。
==========================================================
4.4.2. getatt r 作为一 个分发者
getattr 常见的使用模式是作为一个分发者。举个例子,如果你有一个程序可以
以不同的格式输出数据,你可以为每种输出格式定义各自的格式输出函数,
然后使用唯一的分发函数调用所需的格式输出函数。
例如,让我们假设有一个以 HTML、XML 和普通文本格式打印站点统计的程序。
输出格式在命令行中指定,或者保存在配置文件中。statsout 模块定义了三个
函数:output_html、output_xml 和 output_text。然后主程序定义了唯一的输出函数,
如下:
Example 4.12. 使用 getatt r 创建分 发者
import statsout
def output(data, format="text"):                    (1)
   output_function = getattr(statsout, "output_%s" % format) (2)
   return output_function(data)                    (3)
(1) output 函数接收一个必备参数 data,和一个可选参数 format。如果没有指定
     format 参数,其缺省值是 text 并完成普通文本输出函数的调用。
(2) 你可以连接 format 参数值和 "output_" 来创建一个函数名称作为参数值,
     然后从 statsout 模块中取得该函数。这种方式允许今后很容易地扩展程序
     以支持其它的输出格式,而且无需修改分发函数。所要做的仅仅是向
     statsout 中添加一个函数,比如 output_pdf,之后只要将 “pdf” 作为 format 的
     参数值传递给 output 函数即可。
(3) 现在你可以简单地调用输出函数,就像调用其它函数一样。output_function
     变量是指向 statsout 模块中相应函数的引用。
==========================================================
callable 函数,它接收任何对象作为参数,如果参数对象是可调用的,
返回 True;否则返回 False。可调用对象包括函数、类方法,甚至类自身 (下一
章将更多的关注类)。
也就是检测函数指针是否可以正确调用
==========================================================
如你所知,Python 具有通过列表解析 (Section 3.6, “映射 list”) 将列表映射到
其它列表的强大能力。这种能力同过滤机制结合使用,使列表中的有些元素
被映射的同时跳过另外一些元素。
过滤列表语法:
[mapping-expression for element in source-list if filter-expression]
这是你所知所爱的列表解析的扩展。前三部分都是相同的;最后一部分,以 if
开头的是过滤器表达式。过滤器表达式可以是返回值为真或者假的任何表达
式 (在 Python 中是几乎任何东西)。任何经过滤器表达式演算值为真的元素都
可以包含在映射中。其它的元素都将忽略,它们不会进入映射表达式,更不
会包含在输出列表中。
Example 4.14. 列表过 滤介绍
>>> li = ["a", "mpilgrim", "foo", "b", "c", "b", "d", "d"]
>>> [elem for elem in li if len(elem) > 1]    (1)
['mpilgrim', 'foo']
>>> [elem for elem in li if elem != "b"]       (2)
['a', 'mpilgrim', 'foo', 'c', 'd', 'd']
>>> [elem for elem in li if li.count(elem) == 1] (3)
['a', 'mpilgrim', 'foo', 'c']
(1) 这里的映射表达式很简单 (只是返回每个元素的值),所以请把注意力集中
      到过滤器表达式上。由于 Python 会遍历整个列表,它将对每个元素执行
      过滤器表达式。如果过滤器表达式演算值为真,该元素就会被映射,同时
      映射表达式的结果将包含在返回的列表中。这里,你过滤掉了所有单字符
      的字符串,留下了一个由长字符串构成的列表。
(2) 这里你过滤掉了一个特定值 b。注意这个过滤器会过滤掉所有的 b,因为
      每次取出 b,过滤表达式都将为假。
(3) count 是一个列表方法,返回某个值在列表中出现的次数。你可以认为这
      个过滤器将从列表中剔除重复元素,返回一个只包含了在原始列表中有着
      唯一值拷贝的列表。但并非如此,因为在原始列表中出现两次的值 (在本
      例中,b 和 d) 被完全剔除了。从一个列表中排除重复值有多种方法,但过
      滤并不是其中的一种。
==========================================================
回到 apihelper.py 中的这一行:
 methodList = [method for method in dir(object) if callable(getattr(object, method))]
这行看上去挺复杂――确实也很复杂――但是基本结构都还是一样的。整个
过滤表达式返回一个列表,并赋值给 methodList 变量。表达式的前半部分是列
表映射部分。映射表达式是一个和遍历元素相同的表达式,因此它返回每个
元素的值。dir(object) 返回 object 对象的属性和方法列表――你正在映射的列表。
所以唯一新出现的部分就是在 if 后面的过滤表达式。
过滤表达式看上去很恐怖,其实不是。你已经知道了 callable、getattr 和 in。正
如你在前面的部分中看到的,如果 object 是一个模块,并且 method 是上述模
块中某个函数的名称,那么表达式 getattr(object, method) 将返回一个函数对象。
所以这个表达式接收一个名为 object 的对象,然后得到它的属性、方法、函数
和其他成员的名称列表,接着过滤掉我们不关心的成员。执行过滤行为是通
过对每个属性/方法/函数的名称调用 getattr 函数取得实际成员的引用,然后
检查这些成员对象是否是可调用的,当然这些可调用的成员对象可能是方法
或者函数,同时也可能是内置的 (比如列表的 pop 方法) 或者用户自定义的 (比
如 odbchelper 模块的 buildConnectionString 函数)。这里你不用关心其它的属性,
如内置在每一个模块中的 __name__ 属性。
==========================================================
4.6.and和or的特殊性质
在 Python 中,and 和 or 执行布尔逻辑演算,如你所期待的一样。但是它们并
不返回布尔值,而是返回它们实际进行比较的值之一。
Example 4.15. and 介绍
>>> 'a' and 'b'       (1)
'b'
>>> '' and 'b'       (2)
''
>>> 'a' and 'b' and 'c' (3)
'c'
(1) 使用 and 时,在布尔环境中从左到右演算表达式的值。
    0、''、[]、()、{}、None 在布尔环境中为假;其它任何东西都为真。还好,
    几乎是所有东西。默认情况下,布尔环境中的类实例为真,但是你可以在
    类中定义特定的方法使得类实例的演算值为假。你将会在第 5 章中了解到
    类和这些特殊方法。如果布尔环境中的所有值都为真,那么 and 返回最后
    一个值。在这个例子中,and 演算 'a' 的值为真,然后是 'b' 的演算值为真,
    最终返回 'b'。
(2) 如果布尔环境中的某个值为假,则 and 返回第一个假值。在这个例子
    中,'' 是第一个假值。
(3) 所有值都为真,所以 and 返回最后一个真值,'c'。
Example 4.16. or 介绍
>>> 'a' or 'b'      (1)
'a'
>>> '' or 'b'      (2)
'b'
>>> '' or [] or {} (3)
{}
>>> def sidefx():
...  print "in sidefx()"
...  return 1
>>> 'a' or sidefx()    (4)//不会执行sidefx()函数,因为'a'已经为真值,所以后面的所有or操作将跳过
'a'
(1) 使用 or 时,在布尔环境中从左到右演算值,就像 and 一样。如果有一个值
    为真,or 立刻返回该值。本例中,'a' 是第一个真值。
(2) or 演算 '' 的值为假,然后演算 'b' 的值为真,于是返回 'b' 。
(3) 如果所有的值都为假,or 返回最后一个假值。or 演算 '' 的值为假,然后演
    算 [] 的值为假,依次演算 {} 的值为假,最终返回 {} 。
(4) 注意 or 在布尔环境中会一直进行表达式演算直到找到第一个真值,然后
    就会忽略剩余的比较值。如果某些值具有副作用,这种特性就非常重要了。
    在这里,函数 sidefx 永远都不会被调用,因为 or 演算 'a' 的值为真,所以
    紧接着就立刻返回 'a' 了。
如果你是一名 C 语言黑客,肯定很熟悉 bool ? a : b 表达式,如果 bool 为真,表
达式演算值为 a,否则为 b。基于 Python 中 and 和 or 的工作方式,你可以完
成相同的事情。
4.6. 1. 使用 and-or 技巧
Example 4.17. and-or 技巧介绍
>>> a = "first"
>>> b = "second"
>>> 1 and a or b (1)
'first'
>>> 0 and a or b (2)
'second'
(1) 这个语法看起来类似于 C 语言中的 bool ? a : b 表达式。整个表达式从左到
       右进行演算,所以先进行 and 表达式的演算。1 and 'first' 演算值为 'first',
       然后 'first' or 'second' 的演算值为 'first'。
(2) 0 and 'first' 演算值为 False,然后 0 or 'second' 演算值为 'second'。
然而,由于这种 Python 表达式单单只是进行布尔逻辑运算,并不是语言的特
定构成,这是 and-or 技巧和 C 语言中的 bool ? a : b 语法非常重要的不同。如果
a 为假,表达式就不会按你期望的那样工作了。(你能知道我被这个问题折腾
过吗?不止一次?)

>>> a = ""
>>> b = "glx"
>>> (1 and [a] or [b])
['']
>>> (1 and [a] or [b])[0]
''
==========================================================
4.7. 使用lambda函数
Python 支持一种有趣的语法,它允许你快速定义单行的最小函数。这些叫做
lambda 的函数,是从 Lisp 借用来的,可以用在任何需要函数的地方。
Example 4.20. lambda 函数介绍
>>> def f(x):
...  return x*2
...
>>> f(3)
6
>>> g = lambda x: x*2 (1)
>>> type(g)

>>> callable(g)
True
>>> g(3)
6
>>> (lambda x: x*2)(3) (2)
6
(1) 这是一个 lambda 函数,完成同上面普通函数相同的事情。注意这里的简短
    的语法:在参数列表周围没有括号,而且忽略了 return 关键字 (隐含存在,
    因为整个函数只有一行)。而且,该函数没有函数名称,但是可以将它赋
    值给一个变量进行调用。
(2) 使用 lambda 函数时甚至不需要将它赋值给一个变量。这可能不是世上最有
    用的东西,它只是展示了 lambda 函数只是一个内联函数。
总的来说,lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个
表达式的值。lambda 函数不能包含命令,包含的表达式不能超过一个。不要
试图向 lambda 函数中塞入太多的东西;如果你需要更复杂的东西,应该定义
一个普通函数,然后想让它多长就多长。
Note: lambda 是可选的
lambda 函数是一种风格问题。不一定非要使用它们;任何能够使用它们的地
方,都可以定义一个单独的普通函数来进行替换。我将它们用在需要封装特
殊的、非重用代码上,避免令我的代码充斥着大量单行函数。
Example 4.21. spl it 不带参数
>>> s = "this is\na\ttest" (1)
>>> print s
this is
a             test
>>> print s.split()         (2)//过滤掉所有的空格,\n和\t
['this', 'is', 'a', 'test']
>>> print " ".join(s.split()) (3)
'this is a test'
(1) 这是一个多行字符串,通过使用转义字符的定义代替了三重引号。\n 是一
      个回车,\t 是一个制表符。
(2) 不带参数的 split 按照空白进行分割。所以三个空格、一个回车和一个制表
      符都是一样的。
(3) 通过 split 分割字符串你可以将空格统一化;然后再以单个空格作为分隔符
      用 join 将其重新连接起来。这也就是 info 函数将多行 doc string 合并成单行
      所做的事情。

那么 info 函数到底用这些 lambda 函数、split 函数和 and-or 技巧做了些什么呢?
   processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
processFunc 现在是一个函数,但是它到底是哪一个函数还要取决于 collapse 变
量。如果 collapse 为真,processFunc(string) 将压缩空白;否则 processFunc(string)
将返回未改变的参数。

==========================================================
Python 是完全面向对象的:你可以定义自已的类,从自已的或内置的类继承,
然后从你定义的类创建实例。
在 Python 中定义类很简单。就像定义函数,没有单独的接口定义。只要定义
类,然后就可以开始编码。Python 类以保留字 class 开始,后面跟着类名。从
技术上讲,有这些就够了,因为一个类并非必须从其它类继承。
Example 5.3. 最简单的 Python 类
class Loaf: (1)
   pass   (2) (3)
(1) 这个类的名字是 Loaf,它没有从其它类继承。类名通常是第一个字母大写,
     如:EachWordLikeThis,但这只是一个习惯,不是一个必要条件。
(2) 这个类没有定义任何方法或属性,但是从语法上,需要在定义中有些东西,
     所以你使用 pass。这是一个 Python 保留字,仅仅表示 “向前走,不要往这
     看”。它是一条什么都不做的语句,当你删空函数或类时,它是一个很好
     的占位符。
(3) 你可能猜到了,在类中的所有东西都要缩近,就像位于函数、if 语句,for
     循环,诸如此类的代码。第一条不缩近的东西不属于这个类。
Note: Python v s. Java: pass
在 Python 中的 pass 语句就像 Java 或 C 中的大括号空集 ({})。
当然,实际上大多数的类都是从其它的类继承来的,并且它们会定义自已的
类方法和属性。但是就像你刚才看到的,除了名字以外,类没有什么必须要
具有的。特别是,C++ 程序员可能会感到奇怪,Python 的类没有显示的构造
函数和析构函数。Python 类的确存在与构造函数相似的东西:__init__ 方法。
==========================================================
fsock = open(filename, "rb", 0)
fsock.seek(-128, 2)
tagdata = fsock.read(128)
fsock.close()
分割路 径名
>>> os.path.split("c:\\music\\ap\\mahadeva.mp3")
列出目 录
>>> os.listdir("c:\\music\\_singles\\")
os.path.isdir(os.path.join(dirname, f))
os.path.isfile(os.path.join(dirname, f))
==========================================================
p118 正则表达式
  ^ 匹配字符串的开始。
  $ 匹配字符串的结尾。
  \b 匹配一个单词的边界。
  \d 匹配任意数字。
  \D 匹配任意非数字字符。
  x? 匹配一个可选的 x 字符 (换言之,它匹配 1 次或者 0 次 x 字符)。
  x* 匹配 0 次或者多次 x 字符。
  x+ 匹配 1 次或者多次 x 字符。
  x{n,m} 匹配 x 字符,至少 n 次,至多 m 次。
  (a|b|c) 要么匹配 a,要么匹配 b,要么匹配 c。
  (x) 一般情况下表示一个记忆组         (remembered group)。你可以利用
  re.search 函数返回对象的 groups() 函数获取它的值。




==========================================================
20081122
li = []
li.append('a')
li.extend(['b','c','d'])
li.sort()       对list中的成员们做排序
li.reverse()    从头到尾对调，颠倒list元素的顺序
li.pop()        弹出同时删除list的最后一个元素
li.pop(2)       弹出同时删除index=2的数据
li.count(1)     统计list中1出现的次数
li.index(1)     检查list中第一个1对应的索引index值
li.insert(1,'g')将'g'插入到索引号1处
li.insert(-2,'g')在倒数第2个元素前面插入'g',这样'g'就位于倒数第3个索引
li.remove('g')  删除list中第一个匹配上的'g'元素
[x*x for x in range(1,10)]
[x+y for x in "123" for y in "abc"]
'a' in li       判断'a'元素是否在list中

list = [ "a", "b", "c" ]，这是字符列表。
list = [ 1, 2, 3, 4 ]，这是数字列表。
list = [ [1,2,3,4], ["a","b","c"] ]，这是列表的列表。
list = [ (1,2,3,4), ("a","b","c") ]，这是元组列表。
list((1,2))把一个元组转换成一个列表[1,2]，list('test')可把字符串转换成['t','e','s','t']列表。
list("hello world")
li=os.listdir('d:/')
print "%s" % string.join(li,'\n')    显示中文字符
=================================================
monthdays = { "Jan":31, "Feb":28, "Mar":31, "Apr":30, "May":31, "Jun":30, "Jul":31, "Aug":31, "Sep":30, "Oct":31, "Nov":30,"Dec":31 }

monthdays.has_key('Jan')    查看'Jan'键值是否存在
monthdays.keys()            返回dictionary中所有键,使用list方式
monthdays.values()          返回dictionary中所有键值
monthdays.items()           返回tuples列表,每个tuple由dictionary的键和相应值组成。
monthdays.clear()           删除dictionary的所有条目
b = monthdays.copy()        拷贝dictionary中的所有内容,但不复制嵌入结构，而只复制对那些结构的引用
b = {}
b.update(monthdays)         将monthdays中的键和键值同步到b这个dictionary中,类似于融合
s = 1,2,3
x,y,z = s                   一次性分别赋值给x,y和z
=================================================
String模块
import string

replace(string,old,new[,maxsplit])
>>>a="11223344"
>>>print string.replace(a,"1","one")
oneone2223344
>>>print string.replace(a,"1","one",1)
one12223344

split(string,sep=None,maxsplit=-1)
从string字符串中返回一个列表，以sep的值为分界符。
>>> import string
>>> ip="192.168.3.3"
>>> ip_list=string.split(ip,'.')
>>> print ip_list
['192', '168', '3', '3']

join(string[,sep])
返回用sep连接的字串，默认的sep是空格。
>>> import string
>>> a = ['a','b','c']
>>> b = string.join(a,'-')
或者
>>> b = '-'.join(a)
>>> b
'a-b-c'
>>> a
['a', 'b', 'c']
=================================================
如何判断操作系统类型
import sys
print sys.platform
print sys.version
显示和修改python的Module搜索路径
import sys
print sys.path
sys.path.append('/usr/lib/mypath')  //追加自定义路径
把列表转换成字符串
t=['a','b','c']
import string
string.join(t)
运行系统程序
>>>import os
>>>os.system('ping ')
>>>os.system('ls')            #用os.system()可执行系统命令
>>>exec "os.system('ls')"     #用exec可执行字符串中的命令，两个命令的效果一样。
以上两个命令的输出都是直接显示在屏幕上，不能保存到变量中，如果我们要把输出保存起来，可用os.pope\ n()函数。
>>>cmd = '/usr/bin/mkntpwd %s' % password
>>>handler = os.popen(cmd,'r')
>>>passwordString=handler.read()   #passwordString为mkntpwd程序的输出结果
使用commands模块也可以获取程序的输出，它包含一些基于os.popen()的封装函数，使我们能更方便地获取运行系统命令和获取命令的输出，但该模块只在Unix系统下有效，不能用于Windows平台。
>>> import commands
>>> status,output = commands.getstatusoutput('ls -l')
>>> print output
交换两个变量
a,b = 1,2
a,b = b,a
拆分序列
a=[c for c in 'abcdefg']
=================================================
运算符优先顺序列表(从最高到最低)
运算符    描述
'expr'    字符串转换
{key:expr,...}    字典
[expr1,expr2...]    列表
(expr1,expr2,...)    元组
function(expr,...)    函数调用
x[index:index]    切片
x[index]    下标索引取值
x.attribute    属性引用
~x    按位取反
+x，-x    正，负
x**y    幂
x*y，x/y，x%y    乘，除，取模
x+y，x-y    加，减
x<>y    移位
x&y    按位与
x^y    按位异或
x|y    按位或
x=y，x>y    比较
x is y，x is not y    等同测试
x in y，x not in y    成员判断
not x    逻辑否
x and y    逻辑与
x or y    逻辑或
lambda arg,...:expr    Lambda匿名函数
2.3.3. 真值表

Table 2.3.
对象/常量    值
""    假
"string"    真
0    假
>=1    真
<=-1    真
()空元组    假
[]空列表    假
{}空字典    假
None    假
=================================================
文件处理的函数和方法
file_handler = open(filename,[,mode[,bufsize]]

r    以读方式打开文件，可读取文件信息。
w    以写方式打开文件，可向文件写入信息。
a    以追加方式打开文件，文件指针自动移到文件尾。
r+    以读写方式打开文件，可对文件进行读和写操作。
w+    消除文件内容，然后以读写方式打开文件。
a+    以读写方式打开文件，并把文件指针移到文件尾。
b    以二进制模式打开文件，而不是以文本模式。该模式只对Windows或Dos有效，类Unix的文件是用二进制模式进行操作的。

bufsize取值    描述
0    禁用缓冲
1    行缓冲
>1    指定缓冲区的大小
<1    系统默认的缓冲区大小

f.close()    关闭文件，记住用open()打开文件后一定要记得关闭它，否则会占用系统的可打开文件句柄数。
f.fileno()    获得文件描述符
f.flush()    刷新输出缓存
f.isatty()    如果文件是一个交互终端，则返回True，否则返回False。
f.read([count])    读出文件，如果有count，则读出count个字节。
f.readline()    读出一行信息。
f.readlines()    读出所有行，也就是读出整个文件的信息。
f.seek(offset[,where])    把文件指针移动到相对于where的offset位置。offset为0表示文件开始处，这是默认值 ；1表示当前位置；2表示文件结尾。
f.tell()    获得文件指针位置。
f.truncate([size])    截取文件，使文件的大小为size。
f.write(string)    把string字符串写入文件。
f.writelines(list)    把list中的字符串一行一行地写入文件。

os.listdir('c:/')
os.mkdir('py')                  #在当前目录下创建一个py目录，且只能创建一层
os.rmdir( 'py')                 #在当前目录下删除py目录，且只能删除一层
os.makedirs('py/aa')            #可创建多层目录
os.removedirs('py/aa')          #可删除多层目录

li=os.listdir('d:/')
print "%s" % string.join(li,'\n')    显示中文字符
print "%s" % string.join(os.listdir('e:/'),'\n') 显示e盘的所有目录

import os,time,stat
fileStats = os.stat ( 'test.txt' )                         #获取文件/目录的状态
fileInfo = {
'Size':fileStats [ stat.ST_SIZE ],                         #获取文件大小
'LastModified':time.ctime( fileStats [ stat.ST_MTIME ] ),  #获取文件最后修改时间
'LastAccessed':time.ctime( fileStats [ stat.ST_ATIME ] ),  #获取文件最后访问时间
'CreationTime':time.ctime( fileStats [ stat.ST_CTIME ] ),  #获取文件创建时间
'Mode':fileStats [ stat.ST_MODE ]                          #获取文件的模式
}

import os.path

fileStats = 'test.txt'

if os.path.isdir ( fileStats ):         #判断是否路径
        print 'Directory.'
elif os.path.isfile ( fileStats ):      #判断是否一般文件
        print 'File.'
elif os.path.islink ( fileStats ):      #判断是否链接文件
        print 'Shortcut.'
elif os.path.ismount ( fileStats ):     #判断是否挂接点
        print 'Mount point.'

内存文件
import StringIO

fileHandle = StringIO.StringIO ( "Let freedom ring." )   #create file in memory
print fileHandle.read() # "Let freedom ring."
fileHandle.close()
#cStringIO是用C写的StringIO模块，执行速度比StringIO快。

>>> li=['a','b']
>>> getattr(li,'append')
>>> getattr(li,'append')('c')          #相当于li.append('c')
>>> li
['a', 'b', 'c']
>>> handler=getattr(li,'append',None)
>>> handler

>>> handler('cc')                      #相当于li.append('cc')
>>> li
['a','b','c','cc']
>>>result = handler('bb')
>>>li
['a','b','c','cc','bb']
>>>print result
None


Chapter 11. 调试

Python自带了一个调试器叫pdb，和Gnu的gbd类似。下面用一个简单的程序来演示pdb的功能。程序代码如下：

#!/usr/bin/python

import pdb
a = "aaa"
pdb.set_trace()
b = "bbb"
c = "ccc"
final = a + b + c
print final

该程序已导入pdb模块，并在代码中添加的pdb.set_trace()跟踪点。现在让我们来运行该程序。

localhost:~/python/pdb# python pdbtest.py
--Return--
> /usr/lib/python2.3/pdb.py(992)set_trace()->None
-> Pdb().set_trace()              # 从跟踪点开始执行
(Pdb) n                           # n 读入下一行代码
> /root/python/pdb/pdbtest.py(6)?()
-> b = "bbb"
(Pdb) n
> /root/python/pdb/pdbtest.py(7)?()
-> c = "ccc"
(Pdb) p b                         # p 打印变量值
'bbb'
(Pdb) l                           # l 显示当前执行位置
  2
  3     import pdb
  4     a = "aaa"
  5     pdb.set_trace()
  6     b = "bbb"
  7  -> c = "ccc"
  8     final = a + b + c
  9     print final
 10
[EOF]
(Pdb) n                         
> /root/python/pdb/pdbtest.py(8)?()
-> final = a + b + c
(Pdb) n                           # 如果命令和上次的一样，也可直接按回车，不用输入'n'
> /root/python/pdb/pdbtest.py(9)?()
-> print final
(Pdb) n
aaabbbccc
--Return--
> /root/python/pdb/pdbtest.py(9)?()->None
-> print final
(Pdb) p a,b,c,final
('aaa', 'bbb', 'ccc', 'aaabbbccc')
(Pdb)
('aaa', 'bbb', 'ccc', 'aaabbbccc')
(Pdb) n
localhost:~/python/pdb#           # 返回shell      

pdb还有很多命令，用help命令就可以列出所有的pdb命令，用help p可以查询p命令的说明。