基础语言-第11天-函数基础

函数基础

一、函数的作用

当一个功能需要反复使用的时候,如果没有函数,每次需要这个功能就必须把实现功能的代码写一遍。

如果有函数,实现功能的代码只写一遍(封装成函数),然后在每次需要这个功能的时候调用实现功能的函数。

二、定义

函数是实现某一特定功能的代码的封装。(函数就是将实现某一个或者某一类功能的代码打包,以后在需要包中的

代码对应的功能时不用重新写这段代码,而是使用封装了这段代码的函数)

三、分类

根据这个函数是由谁创建的,将函数分为系统函数和自定义函数两种。

  • 系统函数(别人已经造好的机器):

    由系统创建的函数(python本身就创建好的函数),例如:print、input、type、max、min…

  • 自定义函数(自己造的机器):

    由程序员自己创建的函数

四、函数创建

  • 语法

    def 函数名(形参列表):
        函数说明文档
        函数体
    
  • 说明

    扫描二维码关注公众号,回复: 14490554 查看本文章

    1.def:关键字;固定写法

    2.函数名:

    • 由程序员自己命名

    • 两个要求:是标识符;不是关键字

    • 三个规范:

      a.见名知义(看到函数名就知道函数的功能是什么);

      b.所有的字母都小写,多个单词用下划线隔开;

      c.不使用系统的函数名、类名和模块。

    3.():固定写法

    4.形参列表:

    • 以’变量名1,变量名2,变量名3, …'的形式存在,根据情况变量的数据可以为0(每一个变量就是一个形参)

    • 形参的作用:将函数外部的数据传递到函数里面。

    • 确定形参的方法:看实现函数的功能需不需要额外的数据,需要多少个额外的数据。

    5.函数说明文档:多行注释(相当于生活中机器的说明书)

    6.函数体:

    • 结构上,和def保持一个缩进的一条或者多条语句
    • 逻辑上,函数体就是实现函数功能的代码。
  • 例子

    # 1.定义一个函数求一个数的阶乘
    def factorial(num):
        """
        (功能说明区)求一个数的阶乘:num!
        :param num: (参数说明)求阶乘的对象
        :return: (返回值说明)
        """
        sum1 = 1
        for i in range(1, num + 1):
            sum1 *= i
        print(f'阶乘为:{
            
            sum1}')
    factorial(10)    # 阶乘为:3628800
    
    # 2.定义一个函数求两个数的乘积
    def product(a, b):
        print(f'{
            
            a} * {
            
            b} = {
            
            a * b}')
    product(3, 45)    # 3 * 45 = 135
    
    # 3.定义一个函数,删除列表中所有的空值(包括None,和其他空值(比如空字符串、空列表、空元组等))
    def delete_null_value(list1):
        """
        删除列表中所有的空值
        :param list1:
        :return:
        """
        for i in list1[:]:
            if not i and (i != 0):
                list1.remove(i)
        print(f'删除空值后的列表为:{
            
            list1}')
    
    list1 = ['', {
          
          }, 1, None, (), 'abc', 0]
    delete_null_value(list1)    # 删除空值后的列表为:[1, 'abc', 0]
    

五、函数调用

  • 语法

    函数名(实参列表)
    
  • 说明

    1.函数名:需要哪个函数对应的功能就调用哪个函数;想要调用哪个函数就写哪个函数的函数名。函数名必须

    是已经定义过的函数的函数名。

    2.():固定写法。

    3.实参列表:

    • 以’数据1,数据2,数据3,…'的形式存在,这儿的每个数据就是一个实参。(实参对应的数据可以是任何有结

      果的表达式)。

    • 实参是用来给形参赋值的。在提供实参的时候要保证和形参一一对应。

  • 调用过程 - 可以在每一步执行代码的网址上查看

    1.回到函数定义的位置

    2.传参(用实参给形参赋值,传参的时候必须保证每个形参都有值)

    3.执行函数体

    4.确定函数返回值

    5.回到函数调用的位置,接着往后执行

    def func4(x,  y, z):
        print(f'x:{
            
            x}, y:{
            
            y}, z:{
            
            z}')
    
    func4(100, 200, 300)
    print('end!')
    

