python笔记-day9-高阶函数

前言
python语法学习，留给需要的人，懂得都懂！！

# coding=utf8
# @time:2022/4/15 15:04
# Author 浩宇

# 1.函数就是变量
# python中定义函数，就是定义类型是function的变量，函数名就是变量
'''''''''
a=10
b=lambda x:x*2
c={'a':1,'b':2}
print(type(a),type(b),type(c))  #   
'''''''''

# 1)一个变量可以给另一个变量赋值
import time

'''''''''
x=100
y=x
print(y+100)
'''''''''

# 2)修改变量的值
# 3）变量作为序列的元素
'''''''''
x=100
list1=[x,200]
print(list1)
'''''''''
# 4)变量作为函数的参数
# 5）变量作为函数的返回值
'''''''''
def func3():
    def s():
        print('我是小函数')
    return s
func3()()
'''''''''

'''''''''
# 练习：
list3 = []
for i in range(5):
    list3.append(lambda x:x*i)
print(list3[1](2))  # 8
print(list3[2](2))  # 8
'''''''''





# 2.实参高阶函数
# 参数是函数的函数就是实参高阶函数
'''''''''
# func1就是实参高阶函数
def func1(x):
    print(x())


def func2(m=10):
    print('你好')

func1(func2)
'''''''''










# 3.系统常见的高阶函数的使用
# max、min、sorted、map、reduce
# max（序列）   -   比较序列中元素的大小来获取值最大的元素
'''''''''
# 1)max、min
nums = [23,34,65,4,43,234,12]
print(max(nums))    -   # 234
'''''''''
# max（序列，key=函数）    -   函数决定区最大值的时候的比较对象
#   参数key的要求：a.是一个函数
#                 b.这个函数有且只有一个参数(这个参数指向的就是序列中的元素)
#                 c.函数要有一个返回值（比较对象）
'''''''''
# 2)max、min
nums = [23,34,65,4,43,234,12]
def f1(item):
    return item%10
result = max(nums,key=f1)
print(result)
'''''''''

'''''''''
# 求说有学生中成绩最高的学生？
students=[
    {'name':'小明','age':'27','score':'90'},
    {'name':'小红','age':'53','score':'80'},
    {'name':'小绿','age':'27','score':'70'},
    {'name':'小白','age':'22','score':'40'},
]
# def f2(item):
#     return item['score']
# print(max(students,key=f2))   # {'name': '小明', 'age': '27', 'score': '90'}

print(max(students,key=lambda item:item['score']))  #{'name': '小明', 'age': '27', 'score': '90'}
'''''''''
'''''''''
# 求所有学生中年龄最小的学生？
students=[
    {'name':'小明','age':'27','score':'90'},
    {'name':'小红','age':'53','score':'80'},
    {'name':'小绿','age':'27','score':'70'},
    {'name':'小白','age':'22','score':'40'},
]
# def f3(item):
#     return item['age']
# print(min(students,key=f3))
print(min(students,key=lambda item:item['age']))
'''''''''
'''''''''
# 练习：获取列表中各位数的和的最大的元素？
# nums=[23，78，80，72，233，91]
# 5，15，8，9，8，10 -> 78

nums=[23,78,80,72,233,91]
def f3(item):
    n=[int(x) for x in str(item)]
    return sum(n)
print(max(nums,key=f3))
'''''''''

# sorted 排序
# sorted(序列)    -   比较序列中元素的大小对序列中的元素从小到大排序
# sorted(序列，key=函数) - 函数决定排序的时候比较大小的比较对象
# 函数要求：
# a.是一个函数
# b.这个函数有且只有一个参数(这个参数指向的就是序列中的元素)
# c.函数要有一个返回值（比较对象）

'''''''''
# 练习1：让列表中的元素按照个位数的大小从小到大排序
nums=[23,78,80,72,26,91]
def f4(item):
    return item%10
print(sorted(nums,key=f4))
'''''''''

# map
'''''''''
用法一：原序列 -> 新序列
map（函数，序列）  -   将序列按照指定的方式进行转换，返回值是一个map对象（map对象是序列）
函数：a.有一个参数（指向原序列中的元素）  b.需要一个返回值（新序列中的元素）
举例：
nums = [19,78,76,55,30,12]
result = map(lambda item:item%10,nums)
print(list(result))

用法二：
map（函数，序列1，序列2） -   根据序列1和序列2创建一个新的序列
函数：a.有两个参数，分别指向序列中的元素    b.需要一个返回值（新序列中的元素）
举例：
a = [19,78,76,55,30,12]
b = [19,72,72,55,30,12]
result = map(lambda i1,i2:i1+i2,a,b)
print(list(result))
'''''''''

