Facultad de ciencia e ingeniería en biotecnología

ALGORITMO Y LÓGICA DE PROGRAMACIÓN

Integrantes del grupo:

1. Jamilet Esthefania Oyola Flores
2. Nagely Marisol Piloso Olaya
3. George Mathews Zambrano Chin
4. Frixson Bryan Primero Guillermo
Tema:
Arreglos y matrices en Python
Nivel:
3er. Semestre - B2
Docente:
CESAR ANÍBAL BARZOLA GAIBOR
Periodo académico
abril – agosto

2024
 Introducción

La programación en Python ofrece una variedad de herramientas para trabajar con arreglos
unidimensionales y multidimensionales, lo que permite manejar conjuntos de datos estructurados de
manera eficiente. Los vectores o arreglos unidimensionales son listas de elementos del mismo tipo
que se acceden mediante índices. Por otro lado, la representación de datos más compleja, con
múltiples niveles de profundidad, se puede lograr mediante arreglos multidimensionales, como
matrices o tensores.

La librería NumPy es ampliamente utilizada en Python para el manejo de arreglos

multidimensionales, ofreciendo funciones y operaciones optimizadas para el álgebra lineal, la
estadística y otros campos de las matemáticas e ingeniería. Esta librería facilita la creación,
manipulación y procesamiento de arreglos de manera eficiente, lo que resulta esencial para
aplicaciones que requieren un alto rendimiento en el manejo de datos.

En este contexto, es fundamental comprender las ventajas y recomendaciones de trabajar con arreglos
unidimensionales y multidimensionales, así como practicar el manejo de índices, operaciones y
funciones específicas de las librerías especializadas. Esto permitirá maximizar las capacidades de
Python en el procesamiento de datos estructurados y mejorar la eficiencia en el desarrollo de
aplicaciones que requieren un uso intensivo de arreglos.
 Desarrollo
¿Qué son los arreglos y matrices en Python?

Los arreglos son listas de elementos del mismo tipo en una o más dimensiones. Los operadores y
funciones de la librería NumPy son los principales recursos utilizados para su manejo.

Una matriz o arreglo de dos dimensiones en la notación del lenguaje Python es una lista de elementos
con igual longitud y del mismo tipo (numérico). Estos objetos, al igual que los vectores (arreglos
unidimensionales), son cruciales en aplicaciones matemáticas y de ingeniería.

¿Cómo se declaran?

Para declarar arreglos y matrices en Python, se usa la librería NumPy que es una librería que apoya
aplicaciones en álgebra lineal, estadística y otros campos de las matemáticas e ingeniería.

La librería NumPy normalmente se refiere con la declaración siguiente: import numpy as np

• Declaración de un arreglo unidimensional (vector) con NumPy:

Numeros enteros:
import numpy as np
arr_int = np.array([1, 2, 3, 4])
print(arr_int)
Numeros reales:
import numpy as np
arr_float = np.array([1.0, 2.5, 3.7, 4.2])
print(arr_float)
Cadena de texto:
import numpy as np
arr_str = np.array(['a', 'b', 'c'])
print(arr_str)
Gracias a las funcionalidades de NumPy, puedes realizar operaciones matemáticas y
manipulaciones de manera eficiente con estos arreglos.
• Declaración de una matriz multidimensional con NumPy:
Numeros enteros:
import numpy as np
mat_3d_int = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])
print(mat_3d_int)
 Numeros reales:
import numpy as np
mat_3d_float = np.array([[[1.0, 2.5], [3.7, 4.2]], [[5.3, 6.8], [7.1, 8.9]], [[9.2, 10.6]]])
print(mat_3d_float)

Cadena de texto:
import numpy as np
mat_3d_str = np.array([[['a', 'b'], ['c', 'd']], [['e', 'f'], ['g', 'h']]])
print(mat_3d_str)

NumerPy ofrece características útiles para trabajar con matrices multidimensionales en Python.

Estos ejemplos utilizan np.array() para generar arreglos unidimensionales y matrices

multidimensionales. Para su manipulación y cálculo posterior, se pueden asignar estos arreglos y
matrices a las variables. Al usar NumPy, se recomienda importar la librería con un alias, como np,
para facilitar el acceso a sus funciones y evitar conflictos con otras librerías o funciones de Python
comunes.

