【Python使用】嘿马python基础入门全体系教程第9篇：高阶函数,函数应用：学生管理系统【附代码文档】

本教程的知识点为：计算机组成 计算机是由什么组成的？ 1. 硬件系统： 2. 软件系统： 目标 运算符的分类 1. 算数运算符 2. 赋值运算符 3. 复合赋值运算符 判断语句和循环语句 if嵌套 1. if嵌套的格式 2. if嵌套的应用 if嵌套执行流程 容器：字符串、列表、元组、字典 字符串介绍 一. 认识字符串 1.1 字符串特征 字符串输出 容器：字符串、列表、元组、字典 列表的相关操作 1添加元素("增"append, extend, insert)1 append extend 容器：字符串、列表、元组、字典 字典的常见操作1 1查看元素1 2修改元素2 3添加元素3 函数介绍 1什么是函数1 小总结: 函数定义和调用 1定义函数1 多函数程序的基本使用流程 1. 使用全局变量 2. 使用函数的返回值、参数 3. 函数嵌套调用 函数返回值(二) 函数应用：学生管理系统 递归函数 1什么是递归函数1 2递归函数的作用2 看阶乘的规律 文件操作介绍 1什么是文件1 2文件的作用2 文件的打开与关闭 1打开文件1 面向对象编程介绍 面向对象 1. 概述 2. 生活举例 类和对象 init()方法 说明： 问题： 有参数的__init__()方法 说明： 继承介绍以及单继承 1. 现实中的继承 2. 程序中的继承 单继承：子类只继承一个父类 说明： super()的使用 问题： 知识点： 私有权限 面向对象三大特性：封装、继承、多态 静态方法和类方法 1. 类方法 2. 静态方法 总结 异常 模块 1Python中的模块1 2import2 3from…import3 注意

完整笔记资料代码：https://gitee.com/yinuo112/Backend/tree/master/Python/嘿马python基础入门全体系教程/note.md

感兴趣的小伙伴可以自取哦~

---

全套教程部分目录：

---

部分文件图片：

函数应用：学生管理系统

import time
import os

  
  
# 定一个列表，用来存储所有的学生信息(每个学生是一个字典)
  
  
info_list = []


def print_menu():
    print("---------------------------")
    print("      学生管理系统 V1.0")
    print(" 1:添加学生")
    print(" 2:删除学生")
    print(" 3:修改学生")
    print(" 4:查询学生")
    print(" 5:显示所有学生")
    print(" 6:退出系统")
    print("---------------------------")


def add_new_info():
    """添加学生信息"""
    global info_list

    new_name = input("请输入姓名:")
    new_tel = input("请输入手机号:")
    new_qq = input("请输入:")

    for temp_info in info_list:
        if temp_info['name'] == new_name:
            print("此用户名已经被占用,请重新输入")
            return  # 如果一个函数只有return就相当于让函数结束，没有返回值

    # 定义一个字典，用来存储用户的学生信息(这是一个字典)
    info = {}

    # 向字典中添加数据
    info["name"] = new_name
    info["tel"] = new_tel
    info["qq"] = new_qq

    # 向列表中添加这个字典
    info_list.append(info)


def del_info():
    """删除学生信息"""
    global info_list

    del_num = int(input("请输入要删除的序号:"))
    if 0 <= del_num < len(info_list):
        del_flag = input("你确定要删除么?yes or no")
        if del_flag == "yes":
            del info_list[del_num]
    else:
        print("输入序号有误,请重新输入")


def modify_info():
    """修改学生信息"""
    global info_list

    modify_num = int(input("请输入要修改的序号:"))
    if 0 <= modify_num < len(info_list):
        print("你要修改的信息是:")
        print("name:%s, tel:%s, :%s" % (info_list[modify_num]['name'],
            info_list[modify_num]['tel'],info_list[modify_num]['qq']))
        info_list[modify_num]['name'] = input("请输入新的姓名:")
        info_list[modify_num]['tel'] = input("请输入新的手机号:")
        info_list[modify_num]['qq'] = input("请输入新:")
    else:
        print("输入序号有误,请重新输入")


