Python async异步编程获取函数返回值
import asyncio
import time

async def test1():
    lit1=[]
    for i in range(10):
        await asyncio.sleep(3)
        # print(i,"test1")
        lit1.append(i)
    return lit1

async def test2():
    lit2=[]
    for i in range(15):
        await asyncio.sleep(2)
        # print(i,"test2")
        lit2.append(i)
    return lit2

def run():
    start_time = time.time()
    loop = asyncio.get_event_loop()
    task = loop.create_task(test1())
    task1 = loop.create_task(test2())
    loop.run_until_complete(task)
    loop.run_until_complete(task1)
    loop.close()
    print(task.result())
    print(task1.result())
    end_time = time.time()
    print(end_time-start_time)

run()

执行结果:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

30.025165796279907

前言
目前TS官方API还不支持获取函数返回值类型，但是对于函数式编程流行的当今，这个功能非常的重要，比如我们希望能在使用redux-thunk中getState或者mapStateToProps中state时IDE提示state类型，这时就需要获取reducer函数的返回值类型，并且进行联合导出供我们使用。
前置知识
高级类型
泛型、泛型约束
类型推论 
类型断言
以上几点都能在TS文档中找到非常清晰简洁的解释和例子，这里就不花篇幅解释了。
核心代码
// 声明一个泛型类型别名，返回值与泛型类型相同，入参类型不限制。
type Reverse<T> = (arg: any) => T;

// 声明一个泛型方法，入参arg继承泛型约束，返回空对象并断言其类型为T
function returnResultType<T>(arg: Reverse<T>): T {
  return {} as T;
}

// 调用returnResultType，传入方法 (arg: any) => 3，获得result返回值
const result = returnResultType((arg: any) => 3);

// 获取result类型并重名为ResultType
type ResultType = typeof result;
代码分析
returnResultType((arg:any)=>3);
调用returnResultType时，由于没有显示声明泛型类型，所以TS只能通过入参来进行类型推论，接着往下面走：
type Reverse<T> = (arg: any) => T;
由于入参的类型为Reverse<T> ，通过入参返回值是3可以推断出：
type Reverse<number> = (arg: any) => number;
由于Reverse的T是根据returnResultType传入的，所以同理得出：
function returnResultType<number>(arg: Reverse<number>): number {
  return {} as number;
}
由于返回值已经进行类型断言为number。所以在typeof result时，可以得出number类型。
该方法确实比较绕，因为存在多个泛型T的来回推论和反推论。
～～～
结合Redux应用
接下来我们通过reducer函数来应用一下：
1.首先编写两个简单的reducer：userReducer和loginReducer
/**
* userReducer
*/
const initUserState = {
  name: ''
}

const userReducer = (state = initUserState, action: any) => {
  switch (action.type) { 
    case 'setName':
      return {
        name: 'Larry',
        ...state
      };
    default:
      return state;
  }
}

/**
* loginReducer
*/
const initLoginState = {
  token: ''
}

const loginReducer = (state = initLoginState, action: any) => {
  switch (action.type) { 
    case 'login':
      return {
        token: 'token',
        ...state
      };
    default:
      return state;
  }
}
2.在store中
const reducers = combineReducers({
  userReducer,
  loginReducer
});

type Reverse<T> = (state: any, action:any) => T;

function returnResultType<T>(arg: Reverse<T>): T {
  return {} as T;
}

const GlobalState = returnResultType(reducers);

type GlobalStateType = typeof GlobalState;
此时的 GlobalStateType 就是我们需要的所有reducer函数返回的对象类型。
最后，导出 GlobalStateType，在我们mapStateToProps中使用时就能轻松得到类型:
逃～～～

Python中利用强大的threading模块可以很容易的实现多线程开发，提高运行速度。这一般是对某个进行大量计算操作的的函数进行多线程处理，然后合并各线程的结果。获取函数返回值的方法可以如下：
1). 利用multiprocessing.pool类
import time
import random
def test1(): # run without multi-thread
t = time.time()
list = []
for i in range(10000000):
list.append(random.choice([0,1,2,3,4,5])) # operation
print time.time()-t
return list
def test2(): # run with multi-thread
from multiprocessing.pool import Pool
def func(x):
return random.choice([0,1,2,3,4,5])
t = time.time()
pool = Pool(processes=4) #线程数
results = pool.map_async(func, range(10000000)) # 用法同map，与之相似的还有apply和apply_async
print time.time()-t
return results
r1 = test1()
r2 = test2()
运行结果为7.6s和4.2s。可以看到结果并非线性地减少4倍，这可能与运行结果需要同步有关（没深入研究，猜的）。
2). 利用threading类
def func2(m, results, index):
for i in range(m):
result[index].append(random.choice([0,1,2,3,4,5]))
from threading import Thread
def test4():
threads = [None] * 4
results = [[] for i n range(4)]
for i in range(4):
threads[i] = Thread(target=func2, args=(2500000, results, i))
threads[i].start() # 开始线程
for i in range(4):
threads[i].join()  # 等待线程结束后退出
return results
不过要注意的是只有在处理需要占用大量内存的数据的时候才考虑多线程，因为线程之间的同步问题很重要，因此设计函数的时候就需要注意，否则处理不好反而会产生很多问题。
参考
PS：threading模块和multiprocessing模块的文档的说明十分详细，准备好好研究下。

Python中利用强大的threading模块可以很容易的实现多线程开发，提高运行速度。这一般是对某个进行大量计算操作的的函数进行多线程处理，然后合并各线程的结果。获取函数返回值的方法可以如下：

1). 利用multiprocessing.pool类
import time
import random

def test1(): # run without multi-thread
    t = time.time()
    list = []
    for i in range(10000000):
        list.append(random.choice([0,1,2,3,4,5])) # operation 
    print time.time()-t
    return list

def test2(): # run with multi-thread
    from multiprocessing.pool import Pool
    def func(x):
        return random.choice([0,1,2,3,4,5])
    t = time.time()
    pool = Pool(processes=4) #线程数
    results = pool.map_async(func, range(10000000)) # 用法同map，与之相似的还有apply和apply_async
    print time.time()-t
    return results
r1 = test1()
r2 = test2()
运行结果为7.6s和4.2s。可以看到结果并非线性地减少4倍，这可能与运行结果需要同步有关（没深入研究，猜的）。
2). 利用threading类
def func2(m, results, index):
    for i in range(m):
        result[index].append(random.choice([0,1,2,3,4,5]))

from threading import Thread
def test4():
    threads = [None] * 4
    results = [[] for i n range(4)]
    for i in range(4):
        threads[i] = Thread(target=func2, args=(2500000, results, i))
        threads[i].start() # 开始线程
    for i in range(4):
        threads[i].join()  # 等待线程结束后退出
    return results
不过要注意的是只有在处理需要占用大量内存的数据的时候才考虑多线程，因为线程之间的同步问题很重要，因此设计函数的时候就需要注意，否则处理不好反而会产生很多问题。
参考

PS：threading模块和multiprocessing模块的文档的说明十分详细，准备好好研究下。
http://stackoverflow.com/questions/17262095/speed-up-a-single-task-using-multi-processing-or-threading
http://stackoverflow.com/questions/6893968/how-to-get-the-return-value-from-a-thread-in-python
https://www.tutorialspoint.com/python/python_multithreading.htm