博客园_iTech's Blog

Gird Engine 是什么？

2012-02-09T11:27:00Z

一 Gird Engine

Gird Engine 指的是SGE(Sun Gird Engine)，是一个开源免费的batch-queuing 系统用来对分布式资源的管理。典型地他将被应用于计算机farm和高性能计算cluster，用来接收，schedule，分发和管理远程和分布式的大量的独立，并行的非交互的jobs，他也可以管理和schedule分布式资源的分配，例如处理器，内存，硬盘和软件license。简单地说就是将任务打包为job分发到计算机集中执行。

在Sun后来被Oracle收购后，从SGE延伸的开源产品为：

http://gridscheduler.sourceforge.net/

基于SGE开发的且提供企业级服务的为UGE(Univa Gird Engine)：

http://www.univa.com/

当然了Oracle在收购了Sun后改名为OGE（Oracle Gird Engine)且不免费：

http://www.oracle.com/technetwork/oem/grid-engine-166852.html?ssSourceSiteId=ocomen

其他关于SGE：

http://www.gridengine.info/

二 Gird Engine 的特点

* 多个高级的scheduling算法，从而允许基于多种策略的资源分配；

* cluster queues；

* job和scheduler错误冗余；

* job checkpointing；

* job 数组和job 任务；

* Distributed Resource Management And Access （job API），支持perl，python，java，c++等语言；

* 资源的保留；

* 基于xml的状态报告；

* 并行的job（MPI，PVM，OpenMP),使用qrsh实现可伸缩并行job的启动；

* 使用率统计；

* 并行的make，distmake，dmake，qmake；

* 支持几乎所有的系统，例如*unix,windows,Mac;

三 Gird Engine的架构和工作

典型的Gird Engine cluster包含了一个master host和一个或多个execution hosts。但是也可以设置多个shadow masters作为主master的后备，当主master出问题的时候，多个shadow masters可以代替主master继续工作。所有的execution hosts安装有gird engine execution daemon， master host装有qmaster daemon， shadow mater运行了shadow daemon。qmaster用来提交和schedule job到execution hosts。

使用实例参考：

例如EDA软件公司Mentor Graphics使用Gird Engine来管理所有的regression tests。为了测试他们的软件，他们提交数千的jobs到gird或cluster中运行。gird engine使得所有的机器能够被充分地被利用，当一个机器完成了一个测试用例的运行，gird engine将提交另一个job给他，直到所有的测试运行结束。gird engine还可以用来管理licenses。

四其他

platform Load Sharing Facility（LSF） http://www.platform.com/

参考：http://www.oracle.com/technetwork/oem/host-server-mgmt/twp-gridengine-overview-167117.pdf

完！

本文链接

Python分布式+云计算

2012-01-10T10:36:00Z

参考：

http://wiki.python.org/moin/ParallelProcessing

http://wiki.python.org/moin/DistributedProgramming

分布式：

http://www.celeryproject.org/

http://www.parallelpython.com/

http://code.google.com/p/distributed-python-for-scripting/

http://code.google.com/p/superpy/

http://code.google.com/appengine/

cloud：

http://www.picloud.com/

http://libcloud.apache.org/

new things：

http://www.heroku.com/

http://www.pythonanywhere.com/

完！

本文链接

python类库32[序列化和反序列化之pickle]

2012-01-10T09:49:00Z

一 pickle

pickle模块用来实现python对象的序列化和反序列化。通常地pickle将python对象序列化为二进制流或文件。

python对象与文件之间的序列化和反序列化：

pickle.dump()

pickle.load()

如果要实现python对象和字符串间的序列化和反序列化，则使用：

pickle.dumps()

pickle.loads()

可以被序列化的类型有：

* None,True 和 False;

* 整数，浮点数，复数;

* 字符串，字节流，字节数组;

* 包含可pickle对象的tuples，lists，sets和dictionaries；

* 定义在module顶层的函数：

* 定义在module顶层的内置函数；

* 定义在module顶层的类；

* 拥有__dict__()或__setstate__()的自定义类型；

