【Python基础知识库】Python中的参数类型

╰半夏微凉° 2023-02-23 03:39 28阅读 0赞

## python中参数类型有哪些 ##

*  位置参数：也叫必备参数，指函数调用时，传入的实参数量和位置、类型必须与函数定义时保持一致，即形参和实参的位置数量必须一致

# 在调用func函数时，必须按位置传入name和age，多了少了都不行，否则会抛出TypeError异常
    def func(name, age):
        """
        :param name: str
        :param age: int
        :return: tuple
        """
        print(name, age)
    
    func('lucy' ,18)
    func(*('lucy' ,18))  # 使用*解构
    
    # 结果
    '''
    lucy 18
    lucy 18
    '''

*  默认参数
    
     *  函数定义时，为参数设置一个默认值，当函数调用时，没有传入这个参数值，直接使用这个默认值。指定有默认值的形参，必须是在没有默认值的参数的最后，否则会产生语法错误；而且默认参数必须指向不可变对象，如果指向可变对象，多次调用时，可能得到的不是意料之内的结果
    
        def func(x, y=0):
          """
          :param x: int
          :param x: int
          :return:
          """
          return x + y
        
        print(func(3))  # 传入参数x=3
        print(func(3, 4))  # 传入参数x=3, y=4
        
        # 结果
        '''
        3
        7
        '''
 *  关键字参数：函数调用时，是指使用形式参数的名字来确定输入的参数值,（形参的名字=输入的参数值），通过此方式指定函数实参时，不再需要与形参的位置完全一致，只要将参数名写正确即可；使用位置参数和关键字参数混合传参的方式时，关键字参数必须位于所有的位置参数（即前面必须传位置参数，最后在传关键字参数，位置得对应）。

def func(x, y):
        """
        :param x: int
        :param x: int
        :return:
        """
        return x + y
    
    print(func(3, 4))  # 位置参数
    print(func(x=3, y=4))  # 关键字参数
    print(func(y=4, x=3))  # 关键字参数，位置改变
    print(func(3, y=4))  # 位置参数与关键字混合
    
    # 结果
    '''
    7
    7
    7
    7
    '''

*  可变位置参数：定义参数时前面加一个\*，表示这个参数是可变的，可以接受任意多个参数，这些参数构成一个元组，只能通过位置参数传递。

# 可以接收不定参数，返回的类型是元组
    def func(*args):
        """
        :param args:
        :return:
        """
        print(type(args))
        sum = 0
        for i in args:
            sum += i
        return sum
    
    print(func(1, 2, 3))
    print(func(*(1, 2, 3)))  # 使用*解构
    
    # 结果
    '''
    <class 'tuple'>
    6
    <class 'tuple'>
    6
    '''

*  可变关键字参数：定义参数时，在前面加\*\*，`**kwargs`表示这个参数可变，可以接受零个或多个关键字参数，并以字典的形式传入函数体，关键字为字典的key，关键字绑定的值为value，如果可变关键字没有接收到任何参数，则传入函数体一个空字典\{\}。