# reduce    把序列中所有的数据累积 *** 作
# from functools import reduce  需要导入模块
'''''''''
reduce(函数，序列，初始值)
函数的要求：a.需要两个参数
          第一个参数 -   第一次指向初始值；从第二次开始会指向上一次的运算结果
          第二个参数 -   指向序列中的每一个元素
          b.需要一个返回值（决定运算规则）
# 练习1：累计求和？
from functools import reduce
nums = [19,78,76,55,30,12]
result = reduce(lambda x,item:x+item,nums,0)
print(result)   # 270

# 函数（0，19） -> 0+19=19
# 函数（19，78） -> 19+78=97
# ............
# 函数（258，12） -> 270
--------------------------------------------
# 练习2：累积求乘积？
from functools import reduce
nums = [19,78,76,55,30,12]
result = reduce(lambda x,item:x*item,nums,1)
print(result)   # 2230113600
----------------------------------------------
# 练习3：将序列中的元素全部拼接在一起？
# nums = [19,78,76,55,30,12]  ->  197876553012
from functools import reduce
nums = [19,78,76,55,30,12]
result = reduce(lambda x,item:x+str(item),nums,'')
print(result)    # 197876553012

'''''''''










# 4.无参装饰器
# 1）什么是装饰器
'''''''''
作用：装饰器是用来给函数添加功能
本质：就是一个函数（实参高阶函数+返回值高阶函数+糖语法）
用法（套路）：
def 函数名1（参数1）：
    def 函数名2（*args,**kwarg）:
        新增功能的代码
        调用原函数的代码：参数1（*args,**kwarg）
    return 函数名2
    
说明：
a.函数名1  -   装饰器的名称，更具新增的功能来命名
b.参数1   -   需要添加功能的函数(原函数)，一般命名程f、fn
c.函数名2  -   添加完功能的新函数名，new_f、new_fn
d.
e.
'''''''''

# 给函数添加统计函数执行时间的功能
# 方法一：给需要添加功能的函数添加功能的代码
# 存在的问题：如果给不同的函数添加相同的功能，相同的功能需要添加多次
'''''''''
def func1():
    star = time.time()
    time.sleep(1)
    print('函数1的功能')
    end = time.time()
    print('执行时间为:',end-star)
def func2(x,y):
    print(x+y)

func1()
func2(10,20)

'''''''''
# 方法二：将需要添加的功能封装到一个函数中
# 存在问题：原函数并没有新增功能
'''''''''
def func3():
    print('你好世界')


def count_time(f):
    # 获取开始时间
    star = time.time()
    # 调用原函数
    time.sleep(1)
    f()
    # 获取结束时间
    end = time.time()
    # 计算时间差
    print('执行时间为:',end-star)

count_time(func3)
'''''''''

# 方法三：装饰器
'''''''''
用法（套路）：
def 函数名1（参数1）：
    def 函数名2（）:
        新增功能的代码
        调用原函数的代码：参数1（）
    return 函数名2

说明：
a.函数名1 - 装饰器的名称，更具新增的功能来命名
b.参数1 - 需要添加功能的函数(原函数)，一般命名程f、fn
c.函数名2 - 添加完功能的新函数名，new_f、new_fn


def count_time(f):
    def new_fn(*args,**kwarg):
        start = time.time()
        time.sleep(1)
        f(*args,**kwarg)
        end = time.time()
        print('执行时间为:', end - start)
    return new_fn()

@count_time
def func5():
    print('你好python')
func5       # 你好python  执行时间为: 1.0091712474822998
'''''''''

'''''''''
# 练习：写一个装饰器，在函数开始执行的时候打开‘start’
def zz(f):
    def new_f(*args,**kwargs):
        print('start')
        f(*args,**kwargs)
    return new_f

@zz
def func6():
    print('Hello World')

@zz
def func7(x,y):
    print(x+y)


func7(10,20)
func6()
# 输出：
start
30
start
Hello World
'''''''''









# 5.有参装饰器
# 应用场景：如果实现装饰器的功能的时候需要额外的数据，就需要有参装饰器
'''''''''
def 函数名（参数列表）
    定义无参装饰器函数
    return 无参装饰器函数名

函数名：创建装饰器的函数名

# 例子：写一个有参装饰器，添加一个标签
def create_tag(name):
    def tag(f):
        def new_f(*args,**kwargs):
            result=f(*args,**kwargs)
            return f'<{name}>{result}'
        return new_f
    return tag

@create_tag('a')
def func1():
    return 'hello'
print(func1())
'''''''''

更多安全分享，请关注【安全info】微信公众号！