¿Cuál es la diferencia entre un arreglo unidimensional y multidimensional?

Un arreglo unidimensional, también conocido como vector, es una estructura de datos que contiene
elementos dispuestos en una sola dimensión, como una lista de elementos en una fila o columna. Los
elementos se almacenan de forma lineal uno después del otro y se utiliza un solo índice para acceder
a ellos.

Un arreglo multidimensional, por otro lado, es una estructura de datos que contiene elementos
dispuestos en dos o más dimensiones, como una tabla con filas y columnas o un cubo con
profundidad. Los elementos están organizados en filas, columnas y posiblemente en más
dimensiones, y se puede acceder a ellos utilizando múltiples índices para determinar su posición en
cada dimensión.

Por lo tanto, la principal distinción entre un arreglo unidimensional y multidimensional radica en la

cantidad de dimensiones en las que se organizan los elementos. Mientras que un arreglo
unidimensional tiene una dimensión (una fila o columna), el otro arreglo multidimensional tiene dos
o más dimensiones (filas, columnas, profundidad, etc.), lo que permite representar estructuras de
datos más complejas y mejor organizadas.
¿Cuál es su importancia en la programación?

Debido a su capacidad para organizar datos de manera estructurada y eficiente, los arreglos
unidimensionales y multidimensionales son esenciales para la programación.

Primero, los arreglos unidimensionales permiten almacenar una secuencia de elementos en una sola
dimensión, lo que facilita el acceso a los datos con un único índice. Esto es útil para almacenar listas
de elementos simples, como números, cadenas de texto o cualquier otro tipo de información.

Sin embargo, la representación de estructuras de datos más complejas que requieren múltiples
dimensiones requiere arreglos multidimensionales. Por ejemplo, una matriz bidimensional organiza
los datos en filas y columnas, como una tabla, mientras que un arreglo tridimensional puede
representar los datos en un espacio tridimensional, como en imágenes volumétricas o datos de
sensores.

Los arreglos son importantes porque facilitan el acceso a los datos. Los índices facilitan la
manipulación y procesamiento de grandes conjuntos de datos al almacenar datos en arreglos, lo que
permite un acceso rápido y sencillo a los datos. Además, los arreglos son esenciales para realizar
operaciones matemáticas y algoritmos eficientes porque permiten aplicar operaciones a múltiples
elementos simultáneamente.

Por lo tanto, los arreglos unidimensionales y multidimensionales son herramientas de programación

esenciales para organizar, acceder y manipular datos de manera eficiente. Estos arreglos son
esenciales para el desarrollo de aplicaciones y algoritmos en una variedad de áreas de la informática.

Aplicaciones prácticas

Ciencia de Datos: Los arreglos NumPy son ampliamente utilizados en el análisis y procesamiento
de datos. Permiten realizar operaciones vectorizadas de manera eficiente en grandes conjuntos de
datos numéricos.

Ejemplo: Supongamos que tenemos un conjunto de datos con las edades de una
población y queremos calcular la edad promedio.
Gráficos Computacionales: Las bibliotecas como Matplotlib utilizan arreglos NumPy para
representar y manipular datos en gráficos y visualizaciones.

Ejemplo: Graficar una función seno en un intervalo específico.

Procesamiento de Imágenes: Las imágenes digitales se representan como matrices de píxeles, donde
cada elemento contiene información sobre el color o intensidad de un píxel específico.

Ejemplo: Cargar una imagen y convertirla a escala de grises.

Python es un lenguaje de programación ampliamente utilizado en las aplicaciones web, el desarrollo

de software, la ciencia de datos y el machine learning (ML). Los desarrolladores utilizan Python
porque es eficiente y fácil de aprender, además de que se puede ejecutar en muchas plataformas
diferentes.
El software Python se puede descargar gratis, se integra bien a todos los tipos de sistemas y aumenta
la velocidad del desarrollo. Qué son las matrices y cómo se utilizan en Python. Una matriz es
simplemente una colección de elementos que se organizan en filas y columnas. En Python, las
matrices se pueden crear fácilmente utilizando listas anidadas.
Para declarar una matriz en Python, simplemente escribimos una lista dentro de otra. Por ejemplo, si
queremos crear una matriz de 2x2, podemos hacerlo de la siguiente manera:

matrix = [[1, 2], [3, 4]]

