精华内容
下载资源
问答
  • $today = getdate(); print_r($today); ?> </code></pre> <p>return <pre><code>Array ( [seconds] => 40 [minutes] => 58 [hours] => 21 [mday] => 17 [wday] => 2 [mon] => 6 [year...
  • 本文主要介绍,被装饰函数有/无返回值两种情况 装饰器说的直白点,就是在不改变原有函数的的情况下,给函数增加新的功能。 其中,装饰器也是一个函数。 使用场景: 插入日志、性能测试、事务处理、缓存、权限校验等...

    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

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

    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
    小结:

    1. 因为测试函数的特殊性(函数返回值作为参数传递进函数),两种方法都相当于串行,所以时间方面并没差距
    2. 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一样,内存溢出,其结果只能放在队列当中,只能最后取得,不满足需求

    总结:

    参考文献

    [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 greet(name: String, day: String) -> String { return "Hello \(name), today is \(day)." }greet("Bob", "Tuesday")使用元组定义函数的多个返回值func ge

    函数和闭包

    使用 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...
    
    

    指针函数

            

             指针函数 : 返回值为指针的函数

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

            

             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)

             }

     


    展开全文
  • 2.6.函数使用函数定义示例(文件名称为.../bin/bash ##定义函数 hello() { echo "Hello there today's date is `date +%Y-%m-%d`" return 2 ##返回值其实是状态码,只能在[0-255]范围内 } hello echo $? ##获取函数
  • Swift 函数和闭包

    2016-08-29 15:26:44
    使用 -> 指定函数返回值(分离了返回值和参数)  func greet(name: String, day: String) -> String {  return "Hello \(name), today is \(day)." } greet("Bob", "Tuesday") 练习:删除 day
  • 函数和闭包

    2015-12-18 09:20:00
    来指定函数返回值的类型。 func greet(name: String, day: String) -> String { return "Hello \(name), today is \(day)." } greet("Bob", day: "Tuesday") 练习: 删除day参数,添加一个参...
  • Swift函数和闭包

    2016-03-22 12:19:29
    使用->来指定函数返回值的类型,如下: func greet(name: String, day: String) -> String { return "Hello \(name), today is \(day)." } greet("Bob", "Tuesday") 使用元组来让一个函数返回多个值。该元组的元素
  • swift函数

    2015-10-02 15:39:15
    OC函数 ...func 函数名(参数) -> 返回值类型{ 实现部分} 函数的声明与实现部分 , func 问候语(name:String,day:String)->String{ return “hello ,(name) ,today is (day)” } 函数调用
  • 函数和闭包 ...使用->来指定函数返回值。 1. func greet(name: String, day: String) -> String  { 2. return "Hello \(name), today is \(day)." 3. }
  • Swift小结函数和闭包

    2015-05-23 00:24:28
    使用 -> 来指定函数返回值如下代码:func demo(name: String, day: String) -> String { return “Hello (name), today is (day).” } demo(“zhangsan”, “Tuesday”)我们也可以使用元组来让一个函数返回多个值...
  • Swift函数

    千次阅读 2014-06-25 07:10:36
    函数定义 使用 func 定义一个函数。调用函数使用他的名字加 上小括号中的参数列表。使用 -> 分隔参数的名字和 返回值类型。 函数声明: func greet(name: ...} 函数调用:greet("Bob", "Tuesday") 无返回值函数
  • 使用 func 来声明一个函数,... 来指定函数返回值的类型。  func greet(person: String, day: String) -> String {  return "Hello \(person) , today is \(day)."  }  greet(person:"Bob", day:"Tuesday...
  • Swift使用func关键字定义函数,然后与C语言一样使用函数名进行调用,而函数返回值类型用->标示。 func greet(name: String, day: String) -> String { return "Hello \(name), today is \(day)." } greet("Bob", ...
  • Swift 函数

    2015-12-29 09:14:56
    //函数 ... 使用->分隔参数的名字和返回值类型 //函数声明 func greet(name:String, day:String) -> String { return "hello \(name), today is \(day)" } //函数调用 print(greet("Tom", day: "Tuesday
  • EXCEL 基本函数

    2019-02-17 22:36:00
    TODAY(),显示今天日期,数据格式是日期,如果是常规,就是数字。 EXCEL 起始日期,1900/1/1是第一天 日期输入方式要正确 时间数据格式 1:00:00 = 1/24 0:00:01 ==1/24/60/60 IF函数有三个参数,语法如下:...
  • EXCEL公式函数整理

    2020-11-17 10:40:37
    文本函数 UPPER 将一个字符串中所有小写字母转换为大写字母; =UPPER(A8) LOWER 是都变成小写,PROPER是首字母大写;...IF(logical_test, value_if_true, value_ if_false)判断logical_test是否是真,如果真则返回值va
  • Swift 函数使用方法

    2014-06-04 07:32:56
    用来分隔函数参数和返回值//demo1 返回不同类型的值func greet(name: String,what: String ) -> String{ return "Hello \(name), today is \(what)"}let string = greet("zhongkun","wednesday")...
  • 3返回值 4传递列表 5.传递任意数量的实参 6.函数编写 1函数定义 def greet_user(): """显示简单的问候语""" print("Today is Sunday!") greet_user() >>>Today is Sunday! 紧跟在def greet_user...
  • 函数与闭包func

    2014-06-09 14:26:02
    func  使用 func 声明一个...使用 -> 分隔参数的名字和返回值类型。    func greet(name: String, day: String) -> String {  return "Hello \(name), today is \(day)."  }  greet("Bob",
  • Xcelsius常用日期函数

    2010-09-07 12:20:00
    1. 函数DATESyntax:DATE(year,month,day)通过输入月,日,年得到日期,注意如果单元格格式为数字,返回值是数字入78923,如果是日期那么返回值是1/1/2008。格式决定。YEARSyntax:YEAR(serial_number)如:=Year(3...
  • // 函数 ...//func 函数名 (参数) -> 返回值{ // 实现部分 //} //函数的声明与实现 func 问候语 (name:String, day:String) ->String{  return "hello, \(name), today is \(day)" } // 函数调用
  • 慎用today 做列初始值

    2010-07-05 16:25:00
    [column specification] tab页上, 可以定义列的初始值(Initial Value)对于datetime类型的字段, 要慎用today(不是today()函数)来做初始值, 因为这代表Pb将使用datetime类型的 today() 的返回值 , 也就是包括时分秒...
  • 一.函数定义 #!/bin/sh #func1.sh ... echo "Hello there today's date is 'date +%Y-%m-%d' "  #return 2 ###返回值其实是状态码,只能在[0-255]范围内 } echo "now going to the funct...
  • iOS-swift-函数和闭包

    2019-09-30 06:09:38
    一、函数 关键字:func 参数列表用 , 分割 使用 -> 分割参数和返回值 1 func greet(person: String, day: String) -> String { 2 return "Hello \(person), today is \(day)." 3 } 4 gre...
  • //声明一个函数,使用func关键字,调用函数时需要通过函数的名字和参数来调用。返回值由->来指定 func greet(name:String,day:String) ->String{  return "Hello \(name),today is \(day)." }

空空如也

空空如也

1 2 3
收藏数 57
精华内容 22
关键字:

today函数返回值