Identificación y conteo de respuestas únicas con NumPy

Solo para agregar: En la forma de imprimir los valores unicos y sus conteos se puede usar un `zip` para juntarlos en una tupla y después podemos imprimirlos o pasarlos a un diccionario como lo hice yo ```js survey_responses = np.array(["bueno", "excelente", "malo", "bueno", "bueno", "malo", "malo", "bueno", "excelente", "malo"]) unique_elements, counts_elements = np.unique(survey_responses, return_counts=True) counts = dict(zip(unique_elements, counts_elements)) print(counts) ```

Alberto Duque Villegas

Respuesta a la pregunta final: Se puede diferenciar entre una vista y una copia de un array original mediante la identificación de la dirección en memoria -con la función id(array\_que\_corresponda)- o con el método base (array\_que\_corresponda.base). Sin embargo, es más explícito y eficaz utilizar el método base: * Si un array es una vista de otro array original, el método o atributo `.base` del array vista apuntará al array original (es decir, indicará el array original). * Si el array es una copia, el método o atributo `.base` retornará `None`. ```js original = np.array([1, 2, 3, 4]) # Crear un array original vista = original[1:3] # Crear una vista copia = original.copy() # Crear una copia print(vista.base) # Esto imprimirá el array original: [1, 2, 3, 4] porque el atributo ".base" del array vista apuntará al array original, cuando es una vista print(copia.base) # Esto imprimirá "None" porque el atributo ".base" del array vista NO apuntará al array original, por tratarse de una copia (otro lugar en memoria) ```original = np.array(\[1, 2, 3, 4]) # Crear un array original vista = original\[1:3] # Crear una vistacopia = original.copy() # Crear una copia print(vista.base) # Esto imprimirá el array original: \[1, 2, 3, 4] porque el atributo ".base" del array vista apuntará al array original, cuando es una vistaprint(copia.base) # Esto imprimirá "None" porque el atributo ".base" del array vista NO apuntará al array original, por tratarse de una copia (otro lugar en memoria)

Cristian Miguel Gómez Salazar

Una lista de los métodos más usados en numpy según lo que se desee hacer: **Creación de arrays:** * `np.array()`: Crea un array a partir de una lista o tupla * `np.zeros()`: Crea un array lleno de ceros * `np.ones()`: Crea un array lleno de unos * `np.arange()`: Crea un array con una secuencia de números * `np.linspace()`: Crea un array con números igualmente espaciados **Manipulación de arrays:** * `reshape()`: Cambia la forma de un array * `flatten()`: Convierte un array multidimensional en unidimensional * `transpose()`: Transpone un array * `concatenate()`: Concatena arrays **Operaciones matemáticas:** * `np.sum()`: Suma los elementos de un array * `np.mean()`: Calcula la media de los elementos de un array * `np.max()`, `np.min()`: Encuentra el valor máximo y mínimo * `np.dot()`: Realiza el producto punto entre arrays **Álgebra lineal:** * `np.linalg.inv()`: Calcula la inversa de una matriz * `np.linalg.det()`: Calcula el determinante de una matriz * `np.linalg.eig()`: Calcula los valores y vectores propios * `np.linalg.solve()`: Resuelve sistemas de ecuaciones lineales **Indexación y slicing:** * `array[index]`: Accede a elementos específicos * `array[start:end:step]`: Extrae subarrays * `np.where()`: Encuentra índices que cumplen una condición **Funciones universales (ufuncs):** * `np.exp()`, `np.log()`: Funciones exponencial y logarítmica * `np.sin()`, `np.cos()`: Funciones trigonométricas * `np.sqrt()`: Raíz cuadrada

Antonio Demarco Bonino

Platzi Team