def search_info():
    """查询学生信息"""
    search_name = input("请输入要查询的学生姓名:")
    for temp_info in info_list:
        if temp_info['name'] == search_name:
            print("查询到的信息如下:")
            print("name:%s, tel:%s, :%s" % (temp_info['name'],
                temp_info['tel'], temp_info['qq']))
            break
    else:
        print("没有您要找的信息....")


def print_all_info():
    """遍历学生信息"""
    print("序号\t姓名\t\t手机号\t\t")
    i = 0
    for temp in info_list:
        # temp是一个字典
        print("%d\t%s\t\t%s\t\t%s" % (i, temp['name'], temp['tel'], temp['qq']))
        i += 1


def main():
    """用来控制整个流程"""
    while True:
        # 1. 打印功能
        print_menu()

        # 2. 获取用户的选择
        num = input("请输入要进行的操作(数字)")

        # 3. 根据用户选择,做相应的事情
        if num == "1":
            # 添加学生
            add_new_info()
        elif num == "2":
            # 删除学生
            del_info()
        elif num == "3":
            # 修改学生
            modify_info()
        elif num == "4":
            # 查询学生
            search_info()
        elif num == "5":
            # 遍历所有的信息
            print_all_info()
        elif num == "6":
            # 退出系统
            exit_flag = input("亲,你确定要退出么?~~~~(>_<)~~~~(yes or no) ")
            if exit_flag == "yes":
                break
        else:
            print("输入有误,请重新输入......")


        input("\n\n\n按回车键继续....")
        os.system("clear")  # 调用Linux命令clear完成清屏

  
  
# 程序的开始
  
  
main()

递归函数

<1>什么是递归函数1>

通过前面的学习知道一个函数可以调用其他函数。

如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

<2>递归函数的作用2>

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n

解决办法1:

看阶乘的规律

1! = 1
2! = 2 × 1 = 2 × 1!
3! = 3 × 2 × 1 = 3 × 2!
4! = 4 × 3 × 2 × 1 = 4 × 3!
...
n! = n × (n-1)!

解决办法2:

原理

总结

• 函数内部自己调用自己
• 必须有终止条件(即必须有出口)

1. 匿名函数

大家来思考一个问题:

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

my_add()

my_add 函数需要2行定义, 能不能简化一下定义方式, 一行搞定! 当然可以， 我们可以把这种函数写成一个 匿名函数.

• 匿名函数的概念
• 匿名函数语法格式
• 匿名函数和普通函数的区别
• 匿名函数的使用场景

1.1 语法格式

定义的函数没有名字,这样的函数叫做匿名函数.

我们先看下匿名函数的语法结构:

lambda [形参1], [形参2], ... : [单行表达式] 或 [函数调用]

使用匿名函数, 上面的函数我们就可以定义为单行的函数.

  
  
# 不带参数
  
  
my_fun = lambda : 10 + 20
  
  
# 带参数
  
  
my_add = lambda a, b: a + b
my_add()

注意:

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

1.2 和普通函数的区别

def my_function(start, end):

    my_sum = 0

    while start <= end:
        my_sum += start
        start += 1

    return my_sum

1. 匿名函数中不能使用 while 循环、for 循环, 只能编写单行的表达式，或函数调用, 普通函数都可以.
2. 匿名函数中返回结果不需要使用 return, 表达式的运行结果就是返回结果, 普通函数返回结果必须 return.
3. 匿名函数中也可以不返回结果. 例如: lambda : print('hello world')

1.3 应用场景

1.3.1 定义简单的单行函数

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

使用 lambda 定义格式如下:

my_function = lambda a, b: a + b

1.3.2 作为函数的参数进行传递(重点、难点, 扩展点)

1.3.2.1 为什么函数要作为另外函数的参数?

def my_function1():

    a = 100
    b = 200
    result = a + b
    print('result:', result)


def my_function2():

    a = 100
    b = 200
    result = a - b
    print('result:', result)


def my_function3():

    a = 100
    b = 200
    result = a * b
    print('result:', result)

上面函数定义的缺点是:

