• 对象变动(Mutation)

    对象变动(Mutation)

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

    1. foo = ['hi']
    2. print(foo)
    3. # Output: ['hi']
    4. bar = foo
    5. bar += ['bye']
    6. print(foo)
    7. # Output: ['hi', 'bye']

    刚刚发生了什么?我们预期的不是那样!我们期望看到是这样的:

    1. foo = ['hi']
    2. print(foo)
    3. # Output: ['hi']
    4. bar = foo
    5. bar += ['bye']
    6. print(foo)
    7. # Output: ['hi']
    8. print(bar)
    9. # Output: ['hi', 'bye']

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

    1. def add_to(num, target=[]):
    2. target.append(num)
    3. return target
    4. add_to(1)
    5. # Output: [1]
    6. add_to(2)
    7. # Output: [1, 2]
    8. add_to(3)
    9. # Output: [1, 2, 3]

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

    1. def add_to(num, target=[]):
    2. target.append(num)
    3. return target
    4. add_to(1)
    5. # Output: [1]
    6. add_to(2)
    7. # Output: [2]
    8. add_to(3)
    9. # Output: [3]

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

    1. def add_to(element, target=None):
    2. if target is None:
    3. target = []
    4. target.append(element)
    5. return target

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

    1. add_to(42)
    2. # Output: [42]
    3. add_to(42)
    4. # Output: [42]
    5. add_to(42)
    6. # Output: [42]