Copy

📝Copy

.copy() nos permite copiar un array de NumPy en otra variable de tal forma que al modificar el nuevo array los cambios no se vean reflejados en array original.

arr = np.arange(0, 11)
arr ----> array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
arr[0:6] ----> array([0, 1, 2, 3, 4, 5])
trozo_de_arr = arr[0:6]
trozo_de_arr[:] = 0
trozo_de_arr ----> array([0, 0, 0, 0, 0, 0])

Se han modificado los datos del array original porque seguía haciendo referencia a esa variable.

arr ----> array([ 0,  0,  0,  0,  0,  0,  6,  7,  8,  9, 10])
arr_copy = arr.copy()
arr_copy[:] = 100
arr_copy ----> array([100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100])
arr ----> array([ 0,  0,  0,  0,  0,  0,  6,  7,  8,  9, 10])

En python está la built-in function id que permite saber el espacio en memoria de una variable. Esto no solo pasa con numpy y pandas, tambien con diccionarios.

Con id podemos ver con un poco más de evidencia este error que varios hemos pasado

Este es un ejemplo con diccionarios pero funciona igual para un numpy array

dict_1 = {"llave_1": 1, }
dict_2 = dict_1
id(dict_2)  #1430585063744
id(dict_1)  #1430585063744

dict_2 = dict_1.copy()
id(dict_2) # 1430585063872

Es muy importante esta clase.

También es posible copiar el array original y hacer el slicing en la misma linea

a = [1,2,3,4,5,6,7,8,9,10]
b = a.copy()[:6]
* b será igual a = [1,2,3,4,5]

• Cuando es por valor, la información de la variable se almacenan en una dirección de memoria diferente al recibirla en la función, por lo tanto si el valor de esa variable cambia no afecta la variable original, solo se modifica dentro del contexto de la función.

• Cuando es por referencia, la variable que se recibe como parámetro en la función apunta exactamente a la misma dirección de memoria que la variable original por lo que si dentro de la función se modifica su valor también se modifica la variable original.

Básicamente, estamos hablando de una herramienta para evitar la perdida de data. Interesante. Muchas gracias .copy()

Copy

⚠️ Cuando trabajamos con pedazos de un array padre y empezamos a modificar ese supuesto pedazo, estamos modificanto el array padre

arr_copy = arr.copy()
🚨
Aca si tenemos un array que es una copia del padre y podemos modificarlo sin danar el original
…
⚠️ Siempre que quieras modificar un pedazo del array → COPY
…

Esto no solo sucede en Numpy sino en cualquier estructura de datos de bloques de memoria en Python (como las listas clásicas).

Les voy a contar una historia terrible que me sucedió con Tensorflow respecto al copy: Estaba programando mi tesis de grado con 3 redes neuronales de misma arquitectura, por lo que, al entrenar una red, “copiaba” la arquitectura y seguía con las otras

network_2 = network_1
network_3 = network_1

Esto hacía que se copiara la red entera con todos los parámetros internos ya entrenados.

Para hacer la historia corta, me di cuenta porque en el desempeño la red nunca superaba el 70% aunque en entrenamiento era muy precisa, y sucedía porque estaba reescribiendo el entrenamiento de la red cada que la “copiaba” y reentrenaba.

La parte positiva es que descubrí inconscientemente que se puede tomar una red ya entrenada para optimizar muchísimas etapas de entrenamiento, tan solo cambiando las instrucciones a

network_2 = network_1.copy()
network_3 = network_1.copy()

No es exactamente python pero si puede darles una ayudita con el tema de entender que es lo que ocurre cuando estamos haciendo moviendo las cosas de un lado a otro.
Y esta cortito el video dura 7 minutos mírale si
Clase: Como funciona la memoria en JavaScript || Curso Intermedio de Programación Orientada a Objetos en JavaScript

Información resumida de esta clase
#EstudiantesDePlatzi

• Es importante tener cuidado al editar nuestros arreglos, ya que así yo este editando un array que no es el original, pero que este trozo si pertenece al original, los cambios que yo realice aquí se verán reflejados en el array original

• Con el comando o propiedad copy puedo crear una copia de cualquier arreglo que desee y le estoy diciendo que esto lo guarde en otro espacio de memoria

• Siempre debemos manejar los datos de esta manera para que no sea peligroso

NOTAS COPY

 Python tiene dos tipos de copias, una copia superficial y una copia profunda. Una copia superficial significa que el array copiado contiene solo una referencia al array original. Significa que cualquier cambio en el array original se reflejará dentro del array copiada. Por otro lado, una copia profunda significa copiar cada elemento del array original en el array copiada. En este tipo de copia, se asigna una nueva ubicación de memoria a cada elemento dentro del array copiada. Esto significa que cualquier cambio en el array original no cambiará nada dentro del array copiada.
