相关疑难解决方法(0)

深拷贝和浅拷贝之间有什么区别？

import copy

a = "deepak"
b = 1, 2, 3, 4
c = [1, 2, 3, 4]
d = {1: 10, 2: 20, 3: 30}

a1 = copy.copy(a)
b1 = copy.copy(b)
c1 = copy.copy(c)
d1 = copy.copy(d)


print("immutable - id(a)==id(a1)", id(a) == id(a1))
print("immutable - id(b)==id(b1)", id(b) == id(b1))
print("mutable - id(c)==id(c1)", id(c) == id(c1))
print("mutable - id(d)==id(d1)", id(d) == id(d1))

我得到以下结果 -

immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) False
mutable - id(d)==id(d1) False

如果我进行深度扫描 …

我想创建一个对象的副本.我希望新对象拥有旧对象的所有属性(字段的值).但我想拥有独立的对象.因此,如果我更改新对象的字段值,则旧对象不应受此影响.

我希望下面的代码只会初始化dict_a,dict_b以及dict_c字典.但它接触到副本通过效果:

dict_a = dict_b = dict_c = {}
dict_c['hello'] = 'goodbye'

print dict_a
print dict_b
print dict_c

如您所见,结果如下:

{'hello': 'goodbye'}
{'hello': 'goodbye'}
{'hello': 'goodbye'}

为什么该程序会给出以前的结果,当我希望它返回时:

{}
{}
{'hello': 'goodbye'}

简而言之,问题是:有没有办法阻止Python查找当前范围之外的变量？

细节:

如果未在当前作用域中定义,Python会在外部作用域中查找变量定义.因此,在重构期间不小心时,这样的代码可能会破坏:

def line(x, a, b):
    return a + x * b

a, b = 1, 1
y1 = line(1, a, b)
y2 = line(1, 2, 3)

如果我重命名了函数参数,但忘了在函数体内重命名它们,代码仍会运行:

def line(x, a0, b0):
    return a + x * b  # not an error

a, b = 1, 1
y1 = line(1, a, b)  # correct result by coincidence
y2 = line(1, 2, 3)  # wrong result

我知道从外部作用域中遮蔽名称是不好的做法.但是,为什么要这样做有几个原因:

• 有时,使用相同的名称可能是有意义的,因为它们指的是同一个东西
• 人们可能会用尽有意义的变量名称
• 怠惰

有没有办法阻止Python查找当前范围之外的变量？(这样在第二个例子中访问a或 …

我想这是一个有点奇怪的问题.
问题是,当我研究django代码的某些部分时,我遇到了一些我以前从未见过的东西.
根据复制差异问题及其 在字典中的用法,我们可以创建两个具有相同引用的字典.

问题是将字典的浅层副本设置为自身的目的是什么？
码:

django.template.backends.base

params = {
   'BACKEND' = 'Something',
   'DIRS' = 'Somthing Else',
}
params = params.copy()

我有字典复制方法的问题例如让我说我有

>> d = {'pears': 200, 'apples': 400, 'oranges': 500, 'bananas': 300}

>> copy_dict = d.copy()

现在,如果我检查d和copy_dict的id,则两者都不同

>> id(d)
o/p = 140634603873176

>> id(copy_dict)
o/p = 140634603821328

但如果我检查字典中对象的id,它们是相同的意思是id(d ['pears'])= id(copy_dict ['pears'])

>> id(d['pears'])
o/p = 140634603971648
>> id (copy_dict['pears'])
o/p = 140634603971648

新dict中的所有对象都引用与原始dict相同的对象.

现在,如果我在d中更改键'pears'的值,copy_dict中的相同键没有变化,当我现在检查id时,id(d ['pears'])!= id(copy_dict ['pears'] )

>> d['pears'] = 700
>> print copy_dict['pears']
o/p = 200

我的问题是,如果新dict中的对象是与原始字典相同的对象的引用,为什么当原始字典中的值发生更改时,新字典的值不会改变,以及Python如何立即更改id因为它看到价值变了？

你能否详细说明深浅拷贝的区别？

所以说我有一个字典,其默认值是另一个字典

attributes = { 'first_name': None, 'last_name': None, 'calls': 0 }
accounts = defaultdict(lambda: attributes)

问题是我传递给defaultdict(属性)的默认字典作为引用传递.我如何将其作为值传递？因此,更改一个键中的值不会更改其他键中的值

例如 -

accounts[1]['calls'] = accounts[1]['calls'] + 1
accounts[2]['calls'] = accounts[2]['calls'] + 1
print accounts[1]['calls'] # prints 2
print accounts[2]['calls'] # prints 2

我希望他们每个人都打印1,因为我只增加了他们各自的"调用"值一次.

为了简单解析/创建 JSON，机器学习应用程序通常使用Bunch对象，例如https://github.com/dsc/bunch/blob/master/bunch/__init__.py

获取时，有一个嵌套的 EAFP 习语，它检查dict.get()函数，然后尝试使用字典方括号语法访问它，即

class Bunch(dict):
    def __getattr___(self, k):
        try:
            return object.__getattribute__(self, k)
        except AttributeError:
            try: 
                 return self[k]
            except KeyError:
                 raise AttributeError

当试图设置一个属性时，

    def __setattr__(self, k, v):
        try:
            # Throws exception if not in prototype chain
            object.__getattribute__(self, k)
        except AttributeError:
            try:
                self[k] = v
            except:
                raise AttributeError(k)
        else:
            object.__setattr__(self, k, v)

似乎sklearn实现遵循相同的思路，但检查较少https://github.com/scikit-learn/scikit-learn/blob/2beed5584/sklearn/utils/__init__.py#L61

class Bunch(dict):
    def __init__(self, **kwargs):
        super().__init__(kwargs)

    def __setattr__(self, key, value):
        self[key] = value

    def __dir__(self):
        return self.keys()

    def __getattr__(self, …

我正在改变for循环中的状态字典,并在每次迭代时将新状态附加到列表中.

在Python中,字典当然是可变的,因此附加到列表中的是对连续变异字典对象的引用.所以最后我得到一个相同重复引用的列表,指向状态的最终版本.

state = {'temp': 21.6, 'wind': 44.0}
state_list = []
for i in range(10):
    state['temp'] += 0.5
    state['wind'] -= 0.5
    state_list.append(state)

有没有办法告诉翻译我希望"通过价值传递"？我能够在追加前的行中构造一个元组或一些可变的元素,并在列表中附加说明元组.我只是想检查这是最好的解决方案.