匿名函数

原文：https://blog.csdn.net/jinzhencs/article/details/50748202 lambda表达式详解 一.问题 1.什么是lambda表达式？ 2.lambda表达式用来干什么的？ 3.lambda表达式的优缺点？ 4.lambda表达式的使用场景？ 5.lambda只是一个语法糖吗？ 二.概念 lambda表达式是JAVA8中提供的一种新的特性，它支持JAVA也能进行简单的“函数式编程”。 它是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。 三.先看看效果 先看几个例子： 1.使用lambda表达式实现Runnable package com.lambda; /** * 使用lambda表达式替换Runnable匿名内部类 * @author MingChenchen * */ public class RunableTest { /** * 普通的Runnable */ public static void runSomeThing(){ Runnable runnable = new Runnable() { @Override public void run() { System.out.println("I am

在Javascript中允许函数通过直接量来定义。一般情况下，我们定义函数时，最常见的方式是通过function语句进行定义，例如： function sum(a,b){ return a+b; } 这样，sum这个函数就在它所在的作用域中可以被任意调用了。除此之外，函数的定义方式可以通过另外一种方式，就是通过直接量定义。例如上面这个例子，我们可以用另外一种方式： var sum= function(a,b){ return a+b; } 上述代码就是函数通过直接量的方式进行定义。 函数直接量是一个表达式 ，它可以定义匿名函数。函数直接量的语法和function语句十分相似，只不过， 它被用作表达式的一部分，而不是用作语句了。在函数直接量定义中，右侧的function所定义的是匿名函数，并将这个匿名函数的引用传递给表达式左侧。 关于函数直接量定义，需要说明几点： 第一，函数直接量定义方式定义出来的函数是一个匿名函数，尽管通过表达式赋值语句将这个函数赋值给了左侧的变量名，但是，左侧的变量被赋值的是这个匿名函数的引用。 第二，由于函数直接量的定义方式中（代码2），实际上function已经作为一个表达式来看待，因此，表达式左侧的变量就必须在该语句执行之后才会引用 右侧的匿名函数，也就是说，在该语句执行之前，作用域中仅仅是知道有个变量是sum，但是类型未知。于此相反的是，常规的函数语句

