Python第十一天    異常處理  glob模塊和shlex模塊    打開外部程序和subprocess模塊  subprocess類  Pipe管道  operator模塊   sorted函數   生成器  walk模塊   hashlib模塊

目錄

Pycharm使用技巧（轉載）

Python第一天  安裝  shell  文件

Python第二天  變量  運算符與表達式  input()與raw_input()區別  字符編碼  python轉義符  字符串格式化

Python第三天 序列  5種數據類型  數值  字符串  列表  元組  字典

Python第四天   流程控制   if else條件判斷   for循環 while循環

Python第五天   文件訪問    for循環訪問文件    while循環訪問文件   字符串的startswith函數和split函數

Python第六天   類型轉換

Python第七天   函數  函數參數   函數變量   函數返回值  多類型傳值    冗余參數   函數遞歸調用   匿名函數   內置函數   列表表達式/列表重寫

Python第八天  模塊   包   全局變量和內置變量__name__    Python path

Python第九天  面向對象  類定義   類的屬性    類的方法    內部類   垃圾回收機制   類的繼承 裝飾器

Python第十天   print >> f,和fd.write()的區別    stdout的buffer  標準輸入 標準輸出  標準錯誤   重定向 輸出流和輸入流

Python第十一天    異常處理  glob模塊和shlex模塊    打開外部程序和subprocess模塊  subprocess類  Pipe管道  operator模塊   sorted函數   生成器  walk模塊   hashlib模塊

Python第十二天     收集主機信息     正則表達式  無名分組   有名分組

Python第十三天   django 1.6   導入模板   定義數據模型   訪問數據庫   GET和POST方法    SimpleCMDB項目   urllib模塊   urllib2模塊  httplib模塊  django和web服務器整合  wsgi模塊   gunicorn模塊

Python第十四天 序列化  pickle模塊  cPickle模塊  JSON模塊  API的兩種格式

Python第十五天  datetime模塊 time模塊   thread模塊  threading模塊  Queue隊列模塊  multiprocessing模塊  paramiko模塊  fabric模塊  

python標準庫，python自帶的模塊
不是python標準庫，不是python自帶的模塊都需要安裝第三方軟件

hashlib模塊
相當于shell里面的md5sum命令
一定要去除換行符

不能對目錄進行求md5值，變通一下，對目錄下的所有文件求md5值就是目錄的md5值

import hashlib
md5 = hashlib.md5()
md5.update('hello')
md5.hexdigest()
'5d41402abc4b2a76b9719d911017c592'

hashlib.md5(lines).hexdigest()

等價于 echo -n hello |md5sum  #echo一定要加 -n，不然md5sum會把換行符也算進去
5d41402abc4b2a76b9719d911017c592

