Forma de acceder a los elementos de un array por medio de su índice.
📢 Los indices empiezan a partir del 0 que representa el primer elemento del array.
array = np.random.randint(5,30,20)print(array)print("Elemento en la posición 5:", array[4])print("Elemento en la primer posición:", array[0])print("Elemento en la última posición", array[-1])print("Elemento en la ante última posición", array[-2])
Indexación booleana
Forma de obtener datos a partir de una condición.
📢 Todos los elementos que cumplan con la condición serán “devueltos”.
bool_index = array >15print("Array booleano:", bool_index)print("Elementos mayortes a 15:", array[bool_index])print("Elementos entre 15 y 20:", array[(array >=15)&(array <=20)])
Indexación por listas
Permite obtener multiples elementos de un array con una lista de indices.
📢 Al mandarle indices “desordenados” el array resultante obtiene los elementos en el orden en que se pasó el índice centro de la lista.
index_list =[3,8,5,0]print("Elementos en las posiciones 3,8,5 y 0:", array[index_list])print("Elementos en las posiciones -1, 2,3 y 5:", array[[-1,2,3,5]])```**Indexación de arrays multidimensionales**Para acceder a un elemento de un array bidimensional, le indicamos 2 indices. 📢 `[indice_fila, indice_columna]`
```python
matrix = np.random.randint(5,30,(5,5))matrix
print("Elemento de la fila 2, columna 2:", matrix[2,2])# Elemento especifioprint("Elementos de las fila 1 y 2, columna 2:", matrix[[1,2],2])# Indexaciónb por lista (1)print("Elementos en la fila 1 , columna 2, y fila 3, columna 2:", matrix[[1,2],[3,2]])# Indexaciónb por lista (2)print("Elementos mayores a 18:", matrix[matrix >18])# Indexación booleana
Slicing
Selección de sub-arrays, donde le indicamos el índice inicial e índice final del conjunto original.
📢 También se se pueden agregar “saltos”.
print("*"*5,"Array","*"*5)print("Elementos desde el incio hasta la posición 3:", array[:3])print("Elementos desde la posición 5 hasta el final:", array[5:])print("Elementos desde la posición 5 hasta la posición 10:", array[5:10])print("Elementos desde la posición hasta la penultima posición dando 2 saltos:", array[3:-2:2])print("*"*5,"Matriz","*"*5)print("Elementos a partir de la fila uno, y columnas a partir de la fila 2:\n", matrix[1:,2:])print("Elementos hasta la fila 3, y hasta la columna 2:\n", matrix[:3,:2])print("Elementos a partir de la fila 1 dando 2 saltos, hasta la columna 1 dando 2 saltos\n",matrix[1::2,:1:2])
Super Paola
Bien
¿Y los ejercicios?
Están en el Resumen debajo del video de la clase. 🤓
Los ejercicios están para Jupiter?. Yo uso visual studio code.
## Resumen
- Indexación Básica: Acceso a elementos individuales con índices enteros.
- Indexación con Listas y Booleana: Selección de múltiples elementos utilizando listas de índices o máscaras booleanas.
- Slicing: Selección de subarrays con notación de dos puntos, incluyendo pasos.
- Indexación en Arrays Multidimensionales: Aplicación de slicing y selección en cada dimensión.
- Indexación Avanzada: Selección de elementos arbitrarios utilizando arrays de índices y combinaciones de métodos.
Mis respuestas a los ejercicios
import numpy as np
print("1. Crea un arreglo de 10 números y accede al cuarto y penúltimo elemento usando índices positivos y negativos.")array_specific_elements = np.arange(10)print(array_specific_elements)print(f'El cuarto elemento es:{array_specific_elements[3]}')print(f'El penultimo elemento es:{array_specific_elements[-2]}')print("******"*20)print("2. Dado un arreglo de números del 1 al 20, extrae los elementos entre las posiciones 3 y 7, y luego los elementos de las últimas 5 posiciones.")array_slicing = np.arange(20)print(array_slicing)print(f'elementos entre las posiciones 3 y 7: {array_slicing[3:8]}')print(f'elementos de las últimas 5 posiciones: {array_slicing[-5:]}')print("******"*20)print("3. Crea un arreglo de números aleatorios entre 0 y 100. Usa una expresión booleana para acceder solo a los números mayores a 50.")array_random = np.random.randint(0,100, size=10)boolean_index = array_random >50print(array_random)filtered_numbers = array_random[boolean_index]print(f'Los numeros mayores a 50 son: {filtered_numbers}')print("******"*20)print("4. Dado un arreglo de 8 elementos, crea una lista de índices para acceder a los elementos en las posiciones 1, 4, y 6.")array_8_elements = np.random.randint(0,100, size=8)indice =[1,4,6]print(array_8_elements)value_of_position = array_8_elements[indice]print(f'los valores de la posiciones son: {value_of_position}')print("******"*20)print("5. Genera una matriz 4x4 de números aleatorios entre 10 y 50, y accede a la submatriz de 2x2 ubicada en la esquina inferior derecha.")matriz = np.random.randint(10,51, size=(4,4))print(f'la matriz en 4x4 es: \n {matriz}')# matriz[fila_inicio:fila_fin, columna_inicio:columna_fin]submatriz = matriz[-2:, -2:]print(f'la submatriz en 2x2 es: \n {submatriz}')print("******"*20)
En NumPy, la **indexación** y el **slicing** permiten acceder y modificar elementos de arrays de manera muy flexible. Estas técnicas son esenciales para trabajar con arrays de múltiples dimensiones.
### **1. Indexación**
La indexación en NumPy es similar a la de listas de Python, pero se extiende a arrays de múltiples dimensiones. Los índices comienzan en 0.
#### **1.1. Indexación en arrays unidimensionales**
import numpy as np
\# Array unidimensional
arr = np.array(\[10,20,30,40,50])
\# Acceder al primer elemento
print(arr\[0])# 10
\# Acceder al último elemento
print(arr\[-1])# 50
#### **1.2. Indexación en arrays multidimensionales**
En arrays multidimensionales, se usa una tupla de índices, donde cada índice corresponde a una dimensión del array.
\# Array bidimensional
arr\_2d = np.array(\[\[1,2,3], \[4,5,6], \[7,8,9]])\# Acceder al elemento en la fila 1, columna 2print(arr\_2d\[1,2])# 6\# Acceder a toda la fila 0print(arr\_2d\[0])# \[1 2 3]\# Acceder a toda la columna 1print(arr\_2d\[:,1])# \[2 5 8]
#### **1.3. Modificación mediante indexación**
Se puede cambiar el valor de un elemento específico accediendo a él mediante su índice.
\# Cambiar el valor en la fila 1, columna 2arr\_2d\[1,2]=10print(arr\_2d)\# \[\[123]\# \[4510]\# \[789]]
### **2. Slicing (Corte de arrays)**
El slicing en NumPy permite extraer una parte del array (subarrays). La sintaxis general para slicing es arr\[inicio:fin], donde se incluye inicio y se excluye fin.
#### **2.1. Slicing en arrays unidimensionales**
\# Array unidimensional
arr = np.array(\[10,20,30,40,50])\# Extraer elementos desde el índice 1 hasta el 3(no incluye el 3)print(arr\[1:3])# \[20 30]\# Todos los elementos desde el índice 2 en adelante
print(arr\[2:])# \[30 40 50]\# Todos los elementos hasta el índice 3(sin incluirlo)print(arr\[:3])# \[10 20 30]
#### **2.2. Slicing en arrays multidimensionales**
En arrays multidimensionales, se puede aplicar slicing en cada dimensión.
\# Array bidimensional
arr\_2d = np.array(\[\[1,2,3], \[4,5,6], \[7,8,9]])\# Extraer un subarray: filas 0 y 1, columnas 1 y 2subarray = arr\_2d\[0:2,1:3]print(subarray)\# \[\[23]\# \[56]]\# Extraer todas las filas y solo la columna 0print(arr\_2d\[:,0])# \[1 4 7]
#### **2.3. Slicing con paso**
Se puede definir un paso en el slicing, que indica la cantidad de elementos que se deben saltar.
\# Array unidimensional
arr = np.array(\[10,20,30,40,50])
\# Extraer elementos cada dos posiciones
print(arr\[::2])# \[10 30 50]
\# Array bidimensional
arr\_2d = np.array(\[\[1,2,3], \[4,5,6], \[7,8,9]])
\# Extraer subarray con salto en las filas
print(arr\_2d\[::2,:])# \[\[1 2 3] \[7 8 9]]
### **3. Indexación booleana**
NumPy permite seleccionar elementos del array en función de una condición. Esto se conoce como **indexación booleana**.
\# Array unidimensional
arr = np.array(\[10,20,30,40,50])\# Condición: seleccionar elementos mayores a 20cond = arr >20print(arr\[cond])# \[30 40 50]
### **4. Indexación avanzada**
En NumPy, también puedes seleccionar elementos específicos utilizando listas o arrays de índices.
\# Array unidimensional
arr = np.array(\[10,20,30,40,50])\# Seleccionar elementos en los índices 0,2 y 4print(arr\[\[0,2,4]])# \[10 30 50]
\# Array bidimensional
arr\_2d = np.array(\[\[1,2,3], \[4,5,6], \[7,8,9]])
\# Seleccionar elementos específicos de varias filas
print(arr\_2d\[\[0,2], \[1,2]])# \[2 9]
### **5. Asignación mediante slicing**
También es posible modificar partes de un array utilizando slicing.
\# Array unidimensional
arr = np.array(\[10,20,30,40,50])
\# Cambiar los primeros tres elementos
arr\[:3]= \[1,2,3]print(arr)# \[ 1 2 3 40 50]
\# Array bidimensional
arr\_2d = np.array(\[\[1,2,3], \[4,5,6], \[7,8,9]])
\# Cambiar toda la primera fila
arr\_2d\[0,:]= \[0,0,0]print(arr\_2d)\# \[\[000]\# \[456]\# \[789]]
### Resumen de indexación y slicing en NumPy:
- **Indexación**: Se usa para acceder a elementos individuales de arrays de cualquier dimensión.
- **Indexación booleana**: Selecciona elementos basados en condiciones.
- **Indexación avanzada**: Permite seleccionar varios elementos específicos a la vez.
Estas técnicas son muy poderosas para manipular y acceder a datos de manera eficiente en NumPy. ¿Te gustaría profundizar en algún aspecto específico?
Cuando manejas grandes volúmenes de datos, es fundamental poder extraer información específica de manera eficiente sin necesidad de copiar grandes cantidades de datos. En esta lección, exploraremos cómo la indexación y el slicing en arrays permiten trabajar rápidamente con subconjuntos de datos. También practicaremos estas técnicas para reforzar conceptos.
1. ¿Qué es la indexación y el slicing?
Indexación: Permite acceder a elementos específicos dentro de un array.
Slicing: Facilita la selección de subconjuntos de datos utilizando rangos.
Ambas técnicas son útiles para trabajar de forma eficiente con datos en estructuras como los arrays de NumPy.
2. Ejemplo básico de indexación
En este ejemplo, utilizamos un array unidimensional:
import numpy as np
array = np.array([10, 20, 30, 40, 50])
print(array[1]) # Accede al segundo elemento (índice 1)
print(array[-1]) # Accede al último elemento utilizando indexación negativa
Salidas:
20: Corresponde al elemento en el índice 1.
50: Es el último elemento del array, accedido mediante -1.
3. Ejemplo de slicing
El slicing permite extraer subconjuntos de datos usando rangos:
print(array[1:4]) # Elementos desde el índice 1 al 3
print(array[1:7]) # Intenta extraer del índice 1 al 6 (se detiene al final del array)
print(array[-1:-7]) # Intento de slicing negativo (devuelve array vacío)
Salidas:
[20 30 40]: Subconjunto desde el índice 1 hasta el 3 (excluye el índice 4).
[20 30 40 50]: Se detiene en el final del array, ya que no hay índice 7.
[]: La dirección del slicing negativo es incorrecta, resultando en un array vacío.
4. Indexación booleana
La indexación booleana permite seleccionar elementos que cumplen una condición específica:
array = np.array([10, 20, 30, 40, 50])
bool_index = array > 25
print(bool_index) # Array booleano con True/False según la condición
print(type(bool_index)) # Tipo del array resultante
Salidas:
[False False True True True]: Indica qué elementos son mayores a 25.
<class 'numpy.ndarray'>: El resultado es un array booleano de NumPy.
5. Indexación avanzada (Fancy Indexing)
Podemos acceder a múltiples posiciones usando una lista de índices:
index = [2, 0, 3]
print(array[index]) # Elementos en las posiciones 2, 0 y 3
Salida:
[30 10 40]: Los valores seleccionados según la lista de índices.
6. Trabajando con arrays multidimensionales
Los arrays de múltiples dimensiones requieren un formato más detallado para acceder a sus elementos:
array = np.random.randint(1, 10, size=(3, 3))
print(array) # Imprime el array 3x3
print(array[0, 1]) # Accede al elemento en la fila 0, columna 1
Salida (puede variar por los valores aleatorios):
[[8 5 1] [9 2 7] [8 3 6]]: Ejemplo de un array 3x3 generado aleatoriamente.
5: Valor en la fila 0, columna 1.
7. Extrayendo submatrices
Podemos seleccionar subconjuntos de una matriz mayor, creando submatrices:
print(array[:2, :2]) # Submatriz de las primeras 2 filas y columnas
Salida (puede variar):
[[8 5] [9 2]]: Una submatriz de 2x2 extraída del array original.
Muchas gracias!! Excelente resumen
Hola, hace poco vi un video de un chico que hablala sobre el punto de Feynman en el número pi, que es una curiosidad donde tenemos 6 nueves seguidos dentro de este numero,
!Puede ser una imagen de texto
así que quise verlo utilizando lo aprendido en esta clase, investigando para extraer el número pi tocaba importar la libreria mpmath.
# Indexación para acceder a elementos específicosarray_1 = np.array([1,2,3,4,5,6,7,8,9,10])print(array_1)print("Los elementos último y penúltimo son: ", array_1[-1], array_1[-2])# Slicing de arraysarray_2 = np.arange(1,20)print(array_2[3:8])print(array_2[-5:])# Indexación con booleanosarray_3 = np.arange(1,101)lista_3 = array_3.tolist()array_booleano =[]print(array_3,"\n")for i in lista_3:if i >50: array_booleano.append(i)array_new = np.array(array_booleano)print(array_new,"\n")print(type(array_new))# Indexación para acceder a elementos con múltiples índicesarray_4 = np.arange(1,9)print(array_4)print(array_4[[0,3,5]])# Slicing de una matriz 4x4 a una 2x2matrix_4x4 = np.random.randint(1,8, size=(4,4))print(matrix_4x4,"\n")print(matrix_4x4[2:,2:])
Recuerda que Estamos enfocados en atender y brindar espacios para nomadas digitales, teletrabajo y coworking space en Agrolenials Paradise Ecohostel Country Inns contacto directo whatsapp +573206299333 y Faccebook
MOdelo coworcountry o modelo coworculture con muchas actividades para pausas activas y acompañamiento de tu rol profesional
# Ejercicio 1
print("Ejercicio 1")
array = np.random.randint(1,10, size=10)
print(array)
print(array[3:-1])
#Ejercicio 2
print("\nEjercicio 2")
array = np.random.randint(1,20, size=20)
print(array)
print(array[2:7])
print(array[-5:])
#Ejercicio 3
print("\nEjercicio 3")
array = np.random.randint(1,100, size=10)
print(array)
print(array[array > 50])
#Ejercicio 4
print("\nEjercicio 4")
array = np.random.randint(1,100, size=8)
print(array)
index = [0,2,5]
print(array[index])
#Ejercicio 5
print("\nEjercicio 5")
array = np.random.randint(1,50, size=(4,4))
print(array)
print(array[2:4,2:4])
1.#Acceder a elementos específicos:#Crea un arreglo de 10 números y accede al cuarto y penúltimo elemento usando índices positivos y negativos.array = np.array([1,2,3,4,5,6,7,8,9,10])print(array[3:-1])--------------------------------------------------2.#Slicing de arreglos:#Dado un arreglo de números del 1 al 20, extrae los elementos entre las posiciones 3 y 7, y luego los elementos de las últimas 5 posiciones.array = np.arange(20)print(array[2:6])print(array[-5:])------------------------------------------------3.#Indexing con booleanos:#Crea un arreglo de números aleatorios entre 0 y 100. Usa una expresión booleana para acceder solo a los números mayores a 50.array = np.random.randint(1,100, size=20)bool_index = array >50print(array)print(bool_index)print(array[bool_index])----------------------------------------------4.#Indexación con múltiples índices:#Dado un arreglo de 8 elementos, crea una lista de índices para acceder a los elementos en las posiciones 1, 4, y 6.array = np.arange(8)print(array[[0,3,5]])-----------------------------------------------5.#Matrices bidimensionales:#Genera una matriz 4x4 de números aleatorios entre 10 y 50, y accede a la submatriz de 2x2 ubicada en la esquina inferior derecha.matrix = np.random.randint(10,50, size=(4,4))print(matrix)print(matrix[2:,2:])
#EJERCICIO Acceso a elementos específicosarray1 = np.random.randint(1,44, size=(5,10))print(array1)print(array1[0][4])# Extrae de la primer linea el elemento 4print(array1[4][-2])# Extrae de la ultima fila el penúltimo elemento#EJERCICIO Slicing de arreglosarray2 = np.arange(20)print(array2)print(array2[3:7])#Elementos desde la posición 3 a la 7print(array2[-5:])# Elementos de las últimas 5 posiciones#EJERCICIO indenxing con booleanosarray3 = np.random.randint(0,100, size=100)#Genera 100 numeros aleatorios con un rango entre 0 y 100print(array3)array3[array3 >50]print(array3 [array3 >50])# Extrae los datos que son mayores a 50#EJERCICIO indexación con multiples indicesarray4 = np.random.randint(0,100, size=8)print(array4)print(array4 [[1,4,6]])#Visualiza los elementos de las posiciones 1,4,6#EJERCICIO Matrices bidimensionalesmatrix = np.random.randint(10,50,size =(4,4))print(matrix)print(matrix [2:,2:])#Imprime la matriz 2x2 de la parte inferior