注意：对于函数或类的序列化是以名字来识别的，所以需要import相应的module。

二 pickle的运行过程

在大部分情况下，要是的对象picklable，我们不需要额外的代码。默认地pickle将智能地检查类和实例的属性，当一个类实例反序列化的时候，它的__init__()方法通常不被调用。而是首先创建一个未初始化的实例，然后再回复存储的属性。

但是可以通过实现下列的方法来修改默认的行为：

object.__getstate__() :默认地序列化对象的__dict__,但是如果你实现了__getstate__(),则__getstate__()函数返回的值将被序列化。

object.__setstate__(state) :如果类型实现了此方法，则在反序列化的时候，此方法用来恢复对象的属性。

object.__getnewargs__() ：如果实例构造的时候（__new__()）需要参数，则需要实现此函数。

注意：如果__getstate__()返回False，则在反序列化的时候__setstate__()则不被调用。

有的时候为了效率，或上面的3个函数不能满足需求时，需要实现__reduce__()函数。

三实例

import pickle

# An arbitrary collection of objects supported by pickle.
data = {
    'a': [1, 2.0, 3, 4+6j],
    'b': ("character string", b"byte string"),
    'c': set([None, True, False])
}

with open('data.pickle', 'wb') as f:
    # Pickle the 'data' dictionary using the highest protocol available.
    pickle.dump(data, f, pickle.HIGHEST_PROTOCOL)


with open('data.pickle', 'rb') as f:
    # The protocol version used is detected automatically, so we do not
    # have to specify it.
    data = pickle.load(f)
    print(str(data))

四修改picklable类型的默认行为

class TextReader:
    """Print and number lines in a text file."""

    def __init__(self, filename):
        self.filename = filename
        self.file = open(filename)
        self.lineno = 0

    def readline(self):
        self.lineno += 1
        line = self.file.readline()
        if not line:
            return None
        if line.endswith('\n'):
            line = line[:-1]
        return "%i: %s" % (self.lineno, line)

    def __getstate__(self):
        # Copy the object's state from self.__dict__ which contains
        # all our instance attributes. Always use the dict.copy()
        # method to avoid modifying the original state.
        state = self.__dict__.copy()
        # Remove the unpicklable entries.
        del state['file']
        return state

    def __setstate__(self, state):
        # Restore instance attributes (i.e., filename and lineno).
        self.__dict__.update(state)
        # Restore the previously opened file's state. To do so, we need to
        # reopen it and read from it until the line count is restored.
        file = open(self.filename)
        for _ in range(self.lineno):
            file.readline()
        # Finally, save the file.
        self.file = file

reader = TextReader("hello.txt")
print(reader.readline())
print(reader.readline())
s = pickle.dumps(reader)
#print(s)
new_reader = pickle.loads(s)
print(new_reader.readline())

# the output is
# 1: hello
# 2: how are you
# 3: goodbye

完！

本文链接

python类库32[多进程之Pool+Logging]

2012-01-10T08:12:00Z

一 pool

multiprocessing.pool也就是传说中的进程池，pool的构造如下

multiprocessing.Pool([processes[, initializer[, initargs[, maxtasksperchild]]]]) 中，

processes表示pool中进程的数目，默认地为当前CPU的核数。

initializer表示新进程的初始化函数。

initargs表示新进程的初始化函数的参数。

maxtasksperchild表示每个进程执行task的最大数目。

apply()用来为pool中的进程赋予task。

map()用来循环地为pool中的进程赋予tasks。

close()用来阻止新的task的提交到pool中，一但已有的tasks都完成后，pool将退出。

terminate()用来立即停止pool中所有的进程。

join()等待pool中所有的进程退出。

实例：

import multiprocessing
import time

def do_calculation(data):
    print(multiprocessing.current_process().name)
    time.sleep(3)
    return data * 2

def start_process():
    print ('Starting', multiprocessing.current_process().name)

if __name__ == '__main__':
    inputs = list(range(10))
    print ('Input   :' + str(inputs))

    pool_size = multiprocessing.cpu_count()
    pool = multiprocessing.Pool(processes=pool_size,
                                initializer=start_process,
                                )
    pool_outputs = pool.map(do_calculation, inputs)
    pool.close() # no more tasks
    pool.join()  # wrap up current tasks

    print ('Pool    :' + str(pool_outputs))

