Python — 函数进阶(1)

在Python这个编程语言中，最为明显的两大分水岭就是函数和类
而今天则继续介绍一下函数进阶内容
今天将会介绍的就是匿名函数（lambda）、过滤器（filter）、映射（map）、以及压缩（zip）。

函数进阶(1)

lambda表达式

lambda表达式的定义

在编写程序的过程中我们总是会遇到一些小功能（比如说将符合某些条件的数据筛选出来），
这时候就该轮到我们纠结了，是为了提高复用性写一个函数呢？还是直接硬写下去呢？
而这时候就该轮到lambda表达式登场了。

lambda表达式
使用方法：lambda x : x % 2 == 0
lambda表达式省去了命名的过程，同时也能够接收参数x，定义一个返回值x % 2 == 0
这就直接省去了咱们命名困难的问题，而且整体编写风格也十分简洁

lambda表达式的使用

接下来就是详细的使用教程，
首先需要说明的就是基础使用方法

lambda x : x ** 2
<function <lambda> at 0x000001C2BADB3E20>
# 因为没有变量接受lambda表达式，所以只能得到一个关于函数的内存地址
'''
在Python中给函数定义的过程其实发生了三件事情
1）定义一个函数名的名字
2）在内存空间中创建处对应的函数体
3）将函数名与内存空间相互绑定（后续就可以直接用函数名完成对函数的定义）
'''

'接下里使用一个变量接收lambda表达式，让我们可以长期使用它'
g = lambda x,y : x**y
print(g(3,2))		# 9

g = lambda x : len(x)
g([1,3,5,7,9])		# 5

filter函数

filter函数的参数和返回值

接下来我们将要讲解的是filter函数，俗称过滤器

filter(func or None, iterator)
参数：
1）对于过滤器来说，第一个参数可以是一个函数，或者也可以填写一个None用于表示不需要函数
2）第二个参数接受的是可迭代对象，对于可迭代对象的讲解我们放在下一章的函数进阶中讲解，目前我们只需要记住，所有序列都是可迭代对象；
返回值：
1）当我们没有填写函数时，过滤器函数将会把可迭代对象中、布尔值为真的值全都挑选出来，并且给我们一个过滤器对象；
2）当我们填写函数后，过滤器就会依次将可迭代对象中的值放入函数中，将满足条件的值全都挑选出来，并且给我们一个过滤器对象；

filter函数的使用方式

接下来就要讲解关于filter函数的使用

list_1 = [1,2,3,4,5,6,7,8,9]
def odd(num):
	if num%2:
		return num
fo = filter(odd,list_1)
print(fo)			# <filter object at 0x000001561B575B10> 恭喜我们得到一个过滤器对象

filter object —— 过滤器对象
啥是过滤器对象？
我们来求助一下Python，让她告诉我们filter函数返回的东西到底是怎么样的

过滤器对象，啥事过滤器对象？
我们来求助一下Python，让她告诉我们filter函数返回的东西到底是怎么样的

help(filter)

'''
Help on class filter in module builtins:

class filter(object)
 |  filter(function or None, iterable) --> filter object
 |	
 |  重点关注以下信息：
 |  Return an iterator yielding those items of iterable for which function(item)
 |  is true. If function is None, return the items that are true.
'''

在有函数的情况下，返回一个迭代器，而这个迭代器将生产经过函数运算后返回值为真的可迭代对象；
当函数是None的时候，将会把传入的可迭代对象中的真值筛选出来。
这因为具有筛选的属性，filter()函数才会被称作是过滤器。

这下我们知道了，虽然叫做filter object但其实还是一个迭代器，
我们只需要使用list()就能够完成对其的转化了，当然使用set()、tuple()也是可以的，
因此让我们改进一下代码；

list_1 = [1,2,3,4,5,6,7,8,9]
def odd(num):
	if num%2:
		return num
fo = list(filter(odd,list_1))		# 将filter函数返回的可迭代对象转化为列表
print(fo)							# [1,3,5,7,9]

