【python进阶攻略4】Global、Return和对象变动Mutation

Global和Return

你也许遇到过, python中一些函数在最尾部有一个return关键字。你知道它是干嘛吗？它和其他语言的return类似。我们来检查下这个小函数：

def add(value1, value2):
    return value1 + value2

result = add(3, 5)
print(result)
# Output: 8

上面这个函数将两个值作为输入，然后输出它们相加之和。我们也可以这样做：

def add(value1,value2):
    global result
    result = value1 + value2

add(3,5)
print(result)
# Output: 8

那首先我们来谈谈第一段也就是包含return关键字的代码。那个函数把值赋给了调用它的变量（也就是例子中的result变量）。
大多数境况下，你并不需要使用global关键字。然而我们也来检查下另外一段也就是包含global关键字的代码。
那个函数生成了一个global（全局）变量result。

global在这的意思是什么？global变量意味着我们可以在函数以外的区域都能访问这个变量。让我们通过一个例子来证明它：

# 首先，是没有使用global变量
def add(value1, value2):
    result = value1 + value2

add(2, 4)
print(result)

# Oh 糟了，我们遇到异常了。为什么会这样？
# python解释器报错说没有一个叫result的变量。
# 这是因为result变量只能在创建它的函数内部才允许访问，除非它是全局的(global)。
Traceback (most recent call last):
  File "", line 1, in
    result
NameError: name 'result' is not defined

# 现在我们运行相同的代码，不过是在将result变量设为global之后
def add(value1, value2):
    global result
    result = value1 + value2

add(2, 4)
print(result)
6

如我们所愿，在第二次运行时没有异常了。在实际的编程时，你应该试着避开global关键字，它只会让生活变得艰难，因为它引入了多余的变量到全局作用域了。

多个return值

那如果你想从一个函数里返回两个变量而不是一个呢？
新手们有若干种方法。最著名的方法，是使用global关键字。让我们看下这个没用的例子：

def profile():
    global name
    global age
    name = "Danny"
    age = 30

profile()
print(name)
# Output: Danny

print(age)
# Output: 30

注意: 不要试着使用上述方法。重要的事情说三遍，不要试着使用上述方法！

有些人试着在函数结束时，返回一个包含多个值的tuple(元组)，list(列表)或者dict(字典),来解决这个问题。这是一种可行的方式，而且使用起来像一个黑魔法：

def profile():
    name = "Danny"
    age = 30
    return (name, age)

profile_data = profile()
print(profile_data[0])
# Output: Danny

print(profile_data[1])
# Output: 30

或者按照更常见的惯例：

def profile():
    name = "Danny"
    age = 30
    return name, age

这是一种比列表和字典更好的方式。不要使用global关键字，除非你知道你正在做什么。global也许在某些场景下是一个更好的选择（但其中大多数情况都不是）。

对象变动(Mutation)

Python中可变(mutable)与不可变(immutable)的数据类型让新手很是头痛。简单的说，可变(mutable)意味着"可以被改动"，而不可变(immutable)的意思是“常量(constant)”。想把脑筋转动起来吗？考虑下这个例子：

foo = ['hi']
print(foo)
# Output: ['hi']

bar = foo
bar += ['bye']
print(foo)
# Output: ['hi', 'bye']

刚刚发生了什么？我们预期的不是那样！我们期望看到是这样的：

foo = ['hi']
print(foo)
# Output: ['hi']

bar = foo
bar += ['bye']

print(foo)
# Output: ['hi']

print(bar)
# Output: ['hi', 'bye']

这不是一个bug。这是对象可变性(mutability)在作怪。每当你将一个变量赋值为另一个可变类型的变量时，对这个数据的任意改动会同时反映到这两个变量上去。新变量只不过是老变量的一个别名而已。这个情况只是针对可变数据类型。下面的函数和可变数据类型让你一下就明白了：

def add_to(num, target=[]):
    target.append(num)
    return target

add_to(1)
# Output: [1]

add_to(2)
# Output: [1, 2]

add_to(3)
# Output: [1, 2, 3]

你可能预期它表现的不是这样子。你可能希望，当你调用add_to时，有一个新的列表被创建，就像这样：

def add_to(num, target=[]):
    target.append(num)
    return target

add_to(1)
# Output: [1]

add_to(2)
# Output: [2]

add_to(3)
# Output: [3]

啊哈！这次又没有达到预期，是列表的可变性在作怪。在Python中当函数被定义时，默认参数只会运算一次，而不是每次被调用时都会重新运算。你应该永远不要定义可变类型的默认参数，除非你知道你正在做什么。你应该像这样做：

def add_to(element, target=None):
    if target is None:
        target = []
    target.append(element)
    return target

现在每当你在调用这个函数不传入target参数的时候，一个新的列表会被创建。举个例子：

add_to(42)
# Output: [42]

add_to(42)
# Output: [42]

add_to(42)
# Output: [42]

详解：
在Python中，默认参数在函数定义时就被解析和创建了。这意味着如果默认参数是一个可变类型（如列表、字典等），那么这个参数在整个程序运行期间都指向同一个对象。

当我们来看第一个函数

def add_to(num, target=[]):
    target.append(num)
    return target

这里的 target=[] 表示默认情况下 target 是一个空列表。但是这个列表在函数定义时就创建了，并且在后续的函数调用中，如果没有明确传入 target 参数，那么就会使用这个在定义时创建的列表。

当你第一次调用 add_to(1) 时，由于没有提供 target 参数，它使用了默认的列表，并向其中添加了数字 1。现在这个列表不再是空的，而是 [1]。

当你第二次调用 add_to(2) 时，同样的事情发生了，但这次 target 仍然使用的是那个默认列表，也就是现在内容为 [1] 的列表。所以当你添加 2 到 target 中时，你实际上是向那个已经包含了 1 的列表中添加了 2，结果就是 [1, 2]。

这就是为什么在第二次调用时，你是在向同一个列表中添加元素的原因。因为默认参数在函数定义时被初始化，并且在后续的调用中，如果没有显式地传递不同的参数，那么它将始终引用最初创建的那个对象。