【无标题】Python lambda 初探

python3 中lambda的高级用法中返回的多为迭代器：

<filter object at 0x000002B8A1C9AC88>  # 迭代器
[1,2,3]                                # 列表

lambda函数总结：

1、lambda只是一个表达式，函数体比def简单很多

2、lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去

3、lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数

4、 简单单行代码或者一次性的函数可以用lambda函数来书写，可以让代码更简洁。

5、 对于复杂函数或者函数体体量大的函数，最好不要用lambda函数，会增加代码的阅读难度，使代码晦涩难懂。

6、 在非多次调用的函数的情况下，lambda表达式即用既得，提高性能

原型：

lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边的返回值。lambda语句构建的其实是一个函数对象。

如果没有参数，则lambda冒号前面就没有

示例：

add = lambda x, y: x + y
demo = lambda :'无参数'
print(add(3, 5))  # 8
print(demo())  # 无参数

高阶用法：

1.map（）函数：

        描述：
        map() 会根据提供的函数对指定序列做映射。
        第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function         函数返回值的新列表。
        语法：
        map(function, iterable, ...)
        参数：
        function ----> 函数
        iterable ----> 一个或多个序列
        返回值：
        Python 2.x 版本返回的是列表
        Python 3.x 版本返回的是迭代器

        

# ===========一般写法：===========
# 1、计算平方数
def square(x):
	return x ** 2

map(square, [1,2,3,4,5])	# 计算列表各个元素的平方
# 结果：
[1, 4, 9, 16, 25]

# ===========匿名函数写法：============
# 2、计算平方数，lambda 写法
map(lambda x: x ** 2, [1, 2, 3, 4, 5])
# 结果：
[1, 4, 9, 16, 25]	 

# 3、提供两个列表，将其相同索引位置的列表元素进行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
# 结果：
[3, 7, 11, 15, 19]

a = [1,2,3,4,5]
b = map(lambda x:x*2, a)
print(b,type(b))
for i in b:
 print(i)
#结果：
<map object at 0x0000010EDCFE59B0> <class 'map'>
2
4
6
8
10

2.

reduce() 函数：
描述：
reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

语法：
reduce(function, iterable[, initializer])
参数：
function  ----> 函数，有两个参数
iterable   ----> 可迭代对象
initializer ----> 可选，初始参数
返回值：
返回函数计算结果。
 

# ===========一般写法：===========
# 1、两数相加
def add(x, y):            
	return x + y

reduce(add, [1, 3, 5, 7, 9])    # 计算列表元素和：1+3+5+7+9
# 结果：
25

"""
===========执行步骤解析：===========
调用 reduce(add, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：
1	先计算头两个元素：f(1, 3)，结果为4；
2	再把结果和第3个元素计算：f(4, 5)，结果为9；
3	再把结果和第4个元素计算：f(9, 7)，结果为16；
4	再把结果和第5个元素计算：f(16, 9)，结果为25；
5	由于没有更多的元素了，计算结束，返回结果25。
"""
# ===========匿名函数写法：===========
# 2、两数相加，lambda 写法
reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
# 结果：
15

# 当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。
	
# 3、但是如果要把序列 [1, 3, 5, 7, 9] 变换成整数 13579，reduce就可以派上用场：
from functools import reduce

def fn(x, y):
	return x * 10 + y

reduce(fn, [1, 3, 5, 7, 9])
# 结果：
13579


from functools import reduce
a = [1,3,5,7,9]
def add(x,y):
 return x+y
c = reduce(add,a)
d = reduce(lambda x,y:x+y,a)
print(c)
print(d)
#结果：
25
25

3.

sorted() 函数：
描述：
sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：
sort 是 list 的一个方法，而 sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法：
sorted(iterable[, cmp[, key[, reverse]]])
参数说明：
iterable  ----> 可迭代对象。
cmp       ----> 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key        ----> 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse  ----> 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回值：
返回重新排序的列表。

# ===========一般用法：===========
# 1、简单排序
a = [5,7,6,3,4,1,2]
b = sorted(a)       # 使用sorted，保留原列表，不改变列表a的值
print(a)
[5, 7, 6, 3, 4, 1, 2]
print(b)
[1, 2, 3, 4, 5, 6, 7]

# ===========匿名函数用法：===========
L=[('b',2),('a',1),('c',3),('d',4)]
# 2、利用参数 cmp 排序
sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))
# 结果：
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
# 3、利用参数 key 排序
sorted(L, key=lambda x:x[1])
# 结果：
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

# 4、按年龄升序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2])
# 结果：
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
# 5、按年龄降序
sorted(students, key=lambda s: s[2], reverse=True)
# 结果：
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]


a = [4,5,6,2,1,9]
print(sorted(a))  #[1, 2, 4, 5, 6, 9]
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students, key=lambda s: s[2])) #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

3. filter() 函数：
描述：
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
语法：
filter(function, iterable)
参数：
function ----> 判断函数。
iterable  ----> 可迭代对象。
返回值：
Pyhton2.7 返回列表，Python3.x 返回迭代器对象，具体内容可以查看：Python3 filter() 函数

实例：

# ===========一般用法：===========
# 1、过滤出列表中的所有奇数
def is_odd(n):
	return n % 2 == 1
		 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist))
# 结果： [1, 3, 5, 7, 9]

# ===========匿名函数用法：===========
# 2、将列表[1, 2, 3]中能够被3整除的元素过滤出来
newlist = filter(lambda x: x % 3 == 0, [1, 2, 3])
print(list(newlist))
# 结果： [3]


# 过滤数据
def is_odd(n):
  return n % 2 ==1

newlist = filter(is_odd,[1,2,34,4,5,6,7])
print(newlist)
newlist = filter(lambda x:x%3 == 0,[1,2,3])
print(newlist)  #数组
print(list(newlist))  #数组转列表

# 结果：
# <filter object at 0x0000023EDB65AC50>
# <filter object at 0x0000023EDB65ACF8>
# [3]