python中一些实用而有趣的模块



以下为日常总结的Python中实用的模块和函数，放在这里当做记录，也希望能帮到其他人

#cv2模块为opencv

img=cv2.imread('1.jpg',cv2.IMREAD_GRAYSCALE)# 读入图片，灰阶化
img=cv2.imread('1.jpg')# 读入图片

import os
flist=os.listdir('test')
def showvar(flist):
     for f in flist:
             img=cv2.imread(f,cv2.IMREAD_GRAYSCALE)   //可以使用某个通道，一般用灰度值
             print f+'    '+str(cv2.Laplacian(img,cv2.CV_64F).var())  //用拉普拉斯算子计算图像清晰度，值越大越清晰 var为方差
showvar(test)

def show(img):
   cv2.imshow('d',img)
   cv2.waitKey(0)    #习惯使用的显示图片函数

x,y,color=img.shape#获得图片大小

img2=cv2.resize(img,(300,300))#改变图片大小

kernel = cv2.getStructuringElement(cv2.MORPH_CROSS,(5,5))  #定义结构元素，图像膨胀、侵蚀、开闭运算用

eroded = cv2.erode(img,kernel)#腐蚀图像 

dilated = cv2.dilate(img,kernel)#膨胀图像

opened = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)#开运算  morphology:形态学
closed = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)#闭运算
show(cv2.absdiff(opened,closed))#两个图像的差->边缘
#闭运算用来连接被误分为许多小块的对象，而开运算用于移除由图像噪音形成的斑点。因此，某些情况下可以连续运用
#这两种运算。如对一副二值图连续使用闭运算和开运算，将获得图像中
#的主要对象。同样，如果想消除图像中的噪声（即图像中的“小点”），也可以对图像先用开运算后用闭运算，不过这样也会消除一些破碎的对象。

retval, result = cv2.threshold(result, 40, 255, cv2.THRESH_BINARY)#二值化，40为阈值

cap=cv2.VideoCapture(0)#获得照相设备的句柄，一般0是摄像头
flag,img=cap.read()#从该设备处获得图像

result = cv2.bitwise_not(result)#反色

#文件与文件夹内容的比较 filecmp模块
>>> filecmp.cmp('D:\\sushu.txt','D:\\sushu2.txt')
False
>>> filecmp.dircmp('D:\\test1','D:\\test2')
<filecmp.dircmp instance at 0x01D6AF30>
>>> x=filecmp.dircmp('D:\\test1','D:\\test2')
>>> x.report()  #x还有各种属性，可以通过访问他们方便地得到下面所有的数据
diff D:\test1 D:\test2
Only in D:\test2 : ['333.txt']
Identical files : ['11.txt', '11.txt.bak']
Differing files : ['22.txt', '22.txt.bak']

#对字符串内容的比较  difflib模块
>>> import difflib
>>> str1='abbbcd'
>>> str2='abcd'
>>> k=difflib.SequenceMatcher(None,str1,str2)
>>> k.get_matching_blocks()
[Match(a=0, b=0, size=1), Match(a=3, b=1, size=3), Match(a=6, b=4, size=0)]
>>> k.get_opcodes()
[('equal', 0, 1, 0, 1), ('delete', 1, 3, 1, 1), ('equal', 3, 6, 1, 4)]

#hash算法    hashlib模块
>>> import hashlib
>>> hashlib.algorithms    #所有可使用的hash算法
('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')
>>> k=hashlib.md5()      #与下一行效果一样
>>> k2=hashlib.new('md5')   #可以动态指定hash算法
>>> str='haha'
>>> k.update(str)       #！！！！注意是在原有的字符串后加新字符串，所以要计算另一个字符串的hash值需要新建一个hash对象
>>> print k.digest()     #二进制下
NMl3+o?caq?%
>>> print k.hexdigest()    #16进制下
4e4d6c332b6fe62a63afe56171fd3725

