every blog every motto:  Light tomorrow with today.
0. 前言
本文主要介绍，被装饰函数有/无返回值两种情况和保留被装饰函数信息等问题。

装饰器说的直白点，就是在不改变原有函数的的情况下，给函数增加新的功能。

其中，装饰器也是一个函数。

使用场景： 插入日志、性能测试、事务处理、缓存、权限校验等。

说明：  本文以最常见的测试函数运行时间举例
1. 正文
1.1被装饰函数无返回值
装饰器：
import time


def count_time(func):
    """装饰器：计算程序运行时间"""

    def wrapper(*args, **kwargs):
        t1 = time.time()
        func(*args, **kwargs)
        t2 = time.time()

        # 计算时间
        time_consumed = t2 - t1
        print('{}函数一共花费了{}秒'.format(func.__name__, time_consumed))
        
    return wrapper

用@符号对（无返回值）函数进行装饰
@count_time
def sum_n(n):
    """求和"""
    sum = 0
    for i in range(n):
        sum += i
    print('-----------sum:', sum)

主程序
def main():
    temp = sum_n(1111150)


if __name__ == '__main__':
    main()

1.2被装饰函数有返回值
装饰器
import time


def count_time(func):
    """装饰器：计算程序运行时间"""

    def wrapper(*args, **kwargs):
        t1 = time.time()
        res = func(*args, **kwargs)
        t2 = time.time()

        # 计算时间
        time_consumed = t2 - t1
        print('{}函数一共花费了{}秒'.format(func.__name__, time_consumed))
        return res
    return wrapper

被装饰函数
@count_time
def sum_n(n):
    """求和"""
    sum = 0
    for i in range(n):
        sum += i
    print('-----------sum:', sum)

    return sum

主程序
def main():
    n = 1111150
    temp = sum_n(n)
    print('1到{}的和为：{}'.format(n, temp))


if __name__ == '__main__':
    main()

1.3 保留被装饰函数的属性信息（函数名、帮助文档等）
未做处理前：
import time


def count_time(func):
    """装饰器：计算程序运行时间"""

    def wrapper(*args, **kwargs):
        t1 = time.time()
        res = func(*args, **kwargs)
        t2 = time.time()

        # 计算时间
        time_consumed = t2 - t1
        print('{}函数一共花费了{}秒'.format(func.__name__, time_consumed))
        return res

    return wrapper


@count_time
def sum_n(n):
    """
    对传进来的n，从1开始求和，并返回结果
    :param n: 传进的n
    :return: 返回求和后的结果
    """
    sum = 0
    for i in range(n):
        sum += i
    print('-----------sum:', sum)

    return sum


def main():
    n = 1111150
    temp = sum_n(n)
    print('1到{}的和为：{}'.format(n, temp))
    print('-----------------------------------')
    print('函数名：', sum_n.__name__)  # 查看函数名
    print('显示帮助文档信息：')
    help(sum_n)  # 查看帮助文档
    print('-----------------------------------')

if __name__ == '__main__':
    main()

可以发现函数名、帮助文档都被改变结果如下图所示：



处理后，
import time
import functools


def count_time(func):
    """装饰器：计算程序运行时间"""

    @functools.wraps(func) # 保留被装饰函数信息
    def wrapper(*args, **kwargs):
        t1 = time.time()
        res = func(*args, **kwargs)
        t2 = time.time()

        # 计算时间
        time_consumed = t2 - t1
        print('{}函数一共花费了{}秒'.format(func.__name__, time_consumed))
        return res

    return wrapper


@count_time
def sum_n(n):
    """
    对传进来的n，从1开始求和，并返回结果
    :param n: 传进的n
    :return: 返回求和后的结果
    """
    sum = 0
    for i in range(n):
        sum += i
    print('-----------sum:', sum)

    return sum