Esta matriz contiene cuatro elementos, organizados en dos filas y dos columnas. La primera fila
contiene los elementos 1 y 2, mientras que la segunda fila contiene los elementos 3 y 4.
Una vez que tengamos una matriz en Python, podemos realizar una serie de operaciones en ella. Por
ejemplo, podemos utilizar la sintaxis de la matriz para acceder a elementos individuales. Para acceder
al elemento en la fila 0, columna 1 de la matriz anterior, podemos escribir:

print(matrix[0][1]) # salida: 2

También podemos recorrer una matriz utilizando un bucle for. Si queremos imprimir todos los
elementos de la matriz anterior, podemos hacerlo de la siguiente manera:

for row in matrix:

for element in row:

print(element)

Esta operación imprimirá los elementos 1, 2, 3 y 4 en la consola. Además de estas operaciones básicas,
también es posible realizar operaciones específicas de las matrices en Python. Por ejemplo, podemos
sumar dos matrices juntas utilizando el operador +. Si tenemos dos matrices almacenadas en las
variables matrix_1 y matrix_2, podemos sumarlas juntas de la siguiente manera:

result = [[0, 0], [0, 0]]

for i in range(len(matrix_1)):

for j in range(len(matrix_1[0])):

result[i][j] = matrix_1[i][j] + matrix_2[i][j]

Esta operación nos devuelve una nueva matriz que contiene la suma de los elementos
correspondientes de las dos matrices originales.
Suma de Números
La suma de números enteros o de punto flotante se realiza utilizando el operador (+):

# Suma de enteros # Suma de flotantes

a=5 x = 2.5
b=3 y = 4.5
resultado = a + b # Resultado: 8 resultado = x + y # Resultado: 7.0

Suma de Cadenas (Concatenación)

En el caso de las cadenas (strings), el operador + se usa para concatenar:
str1 = "Hola"
str2 = " Mundo"
resultado = str1 + str2 # Resultado: "Hola Mundo"

Suma de Listas
Para listas, el operador (+) también se utiliza para concatenar:
list1 = [1, 2, 3]
list2 = [4, 5, 6]
resultado = list1 + list2 # Resultado: [1, 2, 3, 4, 5, 6]

Suma de Arreglos y Matrices usando NumPy

Con numpy, puedes realizar la suma de arreglos y matrices de manera eficiente:
import numpy as np
# Suma de arreglos de una dimensión
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
sum_arr = arr1 + arr2 # Resultado: array([5, 7, 9])

# Suma de matrices de dos dimensiones

mat1 = np.array([[1, 2], [3, 4]])
mat2 = np.array([[5, 6], [7, 8]])
sum_mat = mat1 + mat2 # Resultado: array([[ 6, 8], [10, 12]])
Suma de Elementos en una Lista o Arreglo
Para sumar todos los elementos de una lista o arreglo, puedes usar la función sum:
# Suma de elementos en una lista
lista = [1, 2, 3, 4, 5]
resultado = sum(lista) # Resultado: 15

# Suma de elementos en un arreglo de numpy

arr = np.array([1, 2, 3, 4, 5])
resultado = np.sum(arr) # Resultado: 15

Resta de Números
La resta de números enteros o de punto flotante se realiza utilizando el operador (–) de la siguiente manera:

# Resta de enteros
a = 10
b=3
resultado = a - b # Resultado: 7

# Resta de flotantes
x = 5.5
y = 2.5
resultado = x - y # Resultado: 3.0

Resta de Elementos en una Lista

Para restar elementos de una lista, puedes iterar a través de la lista o utilizar comprehensiones de lista,
pero no hay una operación directa para restar listas completas de la misma manera que se suma o
concatena listas. Aquí tienes algunos ejemplos:

Restar elementos correspondientes en dos listas

list1 = [10, 20, 30]
list2 = [1, 2, 3]
resultado = [a - b for a, b in zip(list1, list2)] # Resultado: [9, 18, 27]

Restar un valor a todos los elementos de una lista

lista = [10, 20, 30]
resultado = [x - 5 for x in lista] # Resultado: [5, 15, 25]
Resta de Arreglos y Matrices usando NumPy
Con numpy, puedes realizar la resta de arreglos y matrices de manera eficiente:
import numpy as np

