你真的掌握了 Python 的七种参数了吗？

不知道为什么网上总有人说 Python 的参数类型有 4 种啊，5 种啊，殊不知其实有 7 种。Python 的 7 种参数分别是 默认参数、位置参数、关键字参数、可变长位置参数、可变长关键字参数、仅位置参数 和 仅关键字参数。小白可能没见过“可变长参数”，但是大部分人可能都没见过“仅参数”，“仅参数”一般只会在开发模块时才会用到，那么我为什么会知道呢？您猜……下面就让我为你细细道来。

先看段代码，一般人可看不懂哦：

def function(a, /, b, c=1, *, d=2, **e) -> None: ...

上面的这段代码是可以正常运行的，它几乎体现了所有参数类型，几乎哈，不是完全。因为有几种参数类型互相之间无法共存。

一、默认参数（Default Parameter）

默认参数简单，就是字面意思，当你不给它值的时候，它会有个默认值，因为某些时候不传具体的值，是缺省的，因此它也叫缺省参数。

def function(default_parameter: int = 1) -> int:
    return default_parameter

上面的函数，若不传值给它，它会默认返回 1，若是传了值，那就返回你传入的值。是不是很简单？若是这样想，那你就大错特错了，您猜下面的代码输出是什么？

def function(default_parameter=[1]) -> None:
    print(default_parameter)
    default_parameter.append(default_parameter[-1] + 1)

function()
function()
function()

下面是输出的结果：

[1]
[1, 2]
[1, 2, 3]

具体解释见（链接文章的第七点）：Python 易错点大集合

这是默认参数中最常见的坑，一般人都会往里跳，曾经有个公司的业务代码中就犯了这个致命错误，直接导致服务器崩溃，因为那个列表变得异常大……

二、位置参数（Positional Parameter）

位置参数就是我们天天用的了，喜闻乐见啊，大家都会用的那种。

def function(a: int, b: float, c: str) -> None:
    print(a + b, c)

所谓“位置”，意思就是参数是按位置来传递的，位置参数的位置不是严格要求的，你可以像关键字参数那样传参，举个栗子：

def function(a: int, b: int) -> None:
    print(a, b)

function(1, 2)
function(b=2, a=1)

 上面的两种调用方式输出结果相同，都是 1，2。实际上，位置参数的本质是用元组进行传参，后面会细讲。

三、关键字参数（Keyword Parameter）

关键字参数，也是从字面意思上就可以理解，它很“关键”，必须要指明它的名字来进行传参，就这么简单。

上面讲位置参数的时候也讲了一点关键字参数的内容，关键字参数不关心参数的位置，只要指明了参数名即可。关键字参数和位置参数类似，实际是用字典进行传参，字典的键是参数名，字符串形式，值是对应参数的值。

四、可变长位置参数（Variable-length Positional Parameter）

 可变长位置参数，也叫变长位置参数或者不定长位置参数，一般写作 *args，args 是英文单词 argument 的复数形式的缩写，“变长”是指参数的个数是不确定的意思，也就是说，它没有参数数量的限制。

def function(*args: int) -> tuple[int]:
    for arg in args:
        print(arg)
    return args

function(1)
function(1, 2)
function(1, 2, 3)

上面的函数返回一个元组，也就是说，args 实际就是一个元组，这和位置参数是元组传递构成了某种联系……

其实上面的代码还可以这样写：

def function(*args: int) -> tuple[int]:
    print(*args)
    return args

有人在想，*args 是什么意思呢？这涉及到 Python 的序列解包知识（是不是又没听过这个呀？）具体内容见：Python 星号的妙用 —— 灵活的序列解包

print 函数就是 Python 中最典型的使用了可变长参数的函数，它的函数原型是这样的（两个重载）：

def print(
    *values: object,
    sep: str | None = " ",
    end: str | None = "\n",
    file: SupportsWrite[str] | None = None,
    flush: Literal[False] = False,
) -> None: ...

def print(
    *values: object,
    sep: str | None = " ",
    end: str | None = "\n",
    file: _SupportsWriteAndFlush[str] | None = None,
    flush: bool
) -> None: ...

 那个 *values 就是可变长参数了。实际上，位置参数就是可变长位置参数序列解包后再进行参数传递的，而可变长位置参数是直接整个元组进行传值的。

那么我们扩展延伸一下，大家是不是总在网上看到说 Python 的函数可以有多个返回值？这是真的吗？这是错误的认知！实际上，Python 的函数返回值仍然只有一个，当写出多个值的时候，Python 自动给你弄成元组了，下面的代码可以验证：

def function():
    a = 1
    b = 2
    return a, b

c = 1, 2

print(type(c))
print(type(function()))

输出结果都是 tuple。 

