app.config['SQLALCHEMY_DATABASE_URI']='mysql://root:root@localhost/flasky'

if condition1:
    func1()
elif contidion2:
    func2()
else:
    func3()

(condition1 and func1()) or (condition2 and func2()) or (func3())

>>> pr=lambda p:p
>>> print_number=lambda x:(x==1 and pr("it's one")) or (x==2 and pr("it's two")) or (pr("it's something else"))
>>> print_number(1)
"it's one"
>>> print_number(2)
"it's two"
>>> print_number(3)
"it's something else"
>>>

#命令式编程版本
def echo_IMP():
    while 1:
        x = raw_input("IMP -- ")
        print x
        if x == 'quit':
            break
 
echo_IMP()

def monadic_print(x):
    print x
    return x
 
echo_FP = lambda: monadic_print(raw_input("FP -- "))=='quit' or echo_FP()
echo_FP()

bigmuls = lambda xs,ys: filter(lambda (x,y):x*y > 25, combine(xs,ys))
combine = lambda xs,ys: map(None, xs*len(ys), dupelms(ys,len(xs)))
dupelms = lambda lst,n: reduce(lambda s,t:s+t, map(lambda l,n=n: [l]*n, lst))

print bigmuls([1,2,3,4],[10,15,3,22])

[(3, 10), (4, 10), (2, 15), (3, 15), (4, 15), (2, 22), (3, 22), (4, 22)]

class Person(object):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, first_name, last_name):
        """Constructor"""
        self.first_name = first_name
        self.last_name = last_name
 
    #----------------------------------------------------------------------
    @property
    def full_name(self):
        """
        Return the full name
        """
        return "%s %s" % (self.first_name, self.last_name)

from decimal import Decimal

class Fees(object):
    
    def __init__(self):
        """Constructor"""
        self._fee = None
    
    def get_fee(self):
        """
        The getter
        """
        return self._fee
    
    def set_fee(self, value):
        """
        The setter 
        """
        if isinstance(value, str):
            self._fee = Decimal(value)
        elif isinstance(value, Decimal):
            self._fee = value
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    f = Fees()
    f.set_fee("100")
    f.get_fee()

>>> f.set_fee("200")
>>> f.get_fee()
Decimal('200')

#看起来还不错
>>> f.set_fee("haha")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 24, in set_fee
  File "C:\Users\wenqiang\Anaconda\lib\decimal.py", line 547, in __new__
    "Invalid literal for Decimal: %r" % value)
  File "C:\Users\wenqiang\Anaconda\lib\decimal.py", line 3873, in _raise_error
    raise error(explanation)
decimal.InvalidOperation: Invalid literal for Decimal: 'haha'

#但是下面这样就不行了
>>> f._fee="haha"
>>> f.get_fee()
'haha'

from decimal import Decimal

class Fees(object):
    
    def __init__(self):
        """Constructor"""
        self._fee = None

    @property
    def fee(self):
        """
        The fee property - the getter
        """
        return self._fee

    @fee.setter
    def fee(self, value):
        """
        The setter of the fee property
        """
        if isinstance(value, str):
            self._fee = Decimal(value)
        elif isinstance(value, Decimal):
            self._fee = value

#----------------------------------------------------------------------
if __name__ == "__main__":
    f = Fees()

>>> f=Fees()
>>> f.fee="1"
>>> f.fee
Decimal('1')
>>> f.fee="haha"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 11, in fee
  File "C:\Users\wenqiang\Anaconda\lib\decimal.py", line 547, in __new__
    "Invalid literal for Decimal: %r" % value)
  File "C:\Users\wenqiang\Anaconda\lib\decimal.py", line 3873, in _raise_error
    raise error(explanation)
decimal.InvalidOperation: Invalid literal for Decimal: 'haha'
#哈哈，还是被异常修改了
>>> f._fee="haha"
>>> f.fee
'haha'
>>>

