day11-高阶函数

最新推荐文章于 2021-11-03 21:40:06 发布
最新推荐文章于 2021-11-03 21:40:06 发布
阅读量93 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/The_hacker/article/details/111566712
版权

day11-高阶函数

01-高阶函数

  • 函数就是变量

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

变量能做的事情，函数都能做

a = 10
d = 'abc'
e = [10, 20, 30]
b = lambda x: x*2
# def b(x):
#   return x*2
c = {'a': 10, 'b': 100}
print(type(a), type(b), type(c))

x = 100
def func1():
    print('我是一个函数')

1）一个变量可以给另外一个变量赋值

y = x
print(y+100)

z = func1
z()
  1. 修改变量的值
# x = 'abc'
# print(x+'123', x.replace('a', '100'))
# #
# func1 = 100
# # func1()     # TypeError: 'int' object is not callable
# print(func1, func1+200)

3)变量作为序列的元素

list1 = [x, 200]
print(list1)    # [100, 200]
print(list1[0] - 100)

list2 = [func1, 200, func1()]
print(list2)     # [<function func1 at 0x10a776710>, 200, None]
list2[0]()    # func1()

4)变量作为函数的参数

def func2(m):
    print(f'x:{m}')

a = 100
func2(a)

func2(func1)

5)变量作为函数的返回值

def func3():
    # s = 100
    def s():
        print('我是小函数')
    return s

# print(func3()-50)
func3()()   # s()

面试题

list3 = []
for i in range(5):
    list3.append(lambda x:x*i)

"""
i = 0:  [lambda x:x*i]
i = 1: [lambda x:x*i, lambda x:x*i]
i = 2: [lambda x:x*i, lambda x:x*i, lambda x:x*i]
i = 3: [lambda x:x*i,lambda x:x*i,lambda x:x*i,lambda x:x*i]
i = 4: [lambda x:x*i, lambda x:x*i, lambda x:x*i, lambda x:x*i, lambda x:x*i]
list3 = [lambda x:x*i, lambda x:x*i, lambda x:x*i, lambda x:x*i, lambda x:x*i]

lambda x:x*i
"""
print(list3[1](2))    # 8
print(list3[2](2))    # 8

02 -实参高阶函数

  • func1就是实参高阶函数
def func1(x):
    print(x())

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

func1(func2)
  • 系统常见实参高阶函数的使用
# max、min、sorted、map、reduce

1） max、min、

‘’‘

1）max(序列) - 比较序列中元素的大小来获取值最大的元素

2）max(序列, key=函数) - 函数决定求最大值的时候的比较对象

​ 参数key的要求：a.是一个函数 b.这个函数有且只有一个参数(这个参数指向的就是序列中的元素)

​ c.函数要有一个返回值(比较对象)

’‘’

nums = [23, 78, 90, 78, 233, 91]
print(max(nums))   # 233

求列表中个位数最大的元素

nums = [19, 78, 76, 55, 30, 12]
# def f1(item):
#     return item % 10
# result = max(nums, key=f1)
result = max(nums, key=lambda item: item % 10)
print(result)

students = [
    {'name': '小明', 'age': 23, 'score': 90},
    {'name': '张三', 'age': 30, 'score': 78},
    {'name': '小红', 'age': 18, 'score': 82},
    {'name': 'Tom', 'age': 26, 'score': 99}
]
# 求所有学生中成绩最高的学生
# def f2(item):
#     print(f'item:{item}')
#     return item['score']
print(max(students, key=lambda item: item['score']))
# print(max(students, key=f2))
# 求年龄最小的学生
print(min(students, key=lambda item: item['age']))

# 练习：获取列表中数字各位数的和最大的元素
# nums = [23, 78, 90, 73, 233, 91]
# 5， 15， 9， 10， 8， 10   -> 78
nums = [23, 78, 90, 73, 233, 91]


def f3(item):
    n = [int(x) for x in str(item)]
    return sum(n)


print(max(nums, key=f3))

2）sorted

sorted(序列) - 比较序列中元素的大小对序列中的元素从小到大排序

sorted(序列, key=函数) - 函数决定排序的时候比较大小的比较对象

函数要求： a.是一个函数 b.需要一个参数(指向序列中的元素) c.需要一个返回值(比较对象)

nums = [19, 78, 76, 55, 30, 12]
result = sorted(nums)
print(result)

# 练习1：让列表中的元素按照个位数的大小从小到大排序
# nums = [19, 78, 76, 55, 30, 12]  ->  [30, 12, 55, 76, 78, 19]
nums = [19, 78, 76, 55, 30, 12]
result = sorted(nums, key=lambda item:item%10)
print(result)    # [30, 12, 55, 76, 78, 19]

