python函数进阶与三大神器

一、高阶函数

1.函数就是变量

python中定义函数其实就是定义一个类型是function的变量，函数名就是变量名

def func1():
    print('func1')
print(type(func1))

1)查看变量的类型

a = 10
print(type(a))    # <class 'int'>
print(type(func1))    # <class 'function'>

2)用一个变量给另外一个变量赋值

b = a
print(b+20)
c = func1
c()

3)查看变量的地址

print(id(a))
print(id(func1))

4)修改变量的值

a = 100
# func1 = 'abc'

5)变量可以作为序列的元素

a = 200
list1 = [a, 10, 20, 30, func1, func1()]
print(list1)
print(list1[-2]())

2.高阶函数

1）实参高阶函数

参数是函数的函数就是实参高阶函数

def func3(x):
    print(x(1,2))

func3(lambda m,n: m + n)  # 3

系统提供的常见的实参高阶函数
a.max、min、sorted 都是实参高阶函数，有一个参数key需要传一个函数，被传入的函数需要一个参数和一个返回值，这个参数指向的是序列中的元素，返回值是比较对象

def func3(item):   # 求各位数之和最大的数
    sum1 = 0
    for x in str(item):
        sum1 += int(x)
    return sum1

list2 = [19,90,88,78,45]
print(max(list2, key= lambda item: item % 10)) # 19 个位数最大的数
print(max(list2, key= func3)) # 88

# 练习1：用max函数获取学生列表中成绩最高的学生
student1 = [
    {'name':'zhangsan', 'age':18, 'score':88},
    {'name':'lisi', 'age':19, 'score':89},
    {'name':'wangwu', 'age':17, 'score':78},
    {'name':'zhaoliu', 'age':21, 'score':91},
    {'name':'wangqi', 'age':18, 'score':78}
]

# 获取成绩最高的学生
print(max(student1,key=lambda item: item['score'])) # {'name': 'zhaoliu', 'age': 18, 'score': 91}

print(min(student1,key=lambda item:item['age'])) # {'name': 'wangwu', 'age': 17, 'score': 78}

print(sorted(student1,key=lambda item:item['age'])) # 按照年龄进行排序

b.map函数

map(函数，序列)
将序列中所有的元素按照函数指定的规则进行转换,返回的是map的对象。函数需要一个参数和一个返回值，参数指向的是序列中的元素，返回值就是用来替换原来元素的新元素

# 示例1：将列表list3中所有的元素都加1
list3 = [10, 20, 30, 40]
new_list3 = map(lambda item: item + 1, list3)
print(list(new_list3)) # [11, 21, 31, 41]

# 实例2：将列表list3中的所有元素都转换成对应的字符串
new_list3 = map(str, list3)
print(list(new_list3)) # ['10', '20', '30', '40']

c.reduce函数

reduce(函数，序列)
对序列中的元素按照函数提供的功能进行累积的操作。函数需要两个参数，第一个参数是初始化或者上次运算的结果，y指向每一个元素
reduce(函数，序列，初始值)

# 实例1：求所有元素的和
from functools import reduce
list3 = [10, 20, 30, 40]
print(reduce(lambda x, y:x + y, list3)) # 100
# 实例2：求所有元素的乘积
print(reduce(lambda x, y:x * y, list3)) # 240000
# 实例3：求学生总成绩
student1 = [
    {'name':'zhangsan', 'age':18, 'score':88},
    {'name':'lisi', 'age':19, 'score':89},
    {'name':'wangwu', 'age':17, 'score':78},
    {'name':'zhaoliu', 'age':21, 'score':91},
    {'name':'wangqi', 'age':18, 'score':78}
]
print(reduce(lambda x, y:x + y['score'], student1, 0)) # 424，x是初始值0

2）返回值高阶函数

函数的返回值是函数的函数

def func1():
    def fun2(x, y):
        return x + y
    return fun2

print(func1()(100,200)) # 300

二、生成器

1.什么是生成器

a.生成器就是迭代器，迭代器不一定是生成器
b.调用一个带有yield关键字的函数就可以得到一个生成器

from random import randint, choices


def func1():
    print('+++++++')
    print('-------')
    yield


result = func1()
print(result) # <generator object func1 at 0x0000023E8D72C848>

2.生成器产生数据（生成器中的元素怎么产生）

生成器能生产多少数据就看执行生成器对应的函数的函数体会遇到几次yield。
yield后面表达式的值就是生成器能产生的数据。

# 示例一：创建一个生成器可以产生3个数据分别是：10，100，78
def create_gender1():
    yield 10
    yield 100
    yield 78


gen1 = create_gender1()
print(list(gen1)) # [10, 100, 78]

3.生成器产生数据的原理

当获取生成器元素的时候，会自动调用生成器关联的函数。第一次从函数开始的地方开始执行，知道遇到yield为止，并且将yield后面的值作为获取到的数据，后面每次都是从上一次结束的位置开始执行，直到遇到yield。如果从开始执行到函数结束都没有遇到yield就不会产生数据（如果是用next去获取的数据，这个时候会报错）

def create_gender2():
    for x in range(100, 150):
        print('==============')
        yield x


# gen2 = create_gender2() # 调用的时候不会执行print('==============')
# print(f'元素：{next(gen2)}') # 获取的时候才会执行print('==============')