五、可变长关键字参数（Variable-length Keyword Parameter）

可变长关键字参数呢，可以类比可变长位置参数，将元组换成字典就行，其他的都一样，这里就不再赘述了。

六、仅位置参数（Position-only Parameter）

好，终于到重点了，看仅位置参数之前先给大家介绍一位兄弟，就是一个斜杠（/），它在 Python 里面不仅仅是除法的含义，还有一个含义，而且有专门的名字，叫 仅位置参数分隔符（Position-only argument separator），不知有多少人认识这位兄弟呀？

在参数列表中就直接写一个斜杠就行，它强制其前面的参数是位置参数，无法用关键字参数进行传递！

在 Python 的内置函数 isinstance 中就有出现：

def isinstance(
    __obj: object,
    __class_or_tuple: _ClassInfo,
    /  # 这里！这里！这儿出现了仅位置参数分隔符！
) -> bool

在 int 中也有：

class int(
    __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...,
    /  # 这里！这里！这儿有仅位置参数分隔符！
)

我对这个东西给的理解是（非官方理解），这个东西的作用一般是为了防止一些一般人看不懂代码，有些东西是约定俗成的，不需要刻意地写出来，比如参数名，毕竟你见过谁用 int 的时候像下面这样写了？？？

int(__x=1)

上面是错误的代码！尽管这个参数名确实是 __x，但是仅位置参数分隔符强制了它为位置参数，不允许将 __x 写出来（写出来就是关键字参数了）！ 且写出来只会让人误解且读起来费劲！

七、仅关键字参数（Keyword-only Parameter）

同样的，看仅关键字参数之前先给大家介绍一位兄弟，就是一个星号（*），它在 Python 里面不仅仅是乘法的含义，以及序列解包的含义，还有一个含义，而且也有专门的名字，叫 仅关键字参数分隔符（Keyword-only argument separator），不知又有多少人认识这位兄弟呀？

在参数列表中就直接写一个星号就行，它强制其后面的参数是关键字参数，无法用位置参数的方式进行参数传递！

我对这个理解（非官方理解）是，它非常方便于修改模块和项目，对不同版本的兼容性很好，不像位置参数，一旦中间少了或者多了一个参数，后面的参数全部错位，导致出现不可预计的问题。而这个仅关键字参数分隔符写了之后可以强制别人用你的函数时必须按照关键字参数的方式进行传递，防止出现参数错位的情况。这个一般在参数比较多的情况下会使用，比如 Python 内置模块 tkinter 某些控件类初始化的参数，多到离谱：

def __init__(
    self: Canvas,
    master: Misc | None = None,
    cnf: dict[str, Any] | None = {},
    *,  # 这里！这里！这儿有个仅关键字参数分隔符！
    background: str = ...,
    bd: _ScreenUnits = ...,
    bg: str = ...,
    border: _ScreenUnits = ...,
    borderwidth: _ScreenUnits = ...,
    closeenough: float = ...,
    confine: bool = ...,
    cursor: _Cursor = ...,
    height: _ScreenUnits = ...,
    highlightbackground: str = ...,
    highlightcolor: str = ...,
    highlightthickness: _ScreenUnits = ...,
    insertbackground: str = ...,
    insertborderwidth: _ScreenUnits = ...,
    insertofftime: int = ...,
    insertontime: int = ...,
    insertwidth: _ScreenUnits = ...,
    name: str = ...,
    offset: ... = ...,
    relief: _Relief = ...,
    scrollregion: tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits, _ScreenUnits] | tuple[()] = ...,
    selectbackground: str = ...,
    selectborderwidth: _ScreenUnits = ...,
    selectforeground: str = ...,
    state: Literal['normal', 'disabled'] = ...,
    takefocus: _TakeFocusValue = ...,
    width: _ScreenUnits = ...,
    xscrollcommand: _XYScrollCommand = ...,
    xscrollincrement: _ScreenUnits = ...,
    yscrollcommand: _XYScrollCommand = ...,
    yscrollincrement: _ScreenUnits = ...
) -> None

讲完了，现在有个问题，看完这些知识的你，回过头再看开篇的那段代码，你能说出哪些参数类型互相之间是冲突和矛盾，导致无法并存的吗？评论区里留下你的答案（我不会写出答案的【doge】） 

---

我本人平时就在自己写一些模块的代码，所以呢，对这些比较了解，它们都是 Python 的编程利器！建议大家也掌握这些知识，虽然可能没什么用，但是技多不压身啊！

看到这里，不知您是否涨知识了呢？喜欢的话不妨 点赞、收藏 加 转发 ？如果可以 关注 的话，那更好了！！！

该文章已被收入到专栏中，专栏在文章顶部可以看到，里面有更多让你匪夷所思的 Python 知识！