lambda多有几个参数(lambada表达式)

一、Sarsa-lambda

Sarsa-lambda

Q learning和 Sarsa都是单步更新的算法。单步跟新的算法缺点就是在没有找到宝藏之前，机器人在原地打转的那些行动也被记录在案，并更新了Q表，即便那些行动都是没有意义的。

Lambda(λ)这个衰减系数的引入，就是为了解决这个问题的。与γ用来衰减未来预期Q的值一样，λ是当机器人获得宝藏之后，在更新Q表的时候，给机器人一个回头看之前走过的路程的机会。相当于，机器人每走一步就会在地上插一杆旗子，然后机器人每走一步旗子就会变小一点。

Sarsa(lambda)算法是Sarsa的改进版，二者的主要区别在于：

在每次take action获得reward后，Sarsa只对前一步Q(s,a)进行更新，Sarsa(lambda)则会对获得reward之前的步进行更新。

Sarsa(lambda)算法的流程如下：

从上图可以看出，和Sarsa相比，Sarsa(lambda)算法中多了一个矩阵E(eligibility trace)，它是用来保存在路径中所经历的每一步，因此在每次更新时也会对之前经历的步进行更新。

参数lambda取值范围为[0, 1]，如果 lambda= 0，Sarsa(lambda)将退化为Sarsa，即只更新获取到 reward前经历的最后一步；如果 lambda= 1，Sarsa(lambda)更新的是获取到 reward前的所有步。lambda可理解为脚步的衰变值，即离奶酪越近的步越重要，越远的步则对于获取奶酪不是太重要。

和Sarsa相比，Sarsa(lambda)算法有如下优势：

Sarsa虽然会边走边更新，但是在没有获得奶酪之前，当前步的Q值是没有任何变化的，直到获取奶酪后，才会对获取奶酪的前一步更新，而之前为了获取奶酪所走的所有步都被认为和获取奶酪没关系。Sarsa(lambda)则会对获取奶酪所走的步都进行更新，离奶酪越近的步越重要，越远的则越不重要（由参数lambda控制衰减幅度）。因此，Sarsa(lambda)能够更加快速有效的学到最优的policy。

在算法前几回合，老鼠由于没有头绪,可能在原地打转了很久，从而形成一些重复的环路，而这些环路对于算法的学习没有太大必要。Sarsa(lambda)则可解决该问题，具体做法是：在E(s,a)←E(s,a)+1这一步之前，可先令E(s)=0，即把状态s对应的行置为0，这样就只保留了最近一次到达状态s时所做的action。

二、lambada表达式

lambada表达式

Lambda表达式（lambda expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）。

C#表达式

C#的Lambda表达式都使用 Lambda运算符=>，该运算符读为“goes to”。语法如下：

(object argOne, object argTwo)=>{;/*Your statement goes here*/}

函数体多于一条语句的可用大括号括起。

类型

可以将此表达式分配给委托类型，如下所示：

delegate int del(int i);

del myDelegate=x=>{return x*x;};

int j= myDelegate(5);//j=25

创建表达式目录树类型：

using System.Linq.Expressions;

//...

Expression<del>=x=>x*x;

=>运算符具有与赋值运算符(=)相同的优先级，并且是右结合运算符。

Lambda用在基于方法的 LINQ查询中，作为诸如 Where和 Where等标准查询运算符方法的参数。

使用基于方法的语法在 Enumerable类中调用 Where方法时（像在 LINQ to Objects和 LINQ to XML中那样），参数是委托类型 System..::.Func<(Of<(T, TResult>)>)。使用 Lambda表达式创建委托最为方便。例如，当您在 System.Linq..::.Queryable类中调用相同的方法时（像在 LINQ to SQL中那样），则参数类型是 System.Linq.Expressions..::.Expression<Func>，其中 Func是包含至多五个输入参数的任何 Func委托。同样，Lambda表达式只是一种用于构造表达式目录树的非常简练的方式。尽管事实上通过 Lambda创建的对象的类型是不同的，但 Lambda使得 Where调用看起来类似。

