函数进阶

一、匿名函数

　　匿名函数顾名思义就是没有名字的函数，比如如下：

def add(x,y):
    return x+y

print(add(1,2))

　　这时需要定义函数，匿名函数就不用定义函数，直接使用关键字lambda来创建：

lambda x,y:x+y

　　关键字lambda表示匿名函数，冒号前面的x，y表示函数参数；x+y表示返回的结果。

　　如何调用匿名函数呢？可以将匿名函数赋值，然后调用：

func=lambda x,y:x+y

print(func)#<function <lambda> at 0x0000000000DD4730>
#进行调用
print(func(1,2))

　　同样可以将匿名函数作为返回值返回，例如：

def add(x,y):
    return lambda:x+y

print(add(1,2)())#3

二、内置函数

 

1、abs 

#函数返回数字的绝对值。
print(abs(-45))#45

2、all

#函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。
print(all(['a', 'b', 'c', 'd']))  # True 

3、any

#any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。
print(any(['a', 'b', 'c', 'd']))#True

5、map

　　根据提供的函数对指定序列做映射，第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

def add(x,y):
    return x+y

res=map(add,[1,2,3],[4,5,6]) #得到的是map的可迭代对象
for i in res:
    print(i)#5,7,9

　　另外简便一些的直接使用lambda表达式：

res=map(lambda x,y:x+y,[1,2,3],[4,5,6]) #得到的是map的可迭代对象
for i in res:
    print(i)#5,7,9

6、reduce

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

reduce() 函数语法：

reduce(function, iterable[, initializer])

• function -- 函数，有两个参数
• iterable -- 可迭代对象
• initializer -- 可选，初始参数

from functools import reduce
res=reduce(lambda x, y: x + y, [1, 2, 3, 4, 5],10)
print(res)#25

array=[1,2,3,4]

def func(array,initial=None):
    sum=0
    if initial:
        sum += initial
    for i,j in enumerate(array):
        sum+=j
    return sum

def reduce_test(func,array,initial=None):
    return func(array,initial)
res=reduce_test(func,array,20)
print(res)#30

7、filter

　　函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

　　接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

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])

print(newlist) #<filter object at 0x00000000006B7860>

def func(arrey):
    list=[]
    for i in arrey:
        if i%2 == 1:
            list.append(i)
    return list

def filter_test(func,arrey):
    return func(arrey)

print(filter_test(func,[1,2,3,4,5,6]))#[1, 3, 5]

8、zip

　　用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

　　如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

user_info={"name":"bright","age":27,"city":"西安"}

res=zip(user_info.keys(),user_info.values())
print(list(res))#[('age', 27), ('city', '西安'), ('name', 'bright')]

详情查看：https://www.runoob.com/python/python-built-in-functions.html

三、其它

1、三元表达式

x=2
res="条件成立" if x>1 else "条件失败"

print(res)#条件成立
# if x>1 为一元
# "条件成立" 为第二元
# else "条件失败" 为第三元


# 用于函数中


def func():
    x=2
    # if x>1:
    #     return "条件成立"
    # else:
    #     return "条件失败"

    return "条件成立" if x>1 else "条件失败"

2、列表解析式

 一般普通方式生成列表的方法如下：

list=[]
for i in range(10):
    list.append(i)
print(list)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

但是，如果想要简洁，可以使用列表生成式：

res=[ i for i in range(10)]
print(res)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

列表生成式中可以加入判断：

#加入一个判断
res=[ i for i in range(10) if i>5]
print(res)#[6, 7, 8, 9]

#加入多个判断
res=[ i for i in range(10) if i>5 and i<8]

列表生成式加入多重循环：

# #加入多个循环
res= [i + j for i in 'ABC' for j in 'XYZ']
print(res)#['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

3、列表生成式

比起列表解析式，列表生成式会更加节约内存。

列表生成式只需要将列表解析式换种写法即可，将[]变成()。

res=(i for i in range(10))
print(res)#<generator object <genexpr> at 0x0000000000D96CA8>

可以看到打印出来的是generator对象，那么应该如何取值呢？

res=(i for i in range(10))
print(next(res))#0
print(next(res))#1
...

这里使用next()方法进行输出，next()方法的本质就是调用__next()__方法

res.__next__()

但是不能每次这样取值吧，一般使用for循环进行取值，因为生成器也是一个可迭代的对象。

res=(i for i in range(10))

for i in res:
    print(i)