相关疑难解决方法(0)

有这个代码:

# assignment behaviour for integer
a = b = 0
print a, b # prints 0 0
a = 4
print a, b # prints 4 0 - different!

# assignment behaviour for class object
class Klasa:
    def __init__(self, num):
        self.num = num

a = Klasa(2)
b = a
print a.num, b.num # prints 2 2
a.num = 3
print a.num, b.num # prints 3 3 - the same!

问题:

1. 为什么赋值运算符对基本类型和类对象的工作方式不同(对于基本类型,它按值复制,对于通过引用复制的类对象)？
2. 如何只按值复制类对象？
3. 如何为C++ int&b = a中的基本类型引用？

在下面的python代码中,变量number被传递给函数addone,并且操作本地副本.数字的值保持不变.

def addone(num):
    num = num + 1
    print "function: added 1, now %d" % num

number = 5
print "Before:", number
addone(number)
print "After:", number

输出:

Before: 5
function: added 1, now 6
After: 5

但是,行为似乎与pop,append等列表操作不同.这有点让我感到困惑.所有列表操作是否全局运行？如果是这样,背后有什么特别的原因吗？

def pop_first(stuff):
    popped = stuff.pop(0)
    print "function: '%s' was popped!" % popped

words = ["A", "list", "of", "words"]
print "Before:", words
pop_first(words)
print "After:", words

输出:

Before: ['A', 'list', 'of', 'words']
function: 'A' was popped!
After: ['list', 'of', 'words']

这是一个简单的问题,但我在SO中找不到类似的问题.无论如何都是以Python的形式返回？(也许是简单的黑客攻击.)

返回参考说明:

def func(lst):
    return reference of lst[2] somehow

func([7, 8, 9, 10])        # returns 9
func([7, 8, 9, 10]) = 11   # lst is changed to [7, 8, 11, 10]

这种行为是否可以实现？可能有一些运算符重载？

C++中此用法的一个示例:在C++中通过引用返回值

函数的预期目标foo是将作为参数提供的数字添加到列表中,如果它为0,则重置列表.首先我写了这个程序:

def foo(n, bar = []):
    if n == 0:
        bar = []
        print("list empty")
    else:
        bar.append(n)
        for y in bar:
            print(y, end=', ')
        print()

foo(5)
foo(3)
foo(0)
foo(6)

输出:

5, 
5, 3, 
list empty
5, 3, 6, 

但它看起来像bar = []被忽略了.然后我改变bar = []了bar.clear(),它按照我的想法运作:

def foo(n, bar = []):
    if n == 0:
        bar.clear()
        print("list empty")
    else:
        bar.append(n)
        for y in bar:
            print(y, end=', ')
        print()

foo(5)
foo(3)
foo(0)
foo(6)

输出:

5, 
5, …

def change(s):
    s = s + "!"


word = "holiday"
change(word)    
print word

为什么输出这个是"假日"而不是"假日"？是因为3行代码不属于函数吗？如果是这样,为什么它会在函数之外,因为它是在更改函数之后？

这是我在Python中实现二叉树实现的代码片段.这在运行PreOrder函数时起作用.

class Node:
    def __init__(self,data):
        self.left = None
        self.right = None
        self.data = data

class BinaryTree(Node):
    def __init__(self):
        self.root = None

    def addNode(self,data):
        return Node(data)

    def insert(self,root,data):
        if(root == None):
            root = self.addNode(data)
        else:
            if(data <= root.data):
               root.left = self.insert(root.left,data)
            else:
                root.right = self.insert(root.right,data)
        return root

    def PreOrder(self,root):
        if root == None:
            pass
        else:
            print(root.data)
            self.PreOrder(root.left)
            self.PreOrder(root.right)



a = BinaryTree()
root = a.addNode(2)
#root = None
a.insert(root,4)
a.insert(root,34)
a.insert(root,45)
a.insert(root,46)
a.insert(root,41)
a.insert(root,48)
a.PreOrder(root)

然而,改变主要的第2和第3行

#root = a.addNode(2)
root = None …

我只是觉得我已经把它记下来了,因为我已经看过了 - 对这种行为得到确认会很好; 我确实看到如何通过引用传递变量？,但我不确定如何在这种情况下解释它.

假设我们有这两个数组/列表:

a = [1, 2, 3, 4]
b = [-1, a, -100, a[2], -1]

口译员最初将其视为:

>>> print(a)
[1, 2, 3, 4]
>>> print(b)
[-1, [1, 2, 3, 4], -100, 3, -1]

现在让我们改变a[2],看看会发生什么:

>>> print(a)
[1, 2, 55, 4]
>>> print(b)
[-1, [1, 2, 55, 4], -100, 3, -1]

所以,无论列表b具有的参考名单 a,该值已经更新-但只要b有一个(一个引用？)被初始化从元素列表a,似乎是Python的扩展在初始化时的值,这样存储的元素值(不是通过引用),所以它的值显然不会更新.

基本上,我找到了一个用例,在这里可以方便地定义eg b = [-1 a[2] -1],然后更新a[2],并且能够计算出a[2]获取(在这种情况下)的值时将发出的最新值b[1] …

有没有办法在dict值中保留对列表元素的引用,并通过dict修改列表？

a = [1, 2]
b = [11, 22]

d = {k: v for k, v in zip(a, b)}
d[1] = 33
print b, d

输出是第二次打印:

[11, 22] {1: 33, 2: 22}

虽然我想:

[33, 22] {1: 33, 2: 22}

我怀疑字典创建者和修改都不正确...

在C中,可以将指针保留在字典中并通过*运算符修改值.

有什么类似的python或任何其他pythonic方式来实现这一点？

我之前正在编写一个小文件实用程序,并且通过引用传递了一个问题.阅读后如何通过引用传递变量？,我将我想要传递的变量设置为参数,并将其设置为返回值.在下面的代码中,它是行:

diff = compareDir(path0, path0List, path1, path1List, diff)

其中diff是我希望通过引用传递的变量.

虽然这有效,但感觉相当尴尬.我认为必须有更好的方法.在许多其他语言中,我可以设置compareLists()为没有返回值,并使用修改pass-by-reference参数的副作用.Python的pass-by-assignment似乎不允许这样做.

我对python比较陌生,想知道是否有更多的pythonic方法来解决我的问题.是否需要完全重新考虑这些功能？或者有一个我不知道的好声明？我想远离全局变量.

我欢迎任何建设性的批评和评论.谢谢!

相关守则:

def comparePaths(path0, path1):
    path0List = os.listdir(path0)
    path1List = os.listdir(path1)

    diff = False
    diff = compareDir(path0, path0List, path1, path1List, diff)
    print()
    diff = compareDir(path1, path1List, path0, path0List, diff)
    return diff

def compareDir(basePath, baseList, comparePath, compareDir, diffVar):
    for entry in baseList:
        #compare to the other folder
        if (not (entry in compareDir)):
            if (not (diffVar)):
                diffVar = True
                print ("Discreptancies found. The following files are different:") …

我希望将列表中的所有元素乘以数字.我知道其他方法,但我想知道为什么这不起作用？我得到了与输出完全相同的列表.

lst = eval(input('enter a list'))
for num in lst:
     num = num * 2
print(lst)