Python 函数的不定长参数介绍 -- argc/*argcs/**kargcs

目录

零基础 Python 学习路线推荐 : Python 学习目录 >> Python 基础入门

一.前言

在 Python 函数的声明和调用 中我们简单的了解了函数的相关使用，然而在函数传递参数的时候，我们埋下了一个坑，关于不定长参数的传递我们还没有讲，今天这篇文章主要就是讲解这个问题。

Python 内置函数 print，这个函数想大家都会用，观察如下代码：

# !usr/bin/env python
# -*- coding:utf-8 _*-
"""
@Author:猿说编程
@Blog(个人博客地址): www.codersrc.com
@File:Python 不定长参数 *argc/**kargcs.py
@Time:2021/3/29 07:37
@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！

"""

a = 1.0
b = False
c = "python教程 - 猿说编程"
print("a = %g" % (a))
print("a = %g b = %d" % (a,b))
print("a = %g b = %d c = %s" % (a,b,c))

'''
输出结果：
a = 1
a = 1 b = 0
a = 1 b = 0 c = python教程 - 猿说编程
'''

问题来了，内置 Python 内置函数 print 到底需要传递几个参数？？

二.Python 不定长参数 argc/*kargcs 简介

Python 函数的不定长参数包含 *args 和 **kwargs ，完整实例如下：

# !usr/bin/env python
# -*- coding:utf-8 _*-
"""
@Author:猿说编程
@Blog(个人博客地址): www.codersrc.com
@File:Python 不定长参数 *argc/**kargcs.py
@Time:2021/3/29 07:37
@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！

"""

def function_print(*args,**kwargs): # 传递不定长参数，即参数个数不固定
    print(args)
    print(kwargs)


function_print()

'''
输出结果：
()
{}
'''

代码分析：由输出结果可以看出来，第一个形参 args 是元组 tuple 类型，第二个形参 *kwargs 是字典 dict 类型.

1.函数不定长参数**** ***args 使用**

a.形参 *args 类型是元组 tuple，外部调用函数时传递的参数不论是整数还是 BOOL 值或者是字符串 string ，实际上传递的都是元组数据;

b.如果函数形参是不定长参数，外部调用函数传递多个参数时，默认按顺序实参匹配形参，剩余的参数全部作为(元组)不定长参数传递；

c.如果没有为函数的不定长参数传递参数，默认为空元组();

示例代码如下：

# !usr/bin/env python
# -*- coding:utf-8 _*-
"""
@Author:猿说编程
@Blog(个人博客地址): www.codersrc.com
@File:Python 不定长参数 *argc/**kargcs.py
@Time:2021/3/29 07:37
@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！

"""

#普通形参
def function_print1(arg):
    print("普通形参 : arg=",arg)

#不定长形参
def function_print2(*args):
    print("不定长形参 : args=",args)

#普通形参 + 不定长形参
def function_print3(arg,*args):
    print("普通形参 + 不定长形参 : arg=",arg)
    print("普通形参 + 不定长形参 : args=",args)

function_print1(False)
function_print1("hello world")
print("***"*20)

function_print2(False)
function_print2("hello world")
print("***"*20)

function_print3(False) # 只为函数传递了一个形参，不定长参数的形参默认为空元组()
function_print3("hello world")
print("***"*20)

# 如果函数的形参是不定长参数，当外部调用函数传递多个参数时，默认按顺序匹配形参，剩余的参数全部作为不定长参数传递
function_print3(False,1,23,4,5)
function_print3("hello world",False,0,True,"python教程")

'''
输出结果：
普通形参 : arg= False
普通形参 : arg= hello world
************************************************************
不定长形参 : args= (False,)
不定长形参 : args= ('hello world',)
************************************************************
普通形参 + 不定长形参 : arg= False
普通形参 + 不定长形参 : args= ()
普通形参 + 不定长形参 : arg= hello world
普通形参 + 不定长形参 : args= ()
************************************************************
普通形参 + 不定长形参 : arg= False
普通形参 + 不定长形参 : args= (1, 23, 4, 5)
普通形参 + 不定长形参 : arg= hello world
普通形参 + 不定长形参 : args= (False, 0, True, 'python教程')

'''

2.函数不定长参数**** ****kwargs 使用**

**a.形参 **kwargs 类型是字典 dict，函数外部调用函数传递参数时需要使用关键字参数，实参写法：a=1,b=2,c=False,d=”hello”;**

b.如果函数形参是不定长参数，外部调用函数传递多个参数时，默认按顺序实参匹配形参，关键字参数全部作为(字典)不定长参数传递；

c.如果没有为函数的不定长参数传递参数，默认为空字典 {} ;

示例代码如下：

# !usr/bin/env python
# -*- coding:utf-8 _*-
"""
@Author:猿说编程
@Blog(个人博客地址): www.codersrc.com
@File:Python 不定长参数 *argc/**kargcs.py
@Time:2021/3/29 07:37
@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！

"""

#普通函数
def function_print1(arg):
    print("普通函数形参 : arg=",arg)

#普通函数不定长形参
def function_print2(**kwargs):
    print("不定长形参 : args=",kwargs)

#普通函数形参 + 不定长形参
def function_print3(arg,**kwargs):
    print("普通函数形参 + 不定长形参 : arg=",arg)
    print("普通函数形参 + 不定长形参 : args=",kwargs)

function_print1(False)
function_print1("hello world")
print("***"*20)

function_print2(a=False)
function_print2(c="hello world")
print("***"*20)

function_print3(False)
function_print3("hello world")
print("***"*20)

function_print3(False,a=1,b=23,h=4,v=5)
function_print3("hello world",y=False,i=0,a=True,j="python教程")

'''
输出结果：
普通函数形参 : arg= False
普通函数形参 : arg= hello world
************************************************************
不定长形参 : args= {'a': False}
不定长形参 : args= {'c': 'hello world'}
************************************************************
普通函数形参 + 不定长形参 : arg= False
普通函数形参 + 不定长形参 : args= {}
普通函数形参 + 不定长形参 : arg= hello world
普通函数形参 + 不定长形参 : args= {}
************************************************************
普通函数形参 + 不定长形参 : arg= False
普通函数形参 + 不定长形参 : args= {'a': 1, 'b': 23, 'h': 4, 'v': 5}
普通函数形参 + 不定长形参 : arg= hello world
普通函数形参 + 不定长形参 : args= {'y': False, 'i': 0, 'a': True, 'j': 'python教程'}

'''

3.函数不定长参数*args 和**kwargs 只能放在形参的末尾，顺序不能错.

def function_print(arg1,*args,**kwargs): # *args,**kwargs 必须在形参的末尾，顺序不能乱
    pass

三.Python 不定长参数 argc/*kargcs 实战

# !usr/bin/env python
# -*- coding:utf-8 _*-
"""
@Author:猿说编程
@Blog(个人博客地址): www.codersrc.com
@File:Python 不定长参数 *argc/**kargcs.py
@Time:2021/3/29 07:37
@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！

"""

'''
普通函数形参 + 不定长形参:
    arg1:普通形参
    arg1:普通形参
    args:不定长参数-元组
    kwargs:不定长参数-字典
'''

def function_print(arg1,arg2,*args,**kwargs):
    print(arg1,arg2,args,kwargs)

function_print(False,1,b=23,h=4,v=5)
function_print("hello world",False,0,True,j="python教程",a=True)

'''
输出结果：
False 1 () {'b': 23, 'h': 4, 'v': 5}
hello world False (0, True) {'j': 'python教程', 'a': True}

'''

注意：注意参数的顺序匹配

四.Python 不定长参数 argc/*kargcs 总结

注意函数传参的三种形式：

  • 1.普通传参;
  • 2.缺省参数，如果外部没有为缺省参数传递实参，形参等于默认值;
  • 3.注意不定长参数的拆包，普通实参打包为元组 tuple 类型，关键字参数打包为字典 dict 类型;

五.猜你喜欢

  1. Python 配置环境
  2. Python 变量
  3. Python 运算符
  4. Python 条件判断 if/else
  5. Python while 循环
  6. Python break
  7. Python continue
  8. Python for 循环
  9. Python 字符串
  10. Python 列表 list
  11. Python 元组 tuple
  12. Python 字典 dict
  13. Python 条件推导式
  14. Python 列表推导式
  15. Python 字典推导式

未经允许不得转载：猿说编程 » Python 不定长参数 *argc/**kargcs

本文由博客 - 猿说编程 猿说编程 发布！

 

2024-03-15 14:43:38【出处】：https://www.cnblogs.com/shuopython/p/14867063.html

=======================================================================================

python函数的不定长参数的详解

在Python中，函数不定长参数是指在定义函数时，能够接收任意数量的参数。这种参数可以是位置参数、关键字参数甚至是混合参数。使用不定长参数可以使函数更加灵活，能够适应不同的需求。本文将从多个角度分析如何使用Python函数的不定长参数。

一、使用*args

*args是Python中最常用的不定长参数。它用于接收任意数量的位置参数，用法如下：


def func(*args):
    print(args)

在这个例子中，我们定义了一个func函数，并使用*args接收任意数量的位置参数。函数体中使用print函数输出args，args是一个元组，其中包含了传入的所有位置参数。

我们可以传入任意数量的位置参数：


func() # 输出 ()
func(1) # 输出 (1,)
func(1, 2) # 输出 (1, 2)
func(1, 2, 3) # 输出 (1, 2, 3)

二、使用**kwargs

**kwargs用于接收任意数量的关键字参数，用法如下：


def func(**kwargs):
    print(kwargs)

在这个例子中，我们定义了一个func函数，并使用**kwargs接收任意数量的关键字参数。函数体中使用print函数输出kwargs，kwargs是一个字典，其中包含了传入的所有关键字参数。

我们可以传入任意数量的关键字参数：


func() # 输出 {}
func(a=1) # 输出 {'a': 1}
func(a=1, b=2) # 输出 {'a': 1, 'b': 2}
func(a=1, b=2, c=3) # 输出 {'a': 1, 'b': 2, 'c': 3}

三、使用*args和**kwargs

*args和**kwargs也可以一起使用，用法如下：


def func(*args, **kwargs):
    print(args)
    print(kwargs)

在这个例子中，我们定义了一个func函数，并使用*args接收任意数量的位置参数，使用**kwargs接收任意数量的关键字参数。函数体中使用print函数分别输出args和kwargs，args是一个元组，其中包含了传入的所有位置参数，kwargs是一个字典，其中包含了传入的所有关键字参数。

我们可以传入任意数量的位置参数和关键字参数：


func() # 输出 () {}
func(1) # 输出 (1,) {}
func(1, 2) # 输出 (1, 2) {}
func(a=1) # 输出 () {'a': 1}
func(a=1, b=2) # 输出 () {'a': 1, 'b': 2}
func(a=1, b=2, c=3) # 输出 () {'a': 1, 'b': 2, 'c': 3}
func(1, a=1) # 输出 (1,) {'a': 1}
func(1, 2, a=1, b=2) # 输出 (1, 2) {'a': 1, 'b': 2}

四、使用默认值

我们可以为不定长参数设置默认值，用法如下：


def func(a, b=2, *args, **kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)

在这个例子中，我们定义了一个func函数，其中a是位置参数，b是关键字参数，*args和**kwargs分别用于接收任意数量的位置参数和关键字参数。我们为b设置了默认值2。

我们可以传入任意数量的位置参数和关键字参数：


func(1) # 输出 1 2 () {}
func(1, b=3) # 输出 1 3 () {}
func(1, 2) # 输出 1 2 () {}
func(1, 2, 3) # 输出 1 2 (3,) {}
func(1, 2, 3, a=1) # 输出 1 2 (3,) {'a': 1}
func(1, 2, 3, a=1, b=2) # 输出 1 2 (3,) {'a': 1, 'b': 2}

五、使用解包

我们可以使用解包来传递不定长参数，用法如下：


def func(a, b, c):
    print(a)
    print(b)
    print(c)

args = (1, 2, 3)
func(*args)

kwargs = {'a': 1, 'b': 2, 'c': 3}
func(**kwargs)

在这个例子中，我们定义了一个func函数，其中a、b、c是位置参数。我们将位置参数存储在一个元组args中，并通过解包将其传递给func函数。我们还将关键字参数存储在一个字典kwargs中，并通过解包将其传递给func函数。

我们还可以将不定长参数和其他参数一起使用解包，用法如下：


def func(a, b, c, *args, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)
    
args = (1, 2, 3)
kwargs = {'d': 4, 'e': 5}

在这个例子中，我们定义了一个func函数，其中a、b、c是位置参数，*args和**kwargs分别用于接收任意数量的位置参数和关键字参数。我们将位置参数存储在一个元组args中，将关键字参数存储在一个字典kwargs中，并通过解包将它们一起传递给func函数。

 

 

出处：https://www.ycpai.cn/python/SHJGUGv3.html

=======================================================================================

Python打印去掉括号

在Python中，我们经常需要打印输出结果或者将结果以字符串形式展示出来。但有时候，我们会发现打印出来的结果带有括号，这可能不符合我们的需求。本文将介绍几种常见的方法，帮助您去掉Python打印结果中的括号。

方法一：使用字符串格式化

字符串格式化是Python中一种强大的输出方式。我们可以使用%操作符或者str.format()方法将括号去掉。

使用%操作符

result = (1, 2, 3)
print("Result: %s" % result)
 

上述代码中，我们使用了%s占位符，将result作为字符串的一部分输出。%s表示输出一个字符串，而不是元组或者其他类型。这样我们就可以去掉打印结果中的括号。

使用str.format()

result = (1, 2, 3)
print("Result: {}".format(result))
 

在上述代码中，我们使用了{}作为占位符，将result插入到字符串中。str.format()方法可以自动将元组转换为字符串，并且去掉括号。

方法二：使用join()函数

另一种去掉括号的方法是使用join()函数。join()函数可以将一个可迭代对象中的元素连接成一个字符串。

result = (1, 2, 3)
print("Result: " + ", ".join(str(x) for x in result))
 

在上述代码中，我们首先使用一个生成器表达式将元组中的元素转换为字符串，然后使用join()函数将这些字符串连接起来。通过这种方式，我们可以去掉打印结果中的括号。

方法三：使用*操作符

使用*操作符可以将元组中的元素解包，然后传递给函数或者格式化字符串。

result = (1, 2, 3)
print(*result)
 

在上述代码中，我们将result作为参数传递给print()函数，并使用*操作符解包元组。这样，print()函数将会打印出元组中的元素，而不是整个元组。

方法四：使用列表推导式

列表推导式是Python中一种简洁的生成列表的方式。我们可以使用列表推导式将元组中的元素转换为字符串，并去掉括号。

result = (1, 2, 3)
print("Result: " + ", ".join(str(x) for x in result))
 

在上述代码中，我们使用一个列表推导式将元组中的元素转换为字符串，然后使用join()函数将这些字符串连接起来。通过这种方式，我们可以去掉打印结果中的括号。

结论

在Python中，有多种方法可以去掉打印结果中的括号。我们可以使用字符串格式化、join()函数、*操作符或者列表推导式来实现这一目的。根据实际情况选择最适合的方法。

希望本文对您有所帮助，让您能够更好地处理Python中的打印输出操作。Happy coding!

 

出处：https://blog.51cto.com/u_16175507/6946997

posted on 2024-03-15 14:48  jack_Meng  阅读(787)  评论(0)  编辑  收藏  举报

导航