Identificación y conteo de respuestas únicas con NumPy

Clase 7 de 32 • Curso de Python para Ciencia de Datos

Resumen

¿Cómo identificar y contar elementos únicos con NumPy?

Analizar opiniones de clientes sobre productos es vital para cualquier empresa. Al recolectar respuestas como "bueno", "excelente" o "malo", es crucial cuantificar cuántas veces cada término aparece. Aquí es donde entra en juego la eficiencia de NumPy para identificar elementos únicos y contar sus frecuencias, ofreciendo insights valiosos para guiar decisiones estratégicas.

Para empezar, digamos que ya tenemos las respuestas de los clientes en una variable. Lo que queremos es determinar cuáles son las respuestas únicas presentes. Aquí es donde utilizamos numpy.unique.

import numpy as np

# Supongamos que tenemos la variable 'respuestas' con las opiniones de los clientes
respuestas = np.array(['bueno', 'excelente', 'malo', 'bueno', 'excelente', 'bueno', 'malo', 'excelente'])

# Utilizamos el método unique para encontrar los elementos únicos
elementos_unicos = np.unique(respuestas)
print(elementos_unicos)

Esto devolverá las respuestas únicas: "bueno", "excelente" y "malo".

¿Cómo contar la frecuencia de cada elemento?

Además de identificar los elementos únicos, saber cuántas veces aparecen también es fundamental para un análisis más profundo. Afortunadamente, numpy.unique también puede ayudarnos con esto.

# Contar las frecuencias de los elementos únicos
elementos_unicos, conteos = np.unique(respuestas, return_counts=True)
print(elementos_unicos)
print(conteos)

Esto mostrará tanto los elementos únicos como el número de veces que aparecen: cuatro "bueno", tres "excelente" y dos "malo".

¿Qué diferencias existen entre copias y vistas al operar con arrays en NumPy?

Al trabajar con NumPy, es posible acceder al buffer de datos internos de un array mediante una vista, sin copiar datos. Esto optimiza el rendimiento, pero puede generar problemas. Entender las diferencias entre una vista y una copia es esencial para realizar operaciones sin errores.

¿Cómo usar vistas para manipular arrays?

Veamos cómo una vista afecta tanto a la variable original como a ella misma:

x = np.arange(10)
vista = x[1:3]

print(x)
print(vista)

# Modificar la vista
x[1:3] = [10, 11]
print(x)
print(vista)

La vista refleja los cambios realizados en x, ya que es una porción del array original, mostrando la gran interdependencia entre ambos.

¿Cómo evitar modificaciones no deseadas usando copias?

Para situaciones donde solo se requiere acceder a la información sin modificar el array original, crear una copia es la solución.

# Crear una copia de la porción del array
copia = x[1:3].copy()

# Hacer cambios en el array original
x[1:3] = [12, 13]
print(x)
print(copia)

Aquí, modificar x no afecta a copia, ya que es independiente del array original. Esto resalta la importancia de distinguir entre vistas y copias en NumPy.

Prácticas recomendadas y reflexiones finales

NumPy ofrece herramientas potentes para el análisis de datos, desde la identificación de elementos únicos hasta el manejo de vistas y copias. Aprovechar estas funcionalidades asegura un análisis eficiente y preciso. Al crear copias de datos y usar vistas adecuadamente, maximizamos tanto el rendimiento como la seguridad de nuestras operaciones. Siempre cuestionémonos: ¿cómo podemos asegurarnos de que estamos trabajando con una copia o una vista? Esta reflexión nos permitirá mejorar continuamente en el uso de NumPy. ¡Anímate a dejar tus experiencias y preguntas en los comentarios!

Alberto Duque Villegas

student•

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.

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)

Rodrigo Ramirez Chaguala

student•

simplificando, para saber si es copia o vista, del array, al imprimir adiciono a la variable el atributo base ej: (print( x.base), si es una copia devuelve "none", y si es la vista, devuelve el array.

Juan Jose Ramirez Lopez

student•

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

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)

Fidel Ortega Guzman

student•

muy bien

Cristian Miguel Gómez Salazar

student•

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

student•

Aquí los ejemplos del reto:

Samuel Enrique Velásquez De La Cruz

student•

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

Samuel Enrique Velásquez De La Cruz

