c#函数func用lambda表达式怎么写

Posted 2023-04-23

一般都是匿名的委托方式，直接传参数进去：

例如：

Func<int,string,string> t=(int x, string b) => (x.ToString() + b);就等于private  string  deletegate  TestString(int x， string b );//定义一个委托,返回值为string类型

private string  test(int x，string b)｛
　　return x.ToString() + b;
｝

TestString t=new TestString(test);
t(44,"bbb");


Func<int,string,string>就是定义一个委托=private  string  deletegate  TestString(int x string b )，前两个参数是相应方法的参数类型，最后一个为方法的返回类型。

参考技术A using System;
public class GenericFunc

   public static void Main()
   
      // Instantiate delegate to reference UppercaseString method
      Func<string, string> convertMethod = UppercaseString;//非lambda
      //或者
      Func<string, string> convertMethod2 = (s)=>return  s.ToUpper();;//lambda表达式
      string name = "Dakota";
      // Use delegate instance to call UppercaseString method
      Console.WriteLine(convertMethod(name));
   

   private static string UppercaseString(string inputString)
   
      return inputString.ToUpper();
   

func是个泛型委托，上面是采用 string作为返回值和参数的版本

内置函数 lambda表达式

匿名函数

# 函数名 = lambda 参数:返回值
def func(a, b):
    return a + b
print(func(2,3)) # 5

func = lambda a, b: a+b
print(func(1, 2)) # 3

# 写匿名函数：接收两个int参数，将较大的数据返回。
func = lambda a, b: a if a > b else b
print(func(12, 1))# 12

# 匿名函数：接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式）。
func = lambda a: (a[0], a[2])
print(func([1,  2, 3]))   # (1, 3)

func = lambda a, b, *args, name, **kwargs: kwargs
# 返回如下 # {‘sex‘: ‘男‘, ‘hobby‘: ‘basketball‘}
print(func(1, 2, [1, 2, 3], ‘hello‘, name=‘张三‘, **{‘sex‘: ‘男‘}, hobby=‘basketball‘))

print(float(3))  # 3.0
print(int(3.5))  # 3
print(complex(1, 2))  # (1+2j)
# bin：将十进制转换成二进制并返回。  **
print(bin(100))  # 0b1100100
# # oct：将十进制转化成八进制字符串并返回。  **
print(oct(10))  # 0o12
# # hex：将十进制转化成十六进制字符串并返回。  **
print(hex(10))  # 0xa

# divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(10,  3))
# round：保留浮点数的小数位数，默认保留整数。
print(round(3.1415, 2))  # 3.14
print(round(10/3))  # 3
# pow：求x**y次幂。（三个参数为x**y的结果对z取余）
print(pow(2, 3))  # 8 幂
print(pow(2, 4, 3)) # 1  2的4次方，对3取余

# bytes
s1 = ‘中国‘
t = s1.encode(‘utf-8‘)
print(t)  # b‘xe4xb8xadxe5x9bxbd‘
print(bytes(s1, encoding=‘utf-8‘))  # b‘xe4xb8xadxe5x9bxbd‘
print(t.decode(‘utf-8‘))  # 中国


# ord:输入字符找该字符编码的位置
print(ord(‘a‘))  # 97
# chr:输入位置数字找出其对应的字符
print(chr(97))  # a


# repr:返回一个对象的string形式（原形毕露）。
name = ‘王路飞‘
print(name)  # 王路飞
print(repr(name))  # ‘王路飞‘
msg = ‘我是%s‘ % ‘海贼王‘
print(msg)  # 我是海贼王
msg = ‘我是%r‘ % ‘海贼王‘
print(msg)  # 我是‘海贼王‘

# all：可迭代对象中，全都是True才是True
# any：可迭代对象中，有一个True 就是True

print(all([1, 2, True, 0]))  # False
print(any([1, ‘‘, 0]))  # True


# print| sep分隔符 end（默认是换行）
# print(1, 2, 3, sep=‘|‘)  # 1|2|3 sep是分隔符号

# 99 乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(‘%s * %s = %s‘ % (i, j, i*j), end=‘ ‘)
    print()

l2 = list()
print(l2)  # []
print(list(‘hello‘))  # [‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘]
print(list([1, 2, 3]))  # [1, 2, 3]

# abs # 绝对值
print(abs(-6))

# sum 求和 只能求int型
l1 = [i for i in range(5)]
print(sum(l1))  # 10
print(sum(l1, 10))   # 20  初始值

s1 = ‘1234‘ # 求每个数字相加，列表推倒式 转为列表
t = [int(s1[i]) for i in range(len(s1))]
print(t)  # [1, 2, 3, 4]
print(sum(t))

# reversed() 将一个序列翻转, 返回翻转序列的迭代器 reversed 示例:
l = [i for i in range(5)]
ret = reversed(l)  # 获得的是生成器
print(l)  # [0, 1, 2, 3, 4] 原列表是没有变化的
print(ret)  # <list_reverseiterator object at 0x1080315c0>
print(list(ret))  # [4, 3, 2, 1, 0]
l = reversed(‘你好‘)  # l 获取到的是一个生成器
print(list(l))  # [‘好‘, ‘你‘]
# reverse 是在原列表更改的
list1 = [1, 2, 3]
list1.reverse()
print(list1)  # [3, 2, 1]

# zip() 拉链方法。函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,
# 然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回，
l1 = [1, 2, 3]
l2 = [‘路飞‘, ‘索隆‘, ]
s = ‘onepiece‘
print(zip(l1, l2, s))  # <zip object at 0x10de7c548> 迭代器
t = list(zip(l1, l2, s))
print(t)  # [(1, ‘路飞‘, ‘o‘), (2, ‘索隆‘, ‘n‘)]
for i in zip(l1, l2, s):
    print(i)  # (1, ‘路飞‘, ‘o‘)    (2, ‘索隆‘, ‘n‘)

# min
# 有key的：它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中，
# # 以返回值比较大小。
l =[1, 2, -3]
print(min(l))  # -3
print(min(l, key=abs))  # 1  l中的每一个值传入到abs函数中比大小，返回绝对值的最小值
# 字典默认是以键比较大小
# 以下以值的大小作比较(每一个键传入到lambda函数中做比较)

dic = {‘a‘: 3, ‘b‘: 2, ‘c‘: 1}
dic_min = min(dic, key=lambda args: dic[args])
print(dic_min)  # 默认返回的是键的值 c
#     第一次：
#      args:   ‘a‘   返回值：dic[‘a‘]     记录：3
#     第二次：
#      args :   ‘b‘   返回值：dic[‘b‘]     记录：2
#     第三次：
#      args:  ‘c‘   返回值：dic[‘c‘]    记录：1
#     ‘‘‘
print((dic_min, dic[dic_min]))  # (‘c‘, 1)

# 返回年龄的最小值(‘太白‘, 18)
l2 = [(‘太白‘, 18), (‘alex‘, 73), (‘wusir‘, 35), (‘口天吴‘, 41)]
print(min(l2))  # (‘alex‘, 73) 默认是按照每个元组的首字母找最小,返回的是元组
print(min(l2, key=lambda x: x[1]))  # (‘太白‘, 18)根据年龄找最小元组
print(min(l2, key=lambda x: x[1])[1])  # 18 最小年龄的值18

# sorted 生成的是新列表
l2 = [(‘B‘, 86), (‘C‘, 70), (‘A‘, 94)]
l = sorted(l2)
print(l)  # 默认首字符排列 [(‘A‘, 94), (‘B‘, 86), (‘C‘, 70)]
print(sorted(l2, key=lambda x: x[1]))  # [(‘C‘, 70), (‘B‘, 86), (‘A‘, 94)] 按照成绩大小排序
print(sorted(l2, key=lambda x: x[1], reverse=True))  # [(‘A‘, 94), (‘B‘, 86), (‘C‘, 70)]


# filter  返回的是迭代器
l = [1, 2, 3, 4]
print([x for x in l if x > 2]) #  列表推倒 # [3, 4] 返回的是列表
ret = filter(lambda a: a > 2, l)
print(ret)  #  <filter object at 0x106bdbf98>  返回的是迭代器
print(list(ret))  #  [3, 4]


# map 写出 l = [1, 4, 9, 16] 类似列表推倒循环模式
# 用列表推倒 返回的是列表
l = [i**2 for i in range(1, 5)]
print(l)  # [1, 4, 9, 16]
# map返回的是迭代器
l = map(lambda x: x**2, range(1, 5))
print(l)  # <map object at 0x101898e10> 迭代器
print(list(l))  # [1, 4, 9, 16]

# reduce
# reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
# 接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始
# 临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推
# 注意:我们放进去的可迭代对象没有更改

from functools import reduce
res = reduce(lambda x, y: 10*x+y, range(4))
print(res)  # 123