1. openpyxl / xlrd / xlwt => 操作Excel 文件(xlsx格式)
=> xlrd + xlwt : 只能操作xls文件，分别负责读写， 暂时不讨论
=> openpyxl : 只能用来处理Excel2007及以上的版本， .xlsx/.xlsm文件
读xlsx文件
#coding=utf-8
from openpyxl import load_workbook
wb = load_workbook(filename=r'a.xlsx') #加载workbook,也就是一个Excel文件
sheets = wb.get_sheet_names() #获取所有worksheet的名字
print "sheets: ",sheets
sheet0 = sheets[0] #得到第一个sheet的名字
ws = wb.get_sheet_by_name(sheet0) #如果sheet不存在不会抛出异常，而是返回None
#获取所有的行和列
rows = ws.rows
columns = ws.columns
content = []
# 双重循环获取sheet0的内容
for row in rows:
line = [col.value for col in row]
content.append(line) print content
#通过坐标读取值, 注意编号是从1 开始
print ws.cell('B12').value #Excel内部索引, 使用ws['B12']，应该也能读取，方法有很多种
print ws.cell(row=12,column=2).value #数组索引
创建xlsx文件，创建sheet表单
#coding=utf-8
from openpyxl import Workbook
# 创建一个workbook对象
wb = Workbook()
# 获取当前活动的worksheet
ws = wb.active
# 通过赋值给单元格来写
ws['A1'] = "roger"
# 可以写一整行
ws.append([1,2,34])
# python 的类型将会自动转换
import datetime
ws['A2'] = datetime.datetime.now()
# 最后一定要保存文件， 当然也可以在其他地方保存(创建之后)
wb.save("b.xlsx")
# 创建一个新的sheet
wb.create_sheet(title='roger')
wb.save('b.xlsx')
2.Queue
是一个同步队列类，在线程安全的多线程环境中很适用。模块实现了所有required locking semantics，依赖于python对线程的支持！
模块实现了3种类型的queue：
FIFO: the first tasks added are the firsted retrieved.
LIFO(like stack): the most recently added entry is the first retrieved.
Priority queue: the entries are kept sorted (using the heapq mudule), the lowest valued entry is retrieved first.
模块中定义的类和异常：
Clssess：
Queue.Queue (maxsize=0: mean infinite,下面的也都是)
Queue.LifoQueue
Queue.PriorityQueue
Exceptions:
Queue.Empty
Queue.Full
常用方法：
Queue.qsize(): 返回queue的大小
Queue.empty(), Queue.full()
Queue.put(item[,block[,timeout]]: 存放item，如果block 参数为true且timeout为None(default)， block if necessary until a free slot is available.
Queue.put_nowait(item) : 等同 Queue.put(item,False)
Queue.get([block[,timeout]]): 删除并返回queue中对应的item。
Queue.get_nowait(): 等同 Queue.get(False)
Queue.task_done(): 指示以前的操作完成了，被Queue的消费者线程使用。对于每一个get()用来获取元素后，一个subsequent调用 task_done() 来告诉Queue任务处理完成。
Queue.join(): Block until all items in the queue have been gotten and processed! 只有当调用task_done()之后未完成任务数才会减少，减少为0 的时候，join() unblocks.
伪代码
# 一段不能运行的sample
#coding=utf-8
from Queue import Queue
def worker():
while True:
item = q.get()
do_work(item)
q.task_done()
q = Queue() # 如果只使用 import Queue, 那么这行需要用 Queue.Queue
for i in range(num_worker_threads):
t = Thread(target=worker)
t.daemon = True
t.start() for item in source():
q.put(item) q.join() # block until all tasks are done
参考代码(参考原文链接)
#coding=utf-8
#
#FIFO
from Queue import Queue
q = Queue(0)
for i in range(10):
q.put(i)
while not q.empty():
print q.get() # LIFO
from Queue import LifoQueue
q = LifoQueue(maxsize=0)
for i in range(10,20):
q.put(i)
while not q.empty():
print q.get() # Priority Queue
from Queue import PriorityQueue
q = PriorityQueue() class work(object):
def __init__(self,priority,description):
self.priority = priority
self.description = description def __cmp__(self,other): #自定义比较函数
return cmp(self.priority, other.priority) q.put(work(4,"Middle range work"))
q.put(work(1,"Emergency work"))
q.put(work(7,"Low priority work")) while not q.empty():
wk = q.get()
print wk.priority,":",wk.description
3.Thread模块
这个模块提供低级原语来使用多线程， 多线程共享他们的全局数据空间，从而实现同步， 提供简单的互斥锁。dummy＿thread重复实现了这个模块，更适用，Threading是更高级的多线程实现。
模块定义了如下常量和函数
Exceptions：
thread.error : Raised on thread-specific errors.
Constants:
thread.LockType: lock对象的类型
Functions:
thread.start_new_thread(function,args[,kwargs]): 开始一个新线程并返回他的 线程ID，这个线程执行函数 function，args是这个function的参数。
thread.interrupt_main(): 在主线程中抛出一个keyboardInterrupt异常，一个子线程可以利用这个函数来中断主线程
thread.exit(): 抛出一个SystemExit的异常， 如果不捕获的话就终止线程
thread.allocate_lock() ： 返回新的lock对象
thread.get_ident(): 返回当前线程的id
thread.stack_size([size]): 返回线程堆栈大小
lock.acquire([waitflag]): 请求锁， 等待其他线程释放锁。
lock.release()
lock.locked(): 判断是否locked，返回True / False
import thread
a_lock = thread.allocate_lock()
with a_lock:
print "a_lock is locked while this executes"