# 只接收可变关键字参数
    def func(**kwargs):
        """
        :param kwargs:
        :return:
        """
        kwargs_type = (str(type(kwargs))).split("'")[1]
        print("kwargs: 类型为{0}, 值为{1}".format(kwargs_type, kwargs))
    
    func()  # 未传任何参数，返回空字典
    func(x=1, y=2, z=3)  # 关键字对传参
    func(**{
        'x': 1, 'y': 2, 'z': 3})  # 使用**解包字典
    
    # 结果
    '''
    kwargs: 类型为dict, 值为{}
    kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3}
    kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3}
    '''
    
    # 可变位置参数与可变关键字参数一起使用，这是可变位置参数必须在前面
    def func(*args, **kwargs):
        """
        :param args:
        :param kwargs:
        :return:
        """
        args_type = (str(type(args))).split("'")[1]
        kwargs_type = (str(type(kwargs))).split("'")[1]
        print("args: 类型为{0}, 值为{1}".format(args_type, args))
        print("kwargs: 类型为{0}, 值为{1}".format(kwargs_type, kwargs))
    
    print("未传任何参数：")
    func()  # 未传任何参数，返回args为空元组，kwargs我空字典
    print("只传入可变位置参数：")
    func(1, 2, 3)
    print("只传入可变关键字参数：")
    func(x='a', y='b', z='c')
    print("传入可变位置参数和可变关键字参数：")
    func(1, 2, 3, x='a', y='b', z='c')
    func(1, 2, 3, **{
        'x': 1, 'y': 2, 'z': 3})  # 使用 **解包
    
    # 结果
    '''
    未传任何参数：
    args: 类型为tuple, 值为()
    kwargs: 类型为dict, 值为{}
    只传入可变位置参数：
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{}
    只传入可变关键字参数：
    args: 类型为tuple, 值为()
    kwargs: 类型为dict, 值为{'x': 'a', 'y': 'b', 'z': 'c'}
    传入可变位置参数和可变关键字参数：
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{'x': 'a', 'y': 'b', 'z': 'c'}
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3}
    '''
    
    # 位置参数，可变位置参数、默认参数、可变关键字参数结合
    # 参数定义顺序：位置参数->*args->默认参数->**kwargs
    def func(m, n, *args, flag=0, **kwargs):
        """
        :param args:
        :param kwargs:
        :return:
        """
        print("m: %s" % m)
        print("n: %s" % n)
        print("flag: %s" % flag)
        args_type = (str(type(args))).split("'")[1]
        kwargs_type = (str(type(kwargs))).split("'")[1]
        print("args: 类型为{0}, 值为{1}".format(args_type, args))
        print("kwargs: 类型为{0}, 值为{1}".format(kwargs_type, kwargs))
    
    
    print("只传位置参数：")
    func(22, 33)  # 这时默认参数flag=0
    print("以关键字参数形式传入位置参数：")
    func(m=22, n=33)
    print("传入位置参数和可变位置参数：")
    func(22, 33, 1, 2, 3)
    print("位置参数、可变位置参数、默认参数：")
    func(22, 33, 1, 2, 3, flag=666)
    print("位置参数、可变位置参数、默认参数和可变关键字参数：")
    func(22, 33, 1, 2, 3, flag=666, x='a', y='b', z='c')
    print("以**解包形式传入位置参数：")
    func(22, 33, 1, 2, 3, flag=666, **{
        'x': 1, 'y': 2, 'z': 3})
    
    # 结果
    '''
    只传位置参数：
    m: 22
    n: 33
    flag: 0
    args: 类型为tuple, 值为()
    kwargs: 类型为dict, 值为{}
    以关键字参数形式传入位置参数：
    m: 22
    n: 33
    flag: 0
    args: 类型为tuple, 值为()
    kwargs: 类型为dict, 值为{}
    传入位置参数和可变位置参数：
    m: 22
    n: 33
    flag: 0
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{}
    位置参数、可变位置参数、默认参数：
    m: 22
    n: 33
    flag: 666
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{}
    位置参数、可变位置参数、默认参数和可变关键字参数：
    m: 22
    n: 33
    flag: 666
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{'x': 'a', 'y': 'b', 'z': 'c'}
    以**解包形式传入位置参数：
    m: 22
    n: 33
    flag: 666
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3}
    '''

*  仅限关键字参数：在\*号之后的参数只能通过关键字参数传递的叫keyword-only参数。其中，可变位置参数之后的参数也是keyword-only参数

# *号的参数用关键字参数形式传参
    def func(*, x):
        """
        :param x:
        :return:
        """
        print(x)
    
    func(x=3)
    
    # 结果
    '''
    3
    '''
    
    # 可变位置参数后的参数，也是仅限关键字参数
    def func(*args, x):
        """
        :param args:
        :param x:
        :return:
        """
        args_type = (str(type(args))).split("'")[1]
        print("args: 类型为{0}, 值为{1}".format(args_type, args))
        print("x: %s" % x)
    
    print("---- 只传关键字参数: ----")
    func(x=3)
    print("---- 传入可变位置参数和关键字参数：----")
    func(1,2,3, x=666)
    
    # 结果
    '''
    ---- 只传关键字参数: ----
    args: 类型为tuple, 值为()
    x: 3
    ---- 传入可变位置参数和关键字参数：----
    args: 类型为tuple, 值为(1, 2, 3)
    x: 666
    '''
    
    # 可变位置参数、普通参数、默认参数组成仅限关键字参数
    def func(*args, x, y=0):
        """
        :param args:
        :param x:
        :param y:
        :return:
        """
        args_type = (str(type(args))).split("'")[1]
        print("args: 类型为{0}, 值为{1}".format(args_type, args))
        print("x: %s" % x)
        print("y: %s" % y)
    
    print("---- 只传关键字参数: ----")
    func(x=3)
    print("---- 传入可变位置参数和关键字参数：----")
    func(1,2,3, x=666)
    print("---- 传入可变位置参数、关键字参数和默认参数：----")
    func(1,2,3, x=666, y=333)
    
    # 结果
    '''---- 只传关键字参数: ----
    args: 类型为tuple, 值为()
    x: 3
    y: 0
    ---- 传入可变位置参数和关键字参数：----
    args: 类型为tuple, 值为(1, 2, 3)
    x: 666
    y: 0
    ---- 传入可变位置参数、关键字参数和默认参数：----
    args: 类型为tuple, 值为(1, 2, 3)
    x: 666
    y: 333
    '''

*  参数解构：参数解构发生在函数调用时，可变参数发生在函数定义的时
    
     *  \*解构：解构对象是可迭代对象，结构后的结果为位置参数
     *  \*\*解构：解构对象是字典，解构后的结果为关键字参数，这里key必须是str类型，且和函数定义的形参名一致，否则抛出TypeError异常

def add(x, y):
        return x + y
    
    # 位置参数解构
    data1 = (1, 2)
    print(add(*data1))
    
    # 关键字参数解构
    data2 = {
        'x': 3, 'y': 4}
    print(add(**data2))
    
    # 结果
    '''
    3
    7
    '''