Referencia compartida en Python

Vamos, asignamos una variable x al valor 5, y otra variable y a la variable x.

x = 5
y = x

Cuando Python mira la primera declaración, lo que hace es que, primero, crea un objeto para representar el valor 5. Luego, crea la variable x si no existe y la convierte en una referencia a este nuevo objeto 5. La segunda línea hace que Python cree la variable y, y no se le asigna x, sino que se hace referencia a ese objeto que hace x. El efecto neto es que las variables x e y terminan haciendo referencia al mismo objeto. Esta situación, con varios nombres que hacen referencia al mismo objeto, se denomina referencia compartida en Python.
Ahora bien, si escribimos:

x = 'Geeks'

Esta declaración crea un nuevo objeto para representar a ‘Geeks’ y hace que x haga referencia a este nuevo objeto. Sin embargo, y todavía hace referencia al objeto original, es decir, 5. Nuevamente, si escribimos una declaración más como:

b = 10

Esta declaración provoca la creación de un nuevo objeto e hizo que y haga referencia a este nuevo objeto. El espacio ocupado por el objeto anterior se recupera si ya no se hace referencia a él, es decir, el espacio del objeto se devuelve automáticamente al grupo de espacio libre, para ser reutilizado para un objeto futuro.
Esta recuperación automática del espacio del objeto se conoce como recolección de basura .

Referencia compartida y cambios en el lugar

Hay objetos y operaciones que realizan cambios de objetos en el lugar. Por ejemplo, una asignación a un elemento en una lista en realidad cambia el objeto de lista en su lugar, en lugar de crear un nuevo objeto de lista. Para los objetos que admiten cambios en el lugar, debe tener mucho cuidado con la referencia compartida, ya que un cambio en uno puede afectar a los demás.

L1 = [1, 2, 3, 4, 5]
  
L2 = L1

Al igual que x e y, L1 y L2, después de la declaración 2, se referirán al mismo objeto. Si cambiamos el valor del lugar 0 en L1, ahora piense en lo que sucederá, ¿si cambiará solo L1 o L1 y L2?

L1 = [1, 2, 3, 4, 5]
L2 = L1
  
L1[0] = 0
  
print(L1)
print(L2)

Producción:

[0, 2, 3, 4, 5]
[0, 2, 3, 4, 5]

Por lo tanto, el cambio en L1 se refleja en L2. En lugar de crear un nuevo objeto para L1, sobrescribe la parte del objeto de la lista en ese lugar. Este es un cambio en el lugar. Si aún queremos mantener una copia separada para L2 de modo que cualquier cambio en L1 no se refleje en L2, entonces podemos solicitar a Python que cree una copia de la lista L1 para L2.

L1 = [1, 2, 3, 4, 5]
L2 = L1[:]
  
L1[0] = 0
  
print(L1)
print(L2)

Producción:

[0, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

Nota: esta técnica de corte no funciona para diccionarios y conjuntos.

Debido al modelo de referencia de Python, hay dos formas diferentes de verificar la igualdad en el Programa de Python.

L1 = [1, 2, 3, 4, 5]
L2 = L1
  
print(L1 == L2)
print(L1 is L2)

Producción:

True
True

El primer método, el ==operador prueba si los objetos referenciados tienen los mismos valores, si tienen los mismos valores, devuelve True, de lo contrario False. El segundo método, el is operator, prueba la identidad del objeto: devuelve True solo si ambos nombres apuntan exactamente al mismo objeto, por lo que básicamente es una forma mucho más fuerte de prueba de igualdad. Sirve como una forma de detectar referencias compartidas en su código si es necesario. Devuelve False si los nombres apuntan a un objeto equivalente pero diferente.

Ahora, aquí viene una parte complicada:
mire el siguiente código,

L1 = [1, 2, 3, 4, 5]
L2 = [1, 2, 3, 4, 5]
  
print(L1 == L2)
print(L1 is L2)

Producción:

True
False

¿Qué sucederá si realizamos la misma operación en números pequeños?

a = 50
b = 50
  
print(a == b)
print(a is b)

Producción:

True
True

Debido a que los enteros pequeños y las strings se almacenan en caché y se reutilizan, por lo tanto, se refieren a un mismo objeto único. Y dado que no puede cambiar enteros o strings en el lugar, no importa cuántas referencias haya al mismo objeto.