高阶函数整理

参数传递

参数传递机制

函数参数传递机制和赋值机制是一样的,其本质就是传递内存地址,这就是引用传递

 a传进来的时候传进来的是内存地址

 如果实在不理解,你可以以为是  x= a

def isid(x):
    #打印参数的内存地址
    print(id(x))

a = 10
#变量的内存地址
print(id(a)) #140731588047408

#a变成的参数,打印参数内存地址
isid(a) #140731588047408

默认参数

#定义一个带有默认参数的函数
def add(x,y=10):
    sum01 = x+y
    return sum01

"""
1.add(2)  x=2  y=10
2.add(2,3)  x=2  y=3
"""
print(add(2)) #12
print(add(2,3)) #5


"""
 能不能传参传入一个序列类型,比如list,让他默认是[]
"""
def add(list01 = []):
    list01.append(1)
    return list01
#第一调用
print(add()) #[1]
#第二次调用
print(add()) #[1, 1]
#第三次调用 
print(add()) #[1, 1, 1]

不定数目的参数

一个 *

 一个* :代表的是可变参数(就是可以是多个值)

def add(x,*y):
    sum01 = x
    for i in y:
        sum01 += i
    return sum01

print(add(1,2,3,4,5)) #15

两个*

 **y代表可以使用任意  键值(字典)  作为参数

 **y就相当于字典类型

def func_add(x,**y):
    sum01 = x
    #切记这里是字典的循环
    for k,v in y.items():
        print(k,v)
        #把v(值)进行和x相加
        sum01 += v
    return sum01

调用

a=3,b=4,c=5 ----> {"a":3,"b":4,"c":5}

print(func_add(1,a=3,b=4,c=5)) #13

name

执行本文件的时候,name==main

#打印name这个属性

#执行本文件的时候,打印的是main,__name__ == __main__

print("1、"+__name__) #1、__main__

2.在被import导入到别的文件的时候,name==文件名字

 一个文件就是一个模块,导入模块,就相当于导入文件,可以直接写

    import  文件名字

import 本文件 as bwj

#在其他类中运行导入的文件名字,__name__==文件名字

print(bwj.__name__) #本文件

高阶函数

定义

高阶函数是一个( 以函数为参数,或者以函数为返回值的)函数

函数可以是参数,参数是变量,那么函数可以是变量吗

参数其实就是变量进行了赋值,函数能不能是变量

函数为变量(补充)

  函数为变量并不是高阶函数,只是和大家补充这个知识点

 函数为变量

#定义一个函数,传入一个参数,求这个参数的平方

def func_pf(x):

    return pow(x,2)

#字典

#已知李四的年龄是5的平方,求李四的年龄

dict01 = {"张三":20,"李四":func_pf}

"""

 调用

  1.func_pf = dict01["李四"]  根据key获取value,vaule是一个函数对象

  2.age02 = func_pf(5) #调用函数就能获取年龄

"""

#字典的特点是根据key获取value

age01 = dict01["张三"]

print(age01) #20

#顾名思义,通过李四,我们可以拿到函数func_pf

#拿到的是函数对象,我们不能直接打印

func_pf = dict01["李四"]

print(func_pf) #<function func_pf at 0x000001E25A23D048>

age02 = func_pf(5)

print(age02) #25

函数为参数

定义

#普通函数

def func_pf(x):

    return x**2



#高阶函数,以函数为参数

def func_add(func_pf):

    #x**2+10

    return func_pf+10



#2**2+10

a = func_add(func_pf(2))

print(a) #14

常用的高阶函数

这些常用的高阶函数是以函数为参数的高阶函数

map()

定义

"""

 map(fun,x) 转换,接受一个序列,按照fun的函数逻辑转换成新的序列,返回一个map对象

  1. x必须是一个序列

  2. 返回一个map对象

"""

 map(fun,x) 转换,接受一个序列,按照fun的函数逻辑转换成新的序列,返回一个map对象

 1. x必须是一个序列

 2.返回一个map对象

"""

def func_add(x):

    return x+1

"""

  把原来的数据,经过func_add函数以后,每一个都加1,然后输出新的列表

"""

m = map(func_add,[1,2,3,4,5])

print(m) #<map object at 0x00000248E965C788>

print(list(m)) #[2, 3, 4, 5, 6]

filter()

定义

"""

filter(func,x) 过滤,接受一个序列x,按照func函数要求进行转换, 

    func函数返回 True 或 False,最后将返回 True 的元素放到新列表中。

    返回filter对象

"""

filter(func,x) 过滤,接受一个序列x,按照func函数要求进行转换, 

    func函数返回 True 或 False,最后将返回 True 的元素放到新列表中。

    返回filter对象

"""

def func_ifScore(x):

    #比较运算符,本身就是返回布尔值的

    #如果大于等于60就是Ture,否则就是False

    return  x>=60