md5.update方法會追加后來添加的值
md5.update('a')
md5.update('b')
#計算出來的是ab的md5值，也就是md5.update('ab')
md5.hexdigest()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
md5加密一個文件
Date:2016.08.12
"""




import sys
import hashlib

def md5sum(f):
    m = hashlib.md5()
    with open(f) as fd:
        while True:
            data = fd.read(4096)
            if data:
                m.update(data)
            else:
                break
    return m.hexdigest()

if __name__ == '__main__':
    try:
        print md5sum(sys.argv[1])
    except IndexError:
        print "%s follow a argument" % __file__

hashlib.md5 只是一個生成hash對象的hash函數
openssl_md5(...)
Returns a md5 hash object; optionally initialized with a string

print hashlib.md5
<built-in function openssl_md5>

####################
hashlib.md5() 返回一個hash對象
class HASH(__builtin__.object)
| A hash represents the object used to calculate a checksum of a
| string of information.
|
| Methods: 方法
|
| update() -- updates the current digest with an additional string 更新md5對象的原有內容 再加上本次加的內容
md5.update('a')
md5.update('b')
#計算出來的是ab的md5值，也就是md5.update('ab')
| digest() -- return the current digest value 返回md5對象的內容
| hexdigest() -- return the current digest as a string of hexadecimal digits 返回md5對象加密后的內容
| copy() -- return a copy of the current hash object 返回md5對象的拷貝
|
| Attributes: 屬性
|
| name -- the hash algorithm being used by this object， hash算法名字一般返回md5
| digest_size -- number of bytes in this hashes output
print hashlib.md5()
<md5 HASH object @ 000000000220DA30>

walk模塊

os.walk 

迭代目錄里文件
os.walk返回的是1個元組（生成器對象）， 生成目錄樹，這個元組有3個元素，分別是dirpath, dirnames, filenames，所以使用3個變量p,d,f去接收這3個元素，即for p,d,f in a
filenames是個列表，對應的是f，所以對f進行for循環遍歷，取里面的每一個文件名，最后把文件名組織成帶路徑的，即os.path.join(p,i)。

例如

ll -R /tmp/mysql/
/tmp/mysql/:
total 12
-rw-r--r-- 1 root root    7 Sep 17 10:04 22.txt
drwxr-xr-x 3 root root 4096 Sep 17 11:15 3dir
-rw-r--r-- 1 root root    5 Sep 17 11:15 88.txt

/tmp/mysql/3dir:
total 8
drwxr-xr-x 2 root root 4096 Sep 17 11:24 2dir
-rw-r--r-- 1 root root    4 Sep 17 11:08 33.txt

/tmp/mysql/3dir/2dir:
total 4
-rw-r--r-- 1 root root 4 Sep 17 11:24 55.txt



roo = os.walk("/tmp/mysql")
for p, d, f in roo:
    print p,d,f   
/tmp/mysql ['3dir'] ['88.txt', '22.txt']
/tmp/mysql/3dir ['2dir'] ['33.txt']
/tmp/mysql/3dir/2dir [] ['55.txt']
dirpath, dirnames, filenames
如果目錄下面沒有目錄則dirnames為空

示例
def 遞歸打印指定目錄下的目錄和文件(topdir):
    roo = os.walk(topdir)
    for p, d, f in roo:
        for i in f:
            print os.path.join(p,i)
        for j in d:
            print os.path.join(p,j)
            

示例
#!/usr/bin/env python

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
實現功能：find  . -type f  -exec md5sum {} \;
Date:2016.08.12
"""





import os
import sys
import hashlib

def md5sum(f):
   m = hashlib.md5()
   with open(f) as fd:
       while True:
           data = fd.read(4096)
           if data:
               m.update(data)
           else:
               break
               return m.hexdigest()

def file_md5(topdir):
    a = os.walk(topdir)
    for p, d, f in a:
        for i in f:
            fn = os.path.join(p,i)
            md5 = md5sum(fn)
            yield "%s %s" % (md5, fn)  # 每調用一次，返回一個文件和該文件的md5值，當然也可以把文件和md5值保存在字典里，讀取字典里的key和value

if __name__ == '__main__':
    lines = ''
try:
    topdir = sys.argv[1]
except IndexError:
    print "%s follow a dir" % __file__
    sys.exit()

gen = file_md5(topdir)  #gen是一個生成器對象

for i in gen:
    lines += i+'\n'
print lines
print hashlib.md5(lines).hexdigest()

生成器

百度百科的解釋
生成器是一次生成一個值的特殊類型函數。可以將其視為可恢復函數。調用該函數將返回一個可用于生成連續 x 值的生成器【Generator】，簡單的說就是在函數的執行過程中，yield語句會把你需要的值返回給調用生成器的地方，然后退出函數，下一次調用生成器函數的時候又從上次中斷的地方開始執行，而生成器內的所有變量參數都會被保存下來供下一次使用。

容器(container)
容器是一種把多個元素組織在一起的數據結構，容器中的元素可以逐個地迭代獲取，可以用 in , not in 關鍵字判斷元素是否包含在容器中。通常這類數據結構把所有的元素存儲在內存中（也有一些特列并不是所有的元素都放在內存）在Python中，常見的容器對象有：

list, deque, ....
set, frozensets, ....
dict, defaultdict, OrderedDict, Counter, ....
tuple, namedtuple, …
str