# Resta de arreglos de una dimensión

arr1 = np.array([10, 20, 30])
arr2 = np.array([1, 2, 3])
resta_arr = arr1 - arr2 # Resultado: array([ 9, 18, 27])

# Resta de matrices de dos dimensiones

mat1 = np.array([[10, 20], [30, 40]])
mat2 = np.array([[1, 2], [3, 4]])
resta_mat = mat1 - mat2 # Resultado: array([[ 9, 18], [27, 36]])

Multiplicación de Números
La multiplicación de números enteros o de punto flotante se realiza utilizando el operador (*):
# Multiplicación de enteros
a=5
b=3
resultado = a * b # Resultado: 15

# Multiplicación de flotantes
x = 2.5
y = 4.0
resultado = x * y # Resultado: 10.0

Multiplicación de Cadenas (Repetición)

Para cadenas, el operador (*) se utiliza para repetir la cadena un número específico de veces:

str1 = "Hola"
resultado = str1 * 3 # Resultado: "HolaHolaHola"

Multiplicación de Elementos en una Lista

Para multiplicar elementos correspondientes en dos listas, puedes utilizar una comprensión de lista:
list1 = [1, 2, 3]
list2 = [4, 5, 6]
resultado = [a * b for a, b in zip(list1, list2)] # Resultado: [4, 10, 18]
Multiplicación de Arreglos y Matrices usando NumPy
Con numpy, puedes realizar la multiplicación de arreglos y matrices de manera eficiente:
Multiplicación Elemento a Elemento
Para multiplicar elemento a elemento, se utiliza el operador (*):
import numpy as np

# Multiplicación de arreglos de una dimensión

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
mul_arr = arr1 * arr2 # Resultado: array([ 4, 10, 18])

# Multiplicación de matrices de dos dimensiones

mat1 = np.array([[1, 2], [3, 4]])
mat2 = np.array([[5, 6], [7, 8]])
mul_mat = mat1 * mat2 # Resultado: array([[ 5, 12], [21, 32]])

Multiplicación de Matrices (Producto Matricial)

Para el producto matricial, se utiliza la función np.dot o el operador @:
# Producto matricial
product_mat = np.dot(mat1, mat2) #O también mat1 @ mat2
# Resultado: array([[19, 22], [43, 50]])

En Python, la transposición de matrices se puede realizar de manera sencilla utilizando la biblioteca

numpy. La transposición de una matriz implica intercambiar sus filas por columnas. Aquí te explico
cómo hacerlo:
Importar NumPy
Primero, necesitas importar numpy:
import numpy as np
Crear una Matriz
Crea una matriz usando np.array:
matriz = np.array([[1, 2, 3], [4, 5, 6]])
print("Matriz original:")
 print(matriz)
Transponer la Matriz

Para transponer la matriz, puedes usar el atributo .T:

matriz_transpuesta = matriz.T
print("Matriz transpuesta:")
print(matriz_transpuesta)
Ejemplo Completo
import numpy as np

# Crear una matriz

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

# Imprimir la matriz original

print("Matriz original:")
print(matriz)

# Transponer la matriz
matriz_transpuesta = matriz.T

# Imprimir la matriz transpuesta

print("Matriz transpuesta:")
print(matriz_transpuesta)

Salida del Código

La salida del código anterior será:
Matriz original:
[[1 2 3]
[4 5 6]]

Matriz transpuesta:
[[1 4]
[2 5]
[3 6]]
Uso de numpy.transpose
También puedes usar la función numpy.transpose para transponer una matriz:
matriz_transpuesta = np.transpose(matriz)
print("Matriz transpuesta usando np.transpose:")
 print(matriz_transpuesta)
Ambos métodos (.T y np.transpose) son equivalentes y proporcionan la misma salida.
Estos ejemplos demuestran cómo transponer matrices en Python utilizando numpy, lo cual es útil en
diversas aplicaciones matemáticas y científicas.
• Funciones Adicionales
• Inversa de una Matriz
Para calcular la inversa de una matriz, usa np.linalg.inv:
inversa = np.linalg.inv(mat1)
# Resultado: array([[-2. , 1. ], [ 1.5, -0.5]])

Determinante de una Matriz

Para calcular el determinante, usa np.linalg.det:

determinante = np.linalg.det(mat1)

