• 014python-内置函数

    函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

    函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

    定义一个函数

    你可以定义一个由自己想要功能的函数，以下是简单的规则：

    • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
    • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
    • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
    • 函数内容以冒号 : 起始，并且缩进。
    • return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

    语法

    Python 定义函数使用 def 关键字，一般格式如下：

    默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。 

    def 函数名（参数列表）:
    函数体

    调用：函数名（参数）

     1.函数名明明规范：

    小写字母，不能以数字开头，不同的字母制安用下划线隔开

    def 函数名():

             函数体       # 你希望这个函数去给你实现什么功能

    调用：函数名()

     练习：输出“我是测试”

    1. def ce_shi():
    2.     print('我是测试')
    3.  
    4. ce_shi()

    2.形式参数/位置参数 

    (1)函数名中的参数为形参/位置参数时，调用函数名中的参数是实参

    def 函数名(形参/位置参数):        # 函数名中存在形参

            函数体                                # 可以调用形参或者赋值，如果赋值则以赋值为准

    调用：函数名(实参)                   #当函数名字的参数为形参时，调用函数时实参必传，且以实参为准

     练习1：输出‘huahua是测试’，且函数体调用形参，以实参为准

    1. def ce_shi(name):     # 此时name是形参.调用函数时必须要有参数，可用可不用
    2.     print('{0}是测试'.format(name))    # 调用形参name
    3.  
    4. ce_shi('huahua')      # 'huahua'是实参，当函数名字的参数为形参时，调用函数时实参必传

    练习2：输出‘XXX是测试’，且函数体不调用形参，自己赋值，此时以函数体自己赋值为准

    1. def ce_shi(name):     # 此时name是形参.调用函数时必须要有参数，可用可不用
    2.     print('{0}是测试'.format('暖暖'))    # 可调用形参name，也可自己赋值不调用形参
    3.  
    4. ce_shi('huahua')      # 'huahua'是实参，当函数名字的参数为形参时，调用函数时实参必传

    3.默认参数 

    def 函数名(默认参数名='默认参数值'):        # 函数名中存在默认值

            函数体                                 # 可调用默认参数，也可自己赋值，如果赋值则以赋值为准

    调用：函数名(实参)                    #当函数名为默认参数时，调用函数时以实参为准

    练习1：函数名中存在默认值 且实参也传参时，以实参为准

    1. def ce_shi(name='幺幺'):    # 函数名存在默认值
    2.     print('{0}是测试'.format(name))
    3.  
    4. ce_shi('huahua')      # 'huahua'是实参，当函数名为默认参数时，调用函数时以实参为准

     练习2：函数名中存在默认值 且实参未传参时，以默认参数为准

    1. def ce_shi(name='幺幺'):    # 函数名存在默认值
    2.     print('{0}是测试'.format(name))
    3.  
    4. ce_shi()      # 当函数名为默认参数时，实参可不传值

    练习3：函数名中存在默认值 且实参未传参的同时函数体自己赋值时，以以函数体赋值为准

    1. def ce_shi(name='幺幺'):    # 函数名存在默认值
    2.     print('{0}是测试'.format('暖暖'))    # 可调用默认参数，也可自己赋值，如果赋值则以赋值为准
    3.  
    4. ce_shi()      # 当函数名为默认参数时，实参可不传值

    4.位置参数与默认参数同时使用

    位置参数：没有指定参数时，调用函数时按顺序赋值；

    1. def add(m, n, k):    # 形参
    2.     sum = 0
    3.     for a in range(m, n, k):   # 调用参数
    4.         sum += a
    5.     print(sum)
    6. add(1, 5, 2)   # 实参，# 没有指定参数时，按顺序赋值

     有指定参数值时，调用函数时不是按顺序赋值，需要与def add(m, n, k): 中的参数一致

    1. def add(m, n, k):    # 形参
    2.     sum = 0
    3.     for a in range(m, n, k):   # 调用参数
    4.         sum += a
    5.     print(sum)
    6. add(n=5, m=1, k=2)   # 实参，# 指定参数值时，不是按顺序赋值，需要与def add(m, n, k): 中的参数一致

    5.编写函数三部走

     练习题：请把1-100的练习整数相加功能，写成一个函数：

     第一步：先用代码实现功能，还可以选取一组数据来证明自己的diamante是否镇正确

    1.     sum = 0
    2.     for a in range(1, 101):
    3.         sum += a
    4.     print(sum)

     第二步：变成函数，加def 且调用

    1. def add():
    2.     sum = 0
    3.     for a in range(1, 101):
    4.         sum += a
    5.     print(sum)
    6.  
    7. #方便测试
    8. if __name__ == '__main__':    #主程序的执行入口，只有当前模块下面执行的时候才会执行
    9.     print('主程序的执行入口')
    10.     add()

     第三步：想办法提高代码的复用性

    6.return 

     return不能脱离函数

     1.当调用函数时，会返回一个值 即return后面的表达式

    (1)正常的打印输出到控制台

    1. def add(a, b):
    2.     print(a + b) # 目前只学习了print输出到控制台 
    3.  
    4. add(1, 3)

    (2)使用返回值

    1. def add(a, b):
    2.     print(a + b)
    3.  
    4. add(1, 3) + 10

    （2-1）输出报错：

    TypeError: unsupported operand type(s) for +: 'NoneType' and 'int' ——> 类型错误：不支持+：“NoneType”和“int”的操作数类型

     （2-2）报错原因：

    add(1, 3) 已经被print(a + b)输出到控制台，返回值是“NoneType”

    （2-3）如何解决上述问题：

    此时可以用返回值

    1. def add(a, b):
    2.  
    3.     return(a + b)   # 返a+b的值
    4.  
    5. print(add(1, 3) + 10)   #输出返回值+10

    (3)可以使用存储值

    1. def add(a, b):
    2.  
    3.     return(a + b) # 返a+b的值
    4.  
    5. res = add(1, 3) + 10 # 存储add(1, 3) + 10的值
    6.  
    7. print(res) # 输出存储值

    2.return在函数里面相当于一个结束符，表示函数到此为止，后面的代码不会被执行

    (1)return在函数里面相当于一个结束符，表示函数到此为止，函数里面的代码会被执行：

    1. def add(a, b):
    2.  
    3.     print('函数里面的代码是否会被执行')    #函数里面且return前面的代码被执行
    4.  
    5.     return(a + b)       # 返a+b的值
    6.  
    7. res = add(1, 3) + 10    # 存储add(1, 3) + 10的值
    8.  
    9. print(res) # 输出存储值

    (2)return在函数里面相当于一个结束符，表示函数到此为止，后面的代码不会被执行

    1. def add(a, b):
    2.  
    3.     return(a + b)     # 返a+b的值
    4.  
    5.     print('函数里面的代码是否会被执行')    #函数里面且return后面的代码不被执行
    6.  
    7. res = add(1, 3) + 10     # 存储
    8.  
    9. add(1, 3) + 10的值 print(res)    # 输出存储值

    (3)return在函数里面相当于一个结束符，表示函数到此为止，后面的代码不会被执行，函数外面的代码被执行

    1. def add(a, b):
    2.  
    3.     return(a + b)     # 返a+b的值
    4.  
    5. print('函数里面的代码是否会被执行')    #函数外面的代码被执行
    6.  
    7. res = add(1, 3) + 10     # 存储add(1, 3) + 10的值
    8.  
    9. print(res)     # 输出存储值

     （4）练习：写函数，检查传入的列表的长度，如果大于2，那么仅仅保留前两位长度的内容，并将新内容返回

    1. B = [12, 2, 2, 2]        # 给出一个列表
    2. def check_list(L):
    3.     if len(L) > 2:      # 判断列表长度是否大于2
    4.         n_list = L[0:2]     # 如果列表长度大于2，取列表前两位并赋值给新的变量
    5.         return n_list       # 返回新列表
    6.     else:                   # 如果列表长度小于等于2，直接返回原列表
    7.         return(L)
    8.  
    9. n_list = check_list(B)     # 存储新列表   ,B为实参，L为形参
    10. print(n_list)            # 输出结果

     7.不定长参数/动态参数

    *agrs 为arguments的简写，*不能改变，但是args可以使用其他内容代替

    1.不限制参数的个数和长度

    2.在函数组织内部以元组的形式表示

    1. def make_sandwich(*args):
    2.     # print(args)     # 函数内部表现形式元组('生菜', '鸡蛋')
    3.     all = ''          # 定义一个空值
    4.     for item in args:     # 遍历动态参数，赋值给item 
    5.         all += item       # 给all赋值item
    6.         all += '、'       # 给all赋值、 
    7.     print('您的三明治里面有：'+all)       # 使用拼接将字符串和值输出 
    8.  
    9. make_sandwich('生菜', '鸡蛋')       # 实参

     8.关键字参数

    key -value形式，关键字**kwargs kw -> key word,注意必须加**，kwargs可以换成其他 在函数里面以字典的形式展示

    1. def kw_function(**kwargs):
    2.     print(kwargs)            # 输出内容字典的形式展示
    3.  
    4. kw_function(x=1, y=2)     #key - value

    练习：

    1.不定长参数练习

    1. def add(*L):  #函数名为动态/不定长参数
    2.     sum = 0
    3.     for item in L:   # 遍历参数赋值给item
    4.         sum += item
    5.     print(sum)
    6.  
    7. add(1, 2, 3, 4, 5)   # 实参为位置参数,默认/指定参数要放在位置参数的后面

    2.不定长参数和位置参数一起使用

    1. def add(*l, a):    # 按顺序赋值,参数a为1
    2.     # 当不定长参数后面存在位置参数，实参为位置参数时运行报错：TypeError: add() missing 1 required keyword-only argument: 'a'
    3.     # 报错原因：不定长参数不限制参数个数和长度，可以包含所有参数，此时位置参数a没有值
    4.     # 解决方法：
    5.     # （1）将位置参数a放置在不定长参数前面
    6.     # （2）在实参中给a赋值
    7.     sum = 0
    8.     for item in l:   # 遍历参数赋值给item
    9.         sum += item
    10.     print(a)
    11.     print(sum)
    12.  
    13. add(1, 2, 3, 4, 5)   # 实参为位置参数,默认/指定参数要放在位置参数的后面
    14.  
    15.  
    16.  
    17.  
    18.  
    19. # （1）将位置参数a放置在不定长参数前面
    20. def add(a, *l):    # 按顺序赋值,参数a为1
    21.     sum = 0
    22.     for item in l:   # 遍历参数赋值给item
    23.         sum += item
    24.     print(a)
    25.     print(sum)
    26.  
    27. add(1, 2, 3, 4, 5)   # 实参为位置参数,默认/指定参数要放在位置参数的后面
    28.  
    29.  
    30.  
    31.  
    32. # （2）在实参中给a赋值
    33. def add(*l, a):    # 按顺序赋值,参数a为1
    34.     sum = 0
    35.     for item in l:   # 遍历参数赋值给item
    36.         sum += item
    37.     print(a)
    38.     print(sum)
    39.  
    40. add(1, 2, 3, 4, 5, a=6)   # 实参为位置参数,默认/指定参数要放在位置参数的后面

    3.不定长参数、关键字参数和默认参数一起使用

    1. def add(*l, a, **kwargs):
    2.     sum = 0
    3.     for item in l:   # 遍历参数赋值给item
    4.         sum += item
    5.     print(a)
    6.     print(sum)
    7.     print(kwargs)
    8.  
    9. add(1, 2, 3, 4, 5, a=1, x=6,y=8)   # 实参为位置参数,默认/指定参数要放在位置参数的后面

  • 相关阅读:
    领域驱动设计
    leetcode 101对称二叉树
    vue项目使用electron打包exe桌面程序
    解决方案：解决https页面加载http资源报错
    环形链表问题（判环、求入口点）
    宝宝爱吃手指是饿了吗?
    令人疑惑的Promise相关问题
    C# 变量
    计算机网络408考研 2014
    怎么批量提取文件名字到Excel中？
  • 原文地址：https://blog.csdn.net/weixin_47481102/article/details/126009668