def main():
    n = 1111150
    temp = sum_n(n)
    print('1到{}的和为：{}'.format(n, temp))
    print('-----------------------------------')
    print('函数名：', sum_n.__name__)  # 查看函数名
    print('显示帮助文档信息：')
    help(sum_n)  # 查看帮助文档
    print('-----------------------------------')


if __name__ == '__main__':
    main()

保留了函数信息，结果如下图所示：


参考文献
[1] https://blog.csdn.net/TangHuanan/article/details/45094497?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase

[2] https://blog.csdn.net/xiangxianghehe/article/details/77170585?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase

[3] https://blog.csdn.net/y_yang666/article/details/86737541

[4] https://blog.csdn.net/sheqianweilong/article/details/89787944

[5] https://blog.csdn.net/tryhardsilently/article/details/90767627

every blog every motto:  Light tomorrow with today.
0. 前言
网上目前关于多进程返回值的文章较为零散，本文主要进行简单的小结。

说明：

其中被测试函数的函数返回值作为函数参数。所以使用多进程运行时间并没有减少，反而更慢，这是需要说明的，关于运行时间，仅作一般结果进行展示，不是本文的重点。
其中关于apply和apply_async两种方法运行时间的比较可参考时间比较

1. 正文
测试函数时间用到装饰器，具体可参考装饰器

导入模块：
import threading
from queue import Queue
import multiprocessing
from multiprocessing import Manager
import time

loop_number = 30000 # 循环次数

1.1 无多进程情况
def fun(k):
    """被测试函数"""
    print('-----fun函数，参数为{}----'.format(k))
    m = k + 10
    return m 

@count_time
def call_fun():
    """没有使用多线/进程的情况"""
    number = 0

    for i in range(loop_number):
        print('number:{}'.format(number))
        number = fun(number)

def main():
    """主程序"""

    # 1. 没有使用多线程
    call_fun()


if __name__ == '__main__':
    main()

结果：


1.2 多进程返回值
1.2.1 方法一：进程池Pool
有关多种进程池的apply，apply_async的时间比较可参考文献1
1. apply
def fun(k):
    """被测试函数"""
    print('-----fun函数，参数为{}----'.format(k))
    m = k + 10
    return m  
   