>>> threads=[]
>>> def t():
...   threads.append(4)
...
>>> t()
>>> threads
[4]               #说明在函数中可以访问全局变量
>>> def t():
...   threads=[3,4,5]
...   threads.append(9)
...
>>> threads
[4]
>>> t()
>>> threads
[4]               #说明局部变量对全局变量有遮蔽现象
    
    
#多线程方法   threading模块（thread模块的改进版）  
#python中得thread的一些机制和C/C++不同：在C/C++中，主线程结束后，其子线程会默认被主线程kill掉。而在python中，主线程结束后，会默认等待子线程结束后，主线程才退出。
#python对于thread的管理中有两个函数：join和setDaemon
#join：如在一个线程B中调用threada.join()，则threada结束后，线程B才会接着threada.join()往后运行。
#setDaemon：主线程A启动了子线程B，调用b.setDaemaon(True)，则主线程结束时，会把子线程B也杀死，与C/C++中得默认效果是一样的。
import threading
def show(x,y):
  i=0
  while i<y:
      print '%d: %d' % (x,i)
      i+=1
threads = []
t1 = threading.Thread(target=show,args=(1,9))
threads.append(t1)
t2 = threading.Thread(target=move,args=(2,20))  #并不会直接开始运行
threads.append(t2)                 
if __name__ == '__main__':
  for t in threads:
    t.setDaemon(True)             #将线程声明为守护线程，必须在start() 方法调用之前设置
    t.start()
for t in threads:
  t.join()
print 'all over'
#其他threading中的函数:
#threading.activeCount()  此方法返回当前进程中线程的个数。返回的个数中包含主线程。
#threading.enumerate()   此方法返回当前运行中的Thread对象列表。enumerate->列举、枚举
  
  
#访问操作系统服务的功能    os模块
os.system('D:\ha.exe')    #执行外部程序，文件名中不能出现空格
os.startfile('D:\ha.exe')   #执行外部程序，文件名中可以出现空格
os.urandom(n)         #返回n字节的足够强度加密的随机数

#对文件的大量操作       fileinput模块
import fileinput
for line in fileinput.input(list or str,inplace=1 or 0):  #inplace=1表示原地修改
  do something about line
  if fileinput.isfirstline():               #竟然可以直接调用fileinput,于是只能存在一个fileinput对象？
    print line                     #若inplace=1，则会输出到原文件，而不是到屏幕
#其他fileinput中的函数
#fileinput.lineno()        返回当前行数，累计值
#fileinput.filelineno()      返回当前行数，对每个文件重新计数
#fileiput.nextfile()       关闭当前文件，跳到下个文件，跳过的行并不计数
#fileinput.isfirstline()     若所在行为文件的第一行则返回True
#fileinput.filename()       返回当前正在处理的文件的名字

#实用命令 
exec(str)             #把str当成代码来执行
#>>> str="print 'haha'"
#>>> exec(str)
#haha
eval(str)             #计算str的结果
#>>> import cmath
#>>> str='1+3+5+cmath.sqrt(8)'
#>>> exec(str)          #于是exec不会有返回值
#>>> eval(str)          #eval返回运行结果
#(11.82842712474619+0j)

#文件操作（复制删除等）    shutil模块与os模块
os.path.exists(str)        #判断该文件是否存在
os.remove(str)          #删除文件
os.rmdir(str)           #删除空文件夹，若非空则会弹出异常
shutil.rmtree(str)        #删除文件夹，可以非空
shutil.copyfile( src, dst)    #从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为IOException. 如果当前的dst已存在的话就会被覆盖掉 
shutil.copymode( src, dst)    #只是会复制其权限其他的东西是不会被复制的 
shutil.copystat( src, dst)    #复制权限、最后访问时间、最后修改时间 
shutil.copy( src, dst)      #复制一个文件到一个文件或一个目录 
shutil.copy2( src, dst)      #在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了，类似于cp –p的东西 
shutil.copy2( src, dst)      #如果两个位置的文件系统是一样的话相当于是rename操作，只是改名；如果是不在相同的文件系统的话就是做move操作 
shutil.copytree(olddir,newdir,True/Flase)  #把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接 

#邮件操作             smtplib模块     
import smtplib
import time
from email.message import Message
smtpserver='smtp.21cn.com'
username='123@21cn.com'
password='password'
from_addr='123@21cn.com'
to_addr='321@mails.tsinghua.edu.cn'
message=Message()
message['Subject']='haha'
message['From']=from_addr
message['To']=to_addr
msg=message.as_string()
sm=smtplib.SMTP(smtpserver,port=25,timeout=10)
sm.login(username,password)
i=0
while i<10:
 sm.sendmail(from_addr,to_addr,msg)
 i+=1
time.sleep(10)
sm.quit()