可迭代對象(iterable)
剛才說過，很多容器都是可迭代對象，此外還有更多的對象同樣也是可迭代對象，比如處于打開狀態的files，sockets等等。
但凡是可以返回一個 迭代器 的對象都可稱之為可迭代對象


什么是迭代器呢？
它是一個帶狀態的對象，他能在你調用 next() 方法的時候返回容器中的下一個值，任何實現了 __next__() （python2中實現 next() ）方法的對象都是迭代器


序列：字符串、列表、元組
序列跟迭代器不一樣，序列對象沒有next()方法


生成器(generator)
生成器算得上是Python語言中最吸引人的特性之一，生成器其實是一種特殊的迭代器，不過這種迭代器更加優雅。
它不需要再像上面的類一樣寫 __iter__() 和 __next__() 方法了，只需要一個 yiled 關鍵字。 因此任何生成器也是以一種懶加載的模式生成值。，因此任何生成器也是以一種懶加載的模式生成值。

例如數據庫的全局唯一ID生成器，也是一種生成器


生成器是迭代器，但是迭代器不一定是生成器，因為生成器是有狀態的！！！！！！

 

生成器對象
mygenerator = (x*x for x in range(4))  #用小括號而不是中括號，中括號是列表重寫，mygenerator 生成器對象
for i in mygenerator : print i 調用next方法


next()方法
mygenerator.next()

#文件也是生成器
f=open('/etc/hosts')
for i in f : print i 調用next方法，f.next()


yield
當調用這個函數的時候，函數內部的代碼并不立馬執行 ，
這個函數只是返回一個生成器對象
當使用for進行迭代的時候，函數內的代碼才會被執行
因為函數里出現了yield，我們把這個函數叫做生成器
當產生一個生成器的時候，每遍歷一次，yield就會吐出一個值，這個值是不會保存在內存里的，除非有其他變量來接收這個值。


>>> def h():
... print 'one'
... yield 1
... print 'two'
... yield 2
... print 'three'
... yield 3
...
>>> c = h()
>>> c.next()

def f(n):
    for i in range(n):
    yield i

a = f(5)
a.next()
for i in a: print i

生成器是一個可迭代的對象，可以對可迭代對象進行遍歷，比如字符串，列表等，都是可迭代對象

return與yield區別
return的時候這個函數的局部變量就都銷毀了
所以return是得到所有結果之后的返回
yield是產生了一個可以恢復的函數（生成器），恢復了局部變量。
生成器只有在調用.next()時才運行函數生成一個結果

def file_md5(topdir):
    a = os.walk(topdir)
    for p, d, f in a:
        for i in f:
            fn = os.path.join(p,i)
            md5 = md5sum(fn)
            print  "%s %s" % (md5, fn)
            
#改寫為生成器            
def file_md5(topdir):
    a = os.walk(topdir)
    for p, d, f in a:
        for i in f:
            fn = os.path.join(p,i)
            md5 = md5sum(fn)
            yield "%s %s" % (md5, fn)

operator模塊
sorted函數

按字典值排序

sorted函數
第一個參數是必須的，必須傳入一個可迭代對象用來排序，其他參數都有默認值
reverse表示正向還是反向排序，默認是false即是正向
key表示排序的值，如果是字典通過operator來選擇key排序還是value排序
返回值是一個列表，跟字典轉列表一樣

dic={1:1,2:2,3:3}
print dic.items()
[(1, 1), (2, 2), (3, 3)]

sorted(可迭代對象,cmp,key,reverse)

operator.itemgetter(0)：按照key來排序
operator.itemgetter(1)：按照value來排序

按照字典value排序，類似sort -k命令
import operator
x = {1:2, 3:4, 4:3, 2:1, 0:0}
sorted_x = sorted(x.iteritems(), key=operator.itemgetter(1))
sorted_y = sorted(x.iteritems(), key=operator.itemgetter(1), reverse=True)

找出占用空間大的文件
os.walk
os.path.getsize
dict sort (top10)
#!/usr/bin/env python

import os
import sys
import operator

def gen_dic(topdir):
    dic = {}
    a = os.walk(topdir)
    for p, d, f in a:
        for i in f:
            fn = os.path.join(p, i)
            f_size = os.path.getsize(fn)
            dic[fn] = f_size
    return dic

