基础学习第六弹,关于函数和python的面向对象

一、函数

函数就是将一段具有独立功能的代码块整合到一个整体并命名,在需要的位置,调用这个名称即可完成对应的需求。

1.1 定义函数

def 函数名(参数):
    代码1
    代码2
    ......

1.2 调用函数

函数名(参数)

注意:

   1. 不同的需求,参数可有可无。
            2. 在Python中,函数必须==先定义后使用==

1.3 快速体验

需求:复现ATM取钱功能。

  1. 搭建整体框架(复现需求)
print('密码正确登录成功')

# 显示"选择功能"界面

print('查询余额完毕')

# 显示"选择功能"界面

print('取了2000元钱')

# 显示"选择功能"界面
  1. 确定“选择功能”界面内容
print('查询余额')
print('存款')
print('取款')
  1. 封装"选择功能"

注意:一定是先定义函数,后调用函数。

# 封装ATM机功能选项 -- 定义函数
def select_func():
    print('-----请选择功能-----')
    print('查询余额')
    print('存款')
    print('取款')
    print('-----请选择功能-----')
  1. 调用函数

在需要显示“选择功能”函数的位置调用函数。

print('密码正确登录成功')
# 显示"选择功能"界面 -- 调用函数
select_func()

print('查询余额完毕')
# 显示"选择功能"界面 -- 调用函数
select_func()

print('取了2000元钱')
# 显示"选择功能"界面 -- 调用函数
select_func()

二、参数、返回值、说明文档

2.1 参数

思考:完成需求如下:一个函数完成两个数1和2的加法运算,如何书写程序?

# 定义函数
def add_num1():
    result = 1 + 2
    print(result)


# 调用函数
add_num1()

思考:上述add_num1函数只能完成数字1和2的加法运算,如果想要这个函数变得更灵活,可以计算任何用户指定的两个数字的和,如何书写程序?

分析:用户要在调用函数的时候指定具体数字,那么在定义函数的时候就需要接收用户指定的数字。函数调用时候指定的数字和定义函数时候接收的数字即是函数的参数。

# 定义函数时同时定义了接收用户数据的参数a和b,a和b是形参
def add_num2(a, b):
    result = a + b
    print(result)


# 调用函数时传入了真实的数据10 和 20,真实数据为实参
add_num2(10, 20)

2.2 返回值

例如:我们去超市购物,比如买烟,给钱之后,是不是售货员会返回给我们烟这个商品,在函数中,如果需要返回结果给用户需要使用函数返回值

def buy():
    return '烟'

# 使用变量保存函数返回值
goods = buy()
print(goods)

需求:制作一个计算器,计算任意两数字之和,并保存结果。

def sum_num(a, b):
    return a + b


# 用result变量保存函数返回值
result = sum_num(1, 2)
print(result)

2.3 函数的说明文档

思考:定义一个函数后,程序员如何书写程序能够快速提示这个函数的作用?

答:注释

思考:如果代码多,我们是不是需要在很多代码中找到这个函数定义的位置才能看到注释?如果想更方便的查看函数的作用怎么办?

答:函数的说明文档

函数的说明文档也叫函数的文档说明

语法

  • 定义函数的说明文档
def 函数名(参数):
    """ 说明文档的位置 """
    代码
    ......
  • 查看函数的说明文档
help(函数名)

快速体验

def sum_num(a, b):
    """ 求和函数 """
    return a + b


# 函数不用带括号
help(sum_num)

2.4 函数的嵌套

所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数

def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码...(省略)...')
    print('---- testB end----')

def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')

    
testA()
---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----
---- testA end----

如果函数A中,调用了另外一个函数B,那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置。

2.5 打印图像

1.打印一条横线

def print_line():
    print('-' * 20)


print_line()

2.打印多条横线

def print_line():
    print('-' * 20)

def print_lines(num):
    i = 0
    while i < num:
        print_line()
        i += 1


print_lines(10)

2.6 函数计算

def sum_num(a, b, c):
    return a + b + c


print(sum_num(1, 2, 3))


def avg_num(a, b, c):
    return (a + b + c) / 3


print(avg_num(1, 2, 3))

三、作用域和执行流程

3.1 变量作用域

变量作用域指的是变量生效的范围,主要分为两类:局部变量全局变量

  • 局部变量

所谓局部变量是定义在函数体内部的变量,即只在函数体内部生效。

