9 
from cs1graphics import *
from math import sqrt

numLinks = 50
restingLength = 20.0
totalSeparation = 630.0
elasticityConstant = 0.005
gravityConstant = 0.110
epsilon     = 0.001

def combine(A,B,C=(0,0)):
    return (A[0] + B[0] + C[0], A[1] + B[1] + C[1])

def calcForce(A,B):
    dX = (B[0] - A[0])
    dY = (B[1] - A[1])
    distance = sqrt(dX*dX+dY*dY)
    if distance > restingLength:
        stretch = distance - restingLength
        forceFactor = stretch * elasticityConstant
    else:
        forceFactor = 0
    return (forceFactor * dX, forceFactor * dY)                 #return a tuple


def drawChain(chainData, chainPath, theCanvas):
    for k in range(len(chainData)):
        chainPath.setPoint(Point(chainData[k][0], chainData[k][1]),k)
    theCanvas.refresh()                             #refresh canvas

chain = []                                                             #chain here
for k in range(numLinks + 1):
    X = totalSeparation * k / numLinks
    chain.append( (X,0.0) )

paper = Canvas(totalSeparation, totalSeparation)
paper.setAutoRefresh(False)
curve = Path()
for p in chain:
    curve.addPoint(Point(p[0], p[1]))
paper.add(curve)
graphicsCounter = 100

somethingMoved = True
while somethingMoved:
    somethingMoved = False
    oldChain = list(chain)                                             #oldChain here
    for k in range(1, numLinks):
        gravForce = (0, gravityConstant)
        leftForce = calcForce(oldChain[k], oldChain[k-1])
        rightForce = calcForce(oldChain[k], oldChain[k+1])
        adjust = combine(gravForce, leftForce, rightForce)
        if abs(adjust[0]) > epsilon or abs(adjust[1]) > epsilon:
            somethingMoved = True
        chain[k] = combine(oldChain[k], adjust)
    graphicsCounter -= 1
    if graphicsCounter == 0:
        drawChain(chain, curve, paper)
        graphicsCounter = 100

curve.setBorderWidth(2)
drawChain(chain, curve, paper)

有人告诉我list([]) == []。那么为什么这段代码在做
oldChain = list(chain) 而不是oldChain = chain

这是同一件事，所以无论哪种方式都没有关系？

4

4 回答 4

16

list(chain)返回 的浅拷贝chain，相当于chain[:].

如果您想要列表的浅表副本，请使用list()，它有时也用于从迭代器中获取所有值。

y = list(x)和之间的区别y = x：

浅拷贝：

>>> x = [1,2,3]
>>> y = x         #this simply creates a new referece to the same list object
>>> y is x
True
>>> y.append(4)  # appending to y, will affect x as well
>>> x,y
([1, 2, 3, 4], [1, 2, 3, 4])   #both are changed

#shallow copy   
>>> x = [1,2,3] 
>>> y = list(x)                #y is a shallow copy of x
>>> x is y     
False
>>> y.append(4)                #appending to y won't affect x and vice-versa
>>> x,y
([1, 2, 3], [1, 2, 3, 4])      #x is still same

深拷贝：

请注意，如果x包含可变对象，则只是list()或[:]不够：

>>> x = [[1,2],[3,4]]
>>> y = list(x)         #outer list is different
>>> x is y          
False

但是内部对象仍然是对 x 中对象的引用：

>>> x[0] is y[0], x[1] is y[1]  
(True, True)
>>> y[0].append('foo')     #modify an inner list
>>> x,y                    #changes can be seen in both lists
([[1, 2, 'foo'], [3, 4]], [[1, 2, 'foo'], [3, 4]])

由于外部列表不同，因此修改 x 不会影响 y，反之亦然

>>> x.append('bar')
>>> x,y
([[1, 2, 'foo'], [3, 4], 'bar'], [[1, 2, 'foo'], [3, 4]])

处理这种使用copy.deepcopy。

于 2013-07-11T16:55:47.687 回答
3

确实list([])在功能上等同于[]，两者都创建一个新的空列表。

但x = list(y)不一样x = y。前者进行浅拷贝，后者创建对现有列表的新引用。

请注意，这list([])是低效的——它创建一个新的空列表（通过做[]），然后复制它，产生另一个空列表（通过做list(...)），然后释放原始的、未引用的列表。

于 2013-07-11T16:58:17.393 回答
2 
oldchain = list(chain)

oldchain 指向一个不是链（不是同一个对象）但具有相同内容的新列表。
*正如其他答案所提到的，这使得 oldchain 成为链的“浅拷贝”。

oldchain = chain

oldchain 只是指向链，都指向同一个对象

但是，请注意oldchain = []和oldchain = list()功能相同，因为两者都创建一个空列表。当涉及其他引用（即chain）时，它变得不同。

于 2013-07-11T16:57:40.617 回答
1

如果有帮助，这里是直接取自本书第 189 页的解释（Python 中的面向对象编程），紧挨着给出的代码片段的演示下方：

这取决于第二点和第四点的位置。但是现在第二个点的先前位置和它的更新位置之间会有差异。我们想使用第二个点的前面位置来保持一致性。出于这个原因，我们根据旧链的副本计算所有力。”

于 2013-07-19T02:31:34.823 回答