运行结果：

上面的实例中可以看到当前的CPU是8core的，pool中公有8个进程，但是有10个任务，其中有2个进程处理了2个任务。

二 logging

使用multiprocessing启动的logger来帮助调试多进程。例如：

logger = multiprocessing.log_to_stderr(logging.DEBUG)

logger.debug("Test")

完！

本文链接

python类库32[多进程共享高级之Manager]

2012-01-10T06:49:00Z

Python中进程间共享数据，处理基本的queue，pipe和value+array外，还提供了更高层次的封装。使用multiprocessing.Manager可以简单地使用这些高级接口。

Manager()返回的manager对象控制了一个server进程，此进程包含的python对象可以被其他的进程通过proxies来访问。从而达到多进程间数据通信且安全。

Manager支持的类型有list,dict,Namespace,Lock,RLock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value和Array。

1） Manager的dict，list使用

import multiprocessing
import time

def worker(d, key, value):
    d[key] = value

if __name__ == '__main__':
    mgr = multiprocessing.Manager()
    d = mgr.dict()
    jobs = [ multiprocessing.Process(target=worker, args=(d, i, i*2))
             for i in range(10)
             ]
    for j in jobs:
        j.start()
    for j in jobs:
        j.join()
    print ('Results:' )
    for key, value in enumerate(dict(d)):
        print("%s=%s" % (key, value))

# the output is :
# Results:
# 0=0
# 1=1
# 2=2
# 3=3
# 4=4
# 5=5
# 6=6
# 7=7
# 8=8
# 9=9

上面为manager.dict的使用实例。

2）namespace对象没有公共的方法，但是有可写的属性。

然而当使用manager返回的namespace的proxy的时候，_属性值属于proxy，跟原来的namespace没有关系。

>>> manager = multiprocessing.Manager()

>>> Global = manager.Namespace()

>>> Global.x = 10

>>> Global.y = 'hello'

>>> Global._z = 12.3 # this is an attribute of the proxy

>>> print(Global)

Namespace(x=10, y='hello')

完！

本文链接

python类库32[多进程同步Lock+Semaphore+Event]

2012-01-10T05:57:00Z

同步的方法基本与多线程相同。

1) Lock

当多个进程需要访问共享资源的时候，Lock可以用来避免访问的冲突。

import multiprocessing
import sys

def worker_with(lock, f):
    with lock:
        fs = open(f,"a+")
        fs.write('Lock acquired via with\n')
        fs.close()

def worker_no_with(lock, f):
    lock.acquire()
    try:
        fs = open(f,"a+")
        fs.write('Lock acquired directly\n')
        fs.close()
    finally:
        lock.release()

if __name__ == "__main__":

    f = "file.txt"

    lock = multiprocessing.Lock()
    w = multiprocessing.Process(target=worker_with, args=(lock, f))
    nw = multiprocessing.Process(target=worker_no_with, args=(lock, f))

    w.start()
    nw.start()

    w.join()
    nw.join()

在上面的例子中，如果两个进程没有使用lock来同步,则他们对同一个文件的写操作可能会出现混乱。

2）Semaphore

Semaphore用来控制对共享资源的访问数量，例如池的最大连接数。

import multiprocessing
import time

def worker(s,i):
    s.acquire()
    print(multiprocessing.current_process().name + " acquire")
    time.sleep(i)
    print(multiprocessing.current_process().name + " release")
    s.release()

if __name__ == "__main__":

    s = multiprocessing.Semaphore(2)
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(s,i*2))
p.start()

上面的实例中使用semaphore限制了最多有2个进程同时执行。

3）Event

Event用来实现进程间同步通信。

import multiprocessing
import time

def wait_for_event(e):
    """Wait for the event to be set before doing anything"""
    print ('wait_for_event: starting')
    e.wait()
    print ('wait_for_event: e.is_set()->' + str(e.is_set()))