def testA():
    a = 100

    print(a)


testA()  # 100
print(a)  # 报错:name 'a' is not defined

变量a是定义在testA函数内部的变量,在函数外部访问则立即报错。

局部变量的作用:在函数体内部,临时保存数据,即当函数调用完成后,则销毁局部变量。

  • 全局变量

所谓全局变量,指的是在函数体内、外都能生效的变量。

思考:如果有一个数据,在函数A和函数B中都要使用,该怎么办?

答:将这个数据存储在一个全局变量里面。

# 定义全局变量a
a = 100


def testA():
    print(a)  # 访问全局变量a,并打印变量a存储的数据


def testB():
    print(a)  # 访问全局变量a,并打印变量a存储的数据


testA()  # 100
testB()  # 100

思考:testB函数需求修改变量a的值为200,如何修改程序?

a = 100


def testA():
    print(a)


def testB():
    a = 200
    print(a)


testA()  # 100
testB()  # 200
print(f'全局变量a = {a}')  # 全局变量a = 100

思考:在testB函数内部的a = 200中的变量a是在修改全局变量a吗?

答:不是。观察上述代码发现,15行得到a的数据是100,仍然是定义全局变量a时候的值,而没有返回

testB函数内部的200。综上:testB函数内部的a = 200是定义了一个局部变量。

思考:如何在函数体内部修改全局变量?

使用 global声明这个变量为全局变量

a = 100


def testA():
    print(a)


def testB():
    # global 关键字声明a是全局变量
    global a
    a = 200
    print(a)


testA()  # 100
testB()  # 200
print(f'全局变量a = {a}')  # 全局变量a = 200

3.2 多函数程序执行流程

一般在实际开发过程中,一个程序往往由多个函数组成,并且多个函数共享某些数据,如下所示:

  • 共用全局变量
# 1. 定义全局变量
glo_num = 0


def test1():
    global glo_num
    # 修改全局变量
    glo_num = 100


def test2():
    # 调用test1函数中修改后的全局变量
    print(glo_num)
    

# 2. 调用test1函数,执行函数内部代码:声明和修改全局变量
test1()
# 3. 调用test2函数,执行函数内部代码:打印
test2()  # 100
  • 返回值作为参数传递
def test1():
    return 50


def test2(num):
    print(num)


# 1. 保存函数test1的返回值
result = test1()


# 2.将函数返回值所在变量作为参数传递到test2函数
test2(result)  # 50

四、返回值问题

思考:如果一个函数如些两个return (如下所示),程序如何执行?

def return_num():
    return 1
    return 2


result = return_num()
print(result)  # 1

答:只执行了第一个return,原因是因为return可以退出当前函数,导致return下方的代码不执行。

思考:如果一个函数要有多个返回值,该如何书写代码?

def return_num():
    return 1, 2


result = return_num()
print(result)  # (1, 2)

注意:

  1. return a, b写法,返回多个数据的时候,默认是元组类型。
  2. return后面可以连接列表、元组或字典,以返回多个值。

五、参数详解

5.1 位置参数

位置参数:调用函数时根据函数定义的参数位置来传递参数。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20, '男')

注意:传递和定义参数的顺序及个数必须一致。

5.2 关键字参数

函数调用,通过“键=值”形式加以指定。可以让函数更加清晰、容易使用,同时也清除了参数的顺序需求。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)

注意:函数调用时,如果有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序。

5.3 缺省参数

缺省参数也叫默认参数,用于定义函数,为参数提供默认值,调用函数时可不传该默认参数的值(注意:所有位置参数必须出现在默认参数前,包括函数定义和调用)。

def user_info(name, age, gender='男'):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20)
user_info('Rose', 18, '女')

注意:函数调用时,如果为缺省参数传值则修改默认参数值;否则使用这个默认值。

5.4 不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时,可用包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会显得非常方便。

  • 包裹位置传递
def user_info(*args):
    print(args)


# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)

注意:传进的所有参数都会被args变量收集,它会根据传进参数的位置合并为一个元组(tuple),args是元组类型,这就是包裹位置传递。

  • 包裹关键字传递
def user_info(**kwargs):
    print(kwargs)


# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)

综上:无论是包裹位置传递还是包裹关键字传递,都是一个组包的过程。

六、拆包和交换变量值

6.1 拆包

  • 拆包:元组
def return_num():
    return 100, 200