1. 函数名要定义多个, 使用起来不方便. 需要记忆, 那个函数完成什么事情.
2. 上面函数只定义了三种计算方式: a + b、a -b、a * b, 如果用户希望 a 和 b 进行除法运算, 那么显然还需要再写函数.

解决目标: 1、提高函数的通用性 2、减少代码量

可以通过传递给 my_function 一个函数来完成.

def my_function(func):

    a = 100
    b = 200
    # 把 cucalate_rule 当做函数来调用
    result = func(a, b)
    print('result:', result)


def caculate_rule(a, b):
    return a / b


my_function(caculate_rule)

1.3.2.2. 匿名函数做为函数参数

def my_function(func):

    a = 100
    b = 200
    # 把 cucalate_rule 当做函数来调用
    result = func(a, b)
    print('result:', result)


def caculate_rule1(a, b):
    return a / b

def caculate_rule2(a, b):
    return a // b

def caculate_rule3(a, b):
    return a % b

my_function(caculate_rule1)
my_function(caculate_rule2)
my_function(caculate_rule3)

我们为了调用 my_function 函数要写很多规则, 整个文件中可能就有很多定义的函数代码, 问题是:

1. 这些函数只会用一次
2. 这些函数也比较简单

就没有必要 py 文件中出现这么多无用的代码. 如何改进:

def my_function(func):

    a = 100
    b = 200
    # 把 cucalate_rule 当做函数来调用
    result = func(a, b)
    print('result:', result)


my_function(lambda a, b: a / b)
my_function(lambda a, b: a // b)
my_function(lambda a, b: a % b)

1.3.2.3. 总结

1. 函数可以做为参数传递给另外一个函数, 可以使得函数的实现更加通用.
2. 匿名函数也可以作为参数传递给另外一个函数, 对于只需要用到一次函数, 可以通过匿名函数减少代码量.

1.3.3 lambda的参数形式

1.3.3.1.无参数

fn1 = lambda: 100
print(fn1())

1.3.3.2.一个参数

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

1.3.3.3.默认参数

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

1.3.3.4.可变参数：*args

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

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

1.3.3.5.可变参数：**kwargs

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

1.3.4. lambda的应用

1.3.4.1. 带判断的lambda

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

1.3.4.2. 列表数据按字典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)

高阶函数

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

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的代码会更加简洁，函数灵活性更高。

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

4.2 内置高阶函数

1. map 用法

map(function, list) 会根据提供的函数对指定序列做映射.

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表.

计算每一个元素的平方值:

my_list = [1, 2, 3, 4, 5]


def f(x):
    return x ** 2


result = map(f, my_list)
print(type(result), result, list(result))

输出结果:

<class 'map'> <map object at 0x000000C9729591D0> [1, 4, 9, 16, 25]

示例解释:

首字母大写:

my_list = ['smith', 'edward', 'john', 'obama', 'tom']


def f(x):
    return x[0].upper() + x[1:]


result = map(f, my_list)
print(list(result))

输出结果:

['Smith', 'Edward', 'John', 'Obama', 'Tom']

2. reduce 用法

reduce(function, list) 函数会对参数序列中元素进行累计.

函数将一个数据集合中的所有数据进行下列操作:

1. 用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作.
2. 得到的结果继续和序列的下一个元素做累积计算, 最终得到一个结果.

计算列表中的累加和:

import functools

my_list = [1, 2, 3, 4, 5]


def f(x1, x2):
    return x1 + x2


result = functools.reduce(f, my_list)
print(result)

输出结果:

15

示例解释:

3. filter 用法

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

该接收两个参数, 第一个为函数, 第二个为序列, 序列的每个元素作为参数传递给函数进行判断, 然后返回 True 或 False, 最后将返回 True 的元素放到新列表中.

过滤列表中的偶数:

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def f(x):
    return x % 2 == 0


result = filter(f, my_list)
print(list(result))

输出结果:

[2, 4, 6, 8, 10]

示例解释:

过滤列表中首字母为大写的单词:

my_list = ['edward', 'Smith', 'Obama', 'john', 'tom']


def f(x):
    return x[0].isupper()


result = filter(f, my_list)
print(list(result))

输出结果:

['Smith', 'Obama']