if __name__ == '__main__':
    dic = gen_dic(sys.argv[1])
    sorted_dic = sorted(dic.iteritems(), key=operator.itemgetter(1), reverse=True)
    for k, v in sorted_dic[:10]:
        print k, '-->', v

打開外部程序和subprocess模塊  subprocess類  Pipe管道

os.system：輸出在終端上，捕獲不到
os.popen：只能捕捉到標準輸出，捕捉不到標準錯誤輸出
os.popen2：返回2個對象，一個是標準輸入，一個標準輸出
os.popen3：返回3個對象，標準輸入，標準輸出，標準錯誤輸出
os.popen4：已經廢棄，不建議使用，用subprocess模塊代替，返回2個對象，pipe_in和pipe_out_err

os.popenX都不建議使用，使用subprocess模塊代替os.popenX

示例

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
實現功能：find  . -type f  -exec md5sum {} \;
Date:2016.08.12
"""import os

s = os.system('ls')
print s # 只能看到命令成功與否的返回值，不能保存命令執行結果

pipe_out = os.popen('ls')
pipe_out.read() # 讀取命令的執行結果

(pipe_in, pipe_out) = os.popen2('sort')
pipe_in.write('z\n')
pipe_in.write('a\n')
pipe_in.close() # 關閉管道 關閉文件
pipe_out.read()

pipe_in, pipe_out, pipe_err = os.popen3('sort')
pipe_err.read()

pipe_in, pipe_out_err = os.popen4('sort')

subprocess
import subprocess
subprocess.call(['ls', '-l','--color','/root'])  ,call(*popenargs, **kwargs) call函數默認接收多個參數，元組和字典
subprocess.call('ls -l --color /root', shell=True) # shell=True表示命令在shell下執行，默認情況shell=False，參數是列表情況下，shell=True，所以不用顯式聲明shell=True

注意：windows默認是 shell =False
subprocess.call(['ls','-l', '--color', '/root']) 等價于subprocess.call('ls -l --color /root', shell=True)

輸出不能捕捉到，與os.system一樣
subprocess.check_call(['mkdir', '/tmp/aaa'])
check_call會拋python異常

call和check_call跟os.popenX不一樣，不需要調用wait方法，父進程會默認等待子進程執行完才返回

subprocess類

http://www.cnblogs.com/zhoug2020/p/5079407.html

原型
subprocess.Popen(self, args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

args:
args參數。可以是一個字符串，可以是一個包含程序參數的列表。要執行的程序一般就是這個列表的第一項，或者是字符串本身。
subprocess.Popen(["cat","test.txt"])
subprocess.Popen("cat test.txt")
這兩個之中，后者將不會工作。因為如果是一個字符串的話，必須是程序的路徑才可以。(考慮unix的api函數exec，接受的是字符串
列表)
但是下面的可以工作
subprocess.Popen("cat test.txt", shell=True)
這是因為它相當于
subprocess.Popen(["/bin/sh", "-c", "cat test.txt"])
在*nix下，當shell=False（默認）時，Popen使用os.execvp()來執行子程序。args一般要是一個【列表】。如果args是個字符串的
話，會被當做是可執行文件的路徑，這樣就不能傳入任何參數了。

注意：
shlex.split()可以被用于序列化復雜的命令參數，比如：
>>> shlex.split('ls ps top grep pkill')
['ls', 'ps', 'top', 'grep', 'pkill']
>>>import shlex, subprocess
>>>command_line = raw_input()
/bin/cat -input test.txt -output "diege.txt" -cmd "echo '$MONEY'"
>>>args = shlex.split(command_line)
>>> print args
['/bin/cat', '-input', 'test.txt', '-output', 'diege.txt', '-cmd', "echo '$MONEY'"]
>>>p=subprocess.Popen(args)
可以看到，空格分隔的選項（如-input）和參數（如test.txt）會被分割為列表里獨立的項，但引號里的或者轉義過的空格不在此列
。這也有點像大多數shell的行為。

在*nix下，當shell=True時，如果arg是個字符串，就使用shell來解釋執行這個字符串。如果args是個列表，則列表第一個元素被視為命令，
其余的都視為是給shell本身的參數。也就是說，等效于：
subprocess.Popen(['/bin/sh', '-c', args[0], args[1], ...])


executable參數:
指定要執行的程序。它很少會被用到：一般程序可以由args 參數指定。如果shell=True ，executable
可以用于指定用哪個shell來執行（比如bash、csh、zsh等）。*nix下，默認是 /bin/sh ，

注意：args本身是列表的情況下，就不能加shell=True ，否則會執行失敗：Popen(shlex.split(cmd), stdout=PIPE, stderr=PIPE,shell=True) ！！！

subprocess.Popen(['mkdir', 'aaa'],stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)

在*nix下，當shell=True時，如果arg是個字符串，就使用shell來解釋執行這個字符串。如果args是個列表，則第一項被視為命令，
其余的都視為是給shell本身的參數。也就是說，等效于：
subprocess.Popen(['/bin/sh', '-c', args[0], args[1], ...])

注意：當調用mysqldump 這種命令時候，他會把> %s  也會當成命令的參數，所以不能用shlex.split(cmd)
cmd = "/usr/local/mysql/bin/mysqldump  -u%s -p%s  -P%s  -h%s   --all-databases > %s " % (mysqluser,mysqlpwd,mysqlport,mysqlhost,sqlfile)
p = Popen(shlex.split(cmd), stdout=PIPE,stderr=PIPE)

注意：windows默認是 shell =False！！！
為什麼叫subprocess，調用外部命令的時候實際上是fork出一個子進程子shell來執行

p=subprocess.Popen(['cat'],stdin=subprocess.PIPE,stdout=subprocess.PIPE) 要從標準輸入輸入數據就必須指定stdin=subprocess.PIPE

p=subprocess.Popen(['mkdir', 'aaa'],stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

p = Popen(['wc'], stdin=PIPE, stdout=PIPE, stderr=PIPE)
p.terminate() #終止子進程
p.pid #子進程的pid
p.returncode #子進程執行完的返回碼，如果為None，表示子進程還沒終止，如果為負數-N的話，表示子進程還沒正常執行完畢而被N號信號終止，如果為0表示子進程已經正常執行完畢

Popen.wait()和Popen.communicate(input=None)都是等待子進程/程序運行結束并獲取返回值p.returncode
但是如果不需要等待子進程/程序運行結束，比如調用某些服務程序，例如vsftpd，mysql，這些服務一旦啟動就不需要等待他結束就不要用Popen.wait()和Popen.communicate(input=None)


Popen.wait()
等待子進程結束，設置并返回returncode屬性。
>>> p.wait()
0
注意： 如果子進程輸出了大量數據到stdout或者stderr的管道，并達到了系統pipe的緩存大小的話，
子進程會等待父進程讀取管道，而父進程此時正wait著的話，將會產生傳說中的死鎖，后果是非常嚴重滴。建議使用
communicate() 來避免這種情況的發生。
ulimit -a
pipe size            (512 bytes, -p) 8



Popen.communicate(input=None)
和子進程交互：發送數據到stdin，并從stdout和stderr讀數據，直到收到EOF。等待子進程結束。可選的input如有有的話，要為字符串類型。
此函數返回一個元組： (stdoutdata , stderrdata ) 。
注意，要給子進程的stdin發送數據，則Popen的時候，stdin要為PIPE；同理，要可以接收數據的話，stdout或者stderr也要為PIPE。
p1=subprocess.Popen('cat /etc/passwd',shell=True,stdin=subprocess.PIPE,stdout=subprocess.PIPE)              
>>> p2=subprocess.Popen('grep 0:0',shell=True,stdin=p1.stdout,stdout=subprocess.PIPE)
注意：讀到的數據會被緩存在內存里，所以數據量非常大的時候要小心了。
>>> p.communicate()     
(b'Filesystem     Size    Used   Avail Capacity  Mounted on\n/dev/ad0s1a    713M    313M    343M    48%    /\ndevfs          1.0K    1.0K      0B   100%    /dev\n/dev/ad0s1e    514M    2.1M    471M     0%    /tmp\n/dev/ad0s1f    4.3G    2.5G    1.4G    64%    /usr\n/dev/ad0s1d    2.0G    121M    1.7G     6%    /var\n', None)

p=subprocess.Popen(['cat'],stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p.communicate('abc')
('abc', '')
方法的返回值取決于subprocess.Popen，如果subprocess.Popen有stdin，則p.communicate('abc')必須要傳入參數，如果沒有stdin則不需要傳入參數
是否返回stdout或stderr也是取決于subprocess.Popen，如果subprocess.Popen有定義stdout=subprocess.PIPE, stderr=subprocess.PIPE
則stdout,stderr=p.communicate('abc')
communicate：method of subprocess.Popen instance
Interact with process: Send data to stdin. Read data from
stdout and stderr, until end-of-file is reached. Wait for
process to terminate. The optional input argument should be a
string to be sent to the child process, or None, if no data
should be sent to the child.

Pipe管道  
注意管道的大小
ulimit -a
pipe size            (512 bytes, -p) 8

p1 = Popen(['ls'], stdout=PIPE)
p2 = Popen(['grep', 'py'], stdin=p1.stdout, stdout=PIPE)
result = p2.stdout
for i in result:print i,

 

glob模塊和shlex模塊

glob模塊
glob：擴展shell通配符的
import glob
glob.glob(r'/etc/*.conf')

shlex模塊
import shlex
cmd = "mysql -u root -p123 -e 'show processlist'"
shlex.split(cmd)   #返回一個列表

ps ax -o pid,ppid,cmd

shlex.split()能識別引號，認為引號里的為一個元素，例如：
shlex.split('ps -eo "pid lstart"')與'ps -eo "pid lstart"'.split()得到的結果是不一樣的。

異常處理

NameError 嘗試訪問一個沒有聲明的變量
ImportError 無法引入模塊或包；可能路徑不存在
IndentationError 語法錯誤（的子類）；代碼沒有正確對齊
SyntaxError 語法錯誤
IndexError 索引超出序列范圍
KeyError 請求一個不存在的字典關鍵字
IOError 輸入輸出錯誤（比如你要讀的文件不存在）
AttributeError 嘗試訪問未知的對象屬性
ValueError 傳給函數的參數類型不正確，比如給int()函數傳入字符串類型
UnboundLocalError 試圖訪問一個還未被設置的局部變量

如果函數中用到全局變量并且修改了它，那么需要在函數里的變量前加global關鍵字
系統無法判斷你是對全局變量還是局部變量做操作，如果不加global關鍵字，會報錯UnboundLocalError ，如果沒有修改/賦值，就不用加global關鍵字

l=[1,2]

def f():
    l.append(4)
    
不會報UnboundLocalError 

l=[1,2]

def f():
    l[5]
    
會報UnboundLocalError 

KeyboardInterrupt

自定義異常

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#__author__="huazai"
"""
測試
Date:2016.08.12
"""

import subprocess
try:
    subprocess.check_call('exit 1', shell=True) # shell里面退出碼非0會觸發異常
except subprocess.CalledProcessError:
    print 'call fail'
except Exception, e:
    print e
print 'hello world'

自定義異常，繼承Exception根類

class FuncError(Exception):
def __str__(self):
    return "I am a funError"

def func():
    raise FuncError()

func()
#try:
# func()
#except FuncError, e:
# print e
print 'hello world'

#如果不知道異常的類型，就寫Exception，Exception是總的異常

func()

try:
    func()
except Exception , e:
    print e

#如果有多個異常，那么只會捕獲第一個匹配到的異常

func()
try:
     func()
except NameError, e:
     print e
except IndexError, e:
     print e
except ValueError, e:
     print e
     
e表示一個變量，保存異常的信息
當然這個變量名隨便起，比如
except NameError, a:
     print a

異常在try塊里拋。
finally：無論try塊是否拋異常，永遠執行的代碼，通常用來執行關閉文件，斷開服務器連接的功能。

try無異常，才會執行else
語法格式
try:

except:

else:

finally: