表达式和语句：
常用的表达式操作符：
算术运算：+,-,*,/,//截断除法,%,**幂运算
逻辑运算：x or y,x and y,not x
比较运算：<,>,==,<=,>=,!=
一元运算：-x,+x,~x按位取反
三元选择表达式：x if yelse z
成员关系运算：x in y,x not in y
位运算：x | y,x<< y,x >> y,x & y,x ^ y
索引和分片：x[i],x[i:j],x[i:j:stride]
调用：x(...)
取属性：x.ATTRIBUTE
对象实例测试：x is y,x not is y,
匿名函数：lambd aargs: expression
生成器函数发送协议：yield x
元组()，列表[]，字典{}
运算优先级：
(...)
[...]
{...}
s[i],s[i:j],s[i:j:stride]
s.attribute
s(...)
+x,-y
x**y
*,/,//,%
+,-
<<,>>
&与
^异或
|或
<,<=,>,>=,==,!=
is,not is
in,not in
not
and
or
lambda
语句：
赋值语句（创建引用）
调用语句
print语句（打印对象）
if,elif,else（条件判断）
for,else（序列迭代）
while,else（普通循环）
pass（占位符）
break,continue
def,return
yield
global（命名空间）
from,import（模块属性访问）
class
try,except,finally（捕捉异常）
raise（手动触发异常）
del（删除引用）
assert（调试检查）
with,as（环境管理器）
python的比较操作：
所有python对象都支持比较操作，可用于测试相等性、相对大小等；
如果是复合对象，python会检查所有部分，包括自动遍历各级嵌套对象，直到可以得出最终结果；
测试操作符：（==，测试值的相等性；is表达式，测试对象的一致性）
python中不同类型的比较方法（数字，通过相对大小进行比较；字符串，按照字典次序逐字符比较；列表和元组，自左至右比较各部分内容；字典，对排序后的列表(key,value)进行比较）；
python中真和假的含义（非0数字为真，否则为假；非空对象为真，否则为假；None则始终为假；任何非0数字和非空对象都为真；数字0、空对象、特殊对象None均为假；比较和相等测试会递归的应用于数据结构中；返回值为True或False）
组合条件测试（x and y与运算；x or y或运算；not x非运算）
条件测试表达式：
语法结构（elif是可选的，若仅用于占位而后再填充相关语句时可使用pass）：
if boolean_expression1:
suite1
elif boolean_expression2:
suite2
...
else:
else_suite
三元表达式常用于赋值（max=A if A>B else B）：
语法结构（boolean_expression为True结果为expression1，否则为expression2）：
expression1 if boolean_expression else expression2
A = y if x else z，通常在为某变量设定默认值时使用，等同于：
if x:
A= y
else:
A= z
while循环：
用于编写通用迭代结构，顶端测试为真执行循环体，并会重复多次测试直到为假后执行循环后的其它语句
while语法（else分支可选，只要boolean_expression的结果为True循环执行，boolean_expression的结果为False若有else分支else分支将执行；else代码块，循环正常终止才会执行，如果循环终止是由break导致则else段语句不会执行）：
while boolean_expression:
while_suite
else:
else_suite
for循环：
一个通用的序列迭代器，用于遍历任何有序的序列对象内的元素；
可用于字符串、元组、列表和其它的内置可迭代对象，及通过类所创建的新对象；
for语法（通常expression是一个单独的变量或是一个变量序列，一般以元组的形式给出，如果将元组或列表用于expression，则其中的每个数据项都会拆分到表达式的项，如t=[(1,2),(3,4),(5,6)]，for (a,b) in t:）：
for expression1 initerable:
for_suite
else:
else_suite
python也提供了能进行隐性迭代的工具，（有：in成员关系测试；列表解析；map；reduce；filter）；
python提供了两个内置函数range和zip，用于在for循环中定制特殊的循环；
range是一次性生成所有数据元素都放在内存中，一次性返回连续的整数列表；
xrange一次产生一个数据元素，是用一个生成一个，对于非常大的序列用xrange可节约内存空间；
zip返回并行的元素元组的列表，常用于在for循环中遍历数个序列；
enumerate（产生偏移和元素，range可在非完备遍历中生成索引偏移而非偏移处的元素，如果同时需要偏移索引和偏移元素，使用enumerate()函数，此函数返回一个生成器对象）；
for循环比while循环执行速度快，尤其是遍历时要使用for循环；
非完备遍历：
In [52]: s1='how are you these days'
In [53]: for i in range(0,len(s1),2):
....: print s1[i],
....:
h w a e y u t e e d y
修改列表：
In [57]: l1=[1,2,3,4,5]
In [58]: for i in range(len(l1)):
....: l1[i]+=1
....:
In [59]: print l1
[2, 3, 4, 5, 6]
并行遍历zip（取得一个或多个序列为参数，将给定的并排的元素配成元组，返回这些元组的列表，当参数长度不同时，zip会以最短序列的长度为准，可在for循环中用于实现并行迭代，也常用于动态构造字典）：
In [60]: l1=[1,2,3,4,5,6,7]
In [61]: l2=['a','b','c','d','e','f','g']
In [62]: zip(l1,l2)
Out[62]: [(1, 'a'), (2, 'b'), (3, 'c'), (4,'d'), (5, 'e'), (6, 'f'), (7, 'g')]
In [63]: d1={}
In [64]: for (k,v) in zip(l1,l2):
....: d1[k]=v
....: print d1
....:
{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6:'f', 7: 'g'}
产生偏移和元素：
In [66]: s1='hello world'
In [67]: e1=enumerate(s1)
In [68]: e1.next()
Out[68]: (0, 'h')
In [69]: e1.next()
Out[69]: (1, 'e')
In [70]: e1.next()
Out[70]: (2, 'l')
In [71]: e1.next()
Out[71]: (3, 'l')
In [72]: e1.next()
Out[72]: (4, 'o')
举例1（逐一显示列表中的所有元素）：
方一：
In [2]: l1=[1,2,3,4,5]
In [3]: count=0
In [4]: while count < len(l1):
...: print l1[count]
...: count+=1
...:
1
2
3
4
5
方二：
In [5]: while l1:
...: print l1[0]
...: l1=l1[1:] #（此句也可写为l1.pop(0)）
...:
1
2
3
4
5
方三（逆序显示）：
In [11]: l1=[1,2,3,4,5]
In [12]: while l1:
....: print l1[-1]
....: l1.pop()
....:
5
4
3
2
1
方四（推荐使用）：
In [16]: for x in l1:
....: print x
....:
1
2
3
4
5
举例2（求100以内所有偶数之和）：
In [17]: sum=0
In [18]: for i in range(2,100,2):
....: sum+=i
....: print sum
....:
2450
举例三（逐一显示指定字典的所有key，并在最后显示总key数）：
方一（推荐使用）：
In [19]: d1={'x':1,'y':2,'z':3}
In [20]: keylist=d1.keys()
In [21]: print keylist
['y', 'x', 'z']
In [22]: for i in keylist:
....: print i,
....:
y x z
In [23]: print len(d1)
3
方二：
In [25]: keylist=d1.keys()
In [26]: while keylist:
....: print keylist[0]
....: keylist.pop(0)
....: else:
....: print len(d1)
....:
y
x
z
3
举例四（创建一个包含了100以内所有奇数的列表）：
方一：
In [27]: l1=[]
In [28]: x=1
In [29]: while x<100:
....: l1.append(x)
....: x+=2
....: print l1
....:
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23,25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63,65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]
方二（推荐使用）：
In [30]: l1=[]
In [31]: for i in range(1,100,2):
....: l1.append(i)
....: print l1
....:
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23,25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63,65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]
举例五（将两个列表生成字典）：
方一：
In [32]: l1=[1,2,3,4,5,6,7]
In [33]:l2=['mon','tue','wed','thu','fri','sat','sun']
In [34]: d1={}
In [35]: count=0
In [36]: if len(l1)==len(l2):
....: while count<len(l1):
....: d1[l1[count]=l2[count]
....: count+=1
....: print d1
....:
{1: 'mon', 2: 'tue', 3: 'wed', 4: 'thu', 5:'fri', 6: 'sat', 7: 'sun'}
方二：
In [48]: d1={}
In [49]: if len(l1)==len(l2):
....: for i in range(0,len(l1)):
....: d1[l1[i]]=l2[i]
....: print d1
....:
{1: 'mon', 2: 'tue', 3: 'wed', 4: 'thu', 5:'fri', 6: 'sat', 7: 'sun'}
举例六（逐一分开显示字典中的所有元素）：
In [73]: d1={'x':1,'y':2,'z':3}
In [74]: for (k,v) in d1.items():
....: print k,v
....:
y 2
x 1
z 3
举例七（逐一显示列表中索引为奇数的元素）：
In [76]: l1=['mon','tue','wed','thu','fri','sat','sun']
In [77]: for i in range(1,len(l1),2):
....: print l1[i]
....:
tue
thu
sat
举例八（将属于列表1但不属于列表2的所有元素定义为一个新列表3）：
In [78]:l1=['mon','tue','wed','thu','fri','sat','sun']
In [79]: l2=['sun','mon']
In [80]: l3=[]
In [81]: for i in l1:
....: if i not in l2:
....: l3.append(i)
....: print l3
....:
['tue', 'wed', 'thu', 'fri', 'sat']
举例九（将列表1中的每个元素从列表2中移除，属于l1不属于l2的忽略）：
In [82]: l1=['stu3','stu5']
In [83]: l2=['stu1','stu2','stu3','stu4','stu5']
In [84]: for i in l1:
....: if i in l2:
....: l2.remove(i)
....: print l2
....:
['stu1', 'stu2', 'stu4']
减少引用计数：
del VARIABLE_NAME（引用此对象的某变量名称被显示销毁）；
给引用此对象的某变量名重新赋值；
list.pop()、list.remove()等从容器中移除对象；
容器本身被销毁
增加对象的引用计数场景：
变量赋值（对象创建时）；
将对象添加进容器时，如list.append()；
当对象被当作参数传递给函数时；
为对象创建另外的变量名或多重目标赋值，如s1=s2=s3='ab'；
python迭代（重复做一件事，iterable可迭代对象，迭代器iterator）：
支持每次返回自己所包含的一个成员对象，对象实现了__iter__方法；
可迭代对象（序列类型有str、list、tuple；非序列类型有file、dict；用户自定义的一些包含了__iner__()或__getitem__()方法的类）；
dir(list)中有__iter__方法说明此对象支持迭代，某对象内部有__iter__或__getitem__方法，当这个对象调用此方法时会在内存中创建属于当前迭代器的可迭代对象，使用此内存地址的对象就可实现迭代，如i1=l1.__iter__()或i1=iter(l1)，再用 i1.next()遍历每个元素，遍历完成后迭代器不会从头开始再迭代；
l1.__iter__()，返回迭代器地址，要引用此地址如i1=l1.__iter__()；
iterator又称cursor游标，它是程序设计中的软件设计模式，是一种可在容器container上实现元素遍历的接口，iterator是一种特殊的数据结构，在python中以对象形式存在，对于一个集体中的每个元素，想要执行遍历，针对这个集体的迭代器定义了遍历集体中每个元素的顺序或方法，help(iter)；
在python中，iterator是遵循迭代协议的对象，使用iter()可从任何序列对象中得到迭代器，若要实现迭代器，需要在类中定义next()方法（python3.*中是__next__()），要使迭代器指向下一个元素，使用函数next()，当没有元素时引发StopIteration异常；
for循环可用于任何可迭代对象，for循环开始时，会通过迭代协议传递给iter()内置函数，从而能够从可迭代对象中获得一个迭代器，返回的对象含有需要的next()方法；
python列表解析是迭代机制的一种应用，常用于实现创建新的列表，因此要放在[]中，语法：
[expression for iter_var in iterable]
[expression for iter_var in iterable ifcond_expr]
举例1（这种方式性能较差）：
In [91]: l1=[1,2,3,4,5,6,7,8,9]
In [92]: l2=[]
In [93]: for i in l1:
....: l2.append(i**2)
....: print l2
....:
[1, 4, 9, 16, 25, 36, 49, 64, 81]
举例2（推荐使用）：
In [88]: l1=[x**2 for x in range(1,10)]
In [89]: print l1
[1, 4, 9, 16, 25, 36, 49, 64, 81]
举例3：
In [94]: import os
In [95]: files=os.listdir('/var/log')
In [96]: l1=[filename for filename in filesif filename.endswith('.log')]
In [97]: print l1
['anaconda.program.log','spice-vdagent.log', 'anaconda.yum.log', 'yum.log', 'vmware-tools-upgrader.log','boot.log', 'anaconda.ifcfg.log', 'pm-powersave.log', 'anaconda.storage.log','anaconda.log', 'Xorg.0.log', 'dracut.log', 'wpa_supplicant.log']
举例4：
In [101]: for i in [j**2 for j inrange(1,10) if j%2==0]:
.....: print i/2,
.....:
2 8 18 32
举例5：
In [102]: l1=['x','y','z']
In [103]: l2=[1,2,3]
In [104]: l3=[(i,j) for i in l1 for j inl2]
In [105]: l4=[(i,j) for i in l1 for j in l2if j!=1]
In [106]: print l3
[('x', 1), ('x', 2), ('x', 3), ('y', 1),('y', 2), ('y', 3), ('z', 1), ('z', 2), ('z', 3)]
In [107]: print l4
[('x', 2), ('x', 3), ('y', 2), ('y', 3),('z', 2), ('z', 3)]
注：若原列表元素本身就很多，列表解析后的结果又呈几何倍数增长，这会占用大量内存，这时要用到扩展列表解析也叫生成器generator（[]换为()），类似range和xrange的区别
generator生成器：
python2.4引入，并不真正创建数字列表，而是返回一个生成器对象，此对象在每次计算出一个条目后，把这个条目产生yield出来，生成器表达式使用了惰性计算或称作延迟求值的机制；
enumerate()函数返回一个生成器对象（range可在非完备遍历中用于生成索引偏移，而非偏移的元素，如果同时要偏移索引和偏移元素，可使用此函数）；
序列过长，且每次只需要获取一个元素时，应考虑使用生成器表达式而不是列表解析；
语法：
(expression for iter_var in iterable)
(expression for iter_var in iterable ifcond_expr)
举例1：
In [108]: g1=(i**2 for i in range(1,5)) #（要通过变量引用，若不引用是其内存地址，调用一次生成一个值）
In [109]: g1.next()
Out[109]: 1
In [110]: g1.next()
Out[110]: 4
In [111]: g1.next()
Out[111]: 9
In [112]: g1.next()
Out[112]: 16
举例2：
In [119]: for j in (i**2 for i inrange(1,11) if i%2==0):
.....: print j/2
.....:
2
8
18
32
50
举例3：
In [124]: url='www.magedu.com'
In [125]: g1=enumerate(url)
In [126]: g1.next()
Out[126]: (0, 'w')
In [127]: g1.next()
Out[127]: (1, 'w')
In [128]: g1.next()
Out[128]: (2, 'w')
In [129]: g1.next()
Out[129]: (3, '.')
In [130]: g1.next()
Out[130]: (4, 'm')
python文件对象：
FS是OS用于明确磁盘或分区上的文件的方法和数据结构（即在磁盘上组织文件的方法）；
计算机文件（或称文件、电脑档案、档案）是存储在某种长期储存设备或临时存储设备中的一段数据流，且归属于计算机FS管理之下；
文件是计算机中由OS管理的具有名字的存储区域，在linuxOS上文件被看成是字节序列；
open()，此内置函数用于打开文件和创建文件对象，语法：
open(filename[,mode[,bufsize]])；
open()方法接收三个参数，文件名、模式和缓冲区参数：
open()函数返回的是一个文件对象（内存中的位置，要用变量引用）；
mode指定文件的打开模式，r、w、a附加、r+、w+、a+、rb、wb（后面有加号表示同时支持输入输出操作即读入写出，后面有b表示以二进制方式打开）；
bufsize定义输入输出缓存（0表示禁用，无输出缓存；1表示使用缓存，要指定缓冲区大小；负数表示使用系统默认设置；正数表示使用近似指定大小的缓冲）；
In [1]: f1=open('/etc/passwd','r')
In [2]: type(f1)
Out[2]: file
In [3]: f1.<TAB>
f1.close f1.errors f1.isatty f1.newlines f1.readinto f1.seek f1.truncate f1.xreadlines
f1.closed f1.fileno f1.mode f1.next f1.readline f1.softspace f1.write
f1.encoding f1.flush f1.name f1.read f1.readlines f1.tell f1.writelines
In [3]: f1.next()
Out[3]: 'root:x:0:0:root:/root:/bin/bash\n'
In [4]: f1.next()
Out[4]:'bin:x:1:1:bin:/bin:/sbin/nologin\n'
In [5]: f1.next()
Out[5]:'daemon:x:2:2:daemon:/sbin:/sbin/nologin\n'
In [6]: print dir(file)
['__class__', '__delattr__', '__doc__','__enter__', '__exit__', '__format__', '__getattribute__', '__hash__','__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__','__setattr__', '__sizeof__', '__str__', '__subclasshook__','close', 'closed', 'encoding', 'errors', 'fileno', 'flush','isatty', 'mode', 'name', 'newlines', 'next', 'read', 'readinto', 'readline','readlines', 'seek', 'softspace', 'tell', 'truncate', 'write', 'writelines','xreadlines']
In [7]: help(f1.fileno) #（文件描述符，0、1、2系统默认的标准输入、标准输出、标准错误输出）
fileno() -> integer "filedescriptor".
This is needed for lower-level fileinterfaces, such os.read().
In [8]: f1.fileno()
Out[8]: 7
In [56]: f1.readline() #（一次读取一行并返回指针，若使用f1.next()则不会移动指针）
Out[56]:'root:x:0:0:root:/root:/bin/bash\n'
In [57]: f1.readline()
Out[57]:'bin:x:1:1:bin:/bin:/sbin/nologin\n'
In [58]: f1.tell() #（返回当前指针在文件中的位置，单位是字节，若是追加会将指针移至最后）
Out[58]: 65
In [59]: f1.readlines() #（将文件所有内容按行生成列表，行结束符也在列表元素中，若文件很大时会占用内存空间）
Out[59]:
['daemon:x:2:2:daemon:/sbin:/sbin/nologin\n',
'adm:x:3:4:adm:/var/adm:/sbin/nologin\n',
'lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin\n',
……
'nagios:x:501:502::/home/nagios:/bin/bash\n']
In [60]: help(file.seek)
seek(offset[, whence])-> None. Move to new file position.（whence值有0、1、2表示起点位置，默认0表示从文件头，1表示从当前位置，2表示从文件尾部；offset表示偏移量）
In [61]: f1.seek(0) #（f1.seek(0,2)，从文件尾部偏移0个byte）
In [62]: f1.tell()
Out[62]: 0
In [63]: f1.seek(65)
In [64]: f1.readline()
Out[64]:'daemon:x:2:2:daemon:/sbin:/sbin/nologin\n'
In [65]: f1.tell()
Out[65]: 105
In [66]: help(file.read)
read([size]) -> readat most size bytes, returned as a string.（以bytes为单位读字串）
In [67]: f1.read(10)
Out[67]: 'adm:x:3:4:'
In [68]: f1.tell()
Out[68]: 115
In [69]: f1.next()
Out[69]: 'adm:/var/adm:/sbin/nologin\n'
In [70]: f1.tell()
Out[70]: 1515
In [73]: help(file.name)
Help on member descriptor__builtin__.file.name:（获取当前文件名，name是属性不是方法）
In [74]: f1.name
Out[74]: '/etc/passwd'
In [75]: s1='abc'
In [76]: s2='xyz'
In [77]: s1.join(s2) #（以s1为分隔符连接s2中的每个元素）
Out[77]: 'xabcyabcz'
In [78]: ' '.join(s1) #（通常这么用，' '.join，在join前面是分隔符delimeter此例是空格）
Out[78]: 'a b c'
In [79]: ' '.join(s2)
Out[79]: 'x y z'
In [80]: s1+s2 #（连接两个字串）
Out[80]: 'abcxyz'
In [81]:help(file.writelines)
writelines(sequence_of_strings)-> None. Write the strings to thefile.（将列表中的所有元素的字符串连接）
In [85]: f1=open('/tmp/test.txt','r+')
In [86]: f1.writelines(l1) #（此种方式最终test.txt中保存的内容杂乱无章）
In [87]: f1.flush()
In [88]: l2=[i+'\n' for i inos.listdir('/etc')] #（此种方式会将每个文件或目录换行显示）
In [89]: f1.writelines(l2)
In [90]: f1.flush()
[root@localhost ~]# cat /tmp/test.txt
rc.sysinit
favicon.png
ld.so.cache
libreport
……
In [91]:help(file.isatty)
isatty() -> true orfalse. True if the file is connected toa tty device.（判断某一文件是否是终端设备文件）
In [96]: f1=open('/dev/tty')
In [97]: f1.isatty()
Out[97]: True
In [99]:help(file.truncate)
truncate([size]) ->None. Truncate the file to at most sizebytes.（文件截取）
In [113]: f1.truncate(f1.tell()) #（指针所在处之后的内容全部删掉）
In [115]: f1.closed #（closed是属性，判断文件是否为关闭状态）
Out[115]: False
In [116]: f1.encoding #（获取当前文件编码）
In [117]: f1.mode #（获取当前文件打开时的模式）
Out[117]: 'a+'
In [118]: f1.newlines #（显示指针所在位置之前的行结束符）
In [121]: f1.close()
In [122]: f1.closed
Out[122]: True
In [1]: import os
In [2]: os.<TAB> #（os模块下有很多方法和属性，将OS中用C语言编写的命令用python封装即可调用）
Display all 207 possibilities? (y or n)
os.EX_CANTCREAT os.SEEK_END os.execve os.lstat os.setuid
os.EX_CONFIG os.SEEK_SET os.execvp os.major os.spawnl
os.EX_DATAERR os.TMP_MAX os.execvpe os.makedev os.spawnle
os.EX_IOERR os.UserDict os.extsep os.makedirs os.spawnlp
os.EX_NOHOST os.WCONTINUED os.fchdir os.minor os.spawnlpe
os.EX_NOINPUT os.WCOREDUMP os.fchmod os.mkdir os.spawnv
os.EX_NOPERM os.WEXITSTATUS os.fchown os.mkfifo os.spawnve
os.EX_NOUSER os.WIFCONTINUED os.fdatasync os.mknod os.spawnvp
os.EX_OK os.WIFEXITED os.fdopen os.name os.spawnvpe
os.EX_OSERR os.WIFSIGNALED os.fork os.nice os.stat
os.EX_OSFILE os.WIFSTOPPED os.forkpty os.open os.stat_float_times
os.EX_PROTOCOL os.WNOHANG os.fpathconf os.openpty os.stat_result
os.EX_SOFTWARE os.WSTOPSIG os.fstat os.pardir os.statvfs
os.EX_TEMPFAIL os.WTERMSIG os.fstatvfs os.path os.statvfs_result
os.EX_UNAVAILABLE os.WUNTRACED os.fsync os.pathconf os.strerror
os.EX_USAGE os.W_OK os.ftruncate os.pathconf_names os.symlink
os.F_OK os.X_OK os.getcwd os.pathsep os.sys
os.NGROUPS_MAX os.abort os.getcwdu os.pipe os.sysconf
os.O_APPEND os.access os.getegid os.popen os.sysconf_names
os.O_ASYNC os.altsep os.getenv os.popen2 os.system
os.O_CREAT os.chdir os.geteuid os.popen3 os.tcgetpgrp
os.O_DIRECT os.chmod os.getgid os.popen4 os.tcsetpgrp
os.O_DIRECTORY os.chown os.getgroups os.putenv os.tempnam
os.O_DSYNC os.chroot os.getloadavg os.read os.times
os.O_EXCL os.close os.getlogin os.readlink os.tmpfile
os.O_LARGEFILE os.closerange os.getpgid os.remove os.tmpnam
os.O_NDELAY os.confstr os.getpgrp os.removedirs os.ttyname
os.O_NOATIME os.confstr_names os.getpid os.rename os.umask
os.O_NOCTTY os.ctermid os.getppid os.renames os.uname
os.O_NOFOLLOW os.curdir os.getresgid os.rmdir os.unlink os.O_NONBLOCK os.defpath os.getresuid os.sep os.unsetenv
os.O_RDONLY os.devnull os.getsid os.setegid os.urandom
os.O_RDWR os.dup os.getuid os.seteuid os.utime
os.O_RSYNC os.dup2 os.initgroups os.setgid os.wait
os.O_SYNC os.environ os.isatty os.setgroups os.wait3
os.O_TRUNC os.errno os.kill os.setpgid os.wait4
os.O_WRONLY os.error os.killpg os.setpgrp os.waitpid
os.P_NOWAIT os.execl os.lchown os.setregid os.walk
os.P_NOWAITO os.execle os.linesep os.setresgid os.write
os.P_WAIT os.execlp os.link os.setresuid
os.R_OK os.execlpe os.listdir os.setreuid
os.SEEK_CUR os.execv os.lseek os.setsid
与目录相关：
os.chdir(path)（改变当前工作目录）
os.fchdir(fildes)（改变当前的工作目录到由文件描述符fd表示的目录，描述符必须是指向一个打开的目录而不是一个打开的文件）
os.chroot(path)（设定当前进程的根目录）
os.listdir(path)（显示指定目录下的所有文件名）
os.mkdir(path[,mode=0777])（创建指定目录）
os.makedirs(path[,mode=0777])（递归创建指定目录，类似系统中mkdir -p /path/to/）
os.getcwd()（获取当前目录路径）
os.rmdir(path)（删除目录）
os.removedirs(path)（删除多级目录，类似rm -rf）
os.stat(path)
与文件相关：
os.remove(path)（删除文件，同os.unlink(path)）
os.unlink(path)（删除链接文件，Remove a file (same asremove(path))）
os.rename(old.new)（重命名文件或目录Rename a file or directory.)
os.stat(path)（返回文件状态信息Perform a stat system call on the given path.）
os.symlink(src,dst)（创建链接文件）
os.utime(path,None)（更新文件时间戳为当前时间，访问时间和修改时间，set theaccess and modified times to the current time）
os.utime(path,(atime,mtime)) （更新文件时间为指定时间，Set the access and modified time of the file to the given values）
os.tmpfile()（创建一临时文件，Create a temporary file with no directory entries.）
os.mkfifo(filename[,mode=0666])（创建命名管道）
os.mknod(filename[,mode=0600,device])（Create a filesystem node (file,device special file or named pipe)named filename.创建设备文件）
os.makedev(major,minor)（根据指定的主设备号、次设备号创建设备，Composes a rawdevice number from the major and minor device numbers.）
os.major(device)（根据指定的设备获取主设备号，Extracts a devicemajor number from a raw device number.）
os.minor(device)（根据指定的设备获取次设备号，Extracts a deviceminor number from a raw device number.）
os.walk(top,topdown=True,onerror=None,followlinks=False)（将多级目录生成元组，子目录及其下的文件分别是列表中的元素，Foreach directory in the directory tree rooted at top (including top itself, butexcluding '.' and '..'), yields a 3-tuple）
举例：
In [2]: import os
In [3]: g1=os.walk('/tmp')
In [4]: g1.next()
Out[4]:
('/tmp',
['VMwareDnD', '.ICE-unix','pulse-MUK7gfWor9cA', '.esd-500'],
['test.txt'])
In [5]: g1.next()
Out[5]: ('/tmp/VMwareDnD', [], [])
In [6]: g1.next()
Out[6]: ('/tmp/.ICE-unix', [], [])
In [7]: g1.next()
Out[7]: ('/tmp/pulse-MUK7gfWor9cA', [],['native'])
举例（遍历目录，连接目录与文件，常用）：
In [19]: g=os.walk('/tmp/test')
In [20]: for path,d,filelist in g:
for filename in filelist:
print os.path.join(path,filename)
....:
/tmp/test/test3/t2.txt
/tmp/test/test2/test21/t1.txt
与访问权限相关：
os.access(path,mode)（检查某用户对指定文件是否有访问权限，此处mode为用户的uid或gid，Use the real uid/gid to test for access to a path.）
os.chmod(path,mode)（修改权限，mode为0755，Change the access permissions of a file.）
os.chown(path,uid,gid)（修改指定文件的属主属组，Change the owner andgroup id of path to the numeric uid and gid.）
os.umask(new_mask)（修改默认权限模式，Set the current numericumask and return the previous umask.）
与文件描述符相关：
os.open(filename,flag[,mode=0777])（Open a file (for low level IO).）
os.read(fd,buffersize)（Read a file descriptor.）
os.write(fd,string)（Write a string to a filedescriptor.）
与文件路径相关：
In [5]: os.path.<TAB>
os.path.abspath os.path.getmtime os.path.relpath
os.path.altsep os.path.getsize os.path.samefile
os.path.basename os.path.isabs os.path.sameopenfile
os.path.commonprefix os.path.isdir os.path.samestat
os.path.curdir os.path.isfile os.path.sep
os.path.defpath os.path.islink os.path.split
os.path.devnull os.path.ismount os.path.splitdrive
os.path.dirname os.path.join os.path.splitext
os.path.exists os.path.lexists os.path.stat
os.path.expanduser os.path.normcase os.path.supports_unicode_filenames
os.path.expandvars os.path.normpath os.path.sys
os.path.extsep os.path.os os.path.walk
os.path.genericpath os.path.pardir os.path.warnings
os.path.getatime os.path.pathsep
os.path.getctime os.path.realpath
os.path.basename(path)（路径基名，Returns the final component ofa pathname）
os.path.dirname(path)（路径目录名，Returns the directorycomponent of a pathname）
os.path.join(a,*p)（Join two or more pathnamecomponents, inserting '/' as needed.）
os.path.split(p)（返回dirname()、basename()结果的元组，Split a pathname. Returns tuple "(head, tail)" where"tail" is everything after the final slash. Either part may be empty.）
os.path.splitext(p)（返回filename文件名、文件扩展名extention（扩展名包括dot点）为元组，Split the extension from apathname.）
os.path.getatime(filename)（Return the last access time of afile, reported by os.stat()）
os.path.getctime(filename)（Return the metadata change time ofa file, reported by os.stat().）
os.path.getmtime(filename)（Return the last modification timeof a file, reported by os.stat().）
os.path.getsize(filename)（Return the size of a file, reportedby os.stat().）
os.path.exists(path)（判断指定文件是否存在，Test whether a pathexists. Returns False for brokensymbolic links）
os.path.isabs(s)（判断指定路径是否绝对路径，Test whether a path isabsolute）
os.path.isdir(s)（判断路径是否存在且为目录，Return true if thepathname refers to an existing directory.）
os.path.isfile(path)（判断文件是否存在且为普通文件，Test whether a pathis a regular file）
os.path.islink(path)（判断文件是否存在且为链接文件，Test whether a pathis a symbolic link）
os.path.ismount(path)（判断文件是否存在且为挂载点，Test whether a pathis a mount point）
os.path.samefile(f1,f2)（判断两个路径是否指向同一个文件，Test whether twopathnames reference the same actual file）
举例：
In [20]:dir1=os.path.dirname('/etc/sysconfig/network-scripts/ifcfg-eth0')
In [21]: print dir1
/etc/sysconfig/network-scripts
In [22]:file1=os.path.basename('/etc/sysconfig/network-scripts/ifcfg-eth0')
In [23]: print file1
ifcfg-eth0
[root@localhost ~]# mkdir /tmp/testdir
[root@localhost ~]# touch /root/test.txt
In [1]: import os
In [2]:dir1=os.path.dirname('/tmp/testdir')
In [3]:file1=os.path.basename('/root/test.txt')
In [4]: os.path.join(dir1,file1)
Out[4]: '/tmp/test.txt'
In [9]: for file in os.listdir('/tmp'):
print os.path.join('/tmp',file)
...:
/tmp/VMwareDnD
/tmp/testdir
/tmp/.ICE-unix
/tmp/pulse-MUK7gfWor9cA
/tmp/test.txt
/tmp/.esd-500
In [12]:os.path.split('/etc/sysconfig/network-scripts/ifcfg-eth0')
Out[12]: ('/etc/sysconfig/network-scripts','ifcfg-eth0')
In [13]:os.path.splitext('/etc/sysconfig/network-scripts/ifcfg-eth0')
Out[13]: ('/etc/sysconfig/network-scripts/ifcfg-eth0','')
In [15]: os.path.splitext('/root/test.txt')
Out[15]: ('/root/test', '.txt')
举例（判断文件是否存在，存在则打开，可让用户通过键盘反复输入多行数据追加至文件中）：
[root@localhost ~]# vim test.py
-------------------script start-------------------
#!/usr/bin/python2.7
#filename:test.py
import os
filename='/tmp/test.txt'
if os.path.isfile(filename):
f1=open(filename,'a+')
while True:
line=raw_input('Enter something:')
if line=='q' or line=='quit':
break
f1.write(line+'\n')
f1.flush()
f1.close()
--------------------script end---------------------
[root@localhost ~]# chmod 755 test.py
[root@localhost ~]# ./test.py
Enter something:i am jowin
Enter something:who are you
Enter something:hehe
Enter something:q
[root@localhost ~]# cat /tmp/test.txt
i am jowin
who are you
hehe
pickle、marshal对象持久存储（保存了对象的原数据结构，流式化存在文件中）：
DBM（仅写数据库，未实现流式化）；shelve模块（既写入DB，又实现流式化）；
In [1]: d1={'x':1,'y':2,'z':3}
In [2]: f1=open('/tmp/test.txt','w+')
In [3]: f1.write(d1) #（直接将对象写入文件会报错，要通过pickle或marshal实现）
---------------------------------------------------------------------------
TypeError Traceback(most recent call last)
<ipython-input-3-03e18951d68d> in<module>()
----> 1 f1.write(d1)
TypeError: expected acharacter buffer object
In [4]: import pickle
In [5]: pickle.<TAB>
Display all 116 possibilities? (y or n)
pickle.APPEND pickle.EXT4 pickle.ModuleType pickle.TUPLE
pickle.APPENDS pickle.EllipsisType pickle.NEWFALSE pickle.TUPLE1
pickle.BINFLOAT pickle.FALSE pickle.NEWOBJ pickle.TUPLE2 ……
用法：
pickle.dump(obj,file,protocol=None)（将对象写入文件）
pickle.load(file)（将对象从文件中恢复，要使用变量引用否则得到的是内存地址）
In [6]: pickle.dump(d1,f1)
In [7]: f1.flush()
In [8]: f1.close()
[root@localhost ~]# cat /tmp/test.txt
(dp0
S'y'
p1
I2
sS'x'
p2
I1
sS'z'
p3
I3
s.
In [12]: f2=open('/tmp/test.txt')
In [13]: d2=pickle.load(f2)
In [14]: print d2
{'y': 2, 'x': 1, 'z': 3}
copy模块，python对内存的使用（浅拷贝与深拷贝）：
copy.copy()浅拷贝（对引用的拷贝，只拷贝父对象（变量引用））；
copy.deepcopy()深拷贝（对对象资源的拷贝）；
In [1]: import copy
In [3]: copy.<TAB>
copy.Error copy.copy copy.dispatch_table copy.name copy.weakref
copy.PyStringMap copy.deepcopy copy.error copy.t
In [3]: help(copy.copy)
copy(x)
Shallow copy operation on arbitrary Python objects.
deepcopy(x, memo=None,_nil=[])
Deep copy operation on arbitrary Python objects.
In [5]: a=[1,2,3]
In [6]: b=a
In [7]: id(a)
Out[7]: 20685600
In [8]: id(b)
Out[8]: 20685600
In [9]: a.append(4)
In [10]: a
Out[10]: [1, 2, 3, 4]
In [11]: b
Out[11]: [1, 2, 3, 4]
In [12]: id(a)
Out[12]: 20685600
In [13]: id(b)
Out[13]: 20685600
In [14]: a=[1,2,3,['a','b','c']]
In [15]: b=a
In [16]: c=copy.copy(a)
In [17]: id(a)
Out[17]: 20688120
In [18]: id(b)
Out[18]: 20688120
In [19]: id(c)
Out[19]: 20673096
In [20]: a.append('f')
In [21]: a
Out[21]: [1, 2, 3, ['a', 'b', 'c'], 'f']
In [22]: b
Out[22]: [1, 2, 3, ['a', 'b', 'c'], 'f']
In [23]: c
Out[23]: [1, 2, 3, ['a', 'b', 'c']]
In [24]: id(a[0])
Out[24]: 8543336
In [25]: id(c[0])
Out[25]: 8543336
In [26]: id(a[3])
Out[26]: 20688840
In [27]: id(c[3])
Out[27]: 20688840