def wait_for_event_timeout(e, t):
    """Wait t seconds and then timeout"""
    print ('wait_for_event_timeout: starting')
    e.wait(t)
    print ('wait_for_event_timeout: e.is_set()->' + str(e.is_set()))

if __name__ == '__main__':
    e = multiprocessing.Event()
    w1 = multiprocessing.Process(name='block',
                                 target=wait_for_event,
                                 args=(e,))
    w1.start()

    w2 = multiprocessing.Process(name='non-block',
                                 target=wait_for_event_timeout,
                                 args=(e, 2))
    w2.start()

    time.sleep(3)
    e.set()
    print ('main: event is set')

#the output is:
#wait_for_event_timeout: starting
#wait_for_event: starting
#wait_for_event_timeout: e.is_set()->False
#main: event is set
#wait_for_event: e.is_set()->True

参考：http://www.doughellmann.com/PyMOTW/multiprocessing/communication.html

完！

本文链接

python类库32[多进程通信Queue+Pipe+Value+Array]

2012-01-09T08:38:00Z

多进程通信

queue和pipe的区别： pipe用来在两个进程间通信。queue用来在多个进程间实现通信。此两种方法为所有系统多进程通信的基本方法，几乎所有的语言都支持此两种方法。

1）Queue & JoinableQueue

queue用来在进程间传递消息，任何可以pickle-able的对象都可以在加入到queue。

multiprocessing.JoinableQueue 是 Queue的子类，增加了task_done()和join()方法。

task_done()用来告诉queue一个task完成。一般地在调用get()获得一个task，在task结束后调用task_done()来通知Queue当前task完成。

join() 阻塞直到queue中的所有的task都被处理（即task_done方法被调用）。

代码：

import multiprocessing
import time

class Consumer(multiprocessing.Process):

    def __init__(self, task_queue, result_queue):
        multiprocessing.Process.__init__(self)
        self.task_queue = task_queue
        self.result_queue = result_queue

    def run(self):
        proc_name = self.name
        while True:
            next_task = self.task_queue.get()
            if next_task is None:
                # Poison pill means shutdown
                print ('%s: Exiting' % proc_name)
                self.task_queue.task_done()
                break
            print ('%s: %s' % (proc_name, next_task))
            answer = next_task() # __call__()
            self.task_queue.task_done()
            self.result_queue.put(answer)
        return