六、函数的参数

  • 位置参数和关键字参数 - 根据实参的提供方式分类

    1.位置参数:以’实参1,实参2,实参3,…'的形式存在,让实参和形参从位置上一一对应。

    2.关键字参数:以’形参1 = 实参1,形参2 = 实参2,…‘的形式存在,通过’='将实参和形参对应。

    **注意:**位置参数和关键字参数可以一起用,但是必须保证位置参数在关键字参数的前面。

    def func1(x,  y, z):
        print(f'x:{
            
            x}, y:{
            
            y}, z:{
            
            z}')
    
    func1(100, 200, 300)   # x:100, y:200, z:300
    func1(200, 100, 300)    # x:200, y:100, z:300
    
    func1(x=10, y=20, z=30)   # x:10, y:20, z:30
    func1(y=20, x=10, z=30)   # x:10, y:20, z:30
    
    func1(10, y=20, z=30)   # x:10, y:20, z:30
    func1(10, z=30, y=20)   # x:10, y:20, z:30
    
    # func1(x=10,20,z=30)    # 报错!
    
  • 参数默认值

    1.定义函数的时候可以通过 ‘形参名=数据’ 的方式给形参赋默认值;

    2.在调用函数的时候,有默认值的参数可以不用传参。

    3.如果想跳过前面有默认值的参数,直接给后面的参数赋值,使用关键字参数传参。

    **注意:**定义函数时,如果一个函数有的参数有默认值有的没有,没有默认值的形参必须在有的形参的前面。

    def func2(x=10, y=20, z=30):
        """
        不传参 - > x=10, y=20, z=30
        """
        print(f'x:{
            
            x}, y:{
            
            y}, z:{
            
            z}')
    
    func2()    # x:10, y:20, z:30
    func2(100)    # x:100, y:20, z:30
    
    # 如果想跳过前面有默认值的参数,直接给后面的参数赋值,使用关键字参数传参。
    func2(z=100)    # x:10, y:20, z:100
    
    
  • 参数类型说明

    1.没有默认值参数的类型说明:直接在形参后面加’:类型名’

    2.有默认值的参数,默认值数据对应的类型就是这个形参的类型

    3.() -> 类型名:返回值数据类型

    def func6(x: str, y='') -> str:
        return x.strip()
    func6()
    
  • *对应的不定长参数

    1.参数个数不确定可以使用不定长参数

    • 定义函数的时候,如果在某一个形参前面加*,那么这个形参就会变成一个不定长参数,它可以接收多个

      实参(可以是0个,1个,2个,3个,4个,…)。

    • 带*的不定长参数本质是一个元组,它接收的所有实参是元组中的元素。

    # 示例:定义函数求多个数的和
    def sumN(*nums):
        sum1 = 0
        for i in nums:
            sum1 += i
        print(sum1)
        # print(sum(nums))
    # sumN()
    sumN(10, 20)
    sumN(10, 20, 30)
    
    # 优化:求和的时候至少两个参数
    def sumN(num1, num2, *nums):
        sum1 = num1 + num2
        for i in nums:
            sum1 += i
        print(sum1)
        # print(sum(nums))
    # sumN()
    sumN(10, 120)
    sumN(10, 120, 30)
    

    2.定义函数的时候单独使用*

    如果定义函数的时候,形参列表中有一个独立的*,调用函数时,*后面的形参必须使用关键字传参。
    
    def func7(x, *, y, z):
        """y和z必须使用关键字传参"""
        pass
    func7(1, y=4, z=8)
    
    
    def func8(x, *y, z, t):
        print(x, y)
        print(z, t)
    func8(10, 27, 9, z=100, t=19)
    

猜你喜欢

转载自blog.csdn.net/simple_daytime/article/details/126106264