| 学习爬虫技术期间，再一次接触了python的匿名函数，及全局函数max()、min()、sorted()、map()、reduce()、filter()、zip()，以前用这些全局函数时觉得没什么，具体到用，发现挺不简单的，熟悉这些用法，可以少写很多代码。
一、匿名函数：
刚刚接触python时，看完黑马大本营的基础教程，原以为python没有匿名函数，现在才知道，python也有匿名函数，不过在python中称lambda表达式，格式如：
lambda x , y : x+y # 传参x、y，返回x+y
f=lambda x,n:x ** n
print(f(2,3))
# 匿名函数的参数规则、作用域关系与普通函数是一样的
# 匿名函数的函数体通常应该是 一个表达式，该表达式必须要有一个返回值
二、几个全局函数 小结下几个全局函数的用法
1、max()、min() 求最大值最小值函数
a、可求解元组、列表、字典等可迭代对象的最大值，如 max(10,
30, 25) # 可理解为元组对象，返回30 max(
[10, 30, 25] ) # 返回列表中的最大值30 salaries={ 'egon':3000, 'alex':100000000, 'wupeiqi':10000, 'yuanhao':2000 } max(salaries) # 返回字典键的最大值yuanhao，没意义，注意传入字典只能返回键key 2、可传入key=fn参数，fn为函数，改变求解方式 max函数执行时，遍历可迭代对象，如果没有指定处理函数，则取可迭代对象的元素项，进行最大值求解，字典对象取的是键；如果有指定处理函数，则将可迭代对象的元素项值传给处理函数，用处理函数的返回值进行求解！ max()，第一个参数可迭代对象、第二个参数key=func 例：max li=["10","8","20"] print(max(li))
# 返回8，字符串比较8最大 print(max(li,key=lambda x:int(x))) # 转整数再比较，返回20 例：求工资最高的人max # 可迭代对象为字典时，返回key salaries={ 'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000 } print( max(salaries, key=lambda x:salaries[x]) ) # 用处理函数返回值（字典value值）求解，返回相应键，返回alex # 等效用函数 # def get(k): # return salaries[k] 例：由字典组成的列表 # 注意传入列表，返回列表项 info = [ {'name':
'egon', 'age': '18', 'salary': '3000'}, {'name':
'wxx', 'age': '28', 'salary': '1000'}, {'name':
'lxx', 'age': '38', 'salary': '2000'} ] print( max(info, key=lambda dic: int(dic['salary']))) # {'name': 'egon', 'age': '18', 'salary': '3000'} 返回列表项 # 函数返回字典的salary的value值，等效用函数 # def fc(dic):
# return int(dic['salary'])
如果能理解上述max函数，接下来几个函数就好理解了，下面重点是函数本身的理解，至于min函数，同max函数，是求最小值的。
2、sorted() 函数
用来排序，第一个参数为可迭代对象，第二个参数key=func，接受一个函数，不修改原迭代对象，除非赋值
对字典排序，返回字典键的列表，如
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
result =sorted(salaries) # 默认按照字典的键排序，返回键的列表
print(result)
# result =sorted(salaries,key=lambda x:salaries[x]) # 按值排序，默认升序，返回key列表
result =sorted(salaries,key=lambda x:salaries[x],reverse=True) # 降序
print(result)
# 对列表排序，返回的还是列表
info=[
{'name':'egon','age':'18','salary':'3000'},
{'name':'wxx','age':'28','salary':'1000'},
{'name':'lxx','age':'38','salary':'2000'}
]
l=sorted(info,key=lambda dic:int(dic['salary'])) # 返回升序的字典列表
3、map() 函数
循环让每个元素执行函数，将结果保存到新列表（返回map生成器对象，可用list生成列表数据），第一个参数为执行的函数，第二个参数为可迭代元素
li = [11,22,33,44]
result = map(lambda x:x+100, li) # 第一个参数为执行的函数，第二个参数为可迭代元素.
print( list(result) ) # [111,122,133,144]
names=['alex','wupeiqi','yuanhao','egon']
res=map(lambda x:x+'_NB' if x == 'egon' else x + '_SB',names)
print(list(res))
4、reduce() 函数
对参数序列中元素进行累积
import functools
li = ['wo','hao','e']?
result = functools.reduce(lambda x,y:x+y, li)
print(result) # wohaoe
import functools
li=[1,2,3,4,5]
re=functools.reduce(lambda x,y:x*y,li)
print(re) # 120
5、filter() 函数
按条件筛选，满足条件，即True时选入，False则清除掉，返回生成器对象，可用list生成列表数据
result=filter( lambda x:x > 2,[1,2,3,4]) # 返回filter对象（生成器）
print(list(result))
# 筛选整数元素
li = [11,22,33,'asd',44,'xf']
?# 一般做法
def func(x):
if type(x) == int:
return True
return False
result = filter(func,li)
print(list(result)) # [11,22,33,44]
# 简化做法
result = filter(lambda x: True if type(x) == int else False ,li)
print(list(result))
?# 极简做法
result = filter(lambda x: type(x) == int ,li)
print(list(result))
names=['alex_sb','wxx_sb','yxx_sb','egon']
res=filter(lambda x:True if x.endswith('sb') else False,names)
res=filter(lambda x:x.endswith('sb'),names)
print(list(res)) #['alex_sb', 'wxx_sb', 'yxx_sb']
ages=[18,19,10,23,99,30]
res=filter(lambda n:n >= 30,ages)
print(list(res)) # [99, 30]
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
res=filter(lambda k:salaries[k] >= 10000,salaries)
print(list(res)) # ['alex', 'wupeiqi']
还有一个zip函数，可以按索引取多个可迭代对象的元素项，拼成新的可迭代对象，如zip（[1,2],[3,4]）,可生成[1,3] [2,4] 另外还有个遍历列表时用的enumerate函数，可返回列表的索引和列表项，如 for index, xx in enumerate(li): print(index, xx) 在特殊的场合有特别的用法。 写得有点长了，找机会再小结吧。
|
