¿Cuál es la diferencia entre a = b y a = b

a=[1,2,3] b=[4,5,6] c=[] d=[] 

¿Cuál es la diferencia entre estas dos afirmaciones?

 c[:]=a d=b[:] 

Pero ambos dan el mismo resultado.

c es [1,2,3] y d es [4,5,6]

¿Y hay alguna diferencia en cuanto a funcionalidad?

c[:] = a significa reemplazar todos los elementos de c por elementos de a

 >>> l = [1,2,3,4,5] >>> l[::2] = [0, 0, 0] #you can also replace only particular elements using this >>> l [0, 2, 0, 4, 0] >>> k = [1,2,3,4,5] >>> g = ['a','b','c','d'] >>> g[:2] = k[:2] # only replace first 2 elements >>> g [1, 2, 'c', 'd'] >>> a = [[1,2,3],[4,5,6],[7,8,9]] >>> c[:] = a #creates a shallow copy >>> a[0].append('foo') #changing a mutable object inside a changes it in c too >>> a [[1, 2, 3, 'foo'], [4, 5, 6], [7, 8, 9]] >>> c [[1, 2, 3, 'foo'], [4, 5, 6], [7, 8, 9]] 

d = b[:] significa crear una copia superficial de b y asignarla a d, es similar a d = list(b)

 >>> l = [1,2,3,4,5] >>> m = [1,2,3] >>> l = m[::-1] >>> l [3,2,1] >>> l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> m = l[:] #creates a shallow copy >>> l[0].pop(1) # a mutable object inside l is changed, it affects both l and m 2 >>> l [[1, 3], [4, 5, 6], [7, 8, 9]] >>> m [[1, 3], [4, 5, 6], [7, 8, 9]] 

Lo que dijo Ashwini. 🙂 Voy a elaborar un poco:

 In [1]: a=[1,2,3] In [2]: b = a In [3]: c = a[:] In [4]: b, c Out[4]: ([1, 2, 3], [1, 2, 3]) In [5]: a is b, a is c Out[5]: (True, False) 

y de otra manera:

 In [1]: a = [1,2,3] In [2]: aold = a In [3]: a[:] = [4,5,6] In [4]: a, aold Out[4]: ([4, 5, 6], [4, 5, 6]) In [5]: a = [7,8,9] In [6]: a, aold Out[6]: ([7, 8, 9], [4, 5, 6]) 

¿Mira qué pasa?

No hay mucha diferencia. c[:]=a actualiza la lista a la que c hace referencia en su lugar. d=b[:] crea una nueva lista que es una copia de b (olvidando la lista anterior que creó en la cuarta línea). En la mayoría de las aplicaciones, es poco probable que veas la diferencia a menos que tengas otras referencias a los arreglos alrededor. Por supuesto, con la versión c[:]=... , ya debe tener una lista c .

La respuesta de Ashwini describe con precisión lo que está sucediendo, aquí hay algunos ejemplos de diferencias entre los dos métodos:

 a=[1,2,3] b=[4,5,6] c=[] c2=c d=[] d2=d c[:]=a # replace all the elements of c by elements of a assert c2 is c # c and c2 should still be the same list c2.append(4) # modifying c2 will also modify c assert c == c2 == [1,2,3,4] assert c is not a # c and a are not the same list d=b[:] # create a copy of b and assign it to d assert d2 is not d # d and d2 are no longer the same list assert d == [4,5,6] and d2 == [] # d2 is still an empty list assert d is not b # d and b are not the same list