num1, num2 = return_num()
print(num1)  # 100
print(num2)  # 200
  • 拆包:字典
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1

# 对字典进行拆包,取出来的是字典的key
print(a)  # name
print(b)  # age

print(dict1[a])  # TOM
print(dict1[b])  # 18

6.2 交换变量值

需求:有变量a = 10b = 20,交换两个变量的值。

  • 方法一

借助第三变量存储数据。

# 1. 定义中间变量
c = 0

# 2. 将a的数据存储到c
c = a

# 3. 将b的数据20赋值到a,此时a = 20
a = b

# 4. 将之前c的数据10赋值到b,此时b = 10
b = c

print(a)  # 20
print(b)  # 10
  • 方法二
a, b = 1, 2
a, b = b, a
print(a)  # 2
print(b)  # 1

七、引用

7.1 了解引用

在python中,值是靠引用来传递来的。

我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标识。

# 1. int类型
a = 1
b = a

print(b)  # 1

print(id(a))  # 140708464157520
print(id(b))  # 140708464157520

a = 2
print(b)  # 1,说明int类型为不可变类型 

print(id(a))  # 140708464157552,此时得到是的数据2的内存地址
print(id(b))  # 140708464157520


# 2. 列表
aa = [10, 20]
bb = aa

print(id(aa))  # 2325297783432
print(id(bb))  # 2325297783432


aa.append(30)
print(bb)  # [10, 20, 30], 列表为可变类型

print(id(aa))  # 2325297783432
print(id(bb))  # 2325297783432

7.2 引用当做实参

代码如下:

def test1(a):
    print(a)
    print(id(a))

    a += a

    print(a)
    print(id(a))


# int:计算前后id值不同
b = 100
test1(b)

# 列表:计算前后id值相同
c = [11, 22]
test1(c)

效果如下:

100
140722476347312
200
140722476350512
[12, 22]
2165309858440
[12, 22, 12, 22]
2165309858440

八、可变和不可变类型

所谓可变类型与不可变类型是指:数据能够直接进行修改,如果能直接修改那么就是可变,否则是不可变.

  • 可变类型

    • 列表
    • 字典
    • 集合
  • 不可变类型

    • 整型
    • 浮点型
    • 字符串
    • 元组

九、应用:学员管理系统

9.1 系统简介

需求:进入系统显示系统功能界面,功能如下:

  • 1、添加学员
  • 2、删除学员
  • 3、修改学员信息
  • 4、查询学员信息
  • 5、显示所有学员信息
  • 6、退出系统

系统共6个功能,用户根据自己需求选取。

9.2 步骤分析

  1. 显示功能界面
  2. 用户输入功能序号
  3. 根据用户输入的功能序号,执行不同的功能(函数)

3.1 定义函数

3.2 调用函数

9.3 需求实现

显示功能界面

定义函数print_info,负责显示系统功能。

def print_info():
    print('-' * 20)
    print('欢迎登录学员管理系统')
    print('1: 添加学员')
    print('2: 删除学员')
    print('3: 修改学员信息')
    print('4: 查询学员信息')
    print('5: 显示所有学员信息')
    print('6: 退出系统')
    print('-' * 20)
    
    
    print_info()

用户输入序号,选择功能

user_num = input('请选择您需要的功能序号:')

根据用户选择,执行不同的功能

if user_num == '1':
    print('添加学员')
elif user_num == '2':
    print('删除学员')
elif user_num == '3':
    print('修改学员信息')
elif user_num == '4':
    print('查询学员信息')
elif user_num == '5':
    print('显示所有学员信息')
elif user_num == '6':
    print('退出系统')

工作中,需要根据实际需求调优代码。

  1. 用户选择系统功能的代码需要循环使用,直到用户主动退出系统。
  2. 如果用户输入1-6以外的数字,需要提示用户。
while True:
    # 1. 显示功能界面
    print_info()
    
    # 2. 用户选择功能
    user_num = input('请选择您需要的功能序号:')

    # 3. 根据用户选择,执行不同的功能
    if user_num == '1':
        print('添加学员')
    elif user_num == '2':
        print('删除学员')
    elif user_num == '3':
        print('修改学员信息')
    elif user_num == '4':
        print('查询学员信息')
    elif user_num == '5':
        print('显示所有学员信息')
    elif user_num == '6':
        print('退出系统')
    else:
        print('输入错误,请重新输入!!!')

定义不同功能的函数