现在再看看我们的成果，这样真的是最简单的形式吗？
很显然，
并不是的，因为对于像odd这样的简单函数，我们写了三行只能算是技术不过关，
而需要改进的话完全可以使用lambda表达式进行优化，
鱼就是这样才能摸起来的；

list_1 = [1,2,3,4,5,6,7,8,9]
fo = list(filter(lambda x:x%2, list_1))
print(fo)							# [1,3,5,7,9]， 因为所有 偶数%2 得到的值都是0，而0的布尔值是False

# 为了追求极致的同学就可以这样写了		
print(list(filter(lambda x:X%2, [1,2,3,4,5,6,7,8,9])))

接下来就让我们看看更多的使用案例，

list_1 = [1,3,5,{},7,9,'']
fo = list(filter(None,list_1))
print(fo)						# [1,3,5,7,9]

list_1 = [1,3,5,7,9]			# 更改一下list_1， 因为接下里的运算操作只能够支持int、float类型的数据 
fo = list(filter(lambda x : x%2==0 , list_1))
print(fo)						# [] , list_1列表中没有任何元素满足 x%2==0 这个条件

fo = list(filter(lambda x : x*2 , list_1))
print(fo)						# [1,3,5,7,9], list_1列表中的任何元素在执行了 x*2后都是真值

map函数

map函数的参数与返回值

接下来需要介绍的就是map函数的使用方式，filter函数和map函数的使用方式极其相似

map(func,*iterable)
参数：
1）与filter函数不同的地方就在第一个参数是必须填写的，也就是说我们在使用map函数进行映射的
时候必须要传入一个函数；
2）第二个参数与filter函数不同之处就在于可以传入多个可迭代对象，究其原因是因为过滤器是为了筛选，
而map则是为了映射，两者的目的就不相同；
返回值：
1）在参数传入之后，将会返回一个映射对象，而这个映射对象包含着可迭代对象中所有元素经过函数运算后
结果。

map函数的使用方式

老规矩，让Python她自己告诉我们，map函数究竟是个什么鬼

help(map)

'''
class map(object)
 |  map(func, *iterables) --> map object
 |  
 |  Make an iterator that computes the function using arguments from
 |  each of the iterables.  Stops when the shortest iterable is exhausted.
'''

将每个可迭代对象中的元素经过函数计算后生成一个迭代器；
当任意一个传入的可迭代对象元素耗尽就会停止计算。

哦，原来什么映射对象、过滤器对象都是一个样啊，本质其实都是迭代器，
那么既然是迭代器，我们还是老规矩，使用list()、set()、tuple()就行了。

# 先来看看传入两个数量不对等的可迭代序列会返回什么
list_1 = [1,2,3,4]
list_2 = [1,2,3]
mo = list(map(lambda x,y: x**y , list_1, list_2))
print(mo)					# [1, 4, 27], 可见计算规则是这样的 1**1 , 2**2 , 3**3 当list_2中的元素耗尽则停止计算

# 让我们继续看看 x,y 这两个参数是如何确定的,也就是顺序问题
list_1 = [2,3,4]
list_2 = [2,2,2]
mo = list(map(lambda x,y: x**y , list_1, list_2))
print(mo)					# [4, 9, 16], 可见list_1被当做是参数x传入，而list_2被当做是y传入，顺序的一一对应

# 接下来继续实验一下，当lambda表达式中需要一个参数，但是传入了两个可迭代对象会发生什么
list_1 = [2,3,4]
list_2 = [2,2,2]
mo = list(map(lambda x:x**2 , list_1, list_2))
print(mo)					# TypeError: <lambda>() takes 1 positional argument but 2 were given

由此可知，参数的数量一切都要以函数所需要的数量为准。

以上就是关于map函数的使用事项。

zip函数的使用

zip函数的参数和返回值

zip函数其实是与解压赋值这一操作相对立的，
解压复制是一次性完成多变量赋值的操作，
类似于这样；

def test():
	return True,'读者老爷们给咱们点个赞啊'
