-
PHP内部函数更改返回值的语言
2017-04-05 20:32:11$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... -
【python】装饰器小结(被装饰函数有/无返回值情况,保留被装饰函数信息)
2020-07-03 16:21:25本文主要介绍,被装饰函数有/无返回值两种情况 装饰器说的直白点,就是在不改变原有函数的的情况下,给函数增加新的功能。 其中,装饰器也是一个函数。 使用场景: 插入日志、性能测试、事务处理、缓存、权限校验等...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 -
【python】多进程返回值比较
2020-08-08 16:46:36其中被测试函数的函数返回值作为函数参数。所以使用多进程运行时间并没有减少,反而更慢,这是需要说明的,关于运行时间,仅作一般结果进行展示,不是本文的重点。 其中关于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
小结:- 因为测试函数的特殊性(函数返回值作为参数传递进函数),两种方法都相当于串行,所以时间方面并没差距
- 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 -
IOS-函数和闭包(基础一)
2017-03-07 18:31:02使用 -> 指定函数返回值(分离了返回值和参数)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 }
-
C语言基础 指针函数与函数指针
2014-11-12 22:41:10局部变量的地址不可以作为函数返回值 , 因为局部变量在函数结束时候已经被系统回收了 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)
}
-
函数定义、函数参数、跨脚本调用函数
2017-01-02 01:00:332.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:15OC函数 ...func 函数名(参数) -> 返回值类型{ 实现部分} 函数的声明与实现部分 , func 问候语(name:String,day:String)->String{ return “hello ,(name) ,today is (day)” } 函数调用 -
swift 学习之二(函数)
2014-06-18 14:42:32函数和闭包 ...使用->来指定函数返回值。 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") 无返回值函数 -
SwiftTour基础学习(六)函数和闭包
2017-11-01 00:55:00使用 func 来声明一个函数,... 来指定函数返回值的类型。 func greet(person: String, day: String) -> String { return "Hello \(person) , today is \(day)." } greet(person:"Bob", day:"Tuesday... -
Swift简明教程(三)-函数与闭包
2014-06-04 10:11:46Swift使用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:00TODAY(),显示今天日期,数据格式是日期,如果是常规,就是数字。 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")... -
Python小白学习【函数】
2019-03-17 20:03:433返回值 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:02func 使用 func 声明一个...使用 -> 分隔参数的名字和返回值类型。 func greet(name: String, day: String) -> String { return "Hello \(name), today is \(day)." } greet("Bob", -
Xcelsius常用日期函数
2010-09-07 12:20:001. 函数DATESyntax:DATE(year,month,day)通过输入月,日,年得到日期,注意如果单元格格式为数字,返回值是数字入78923,如果是日期那么返回值是1/1/2008。格式决定。YEARSyntax:YEAR(serial_number)如:=Year(3... -
swift中的函数的使用,嵌套
2015-09-23 11:36:05// 函数 ...//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() 的返回值 , 也就是包括时分秒... -
shell编程之函数定义及使用
2019-10-03 14:49:19一.函数定义 #!/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... -
Swift学习笔记 -- 函数和闭包
2015-12-09 18:23:05//声明一个函数,使用func关键字,调用函数时需要通过函数的名字和参数来调用。返回值由->来指定 func greet(name:String,day:String) ->String{ return "Hello \(name),today is \(day)." }