@count_time
def my_process():
    """多进程"""

    # 方法一：apply/apply_async
    pool = multiprocessing.Pool(4)  # 创建4个进程
    k = 0
    for i in range(loop_number):
        k = pool.apply(fun, args=(k,)
        print('返回值为:', k)

 
def main():
    """主程序"""

    # 3. 使用多进程
    my_process()


if __name__ == '__main__':
    main()

结果：


2. apply_async
def fun(k):
    """被测试函数"""
    print('-----fun函数，参数为{}----'.format(k))
    m = k + 10
    return m  
   
@count_time
def my_process():
    """多进程"""

    # 方法一：apply/apply_async
    pool = multiprocessing.Pool(4)  # 创建4个进程
    k = 0
    for i in range(loop_number):
        k = pool.apply_async(fun, args=(k,))
        k = k.get()
        print('返回值为:', k)

 
def main():
    """主程序"""

    # 3. 使用多进程
    my_process()


if __name__ == '__main__':
    main()

结果：



说明：

上述运行时间，仅作一般参考，运行时间非本文重点，具体参考文献1

小结：

因为测试函数的特殊性（函数返回值作为参数传递进函数），两种方法都相当于串行，所以时间方面并没差距
apply_async方法返回结果为对象，所以需要用get方法获取结果


apply_async关于返回结果位置小讨论：
1. 返回结果中间输出：
@count_time
def my_process():
    """多进程"""

    # 方法一：apply/apply_async
    pool = multiprocessing.Pool(4)  # 创建4个进程
    k = 0
    for i in range(loop_number):
        t = pool.apply_async(fun, args=(k,))

        print('返回值为:', t.get())


结果：


2. 返回结果最后输出：
@count_time
def my_process():
    """多进程"""

    # 方法一：apply/apply_async
    pool = multiprocessing.Pool(4)  # 创建4个进程
    k = 0
    li = [] # 空列表
    for i in range(loop_number):
        t = pool.apply_async(fun, args=(k,))
		li.append(t)
	for i in li:
        print('返回值为:', i.get())


结果：



时间不同的原因：

在进行得到各个结果的时候，是将结果追加到列表中，否则，在得到结果get的时候会阻塞进程，从而将多进程变成了单进程，当使用列表来存放时，在进行get数据的时候，可以设置超时时间，如，get(timeout=5)。

小结：

对于apply_async返回结果最后输出时间更短
对于apply二者没有明显区别，读者可自行验证

1.2.2 方法二：Manger
from multiprocessing import Manager, Process

def fun(k,result_dict):
    """被测试函数"""
    print('-----fun函数内部，参数为{}----'.format(k))
    m = k + 10

    result_dict[k] = m # 方法二：manger

@count_time
def my_process():
    """多进程"""

    # 方法二：Manger
    manger = Manager()
    result_dict = manger.dict()  # 使用字典
    jobs = []

    for i in range(10):
        p = Process(target=fun, args=(i, result_dict))
        jobs.append(p)
        p.start()

    for pr in jobs:
        pr.join()
    var = result_dict
    print('返回结果', var.values())

def main():
    """主程序"""


    # 3. 使用多进程
    my_process()


if __name__ == '__main__':
    main()

结果：


说明：

上面用的是字典，也可以用列表
返回的结果只有等所有子进程运行完以后才能获取，从这一点上来说，不满足我们的要求，由于作为获取多进程的一种方法，附上。

1.2.3 方法三：Pipe
定义类
class MyProcess(multiprocessing.Process):
    def __init__(self, name, func, args):
        super(MyProcess, self).__init__()
        self.name = name
        self.func = func
        self.args = args
        self.res = ''

    def run(self):
        self.res = self.func(*self.args)


def fun(k,p):
    """被测试函数"""
    print('-----fun函数内部，参数为{}----'.format(k))
    m = k + 10

    p.send(m)

@count_time
def my_process():
    """多进程"""

    # 方法三：
    process_li = []
    parent_con, child_con = multiprocessing.Pipe()
    for i in range(30):
        p = MyProcess('proce', fun, (1, child_con))
        process_li.append(p)
        p.start()
    for i in process_li:
        i.join()
    for i in process_li:
        print(parent_con.recv())

结果：



说明：

当参数loop_number=30000时，内存溢出，电脑被搞黑屏了，所以仅循环30次，
函数返回的结果只能最后一起输出，不符合要求。

1.2.3 方法四：Quene
定义类
class MyProcess(multiprocessing.Process):
    def __init__(self, name, func, args):
        super(MyProcess, self).__init__()
        self.name = name
        self.func = func
        self.args = args
        self.res = ''

    def run(self):
        self.res = self.func(*self.args)


def fun(k, p):
    """被测试函数"""
    print('-----fun函数内部，参数为{}----'.format(k))
    m = k + 10

    p.put(m)

@count_time
def my_process():
    """多进程"""

    # 方法四：Queue
    process_li = []
    q = multiprocessing.Queue()
    k = 1
    for i in range(30):
        p = MyProcess('proce', fun, (k, q))
        p.start()
        process_li.append(p)
    for i in process_li:
        i.join()

    while q.qsize() > 0:
        print(q.get())

结果：



说明：

和上面Pipe一样，内存溢出，其结果只能放在队列当中，只能最后取得，不满足需求


总结：

建议使用进程池apply / apply_async
参照这篇文章apply/apply_async时间比较分析，推荐使用ThreadPool下的apply_async

参考文献
[1] https://blog.csdn.net/weixin_39190382/article/details/107865552

[2] https://zhidao.baidu.com/question/246068963774450124.html

[3] https://blog.csdn.net/sunt2018/article/details/85336408

[4] https://blog.csdn.net/ztf312/article/details/80337255

[5] https://www.jb51.net/article/86412.htm

[6] https://blog.csdn.net/littlehaes/article/details/102626610

函数和闭包

使用 func 来声明一个函数，通过函数的名字和参数来调用函数。使用 -> 指定函数返回值（分离了返回值和参数）

func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
}

