常用函数-filter、map、reduce、sorted

常用函数

• filter
• map
• reduce
• sorted和列表自带sort
• 待续。。。

一、filter函数

1.说明

　　filter()函数接收一个函数 f 和一个可迭代对象，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的filter对象（一个迭代器）。

filter(...)
    filter(function or None, sequence) -> list, tuple, or string

2.使用

（1）返回列表中所有基数

################### 方式一 ###################
# 函数，返回True/False
def is_odd(x):
    return x % 2 == 1

# 可迭代对象
l = [1, 4, 6, 7, 9, 12, 17]

print(list(filter(is_odd,l)))  # l中的元素逐个导入is_odd进行T/F判断
# [1, 7, 9, 17]

################### 方式二 lambda函数 ###################
l = [1, 4, 6, 7, 9, 12, 17]
print(list(filter(lambda x:x%2==1,l)))
# [1, 7, 9, 17]

################### 方式三 ###################
# 等价于
new_l = []
for item in l:
    if is_odd(item):
        new_l.append(item)
print(new_l)
# [1, 7, 9, 17]

（2）删除 None 或者空字符串

################### 方式一 ###################
# 函数，返回True/False
def is_not_empty(s):
    return s and len(s.strip()) > 0

# 可迭代对象
l = ['test', None, '', 'str', '  ', 'END']

print(list(filter(is_not_empty,l)))  # l中的元素逐个导入is_not_empty进行T/F判断
# ['test', 'str', 'END']

################### 方式二 ###################
l = ['test', None, '', 'str', '  ', 'END']
print(list(filter(lambda x:x and len(x.strip()) > 0,l)))
# ['test', 'str', 'END']

################### 方式三 ###################
# 等价于
def is_not_empty(s):
    return s and len(s.strip()) > 0

l =  ['test', None, '', 'str', '  ', 'END']
new_l = []
for item in l:
    if is_not_empty(item):
        new_l.append(item)
print(new_l)
# ['test', 'str', 'END']

二、map函数

1.说明

　　Python中的map函数应用于每一个可迭代的项，返回的是一个结果迭代器。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为map对象返回。

map(...)
    map(function, sequence[, sequence, ...]) -> list

2.使用

(1).把列表中数字转换为其平方

# 把列表中数字转换为其平方
################### 方式一 ###################
l = [1,2,3,4,5,6,7,8]
def pow(x):
    return x ** 2

print(list(map(pow,l)))
# [1, 4, 9, 16, 25, 36, 49, 64]

################### 方式二 lambda函数 ###################
l = [1,2,3,4,5,6,7,8]
print(list(map(lambda x: x ** 2, l)))
# [1, 4, 9, 16, 25, 36, 49, 64]

################### 方式三 ###################
l = [1,2,3,4,5,6,7,8]
new_l = []
for item in l:
    new_l.append(item ** 2)
print(new_l)
# [1, 4, 9, 16, 25, 36, 49, 64]

(2).多个列表转换

l1 = [1,2,3,4,5,6,7]       # 7 个元素
l2 = [2,3,4,5,6,7]         # 6 个元素
l3 = [100,100,100,100]     # 4 个元素

print(list(map(lambda x,y,z:x**2 + y + z,l1,l2,l3)))
# [103, 107, 113, 121] # 按最少个数

三、reduce函数

1.说明

　　对sequence中的item顺序迭代调用function，函数必须要有2个参数。要是有第3个参数，则表示初始值，可以继续调用初始值，返回一个值。

reduce(...)
    reduce(function, sequence[, initial]) -> value

2.使用

（1）求list的和

# 求list的和
################### 方式一 ###################
from functools import reduce
def mysum(x,y):
    return x+y

print(reduce(mysum,range(1,11)))
# 55（注：1+2+3+4+5+6+7+8+9+10）
print(reduce(mysum,range(1,11),100))
# 155（注：100+1+2+3+4+5+6+7+8+9+10）

################### 方式二 lambda ###################
print(reduce(lambda x,y:x+y,range(1,11)))
# 55（注：1+2+3+4+5+6+7+8+9+10）
print(reduce(lambda x,y:x+y,range(1,11),100))
# 155（注：100+1+2+3+4+5+6+7+8+9+10）
# 100是初始值

print(reduce(lambda x,y:x+y,["a","b","c"],"z"))  # zabc  "z"是初始值