def create_gender1():
    print('函数开始')
    yield 10
    print('++++++++')
    yield 100
    print('==========')
    yield 78
    print('函数结束')


gen1 = create_gender1()
print(f'元素：{next(gen1)}')
print(f'元素：{next(gen1)}')
print(f'元素：{next(gen1)}')
# rint(f'元素：{next(gen1)}') # 报错 StopIteration 输出：print('函数结束')

# 可以不断产生数据
def create_gender3():
    num = 0
    while True:
        num += 1
        yield num


gen3 = create_gender3()
print(next(gen3))  # 1

# 练习：写一个产生4位验证码的生成器（验证码由随机的4位数字和字母组成）
def create_random():
    alp = 'abcdefghijklmnopqrstuvwxyz'
    str1 = alp + alp.upper() + '0123456789'
    while True:
        yield ''.join(choices(str1, k = 4))

yan_zheng_ma = create_random()
print(next(yan_zheng_ma))

# 注意：每次在调用的时候都在创建一个新的对象，与上面的赋值的方式不同
def create_gender5():
    for x in range(5):
        yield x

print(next(create_gender5())) # 0
print(next(create_gender5())) # 0

4.生成式

生成式就是生成器的简写
列表推导式的[]变成()就变成了生成式

list1 = [x * 2 for x in range(5)]
print(list1)

gen1 = (x * 2 for x in range(5))
print(gen1)  # <generator object <genexpr> at 0x00000206BC9FC748>
print(next(gen1)) # 0
print(next(gen1)) # 2


# gen1 = (x * 2 for x in range(5)) 相当于
def func():
    for x in range(5):
        yield x * 2


gen2 = func()
print(next(gen2)) # 0
print(next(gen2)) # 2

三、装饰器

1.装饰器的作用

在不修改函数的情况下给函数添加新的功能

2.什么是装饰器

装饰器本质就是一个函数（这个函数是一个实参高阶函数也是返回值高阶函数）
无参装饰器的写法：
def 函数名1（函数名2）：
    def 行数名3（*args,**kwargs）：
          新功能代码
          返回值 = 函数名2（*args,**kwargs）
          return 返回值
    return 函数名3
说明：
函数名1 - 装饰器名字，命名的时候和这个装饰器要添加的功能进行关联
函数名2 - 随便命名，指向被添加功能的函数；可以命名成fn
函数名3 - 随便命名，在原函数上添加完新的功能以后产生的新的函数
新功能代码 - 实现新加的功能代码
*args,**kwargs - 不定长参数的函数在调用的时候既可以使用位置参数也可以使用关键字参数，达到更强的适应性

# 写一个装饰器，在函数开始执行前打印‘函数开始’
def start_function(fn):
    def new_fn(*args, **kwargs):
        print('函数开始')
        result = fn(*args, **kwargs)
        return result
    return new_fn
@start_function
def yt_sum(sum1, sum2):
    print(sum1 + sum2)
yt_sum(1,2)

# 练习1：写一个装饰器将返回值是字符串的函数，返回值中所有的小写字母变成大写字母
def str_funx(fn):
    def new_fn(*args,**kwargs):
        result = fn(*args, **kwargs)
        return result.upper()
        # result1 = ''
        # for i in result:
        #     if 'a' <= i <= 'z':
        #         result1 += chr(ord(i) - 32)
        #     else:
        #         result1 += i
        # return result1
    return new_fn

@str_funx
def str_func():
    return 'abc'
print(str_func())

四、迭代器

1.什么是迭代器

迭代器是容器数据类型，只能通过类型转换和生成器来获得迭代器对象
迭代器存储数据的特点：同时可以保存多个数据，没有办法直接查看，而是需要先将数据从迭代器中取出（取出来之后不能再放回去），无法获取迭代器的长度

# 所有的容器都可以转换成迭代器
iter1 = iter([10,20,30,40])
print(iter1)  # <list_iterator object at 0x000002B3E0C41D88>
iter2 = iter('abc')
print(iter2)  # <str_iterator object at 0x000002B3E0C41E08>
iter3 = iter({'name':'zhangsan','age':18,'gender':'male'})
print(iter3)  # <dict_keyiterator object at 0x000002B3E0C42908>

2.获取迭代器中的元素

无论通过什么样的方式，只要是将迭代器中的某个元素拿到了，那么这个元素在迭代器中就不存在了

list1 = list(iter1)
print(list1)  # [10, 20, 30, 40]
list2 = list(iter1)
print(list2)  # []

1）遍历

iter5 = iter('hello!')
for x in iter5:
    print(f'x:{x}')
print(list(iter5)) # []

2）获取单个元素

next(迭代器对象) - 获取迭代器中的一个元素（当前最前面的那个元素）
迭代器对象.next() - 获取迭代器中的一个元素（当前最前面的那个元素）

iter3 = iter({'name':'zhangsan','age':18,'gender':'male'})
print(next(iter3)) # name
print(next(iter3)) # age
print(next(iter3)) # gender
# print(next(iter3)) # 报错：StopIteration

iter4 = iter([1,2,3,4,5,6,7])
next(iter4)
next(iter4)
print('=========')
for x in iter4:
    print(f'x:{x}')   # 3  4  5  6  7