# Resultado: -2.0000000000000004

Entre las múltiples bibliotecas de Python, NumPy es una de las más utilizadas. Esto se debe a que
muchas técnicas de Data Science requieren cuadros y matrices de gran tamaño y cálculos complejos
para extraer información valiosa de los datos. NumPy simplifica este proceso con funciones
matemáticas diversas y variadas. Además, NumPy también proporciona funciones que permiten a los
desarrolladores realizar funciones matemáticas y estadísticas básicas o avanzadas en arrays y
matrices multidimensionales con pocas líneas de código.
 Conclusiones y recomendaciones
Los arreglos unidimensionales y multidimensionales son herramientas esenciales en programación
para trabajar con conjuntos de datos de manera estructurada y eficiente porque facilitan el acceso y
la representación de estructuras de datos.
Para aprovechar al máximo el potencial de los arreglos unidimensionales y multidimensionales, es
recomendable practicar el manejo de índices y realizar operaciones comunes como sumar, restar,
multiplicar y dividir elementos. Esto ayuda a familiarizarse con la sintaxis y las operaciones
disponibles para manipular los arreglos de manera eficiente y efectiva.
Además, practicar el uso de funciones y métodos específicos de las librerías especializadas en
arreglos, como NumPy en Python, puede aumentar la productividad y facilitar el trabajo con datos
estructurados, Python nos brindan una herramienta poderosa y versátil para el manejo y
procesamiento de datos, lo que nos ayuda a abordar una amplia gama de tareas y aplicaciones
prácticas en diversos campos, desde la ciencia de datos hasta el procesamiento de imágenes, pasando
por la visualización y el cálculo numérico
 Referencias

Arreglos multidimensionales - MATLAB & Simulink. (2023). MathWorks. Retrieved May 17, 2024, from
https://la.mathworks.com/help/matlab/math/multidimensional-arrays.html
Gonzalez, R. C., & Woods, R. E. (2018). Digital image processing (4th ed.). Pearson.

Harris, C. R., Millman, K. J., van der Walt, S. J., Gommers, R., Virtanen, P., Cournapeau, D., ... & Oliphant, T. E.
(2020). Array programming with NumPy. Nature, 585(7825), 357-362.

Hunter, J. D. (2007). Matplotlib: A 2D graphics environment. Computing in Science & Engineering, 9(3), 90-95.
imagen python. (n.d.). Retrieved May 17, 2024, from
https://www.google.com/url?sa=i&url=https%3A%2F%2Fworldvectorlogo.com%2Fes%2Flogo%2Fpy
thon-
3&psig=AOvVaw2oIFrAXYxnIYSaGXZFa9Id&ust=1716049663324000&source=images&cd=vfe&opi
=89978449&ved=0CBQQjhxqFwoTCPDUkfmNlYYDFQAAAAAdAAAAABAE
Introducción ARREGLOS ARREGLOS ARREGLOS. Introducción Definición de arreglos. Tipos de arreglos.
Arreglos unidimensionales Y bidimensionales. - PDF Free Download. (2022). DocPlayer. Retrieved
May 17, 2024, from https://docplayer.es/68608834-Introduccion-arreglos-arreglos-arreglos-
introduccion-definicion-de-arreglos-tipos-de-arreglos-arreglos-unidimensionales-y-
bidimensionales.html
McKinney, W. (2012). Python para análisis de datos: negociación de datos con Pandas, NumPy e IPython .
"O'Reilly Media, Inc.".

Oliphant, TE (2006). Guía de numpy (Vol. 1, p. 85). Estados Unidos: Editorial Trelgol.
Python. (n.d.). Online Python - IDE, Editor, Compiler, Interpreter. https://www.online-python.com/
PYTHON PROGRAMACION. (2014, July 12). fcnm - espol. Retrieved May 17, 2024, from
https://www.fcnm.espol.edu.ec/sites/fcnm.espol.edu.ec/files/PYTHON_PROGRAMACION_V3_0.pdf
Tipos integrados — documentación de Python - 3.12.3. (2023). Python Docs. Retrieved May 17, 2024, from
https://docs.python.org/es/3/library/stdtypes.html
Van Rossum, G. (junio de 2007). Lenguaje de programación Python. En la conferencia técnica anual de
USENIX (Vol. 41, No. 1, págs. 1-36).