你们说 Python 这个是 Bug 还是 Feature？

不是 {1, 2, 3} 么？

老问题了. {1,2,3}啊.

bug 是说不符合设计预期的行为. 这显然不可能是 bug. (虽然我不懂 python

我猜这种写法大概相当于

```
default = set([1])


class Foo:
def __init__(self, s=default):
self.s = s
```

这样用会引发内存泄露啊

@Jooooooooo 应该算符合预期吧，不过感觉有点反直觉，可能我下意识地以为这样写相当于每次创建一个新的 set

@lusi1990 会吗？不是每次实例化时 copy 一个指向 set 的引用吗？

@lanlanye 人家[官方文档]( https://docs.python.org/zh-cn/3/reference/compound_stmts.html#function)写得很清楚了：

> **默认形参值会在执行函数定义时按从左至右的顺序被求值。** 这意味着当函数被定义时将对表达式求值一次，相同的“预计算”值将在每次调用时被使用。 这一点在默认形参为可变对象，例如列表或字典的时候尤其需要重点理解：如果函数修改了该对象（例如向列表添加了一项），则实际上默认值也会被修改。 这通常不是人们所想要的。 绕过此问题的一个方法是使用 None 作为默认值，并在函数体中显式地对其进测试，例如:

```python
def whats_on_the_telly(penguin=None):
__if penguin is None:
____penguin = []
__penguin.append("property of the zoo")
__return penguin
```

当年 1.6 亿美金估值的公司 Digg 是如何被一句 Python 函数可变默参 毁掉的

/t/467817

@est 惊了居然还有这种事情……这个设计确实挺反直觉的，而且很难注意到，刚才发现 PyCharm 对这种情况有提示，Pyright 没有

开发了这么多年 Python ，还真没在意这个问题，学习了。

算是设计失误, 就跟 Null 的设计失误一样, 反正我用过 Rust 受不了 Go 作为一门比较新的语言居然不保证空类型安全, 特别是结构体默认为 nil 太 tm 容易出错了

这个我知道，参数默认值在函数声明时就初始化了，像 js 的话参数默认值是在函数执行时初始化的

现在流行用 https://docs.python.org/3/library/dataclasses.html#dataclasses.field
```py
@dataclass
class C:
mylist: list[int] = field(default_factory=list)

c = C()
c.mylist += [1, 2, 3]
```

正常 lint 都会提示
老问题了

@est 所以我说谁用 python 谁倒霉

我刚学 python 也踩过这个坑，默认值要用 None

不进行 deep copy 算是 python 的 feature 吧，之前自己刚开始用的时候就遇到了这个坑，然后认真学习了一下 shallow copy 和 deep copy

新手常犯的错误了……

这个例子不知道，但是类似的碰到过，可以理解

应该说是一个反直觉的设计缺陷.

不是 Bug 也不是 Feature

所以说 py 垃圾语言啊

不会 python, 试了试可以这样写

class Foo:
def __init__(self, createSet = lambda : set()):
self.s = createSet()

有点反直觉, 但是想了想又算合理

彻底的设计缺陷
和 js 的 var 和 this 有得一比 甚至更恶劣

为什么操作 f1 ，会改变 f2 的值？

print(id(f1), id(f2))
print(id(f1.s), id(f2.s))

140294972551120 140294972551024
140295241401280 140295241401280

破案了。

不是 Bug 也不是 Feature 。我觉得有过 C++ 经验的程序员更容易接受这个设定。

@ipwx
为啥 C++要躺枪。这明显是一个坑，C++有这么坑吗？

我想起来了， 这不是你们说的 设计问题， 这特么是写法问题：
如 def aaa(list =[] ) 多个使用的时候 地址同一个 所以一般参数不写空 数组 集合等。

好吧也可以说是设计问题， 但是 注意规范就行。 这特么是我老旧以前的一个面试题。。呜呜呜

@sillydaddy ummm 本来觉得 C++ 也应该是类似 Python 的行为，没想到不是。

https://ideone.com/iulg3B

这还挺让我意外的。这么说来 C++ 的默认值是求值表达式，在调用时会展开。

算 bug ，因为人们已经用工具来避免这种情况发生了。

yysy 我觉得接受这种行为去写程序也没啥不好，写起来基本不会有啥不方便的。把对象构造从默认值上面移开其实是一种很好的习惯。

确实有点反直觉，但也不能说是 bug 了，别拿可变对象作为函数默认值就是了

习惯 Javascript 类似默参写法再去写 Python 特别容易中招。只能说此梨非彼梨。

@h404bi 怎么说呢，其实我内心觉得任何语言在默认值里面构造堆对象都不是好的行为。

@sillydaddy 我第一反应 C++ 程序员应该不会意外这种设计，主要是 C++ 有栈对象。如果是栈对象作为默认值，那么我理所当然地认为这里栈对象本身是默认值的一个拷贝。反而如果默认值是 new XXX()，我理所当然地觉得，那这种东西作为默认值，本来就不行，涉嫌内存泄露。

简而言之就是我潜意识觉得符合 RAII 原则的程序就不会在默认值 new XXX()。毕竟连 std::shared_ptr<XXX>(new XXX) 都是错误用法，应该使用 std::make_shared<XXX>() 不是吗（笑

接上一条。总之 C++ 里面我第一反应就是写个重载，然后重载函数构造一个局部栈对象或者智能指针传给参数多的那一个，根本不会轮到 new XXX 这种默认值出场。

默认形参不能用集合，我记得刚学 Python 的时候就知道了……

把默认值赋值逻辑写倒方法里 不要写在参数上

@Aloento 怎么说呢，面对技术选型，比如用 java 的倒霉的多了去了。但是人数多，你不怎么看得出来，倒霉了只能算你自己蠢。。。。。

这其实是大部分 python 教程都会提到的点，比如我们看 Python 之父廖雪峰的教程哈

https://www.liaoxuefeng.com/wiki/1016959663602400/1017261630425888#:~:text=%E9%BB%98%E8%AE%A4%E5%8F%82%E6%95%B0%E4%B8%80%E5%AE%9A%E8%A6%81%E7%94%A8%E4%B8%8D%E5%8F%AF%E5%8F%98%E5%AF%B9%E8%B1%A1%EF%BC%8C%E5%A6%82%E6%9E%9C%E6%98%AF%E5%8F%AF%E5%8F%98%E5%AF%B9%E8%B1%A1%EF%BC%8C%E7%A8%8B%E5%BA%8F%E8%BF%90%E8%A1%8C%E6%97%B6%E4%BC%9A%E6%9C%89%E9%80%BB%E8%BE%91%E9%94%99%E8%AF%AF%EF%BC%81

这个算是 101 的东西吧。这个是 mutable defaults 另一个是 closures late binding 。

这两个有没有放在最前面介绍应该做为判断教材是否合格的主要指标。

另外评价别人的代码，这也是很重要的参考，一旦出现，就要认真想一想了。

@kkhaike 是的，一般这么写
class Foo:
def __init__(self, s=None):
if s is None:
s = set()
self.s = s

老实承认，就是设计失误。

其他语言的默认参数的表达式在调用的时候才执行的，但 python 是在定义的时候执行的。前者更符合多数人的直觉。

@duange7X24 一般是 self.s = s or set()

目前应该所有 py 教学都会说避免这个，要说他是 feature 肯定不是，你根本不可能在任何场景用这个
说是 bug 嘛，这个好像也不太要修复，硬要 2 选 1 那就是 bug

还有一个就是，python 的 for 循环完了可以直接接 else 没有 if ，是 feature ，显然不是 bug ，但是我觉得，也应该删除这个 feature ，纯纯的屁用没有，如果真有人用了，还得反应一会才知道这段代码在干嘛，也很反直觉

是 Feature ，但它会导致一大堆 Bug
所以是个坏 Feature

@est 中肯的，客观的


@duange7X24 确实，我推荐您使用 Jvav

python 默认的 args 在__defaults__下面， 不可能让__defaults__的结果随缘吧?

本质还是可变和不可变对象引用的问题啊，js 虽然能规避掉 (args=[])这种问题， 但是要是下意识写出 const func = (args=window.xxxx)=>{}不一样么

测试的阶段算 Bug ，这种 Public API 都 release 的就算 Feature 了，只能将错就错，外加补一下文档了。

学习了，以前好像写过这样的代码…

老 feature 了

@Vegetable Python 之父中国分父是吧

https://docs.python-guide.org/writing/gotchas/#mutable-default-arguments

Best practice: all mutable default to be None

@westoy 确实，其实发现这个现象后很快就反应过来原因了，但直觉上还是觉得参数列表里的东西应该是表达式而不是直接求好的值……

@Vegetable 老实说我 16 年入门时看过，当时好像还没有这段……不过我也记不太清了

很多 Python 书函数部分都会提到，**参数尽量不要用可变对象**。函数参数部分的可变对象在内存中使用了相同的地址，导致实例化后的操作会产生意料之外的行为。

我觉得说是 bug 有点过，至少是可以理解的行为。只是在一开始不知道的时候容易被坑。

```python
class Foo:
def __init__(self, s=None):
self.s = s if s else set()
```

@zone10 结构体默认可不是 nil

这是 Feature

python 其实挺 c 的...
对象全是引用传递

这个不是 python 新手常见问题，python山里面成堆出现的吗？
一般人都知道可以这么写

def foo(l=None):
l = l or []

我记得 Pyright 是可以检测出来的

@Aloento 都是坑而已，何必纠结坑的哪个更坑；我现在到 go 坑了

正确的：
```
class Foo:
def __init__(self, s: set[int] | NOne= None):
self.s = s or set()


if __name__ == "__main__":
f1 = Foo(set())
f2 = Foo()
f1.s.add(1)
f1.s.add(2)
f1.s.add(3)
print(f2.s)
print(f1.s)

```

并不是 bug, 也不是 feature. 是一个编程要注意的事项. 默认参数不要使用可变类型.

@lolizeppelin 并不是引用传递, 而是按值传递引用

编辑器会提示不建议这么写，这么写只会实例化一个 set 对象

又学到一个不被裁的方法了..哈哈

It's a bug,but also is a feature. It depends on how to use it.
缓存数据的时候可以用这个特性 参考 https://foofish.net/python-tricks.html
```python

def factorial(num, cache={}):
if num == 0:
return 1
if num not in cache:
print('xxx')
cache[num] = factorial(num - 1) * num
return cache[num]


print(factorial(4))
print("-------")
print(factorial(4))
```

建议大家看看这个问答。

https://stackoverflow.com/questions/1132941/least-astonishment-and-the-mutable-default-argument