• Python第二语言（三、Python函数def）

    目录

    1. Python函数（def 函数名():）

    1.1 sorted对容器进行排序：无法指定排序规则

    1.2 sort对容器自定义排序：可以指定排序规则

    1.3 获取变量长度函数（len）

    1.4 函数的定义

    1.5 函数-传参定义

    1.6 函数的说明文档（阅读代码效率低下，使用注释）

    1.7 函数的嵌套调用（函数中，再次调用其他函数）

    1.8 变量作用域

    2. Python函数进阶

    2.1 函数的多返回值

    2.2 函数的多种传参方式

    2.3 匿名函数lambda关键字

    导航：

    Python第二语言（一、Python start）-CSDN博客

    Python第二语言（二、Python语言基础）-CSDN博客

    Python第二语言（三、Python函数def）-CSDN博客

    Python第二语言（四、Python数据容器）-CSDN博客

    Python第二语言（五、Python文件相关操作）-CSDN博客

    Python第二语言（六、Python异常）-CSDN博客

    Python第二语言（七、Python模块）-CSDN博客

    Python第二语言（八、Python包）-CSDN博客

    Python第二语言（九、Python第一阶段实操）-CSDN博客

    Python第二语言（十、Python面向对象（上））-CSDN博客

    Python第二语言（十一、Python面向对象（下））-CSDN博客

    Python第二语言（十二、SQL入门和实战）-CSDN博客

    Python第二语言（十三、PySpark实战）-CSDN博客

    Python第二语言（十四、高阶基础）-CSDN博客

    1. Python函数（def 函数名():）

    1.1 sorted对容器进行排序：无法指定排序规则
    1. arr = [5, 4, 3, 2, 1]
    2. # 默认按照从小到大的方式进行排序
    3. print(sorted(arr))
    '
    运行

    1.2 sort对容器自定义排序：可以指定排序规则

    • 使用方式：

      列表.sort（key=选择排序依据的函数，reverse=TruelFalse）

      • 参数key，是要求传入一个函数，表示将列表的每一个元素都传入函数中，返回排序的依据；
      • 参数reverse，是否反转排序结果，True表示降序，False表示升序；

    列表的sort方法: 

    1. my_list = [["a", 33], ["b", 11], ["c", 55]]
    2.  
    3. def choose_sort_key(element):
    4.     return element[1]
    5.  
    6. # 按照choose_sort_key的值reverse=True降序来排序,False为升序
    7. my_list.sort(key=choose_sort_key, reverse=True)
    8. print(my_list)
    '
    运行

    lambda简写形式: 

    1. # 简写
    2. my_list = [["a", 33], ["b", 11], ["c", 55]]
    3. # 按照choose_sort_key的值reverse=True降序来排序,False为升序
    4. my_list.sort(key=lambda element: element[1], reverse=True)
    5. print(my_list)
    '
    运行

    1.3 获取变量长度函数（len）

    print(len("张三你好"))

    1.4 函数的定义
    1. def fun_name(parm):
    2.     parm = 1
    3.     return parm
    4.  
    5. def 函数名(传入参数):
    6.     函数体
    7.     return 返回值
    '
    运行

    调用函数: 

    1.5 函数-传参定义
    • 函数定义中，提供的x和y，称之为：形式参数(形参)，表示函数声明将要使用2个参数：
      • 参数之间使用逗号进行分隔；
    • 函数调用中，提供的5和6，称之为:实际参数(实参)，表示函数执行时真正使用的参数值：
      • 传入的时候，按照顺序传入数据，使用逗号分隔；

    def(param)函数传参：

    1. def add(x, y):  # 形参
    2.     print(x + y)
    3.     return x + y
    4.  
    5.  
    6. # 函数调用传参 实参
    7. add(5, 5)
    '
    运行

    return返回值: 

    1. 函数在执行完后，返回给调用者的结果；
    2. 使用return关键之来返回结果；
    3. 函数体中在遇到return后就结束了，所以写在return之后的代码不会执行；

    None（函数中没有写return，那么就默认是None类型的）

    1. None是类型'NoneType'的字面量，用于表示：空的，无意义的；
    2. 函数在不适用return语句时就返回None，或主动使用return None；
    3. 场景：变量定义;函数返回值；if判断；
    1. # 1.None用于声明无初始内容的变量
    2. name = None
    3.  
    4.  
    5. def add(num):
    6.     if num > 3:
    7.         return num
    8.     return None  # 2.函数返回值
    9.  
    10.  
    11. # 函数调用传参
    12. result = add(2)
    13.  
    14. if not result:
    15.     # 3.进入if表示result是None值,也就是False
    16.     print("函数体处于None")
    '
    运行

    1.6 函数的说明文档（阅读代码效率低下，使用注释）
    1. def add(num):
    2.     """
    3.     
    4.     :param num:
    5.     :return:
    6.     """
    7.     if num > 3:
    8.         return num
    9.     return None
    '
    运行

    1.7 函数的嵌套调用（函数中，再次调用其他函数）
    1. # 内嵌函数
    2. def add1():
    3.     print(1)
    4.     add2()
    5.  
    6.  
    7. def add2():
    8.     print(2)
    9.     add3()
    10.  
    11.  
    12. def add3():
    13.     print(3)
    14.  
    15.  
    16. # 调用函数
    17. add1()
    '
    运行

    1.8 变量作用域

    局部变量: 

    变量作用域指的是变量的作用范围；（变量在哪里可用，在哪里不可用)

    主要分为两类：局部变量和全局变量：

    1. 局部变量：是定义在函数体内部的变量，即只在函数体内部生效：

    • 局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量；

    2. 全局变量：指的是在函数体内、外都能生效的变量；

    1. num = 10  # 定义全局变量
    2.  
    3.  
    4. def test_a():
    5.     print(num)  # 访问全局变量
    6.  
    7.  
    8. def test_b():
    9.     print(num)  # 访问全局变量
    10.  
    11.  
    12. test_a()
    13. test_b()
    '
    运行

            变量使用的时候，如果在函数内又重置了一个变量，那此时这个变量又变成了局部变量，仅在当前函数中可用，并不会改变全局的变量；

    1. num = 10  # 定义全局变量
    2.  
    3.  
    4. def test_a():
    5.     num = 20  # num现在是个局部变量,不会影响到全局变量
    6.     print(num)  # 访问全局变量
    7.  
    8.  
    9. test_a()
    10. print("全局变量:" + str(num))
    '
    运行

    global将局部变量定义成全局变量: 

    在函数内部定义了global全局变量，那么最终结果会被改变；

    1. num = 10  # 定义全局变量
    2.  
    3.  
    4. def test_a():
    5.     global num  # global声明num是个全局变量
    6.     num = 20
    7.     print(num)  # 访问全局变量
    8.  
    9.  
    10. test_a()
    11. print("全局变量:" + str(num))
    '
    运行

    2. Python函数进阶

    2.1 函数的多返回值
    1. def test_return():
    2.     return 1, 2
    3.  
    4.  
    5. x, y = test_return()
    6. print(x)  # 结果1
    7. print(y)  # 结果2
    '
    运行

    2.2 函数的多种传参方式

    1. 函数的多种传参方式: 

    1. 位置参数；
    2. 关键字参数；
    3. 缺省参数；
    4. 不定长参数；

    2. 位置传参（根据参数的位置传参）

    • 注意：传递的参数和定义的参数的顺序及个数必须一致；
    1. # 位置参数：调用函数时根据函数定义的参数位置来传递参数
    2. def user_info(name, age, gender):
    3.     print(f'我的名字是{name}, 年龄是{age}, 性别是{gender}')
    4.  
    5.  
    6. user_info('yiyi', 20, '男')
    '
    运行

    3. 关键字传参（根据参数的名字传参，也可与位置传参 混合传参）

    • 注意：函数调用时，如果有位置参数，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序；
    1. # 关键字参数：函数调用时通过"键=值"形式传递参数
    2. def user_info(name, age, gender):
    3.     print(f'我的名字是{name}, 年龄是{age}, 性别是{gender}')
    4.  
    5.  
    6. # 关键字传参
    7. user_info(name="yiyi", age=20, gender="男")
    8. # 可以不按照固定顺序
    9. user_info(age=20, gender="男", name="yiyi")
    10. # 可以和位置参数混用，位置参数必须在前，且匹配参数顺序
    11. user_info("yiyi", age=20, gender="男")
    '
    运行

    4. 默认参数 || 缺省参数 （默认给参数传递一个值，如若不传参默认是原本的参数）

    • 注意：函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值；
    1. def user_info(name, age, gender="男"):
    2.     print(f'我的名字是{name}, 年龄是{age}, 性别是{gender}')
    3.  
    4.  
    5. user_info("yiyi", 20)
    6. user_info("zhangsan", 18, "女")
    '
    运行

    5. 不定长参数（可通过*（*默认位置传参） 或者 ** （**字典传参，需要键值对）不定义长度的参数传递）

    • 不定长参数：不定长参数也叫可变参数，用于不确定调用的时候会传递多个参数（不传参也可以）的场景；
    • 作用：当调用函数时不确定参数个数时，可以使用不定长参数；
    • 不定长参数的类型：
    1. 位置传递；
    2. 关键字传递；

    位置传递不定长参数 *args （需要传递的形式为元组tuple形式）: 

    • 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple），args是元组类型，这就是位置传递；
    1. # 不定长参数
    2. def user_info(*args):
    3.     print(args)
    4.  
    5. user_info('yiyi')
    6. user_info('zhangsan', 18)
    '
    运行

    关键字传递不定长参数（需要传递的形式为字典dict()形式）

    参数是"键=值"形式的情况下，所有的"键=值"都会被kwargs接受，同时会根据"键=值"组成字典；

    1. def user_info(**kwargs):
    2.     print(kwargs)
    3.  
    4. # {'name': 'yiyi', 'age': 18, 'id': 120}
    5. user_info(name='yiyi', age=18, id=120)
    '
    运行

    2.3 匿名函数lambda关键字

    1. 函数作为参数传递（可以将函数当作参数一样，传递给其它函数）

    • 函数本身是可以作为参数，传入另一个函数中进行使用的；
    • 将函数传入的作用在于：传入计算逻辑，而非传入数据；
    • 在代码中，不仅仅是相加，相减、相除等如何逻辑都可以自定义并作为函数传入；

    案例：

    1. def test_func(compute):
    2.     result = compute(1, 2)
    3.     print(result)
    4.  
    5.  
    6. # 将函数当作参数传入到函数中
    7. def compute(x, y):
    8.     return x + y
    9.  
    10.  
    11. test_func(compute)
    '
    运行

    2. lambda匿名函数（lamdba 参数，参数 : 逻辑代码，只能写一行）临时函数，只可写一次的匿名函数；

    • 定义：
      • def关键字，可以定义带有名称的函数；
      • lambda关键字，可以定义匿名函数（无名称）

    有名称的函数，可以基于名称重复使用；

    无名称的匿名函数，只可临时使用一次；

    使用def和使用lambda，定义的函数功能完全一致，只是lambda关键字定义的函数是匿名的，无法二次使用；

    • 注意：
      • 匿名函数用于临时构建一个函数，只用一次的场景；
      • 匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数；
    1. # 通过def关键字，定义一个函数，并传入
    2. def test_func(compute):
    3.     result = compute(1, 2)
    4.     print(result)
    5.  
    6.  
    7. # 通过lambda关键字，传入一个一次性使用的lambda匿名函数
    8. test_func(lambda x, y: x + y)  # 结果为3
    '
    运行

  • 相关阅读:
    【计算机网络】深度学习使用应用层的HTTP协议
    StatusBar，状态栏设置中文
    探讨mfc100u.dll丢失的解决方法，修复mfc100u.dll有效方法解析
    Android网络通讯之Retrofit
    双链表的插入和删除
    使用Postern实现Android设备的全局代理优劣势分析
    基于优化的多核局部费舍尔判别分析的故障分类
    如何快速接手做到一半的项目？
    关系数据库设计规范化
    (2)多线程-线程的常用方法与生命周期
  • 原文地址：https://blog.csdn.net/weixin_63514301/article/details/139484587