高级函数

字符串的应用

随机生成验证码：

import random
import string

code_str = string.ascii_letters + string.digits  #生成所有的大小写字母和数字
print(code_str)

def gen_code(len=4):
    # code = ''
    # # 字母或者数字组
    # for i in range(len):
    #     new_s = random.choice(code_str)   # 'a'
    #     code += new_s

    return "".join(random.sample(code_str, len))  #随机在所有大小写字母和数字里生成4个字符

print([gen_code(len=6) for i in range(100)])
print({gen_code(len=6) for j in range(100)}  ##对上面产生的结果进行去重操作，产生100个不重复的验证码

结果：

恺撒加密与暴力破解

import string

# 凯撒加密---加密算法的实现
def kaisacrypt(text='hello', k=3):
    # 对原有小写字母向右移动k位
    lower = string.ascii_lowercase[k:] + string.ascii_lowercase[:k]
    upper = string.ascii_uppercase[k:] + string.ascii_uppercase[:k]

    # 用于创建字符串映射的转换表'hello'
    table = str.maketrans(string.ascii_letters, lower+upper)
    # 根据转换表去转换对应的字符
    return text.translate(table)

def check(text):
    """
    思路:
        测试文本中是否存在至少两个最常见的英文单词， 如果有， 则代表破解成功.
    """
    mostCommonWords = ('the', 'is', 'to', 'not', 'have', 'than', 'for', 'ok', 'and' )
    return  len([1 for word in mostCommonWords  if word in text])>2

# 暴力破解
def bruteForce(text):
    for i in range(26):
        # 1，2，3，4，5
        t = kaisacrypt(text, -i)
        if check(t):
            print(i)
            print(t)
            break
text = 'if have a than than have is to to have ok ok ok  '
cryptStr = kaisacrypt(text=text, k=18)
print(cryptStr)

bruteForce(cryptStr)

结果：

内置高阶函数

1.map 函数
print(list(map(abs, [-1, 3, -4, -5])))
结果：

2. reduce 函数

def multi(x, y):
    return x * y

# [1,2,3]  ====> multi(multi(1,2), 3)
print(reduce(multi, range(1, 4)))

结果：
3.filter 函数

 拿出1～100之间所有的素数
def isPrime(num):
    for i in range(2, num):
        if num % i == 0:
            return  False
    else:
        return True

print(list(filter(isPrime, range(2,101))))

结果：

sorted函数

li.sort()和sorted()两种方法的区别?
1). 列表里面提供了sort方法， 其他数据结构没有.sorted方法可以对任何可迭代对象排序.
2).sort方法支持原地排序(变量排序后， 变量本身改变), sorted排序后返回一个新的列表,并不改变原变量的内容
默认sort和sorted方法由小到大进行排序, reverse=True时， 由大到小进行排序.

li = [1,2,6,67,2,23]
print(sorted(li, reverse=True))

结果：

对于列表里面的嵌套排序

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

]
def sorted_by_count(x):  # x =  ('apple3', 200, 32)
    return x[1]

def sorted_by_price(x):  # x =  ('apple3', 200, 32)
    return x[2]

def sorted_by_price(x):  # x =  ('apple3', 200, 32)
    return 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': 'apple1',
        'count': 200,
        'price': 2
    },
}
print(d.items())   # [(id, {}), (), ()]


# 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']))


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


from operator import  itemgetter
print(sorted(d.values(), key=itemgetter('count')))
print(sorted(d.values(), key=itemgetter('price')))
print(sorted(d.values(), key=itemgetter('price', 'count')))

匿名函数

匿名函数定义规则：lambda 形参：返回值

from functools import reduce
print(reduce(lambda x,y : x +y , [1,2,3,4,5]))

结果：