我真的坚持为什么下面的代码块1导致输出1而不是输出2？

代码块1:

class FruitContainer:
       def __init__(self,arr=[]):
           self.array = arr
       def addTo(self,something):
           self.array.append(something)
       def __str__(self):
           ret = "["
           for item in self.array:
               ret = "%s%s," % (ret,item)
           return "%s]" % ret

arrayOfFruit = ['apple', 'banana', 'pear']
arrayOfFruitContainers = []

while len(arrayOfFruit) > 0:
   tempFruit = arrayOfFruit.pop(0)
   tempB = FruitContainer()
   tempB.addTo(tempFruit)
   arrayOfFruitContainers.append(tempB)

for container in arrayOfFruitContainers:
   print container 

**Output 1 (actual):**
[apple,banana,pear,]
[apple,banana,pear,]
[apple,banana,pear,]

**Output 2 (desired):**
[apple,]
[banana,]
[pear,]

此代码的目标是迭代数组并将每个数据包装在父对象中.这是我的实际代码的减少,它将所有苹果添加到一袋苹果等等.我的猜测是,出于某种原因,它要么使用相同的对象,要么就像水果容器使用静态数组一样.我不知道如何解决这个问题.

我今天遇到了一个有趣的python bug,其中实例化一个类似乎反复出现状态.在以后的实例化调用中,已经定义了变量.

我将问题归结为以下类/ shell交互.我意识到这不是初始化类变量的最佳方法,但它肯定不应该像这样.这是一个真正的错误还是这个"功能"？:d

tester.py:

class Tester():
        def __init__(self):
                self.mydict = self.test()

        def test(self,out={}):
                key = "key"
                for i in ['a','b','c','d']:
                        if key in out:
                                out[key] += ','+i
                        else:   
                                out[key] = i 
                return out

Python提示:

Python 2.6.6 (r266:84292, Oct  6 2010, 00:44:09) 
[GCC 4.2.1 (Apple Inc. build 5664)] on darwin
>>> import tester
>>> t = tester.Tester()
>>> print t.mydict
{'key': 'a,b,c,d'}
>>> t2 = tester.Tester()
>>> print t2.mydict
{'key': 'a,b,c,d,a,b,c,d'}

我有这个简单的课程:

class revs:
    def __init__(self, rev, us, accs = []):
        self.rev = rev
        self.us = us
        self.accs = accs

我有这段代码将值赋予列表并且在循环内部

rev, usu = cada_l.split("|")
acct = each_l[:2].strip()
list_acct.append(acct)

最后,我创建了一个dict,来管理这样的转速列表:

drevs = {}
cada = revs(rev, us, list_acct)
drevs[cada.rev] = cada

并且它与rev和我们一起正常工作,但是list_acct正在更新所有实例:

drevs['1'].rev
'1'
drevs['2'].rev
'2'
drevs['1'].us
'user1'
drevs['2'].us
'user2'
drevs['1'].accs
'["Doc1","Doc2"]'
drevs['2'].accs
'["Doc1","Doc2"]'

如果我改变list_acct.clear(),所有实例中的值都是清楚的,我仍然是Python的新手,这让我很困惑.

谢谢

我相信你很清楚,python和大多数编程语言一样,都带有内置异常.我已经浏览了这个列表,并且不能推断哪个是合适的.当然我可以做出我自己的例外,但这是一个相当标准的错误,将被排除在外.

这是基于实例关系的错误.类的实例仅与其他一些实例相关.可以根据不同的连接进行计算.raise如果尝试对不相关的实例进行计算,则此错误将为d.

例

class Foo:
    def __init__(self,related=None):
        '''related is a list of Foo instances'''
        if related is not None:
            self.related = related
        else:
            self.related = []
    def compute(self,instance):
        if instance in self.related:
            #execute code
        else:
            raise SomeError("You cannot make a computation with an unrelated instance")

我的想法

说实话,似乎ValueError最有意义,因为价值是不允许的,但由于某种原因,这并不能完全适合我.没有关系的事实是这个错误的重要性,而不仅仅是不允许尝试的值这一事实.

我的逻辑是否有比ValueError更好的异常？

注意:我知道这ValueError可能是正确的答案,但我很好奇是否有更精确的东西,当我浏览文档时,我可能无法看到它的连接.

我想创建一个类的实例,其中包含默认为空的列表; 而不是以后将此列表设置为最终完整列表,我想连续添加项目.这是一段示例代码,说明了这一点:

#!/usr/bin/python

class test:
    def __init__(self, lst=[], intg=0):
        self.lista   = lst
        self.integer = intg

name_dict = {}
counter   = 0

for name in ('Anne', 'Leo', 'Suzy'):
    counter += 1

    name_dict[name] = test()
    name_dict[name].integer += 1
    name_dict[name].lista.append(counter)

    print name, name_dict[name].integer, name_dict[name].lista

