3.28Day09函数

昨日复习：
    utf-8 | ascii: ord()  chr()
    1、模式：
    主模式：
    r:读，目标文件必须存在，否则报错
    w:写，目标文件不存在则创建，存在则清空文件内容
    a:写，目标文件不存在则创建，将游标移至末尾
    x:写，必须自己创建文件，否则报错
    从模式：
    t：文本操作模式（默认），要规定文本的编码格式utf-8
    b:二进制操作模式，不需要规定文件的编码格式
    +:可读可写模式

    rt/rb/rt+/rb+  | w | a

    seek（偏移量，偏移起始位置）：要在b模式下操作，因为偏移量是按照字节进行偏移
    偏移量：正为又便宜，负为左偏移
    偏移起始位置： 0为文件开始位置 | 2为文件末尾位置 | 1为当前位置

    flush()：将内存中的数据刷新到硬盘中

    close()：1、将内存中剩余的数据刷新到硬盘中  2、释放文件资源

    with open('文件路径+文件名（与代码同路径时只需写文件名', '文件操作模式', encoding='utf-8') as '文件的变量名':


函数
    今日内容
        函数的四个组成部分：
            函数名：使用函数的依据
            函数体：实现功能的代码
            函数返回值：功能完成的返回信息
            函数参数：完成功能的必要条件

        1、函数的概念
        2、函数的定义
        3、从函数的组成部分来详细介绍

        重点：定义函数的思想 （*****）

    一、函数的概念
        重复利用的工具
        可以完成特定功能的代码块，函数就是存放代码块的容器

    二、函数的定义
        def fn(money):
            print('你付了%s元’ % money'）
            print('代码1')
            print('代码2')
            reture '函数的返回值'

        def：声明函数的关键词
        fn：函数（变量）名
        （）：参数列表，参数个数可以为0~n个，但（）一定不能丢
        函数体：实现功能的代码
        return：函数的返回值

    三：函数的调用
        重点：先定义，后使用  （*****）
        直接打印函数名，只能看到函数存放代码的内存地址

        1、使用函数：
            函数名：拿到函数的地址
            函数名()：拿到函数的地址，并执行函数中存放的代码块（函数体）   *****
            函数名(参数)：执行函数并传入参数

            函数名()：执行完毕后函数的返回值，返回值就跟普通变量一样，可以直接打印、使用、运算

            def fn(num):
                print('传入的num值：%s' % num)
                return '啦啦啦'

            res = fn(100)
            print(res)
            run ==》
            传入的num值：100
            啦啦啦

        2、函数的返回值
            函数的返回值也称之为函数值，就是函数执行结束后的结果
            可以用变量接收 | 可以直接打印 | 可以直接使用

            函数执行的本质：执行函数体，得到函数返回值

    四、函数的分类

    1、从函数体进行分类
    # 计算
    # 空函数：项目之初，知道项目有哪些功能，但还没有明确功能体，可以用pass进行函数体填充
        def computed()
            pass

    # 非空函数：有函数体
        def add_num(n1, n2):
            '''
            :param n1:第一个数
            :param n2:第二个数
            :return: 第一个数 + 第二个数
            '''
            return n1 + n2

        res = add_num(10, 20)
        print(res)
        run ==》
        30

        a = 50
        b = 10
        res = add_num(a, b)
        run ==》
        60

    2、从参数列表进行分类
    # 无参函数：函数体运行不需要外界提供参数
        def print_msg():
            print('欢迎大家来到老男孩')

        print_msg()
        run ==》
        欢迎大家来到老男孩

    # 有参函数：函数体运行需要外界提供参数
        def print_school_msg(person):
            print('欢迎%s来到老男孩' % person)
        print_school_msg('zdc')
        run ==》
        欢迎zdc来到老男孩

    3、从返回值进行分类
        1、无return
        2、空return
        # 空返回

        3、return一个值
        4、return多个值
        # 值返回


        # 无返回 函数

        # 无return函数 与 空return函数的区别
        空return：可以根据具体情况主动退出函数（像break结束循环一样）
        def fn3(msg):
            print('fn3 第一行逻辑')
            # msg信息不正常：'' | None
            if msg == '' or msg is None:
                return  # 结束函数
            print('msg信息正常: %s' % msg)

        msg = input('msg: ')  # zdc
        fn3(msg)
        run ==》
        fn3 第一行逻辑
        msg信息正常: zdc

        # 值返回 函数
        # 一个值的返回
        def add_num(n1, n2):
            return n1 + n2
        print(add_num(10, 15))
        run ==》
        25

        def computed(n1, n2):
            # 返回四则运算的结果
            r1 = n1 + n2
            r2 = n1 - n2
            r3 = n1 / n2
            r4 = n1 * n2
            return [r1, r2, r3, r4]

        a, b, c, d = computed(50, 25)
        print(a, b, c, d)
        run ==》
        75 25 2.0 1250

        # 多个值的返回: 本质就是返回装有多个值的元组
        def computed_sup(n1, n2):
            # 返回四则运算的结果
            r1 = n1 + n2
            r2 = n1 - n2
            r3 = n1 // n2
            r4 = n1 ** n2
            return r1, r2, r3, r4

        a, b, c, d = computed_sup(50, 25)  # 解压赋值
        print(a, b, c, d)

        res = computed_sup(50, 25)  # 得到的是装有所有结果的元组
        print(res)
        run ==》
        75 25 2 2980232238769531250000000000000000000000000
        (75, 25, 2, 2980232238769531250000000000000000000000000)

    五、函数的嵌套调用
        在一个函数体中调用另一个函数

        # 再解释过程中，不执行函数体，在函数被调用时，函数体才被执行
        def fn1():
            print('fn1 run')
            fn2()

        def fn2():
            print('fn2 run')
            fn3()

        def fn3():
            print('fn3 run')

        # 注：在fn1中调用了fn2，所以调用fn1的逻辑应该在fn2定义之后
        fn1()
        run ==》
        fn1 run
        fn2 run
        fn3 run

        # 案例：用函数实现获取两个数的最大值
        def max_2(n1, n2):  # 取两个数的最大值
            if n1 > n2:
                return n1
            return n2

        print(max_2(200, 30))

        # 获取三个数的最大值
        # def max_3(n1, n2, n3):
        #     if n1 > n2 and n1 > n3:
        #         return n1
        #     if n2 > n1 and n2 > n3:
        #         return n2
        #     return n3

        def max_3(n1, n2, n3):
            m2 = max_2(n1, n2)
            '''
            利用 比两个值大小 的函数 max_2 比出一个大的数来
            再放到max_2中与第三个数比出一个大的数
            '''

            return max_2(m2, n3)

        print(max_3(300, 30, 30))

        # 四个数呢？
        def max_4(n1, n2, n3, n4):
            # 与max_3同理，在其中套进一个三个值比大小的函数
            m2 = max_2(n1, n2)
            return max_3(m2, n3, n4)
        print(max_4(10,30,20,0))

转载于:https://www.cnblogs.com/shuchengyi/articles/10615115.html