Aquí los ejemplos del reto: ![](https://static.platzi.com/media/user_upload/image-f316ba6c-b265-40c0-aef0-4d855dc21fd7.jpg) ![](https://static.platzi.com/media/user_upload/image-0b451424-590e-4698-bb7d-da40ab4cfd12.jpg)

Samuel Enrique Velásquez De La Cruz

Pregunta, por qué cuando hace array en posicion \[1,2] se muestran los valores en la posicion 1 y 2 que es 10 y 11, no debería mostrar solo la posición 1? y no la posición 2? ya que es excluyente con la posición final del rango

Alvaro Olarte

Yo buscando encontre la función np.may\_share\_memory. Esta función verifica si dos arrays podrían compartir memoria. Si devuelve True, significa que los arrays podrían compartir memoria, lo que sugiere que uno es una vista del otro. Si devuelve False, significa que los arrays no comparten memoria, lo que sugiere que uno es una copia del otro. ```js # How know if it is a copy or a view # The np.may_share_memory() function can be used to determine if two arrays share memory. # If the arrays share memory, the function returns True; otherwise, it returns False. array_x = np.arange(10); view_y = array_x[1:4]; copy_x = array_x[[1,2]]; print(np.may_share_memory(array_x, view_y)); # True print(np.may_share_memory(array_x, copy_x)); # False ```

Joaquín Bolaños

Un código para generar etiquetas aleatorias y evitar estar escribiendo y repitiendo todos los valores: ```js import numpy as np valores = np.array(["malo", "bueno", "excelente"]) indicesAleatorios = np.random.randint(len(valores), size=(10)) arregloValores = valores[indicesAleatorios] print (arregloValores) ```import numpy as npvalores = np.array(\["malo", "bueno", "excelente"])indicesAleatorios = np.random.randint(len(valores), size=(10))arregloValores = valores\[indicesAleatorios]print (arregloValores)

Jhonfred Galarraga

hace un mes

Entender la diferencia entre copias y vistas en NumPy es crucial para evitar comportamientos inesperados en tu código. Aquí te explico cómo puedes identificar si estás trabajando con una copia o una vista: **Comportamiento al modificar el array:** * **Vistas:** * Cuando modificas una vista, el array original también se modifica, y viceversa. * Esto se debe a que una vista no crea una copia de los datos, sino que simplemente proporciona una forma diferente de acceder a los mismos datos en la memoria. * **Copias:** * Cuando modificas una copia, el array original no se ve afectado, y viceversa. * Esto se debe a que una copia crea un nuevo array con sus propios datos en la memoria. **Cómo detectar la diferencia:** 1. **Operaciones de segmentación (slicing):** * La mayoría de las operaciones de segmentación en NumPy crean vistas. Por ejemplo: * `vista = array[1:5]` * Si modificas `vista`, el array original `array` también se modificará. 2. **La función** `.copy()`**:** * Si usas la función `.copy()`, estás creando una copia del array. Por ejemplo: * `copia = array[1:5].copy()` * En este caso, cualquier modificación en `copia` no afectará a `array`. 3. **Indexación avanzada (fancy indexing):** * La indexación avanzada, que utiliza listas o arrays de índices, generalmente crea copias. Por ejemplo: * `copia = array[[1, 3, 5]]` * Aquí, `copia` será un nuevo array independiente. 4. **Verificar la propiedad** `.base`**:** * Puedes usar la propiedad `.base` de un array para verificar si es una vista. * Si el array es una vista, `.base` apuntará al array original. * Si el array es una copia, `.base` será `None`. **Ejemplo práctico:** Python: `import numpy as np` `array_original = np.arange(10)` `# Creación de una vista` `vista = array_original[2:6]` `# Creación de una copia` `copia = array_original[2:6].copy()` `# Verificación` `print(f"Vista.base: {vista.base}")` `print(f"Copia.base: {copia.base}")` `# Modificación de la vista` `vista[0] = 100` `# Verificación de cambios` `print(f"array_original: {array_original}")` `print(f"vista: {vista}")` `print(f"copia: {copia}")` En este ejemplo, verás que: * `vista.base` apunta a `array_original`, lo que indica que es una vista. * `copia.base` es `None`, lo que indica que es una copia. * La modificación de `vista` afecta a `array_original`, pero no a `copia`.

Daniel Andres Rojas Paredes

hace 3 meses

en lo personal la manera en que crea las copias al final me parece una mala practica porque al leer codigo puede ser muy ambigua, suponga el siguiente codigo si en vex de poner \[1,0] pongo \[1] estoy es noo construyendo una copia con solo la primera fila, si no una vista con solo la primera fila y el comportamiento del codigo es completamente distinto. np.copy o array.copy para hacer copias hace el codigo mas entendible. ```python array=np.array([[1,2,3],[4,5,6]]) new=array [[1,0]] #this creates a vew print(new) new[1:2]=[0,0,0]#this would modify a slice of that vew print(new) ```

Alejandro Gonzalez

```python import numpy as np word_list = ["Good", "Bad", "Hate", "Love", "Ugly", "Nice"] array = np.random.choice(word_list, size=10) print(array) unique, counts = np.unique(array, return_counts = True) print(unique) print(counts) ```

Gabriel Obregón

#### **1. UNIQUE** **Descripción:** La función np.unique en Numpy se utiliza para encontrar elementos únicos en un arreglo. También puede devolver el conteo de ocurrencias de cada elemento único si se especifica el parámetro return\_counts=True. Esto es útil para análisis de datos, como contar frecuencias de elementos. **Ejemplos:** **Código:** survey\_responses = np.array(\["bueno", "excelente", "malo", "bueno", "malo", "excelente", "bueno", "bueno", "malo", "excelente", "excelente", "excelente"]) print(np.unique(survey\_responses)) * **Resultado:** \['bueno' 'excelente' 'malo'] **Explicación:** La función np.unique extrae las respuestas distintas en el arreglo survey\_responses. **Código:** unique\_elements, counts = np.unique(survey\_responses, return\_counts=True) print(unique\_elements) print(counts) **Resultado:** unique\_elements: \['bueno' 'excelente' 'malo'] counts: \[4 5 3] * **Explicación:** Además de los elementos únicos, se devuelven los conteos de cada valor único. Por ejemplo, "bueno" aparece 4 veces, "excelente" aparece 5 veces y "malo" aparece 3 veces. #### **2. COPIAS / VISTAS** **Descripción:** Los arreglos en Numpy pueden crear copias o vistas: * **Vistas:** Son subconjuntos de los datos originales. Cualquier cambio en una vista afecta el arreglo original. * **Copias:** Son duplicados independientes de los datos. Modificar una copia no afecta el arreglo original. **Ejemplos:** **EJEMPLO DE VISTA:**array\_x = np.arange(10) view\_y = array\_x\[1:3] print(array\_x) print(view\_y) array\_x\[1:3] = \[10, 11] print(array\_x) print(view\_y) **Resultado:**array\_x: \[0 1 2 3 4 5 6 7 8 9] view\_y: \[1 2] array\_x (después de modificación): \[ 0 10 11 3 4 5 6 7 8 9] view\_y (después de modificación): \[10 11] * **Explicación:** view\_y es una vista de array\_x. Cuando los elementos en el segmento \[1:3] se modifican en array\_x, los cambios se reflejan en view\_y. **EJEMPLO DE COPIA:** array\_x = np.arange(10) copy\_x = array\_x\[\[1, 2]] print(array\_x) print(copy\_x) array\_x\[1:3] = \[10, 11] print(array\_x) print(copy\_x) **Resultado:** array\_x: \[0 1 2 3 4 5 6 7 8 9] copy\_x: \[1 2] array\_x (después de modificación): \[ 0 10 11 3 4 5 6 7 8 9] copy\_x (sin cambios): \[1 2] * **Explicación:** copy\_x es una copia de array\_x. Los cambios en el segmento \[1:3] en array\_x no afectan a copy\_x, ya que opera de manera independiente.

Cristian Camilo Quinche Vélez

Buenas noches, respecto a la respuesta final, no se si sea muy obvio, pero, una forma de saber sería modificando el array original, si a la hora de visualizar el array se ve la modificación se entiende que es una vista, pero si esta no se ve afectada, sería una copia.

Daniel Andres Rojas Paredes

creo que lo que se debe resaltar es que existe algo llamado shallow copy, es una copia que mantiene undependencia de atributos como el shape pero que sigue atada al original en la data. esta copia superficial se puede obtener implicitamente mediante el slicing x=y\[:4] y que se podria confundir con estar creando un nuevo arreglo, por la sintaxis del codigo, tambien se puede hacer de manera explicita con el metodo vew. para hacer un paralelo, con los arrays de nunpy sucede lo mismo o algo similar que con los objetos de js al usar la sintaxis a=b lo que se creo no es una copia, en js se crea una referencia a memoria (no copia) en numpy se cre una copia superficial (shallow copy) y la unica manera de crear una copia real es con metodos especificos, para el caso de nunpy el metodo .copy

Octavio Delgado

![](https://static.platzi.com/media/user_upload/image-7ffbb68c-c2c3-4510-9dd1-34d8d6d2b52b.jpg)

Elías Jesiel Martínez Hernández

Forma rapida para saber si un array es una copia o una vista: ![](https://static.platzi.com/media/user_upload/image-8cbb0e67-31e8-42e1-a4de-15f4fa851bf4.jpg)

Pável Hernández Reza

hace 5 meses

Visto en Python con diccionarios como ejemplo y en JavaScript con objetos, sucede que, cuando se trata de colecciones de datos u objetos creados a partir de clases (Esto viene de POO) las instancias creadas son referencias en memoria, a diferencia de valores individuales como un entero. Esto no está mal (Eso creía yo en un principio, decía que eso no tenía sentido). Lo que sucede es que, cuando asignamos esa instancia a una nueva variable no estamos haciendo una copia del dato sino una copia de la referencia en memoria, causando que ahora tengamos dos variables apuntando a una misma instancia y, por ende, pudiendo modificar desde dos distintas variables. Esto es sumamente útil en ciertos aspectos. Normalmente la ejecución de un método es una vista, mientras este resultado no se reasigne a la variable en cuestión.

Leonardo daniel Gutierrez Medellin

hace 5 meses

Las copias y las vistas son conceptos clave al trabajar con arrays en NumPy. **Copias**: Se crean al realizar una operación que duplica los datos, de modo que cualquier cambio en la copia no afecta al array original. Ejemplo: `copia = x[1:3].copy()`. **Vistas**: Referencian el mismo bloque de datos que el array original. Cambios en la vista afectan al original. Ejemplo: `vista = x[1:3]`. En resumen, usa copias cuando desees evitar modificaciones en el original, y vistas para optimizar la memoria al trabajar con datos grandes.

Luis Enrique Montes Gonzalez

````js compa = np.arange(5) compa_view = compa[:3] compa_copy = compa[[0,1,2]] print(compa) print(compa_view) print(compa_copy) compa[:3] = [20,50,60] print("Valores modificado") print(compa) print("Valores con copy") print(compa_copy) print("Valores view") print(compa_view) #Verifica si dos elementos comparten memoria np.may_share_memory((compa_copy), np.array(compa_view) ```compa = np.arange(5) compa\_view = compa\[:3] compa\_copy = compa\[\[0,1,2]] print(compa) print(compa\_view) print(compa\_copy) compa\[:3] = \[20,50,60] print("Valores modificado") print(compa) print("Valores con copy") print(compa\_copy) print("Valores view") print(compa\_view) #Verifica si dos elementos comparten memoria np.may\_share\_memory((compa\_copy), np.array(compa\_view) ````

ZeroRoy

Creo que dejaron de paso el method copy: `my_cop = np.copy(arr_x[1:3])`

Gustavo Campos

Cabe acotar que el parámetro 'returns\_counts' es una palabra reservada para la función unique y, como puede notarse en el ejemplo, retorna el numero de veces que un ítem se repite en un array. PD: No soy un experto, solo investigue un poco.

Alvaro Olarte

Yo buscando encontre la función np.may\_share\_memory. Esta función verifica si dos arrays podrían compartir memoria. Si devuelve True, significa que los arrays podrían compartir memoria, lo que sugiere que uno es una vista del otro. Si devuelve False, significa que los arrays no comparten memoria, lo que sugiere que uno es una copia del otro. *# How know if it is a copy or a view# The np.may\_share\_memory() function can be used to determine if two arrays share memory.# If the arrays share memory, the function returns True; otherwise, it returns False.*array\_x = np.arange(10);view\_y = array\_x\[1:4];copy\_x = array\_x\[\[1,2]];print(np.may\_share\_memory(array\_x, view\_y));print(np.may\_share\_memory(array\_x, copy\_x));

Diego Andrés Lopez Rodriguez

Les presento un ejemplo practico de esta clase ![](https://static.platzi.com/media/user_upload/image-9ff5da78-199b-4183-93bd-e39ed5eabc80.jpg)

Joseph Corona

Otra forma de hacer una copia es esta: ```js array_x = np.arange(10) copy_x = np.copy(array_x[1:3]) print(array_x) print(copy_x) array_x[1:3] = [10,11] print(array_x) print(copy_x) ```array\_x = np.arange(10) copy\_x = np.copy(array\_x\[1:3]) print(array\_x) print(copy\_x)

Ana Patricia Pérez Ríos

En los resultados, `view_y` es una vista (porque cambia cuando `array_x` cambia) y `copy_x` es una copia (porque no se ve afectada por los cambios en `array_x`).

GERMAN GARCIA

como le podría hacer para que me lo de uno enfrente del otro y no tener que contar que lugar le pertenece a cada numero??? ![](https://static.platzi.com/media/user_upload/image-c441bb18-198b-4fb2-8eec-bb61b8fb29c8.jpg)

Mario Alexander Vargas Celis

### **Diferencias clave entre Copias y Vistas**: * **Vista**: Comparte la misma memoria que el array original. Es más eficiente en términos de uso de memoria, pero cualquier cambio en la vista también cambia el array original. * **Copia**: Un nuevo array con una nueva asignación de memoria. No afecta al array original cuando se modifica.

Erick Infante

Para saber si son vistas o copias, hay que verificar si comparten el mismo espacio en memoria. Para esto, numpy tiene la funcion .shares\_memory, la cual verifica la ubicación en memoria de los arreglos y retorna True en caso de que sea verdadero (sea una vista) o False en caso contrario (sea una copia). ```python array_x = np.arange(10) copy_x = np.copy(array_x[1:3]) print("Arreglo x:", array_x) print("Copia x:", copy_x) print("Comparten memoria:", np.shares_memory(array_x, copy_x)) ```

Alberto Duque Villegas

Pueden cometerse errores entre tener vistas de los arrays y modificarlas sin tener la intención de hacerlo; para evitar estos errores, es mejor hacer copias de los arrays originales. ## Con comentarios al último ejercicio, veamos cómo se mantiene sin modificación la copia de un array cuando se modifican un array original: ```js array_x = np.arange(10) # Array original copy_x = array_x[[1,2]] # Copia del array original print("array original: ", array_x) print("copia del array original: ", copy_x) array_x[1:3] = [10,11] # Modificación del array original: los índices 1 y 2 del array original, remplácelos con 10 y 11 (no modifica la copia) print("array original modificado: ", array_x) # Imprime array original modificado print("copia del array original, luego de la modificación de array_x: ", copy_x) # Imprime copia del array original que no fue afectada por la modificación ```array\_x = np.arange(10) # Array originalcopy\_x = array\_x\[\[1,2]] # Copia del array original print("array original: ", array\_x) print("copia del array original: ", copy\_x) array\_x\[1:3] = \[10,11] # Modificación del array original: los índices 1 y 2 del array original, remplácelos con 10 y 11 (no modifica la copia) print("array original modificado: ", array\_x) # Imprime array original modificadoprint("copia del array original, luego de la modificación de array\_x: ", copy\_x) # Imprime copia del array original que no fue afectada por la modificación

JHON FREDDY TAVERA BLANDON

### **Elementos Únicos y Conteos**: Utiliza `np.unique` para encontrar elementos únicos y sus conteos en arrays unidimensionales y multidimensionales. ### **Copias y Vistas**: Las vistas son referencias al mismo bloque de memoria que el array original, mientras que las copias son réplicas independientes. Cambios en una vista afectan al array original, pero cambios en una copia no. Estas herramientas son útiles para trabajar con datos en NumPy de manera eficiente y flexible. ```js original_array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) view_array_2d = original_array_2d[:2, 1:] copy_array_2d = original_array_2d[:2, 1:].copy() view_array_2d[0, 0] = 99 print("Array 2D original después de modificar la vista:\n", original_array_2d) print("Vista del array 2D:\n", view_array_2d) copy_array_2d[0, 0] = 77 print("Array 2D original después de modificar la copia:\n", original_array_2d) print("Copia del array 2D:\n", copy_array_2d) ```

Diego Andrés Lopez Rodriguez

Las vistas comparten la memoria con el array original y las modificaciones hechas en la vista afectan a ese array, en cambio, La copia duplica los datos del array y las modificaciones hechas en la copia no afectan al array original

Alejandro Gonzalez