________________________________________
[1]
0 s
import  numpy as np 
________________________________________
[4]
0 s
arr = np.arange(0,21)
arr
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20])
________________________________________
[5]
trozo_de_arr = arr[0:12]
#cuando hacemos cambios en con este trozo afectamos todo el array
 
 
________________________________________
[6]
trozo_de_arr
#acedemos a cierta cantidad de valores de mi array
 
 
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
________________________________________
[7]
trozo_de_arr = arr[:] = 0
trozo_de_arr
#aca volvemos todos nuetros valores en zero 
 
 
0
________________________________________
[8]
0 s
arr
 
 
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
________________________________________
[9]
0 s
arr_copy = arr.copy()
 
 
________________________________________
[10]
0 s
arr_copy[:] = 100
 
 
________________________________________
[11]
arr_copy
#con copy asi haga cambios en mi array, el original me que con los mismos 
#valores, porque se le pide que ocupe otro espacio en memoria 
 
 
array([100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
       100, 100, 100, 100, 100, 100, 100, 100])
________________________________________
[12]
0 s
arr
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
________________________________________
copy nos ayuda a no ser cambios en todo el array evitando desastres en todo nuestro proyecto

Utilizar la función id, también nos da una excelente pista acerca de nuestros objetos evitándonos esos “graves” accidentes.

"The id() function returns a unique id for the specified object.

All objects in Python has its own unique id.

The id is assigned to the object when it is created.

The id is the object’s memory address, and will be different for each time you run the program. (except for some object that has a constant unique id, like integers from -5 to 256)"

Interesante el uso del codigo copy. Este nos permitira a almacenar datos nuevos sin perjudicar el valor original. Espero seguir aprendiendo de lo basico de numpy.

Supongo que el funcionamiento es el mismo que en el lenguaje C. En C se usa un tipo de datos que se llama puntero y que guardan una dirección en memoria. En C se calculan las logitudes en memoria que ocupa un tipo de dato y se multiplica ese espacio por la cantidad de elementos que tiene el array. Entonces es lo que te permite acceder de forma rápida a cualquier elemento dentro del array. Es la razón por la que un array puede ser solo de un mismo tipo de dato.
Cuando uno copia un array en C está copiando el puntero que apunta al primer bloque en memoria del array. Es decir a array[0]. Por lo que todas las modificaciones que se hagan se realizarán sobre un solo array puesto que lo que estás usando como parámetro para modificar el dato es una dirección en memoria y no una reasignación de los datos a otro bloque de memoria. Copy lo que hace es generar una copia en memoria del array en otro lugar y asignarle su respectivo puntero que te permitirá hacer cualquier tipo de cambio sin afectar al array original pues el puntero nuevo no apunta al antiguo espacio en memoria sino a uno nuevo con los datos copiados.

Esta clase tiene que ver con Mutabilidad e inmutabilidad

el jingle de la introduccion es super molestoso

genial .copy()

✅

Existen dos formas de copiar un array en Numpy:

• Copy

• View

La principal diferencia entre una copia y una vista de una matriz es que la copia es una nueva matriz y la vista es solo una vista de la matriz original. Por lo tanto la copia posee los datos y cualquier cambio realizado en la copia no afectará la matriz original, y cualquier cambio realizado en la matriz original no afectará a la copia.

8. Copy

import numpy as np

arr = np.arange(0,11)
arr

trozo = arr[0:6]

trozo[:] =0
trozo

arr

arr_copy=arr.copy()
arr_copy

arr_copy[:] = 100 # siempre hacer las modificaciones con copy
arr_copy

arr

import numpy as np

arr = np.arange(0,10)
print(arr)
trozo = arr[0:6]
print(trozo)
trozo[:]=0
print(trozo)
print(arr)
arr2 = np.arange(0,10)
trozo2 = arr2.copy()
indexes = list(map((lambda x: x>5), arr2))

trozo2 = np.delete(trozo2,indexes)
print(trozo2)
print(id(trozo2))
print(id(arr2))

Output:
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5]
[0 0 0 0 0 0]
[0 0 0 0 0 0 6 7 8 9]
[0 1 2 3 4 5]
1565790213776
1565790667088

No se si alguien tambien tuvo la duda de como sacar una copia del arreglo usando indeces, como tratamos de hacer al principio, pero que se noto que se hizo la referencia de memoria del mismo arreglo y que por ende se modifico, dejo este aporte por si alguien le sirve, vi que no podemos poner en tuplas los indices que queremos, tenemos que ponerlos en un indice, por lo que hice una nueva variable que almacenara los indice en forma de lista y pasarselas a delete y ya con esto tendriamos el array trozo2 de la misma dimension y con los mismos valores que el array trozo original que intentamos,
saludos!

En NumPy, el comando copy se utiliza para crear una copia independiente de un arreglo o matriz en lugar de una vista o referencia a la misma. La copia generada es una nueva instancia de arreglo con sus propios datos y memoria asignada, lo que significa que cualquier modificación realizada en la copia no afectará al arreglo original y viceversa.