当我运行上述程序时,我希望得到

安妮1 [1]
狮子座1 [2]
Suzy 1 [3]

因为我假设lista总是初始化为空列表.

我得到的是这样的:

安妮1 [1]
狮子座1 [1,2]
Suzy 1 [1,2,3]

如果我更换self.lista = lst由self.lista = []它工作正常,当我添加行就像name_dict[name].lista = []for循环.

为什么保留先前对象列表的内容,但它们的值integer不是？我对Python很陌生,所以如果有人可以向我指出我的想法/假设误入歧途,那将会很棒.

非常感谢您的回复.

我知道这种类型的结构有模块,但我喜欢并且更愿意自己了解事情是如何运作的.所以...我正在尝试从图形中扩展路径,例如:

g = dict(
    s=['a','d','s'],
    a=['s','d','b'],
    d=['s','a','e'],
    b=['a','e','c'],
    e=['d','b','f'],
    f=['e','g'],
    c=['b'],
    g=['f'])

到目前为止,我可以看到给定节点的邻居:

def vecinosDe(n = ''):
    return g[n]

我希望每次调用一个给定一个参数的函数时,一个图形节点,返回与给定参数相连的其他节点的列表.
然后输入给定,创建的相同列表到同一个函数,以返回连接到给定列表图节点的节点,并连续地返回到达'g'节点.
我也知道我需要检查连接到给定节点的节点是否有任何递归(循环).

这是我到目前为止的代码:

def expandir(n = '', lista = []):
    lista.append([n]) #or lista = lista + [n]?
    for v in g[n]:
        for i in range(len(lista)): #?
            lista[i].append(v)
    return lista

这就是发生的事情,我知道这不好,哈哈.

>>> expandir('s')
[['s', 'd', 'a', 's']]
>>> expandir('d')
[['S', 'D', 'A', 'S', 'S', 'A', 'E'], ['D', 'S', 'A', 'E']]

在第二个for循环中的代码的某些部分,我想我应该检查是否有一个节点等于我要扩展的节点,给定的节点.这是我被卡住的地方.
试试这个？

if n == v:  #?

另外我认为这可能需要某种递归,对吧？但是我想要一些提示来继续拼图.:P

我应该返回列表,列表清单吗？......怎么样？:S有
什么提示吗？:)
提前谢谢

我对以下概念并不陌生：

TypeError: unhashable type: 'OrderedDict'

但是我不明白下面的代码行如何产生这样的堆栈跟踪。

89:     @staticmethod
90:     def diff(var1, var2, path=[], level=0, curpath=[]):
...
101:        elif isinstance(var1, list) and isinstance(var2, list):
102:            l1s = set(var1)
103:            l2s = set(var2)
104:            retlist = []

  File "myFile.py", line 102, in diff
    l1s = set(var1)
TypeError: unhashable type: 'OrderedDict'

102上面的代码中的line怎么会抛出这样的异常？

我正在学习Python并遇到了一个我不太了解的例子.在官方教程中,给出了以下代码:

i = 5

def f(arg=i):
    print(arg)

i = 6
f()

来自c ++,直觉对我来说这将打印5.但我也想理解技术解释:"默认值在定义范围内的函数定义点进行评估." "定义范围"在这里意味着什么？

当我为什么要使用attr.ib(default=attr.Factory(list))过attr.ib(default=[])？

从文档中我看到Factory用于生成一个新值,如果你使用带输入的lambda表达式,这是有意义的; 但是,如果您只是生成一个空列表,我不明白为什么要使用它.

我在这里错过了什么？

我在'递归函数'中相当新.所以,我试图解决为什么我们使用递归函数以及递归函数如何工作,我想我对它有一个相当好的理解.

两天前,我试图解决最短路径问题.我有一个下面的图(它在python中):

 graph = {'a': ['b', 'c'],
             'b': ['c', 'd'],
             'c': ['d'],
             'd': ['c'],
             'e': ['f'],
             'f': ['c']}

我只是想找到一条路,而不是最短路径.所以,这里是代码:

def find_path(graph,start,end,path=[]):
    path = path + [start]
    #Just a Test
    print(path)

    if start == end:
        return path

    if start not in graph:
        return None

    for node in graph[start]:
        if node not in path:
            new_path = find_path(graph,node,end,path)
        if new_path:
            #Just a test
            print(path)
            return new_path

print(find_path({'a':['b','c'],'b':['c','d'],'c':['d'],'d':['c'],'e':
['f'],'f':['c']},'a','d'))

我的起始顶点是'a',结束顶点是'd'.

在第四行中,我只是打印了"路径"以查看路径的位置.

在第17行,我还打印了"路径",再次进行测试.这是结果:

['a']
['a', 'b']
['a', 'b', 'c']
['a', 'b', 'c', 'd']
['a', 'b', …