在前面的示例中，请注意委托签名具有一个 int类型的隐式类型输入参数，并返回 int。可以将 Lambda表达式转换为该类型的委托，因为该表达式也具有一个输入参数(x)，以及一个编译器可隐式转换为 int类型的返回值。（以下几节中将对类型推理进行详细讨论。）使用输入参数 5调用委托时，它将返回结果 25。

在 is或 as运算符的左侧不允许使用 Lambda。

适用于匿名方法的所有限制也适用于 Lambda表达式。有关更多信息，请参见匿名方法（C#编程指南）。

特殊

下列规则适用于 Lambda表达式中的变量范围：

捕获的变量将不会被作为垃圾回收，直至引用变量的委托超出范围为止。

在外部方法中看不到 Lambda表达式内引入的变量。

Lambda表达式无法从封闭方法中直接捕获 ref或 out参数。

Lambda表达式中的返回语句不会导致封闭方法返回。

Lambda表达式不能包含其目标位于所包含匿名函数主体外部或内部的 goto语句、break语句或 continue语句。

Lambda表达式的本质是“匿名方法”，即当编译我们的程序代码时，“编译器”会自动将“Lambda表达式”转换为“匿名方法”，如下例：

string[] names={"agen","balen","coure","apple"};

string[] findNameA=Array.FindAll<string>(names,delegate(string v){return v.StartsWith("a");});

string[] findNameB=Array.FindAll<string>(names,v=>v.StartsWith("a"));

上面中两个FindAll方法的反编译代码如下：

string[] findNameA=Array.FindAll<string>(names,delegate(string v){return v.StartsWith("a");});

string[] findNameB=Array.FindAll<string>(names,delegate(string v){return v.StartsWith("a");});

从而可以知道“Lambda表达式”与“匿名方法”是可以划上等号的，只不过使用“Lambda表达式”输写代码看上去更直观漂亮，不是吗?

Lambda表达式的语法格式：

参数列表=>语句或语句块[1]

