Indexación y Slicing en NumPy para Análisis de Datos

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

Clase anteriorSiguiente clase

Resumen

Ejercicios para practicar Indexación y Slicing:

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

Paola Alapizco

student•

📝 Mis apuntes y ejercicios de la clase:

Indexación

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 > 15
print("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.&#x20;

📢 `[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 especifio
print("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])

Alberto Duque Villegas

student•

Super Paola

JOSE ANTONIO ARANGO

student•

Bien

Gonzalo Gutiérrez Castillo

student•

¿Y los ejercicios?

Miguel Torres

student•

Están en el Resumen debajo del video de la clase. 🤓

César Cruz

student•

Los ejercicios están para Jupiter?. Yo uso visual studio code.

Jhon Freddy Tavera Blandon

student•

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

Freddy Javier E. Pérez Zelada

student•

Mis respuestas a los ejercicios

Mario Alexander Vargas Celis

student•

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 2

print(arr\_2d\[1, 2])  # 6



\# Acceder a toda la fila 0

print(arr\_2d\[0])  # \[1 2 3]



\# Acceder a toda la columna 1

print(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 2

arr\_2d\[1, 2] = 10

print(arr\_2d)

\# \[\[ 1  2  3]

\#  \[ 4  5 10]

\#  \[ 7  8  9]]

### **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 2

subarray = arr\_2d\[0:2, 1:3]

print(subarray)

\# \[\[2 3]

\#  \[5 6]]



\# Extraer todas las filas y solo la columna 0

print(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 20

cond = arr > 20

print(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 4

print(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)

\# \[\[0 0 0]

\#  \[4 5 6]

\#  \[7 8 9]]

### Resumen de indexación y slicing en NumPy:

- **Indexación**: Se usa para acceder a elementos individuales de arrays de cualquier dimensión.

- **Slicing**: Extrae subarrays especificando rangos (inicio, fin, paso).

- **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?

Gabriel Obregón

student•

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.

Mercedes Jue

student•

Muchas gracias!! Excelente resumen

Nicol Barajas

student••


''' Crea un arreglo de 10 números y accede al cuarto y penúltimo elemento usando índices positivos y negativos.
Slicing de arreglos: '''
array1 = [1,3,3,5,6,5,6,9,8]
print(array1[3])
print(array1[-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.'''
array2 = np.random.randint(1,20,size = (10))
print(array2)
print(array2[3:7])
print(array2[-5:])

''' 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.'''
array2 = np.random.randint(0,100,size = (10))
mayore50 = []
print(array2)
bool_index = array2 &gt; 50
print(bool_index)
for i in range(len(array2)):
  if bool_index[i] == True:
    print(array2[i])
    mayore50.append(array2[i])
print(mayore50)

''' Dado un arreglo de 8 elementos, crea una lista de índices para acceder a los elementos en las posiciones 1, 4, y 6.'''
array3 = np.array([2, 4, 5, 6, 3, 7, 8, 9])
indices = [0,5,6]
print(array3[indices])

''' 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, 50, size = (4, 4))
print(matriz)

Juan David Rojas Heredia

student•

separador="-"*20

#Acceder a elementos especificos
array_10_numeros=np.array([0,1,2,3,4,5,6,7,8,9])
print(f"El array es {array_10_numeros}")
print(f"El cuarto elemento es {array_10_numeros[5]}")
print(f"El penúltimo numero es {array_10_numeros[-2]}")
print(separador)

#Slicing de arreglo
array_20_numeros=np.arange(1, 21)
print(array_20_numeros)
print(f"Elemento entre la posicion 3 y 7 {array_20_numeros[3:8]} ultimo 5 numeros {array_20_numeros[-5:]}")
print(separador)

#Indexing con booleanos
array_numeros_azar=np.random.randint(1, 101, size=10)
print(array_numeros_azar)
bool_index=array_numeros_azar>50
print(f"Los numeros mayores de 50 son {array_numeros_azar[bool_index]}")
print(separador)

#Indexacion con multiples indices
array_8_numeros=np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])
indices=[1, 4, 6]
print(f"Los elementos son {array_8_numeros[indices]}")
print(separador)

#Matriz bidimensional
matriz_4x4=np.random.randint(10, 51, size=(4,4))
print(matriz_4x4)
submatriz=matriz_4x4[2:, 2:]
print(f"Matriz de 2x2 en la esquina inferior izquierda:\n {submatriz}")

Este fue el desarrollo de los ejercicios de práctica. O.O

Mario Alberto Romero Guerrero

student•

EJERCICIOS:

Alvaro Jose Florez Rangel

student••

# Ejercicios

# Acceder a elementos especificos: Crea un arreglo de 10 números y accede al cuarto y penúltimo elemento usando índices positivos y negativos
array_2 = np.array([10,20,30,40,50,60,70,80,90,100])
print(array_2)
print(array_2[3]) 
print(array_2[-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_arange = np.arange(1,21) # n-1 para el ultimo elemento
print(array_arange)
print(array_arange[2:7])
print(array_arange[-5:])

# 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_3 = np.random.randint(0,101, size=20)
print(array_3)
bool_index2 = array_3 > 50
print("Numeros mayores a 50:",bool_index2)

# 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.
multiples_indices = np.arange(1,9)
index_2 = [1,4,6]
print(multiples_indices[index_2])

# 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.
matriz = np.random.randint(10, 51, (4, 4))
submatriz = matriz[2:, 2:]
print("Matriz completa:")
print(matriz)
print("\nSubmatriz 2x2 en la esquina inferior derecha:")
print(submatriz)

Mario Ayala

student•

# 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])

Jesús David Fontalvo Mendoza

student•

# Ejemplo de práctica para mis compañeros: Manipulación de arrays de NumPy
import numpy as np

# Definimos una lista anidada que representa una matriz
array = [[71, 71, 80, 65, 91, 13, 18, 65, 32, 23],
         [18, 48, 97, 42, 0, 1, 92, 68, 66, 60],
         [0, 30, 32, 58, 16, 83, 89, 55, 48, 41],
         [61, 94, 65, 80, 86, 44, 35, 29, 68, 27],
         [2, 79, 51, 61, 82, 49, 89, 90, 42, 36],
         [22, 87, 86, 17, 10, 70, 67, 67, 43, 50],
         [7, 95, 26, 71, 70, 35, 53, 10, 41, 86],
         [11, 86, 10, 14, 98, 5, 23, 20, 23, 75],
         [24, 32, 53, 19, 72, 96, 53, 4, 54, 52],
         [87, 81, 75, 52, 2, 41, 68, 52, 77, 39]]

# Convertimos la lista a un array de NumPy
numpy_array = np.array(array)

print("Array original:")
print(numpy_array)
print("\n" + "="*30 + "\n")

# Realizamos "slicing" para obtener sub-arrays
print("Esquina superior izquierda (filas 0-4, columnas 0-4):")
print(numpy_array[:5, :5]) 
print("\n" + "="*30 + "\n")

print("Esquina inferior izquierda (filas 5-9, columnas 0-4):")
print(numpy_array[5:, :5]) 
print("\n" + "="*30 + "\n")

print("Esquina superior derecha (filas 0-4, columnas 5-9):")
print(numpy_array[:5, 5:]) 
print("\n" + "="*30 + "\n")

print("Esquina inferior derecha (filas 5-9, columnas 5-9):")
print(numpy_array[5:, 5:])

Juan Camilo Sánchez

student•

Ejercicio 1:

excersice1 = np.array([0,1,20,300,4000,50000,600000,7000000,80000000,900000000])
index = [3,-1]
print(excersice1[index])

Ejercicio 2:

excersice1 = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20])
index = [3,-1]
print(excersice1[2:6])
print(excersice1[-5:])

Ejercicio 3:

numran = np.random.randint(1,100)
bool_index = numran > 50
print(bool_index)

Ejercicio 4:

excersice1 = np.array([0,2,4,6,8,10,12,14,16])
index = [1,4,6]
print(excersice1[index])

Ejercicio 5:

numran = np.random.randint(1,50, size=(4,4))
bool_index = numran > 50
print(numran)
print(numran[2:4,2:4])

David Alejandro Villa Posada

student•

Para indexar una matriz en NumPy, utiliza corchetes para acceder a elementos específicos.

Importa NumPy:
```
import numpy as np
```

Crea una matriz:

matriz = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Accede a un elemento:
- Para obtener el elemento en la fila 1, columna 2:
```
elemento = matriz[1, 2]  # Devuelve 6
```

Slicing:

Para obtener las dos primeras filas y columnas:

submatriz = matriz[0:2, 0:2]  # Devuelve [[1, 2], [4, 5]]

Recuerda que los índices empiezan en 0.

Jesus Riveros

student•

Comparto los ejercicios resueltos:

Manuel Ruiz

student•

Del ejercicio de la submatriz que explicó la chica, no pude extraer la submatriz de la posición array[1:2,1:2]. Me devuelve 1 solo valor.

Qué estoy haciendo mal?

Isaac A. Andres Perez

student•

¿Podrías compartir el código de esa celda? Te dejo el código para que puedas copiarlo y compararlo con el tuyo.

array = np.random.randint(1, 10, size=(3,3))
print(array)
print(array[0,1])
print(array[:2,:2])

Isaac A. Andres Perez

student•

Tienes un error en tu slicing, estas escribiendo array[1:2, 1:2], eso solo te arrojará un único elemento en la posición (1,1). Lo correcto es escribir array[:2, :2] para que cuente todas las filas y las columnas anteriores a las segundas.

Daniek G

student•

por qué habla tan raro?

Carli Code

teacher•

Ups, perdón por hablar como la gente en mi ciudad :(

Diego Cantor

student•

Jjaaj es el acento de mexico

Daniel Ortega Sutil

student•

Respuestas!

Cynthia Zárate

student•

por fin ando entendiendo mejor los temas

Christian David Castro Martínez

student•

Comparto mi solución a los ejercicios plantados en la clase, ignoren el nombre las variables XD:

recuerden que en el ejercicio 5 primero se colocan las filas y luego las columnas para hacer el slicing: print(f[2:,2:]), esto se traduciría en toma todos los datos de la fila 2 hasta el final y luego los datos de la columna 2 hasta el final dando como resultado la submatriz de 2x2 ubicada en la esquina inferior derecha.