################### 方式三 lambda ###################
print(sum(range(1,11)))
#

# 或for循环逐个相加
# 略

四、sorted函数和list自带的sort

1.说明

2.使用

（1）列表排序

# 需要一个排序好的副本，同时保持原有列表不变，怎么实现呢？
################### 方式一 sort ###################
l1 = [4, 6, 2, 1, 7, 9]
l2 = l1[:]
l2.sort()
print(l1)
# [4, 6, 2, 1, 7, 9]
print(l2)
# [1, 2, 4, 6, 7, 9]

################### 方式二 sorted ###################
# sorted函数返回的是list
l1 = [4, 6, 2, 1, 7, 9]
l2 = sorted(l1)  # l1不受影响
print(l1)
# [4, 6, 2, 1, 7, 9]
print(l2)
# [1, 2, 4, 6, 7, 9]

(2).无视大小写排序，借助map函数

l1=['This','is','a','Boy','!']
l2 = sorted(map(lambda x:x.lower(),l1))
print(l1)
# ['This', 'is', 'a', 'Boy', '!']
print(l2)
# ['!', 'a', 'boy', 'is', 'this']

(3).reverse=True，revered函数

True为倒序排列，False为正序排列

################### 方式一 sort ###################
l1 = ['mmm', 'mm', 'mm', 'm' ]
l2 = l1[:]
l1.sort()
print(l1)
# ['m', 'mm', 'mm', 'mmm']
l2.sort(reverse=True)
print(l2)
# ['mmm', 'mm', 'mm', 'm']

################### 方式二 sorted ###################
l1 = ['mmm', 'mm', 'mm', 'm' ]
print(sorted(l1))
# ['m', 'mm', 'mm', 'mmm']
print(sorted(l1,reverse=True))
# ['mmm', 'mm', 'mm', 'm']

################### 方式三 reversed ###################
l1 = ['mmm', 'mm', 'mm', 'm' ]
print(list(reversed(l1)))
# ['m', 'mm', 'mm', 'mmm']
print(l1)  # 对l1无影响
# ['mmm', 'mm', 'mm', 'm']

(4).key

类似于map，把迭代对象的元素逐个放到key对应的函数，返回一个值进行排序

# 列表按照其中每一个值的绝对值排序
l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)  # 方式一
print(l2)
# [1, -2, 3, -4, 5, -6]
l1.sort(key=abs)  # 方式二
print(l1)
# [1, -2, 3, -4, 5, -6]

# 列表按照每一个元素的len排序
l1 = [[1,2],[3,4,5,6],(7,),'']
l2 = sorted(l1,key=len)
print(l2)
# [(7,), [1, 2], '123', [3, 4, 5, 6]]
l1.sort(key=len)
print(l1)
# [(7,), [1, 2], '123', [3, 4, 5, 6]]

#将列表中的每个元素变为小写，再按每个元素中的每个字母的ascii码从小到大排序
l1 = ['CCC', 'bb', 'ffff', 'z']
l2 = sorted(l1,key = str.lower )
print(l2)
# ['bb', 'CCC', 'ffff', 'z']
l1.sort(key = str.lower)
print(l1)
# ['bb', 'CCC', 'ffff', 'z']

#自定义函数排序,lastchar为函数名，这个函数返回列表e中每个元素的最后一个字母
def lastchar(s):
    return s[-1]
l1 = ['abc','b','AAz','ef']
l2 = sorted(l1,key=lastchar)
print(l2)
# ['b', 'abc', 'ef', 'AAz']
l1.sort(key=lastchar)
print(l1)
# ['b', 'abc', 'ef', 'AAz']

#自定义函数按列表f中字典的age从小到大排序
l1 = [{'name':'abc','age':20},{'name':'def','age':30},{'name':'ghi','age':25}]
def age(s):
    return s['age']
# 方式一
l2 = sorted(l1,key = age)
print(l2)
# [{'name': 'abc', 'age': 20}, {'name': 'ghi', 'age': 25}, {'name': 'def', 'age': 30}]
# 方式二
l3 = sorted(l1,key = lambda x:x['age'])
print(l3)
# [{'name': 'abc', 'age': 20}, {'name': 'ghi', 'age': 25}, {'name': 'def', 'age': 30}]
# 方式三
l1.sort(key=age)
print(l1)