El uso de copy puede ser útil en ciertas situaciones donde se requiere una copia completamente independiente de un arreglo para realizar operaciones o modificaciones sin afectar al arreglo original. Sin embargo, también puede tener algunas desventajas en términos de rendimiento y consumo de memoria, ya que implica la asignación de nueva memoria para la copia.

Copy

• Se utiliza para crear una copia de un objeto NumPy existente. Al crear una copia, se crea un nuevo objeto con los mismos valores y propiedades que el objeto original.

Por ejemplo, si tenemos un arreglo de frutas en NumPy como este:

import numpy as np

frutas = np.array(["manzana", "banana", "kiwi"])

Podemos hacer una copia de frutas utilizando la función copy de la siguiente manera:

frutas_copia = frutas.copy()

Ahora, si cambiamos el valor de uno de los elementos en el arreglo frutas_copia, el arreglo original frutas no se verá afectado:

frutas_copia[0] = "naranja"

print(frutas)         # Output: ['manzana' 'banana' 'kiwi']
print(frutas_copia)   # Output: ['naranja' 'banana' 'kiwi']

En este ejemplo, frutas_copia es una copia independiente de frutas, por lo que cualquier cambio que se haga en frutas_copia no afectará a frutas.

justamente me ha pasado en una clase anterior, cuando se explicaba el uso de .sort(). Ahí me di cuenta que se afectaba el arr original, pero no supe como resolverlo…
Intente crear una variable temporal, pero no funciono.

print(‘ordenar de menor a mayor cada elemento del arr’)
arr_temp = arr
arr_temp.sort()
print(arr_temp,’\n’)

El .copy() nos ahorra muchos dolores de cabeza 😅

Muy util este comando copy para evitar errores por modificaciones, y ya sabemos las desventajas de no usarlo cuando se necesite.

Muy util este comando copy para evitar errores por modificaciones.

seria bueno que expliques el concepto de valores y referencias

Si deseas tener un array de un solo tipo de numero, tal como

arr[:] = 100

Puedes utiliar el método np.full(). Siguiendo el ejemplo del número 100 y para obtener 10 elementos en el array:

np.full(10, 100)

Copy
Debemos tener mucho cuidado al modificar un array definido por slicing, puesto que siguen haciendo referencia al array principal, cuaquier cambio, será reflejado en el array padre.
Para evitar este error usamos el método copy, que crea una nueva variable (espacio en memoria diferente)

my_new_array = my_array[a:b].copy()

arr_copy

array([100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100])

arr

array([ 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10])

Esto ocurre con las listas normalmente, también es una opción solucionarlo de igual manera les dejo el código y ustedes mismos lo puedes probar saludos.(el type es para que verifiquen que sigue siendo un array de numpy.

arr = np.arange(0,11)
arr
pare = arr [:]
parte = parte[0:6]
parte[:]=0
parte
type(parte)
arr

Mi resumen #9 (Notion + Notas de Cornell)

Peligros de NO utilizar .copy

arr = np.arange(0,11)
print(arr)
slice_arr = arr[0:6] #el slice se define en base a arr (original). Cualquier cambio que ocurra va a afectar el objeto padre
slice_arr[:] = 0
print(slice_arr)
arr
#¿Como lo evito? ---> copy

Utilizando .copy

arr_copy = arr.copy()
arr_copy[:] = 100
print(arr_copy)
arr #se respeta la lista original porque con .copy pido que ocupe otro espacio en memoria. 
#ahora arr y arr_copy son 2 objetos distintos.
#así es como debemos hacer las modificaciones para evitar problemas posteriores

Parece muy loco que al modificar trozo_de_arr automáticamente también se modifique arr.
Pero si lo pensamos, previamente establecimos que trozo_de_arr y arr iban a tener elementos iguales con:

trozo_de_arr = arr[0:6]

Espero que así quede más claro, saludos, amigos. 😃

Dejo mis apuntes: Aqui

Copy, Paste, sigue siendo util

MUY BUEN CURSO! Me encanta

Excelente recomendación, no tenia ni idea de que eso podia llegar a pasar

A nivel LISTA existe el módulo COPY. Para evitar que no pase con listas lo que comentó el profesor Carlos para los array de NUMPY.

import copy  
copia_sin_referencia_lista = copy.copy(lista_original)

Lo explica el profesor David Aroesti en esta clase:
https://platzi.com/clases/1378-python-practico/14164-uso-de-listas/

Buen punto aprender de las fallas y enseñar sobre ellas, gracias

Hola, nada muy creativo por aca, pero dejo mi aporte:

arr2 = np.linspace(1,100,10, dtype=‘int8’)
arr2

arr2[arr2 <= 56]

Cuando recién comencé a aprender Python tuve muchos inconvenientes con reasignar vectores o arrays, debido a que había aprendido a programar en otro lenguaje.

¡Muy importante esta clase!

¡Excelente clase!