相关疑难解决方法(0)

在阅读文档时dict.copy(),它说它是字典的浅层副本.我所遵循的书(Beazley的Python参考书)也是如此,它说:

m.copy()方法生成映射对象中包含的项的浅表副本,并将它们放在新的映射对象中.

考虑一下:

>>> original = dict(a=1, b=2)
>>> new = original.copy()
>>> new.update({'c': 3})
>>> original
{'a': 1, 'b': 2}
>>> new
{'a': 1, 'c': 3, 'b': 2}

所以我假设这会更新original(并添加'c':3)的值,因为我正在做一个浅拷贝.就像你为列表做的那样:

>>> original = [1, 2, 3]
>>> new = original
>>> new.append(4)
>>> new, original
([1, 2, 3, 4], [1, 2, 3, 4])

这按预期工作.

由于两者都是浅拷贝,为什么dict.copy()它不能像我期望的那样工作？或者我对浅层和深层复制的理解是有缺陷的？

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

如果我进行深度扫描 …

array1=[0,1,2]
array2=array1
array2[0]=234234
print array1

OUTPUT:

[234234, 1, 2]

为什么python会改变'array1'？它不应该只改变array2吗？当我更改array2时,如何防止python更改array1？

我理解在python中的每一件事,无论是数字,字符串,字典还是任何东西都是一个对象.变量名只是指向内存中的对象.现在根据这个问题,

>> a_dict = b_dict = c_dict = {}

这将创建一个空字典,并且所有变量都指向此dict对象.因此,改变任何一个都会反映在其他变量中.

>> a_dict["key"] = "value" #say
>> print a_dict
>> print b_dict
>> print c_dict

会给

{'key': value}
{'key': value}
{'key': value}

我已经理解了指向对象的变量的概念,所以这看起来很公平.

现在即使它可能很奇怪,因为它是如此基本的陈述,为什么会发生这种情况？

>> a = b = c = 1
>> a += 1
>> print a, b, c
2, 1, 1   # and not 2, 2, 2

问题的第一部分:为什么这里应用的概念不同？

实际上,当我试图为此寻找解决方案时,出现了这种疑问:

>> a_dict = {}
>> some_var = "old_value"
>> a_dict['key'] = some_var
>> some_var = "new_value" …

对于我正在研究的项目,我正在实现一个链表数据结构,它基于一对的概念,我定义为:

class Pair:
    def __init__(self, name, prefs, score):
        self.name = name
        self.score = score
        self.preferences = prefs
        self.next_pair = 0
        self.prev_pair = 0

where self.next_pair和self.prev_pair是分别指向上一个和下一个链接的指针.

要设置链表,我有一个看起来像这样的安装功能.

def install(i, pair):
    flag = 0
    try:
        old_pair = pair_array[i]
        while old_pair.next_pair != 0:
            if old_pair == pair:
                #if pair in remainders: remainders.remove(pair)
                return 0
            if old_pair.score < pair.score:
                flag = 1
                if old_pair.prev_pair == 0: # we are at the beginning
                    old_pair.prev_pair = pair
                    pair.next_pair = old_pair
                    pair_array[i] = pair …

对于ProjectEuler上的任务,我编写了一些代码,该代码使用强力来查找低于100的最长的素数链,这些素数加起来为素数,并且代码确实给出了正确的结果.因此对于低于100的数字,答案是2 + 3 + 5 + 7 + 11 + 13 = 41

import math

def prime(n):
    for x in xrange(2,int(math.sqrt(n)+1)):
        if n%x == 0:
            return False
    return True

primes = []

for x in xrange(2,100):
    if prime(x):
        primes += [x]

record = 0
i = 0

for num in primes:
    i += 1
    chain = [num]
    for secnum in xrange(i,len(primes)-1):
        chain += [primes[secnum]]
        if len(chain) > record and sum(chain) in primes:
            record = len(chain)
            seq = chain
            print seq …

我读到 python 中的赋值不会像在 c 中那样复制它，它会为对象分配一个指针。

但是当我调试这个函数时：

def popall(self):
    objs = self.curstack
    self.curstack = []
    return objs

看起来正在进行某种复制。这个函数运行后obis满是东西，self.curstack是空的……

所以一些副本正在进行中。它是深的还是浅的？

我为这样的变量分配了值.这很好用.

In [16]: var1 = var2 = 5
In [17]: var1 = 2
In [18]: var2
Out[18]: 5
In [19]: var1
Out[19]: 2

与list完成相同的操作.

In [20]: list1 = list2 = []
In [21]: list1.append(5)
In [22]: list1
Out[22]: [5]
In [23]: list2
Out[23]: [5]

同样的方法我初始化了两个列表.插入值后,list1但它的效果值list2.它是如何发生的.我想知道为什么会这样发生.有人请解释一下.

谢谢