# 练习2：将students按照学生的年龄从大到小排序
students = [
    {'name': '小明', 'age': 23, 'score': 90},
    {'name': '张三', 'age': 30, 'score': 78},
    {'name': '小红', 'age': 18, 'score': 82},
    {'name': 'Tom', 'age': 26, 'score': 99}
]

result = sorted(students, key=lambda item: item['age'])
print(result)
  • map

用法一： 原序列 -> 新序列

map(函数, 序列) - 将序列按照指定的方式进行转换, 返回值是一个map对象(map对象是序列)

函数：a.有一个参数(指向原序列中的元素) b.需要一个返回值(新序列中的元素)

用法二：

map(函数, 序列1, 序列2) - 根据序列1和序列2创建一个新的序列

函数：a.有两个参数，分别指向两个序列中元素 b.需要一个返回值(新序列中的元素)

# 用法一
nums = [19, 78, 76, 55, 30, 12]
result = map(lambda item: item%10, nums)
print(list(result))

result = map(lambda item: item*2, nums)
print(list(result))

# 用法二
names = ['张三', '李四', '小明', '小花']
ages = [19, 29, 30, 17]
# [{'name': '张三', 'age': 19}, {'name':'李四', 'age': 29},...]
result = map(lambda item1, item2: {'name':item1, 'age': item2}, names, ages)
print(list(result))

# 练习：获取班级所有学生的总成绩
c = [90, 89, 88, 99, 27, 76, 56]
e = [98, 78, 66, 82, 90, 12, 78]
m = [23, 98, 100, 72, 69, 27, 96]
result = map(lambda i1, i2, i3: i1+i2+i3, c, e, m)
print(list(result))

4）reduce

reduce(函数, 序列, 初始值)

函数的要求：a.需要两个参数:

​ 第一个参数 - 第一次指向初始值; 从第二次开始指向上一次的运算结果

​ 第二个参数 - 指向序列中的每个元素

​ b. 需要一个返回值(决定运算规则)

  • 累积求和
from functools import reduce

nums = [10, 89, 78, 20]
# result = reduce(lambda s, item: s+item, nums, 0)
def f1(s, item):
    print(f's:{s}, item:{item}')
    return s+item
result = reduce(f1, nums, 0)
print(result)    # 197
  • 累积求乘积
nums = [8, 9, 5, 2]
result = reduce(lambda s, item: s*item, nums, 1)
print(result)

# 将数字序列中的元素全部拼接在一起
# [10, 89, 78, 20] -> 10897820
nums = [10, 89, 78, 20]
result = reduce(lambda s, item: s+str(item), nums, '')
print(result)
# f('', 10)  -> ''+str(10) -> '10'
# f('10', 89) -> '10'+str(89) -> '1089'
# ....

# nums = ['10', '89', '78', '20']

03-无参装饰器

  • 什么是装饰器

作用：装饰器是用来给函数添加功能

本质：就是一个函数(实参高阶函数+返回值高阶函数+糖语法)

用法(套路)：

def 函数名1(参数1):

​ def 函数名2():

​ 新增功能的代码

​ 调用原函数的代码: 参数1()

​ return 函数名2

说明：

​ 1) 函数名1 - 装饰器的名称，根据新增的功能来命名

​ 2) 参数1 - 需要添加功能的函数(原函数)， 一般命名成f、fn

​ 3) 函数名2 - 添加完功能的新函数的函数名, new_f、new_fn

方法一：给需要添加功能的函数添加新增功能的代码

import time

# 给函数添加统计函数执行时间的功能
# 存在的问题：如果给不同的函数添加相同的功能，相同的功能的代码要写多遍
def fun1():
    start = time.time()
    print('函数1的功能')
    end = time.time()
    print(f'执行时间:{end - start}')

def func2(x, y):
    start = time.time()
    print(x + y)
    end = time.time()
    print(f'执行时间:{end - start}')

fun1()
func2(10, 20)

方法二：将需要添加的功能封装到一个函数中

# 存在问题：原函数并没有新增功能
def func3():
    print('hello world!')


def func4():
    print('你好世界！')


def count_time(f):
    # 获取开始时间
    start = time.time()
    # 调用原函数
    # func3()
    f()
    # 获取结束时间
    end = time.time()
    # 计算时间差
    print(f'执行时间:{end - start}')


count_time(func3)
count_time(func4)
func3()

方法三: 装饰器

用法(套路)：
def 函数名1(参数1):
    def 函数名2(*args, **kwarg):
        新增功能的代码
        原函数的返回值 = 调用原函数的代码: 参数1(*args, **kwarg)
        return 原函数的返回值
    return 函数名2

说明：
1) 函数名1  - 装饰器的名称，根据新增的功能来命名
2) 参数1  - 需要添加功能的函数(原函数)， 一般命名成f、fn
3) 函数名2  -  添加完功能的新函数的函数名, new_f、new_fn

