可变数据类型：列表、字典

不可变数据类型：整型、浮点型、字符串、元组

为什么可变数据类型不能作为python函数的参数？请看以下例子：

  1. def foo(a=[]):
  2.   a.append(1)
  3.   return a
  4. print(foo())
  5. print(foo())
  6. print(foo())

结果：

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

我们继续打印下每次函数的返回值的内存地址：

  1. print(id(foo()))
  2. print(id(foo()))
  3. print(id(foo()))

结果：

  1. 140344852133960
  2. 140344852133960
  3. 140344852133960

会发现我们每次返回的都是同一个对象。

再看下以下例子：

  1. b = [1,2]
  2. def test(place=b):
  3.   place.append(1)
  4.   return place
  5. print(b)
  6. print(test())
  7. print(b)
  8. print(test())
  9. print(b)

结果：

  1. [1, 2]
  2. [1, 2, 1]
  3. [1, 2, 1]
  4. [1, 2, 1, 1]
  5. [1, 2, 1, 1]

当使用列表作为参数传入函数时，实际上是引用传递。也就是传入的是实际参数的地址，而place=b也就是指向相同的地址。比如以下的：

  1. c = [1,2,3]
  2. d = c
  3. print(id(c))
  4. print(id(d))

结果：

  1. 140344851860104
  2. 140344851860104

当我们修改d的值时，同样也会影响到c：

  1. d.append(4)
  2. print(d)
  3. print(c)
  4. print(id(d))
  5. print(id(c))

结果：

  1. [1, 2, 3, 4]
  2. [1, 2, 3, 4]
  3. 140344851860104
  4. 140344851860104

所以在上述中，通过在test()函数中修改place的值也会影响到b的值。

为什么会这样呢？

python中一切皆对象。函数也是对象，可以这么理解，一个函数是一个被它自己定义而执行的对，;默认参数是一种”成员数据”，所以它们的状态和其他对象一样,会随着每一次调用而改变。

怎么避免这种现象呢？

使用以下方式：

  1. def foo(a=None):
  2.   if a is None: 
  3.     a = []
  4.   a.append(1)
  5.   return a
  6. print(foo())
  7. print(foo())
  8. print(foo())

结果：

  1. [1]
  2. [1]
  3. [1]

如果需要处理任意对象（包括None），则可以使用哨兵对象：

  1. sentinel = object()
  2.  
  3. def myfunc(value=sentinel):
  4.     if value is sentinel:
  5.         value = expression
  6.     # use/modify value here

应用：求数组的全排列

最后我们来看一个应用例子：求数组的全排列

基本思路是回溯法：每次从数组中选一个值加入到tmp中，如果数组中没有值了，就将tmp加入到结果中，返回。

如果我们的代码是这种：

  1. arr = [1,2,3]
  2. res = []
  3. def permutation(arr,tmp=[]):
  4.   global res
  5.   if len(arr) == 0:
  6.     res.append(tmp)
  7.     return
  8.   for i in range(len(arr)):
  9.     tmp = tmp + [arr[i]]
  10.     newArr = arr[:i]+arr[i+1:]
  11.     permutation(newArr,tmp)
  12. subset(arr,tmp=[])
  13. print(res)

结果：

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

这里就出现了上述的情况，我们只需要简单的改以下即可：

  1. arr = [1,2,3]
  2. res = []
  3. def permutation(arr,tmp=[]):
  4.   global res
  5.   if len(arr) == 0:
  6.     res.append(tmp)
  7.     return
  8.   for i in range(len(arr)):
  9.     newTmp = tmp + [arr[i]]
  10.     newArr = arr[:i]+arr[i+1:]
  11.     permutation(newArr,newTmp)
  12. subset(arr,tmp=[])
  13. print(res)

结果：

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

我们只需要每次新建一个列表即可。

 

参考：https://blog.csdn.net/rommi/article/details/51979556

版权声明：本文为xiximayou原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/xiximayou/p/13832264.html