所有功能函数都是操作学员信息,所有存储所有学员信息应该是一个全局变量,数据类型为列表

info = []

需求分析

  1. 接收用户输入学员信息,并保存
  2. 判断是否添加学员信息

2.1 如果学员姓名已经存在,则报错提示

2.2 如果学员姓名不存在,则准备空字典,将用户输入的数据追加到字典,再列表追加字典数据

  1. 对应的if条件成立的位置调用该函数
  • 代码实现
def add_info():
    """ 添加学员 """
    # 接收用户输入学员信息
    new_id = input('请输入学号:')
    new_name = input('请输入姓名:')
    new_tel = input('请输入手机号:')
    

    # 声明info是全局变量
    global info

    # 检测用户输入的姓名是否存在,存在则报错提示
    for i in info:
        if new_name == i['name']:
            print('该用户已经存在!')
            return

    # 如果用户输入的姓名不存在,则添加该学员信息
    info_dict = {}
    
    # 将用户输入的数据追加到字典
    info_dict['id'] = new_id
    info_dict['name'] = new_name
    info_dict['tel'] = new_tel
    
    # 将这个学员的字典数据追加到列表
    info.append(info_dict)
    
    print(info)

删除学员

  • 需求分析

按用户输入的学员姓名进行删除

    1. 用户输入目标学员姓名
    2. 检查这个学员是否存在

    2.1 如果存在,则列表删除这个数据

    2.2 如果不存在,则提示“该用户不存在”

    1. 对应的if条件成立的位置调用该函数
    • 代码实现
    # 删除学员
    def del_info():
        """删除学员"""
        # 1. 用户输入要删除的学员的姓名
        del_name = input('请输入要删除的学员的姓名:')
    
        global info
        # 2. 判断学员是否存在:如果输入的姓名存在则删除,否则报错提示
        for i in info:
            if del_name == i['name']:
                info.remove(i)
                break
        else:
            print('该学员不存在')
    
        print(info)

    修改学员信息

    • 需求分析
    1. 用户输入目标学员姓名
    2. 检查这个学员是否存在

    2.1 如果存在,则修改这位学员的信息,例如手机号

    2.2 如果不存在,则报错

    1. 对应的if条件成立的位置调用该函数
    • 代码实现
    # 修改函数
    def modify_info():
        """修改函数"""
        # 1. 用户输入要修改的学员的姓名
        modify_name = input('请输入要修改的学员的姓名:')
    
        global info
        # 2. 判断学员是否存在:如果输入的姓名存在则修改手机号,否则报错提示
        for i in info:
            if modify_name == i ['name']:
                i['tel'] = input('请输入新的手机号:')
                break
        else:
            print('该学员不存在')
        
        print(info)

    查询学员信息

    • 需求分析
    1. 用户输入目标学员姓名
    2. 检查学员是否存在

    2.1 如果存在,则显示这个学员的信息

    2.2 如果不存在,则报错提示

    1. 对应的if条件成立的位置调用该函数
    • 代码实现
    # 查询学员
    def search_info():
        """查询学员"""
        # 1. 输入要查找的学员姓名:
        search_name = input('请输入要查找的学员姓名:')
    
        global info
        # 2. 判断学员是否存在:如果输入的姓名存在则显示这位学员信息,否则报错提示
        for i in info:
            if search_name == i['name']:
                print('查找到的学员信息如下:----------')
                print(f"该学员的学号是{i['id']}, 姓名是{i['name']}, 手机号是{i['tel']}")
                break
        else:
            print('该学员不存在')

    显示所有学员信息

    • 需求分析

    打印所有学员信息

    • 代码实现
    # 显示所有学员信息
    def print_all():
        """ 显示所有学员信息 """
        print('学号\t姓名\t手机号')
        for i in info:
            print(f'{i["id"]}\t{i["name"]}\t{i["tel"]}')

    退出系统

    在用户输入功能序号6的时候要退出系统,代码如下:

        ......
        elif user_num == '6':
            exit_flag = input('确定要退出吗?yes or no')
            if exit_flag == 'yes':
                break

    9.4 完整代码

    # 定义功能界面函数
    def info_print():
        print('请选择功能--------------')
        print('1、添加学员')
        print('2、删除学员')
        print('3、修改学员')
        print('4、查询学员')
        print('5、显示所有学员')
        print('6、退出系统')
        print('-' * 20)
    
    
    # 等待存储所有学员的信息
    info = []
    
    
    # 添加学员信息的函数
    def add_info():
        """添加学员函数"""
        # 1. 用户输入:学号、姓名、手机号
        new_id = input('请输入学号:')
        new_name = input('请输入姓名:')
        new_tel = input('请输入手机号:')
    
        # 2. 判断是否添加这个学员:如果学员姓名已经存在报错提示;如果姓名不存在添加数据
        global info
        # 2.1 不允许姓名重复:判断用户输入的姓名 和 列表里面字典的name对应的值 相等 提示
        for i in info:
            if new_name == i['name']:
                print('此用户已经存在')
                # return作用:退出当前函数,后面添加信息的代码不执行
                return
    
        # 2.2 如果输入的姓名不存在,添加数据:准备空字典,字典新增数据,列表追加字典
        info_dict = {}
    
        # 字典新增数据
        info_dict['id'] = new_id
        info_dict['name'] = new_name
        info_dict['tel'] = new_tel
        # print(info_dict)
    
        # 列表追加字典
        info.append(info_dict)
        print(info)
    
    
    # 删除学员
    def del_info():
        """删除学员"""
        # 1. 用户输入要删除的学员的姓名
        del_name = input('请输入要删除的学员的姓名:')
    
        # 2. 判断学员是否存在:存在则删除;不存在提示
        # 2.1 声明info是全局变量
        global info
        # 2.2 遍历列表
        for i in info:
            # 2.3 判断学员是否存在:存在执行删除(列表里面的字典),break:这个系统不允许重名,删除了一个后面的不需要再遍历;不存在提示
            if del_name == i['name']:
                # 列表删除数据 -- 按数据删除remove
                info.remove(i)
                break
        else:
            print('该学员不存在')
    
        print(info)
    
    
    # 修改函数
    def modify_info():
        """修改学员信息"""
        # 1. 用户输入想要修改的学员您的姓名
        modify_name = input('请输入要修改的学员的姓名:')
    
        # 2. 判断学员是否存在:存在修改手机号;不存在,提示
        # 2.1 声明info是全局
        global info
        # 2.2 遍历列表,判断输入的姓名==字典['name']
        for i in info:
            if modify_name == i['name']:
                # 将tel这个key修改值,并终止此循环
                i['tel'] = input('请输入新的手机号:')
                break
        else:
            # 学员不存在
            print('该学员不存在')
    
        # 3. 打印info
        print(info)
    
    
    # 查询学员信息函数
    def search_info():
        """查询学员信息"""
        # 1. 用户输入目标学员姓名
        search_name = input('请输入要查询的学员的姓名:')
    
        # 2. 检查学员是否存在:存在打印这个学员的信息;不存在则提示
        # 2.1 声明info为全局
        global info
        # 2.2 遍历info,判断输入的学员是否存在
        for i in info:
            if search_name == i['name']:
                # 学员存在:打印信息并终止循环
                print('查询到的学员信息如下---------------')
                print(f"学员的学号是{i['id']}, 姓名是{i['name']}, 手机号是{i['tel']}")
                break
        else:
            # 学员不存在的提示
            print('查无此人...')
    
    
    # 显示所有学员信息
    def print_all():
        """显示所有学员信息"""
        # 1. 打印提示字
        print('学号\t姓名\t手机号')
        # 2. 打印所有学员的数据
        for i in info:
            print(f"{i['id']}\t{i['name']}\t{i['tel']}")
    
    
    # 系统功能需要循环使用,直到用户输入6,才退出系统
    while True:
        # 1. 显示功能界面
        info_print()
    
        # 2. 用户输入功能序号
        user_num = int(input('请输入功能序号:'))
    
        # 3. 按照用户输入的功能序号,执行不同的功能(函数)
        # 如果用户输入1,执行添加;如果用户输入2,执行删除... -- 多重判断
        if user_num == 1:
            # print('添加')
            add_info()
        elif user_num == 2:
            # print('删除')
            del_info()
        elif user_num == 3:
            # print('修改')
            modify_info()
        elif user_num == 4:
            # print('查询')
            search_info()
        elif user_num == 5:
            # print('显示所有')
            print_all()
        elif user_num == 6:
            # print('退出系统')
            # 程序要想结束,退出终止while True -- break
            exit_flag = input('确定要退出吗?yes or no')
            if exit_flag == 'yes':
                break
        else:
            print('输入的功能序号有误')
    

    十、lambda表达式

    10.1 lambda的应用场景

    如果一个函数有一个返回值,并且只有一句代码,可以使用 lambda简化。

    10.2 lambda语法

    lambda 参数列表 : 表达式

    注意

    • lambda表达式的参数可有可无,函数的参数在lambda表达式中完全适用。
    • lambda表达式能接收任何数量的参数但只能返回一个表达式的值。

    快速入门

    # 函数
    def fn1():
        return 200
    
    
    print(fn1)
    print(fn1())
    
    
    # lambda表达式
    fn2 = lambda: 100
    print(fn2)
    print(fn2())

    注意:直接打印lambda表达式,输出的是此lambda的内存地址

    10.3 示例:计算a + b

    函数实现

    def add(a, b):
        return a + b
    
    
    result = add(1, 2)
    print(result)

    思考:需求简单,是否代码多?

    lambda实现

    fn1 = lambda a, b: a + b
    print(fn1(1, 2))

    10.4 lambda的参数形式

    无参数

    fn1 = lambda: 100
    print(fn1())

    一个参数

    fn1 = lambda a: a
    print(fn1('hello world'))

    默认参数

    fn1 = lambda a, b, c=100: a + b + c
    print(fn1(10, 20))

    可变参数:*args

    fn1 = lambda *args: args
    print(fn1(10, 20, 30))

    注意:这里的可变参数传入到lambda之后,返回值为元组。

    可变参数:kwargs

    fn1 = lambda **kwargs: kwargs
    print(fn1(name='python', age=20))

    10.5 lambda的应用

    带判断的lambda

    fn1 = lambda a, b: a if a > b else b
    print(fn1(1000, 500))

    列表数据按字典key的值排序

    students = [
        {'name': 'TOM', 'age': 20},
        {'name': 'ROSE', 'age': 19},
        {'name': 'Jack', 'age': 22}
    ]
    
    # 按name值升序排列
    students.sort(key=lambda x: x['name'])
    print(students)
    
    # 按name值降序排列
    students.sort(key=lambda x: x['name'], reverse=True)
    print(students)
    
    # 按age值升序排列
    students.sort(key=lambda x: x['age'])
    print(students)

    十一、高阶函数

    把函数作为参数传入,这样的函数称为高阶函数,高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。

    11.1 体验高阶函数

    在Python中,abs()函数可以完成对数字求绝对值计算。

    abs(-10)  # 10

    round()函数可以完成对数字的四舍五入计算。

    round(1.2)  # 1
    round(1.9)  # 2

    需求:任意两个数字,按照指定要求整理数字后再进行求和计算。

    • 方法1
    def add_num(a, b):
        return abs(a) + abs(b)
    
    
    result = add_num(-1, 2)
    print(result)  # 3
    • 方法2
    def sum_num(a, b, f):
        return f(a) + f(b)
    
    
    result = sum_num(-1, 2, abs)
    print(result)  # 3

    注意:两种方法对比之后,发现,方法2的代码会更加简洁,函数灵活性更高。

    函数式编程大量使用函数,减少了代码的重复,因此程序比较短,开发速度较快。

    11.2 map()

    map(func, lst),将传入的函数变量func作用到lst变量的每个元素中,并将结果组成新的列表(Python2)/迭代器(Python3)返回。

    需求:计算list1序列中各个数字的2次方。

    list1 = [1, 2, 3, 4, 5]
    
    
    def func(x):
        return x ** 2
    
    
    result = map(func, list1)
    
    print(result)  # <map object at 0x0000013769653198>
    print(list(result))  # [1, 4, 9, 16, 25]

    11.3 reduce()

    reduce(func,lst),其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。

    注意:reduce()传入的参数func必须接收2个参数。

    需求:计算list1序列中各个数字的累加和。

    import functools
    
    list1 = [1, 2, 3, 4, 5]
    
    
    def func(a, b):
        return a + b
    
    
    result = functools.reduce(func, list1)
    
    print(result)  # 15

    11.3 filter()

    filter(func, lst)函数用于过滤序列, 过滤掉不符合条件的元素, 返回一个 filter 对象。如果要转换为列表, 可以使用 list() 来转换。

    list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    
    def func(x):
        return x % 2 == 0
    
    
    result = filter(func, list1)
    
    print(result)  # <filter object at 0x0000017AF9DC3198>
    print(list(result))  # [2, 4, 6, 8, 10]