Python list.append是如何工作的？ alist=[] def显示（*args，**kwargs）： 列表.附加（*args，**kwargs） 打印（列表） >>>秀（‘老虎’） [“老虎”] >>>show（'老虎'，'猫'） 回溯（最近一次呼叫最后一次）： 文件“”，第1行，在 文件“”，第2行，在显示中 TypeError:append（）只接受一个参数（给定2个） >>>表演（‘老虎’、‘猫’、{‘名字’：‘汤姆’}） 回溯（最近一次呼叫最后一次）： 文件“”，第1行，在 文件“”，第2行，在显示中 TypeError:append（）只接受一个参数（给定3个）

既然alist的append方法只接受一个参数，为什么不在方法show的定义中的

alist.append（*args，**kwargs）

行检测语法错误？

这不是语法错误，因为语法非常好，该函数可能会也可能不会引发错误，这取决于您如何调用它

你这样称呼它：

 alist = []
 def show(*args, **kwargs):
      alist.append(*args, **kwargs)
      print(alist)


 >>> show('tiger')
 ['tiger']
 >>> show('tiger','cat')
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   File "<stdin>", line 2, in show
 TypeError: append() takes exactly one argument (2 given)
 >>> show('tiger','cat', {'name':'tom'})
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   File "<stdin>", line 2, in show
 TypeError: append() takes exactly one argument (3 given)

alist=[]
def显示（*args，**kwargs）：
列表.附加（*args，**kwargs）
打印（列表）
>>>秀（‘老虎’）
[“老虎”]
>>>表演（‘老虎’、‘猫’）
回溯（最近一次呼叫最后一次）：
文件“”，第1行，在
文件“”，第2行，在显示中
TypeError:append（）只接受一个参数（给定2个）

另一种方式：

alist = []
def show(*args, **kwargs):
     alist.append(*args, **kwargs)
     print(alist)

>>> show('tiger')
['tiger']
>>> show('tiger','cat')
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   File "<stdin>", line 2, in show
 TypeError: append() takes exactly one argument (2 given)

alist=[]
def显示（*args，**kwargs）：
列表.附加（*args，**kwargs）
打印（列表）
>>>秀（‘老虎’）
[‘老虎’、‘老虎’]
>>>L类：通行证
...
>>>alist=L（）
>>>alist.append=打印
>>>表演（‘老虎’、‘猫’）
虎猫

这不是语法错误，因为它是在运行时解决的。语法错误最初是在解析过程中捕获的。诸如不匹配的括号、未定义的变量名、缺少的参数（这不是缺少的参数*args表示任意数量的参数）

show

无法知道在运行时将传递什么，因为您正在

show

中扩展

args

变量，所以可能会有任意数量的参数进入，并且它的语法有效<代码>列表。追加接受一个参数！一个

元组

，一个

列表

，一个

int

，字符串，自定义类等。传递它的是一些数字元素，取决于输入。如果您删除

*

元素，它将作为它的一个元素，例如

alist.append（args）

所有这一切都意味着您的

show

功能有故障。仅当其长度为1时，才配备处理

args

。如果为0，则在调用

append

的点也会出现TypeError。若它超过那个么它就坏了，但直到你们用坏的输入运行它，你们才知道

您可以循环使用

args

（和

kwargs

）中的元素，并逐个添加它们

alist = []
def show(*args, **kwargs):
     alist.append(*args, **kwargs)
     print(alist)

>>> show('tiger')
['tiger', 'tiger']
>>> class L: pass
...
>>> alist = L()
>>> alist.append = print
>>> show('tiger','cat')
tiger cat
<__main__.L object at 0x000000A45DBCC048>

---

Python对象是强类型的。绑定到它们的名称不是。函数参数也不是。鉴于Python的动态特性，静态预测给定源位置的变量在执行时将是什么类型是极其困难的，因此一般规则是Python不必费心尝试

在您的具体示例中，

alist

不在本地范围内。因此，可以在执行函数定义后对其进行修改，并且更改对函数可见，请参见下面的代码段。 因此，根据一般规则：在调用

.append

时预测

alist

是否将是一个列表？几乎不可能。特别是，口译员无法预测这将是一个错误

下面是一些代码，旨在说明在Python中，静态类型检查实际上是不可能的。它使用非局部变量，如您的示例中所示

alist = []
def show(*args, **kwargs):

    for a in args:
        alist.append(a)
    for kv in kwargs.items():
        alist.append(kv)

    print(alist)

输出：

funcs = []
for a in [1, "x", [2]]:
    def b():
        def f():
            print(a)
        return f
    funcs.append(b())

for f in funcs:
    f()

funcs = []
for a in [1, "x", [2]]:
    def b(a):
        def f():
            print(a)
        a = a+a
        return f
    funcs.append(b(a))

for f in funcs:
    f()

同样，对于非全局非局部变量：

[2] # value of a at definition time (of f): 1
[2] # value of a at definition time (of f): 'x'
[2] # value of a at definition time (of f): [2]

输出：

funcs = []
for a in [1, "x", [2]]:
    def b():
        def f():
            print(a)
        return f
    funcs.append(b())

for f in funcs:
    f()

funcs = []
for a in [1, "x", [2]]:
    def b(a):
        def f():
            print(a)
        a = a+a
        return f
    funcs.append(b(a))

for f in funcs:
    f()

---

因为python不是这样工作的。。它在语法上没有什么问题，函数只接受一个以上的参数。Try list.extendh解释器如何知道在您调用

show

时

alist

将是什么？您的意思是问为什么

show（'tiger'）

没有错误，但是

show（'tiger'，'cat'）

有错误？另一个需要认识的重要问题是，正如您所演示的，有一种方法可以毫无问题地调用

show

。为什么一个可以完美工作的函数会被认为是不正确的语法？