python 高阶函数

1、map( ):接受两个参数：一个是函数，一个是可迭代对象。map将传入的函数依次作用到序列的每个元素。用 list 输出 map 函数产生的值。

r = map(str,[1,2,3,4])
print(list(r))

2、reduce(): reduce把一个函数 f 作用在一个序列[x1, x2, x3, ...]上，这个函数 f 必须接收两个参数. reduce把结果继续和序列的下一个元素做累积计算  ：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

from functools import reduce
"""创建一个reduce函数的作用对象：函数 f ,且接受两个参数"""
def f(x,y):
    return x*y

l=[1,2,3]
""" reduce()接收一个函数f 和一个可迭代对象"""
print(reduce(f,l))

3、字符串转数字。

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}
"""s 是一个字符串"""
def str2int(s):
"""创建reduce()函数作用对象"""
    def fn(x, y):
        return x * 10 + y
    """创建map函数作用对象"""
    def char2num(s):
        return DIGITS[s]
    """map函数将char2num函数作用于字符串s的每一个元素，最终返回digitals的vlue。
       reduce函数将 fn 函数作用于value"""

    return reduce(fn, map(char2num, s))

print(str2int("1357"))

 4、字符串转小数。

 from functools import reduce

dict={'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def str2float(s):
    n = s.index(".")
    s1 = s[:n]
    s2 = s[n+1:]
    n = len(s2)

    def char2num(s):
        return dict[s]

    def f(x,y):
        return x*10+y

    return reduce(f,map(char2num,s1))+reduce(f,map(char2num,s2))/10**n
    
   
print(str2float("123.456"))

3、filter():接受一个函数和一个序列，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素.同样用list取filter的值。

"""筛选回文数"""
def is_palindrome(n):
    if str(n)==str(n)[::-1]:
        return n

print(list(filter(is_palindrome,range(1000))))

"""所有的素数除了2以外都是奇数，所以从3开始在奇数里面筛选素数，
   筛选出来的数加上2就可以得到所有素数。筛选条件：不能被其他奇数整除"""

#定义一个从3开始的奇数序列.用生成器 f()保存。
def f():
    n = 1
    while True:
        if n%2==1:
            n +=2
            yield n

            
#定义一个筛选条件：不能被其他奇数整数
def g(n):
    return lambda x: x%n !=0


#定义一个生成器 primes()
def primes():
    yield 2 #primes()生成器第一个元素2
    
    it = f()#生成器f()赋予一个变量it,it继承了f()从3开始的奇数序列。
    
    while True:#一下步骤依次重复执行
        n = next(it)#提取从3开始的奇数序列的元素
        yield n #用生成器保存
        it = filter(g(n),it)#按照既定条件过滤，过滤之后重复执行提取、保存这两步骤。


for n in primes():
    if n < 20:
        print(n)
    else:
        break

　4 、sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序。sorted(L, key=f)：L是一个序列，f 代表一个函数。key函数作用于序列L的每一个元素。

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

#该函数接受一个元组作参数，返回元组第一个元素的首字母
def by_name(t):
    return t[0][0]

def by_score(t):
    return t[1]

#按照姓名首字母排序
L1 = sorted(L,key = by_name)
print(L1)
#按照成绩排序
L2 = sorted(L,key = by_score)
print(L2)

 5、lambda: lambda表示匿名函数,只能有一个表达式，不用写return，返回值就是该表达式的结果

def f(x):
return x**x
print(f(5))

"""等价于"""
f = lambda x: x**x
print(f(5))

"""
def add(n):
    return lambda x: x+n

x = add(2)
print(x(4))
"""

def add(n):
    def g(x):
        return x+n
    return g


g = add(2)
print(g(4))

6、不带参数的装饰器。

import functools, time

#定义装饰器名称:log
def log(func):
    
    #固定写法，作用是固定装饰器后续函数now()的名称
    @functools.wraps(func)
    
    #固定写法：*args,**kw这两个参数使得wrapper可接受任何参数
    def wrapper(*args, **kw):
        print("start_time:", time.ctime())#该语句写在res之前，即在now函数调用前输出
        res = func(*args, **kw)#固定写法
        print("end_time:", time.ctime())#该语句写在res之后，即在now函数调用后输出
    #固定写法
        return res#固定写法
    return wrapper


#不带参数的装饰器
@log
def now():
    time.sleep(1)
    print("test")


now()

7、带参数的装饰器。

import functools, time

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print("%s %s():" %(text,func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator


#带参数的装饰器
@log("hello")
def now():
    print("hello world", time.ctime())


now()

 zip( [可迭代对象] )

a = [1,2,3]
b = [4,5]
print(list(zip(a,b)))
"""output:[(1, 4), (2, 5)]#元素序列与最短的列表一致
"""

strs = ['flower','flow','flight']
for str in zip(*strs):
    print(str)
    print(str[0])
    print(set(str))
"""
('f', 'f', 'f')
f
{'f'}
('l', 'l', 'l')
l
{'l'}
('o', 'o', 'i')
o
{'o', 'i'}
('w', 'w', 'g')
w
{'w', 'g'}
"""

 最长公共前缀：输入: ["flower","flow","flight"]   输出: "fl"；输入: ["dog","racecar","car"]   输出: " "  ；解释: 输入不存在公共前缀。

def longestCommonPrefix(strs):
    res = ""
    for str in zip(*strs):
        if len(set(str))==1:
            res = res+str[0]
        else:
             break
    return res   
        

8、排序指南：operator模块。student =  [("dave",78),("jojo",78),("tom",60)]. 对student先按照成绩由低到高排序，如果成绩相同，就按照姓名排序。

from operator import itemgetter
def f(student):
    res = sorted(student,key=itemgetter(1,0))
    return res

student =  [("dave",78),("jojo",78),("tom",60)]
print(f(student))

from operator import itemgetter
data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
data = sorted(data,key=itemgetter(0))
print(data)
"""
output:[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]

student = [('dave','B',10),('john','A',15),('jane','B',12)] 对年龄先按照升序排列，然后再对等级降序排列

from operator import itemgetter

student = [('dave','B',10),('john','A',15),('jane','B',12)]
s = sorted(student,key=itemgetter(2))
s = sorted(s,key=itemgetter(1),reverse=True)
print(s)
"""
output:[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
"""