相关疑难解决方法(0)

我对List副本有一些问题:

所以我E0来之后'get_edge',我E0打电话给我'E0_copy = list(E0)'.在这里,我想E0_copy是的深层副本E0,和我通E0_copy入'karger(E)'.但在主要功能.
为什么'print E0[1:10]'for循环之前的结果与for循环之后的结果不一样？

以下是我的代码:

def get_graph():
    f=open('kargerMinCut.txt')
    G={}
    for line in f:
        ints = [int(x) for x in line.split()]
        G[ints[0]]=ints[1:len(ints)]
    return G

def get_edge(G):
    E=[]
    for i in range(1,201):
        for v in G[i]:
            if v>i:
                E.append([i,v])
    print id(E)
    return E

def karger(E):
    import random
    count=200 
    while 1:
        if count == 2:
            break
        edge = random.randint(0,len(E)-1)
        v0=E[edge][0]
        v1=E[edge][1]                   
        E.pop(edge)
        if …

我想模仿python中的pass-by-value行为.换句话说,我想确保我写的函数不会修改用户提供的数据.

一种可能的方法是使用深层复制:

from copy import deepcopy
def f(data):
    data = deepcopy(data)
    #do stuff

是否有更高效或更pythonic的方式来实现这一目标,尽可能少地假设传递的对象(如.clone()方法)

编辑

我知道技术上python中的所有内容都是按值传递的.我有兴趣模仿行为,即确保我不会混淆传递给函数的数据.我想最常用的方法是使用自己的克隆机制或深度复制来克隆有问题的对象.

我希望能够通过调用已实例化的对象上的方法来创建对象的新实例.例如,我有对象:

organism = Organism()

我希望能够调用organism.reproduce()并拥有两个类型为Organism的对象.我的方法在这一点看起来像这样:

class Organism(object):
    def reproduce():
        organism = Organism()

并且我很确定它不起作用(我甚至不确定如何测试它.我在这篇文章中尝试了gc方法).那么我怎样才能让我的对象创建一个可以访问的副本,就像我创建的第一个对象一样organism = Organism()？

我有以下型号:

class Ticket(models.Model):
    title = models.CharField()
    merged_to = models.ForeignKey("self", related_name='merger_ticket', null=True, blank=True)
    looser_ticket = models.BooleanField(default=False)

有几种操作模型的方法:

第一

ticket = Ticket.objects.get(pk=1)
ticket.title = "This is edit title"
ticket.merged_to_id = 2
ticket.looser_ticket = True

第二

ticket = Ticket.objects.get(pk=1)
setattr(ticket, "title", "Edit Title")
setattr(ticket, "merged_to_id", 2)
setattr(ticket, "looser_ticket", True)

当我操作这些东西时,在布尔值更新的视图中,第一种方法不起作用,但第二种方法有效.使用第一个和第二个之间有什么区别,什么时候应该使用它们？

谢谢!

我想在python中复制一个类实例.我试过,copy.deepcopy但我收到错误消息:

RuntimeError:此时只有用户显式创建的变量(图形离开)才支持deepcopy协议

所以假设我有类似的东西:

class C(object):
    def __init__(self,a,b, **kwargs):
        self.a=a
        self.b=b
        for x, v in kwargs.items():
            setattr(self, x, v)

c = C(4,5,'r'=2)
c.a = 11
del c.b

现在我想做一个相同的深层副本c,有一个简单的方法吗？

我有一个对象，它有自己的内容（即某物的列表）和对另一个对象的引用，它与其链接。如何排除对另一个对象的引用进行深度复制？

from copy import deepcopy
class Foo:
    def __init__(self, content, linked_to):
        self.content = content
        self.linked_to = linked_to

a1 = Foo([[1,2],[3,4]], None)
a2 = Foo([[5,6],[7,8]], a1)

a3 = deepcopy(a2) # <- I don't want there, that a3.linked_to will be copied
# I want that a3.linked_to will still point to a1

a3.linked_to.content.append([9,10])
print a1.content # [[1,2],[3,4]], but I want [[1,2],[3,4], [9,10]] 

我正在尝试为自定义 deepcopy实现此答案，但带有类型提示，而 mypy 对Any我从第三方库中使用的类型不满意。这是我可以失败的最小代码

# I'm actually using tensorflow.Module, not Any,
# but afaik that's the same thing. See context below
T = TypeVar("T", bound=Any)

def foo(x: T) -> None:
    cls = type(x)
    cls.__new__(cls)

我懂了

 error: No overload variant of "__new__" of "type" matches argument type "Type[Any]"
 note: Possible overload variants:
 note:     def __new__(cls, cls: Type[type], o: object) -> type
 note:     def __new__(cls, cls: Type[type], name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type

如果我绑定 …