Python 简单模块学习

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"