class Task(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __call__(self):
        time.sleep(0.1) # pretend to take some time to do the work
        return '%s * %s = %s' % (self.a, self.b, self.a * self.b)
    def __str__(self):
        return '%s * %s' % (self.a, self.b)

if __name__ == '__main__':
    # Establish communication queues
    tasks = multiprocessing.JoinableQueue()
    results = multiprocessing.Queue()

    # Start consumers
    num_consumers = multiprocessing.cpu_count()
    print ('Creating %d consumers' % num_consumers)
    consumers = [ Consumer(tasks, results)
                  for i in range(num_consumers) ]
    for w in consumers:
        w.start()

    # Enqueue jobs
    num_jobs = 10
    for i in range(num_jobs):
        tasks.put(Task(i, i))

    # Add a poison pill for each consumer
    for i in range(num_consumers):
        tasks.put(None)

    # Wait for all of the tasks to finish
    tasks.join()

    # Start printing results
    while num_jobs:
        result = results.get()
        print ('Result:', result)
        num_jobs -= 1

注意小技巧：使用None来表示task处理完毕。

运行结果：

2） pipe

pipe()返回一对连接对象，代表了pipe的两端。每个对象都有send()和recv()方法。

代码：

from multiprocessing import Process, Pipe

def f(conn):
    conn.send([42, None, 'hello'])
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    p.join()
    print(parent_conn.recv())   # prints "[42, None, 'hello']"

3）Value + Array

Value + Array 是python中共享内存映射文件的方法，速度比较快。

from multiprocessing import Process, Value, Array

def f(n, a):
    n.value = n.value + 1
    for i in range(len(a)):
        a[i] = a[i] * 10

if __name__ == '__main__':
    num = Value('i', 1)
    arr = Array('i', range(10))

    p = Process(target=f, args=(num, arr))
    p.start()
    p.join()

    print(num.value)
    print(arr[:])

    p2 = Process(target=f, args=(num, arr))
    p2.start()
    p2.join()

    print(num.value)
    print(arr[:])

# the output is :
# 2
# [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
# 3
# [0, 100, 200, 300, 400, 500, 600, 700, 800, 900]

参考：
The Python Standard Library By Example

http://www.doughellmann.com/PyMOTW/multiprocessing/communication.html

完！

本文链接

python类库32[多进程]

2012-01-06T08:53:00Z

由于CPython实现中的GIL的限制，python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况我们需要使用多进程。这也许就是python中多进程类库如此简洁好用的原因所在。在python中可以向多线程一样简单地使用多进程。

一多进程

process的成员变量和方法：

>>class multiprocessing.Process([group[, target[, name[, args[, kwargs]]]]]) 来的定义类似于threading.Thread。target表示此进程运行的函数，args和kwargs表示target的参数。

>>name, pid

分别表示进程的名字，进程id。

>> daemon成员

daemon标志位bool变量，需要在start()调用前设置。daemon的初始值是从父进程继承而来。当一个进程结束的时候，它尝试去结束它的所有的daemon子进程。

注意：

daemon进程不允许创建子进程。否则当daemon进程结束的时候它的子进程不能被结束。

这里的daemon不是Unix的daemon进程，当父进程结束的时候所有的daemon子进程也将被终止（对于非daemon进程，父进程不等待非daemon的紫子进程，除非显示地对非daemon子进程使用join()方法）。

>> exitcode

如果进程还没有退出，则为None，如果正确的退出则为0，如果有错误则为>0的错误代码，如果进程为终止则为-1*singal。

>> start(), is_live(), terminate()

start()用来启动进程，is_live()用来查看进程的状态，terminate()用来终止进程。

>> run()

可以在process的子类中重载run()方法，从而设定进程的任务。重载process是构造新进程的另一种方式，一定程度上上等价于process的target参数。

multiprcessing的静态方法：

>> multiprocessing.cpu_count()

用来获得当前的CPU的核数，可以用来设置接下来子进程的个数。

>> multiprocessing.active_children()

用来获得当前所有的子进程，包括daemon和非daemon子进程。

实例：

import multiprocessing
import time
import sys

def worker(num):
    p = multiprocessing.current_process()
    print ('Starting:' + p.name + ":" + str(p.pid))
    print(str(num))
    sys.stdout.flush()
    print ('Exiting :' + p.name + ":" + str(p.pid))
    sys.stdout.flush()

def daemon():
    p = multiprocessing.current_process()
    print ('Starting:' + p.name + ":" + str(p.pid))
    sys.stdout.flush()
    time.sleep(10)
    print ('Exiting :' + p.name + ":" + str(p.pid))
    sys.stdout.flush()

def non_daemon():
    p = multiprocessing.current_process()
    print ('Starting:' + p.name + ":" + str(p.pid))
    sys.stdout.flush()
    time.sleep(20)
    print ('Exiting :' + p.name + ":" + str(p.pid))
    sys.stdout.flush()

if __name__ == '__main__':
    w = multiprocessing.Process(name='worker', target=worker, args=(100,))
    d = multiprocessing.Process(name='daemon', target=daemon)
    d.daemon = True
    nd = multiprocessing.Process(name='non-daemon', target=non_daemon)
    w.start()
    d.start()
    nd.start()

    print("the number of CPU is " + str(multiprocessing.cpu_count()))
    print("All children processes:")
    for p in multiprocessing.active_children():
        print("child:" + p.name + ":" + str(p.pid))
    print()

    w.join()
    #d.join()

运行结果：

可以从上面的例子看到没有多非daemon子进程使用join()方法，结果父进程没有等待非daemon进程结束就退出了。

完！

本文链接

Python转载[编码规范]

2012-01-06T06:49:00Z

转自：http://blog.csdn.net/lanphaday/article/details/6601123

但是有些如果与python自带的类库有冲突的做了适当的修改。

1 编码

>>所有的 Python 脚本文件都应在文件头标上如下标识或其兼容格式的标识：

# -*- coding:utf-8 -*-

>>设置编辑器，默认新建或保存为utf-8格式。

2 注释

>>业界普遍认同 Python 的注释分为两种的概念，一种是由 # 开头的“真正的”注释，另一种是 docstrings。前者表明为何选择当前实现以及这种实现的原理和难点，后者表明如何使用这个包、模块、类、函数（方法），甚至包括使用示例和单元测试。

>>坚持适当注释原则。对不存在技术难点的代码坚持不注释，对存在技术难点的代码必须注释。但与注释不同，推荐对每一个包、模块、类、函数（方法）写 docstrings，除非代码一目了然，非常简单。

3 格式缩进

>>Python依赖缩进来确定代码块的层次，行首空白符主要有两种：tab 和空格，但严禁两者混用。

>>使用4个空格的tab进行缩进，保持与python类库一致。

4 空格

>>空格在Python代码中是有意义的，因为Python的语法依赖于缩进，在行首的空格称为前导空格。在这一节不讨论前导空格相关的内容，只讨论非前导空格。非前导空格在 Python 代码中没有意义，但适当地加入非前导空格可以增进代码的可读性。

>>在二元算术、逻辑运算符前后加空格，如：

a = b + c

>> “:”用在行尾时前后皆不加空格，如分枝、循环、函数和类定义语言；用在非行尾时两端加空格，如 dict 对象的定义：

d = {'key' : 'value'}

>>括号（含圆括号、方括号和花括号）前后不加空格，如：

do_something(arg1, arg2)

而不是

do_something( arg1, arg2 )

逗号后面加一个空格，前面不加空格；

>>函数中命名参数中的=前后不需要加空格，例如：
def parse(fp=None, environ=os.environ, keep_blank_values=0, strict_parsing=0): pass

5 空行

>>适当的空行有利于增加代码的可读性，加空行可以参考如下几个准则：

在类、函数的定义间加空行；

在import不同种类的模块间加空行；

在函数中的逻辑段落间加空行，即把相关的代码紧凑写在一起，作为一个逻辑段落，段落间以空行分隔；

6 断行

>>尽管现在的宽屏显示器已经可以单屏显示超过 256 列字符，但本规范仍然坚持行的最大长度不得超过78个字符的标准(我觉的notepad++默认值为100比较合适)。折叠长行的方法有以下几种方法：

为长变量名换一个短名，如：

this._is.a.very.long.variable_name = this._is.another.long.variable_name

应改为：

variable_name1 = this._is.a.very.long.variable_name

variable_name2 = this._is.another.variable_name

variable_name1 = variable_name2

>>在括号（包括圆括号、方括号和花括号）内换行，如：

class Edit(Widget):

def __init__(self, parent, width,

font = FONT, color = BLACK, pos = POS, style = 0): # 注意：多一层缩进

pass

或：

very_very_very_long_variable_name = Edit(parent,

width,

font,

color,

pos) # 注意：多一层缩进

do_sth_with(very_very_very_long_variable_name)

>>如果行长到连第一个括号内的参数都放不下，则每个元素都单独占一行：

very_very_very_long_variable_name = ui.widgets.Edit(

panrent,

width,

font,

color,

pos) # 注意：多一层缩进

do_sth_with(very_very_very_long_variable_name)

>>在长行加入续行符强行断行，断行的位置应在操作符前，且换行后多一个缩进，以使维护人员看代码的时候看到代码行首即可判定这里存在换行，如：

if color == WHITE or color == BLACK \

or color == BLUE: # 注意 or 操作符在新行的行首而不是旧行的行尾，上一行的续行符不可省略

do_something(color);

else:

do_something(DEFAULT_COLOR);

7 命名

一致的命名可以给开发人员减少许多麻烦，而恰如其分的命名则可以大幅提高代码的可读性，降低维护成本。

>>常量

常量名所有字母大写，由下划线连接各个单词，如：

WHITE = 0xffffffff

THIS_IS_A_CONSTANT = 1

>>变量

变量名全部小写，由下划线连接各个单词，如：

color = WHITE

this_is_a_variable = 1

不论是类成员变量还是全局变量，均不使用 m 或 g 前缀。私有类成员使用单一下划线前缀标识，多定义公开成员，少定义私有成员。

变量名不应带有类型信息，因为 Python 是动态类型语言。如 iValue、names_list、dict_obj 等都是不好的命名。

>>函数

函数名的命名规则与变量名相同。

>>类

类名单词首字母大写，不使用下划线连接单词，也不加入 C、T 等前缀。如：

class ThisIsAClass(object):

passs

>>模块

模块名全部小写，对于包内使用的模块，可以加一个下划线前缀，如：

module.py

_internal_module.py

>>包

包的命名规范与模块相同。

8 缩写

>>命名应当尽量使用全拼写的单词，缩写的情况有如下两种：

常用的缩写，如 XML、ID等，在命名时也应只大写首字母，如：

class XmlParser(object):pass

>>命名中含有长单词，对某个单词进行缩写。这时应使用约定成俗的缩写方式，如去除元音、包含辅音的首字符等方式，例如：

function 缩写为 fn

text 缩写为 txt

object 缩写为 obj

count 缩写为 cnt

number 缩写为 num，等。

>>特定命名方式

主要是指 __xxx__ 形式的系统保留字命名法。项目中也可以使用这种命名，它的意义在于这种形式的变量是只读的，这种形式的类成员函数一般都有特定的含义，自定义时需要确保不要与系统的冲突，只有在确实需要的时候才重载系统保留的这些函数。如：

class Base(object):

def __init__(self, id, parent = None):

self.__id__ = id

self.__parent__ = parent

def __message__(self, msgid): pass

其中 __id__、__parent__ 和 __message__ 都采用了系统保留字命名法。

9 语句

>>import

import 语句有以下几个原则需要遵守：

import 的次序，先import Python 内置模块，再import第三方模块，最后import自己开发的项目中的其它模块；这几种模块中用空行分隔开来。

一条import语句import一个模块。

当从模块中import多个对象且超过一行时，使用如下断行法（此语法 py2.5 以上版本才支持）：

from module import (obj1, obj2, obj3, obj4,

obj5, obj6)

不要使用 from module import *，除非是import常量定义模块或其它你确保不会出现命名空间冲突的模块。

>>赋值

对于赋值语句，主要是不要做无谓的对齐，如：

a = 1 # 这是一个行注释

variable = 2 # 另一个行注释

fn = callback_function # 还是行注释

没有必要做这种对齐，原因有两点：

一是这种对齐会打乱编程时的注意力，大脑要同时处理两件事（编程和对齐）；

二是以后阅读和维护都很困难，因为人眼的横向视野很窄，把三个字段看成一行很困难，而且维护时要增加一个更长的变量名也会破坏对齐。

直接这样写为佳：

a = 1 # 这是一个行注释

variable = 2 # 另一个行注释

fn = callback_function # 还是行注释

>>分支和循环

对于分支和循环，有如下几点需要注意的：

不要写成一行，如：

if not flg: pass

和

for i in xrange(10): print i

都不是好代码，应写成

if not flg:

pass

for i in xrange(10):

print i

注：本文档中出现写成一行的例子是因为排版的原因，不得作为编码中不断行的依据。

>>条件表达式的编写应该足够 pythonic，如以下形式的条件表达式是拙劣的：

if not len(alist) == 0: do_something()

if not alist == []: do_something()

if not s == "": do_something()

if not var == None: do_something()

if not var == False: do_something()

因为python中None，0，''，[]等默认为False，上面的语句应该写成：

if seq: do_somethin() # 注意，这里命名也更改了

if var: do_something()

用得着的时候多使用循环语句的 else 分句，以简化代码。

完！

本文链接

python类库32[多线程同步Lock+RLock+Semaphore+Event]

2012-01-05T10:29:00Z

多线程基础：python类库32[多线程同步]

一多线程同步

由于CPython的python解释器在单线程模式下执行，所以导致python的多线程在很多的时候并不能很好地发挥多核cpu的资源。大部分情况都推荐使用多进程。

python的多线程的同步与其他语言基本相同，主要包含：

Lock & RLock ：用来确保多线程多共享资源的访问。

Semaphore ：用来确保一定资源多线程访问时的上限，例如资源池。

Event : 是最简单的线程间通信的方式，一个线程可以发送信号，其他的线程接收到信号后执行操作。

二实例

1）Lock & RLock

Lock对象的状态可以为locked和unlocked，
使用acquire()设置为locked状态；
使用release()设置为unlocked状态。

如果当前的状态为unlocked，则acquire()会将状态改为locked然后立即返回。当状态为locked的时候，acquire()将被阻塞直到另一个线程中调用release()来将状态改为unlocked，然后acquire()才可以再次将状态置为locked。

Lock.acquire(blocking=True, timeout=-1),blocking参数表示是否阻塞当前线程等待，timeout表示阻塞时的等待时间。如果成功地获得lock，则acquire()函数返回True，否则返回False，timeout超时时如果还没有获得lock仍然返回False。

实例：(确保只有一个线程可以访问共享资源)

import threading
import time

num = 0
lock = threading.Lock()

def func(st):
    global num
    print (threading.currentThread().getName() + ' try to acquire the lock')
    if lock.acquire():
        print (threading.currentThread().getName() + ' acquire the lock.' )
        print (threading.currentThread().getName() +" :%s" % str(num) )
        num += 1
        time.sleep(st)
        print (threading.currentThread().getName() + ' release the lock.'  )
        lock.release()

t1 = threading.Thread(target=func, args=(8,))
t2 = threading.Thread(target=func, args=(4,))
t3 = threading.Thread(target=func, args=(2,))
t1.start()
t2.start()
t3.start()

结果：

RLock与Lock的区别是：RLock中除了状态locked和unlocked外还记录了当前lock的owner和递归层数，使得RLock可以被同一个线程多次acquire()。

2）Semaphore

Semaphore管理一个内置的计数器，

每当调用acquire()时内置计数器-1；

调用release() 时内置计数器+1；

计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

实例：(同时只有2个线程可以获得semaphore,即可以限制最大连接数为2)：

import threading
import time

semaphore = threading.Semaphore(2)

def func():
    if semaphore.acquire():
        for i in range(5):
          print (threading.currentThread().getName() + ' get semaphore')
        semaphore.release()
        print (threading.currentThread().getName() + ' release semaphore')


for i in range(4):
  t1 = threading.Thread(target=func)
  t1.start()

结果：

3) Event