greet("Bob", "Tuesday")

使用元组定义函数的多个返回值

func getGasPrices() -> (Double, Double, Double) {
    return (3.59, 3.69, 3.79)
}
getGasPrices()


传递可变数量的参数，通过数组获取参数

func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(42, 597, 12)

函数可以嵌套，被嵌套的函数可以访问外部函数的变量。可以通过函数的嵌套来重构太长或者太复杂的函数。

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()


函数是一级类型，这意味着函数可以使用另一个函数作为返回值

func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)


函数也可以使用另一个函数作为参数

func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, lessThanTen)


实际上函数是一种特殊的闭包。通过 {} 创建一个匿名的闭包，使用 in 将执行体和参数、返回值进行分离

numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
    })

有多种更简明创建闭包的方法。如果一个闭包类型已知，比如作为一个回调函数，这时可以忽略它的参数类型、或则返回值类型、或则二者都忽略。单条语句的闭包可以直接将语句的结果当做返回值。 
numbers.map({ number in 3 * number })

可以通过参数的位置而不是名称来引用参数–这对于简短的闭包来说非常有用；闭包作为最后一个参数传递给函数时，可以直接跟在括号后面。 
sort([1, 5, 3, 12, 2]) { $0 > $1 }

原文链接：Swift语言学习 http://www.ioswift.org/

指针函数
        

         指针函数 : 返回值为指针的函数
         局部变量的地址不可以作为函数返回值 , 因为局部变量在函数结束时候已经被系统回收了
        

         char *words()
         {       

                  return “today is good day!\n”;
         }
 
         char *words2()  //错误示范(局部变量)
         {
                  char words[] = “today is good day!\n”;
                  return words;
         }
 
         char *words3()
         {
         // 申请堆中一块内存
         int len = 20;
         char *word = alloc(20,sizeof(char));
         strcpy(word ,“today is good day!\n”;len -1);
         return word;
         }
 
         // 当堆中一块内存没有指针指向它的时候 , 那么这一块内存就永远得不到释放
         在堆中的内存没有释放之前必须有一个指针指向这一块内存       

         int main()
         {
         char *w = word();
         printf(“%s”,w);
         }

----------------------------------------------------------------------------------------------------------------
 函数指针
         指向函数的指针
         函数指针定义格式: 指针所指向函数的返回值类型 (*函数指针名称) (指针所指向的函数的形参列表)
 
         写一个函数指针的步骤:
         1.拷贝索要指向的函数
         2.在函数名称使用小括号括起来
         3.在函数名称前面加*
         4.修改函数名为指针名称
 
函数指针的指向是可以改变的 , 但必须指向同类型的函数
同类型的函数 : 返回值类型与形参雷彪都相同函数
 
         void test()
         {
                  printf(“空参数返回值函数\n”);
         }
 
         int main( ){
         // test后面的括号是指向test所指向的代码
         //test本身是一个指针
         test();
         printf(“%p\n”,test);
         }
 
         void (*mothedP)( );
         mothedP = test;
         //第一种调用方式
         mothedP = test;
         //第二种调用方式 
         mothedP( );
 
 
         int sum(int sum1 , int sum2)
         {
                  return num1 +num2;
         }
 
         int minus(int num1,int num2)
         {
                  return num1 - num2;
         }
 
         int main()
         {
                  int (*sumPointer)(int num1,int num2);
                  sumPointer = sum;
 
                  int  rs = sumPointer(10,20);
                  printf(“rs=%d\n”,rs);
                 

                  pointer =minus;
                  rs = pointer(10,20);
                  printf("rs=%d\n",rs)
         }