匿名函数及内置函数

1 匿名函数

python 使用 lambda 来创建匿名函数
语法：lambda [arg1 [,arg2,.....argn]]:expression
lambda 只是一个表达式，函数体比 def 简单很多。 
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。 
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。 
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。 
# 可写函数说明
#创建一个lambda表达式，并把它赋值给一个变量以便于调用
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))

print ("相加后的值为 : ", sum( 20, 20 ))

输出结果为： 

相加后的值为 : 30 

相加后的值为 : 40

2 三个重要的大数据用到的函数：

python map()

map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
举例说明：

list1=[1,2,3,4,5,6]#对list1中的每个元素进行+1的操作，还可以把lambda函数换成更复杂的函数
list2=list(map(lambda x:x+1,list1))
print(list2)

以上实例输出结果为： 
[2, 3, 4, 5, 6, 7] 

python filter（）函数

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的迭代器对象。 
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新对象中。 
基本语法为：filter(function, iterable) 

同样的：function – 判断函数。 iterable – 可迭代对象。 

举例说明：

def is_odd(n):    return n % 2 == 1 
newlist = filter(lambda x:x%2=1, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
newlist=list(newlist)
print(newlist)
输出结果：

[1, 3, 5, 7, 9] 

要注意： map（）函数返回的是一个迭代器（对象），所以并不能直接打印输出一个列表，需要把这个迭代器对象转换成列表才可以打印输出。

python reduce（）函数

reduce() 函数会对参数序列中元素进行累积。 
基本语法为：reduce(function, iterable) 

其中：function – 函数，有两个参数 。iterable – 可迭代对象 

python中的reduce内建函数是一个二元操作函数，他用来将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 function（必须是一个二元操作函数）先对集合中的第1，2个数据进行操作，得到的结果再与第三个数据用func()函数运算，最后得到一个结果。

reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：
reduce(f, [1, 3, 5, 7, 9], 100)
结果将变为125，因为第一轮计算是：
计算初始值和第一个元素：f(100, 1)，结果为101。

举例说明：

form functools import reduce
# 两数相加
def add(x, y) :            
    return x + y
# 计算列表和：1+2+3+4+5
print(reduce(add, [1,2,3,4,5])) 
#也可以使用lambda函数来进行操作,一下是进行7-3-2的操作
print(reduce(lambda x,y:x-y,[7,3,2]))  

输出结果为：15和 2 

3 python中的sorted（）函数与.sort（）方法

sort（）函数 

基本语法为：list.sort(cmp=None, key=None, reverse=False) 
cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。 
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

#先定义一个列表，内部元素无序排列
aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
aList.sort()
print ( "List : ", aList)
输出结果为：List : ['Facebook', 'Google', 'Runoob', 'Taobao'] 
在来看一个例子：
list=["delphi","Delphi","python","Python","c++","C++","c","C","golang","Golang"]  
list.sort(key=lambda ele:len(ele)) #按元素长度顺序升序排列  
print("升序:",list)  
list.sort(key=lambda ele:len(ele),reverse=True) #按降序排列  
print("降序:",list)
#借助于 lambda 表达式，计算 list 列表中的元素的长度，根据元素的长度进行排序。 
排序的结果： 
升序: ['c', 'C', 'c++', 'C++', 'delphi', 'Delphi', 'python', 'Python', 'golang', 'Golang'] 
降序: ['delphi', 'Delphi', 'python', 'Python', 'golang', 'Golang', 'c++', 'C++', 'c', 'C']

sorted（）函数 

sorted() 函数对所有可迭代的对象进行排序操作。 
基本语法为：sorted(iterable, key=None, reverse=False) 
iterable – 可迭代对象。 
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。 
list1 = [5, 0, 6, 1, 2, 7, 3, 4]
#利用key进行倒序排序
list2 = sorted(list1, key=lambda x: x*-1)
print(list2)
输出结果为:[7, 6, 5, 4, 3, 2, 1, 0] 
也可以用reverse来进行倒序排序：
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
print(sorted(example_list, reverse=True))
输出结果也是：[7, 6, 5, 4, 3, 2, 1, 0] 
还可以这么用：
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students, key=lambda s: s[2]))            # 按年龄排序
列表里的每一个元组都是一个元素，key=lambda s: s[2]就是按照每个元素索引值为2的那个值进行排序，也就是年龄。lambda还可以换成其他的自定义函数。 
输出结果为：[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
sort 与 sorted 区别： 
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

4 函数的调用与引用的区别

在python中，函数的调用需要在函数名后面加（）,而函数的引用就不需要加括号。 
在调用函数的时候，需要按照定义函数时的参数设置进行传参
#定义一个tset1函数
def tset1(a,b,func):
    print(func(a,b))
def test2(c,d):
    return c+d
#调用test1函数，对应的将5的引用传递给a，6的引用传递给b，将tese2的引用传递给func
tset1(5,6,test2)
#因为test2的引用指向的是一个函数体，所以func也指向了这个函数体。
输出结果为：11