python-高阶函数;字符串的补充

1.高阶函数

变量可以指向函数，函数的参数可以接收变量，那么函数可以接收另一个函数作为参数，这种函数称为高阶函数

• 把函数作为实参
• 把函数作为返回值

（1）函数本身也可以赋值给变量 变量可以指向函数

print(abs(-11))         ##abs函数：求绝对值
f = abs
print(f(-10))

（2）传递的参数包含函数名

def fun(x,y,f):
    return f(x),f(y)
print(fun(-10,34,abs))

2.python内置高阶函数

（1）map函数

• map( )函数接收两个参数，一个是函数，一个是序列
• map将传入的函数依次作用到序列的每个元素，并且把结果作为新的序列返回

# 对于序列[-1,3,-4,-5]的每个元素求绝对值
print(list(map(abs,[-1,3,-4,-5])))

# 对于序列的每个元素求阶乘
def factoria(x):
    """对与x求阶乘"""
    res = 1
    for i in range(1,x+1):
        res = res * i
    return res

li = [random.randint(2,7) for i in range(10)]
print(list(map(factoria,li)))

（2）reduce函数

• 把一个函数作用在一个序列上，这个函数必须接收两个参数
• 把结果继续和序列的下一个元素做累积计算
  reduce(f,[x1,x2,x3,x4]) = f(f(f(x1,x2),x3),x4)
• python2:reduce为内置函数
  python3:from functools import reduce

from functools import reduce
def multi(x,y):                ##1*2*3*4
    return x*y
print(reduce(multi,range(1,4)))
def add(x,y):                   ##1+2+3+4+5
    return x+y
print(reduce(add,[1,2,3,4,5]))

（3）filter函数

• filter 过滤函数
• 和map()类似，filter()也接收一个函数和一个序列
• 但是和map()不同的是，filter()把传入的函数依次作用于每个 元素，然后根据返回值是True还是False决定保留还是丢弃该元素
• 只能有一个形参，函数的返回值只能是True或者False

# 取出偶数
def isodd(num):  
    if num %2==0:
        return True
    else:
        return False
print(list(filter(isodd,range(100))))

#1～100的素数
def fun(x):
    for i in range(2,x):
        if x%i==0 :
            return False
    return True
print(list(filter(fun,range(2,100))))

（4）sorted函数

• 排序函数，用key关键字排序
• 默认sort和sorted方法由小到大进行排序，reverse=True 由大到小进行排序

li = [1,2,4,6,3]
li.sort()      ##在原列表基础上排序
print(li)
a = sorted(li)        ##创建新列表放置排序后的元素
print(a)
a = sorted(li,reverse=True)        ##从大到小排序
print(a)

info = [
    # 商品名称 商品数量 商品价格
    ['apple1', 200, 32],
    ['apple4', 40, 12],
    ['apple3', 40, 2],
    ['apple2', 1000, 23]
]

# print(sorted(info))
# 按照商品数量进行排序
def sorted_by_count(x):
    return x[1]   

# 按照商品价格进行排序
def sorted_by_price(x):
    return x[2]

# 先按照商品数量由小到大进行排序，如果商品数量一致，则按照商品价格由小到大进行排序
def sorted_by_count_price(x):
    return x[1], x[2]


# key代表排序的关键字
# print(sorted(info,key=sorted_by_count))
# print(sorted(info,key=sorted_by_price))
print(sorted(info, key=sorted_by_count_price))

# 对于字典里面嵌套字典进行排序
d = {
    '003':{
        'name':'apple1',
        'count':100,
        'price':10
    },
    '002':{
        'name':'apple2',
        'count':200,
        'price':2
    }

}
print(d.items())        #[('key',{}),(),()]

# x:('003', {'name': 'apple1', 'count': 100, 'price': 10})
print(sorted(d.items(),key=lambda x:x[1]['count']))
print(sorted(d.items(),key=lambda x:x[1]['price']))

（5）lambda匿名函数

• 匿名函数的关键字为 lambda 冒号前面是形参 冒号后面是返回值
• 匿名函数一般不单独用，与高阶函数搭配使用

from functools import reduce

1.
def fun(*args, **kwargs):   ##返回元组，返回字典
     return args, kwargs
## 两种效果一样
print(lambda *args, **kwargs: (args, kwargs))

2.
def add(x, y):
     return x + y
print(add([1,2,3,4]))
## 两种效果一样
print(reduce(lambda x, y: x + y, [1, 2, 3, 4]))

3.
def mypow(x):
    return x ** 2
## 两种效果一样
print(list(map(lambda x:x**2,range(5))))

def is_odd(num):
     return num %2 ==0
## 两种效果一样
print(list(filter(lambda x:x%2==0,range(10))))

4.
info = [
    # 商品名称 商品数量 商品价格
    ('apple1', 200, 32),
    ('apple4', 40, 12),
    ('apple3', 40, 2),
    ('apple2', 1000, 23)
]

print(sorted(info))

# 按照商品数量进行排序
# print(sorted(info,key=lambda x:x[1]))

# 按照商品价格进行排序
# print(sorted(info,key=lambda x:x[2]))
# print(sorted(info,key=lambda x:(x[1],x[2])))

python内置：
from operator import itemgetter
# 按照商品数量进行排序
print(sorted(info,key=itemgetter(1)))
print(sorted(info,key=itemgetter(2)))
print(sorted(info,key=itemgetter(1,2)))

3.字符串的补充

##如何快速生成验证码，快速生成内推码

import random
import string
code_str = string.ascii_letters + string.digits           ##小写字母a～b+大写字母A～B+数字0～9
print(code_str)

def gen_code(len):
    # code = ''
    # for i in range(len):
    #     new_s = random.choice(code_str)
    #     code += new_s
    # print(code)
    return ''.join(random.sample(code_str,len))

#print([gen_code(6) for i in range(100)])
print([gen_code(8) for i in range(1000)])