Event内部包含了一个标志位，初始的时候为false。
可以使用使用set()来将其设置为true；
或者使用clear()将其从新设置为false；
可以使用is_set()来检查标志位的状态；
另一个最重要的函数就是wait(timeout=None)，用来阻塞当前线程，直到event的内部标志位被设置为true或者timeout超时。如果内部标志位为true则wait()函数理解返回。

实例： (线程间相互通信)

import logging
import threading
import time

logging.basicConfig(level=logging.DEBUG,
format="(%(threadName)-10s : %(message)s",
)

def wait_for_event_timeout(e, t):
    """Wait t seconds and then timeout"""
    while not e.isSet():
      logging.debug("wait_for_event_timeout starting")
      event_is_set = e.wait(t)
      logging.debug("event set: %s" % event_is_set)
    if event_is_set:
      logging.debug("processing event")
    else:
      logging.debug("doing other work")

e = threading.Event()
t2 = threading.Thread(name="nonblock",
target=wait_for_event_timeout,args=(e, 2))
t2.start()
logging.debug("Waiting before calling Event.set()")
time.sleep(7)
e.set()
logging.debug("Event is set")

运行结果：

三其他

1）线程局部变量

线程局部变量的值是跟线程相关的，区别与全局的变量。使用非常简单如下：

mydata = threading.local()

mydata.x = 1

2）对Lock，semaphore，condition等使用with关键字代替手动调用acquire()和release()。

完！

本文链接