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"

巴特西

Python 简单模块学习

最新文章

热门文章