相关疑难解决方法(0)

有人能指出我做错了什么或我的理解错了吗？

对我来说,下面的实例化两个对象的代码似乎应该为每个实例化提供单独的数据.

class Node:
    def __init__(self, data = []):
        self.data = data

def main():
    a = Node()
    a.data.append('a-data') #only append data to the a instance

    b = Node() #shouldn't this be empty?

    #a data is as expected
    print('number of items in a:', len(a.data))
    for item in a.data:
        print(item)

    #b data includes the data from a
    print('number of items in b:', len(b.data))
    for item in b.data:
        print(item)

if __name__ == '__main__':
    main()

但是,第二个对象是使用第一个数据创建的:

>>> 
number of items in a: 1
a-data …

def a(b=[]):
    b.append(1)
    return b

print a()
print a()

我突然得到了一张2元的名单,但是如何？不应该每次都被设置为空列表.

谢谢您的帮助

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

#!/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有
什么提示吗？:)
提前谢谢

可能重复:
Python中的"最小惊讶":可变默认参数

我创建了一个Person类,它有一个名字和一个子列表.孩子们属于同一个人类.如果我创建两个Person实例,并将子项添加到其中一个人员实例,则会将其添加到两个Person实例中.我认为孩子应该只添加到person1的孩子而不是person2,但它会被添加到两者中.我必须做一些明显不对的事,但我看不出来.

类似的问题表明人们将变量定义添加到类本身而不是构造函数,但这不是这里发生的事情.任何帮助都会非常感激,它正在煎炸我的大脑!

请参阅下面的代码和输出:

class Person(object):

    def __init__(self, name, children=[]):
        self.name = name
        self.children = children

    def __repr__(self):
        return '<' + self.name + '>'

    def add_child(self, child):
        self.children.append(child)


def main():
    person1 = Person('Person1')
    person2 = Person('Person2')

    person1.add_child(Person("Person 1's child"))

    print "Person 1's children:", person1.children
    print "Person 2's children:", person2.children

if __name__ == "__main__":
    main()

此代码的输出是:

Person 1's children: [<Person 1's child>]
Person 2's children: [<Person 1's child>]

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

i = 5

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

i = 6
f()

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

python中有什么方法可以用来从堆中获取内存块，并可以使用变量来引用它。就像关键字“ new”或malloc()其他语言的函数一样：

Object *obj = (Object *) malloc(sizeof(Object)); 
Object *obj = new Object();

在项目中，我的程序正在等待以不确定的时间间隔接收某些数据，并且在正确时具有一定的字节长度。

我习惯这样：

void receive()// callback
{
  if(getSize()<=sizeof(DataStruct))
  {
   DataStruct *pData=malloc(sizeof(DataStruct));
   if(recvData(pData)>0)
   list_add(globalList,pData);
  }   
}

void worker()
{
  init()
  while(!isFinish)
 {
  dataProcess(globalList);
 }

}

现在，我想将这些旧项目迁移到python，并尝试这样做：

def reveive():
 data=dataRecv()
 globalList.append(data)

但是，我得到列表中的所有项目都是相同的，并且等于最新收到的项目。显而易见，所有列表项都指向相同的内存地址，并且我想为每个调用该函数的用户获取一个新的内存地址。

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

两天前,我试图解决最短路径问题.我有一个下面的图(它在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', …

我在Python hitchhikers 指南中看到了这个例子：

def create_multipliers():
    return [lambda x, i=i : i * x for i in range(5)]

上面的示例是对后期绑定引起的一些问题的解决方案，其中在调用内部函数时查找闭包中使用的变量。

i=i 是什么意思以及为什么会产生如此大的差异？

我知道我们可以使用self或class名称访问类属性。

但我有点困惑为什么以下也有效

class Crazy(object):
  VERSION = 1
  def __init__(self, version=VERSION):
    print version

但这不

class Crazy(object):
  VERSION = 1
  def __init__(self):
    print VERSION