class Movie(object):
    def __init__(self, title, rating, runtime, budget, gross):
        self._rating = None
        self._runtime = None
        self._budget = None
        self._gross = None

        self.title = title
        self.rating = rating
        self.runtime = runtime
        self.gross = gross
        self.budget = budget

    #nice
    @property
    def budget(self):
        return self._budget

    @budget.setter
    def budget(self, value):
        if value < 0:
            raise ValueError("Negative value not allowed: %s" % value)
        self._budget = value

    #ok    
    @property
    def rating(self):
        return self._rating

    @rating.setter
    def rating(self, value):
        if value < 0:
            raise ValueError("Negative value not allowed: %s" % value)
        self._rating = value

    #uhh...
    @property
    def runtime(self):
        return self._runtime

    @runtime.setter
    def runtime(self, value):
        if value < 0:
            raise ValueError("Negative value not allowed: %s" % value)
        self._runtime = value        

    #is this forever?
    @property
    def gross(self):
        return self._gross

    @gross.setter
    def gross(self, value):
        if value < 0:
            raise ValueError("Negative value not allowed: %s" % value)
        self._gross = value        

    def profit(self):
        return self.gross - self.budget

from weakref import WeakKeyDictionary

class NonNegative(object):
    """A descriptor that forbids negative values"""
    def __init__(self, default):
        self.default = default
        self.data = WeakKeyDictionary()

    def __get__(self, instance, owner):
        # we get here when someone calls x.d, and d is a NonNegative instance
        # instance = x
        # owner = type(x)
        return self.data.get(instance, self.default)

    def __set__(self, instance, value):
        # we get here when someone calls x.d = val, and d is a NonNegative instance
        # instance = x
        # value = val
        if value < 0:
            raise ValueError("Negative value not allowed: %s" % value)
        self.data[instance] = value

class Movie(object):

    #always put descriptors at the class-level
    rating = NonNegative(0)
    runtime = NonNegative(0)
    budget = NonNegative(0)
    gross = NonNegative(0)

    def __init__(self, title, rating, runtime, budget, gross):
        self.title = title
        self.rating = rating
        self.runtime = runtime
        self.budget = budget
        self.gross = gross

    def profit(self):
        return self.gross - self.budget

>>> m = Movie('Casablanca', 97, 102, 964000, 1300000)
>>> print m.budget  # calls Movie.budget.__get__(m, Movie)
964000
>>> m.budget=300
>>> m.budget
300
>>> m.budget=-24
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 16, in __set__
ValueError: Negative value not allowed: -24
>>>

class A(object):
    def foo(self,x):
        print "executing foo(%s,%s)"%(self,x)

    @classmethod
    def class_foo(cls,x):
        print "executing class_foo(%s,%s)"%(cls,x)

    @staticmethod
    def static_foo(x):
        print "executing static_foo(%s)"%x    

a=A()

a.foo(1)
# executing foo(<__main__.A object at 0xb7dbef0c>,1)

a.class_foo(1)
# executing class_foo(<class '__main__.A'>,1)

A.class_foo(1)
# executing class_foo(<class '__main__.A'>,1)

a.static_foo(1)
# executing static_foo(1)

A.static_foo('hi')
# executing static_foo(hi)

print(a.foo)
# <bound method A.foo of <__main__.A object at 0xb7d52f0c>>

print(a.class_foo)
# <bound method type.class_foo of <class '__main__.A'>>

print(a.static_foo)
# <function static_foo at 0xb7d479cc>

print(A.static_foo)
# <function static_foo at 0xb7d479cc>

from multiprocessing import Pool

def f(x):
    return x*x

if __name__ == '__main__':
    p = Pool(5)
    print(p.map(f, [1, 2, 3]))

from multiprocessing import Process

def f(name):
    print 'hello', name

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

from multiprocessing import Process
import os

def info(title):
    print title
    print 'module name:', __name__
    if hasattr(os, 'getppid'):  # only available on Unix
        print 'parent process:', os.getppid()
    print 'process id:', os.getpid()

def f(name):
    info('function f')
    print 'hello', name

if __name__ == '__main__':
    info('main line')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

from multiprocessing import Process, Queue

def f(q):
    q.put([42, None, 'hello'])

if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print q.get()    # prints "[42, None, 'hello']"
    p.join()

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()
    print parent_conn.recv()   # prints "[42, None, 'hello']"
    p.join()

from multiprocessing import Process, Lock

def f(l, i):
    l.acquire()
    print 'hello world', i
    l.release()

if __name__ == '__main__':
    lock = Lock()

    for num in range(10):
        Process(target=f, args=(lock, num)).start()