其中“参数列”中可包含任意个参数(与委托对应），如果参数列中有0个或1个以上参数，则必须使用括号括住参数列，如下：

x=> x+ 1// Implicitly typed, expression body

x=>{ return x+ 1;}// Implicitly typed, statement body

(int x)=> x+ 1// Explicitly typed, expression body

(int x)=>{ return x+ 1;}// Explicitly typed, statement body

(x, y)=> x* y// Multiple parameters

()=> Console.WriteLine()// No parameters

async(t1,t2)=> await t1+ await t2// Async

delegate(int x){ return x+ 1;}// Anonymous method expression

delegate{ return 1+ 1;}// Parameter list omitted

三、Lambda表达式的C#表达式

C#的Lambda表达式都使用 Lambda运算符=>，该运算符读为“goes to”。语法如下：

形参列表=>函数体

函数体多于一条语句的可用大括号括起。可以将此表达式分配给委托类型，如下所示： delegateintdel(inti);delmyDelegate=x=>{returnx*x;};intj=myDelegate(5);//j=25创建表达式目录树类型： usingSystem.Linq.Expressions;//...Expression<del>=x=>x*x;=>运算符具有与赋值运算符(=)相同的优先级，并且是右结合运算符。

Lambda用在基于方法的 LINQ查询中，作为诸如 Where和 Where等标准查询运算符方法的参数。

使用基于方法的语法在 Enumerable类中调用 Where方法时（像在 LINQ to Objects和 LINQ to XML中那样），参数是委托类型 System..::.Func<(Of<(T, TResult>)>)。使用 Lambda表达式创建委托最为方便。例如，当您在 System.Linq..::.Queryable类中调用相同的方法时（像在 LINQ to SQL中那样），则参数类型是 System.Linq.Expressions..::.Expression<Func>，其中 Func是包含至多五个输入参数的任何 Func委托。同样，Lambda表达式只是一种用于构造表达式目录树的非常简练的方式。尽管事实上通过 Lambda创建的对象的类型是不同的，但 Lambda使得 Where调用看起来类似。

在前面的示例中，请注意委托签名具有一个 int类型的隐式类型输入参数，并返回 int。可以将 Lambda表达式转换为该类型的委托，因为该表达式也具有一个输入参数(x)，以及一个编译器可隐式转换为 int类型的返回值。（以下几节中将对类型推理进行详细讨论。）使用输入参数 5调用委托时，它将返回结果 25。

在 is或 as运算符的左侧不允许使用 Lambda。

适用于匿名方法的所有限制也适用于 Lambda表达式。有关更多信息，请参见匿名方法（C#编程指南）。下列规则适用于 Lambda表达式中的变量范围：

捕获的变量将不会被作为垃圾回收，直至引用变量的委托超出范围为止。

在外部方法中看不到 Lambda表达式内引入的变量。

Lambda表达式无法从封闭方法中直接捕获 ref或 out参数。

Lambda表达式中的返回语句不会导致封闭方法返回。

Lambda表达式不能包含其目标位于所包含匿名函数主体外部或内部的 goto语句、break语句或 continue语句。

Lambda表达式的本质是“匿名方法”，即当编译我们的程序代码时，“编译器”会自动将“Lambda表达式”转换为“匿名方法”，如下例： string[]names={agen,balen,coure,apple};string[]findNameA=Array.FindAll<string>(names,delegate(stringv){returnv.StartsWith(a);});string[]findNameB=Array.FindAll<string>(names,v=>v.StartsWith(a));上面中两个FindAll方法的反编译代码如下： string[]findNameA=Array.FindAll<string>(names,delegate(stringv){returnv.StartsWith(a);});string[]findNameB=Array.FindAll<string>(names,delegate(stringv){returnv.StartsWith(a);});从而可以知道“Lambda表达式”与“匿名方法”是可以划上等号的，只不过使用“Lambda表达式”输写代码看上去更直观漂亮，不是吗?

Lambda表达式的语法格式：

参数列表=>语句或语句块

其中“参数列”中可包含任意个参数(与委托对应），如果参数列中有0个或1个以上参数，则必须使用括号括住参数列，如下：

()=> Console.Write(0个参数)

I=> Console.Write(1个参数时参数列中可省略括号，值为：{0},i)

(x,y)=> Console.Write(包含2个参数，值为：{0}*{1},x,y)

而“语句或语句块”中如果只有一条语句，则可以不用大括号括住否则必须使用，如下：

I=> Console.Write(只有一条语句)

I=>{ Console.Write(使用大括号的表达式);}

//两条语句时必须要大括号

I=>{ i++;Console.Write(两条语句的情况);}

如果“语句或语句块”有返回值时，如果只有一条语句则可以不输写“return”语句，编译器会自动处理，否则必须加上，如下示例：

“Lambda表达式”是委托的实现方法，所以必须遵循以下规则：

1）“Lambda表达式”的参数数量必须和“委托”的参数数量相同；

2）如果“委托”的参数中包括有ref或out修饰符，则“Lambda表达式”的参数列中也必须包括有修饰符；

例子： classTest{delegateintAddHandler(intx,inty);staticvoidPrint(AddHandleradd){Console.Write(add(1,3));}staticvoidMain(){Print((x,y)=>x+y);Print((x,y)=>{intv=x*10;returny+v;});Console.Read();}}注：如果包括有修饰符，则“Lambda表达式”中的参数列中也必须加上参数的类型

3）如果“委托”有返回类型，则“Lambda表达式”的“语句或语句块”中也必须返回相同类型的数据；

4）如果“委托”有几种数据类型格式而在“Lambda表达式”中“编译器”无法推断具体数据类型时，则必须手动明确数据类型。

例子：

(错误代码） classTest{delegateTAddHandler<T>(Tx,Ty);staticvoidPrint(AddHandler<int>test){Console.WriteLine(inttype:{0},test(1,2));}staticvoidPrint(AddHandler<double>test){Console.WriteLine(doubletype:{0},test(1d,2d));}staticvoidMain(){Print((x,y)=>x+y);Console.Read();}}当我们编译以下代码时，编译器将会显示以下错误信息：

在以下方法或属性之间的调用不明确:

“ConsoleApplication1.Test.Print(ConsoleApplication1.Test.AddHandler<int>)”和“ConsoleApplication1.Test.Print(ConsoleApplication1.Test.AddHandler<double>)”

所以我们必须明确数据类型给编译器，如下： Print((intx,inty)=>x+y);这样我们的代码就能编译通过了。