在书上看到一个例子，有点错误。修改了一下。以下是我的理解！ 书上是这样写的，我加了些注解： function User(props){ for ( var prop in props){ ( function (currentObj){ // 这里的currentObj由this传过来的。this 为 User alert(currentObj.constructor); // 可以看出来currentObj 为User // 创建此属性的一个新的getter(读取器) currentObj[ " get " + prop] = function (){ // alert(props.name+" "+props.age+" "+prop); return props[prop]; } // 创建此属性的一个新的setter(设置器) currentObj[ " set " + prop] = function (val){ props[prop] = val; }; })( this ); // 这里的this 为 User } } var user = new User({ " name " : " chengkai " , " age " : 22 }); // 注意，name属性并不存在，因为它是属性对象（props Obj）的私有变量 alert(user.name ==

[1]工程师甲编写功能A var a = 1; var b = 2; alert(a+b);//3 [2]工程师乙添加新功能B var a = 2; var b = 1; alert(a-b);//1 [3]上一步中,工程师乙在不知情的情况下,定义了同名变量a,产生冲突。于是使用匿名函数将脚本包起来,让变量作用域控制在匿名函数之内。 //功能A (function(){ 　　var a = 1; 　　var b = 2; 　　alert(a+b);//3 })(); //功能B (function(){ 　　var a = 2; 　　var b = 1; 　　alert(a-b);//1 })(); [4]此时有了新需求,网页中加入功能C,且需要用到功能A中的变量b。于是在window作用域下定义一个全局变量,把它作为一个桥梁,完成各匿名函数之间的通信 //全局变量 var str; //功能A (function(){ 　　var a = 1; 　　//将b的值赋给str 　　var b = str = 2; 　　alert(a+b);//3 })(); //功能B (function(){ 　　var a = 2; 　　var b = 1; 　　alert(a-b);//1 })(); //功能C (function(){ 　　//将str的值赋给b 　　var b = str

匿名函数就是不需要显式的指定函数 #这段代码 def calc(n): return n**n print(calc(10)) #换成匿名函数 calc = lambda n:n**n #n为匿名函数的形参 n**n匿名函数的返回值 print(calc(10)) 匿名函数主要是和其它函数搭配使用的呢，如下： l=[3,2,100,999,213,1111,31121,333] print(max(l)) dic={'k1':10,'k2':100,'k3':30} print(max(dic)) print(dic[max(dic,key=lambda k:dic[k])]) res = map(lambda x:x**2,[1,5,7,4,8]) for i in res: print(i) 输出 1 25 49 16 64 来源： https://www.cnblogs.com/hui147258/p/10855883.html

嵌套&匿名&高阶函数 嵌套函数 函数可以嵌套定义并调用函数 name = "小明" def change(): name = "小明，你好" def change2(): # global name 如果声明了这句，下面的name改的是最外层的全局变层 name = "小明，你好，你好胖" #这句注释掉的话，下面name打印的是哪个值？ print("第3层打印", name) change2() # 调用内层函数 print("第2层打印", name) change() print("最外层打印", name) 执行结果： 第3层打印 小明，你好，你好胖 第2层打印 小明，你好 最外层打印 小明 每个函数里的变量是互相独立的，变量的查找顺序也是从当前层依次往上层找。 匿名函数 匿名函数就是不需要显式的指定函数名 #这段代码 def calc(x,y): return x**y print(calc(2,5)) #换成匿名函数 calc = lambda x,y:x**y print(calc(2,5)) 当在一个大程序中需要使用一个很简单的计算公式时，如果为了这个小计算就定义一个函数还要起一个有意义的函数名，这就会使程序员很头疼。这个时候使用匿名函数，就很方便。 另外，匿名函数主要是和其它函数搭配使用的 res = map(lambda x:x**2,[1,5,7,4,8])

没有名字的函数，不用写return，返回值就是该表达式的结果。 语法：lambda 参数：方法（或三元运算） lambda x:x*x等同于 def f(x): return x * x 1 2 3 4 5 6 7 8 9 10 11 12 13 14 #普通函数 def calc(x,y): if x > y: return x/y else: return x*y #匿名函数，想要调用必须赋一个变量 func = lambda x,y: x/y if x>y else x*y #匿名函数最多只支持三元运算，再复杂的判断不支持 print(calc(3,8)) print(calc(16,8)) print(func(3,8)) print(func(16,8)) 　结果： 24 2.0 24 2.0 上面的例子好像看不出匿名函数和普通函数有什么区别，反而看上去会容易迷糊，那有什么用呢？ 有些时候，不需要显式地定义函数，直接传入匿名函数更方便。 以map（）函数为例： 现在需要一个列表里的所有元素自乘 1 2 3 4 5 6 7 8 9 10 a = list(range(10)) print(a) #普通方法 for index,i in enumerate(a): a[index] = i*i print(a) #map（）方法 print(list(map(lambda x

def calc(x): return x+1 a=calc(10) print(calc) print(lambda x:x+1)#lambda函数的内存地址,利用函数名可以作为值传递给变量 b=lambda x:x+1 print(b(10)) name="alex" # def change_name(x): # return x+'_sb' # # # res=change_name(name) # print(res) func=lambda x:x+'_sb' print(func(name)) f=lambda x,y:x+y print(f(1,2)) fun=lambda x,y,z:(x+1,y+1,z+1)#lambda函数需要返回多个值时需要加上括号表示元祖返回 print(fun(1,2,3)) # def ti(): # return 1,2,3--->(1,2,3)python函数默认已元祖形式返回 # a=ti() # print(a) 来源： https://www.cnblogs.com/tangcode/p/10984042.html

匿名函数 (lambda)就是不需要显式的指定函数名 def calc(x,y): return x**y print(calc(2,5)) #换成匿名函数 calc = lambda x,y:x**y print(calc(2,5)) 和 map()函数 一起使用 res1 = map(lambda x:x**2,[1,5,7,8]) for i in res1: print(i) # 输出 1 25 49 64 和 filter()函数 一起使用 res2 = filter(lambda x:x%2,[i for i in range(1,11)]) for i in res2: print(i) # 输出 1 3 5 7 9 来源： https://www.cnblogs.com/shibojie/p/11658262.html

1.Scala函数的定义 def fun ( a : Int , b : Int ) : Unit = { println ( a + b ) } fun ( 1 , 2 ) def fun1 ( a : Int , b : Int ) = a + b println ( fun1 ( 1 , 2 ) ) 结果: 注意点： 函数定义语法 用def来定义 可以定义传入的参数，要指定传入参数的类型 方法可以写返回值的类型也可以不写，会自动推断，有时候不能省略，必须写，比如在递归函数中或者函数的返回值是函数类型的时候。 scala中函数有返回值时，可以写return，也可以不写return，会把函数中最后一行当做结果返回。当写return时，必须要写函数的返回类型。 如果返回值可以一行搞定，可以将{}省略不写 如果省略掉 = 则函数自动将返回值丢弃掉。即我们一般可以在无返回值的函数中，省略掉= 传递给方法的参数可以在方法中使用，并且scala规定方法的传过来的参数为val的，不是var的。所以在函数中不可以修改参数值 如果去掉方法体前面的等号，那么这个方法返回类型必定是Unit的。这种说法无论方法体里面什么逻辑都成立，scala可以把任意类型转换为Unit.假设，里面的逻辑最后返回了一个string，那么这个返回值会被转换成Unit，并且值会被丢弃。 2.递归函数 /** * 递归函数