3.1415927
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
```		
参数d和i在创建num和arr时被array模块当做字节码使用，d表明是一个双精度浮点数，而i则指明一个有符号的整数类型。这些共享对象是线程和进程安全的。
想要更灵活得使用共享内存，可以使用multiprocessing.sharedctypes,它支持从共享内存创建专门的ctype对象。

##服务进程##
由Manager()方法返回的manager对象可以用于控制一个服务进程，它能管理Python对象并且允许其他进程通过代理操作这些数据。
由Manager()方法返回的manager对象支持以下这些类型：list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Queue, Value and Array。下面举个例子
``` Python
from multiprocessing import Process, Manager

def f(d, l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None
    l.reverse()

if __name__ == '__main__':
    manager = Manager()

    d = manager.dict()
    l = manager.list(range(10))

    p = Process(target=f, args=(d, l))
    p.start()
    p.join()

    print d
    print l

from multiprocessing import Pool, TimeoutError
import time
import os

def f(x):
    return x*x

if __name__ == '__main__':
    pool = Pool(processes=4)              # start 4 worker processes

    # print "[0, 1, 4,..., 81]"
    print pool.map(f, range(10))

    # print same numbers in arbitrary order
    for i in pool.imap_unordered(f, range(10)):
        print i

    # evaluate "f(20)" asynchronously
    res = pool.apply_async(f, (20,))      # runs in *only* one process
    print res.get(timeout=1)              # prints "400"

    # evaluate "os.getpid()" asynchronously
    res = pool.apply_async(os.getpid, ()) # runs in *only* one process
    print res.get(timeout=1)              # prints the PID of that process

    # launching multiple evaluations asynchronously *may* use more processes
    multiple_results = [pool.apply_async(os.getpid, ()) for i in range(4)]
    print [res.get(timeout=1) for res in multiple_results]

    # make a single worker sleep for 10 secs
    res = pool.apply_async(time.sleep, (10,))
    try:
        print res.get(timeout=1)
    except TimeoutError:
        print "We lacked patience and got a multiprocessing.TimeoutError"

>>> from multiprocessing import Pool
>>> p = Pool(5)
>>> def f(x):
...     return x*x
...
>>> p.map(f, [1,2,3])
Process PoolWorker-1:
Process PoolWorker-2:
Process PoolWorker-3:
Traceback (most recent call last):
AttributeError: 'module' object has no attribute 'f'
AttributeError: 'module' object has no attribute 'f'
AttributeError: 'module' object has no attribute 'f'

#引入Queue类
from Queue import Queue

#得到队列的大小
Queue.qsize()

#判断队列是否为空
Queue.empty()

#判断队列是否已满
Queue.full()

#从队列头获取元素，默认为阻塞
Queue.get([block[,timeout]])

#从队列头获取元素，非阻塞方式
Queue.get_nowait()
#或者
Queue.get(block=False)

#阻塞写入队列
Queue.put(item)

#非阻塞写入队列
Queue.put_nowait(item)
#或者
Queue.put(item,block=False)

#向队列中已完成的元素发送join信号
Queue.task_done()

from Queue import Queue
import random
import threading
import time

#Producer thread
class Producer(threading.Thread):
    def __init__(self, t_name, queue):
        threading.Thread.__init__(self, name=t_name)
        self.data=queue
    def run(self):
        for i in range(5):
            print "%s: %s is producing %d to the queue!" %(time.ctime(), self.getName(), i)
            self.data.put(i)
            time.sleep(random.randrange(10)/5)
        print "%s: %s finished!" %(time.ctime(), self.getName())

#Consumer thread
class Consumer(threading.Thread):
    def __init__(self, t_name, queue):
        threading.Thread.__init__(self, name=t_name)
        self.data=queue
    def run(self):
        for i in range(5):
            val = self.data.get()
            print "%s: %s is consuming. %d in the queue is consumed!" %(time.ctime(), self.getName(), val)
            time.sleep(random.randrange(10))
        print "%s: %s finished!" %(time.ctime(), self.getName())

#Main thread
def main():
    queue = Queue()
    producer = Producer('Pro.', queue)
    consumer = Consumer('Con.', queue)
    producer.start()
    consumer.start()
    producer.join()
    consumer.join()
    print 'All threads terminate!'
 
if __name__ == '__main__':
    main()

"""A multi-producer, multi-consumer queue."""

from time import time as _time
try:
    import threading as _threading          # 导入threading模块
except ImportError:
    import dummy_threading as _threading    # 该模块的接口和thread相同，在没有实现thread模块的平台上提供thread模块的功能。
from collections import deque               # https://github.com/BeginMan/pythonStdlib/blob/master/collections.md
import heapq                                # 堆排序 https://github.com/qiwsir/algorithm/blob/master/heapq.md

__all__ = ['Empty', 'Full', 'Queue', 'PriorityQueue', 'LifoQueue']  # 模块级别暴露接口


class Empty(Exception):
    """当调用Queue.get(block=0)/get_nowait()时触发Empty异常

    调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。
    如果队列为空且block为True，get()就使调用线程暂停，直至有项目可用。
    如果队列为空且block为False，队列将引发Empty异常
    """
    pass


class Full(Exception):
    """当调用Queue.put(block=0)/put_nowait()时触发Full异常

    如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。
    如果block为0，put方法将引发Full异常。
    """
    pass


class Queue:
    """创建一个给定的最大大小的队列对象.

    FIFO(先进先出)队列, 第一加入队列的任务, 被第一个取出
    If maxsize is <= 0, the queue size is 无限大小.
    """
    def __init__(self, maxsize=0):
        self.maxsize = maxsize
        self._init(maxsize)             # 初始化queue为空

        # 所有获取锁的方法必须在返回之前先释放，互斥锁在下面三个Condition条件共享
        # 从而获取和释放的条件下也获得和释放互斥锁。
        self.mutex = _threading.Lock()  # Lock锁

        # 当添加queue元素时通知`not_empty`,之后线程等待get
        self.not_empty = _threading.Condition(self.mutex)       # not_empty Condition实例

        # 当移除queue元素时通知`not_full`,之后线程等待put.
        self.not_full = _threading.Condition(self.mutex)        # not_full Condition实例

        # 当未完成的任务数为0时，通知`all_tasks_done`,线程等待join()
        self.all_tasks_done = _threading.Condition(self.mutex)  # all_tasks_done Condition实例
        self.unfinished_tasks = 0

    def task_done(self):
        """表明，以前排队的任务完成了

        被消费者线程使用. 对于每个get()，随后调用task_done()告知queue这个task已经完成
        """
        self.all_tasks_done.acquire()
        try:
            # unfinished_tasks 累减
            unfinished = self.unfinished_tasks - 1
            if unfinished <= 0:
                # 调用多次task_done则触发异常
                if unfinished < 0:
                    raise ValueError('task_done() called too many times')
                self.all_tasks_done.notify_all()    # 释放所有等待该条件的线程
            self.unfinished_tasks = unfinished
        finally:
            self.all_tasks_done.release()

    def join(self):
        """阻塞直到所有任务都处理完成
        未完成的task会在put()累加，在task_done()累减, 为0时，join()非阻塞.
        """
        self.all_tasks_done.acquire()
        try:
            # 一直循环检查未完成数
            while self.unfinished_tasks:
                self.all_tasks_done.wait()
        finally:
            self.all_tasks_done.release()

    def qsize(self):
        """返回队列的近似大小（不可靠！）"""
        self.mutex.acquire()
        n = self._qsize()       # len(queue)
        self.mutex.release()
        return n

    def empty(self):
        """队列是否为空(不可靠)."""
        self.mutex.acquire()
        n = not self._qsize()
        self.mutex.release()
        return n

    def full(self):
        """队列是否已满(不可靠!)."""
        self.mutex.acquire()
        n = 0 < self.maxsize == self._qsize()
        self.mutex.release()
        return n

    def put(self, item, block=True, timeout=None):
        """添加元素.

        如果可选参数block为True并且timeout参数为None(默认), 为阻塞型put().
        如果timeout是正数, 会阻塞timeout时间并引发Queue.Full异常.
        如果block为False为非阻塞put
        """
        self.not_full.acquire()
        try:
            if self.maxsize > 0:
                if not block:
                    if self._qsize() == self.maxsize:
                        raise Full
                elif timeout is None:
                    while self._qsize() == self.maxsize:
                        self.not_full.wait()
                elif timeout < 0:
                    raise ValueError("'timeout' must be a non-negative number")
                else:
                    endtime = _time() + timeout
                    while self._qsize() == self.maxsize:
                        remaining = endtime - _time()
                        if remaining <= 0.0:
                            raise Full
                        self.not_full.wait(remaining)

            self._put(item)
            self.unfinished_tasks += 1
            self.not_empty.notify()
        finally:
            self.not_full.release()

    def put_nowait(self, item):
        """
        非阻塞put
        其实就是将put第二个参数block设为False
        """
        return self.put(item, False)

    def get(self, block=True, timeout=None):
        """移除列队元素并将元素返回.

        block = True为阻塞函数, block = False为非阻塞函数. 可能返回Queue.Empty异常
        """
        self.not_empty.acquire()
        try:
            if not block:
                if not self._qsize():
                    raise Empty
            elif timeout is None:
                while not self._qsize():
                    self.not_empty.wait()
            elif timeout < 0:
                raise ValueError("'timeout' must be a non-negative number")
            else:
                endtime = _time() + timeout
                while not self._qsize():
                    remaining = endtime - _time()
                    if remaining <= 0.0:
                        raise Empty
                    self.not_empty.wait(remaining)
            item = self._get()
            self.not_full.notify()
            return item
        finally:
            self.not_empty.release()

    def get_nowait(self):
        """
        非阻塞get()
        也即是get()第二个参数为False
        """
        return self.get(False)

    # Override these methods to implement other queue organizations
    # (e.g. stack or priority queue).
    # These will only be called with appropriate locks held

    # 初始化队列表示
    def _init(self, maxsize):
        self.queue = deque()        # 将queue初始化为一个空的deque对象

    def _qsize(self, len=len):      # 队列长度
        return len(self.queue)

    # Put a new item in the queue
    def _put(self, item):
        self.queue.append(item)

    # Get an item from the queue
    def _get(self):
        return self.queue.popleft()


class PriorityQueue(Queue):
    """
    继承Queue
    构造一个优先级队列
    maxsize设置队列大小的上界, 如果插入数据时, 达到上界会发生阻塞, 直到队列可以放入数据.
    当maxsize小于或者等于0, 表示不限制队列的大小(默认).
    优先级队列中, 最小值被最先取出
    """

    def _init(self, maxsize):
        self.queue = []

    def _qsize(self, len=len):
        return len(self.queue)

    def _put(self, item, heappush=heapq.heappush):
        heappush(self.queue, item)

    def _get(self, heappop=heapq.heappop):
        return heappop(self.queue)


class LifoQueue(Queue):
    """
    构造一LIFO(先进后出)队列
    maxsize设置队列大小的上界, 如果插入数据时, 达到上界会发生阻塞, 直到队列可以放入数据.
    当maxsize小于或者等于0, 表示不限制队列的大小(默认)
    """
    def _init(self, maxsize):
        self.queue = []

    def _qsize(self, len=len):
        return len(self.queue)

    def _put(self, item):
        self.queue.append(item)

    def _get(self):
        return self.queue.pop()     # 与Queue相比，仅仅是 将popleft()改成了pop()

#coding:utf-8

from multiprocessing import Pool
import time

def f(x):
    time.sleep(1)
    print x
    return x*x

if __name__=='__main__':
    p=Pool(5)
    print (p.map(f,range(10)))

import os 
import PIL 

from multiprocessing import Pool 
from PIL import Image

SIZE = (75,75)
SAVE_DIRECTORY = 'thumbs'

def get_image_paths(folder):
    return (os.path.join(folder, f) 
            for f in os.listdir(folder) 
            if 'jpeg' in f)

def create_thumbnail(filename): 
    im = Image.open(filename)
    im.thumbnail(SIZE, Image.ANTIALIAS)
    base, fname = os.path.split(filename) 
    save_path = os.path.join(base, SAVE_DIRECTORY, fname)
    im.save(save_path)

if __name__ == '__main__':
    folder = os.path.abspath(
        '11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')
    os.mkdir(os.path.join(folder, SAVE_DIRECTORY))

    images = get_image_paths(folder)

    for image in images:
        create_thumbnail(Image)

import os 
import PIL 

from multiprocessing import Pool 
from PIL import Image

SIZE = (75,75)
SAVE_DIRECTORY = 'thumbs'

def get_image_paths(folder):
    return (os.path.join(folder, f) 
            for f in os.listdir(folder) 
            if 'jpeg' in f)

def create_thumbnail(filename): 
    im = Image.open(filename)
    im.thumbnail(SIZE, Image.ANTIALIAS)
    base, fname = os.path.split(filename) 
    save_path = os.path.join(base, SAVE_DIRECTORY, fname)
    im.save(save_path)

if __name__ == '__main__':
    folder = os.path.abspath(
        '11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')
    os.mkdir(os.path.join(folder, SAVE_DIRECTORY))

    images = get_image_paths(folder)

    pool = Pool()
    pool.map(creat_thumbnail, images)
    pool.close()
    pool.join()

#coding:utf-8

from multiprocessing import Pool
import time

def f(x):
    print x*x
    time.sleep(1)
    return x*x

if __name__=='__main__':
    p=Pool(processes=5)
    res_list=[]
    for i in range(10):
        res=p.apply_async(f,[i,])
        res_list.append(res)

    for item in res_list:
        print item.get(),

#coding:utf-8

from multiprocessing import Process
import os

def info(title):
    print title
    print 'module_name:',__name__
    if hasattr(os,'getppid'):#仅在Unix主机上才有此属性
        print 'parent process:',os.getppid()
    print 'process id:',os.getpid()

def f(name):
    info('funcion f')
    print 'hello',name

if __name__=='__main__':
    info('main line')
    p=Process(target=f,args=('bob',))
    p.start()
    p.join()

#coding:utf-8
import threading
import Queue

SHARE_Q=Queue.Queue()
#线程个数
_WORKED_THERAD_NUM=3

class MyThread(threading.Thread):
    '''
    其中func为线程函数的逻辑部分
    '''

    def __init__(self,func):
        super(MyThread,self).__init__()
        self.func=func

    def run(self):
        '''
        重写基类的run方法
        '''
        self.func()

def do_something(item):
    '''
    运行逻辑
    '''
    print item

def worker():
    '''
    用于写工作逻辑，只要队列不空就持续处理，为空时检查队列。
    由于Queue中已经包含了wait notify 和响应的锁，所以不需要在取任务或者放任务的时候
    加锁或解锁
    '''

    global SHARE_Q
    while not SHARE_Q.empty():
        item=SHARE_Q.get()
        do_something(item)
        SHARE_Q.task_done()

def main():
    global SHARE_Q
    threads=[]

    for task in xrange(5):
        SHARE_Q.put(task)

    for i in xrange(_WORKED_THREAD_NUM):
        thread=MyThread(worker)
        thread.start()
        threads.append(thread)
    for thread in threads:
        thread.join()

    SHARE_Q.join()

if __name__=='__main__':
    main()

while True:
    if not SHARE_Q.empty():
        item=SHARE_Q.get()
        do_something(item)
        SHARE_Q.task_done()

results=map(urllib2.urlopen,['https://www.baidu.com','http://cn.bing.com'])

urls=['https://www.baidu.com','http://cn.bing.com']
results=[]
for url in urls:
    results.append(urllib2.urlopen(url))

from multiprocessing import Pool
from multiprocessing.dummy import Pool as ThreadPool

import urllib2
from multiprocessing.dummy import Pool as ThreadPool

urls=[
'http://www.python.org', 
    'http://www.python.org/about/',
    'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
    'http://www.python.org/doc/',
    'http://www.python.org/download/',
    'http://www.python.org/getit/',
    'http://www.python.org/community/',
    'https://wiki.python.org/moin/',
    'http://planet.python.org/',
    'https://wiki.python.org/moin/LocalUserGroups',
    'http://www.python.org/psf/',
    'http://docs.python.org/devguide/',
    'http://www.python.org/community/awards/'
	]

#设定池子的大小
pool=ThreadPool(4)

results=pool.map(urllib2.urlopen,urls)
pool.close()
pool.join()

'''
A more realistic thread pool example 
'''

import time 
import threading 
import Queue 
import urllib2 

class Consumer(threading.Thread): 
    def __init__(self, queue): 
        threading.Thread.__init__(self)
        self._queue = queue 

    def run(self):
        while True: 
            content = self._queue.get() 
            if isinstance(content, str) and content == 'quit':
                break
            response = urllib2.urlopen(content)
        print 'Bye byes!'


def Producer():
    urls = [
        'http://www.python.org', 'http://www.yahoo.com'
        'http://www.scala.org', 'http://www.google.com'
        # etc.. 
    ]
    queue = Queue.Queue()
    worker_threads = build_worker_pool(queue, 4)
    start_time = time.time()

    # Add the urls to process
    for url in urls: 
        queue.put(url)  
    # Add the poison pillv
    for worker in worker_threads:
        queue.put('quit')
    for worker in worker_threads:
        worker.join()

    print 'Done! Time taken: {}'.format(time.time() - start_time)

def build_worker_pool(queue, size):
    workers = []
    for _ in range(size):
        worker = Consumer(queue)
        worker.start() 
        workers.append(worker)
    return workers

if __name__ == '__main__':
    Producer()