f =  filter(func_ifScore,[80,98,70,34,60,59,10])

print(f)  #<filter object at 0x00000232CC78C808>

print(list(f)) #[80, 98, 70, 60]

reduce()

定义

 reduce(func,x) 计算,接受一个序列,把列表中的每一个值按照函数进行累加或者别的运算

   返回一个计算数值

   1.因为是计算,所以我们的func是两个参数

   2.必须要导包

from functools import reduce

"""

 reduce(func,x) 计算,接受一个序列,把列表中的每一个值按照函数进行累加或者别的运算

   返回一个计算数值

   1.因为是计算,所以我们的func是两个参数

   2.必须要导包

"""

#累加   1+2+3+4+5

def func_add(x,y):

    return x+y



a = reduce(func_add,[1,2,3,4,5])

print(a) #15

zip()

定义

 zip(list01,list02) 拉链、压缩

  用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,返回一个对象

  1.参数必须是可迭代的序列类型

  2.对象里面放的是一个一个的元组

  3.返回一个zip对象

ist01 = [1,3,5,7,9]

list02 = [2,4,6,8,10]



z = zip(list01,list02)

print(z) #<zip object at 0x00000292EE17C7C8>

#print(list(z)) #[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

"""

 数据不一样多了,拉链不一样长了,结果该怎么办呢

 以短的为基础

"""

list03 = [1,3,5,7,9,11,13]

list04 = [2,4,6]

a = zip(list03,list04)

#print(list(a)) #[(1, 2), (3, 4), (5, 6)]

 a是一个压缩、拉链数据,能不能解压呢,

 1.符号是*

 2.zip(*list类型)

 3.声明两个变量去承接

 4.zip对象如果执行过了,就不存在了

b = list(a)

list05,list06 = zip(*b)

print(list05) #(1, 3, 5)

print(list06) #(2, 4, 6)

sorted()

定义

 sorted(序列类型的对象,key=函数,reverse=True/False)  排序

  1.reverse=True/False   升序是False 降序是Ture

#list里面可以放任何数据类型

list01 = [{"name":"张三","age":20},

         {"name":"李四","age":30},

         {"name":"王五","age":18},

         {"name":"小明","age":8}

        ]



#按照年龄进行排序

#定义一个函数,返回一个年龄

def func_age(list01):

    #根据key(age)获取value(年龄)

    age01 = list01["age"]
    return age01

s = sorted(list01,key=func_age,reverse=False)

print(s)

#[{'name': '小明', 'age': 8}, {'name': '王五', 'age': 18}, {'name': '张三', 'age': 20}, {'name': '李四', 'age': 30}]

函数为返回值

语法

"""

  def func_name01(参数1):

       def func_name02(参数2):

            return 逻辑

       return fun_name02

代码

#x的y次方

def func01(x,y):

    return x**y

 简化1

   以函数为返回值进行简化

   1.闭包。函数里面的子函数,叫做闭包

"""

#f01 高阶函数

def f01(x):

    #f02是f01的子函数,又叫做闭包函数

    def f02(y):

        return x**y

    #把闭包函数返回出来

    return f02

"""

 调用

   1.f = f01(2) f是谁,f就是f02(y),相当于f=f02(y)

"""

f = f01(2) #意义就是x=2

a = f(3) #意义就是y=3

#a=x**y=2**3 = 8

print(a) #8

练习

"""

 定义一个函数,传入x参数

 定义一个子函数,传入y参数,返回x//y

 把子函数进行返回

 以上是利用的闭包进行写的,可以修改成偏函数吗

"""

偏函数(补充)

语法

"""

 from functools import partial

  partial(fun,x)

   fun:你的函数

    x:你要固定的函数中参数

"""

#x的y次方

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

#x=2不变,y不断在改变

#print(func01(2,2)) #4

#print(func01(2,3)) #8

#print(func01(2,4)) #16

#print(func01(2,5)) #32

#print(func01(2,6)) #64

 简化2

  上面的这种这能固定x,没办法固定y,使用偏函数解决这个bug

  偏函数

  1.partial(fun,你要固定的那个参数x)  可以固定函数中的任意一个参数

  2.导包 from functools import partial

   

def func01(x,y=2):

    return x**y

from functools import partial

#func = func01(x,y=2)

func = partial(func01,y=2)

a =  func(3) #x=3

#a = x**2=3**2=9

print(a) #9

#可以固定多个参数,可以把x和y都固定住

from functools import partial

#func = func01(x=10,y=2)

func = partial(func01,y=2,x=10)

a =  func() 

print(a) #100

lambda表达式

定义

lambda表达式是一行函数。在其他语言中叫做匿名函数

语法

 lambda 参数1,参数2,参数n : 逻辑

"""

  lambda表达式:一行函数

    理解为函数的简写

"""

def func01(x,y):

    return x**y

lambda x,y:x**y

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值