def count_time(f):
    def new_f(*args, **kwargs):
        start = time.time()
        result = f(*args, **kwargs)
        end = time.time()
        print(f'执行时间:{end - start}')
        return result

    return new_f


print('==================================')


@count_time
def func5():
    print('你好, Python')


@count_time
def func6():
    print('*****')


@count_time
def func7(num1, num2):
    print(num1 + num2)


@count_time
def func8(num):
    return num ** 2


func5()

print('==================================')
func6()

print('==================================')
func7(10, 20)

print('==================================')
result = func8(9)
print(result)

print('===========================================')

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

    return new_f


@start
def func11():
    print('hello world!')


@start
def func22(a, b):
    return a * b


func11()
func22(10, 29)
Mr.冠希
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python-09-高阶函数、装饰器
老板来片烤面包的博客
04-06 326
01-函数的回顾总结 # 1. 函数的声明，使用关键字 def 来声明一个函数 # 2. 函数的格式 def 函数名(形参1,形参2...) # 3. 函数的调用 函数名(实参1,实参2...) # 4. 函数返回值 使用 return 语句返回函数的执行结果 # 5. 函数返回多个结果，就是将多个数据打包成一个整体返回。 # 可以使用列表和字典，通常情况下选择使用元组 # 函数名也是一个标识符。 # 由数字、字母下划线组成，不能以数字开头;严格区分大小写;不能使用关键字 # 遵守命名规..
Day 9 - 函数进阶2及装饰器
qq_41175455的博客
10-13 138
Day 9 函数进阶及装饰器 实参高阶函数 前言 在进行实参高阶函数的学习之前要了解一个问题，函数等同于变量 Python中定义函数就是定义一个类型为function的变量，其中函数名就是变量名 因此，变量能做的事情函数都能做 1.给其他变量赋值 2.作为列表元素 3.重新赋值 a = 10 b = 'abc' c = [1, 2, 3] d = {'a': 1, 'b': 2,'c': 3} e = lambda x: x*2 print(f'a: {type(a)}, b: {type(b)},
高阶函数总结
weixin_30359021的博客
05-23 68
一、函数成员 函数中有一个name属性------>函数的名字,属性只读,不能修改 函数中有一个length属性----->函数定义的时候形参的个数 <script> function f1(a,b,c){ console.log(f1.name); console.log(f1.len...
高阶函数
RTC hacker
10-18 1114
<br />函数是计算机程序功能强大的构建块。使用函数可以将代码划分为更简单、更容易管理的代码段，还可以将程序划分为可重用的单元－－这些单元既可以在本程序中使用，也可以在其他程序中使用。在本文中，我们将介绍如何基于一些模板在运行时创建新函数，如何创建一些在运行时可以使用参数配置的函数，以及在函数中 Scheme 语言如何成为一个有价值的工具。<br /> <br />在计算机程序中，函数构成了功能强大的代码段，这让开发人员可以将代码划分成更简单、更容易管理的代码段，同时还让程序员可以将自己的程序划分成可重用
Python函数式编程之高阶函数（一）
06-07 193
该篇中主要介绍什么是高阶函数，高阶函数的用法以及几个常见的内置的高阶函数。 什么是高阶函数？ 　　高阶函数：一个函数可以作为参数传给另外一个函数，或者一个函数的返回值为另外一个函数（若返回值为该函数本身，则为递归），满足其一则为高阶函数。 通过了解以下两个概念来理解高阶函数： A.变量指向函数：函数本身也可以赋值给变量，即：变量可以指向函数 例如：python内置函数求和函数sum: >>sum([11,22])>>33#如果我将函数结果赋值变量>>..
Day16-30_Day16-30_python_
10-03
- 高阶函数：接受一个或多个函数作为参数的函数，如`map()`, `filter()`, `reduce()`。 - 匿名函数（lambda）：简短的、一次性使用的函数。 - `functools`模块：提供高级函数工具，如`partial()`用于固定函数参数...
day17：高阶函数：map、reduce、sorted、fliter、lambda
12-22
在Python编程语言中，高阶函数是一类可以接受一个或多个函数作为参数的函数，它们在函数式编程中扮演着重要角色。今天我们将探讨五个重要的高阶函数：`map()`、`reduce()`、`sorted()`、`filter()`以及`lambda`...
day03-js高级资料.zip
10-01
4. **高阶函数**：可以将函数作为参数传递给其他函数，或者返回一个函数的函数。常见的高阶函数有map、reduce、filter等，它们在数组操作中非常实用。 5. **ES6及以后的新特性**：包括箭头函数、解构赋值、模板字符...
day03-js高级讲义.zip
10-01
4. **高阶函数**：能够接受函数作为参数或返回函数的函数称为高阶函数。例如，`Array.prototype.map()`、`filter()`和`reduce()`等，这些都是常见的高阶函数，它们能对数组进行高效操作。 5. **异步编程**：JS是非...
python-day15-day19
最新发布
03-18
5. **函数式编程**：Python支持函数式编程风格，如使用map()、filter()和reduce()函数，以及lambda表达式和高阶函数。函数式编程强调程序的数据流和变换，而不是对指令进行控制。 6. **生成器**：生成器是Python中...
11 Python - 高阶函数
plyzz的博客
06-23 208
高阶函数 1.函数就是变量 python中定义函数其实就是定义一个类型是 function 的变量,函数名就是变量名 def func1(): print('函数1') a = 10 # 为了证明函数本质就是变量 # 我们来查看一下a和func1类型 print(type(a)) # <class 'int'> print(type(func1)) # <class 'function'> # 我们将变量a赋值给b b = a print(b+20) # 同样我们
高阶函数以及函数的特殊写法
cihongmo6452的博客
08-16 320
高阶函数 val arr5 = Array[Int](1, 2, 3) def plus2(arr:Array[Int], func:(Int)=>Int):Array[Int] = { val buffer = new ArrayBuffer[Int]() for(...
编写一个函数，该函数具有两个形参，分别为int型和指向int型的指针，并返回这两个int值之中较大的数值。
sinat_33531884的博客
11-03 901
这里主要想说明一下采取哪种书写指针的风格比较好：int *a与int* a。以后采取int* a的书写风格 int max(int a, int* b)//我现在觉得这种指针的声明方式比较好， //这样声明指针和取指针所指向的值运算不容易混淆。只是这样声明要注意的是连续声明多个指针不可以像 int *a, *b；这样。要分开声明 int* a; int* b; { if(a>*b) //此处*b的*是取指针b所指向的对象的值运算 return a; else re
Python-高阶函数习题练习
weixin_34033624的博客
04-09 932
本文是针对map()，reduce()和filter()三个高阶函数的程序练习。 map()概念 map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的列表返回。##### 题目> 利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。> 例如输入：[...
函数| 常用模块总结练习
weixin_30394669的博客
04-05 312
### 第一模块内容 1. 请写出 “路飞学城alex” 分别用 utf-8 和 gbk 编码所占的位数（口述） utf-8：一个中文字符占3个字节，英文字符占1个字节，则“路飞学城alex"一共16个字节，则共有16*8=128位。 gbk：一个中文占2个字节，英文字符占1个字节，则“路飞学城alex”一共12个字节，则共占12*8=96位 2. python有哪几种数据...
函数的声明方式，函数的参数，带返回值的函数
weixin_37150764的博客
10-14 1310
一、函数的声明方式 1、普通的声明方式 2、使用变量声明函数(函数字面量) 3、使用构造函数来声明（了解不常使用） 二、函数的参数 (1)、形参：形式上占位，形式参数 (2)、实参：实际传入的参数，arguments 保存实参的类数集合(类数组) 形参与实参数量可以不相等，形参与实参是一个映射关系。 (3)、实参里面传了值的，可以在函数体内修改实参的值，如果没有传值的，给其赋值是没有用的，返回undefined 注意：函数中的形参b与arguments[1]不是同一个变量，b = 3存在栈内存中
学习Spark--(6)--高阶函数
qigemantou的博客
07-15 1330
Scala高级特性 1. 高阶函数 --1--概念 Scala混合了面向对象和函数式的特性，我们通常将可以作为参数传递到方法中的表达式叫做函数。在函数式编程语言中，函数是“头等公民”，把函数作为参数或者是返回值是函数叫高阶函数。 高阶函数包含：作为值的函数、匿名函数、闭包、柯里化等等。 --2-- 作为值的函数 可以像任何其他数据类型一样被传递和操作的函数，每当你想要给算法传入具体动作...
Python学习笔记2：函数式编程
静墨的博客
07-07 974
在上一篇博客中，我们学习了以下内容：Python的安装环境；变量和数据类型（Python内置的基本类型）；List和Tuple（顺序的集合类型）；条件判断和循环（控制程序流程）；Dict和Set（根据key访问的集合类型）；函数（定义和调用函数）；切片（如何对list进行切片）；迭代（如何用for循环迭代集合类型）；列表生成式（如何快速生成列表）。在本篇博客中我们将学习函数式编程。1.相关概念函数：
Scala学习（十二）高阶函数
weixin_34216196的博客
10-09 114
2019独角兽企业重金招聘Python工程师标准>>> ...
Oracle11g SQL基础：实战教程-查询与函数详解
- 日期型函数，如SYSDATE获取当前日期，SYSTIMESTAMP获取时间戳，以及日期操作函数如ADD_MONTHS、LAST_DAY等。 - 还有如ABS、LEAST&GREATEST等函数，提供数据比较和绝对值计算。 通过这些章节的学习，读者将逐步...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值