import multiprocessing as mul
import os
from math import factorial

pool = mul.Pool()
mul.cpu_count()

def get_factorial(num, pid = 0):
    if pid:
        print 'pid is', os.getpid()
    return factorial(num)

timeit get_factorial(100, pid=0)

f_10 = get_factorial(10, pid=1)

def f_list_serial(num, pid=0):
    results = []
    for n in range(1,num + 1):
        results.append(get_factorial(n,pid=pid))
    return results

results = f_list_serial(5, pid=1)

timeit f_list_serial(100, pid=0)

def f_list_para_apply_async(num,pid=0,pool=None):
    pool = mul.Pool()
    results_list = []
    results = []
    for n in range(1,num+1):
        results_list.append(
                pool.apply_async(get_factorial, args=(n,pid)))
    pool.close()
    pool.join()
    for result in results_list:
        results.append(result.get())
    return results

r = f_list_para_apply_async(10,pid=1)

timeit r = f_list_para_apply_async(100)

timeit r = f_list_para_apply_async(100,pool=50)

timeit r = f_list_para_apply_async(100,pool=1)

def f_list_para_map_asyns(num, pool=None):
    results_list = []
    pool = mul.Pool(pool)
    result = pool.map_async(get_factorial,range(1,num+1))
    pool.close()
    pool.join()
    for result in results_list:
        results.append(result.get())
    return result

timeit r = f_list_para_map_asyns(100)

def f_list_para_apply(num,pid=0,pool=None):
    pool = mul.Pool()
    results = []
    for n in range(1,num + 1):
        results.append(pool.apply(get_factorial, args=(n,pid)))
    pool.close()
    pool.join()
    return results

r = f_list_para_apply(10,pid=1)

timeit r = f_list_para_apply(100)

def f_list_para_map(num):
    results_list = []
    pool = mul.Pool()
    result = pool.map(get_factorial,range(1,num+1))
    pool.close()
    pool.join()
    return result

r = f_list_para_apply(10,pid=1)

timeit r = f_list_para_map(100)

token = '2.00Hk5I5B0XUlu4bde500a7f8FHAqIB'
token = '2.00Hk5I5B3mz1gEdaf1f0cb3bCXBvsB'
import json,urllib2,urllib
def get_repost_timeline(id, count=200, page=1, pid=0, **keys):
    if pid:
        print 'pid', os.getpid(),'start!'
    query_args = {'id': id, 'count': count, 'page': page,
                  'access_token': token}
    query_args.update(keys)
    url = 'https://api.weibo.com/2/statuses/repost_timeline.json?'
    encoded_args = urllib.urlencode(query_args)
    content = urllib2.urlopen(url + encoded_args).read()
    if pid:
        print 'pid', os.getpid(),'finished!'
    return json.loads(content)

timeit get_repost_timeline(3664072912104801)

def get_post_reposts(mid):
    reposts = []
    total_number = get_repost_timeline(id=mid)['total_number']
    page_number = total_number / 200 + 1
    if page_number > 10:
        page_number = 10
    for i in range(1,page_number + 1):
        reposts += get_repost_timeline(mid, page=i)['reposts']
    return reposts

timeit get_post_reposts(3664072912104801)

def get_post_reposts_para_async(mid, pool_num=None, pid=0):
    reposts = []
    results = []
    pool = mul.Pool(pool_num)
    total_number = get_repost_timeline(id=mid)['total_number']
    page_number = total_number / 200 + 1
    if page_number > 10:
        page_number = 10
    for i in range(1, page_number + 1):
        results.append(pool.apply_async(get_repost_timeline, kwds=dict(id=mid, page=i, pid=pid)))
    pool.close()
    pool.join()
    for result in results:
        reposts += result.get()['reposts']
    return reposts

reposts = get_post_reposts_para_async(3664072912104801, pid=1)

timeit get_post_reposts_para_async(3664072912104801)

timeit get_post_reposts_para_async(3664072912104801, pool_num=10)

timeit get_post_reposts_para_async(3664072912104801, pool_num=1)

timeit get_post_reposts_para_async(3664072912104801, pool_num=100)

def get_post_reposts_para(mid, pool_num=None, pid=0):
    reposts = []
    pool = mul.Pool(pool_num)
    total_number = get_repost_timeline(id=mid)['total_number']
    page_number = total_number / 20 + 1
    if page_number > 10:
        page_number = 10
    for i in range(1,page_number):
        reposts += pool.apply(get_repost_timeline,kwds=dict(id=mid, page=i, pid=pid))['reposts']
    pool.close()
    pool.join()
    return reposts

reposts = get_post_reposts_para(3664072912104801, pid=1)

timeit get_post_reposts_para(3664072912104801)

timeit get_post_reposts_para(3664072912104801,pool_num=10)

timeit get_post_reposts_para(3664072912104801,pool_num=1)