flag, msg = test()
print(flag,msg)				# True, '读者老爷们给咱们点个赞啊'

而zip函数则是可以将多个可迭代对象中的值依次组合在一起；
而所需要的参数、返回值如下：

zip(*iterables, strict=Flase)
参数：
1）需要数量任意的可迭代序列；
2）strict是默认参数，默认值是False，而把strict的参数更改为True后，并且传入多个
可迭代序列的时候，只要任意一个可迭代序列提前耗尽就会报错ValueError。
返回值：
1）压缩对象，一个迭代器

zip函数的使用方式

从上文中我们已经知道了，zip函数的参数和返回值是如何，
那么先把需要测试的问题给理清楚：

1）当传入可迭代对象只有一个的时候会怎么样？
2）当传入的可迭代对象为多个并且长度不一的时候，strict=False，结果会如何？

先是老规矩，让Python她自己告诉我们zip函数该如何使用；

help(zip)

'''
class zip(object)
 |  zip(*iterables, strict=False) --> Yield tuples until an input is exhausted.
 |  
 |     >>> list(zip('abcdefg', range(3), range(4)))
 |     [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
 |  
 |  The zip object yields n-length tuples, where n is the number of iterables
 |  passed as positional arguments to zip().  The i-th element in every tuple
 |  comes from the i-th iterable argument to zip().  This continues until the
 |  shortest argument is exhausted.
 |  
 |  If strict is true and one of the arguments is exhausted before the others,
 |  raise a ValueError.
'''

压缩对象将会产生长度为n的元组，n的长度取决于传入的可迭代对象数量究竟有多少。
每个元组中第i个元素就是来自于传递给每个可迭代参数的第i个。
并且这个运算过程将会持续到最短的参数消耗殆尽。
当默认参数strict填写为True，并且当任意一个参数在其他可迭代对象前消耗光，则
会给出ValueError的错误。

# 正常情况下zip函数的使用
list_1 = ['Kujo·Jotaro', 'Joseph·Jostar']
list_2 = ['star·paltinum', 'hermit·purple']
zo = list(zip(list_1,list_2))
print(zo)				# [('Kujo·Jotaro', 'star·paltinum'), ('Joseph·Jostar', 'hermit·purple')]

# 接下来测试一下，当传入可迭代对象只有一个的时候会怎么样
list_1 = ['Kujo·Jotaro', 'Joseph·Jostar']
zo = list(zip(list_1))
print(zo)				# [('Kujo·Jotaro',), ('Joseph·Jostar',)] , 能够正常使用，但其实已经失去了压缩的意义了

# 当传入的可迭代对象为多个并且长度不一的时候，strict=False，结果会如何？
list_1 = ['Kujo·Jotaro', 'Joseph·Jostar', "Dio· Don't lazy"]	# list_1的长度是3
list_2 = ['star·paltinum', 'hermit·purple']
zo = list(zip(list_1, list_2))
print(zo)				# [('Kujo·Jotaro', 'star·paltinum'), ('Joseph·Jostar', 'hermit·purple')] , Dio大人被删了！

以上就是关于zip()函数的使用，有可能诸位有一个疑惑
就是zip函数有啥用？
好吧，我再来演示一个zip函数的使用方式
将会运用到的就是dict()

list_1 = ['Kujo·Jotaro', 'Joseph·Jostar']
list_2 = ['star·paltinum', 'hermit·purple']
zo = zip(list_1, list_2)
JoJo = dict(zo)
print(JoJo)				# {'Kujo·Jotaro': 'star·paltinum', 'Joseph·Jostar': 'hermit·purple'} , 这就快速生成了一个字典！

# 使用到的知识其实就是十分基础的,dict()
# 让我再来展示一下dict()的使用细节吧！

dict_1 = dict(Joseph='Hermit·Purple', Jotaro='Star·Platinum')
print(dict_1)

tuple_1 = ('Jonasen','Jostar'),('Joseph','Jostar')
dict_2 = dict(tuple_1)
print(dict_2)

以上就是函数进阶(1)中的所有内容了，
感谢阅读