Python学习笔记——map、reduce、filter、sort

笔记整理自廖雪峰官网和菜鸟教程

---

面向过程编程，把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务。
允许函数本身作为参数传入另一个函数，允许返回一个函数值。

高阶函数

函数与变量

• 变量可指向函数,函数本身可以赋值给变量

>>>abs(-10)
10
>>>f=abs
>>>f(-10)
10

• 函数名也是变量
  将函数名指向变量后将无法调用，重启python交互环境才可用
• 传入函数

def add(x, y, f):
    return f(x) + f(y)
 #x接收5，f接收abs函数，则f(x)实际为abs(-5)
 >>>print(add(-5,6,abs))
 11

map()

• 语法
  map(function, iterable, …)
  map()传入第一个参数function是函数对象，第二个参数是Iterable的对象，map将传入函数依次作用于第二参数的每个元素，将结果作为新的Iterator返回。
  python3中map返回的是迭代器iterator，需要用list来计算整个序列或者next()调用

>>> d=list(range(-3,3))
>>> r=map(abs,d)
#Iterator是惰性序列，通过list函数计算整个序列。
>>> list(r)
[3, 2, 1, 0, 1, 2]
>>> d
[-3, -2, -1, 0, 1, 2]

reduce函数

• 描述
  reduce() 函数在 python 2 是内置函数， 从python 3 开始移到了 functools 模块。from functools import reduce
  reduce的工作过程是 ：在迭代sequence(tuple ，list ，dictionary， string等可迭代物)的过程中，首先把 前两个元素传给 函数参数，函数加工后，然后把得到的结果和第三个元素作为两个参数传给函数参数， 函数加工后得到的结果又和第四个元素作为两个参数传给函数参数，依次类推。 如果传入了 initial 值， 那么首先传的就不是 sequence 的第一个和第二个元素，而是 initial值和 第一个元素。经过这样的累计计算之后合并序列到一个单一返回值
• 语法
  reduce(function, iterable[, initializer])
  function – 函数，有两个参数
  iterable – 可迭代对象
  initializer – 可选，初始参数

from functools import reduce
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))
#lambda函数简化
from functools import reduce
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def char2num(s):
    return DIGITS[s]
def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

• 字符串首字母大写其余小写

# capitalize
>>> L = ['toM', 'BAT', 'book', 'aNT']
>>> [s.capitalize() for s in L]
['Tom', 'Bat', 'Book', 'Ant']
#title
>>>list(map(lambda x:x.title(),L))
#切片
>>>[s[0].upper()+s[1:].lower() for s in L]

# -*- coding: utf-8 -*-
from functools import reduce
def str2float(s):
    n=s.index('.')   
    def fn(x,y):
        return x * 10 + y
    #def fx(x,y):
    #    return x+y/10
    l1=reduce(fn, map(int,[x for x in s[:n]]))
    l2=reduce(fn, map(int,[x for x in s[n+1:]]))
    return l1+l2/(10**len(s[n+1:]))

print('str2float(\'123.456\') =', str2float('123.456'))
if abs(str2float('123.456') - 123.456) < 0.00001:
    print('测试成功!')
else:
    print('测试失败!')

filter函数

• 描述
  filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
  filter返回iterator，要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
• 语法
  filter(function, iterable)
  function – 判断函数。
  iterable – 可迭代对象。
• 实例
  1、用filter移除空值

#filter移除空值
def not_empty(s):
    return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

strip()的用法：
strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。str.strip([chars])，如果chars是多个字符，那么将被拆分成单个字符从头尾去掉。

>>>a="aabcacb1111acbba"
>>>print(a.strip("abc"))
# 1111
>>>a="aabcacb1111acbba"print(a.strip("ab"))
#cacb1111ac
>>>a="aabc1acb1111acbba"print(a.strip("abc"))​
#1acb1111

2、利用filter生成素数序列

#从3开始的奇数序列生成器（无限序列）
def _odd_iter():
    n=1
    while True:
        n=n+2
        yield n
#筛选函数
def _not_divisible(n):
    return lambda x:x%n>0
#定义生成器不断返回下一个素数
def primes():
    yield 2#利用生成器先返回第一个素数2
    it=_odd_iter()
    while True:
        n=next(it)
        yield n #生成器用yield代替return
        it=filter(_not_divisible(n),it)
for n in primes():
    if n<100:
        print(n)
    else:
        break

3、用filter判断是否回文数

def is_palindrome(x):
    s=str(x)
    lenth=int(len(s)/2)
    i=1
    for ch in s[:lenth]:
        if(s[i-1]!=s[-i]):
            return False
        i=i+1
    return True      
 #https://blog.csdn.net/AliceGoToAnother/article/details/79069384 博主
def is_palindrome(n):
    return n == int(str(n)[::-1])#注意用-1来直接倒序生成序列
output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]:
    print('测试成功!')
else:
    print('测试失败!')

sort

• 描述
  sort()只能对已存在的list进行操作，无返回值。
  sorted()可对所有可迭代对象进行排序操作，返回一个新的list。
• 语法
  sorted(iterable, cmp=None, key=None, reverse=False)
  iterable – 可迭代对象。
  cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
  key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。对字符串排序，是按照ASCII的大小比较的，由于’Z’ < ‘a’，结果，大写字母Z会排在小写字母a的前面，可以利用key=str.lower来忽略大小写排序。
  reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
  list.sort(cmp=None, key=None, reverse=False)
• 实例
  对tuple排序

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
#按照名字顺序排序
def by_name(t):
    return(t[0])
L2 = sorted(L, key=by_name)
print(L2)
#按照成绩从高到底
def by_score(t):
    return -t[1]#如果不是负数，则调用时reverse=True来降序
L2 = sorted(L, key=by_score)
print(L2)