student•

ok ya entendí uno es por indexacion por listas y el otro es indexacion por slices

Jhonfred Galarraga

student•

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:

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á.
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.
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.
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.

Mario Alexander Vargas Celis

student•

En **NumPy**, puedes obtener los **elementos únicos** y sus **conteos** utilizando varias funciones útiles como np.unique(). También es importante entender la diferencia entre **copias** y **vistas** cuando trabajas con arrays. A continuación, desglosamos estos temas.

### Elementos Únicos y sus Conteos

#### np.unique()

La función np.unique() devuelve los elementos únicos de un array. También puedes obtener los conteos de cuántas veces aparece cada elemento único.


import numpy as np



\# Crear un array con elementos repetidos

array = np.array(\[1, 2, 2, 3, 3, 3, 4, 4, 4, 4])



\# Obtener los elementos únicos

unicos = np.unique(array)



\# Obtener los elementos únicos y sus conteos

unicos, conteos = np.unique(array, return\_counts=True)



print("Elementos únicos:", unicos)

print("Conteos:", conteos)

### Salida:


Elementos únicos: \[1 2 3 4]

Conteos: \[1 2 3 4]

### Copias y Vistas en NumPy

Cuando trabajas con arrays en NumPy, debes entender si estás manipulando **copias** o **vistas** de un array. Esto afecta el rendimiento y el comportamiento cuando modificas arrays.

#### 1. **Vistas (Views)**:

- Una **vista** es una referencia al array original. Cambios en la vista afectan al array original.

- Al usar técnicas como **slicing** (:), NumPy crea una vista, no una copia.


\# Crear un array original

array\_original = np.array(\[1, 2, 3, 4, 5])



\# Crear una vista del array

vista = array\_original\[:3]



\# Modificar la vista

vista\[0] = 100



print("Array original después de modificar la vista:", array\_original)

print("Vista:", vista)

### Salida:


Array original después de modificar la vista: \[100   2   3   4   5]

Vista: \[100   2   3]

#### 2. **Copias**:

- Una **copia** es un nuevo array en memoria. Cambios en la copia no afectan al array original.

- Para crear una copia explícita, se usa np.copy().


\# Crear un array original

array\_original = np.array(\[1, 2, 3, 4, 5])



\# Crear una copia del array

copia = np.copy(array\_original)



\# Modificar la copia

copia\[0] = 100



print("Array original después de modificar la copia:", array\_original)

print("Copia:", copia)

### Salida:


Array original después de modificar la copia: \[1 2 3 4 5]

Copia: \[100   2   3   4   5]

### Resumen:

- **Elementos Únicos**: Usa np.unique() para obtener los elementos únicos y sus conteos.

- **Vistas**: Son referencias al array original. Modificar una vista afecta el array original.

- **Copias**: Son nuevos arrays en memoria. Modificar una copia no afecta el array original.

¿Te gustaría algún ejemplo más o más detalles sobre estos temas?

Leonardo daniel Gutierrez Medellin

student•

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.

Alvaro Olarte

student•

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)); # True
print(np.may_share_memory(array_x, copy_x)); # False

Joaquín Bolaños

student•

Un código para generar etiquetas aleatorias y evitar estar escribiendo y repitiendo todos los valores:

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)

José Rodrigo Arana Hi

student•

buenisimo el tip!

Luis Fernando Buhezo Gomez

student•

Para saber la diferencia entre "copy" y "view" se puede observar la sintax y la cantidad de "[ ]".

view -> arrayName[a,b,c]
copy ->arrayName[[a,b,c]]

César Vásquez

student•

Una forma con la cual podemos diferencias una vista de una copia es por medio de la función base, puesto que esta nos permite identificar que None es una copia y posee sus propios datos y view es un array ya que viene asociada con el array inicial y los cambios realizados en una afectan la otra

Diego Ernesto Cuaycal Tirira

student•

Y los ejercicios para esta clase ?

Daniel Andres Rojas Paredes

student•

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

student•


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)

Rodrigo Ramirez Chaguala

student•

bien, un ejemplo un poco diferente

Gabriel Obregón

student•

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

student•

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

student•

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

student•

Elías Jesiel Martínez Hernández

student•

Forma rapida para saber si un array es una copia o una vista: