domingo, 21 de diciembre de 2025

Matrices en Pyhon para ciencia de datos

 

Guía de referencia: Matrices

Fuente: Coursera & Google

ASÍ COMO has aprendido, NumPy es una potente librería capaz de realizar cálculo numérico avanzado. Una de sus principales ventajas es la posibilidad de trabajar con matrices, ya que una operación aplicada a un vector se ejecuta mucho más rápido que la misma operación aplicada a una lista. El aumento del rendimiento se hace aún más evidente cuando se trabaja con grandes volúmenes de datos. Esta lectura es una guía de referencia para trabajar con arrays NumPy.

Guardar este elemento del curso

Si lo desea, puede guardar una copia de esta guía para futuras consultas. Utilízala como recurso para prácticas adicionales o en tus futuros proyectos profesionales. Para acceder a una versión descargable de este elemento del curso, haga clic en el siguiente enlace y seleccione "Usar plantilla."

Guía de referencia: Arrays

O

Si no dispone de una cuenta de Google, descargue el elemento directamente desde el archivo adjunto que aparece a continuación.

Crear un array

Como has descubierto, para usar NumPy, primero debes importarlo. La práctica estándar es alias como np.

np.array()

Esto crea un ndarray (array n-dimensional). No hay LIMIT en el número de dimensiones que puede tener un array NumPy, pero los arrays con muchas dimensiones pueden ser más difíciles de trabajar.

matriz unidimensional:

>># Crear un array n dimensional
>>import numpy as np
>>array_1d = np.array([1,2,3])
>>array_1d

>>>
array([1, 2, 3])

Observa que un array unidimensional es similar a una lista.

matriz bidimensional:

>># crear un array de 2D
>>import numpy as np
>>array_2d = np.array([[1,2,3],[4,5,6]])
>>array_2d

>>>
array([[1, 2, 3],
       [4, 5, 6]])

Observa que un array bidimensional es similar a una tabla.

matriz tridimensional:

>># crear un array 3D
>>import numpy as np
>>array_3d = np.array([[[1,2],[3,4],[5,6],[7,8]]])
>>array_3d

>>>
array([[[1, 2],
        [3, 4],
        [5, 6],
        [7, 8]]])

Observa que un array tridimensional es similar a dos tablas.

np.ceros()

  • Crea una matriz de una forma determinada que se rellena previamente con ceros:

>># crea una matriz que se rellena por ceros de froma predeterminada
>>array_zeros = np.zeros((2,3))
>>array_zeros

>>>
array([[0., 0., 0.], [0., 0., 0.]])

>># Para determinar el tamaño de una matriz se hace con shape >>tamaño_matriz = array_zeros.shape >>tamaño_matriz

>>>
(2, 3)

Se observa que el tamaño de una matriz es (filas, columnas).


  • Crea una matriz de una forma determinada que se rellena previamente con unos:

>># crear una matriz de unos
>>array_ones = np.ones((2,2))
>>array_ones

>>>
array([[1., 1.], [1., 1.]])

  • Y esto crea una matriz de una forma designada que se rellena previamente con un valor especificado:

>># Crear una matriz de ((filas, columnas),numero)
>>array_full = np.full((5,3),8)
>>array_full

>>>
array([[8, 8, 8], [8, 8, 8], [8, 8, 8], [8, 8, 8], [8, 8, 8]])

Estas funciones son útiles para varias situaciones:
  • Para inicializar una matriz de un tamaño y forma específicos, y luego llenarla con valores derivados de un cálculo

  • Asignar memoria para un uso posterior

  • Para realizar operaciones matriciales

Métodos de matrices

Las matrices de NumPy tienen muchos métodos que permiten manipularlas y operar con ellas. Para obtener una lista completa, consulte la documentación sobre matrices de NumPy. Algunos de los métodos más utilizados son los siguientes:

ndarray.flatten()

  • Devuelve una copia de la matriz comprimida en una dimensión.

>># ndarray.flatten() devuelve una version comprimida de la matriz en 1 D
>>import numpy as np
>>print(array_2d)
>>ndarray_flatten = array_2d.flatten()
>>print(ndarray_flatten)

>>>
[[1 2 3] [4 5 6]] [1 2 3 4 5 6]

  • Da una nueva forma a un array sin cambiar sus datos.

>># Cambiar la forma de la matriz sin cambiar los datos
>>import numpy as np
>>print(array_2d)
>>print(" ")
>>ndarray_reshape = array_2d.reshape(3,2)
>>print(ndarray_reshape)

>>>
[[1 2 3] [4 5 6]] [[1 2] [3 4] [5 6]]

Añadir un valor de -1 en la nueva forma designada hace que el proceso sea más eficiente, ya que indica a NumPy que infiera automáticamente el valor basándose en otros valores dados.

>># Cambiar la forma de la matriz sin cambiar los datos y agregando un valor de -1 >>import numpy as np >>print(array_2d) >>print(" ") >>ndarray_reshape = array_2d.reshape(3,-1) >>print(ndarray_reshape)

>>>
[[1 2 3] [4 5 6]] [[1 2] [3 4] [5 6]]

  • Esto convierte un array en un objeto lista. Las matrices multidimensionales se convierten en listas anidadas.

>># Convierte un array en un objeto tipo lista
>>import numpy as np
>>print(array_2d)
>>print(" ")
>>ndarray_tolist = array_2d.tolist()
>>print(ndarray_tolist)
>>print(type(ndarray_tolist))

>>>
[[1 2 3] [4 5 6]] [[1, 2, 3], [4, 5, 6]] <class 'list'>

Funciones matemáticas

Los arrays de NumPy también tienen muchos métodos que son funciones matemáticas:

  • ndarray.max(): devuelve el valor máximo en la matriz o a lo largo de un eje especificado.

>># ndarray.max() devuelve el valor máximo en la matriz o a lo largo de un eje especificado.
>>import numpy as np
>>print(array_3d)
>>print(" ")
>>ndarray_max = array_3d.max()
>>print(ndarray_max)

>>>
[[[1 2] [3 4] [5 6] [7 8]]] 8
  • ndarray.mean(): devuelve la media de todos los valores de la matriz o a lo largo de un eje especificado.

>># ndarray.mean() devuelve la media de todos los valores de la matriz o a lo largo de un eje especificado.
>>import numpy as np
>>print(array_3d)
>>print(" ")
>>ndarray_mean = array_3d.mean()
>>print(ndarray_mean)

>>>
[[[1 2] [3 4] [5 6] [7 8]]] 4.5
  • ndarray.min(): devuelve el valor mínimo de la matriz o de un eje especificado.

>># ndarray.min() devuelve el valor mínimo de la matriz o de un eje especificado.
>>import numpy as np
>>print(array_3d)
>>print(" ")
>>ndarray_min = array_3d.min()
>>print(ndarray_min)

>>>
[[[1 2] [3 4] [5 6] [7 8]]] 1
  • ndarray.std(): devuelve la desviación estándar de todos los valores de la matriz o a lo largo de un eje especificado.

>># ndarray.std(): devuelve la desviación estándar de todos los valores de la matriz o a lo >>#largo de un eje especificado.
>>import numpy as np
>>print(array_3d)
>>print(" ")
>>ndarray_std = array_3d.std()
>>print(ndarray_std)

>>>
[[[1 2] [3 4] [5 6] [7 8]]] 2.29128784747792

Atributos de las matrices

Las matrices de NumPy tienen varios atributos que permiten acceder a información sobre la matriz. Algunos de los atributos más utilizados son los siguientes:

  • ndarray.shape: devuelve una tupla de las dimensiones de la matriz.

  • ndarray.dtype: devuelve el tipo de datos del contenido de la matriz.

  • ndarray.size: devuelve el número total de elementos de la matriz.

  • ndarray.T: devuelve la matriz transpuesta (las filas se convierten en columnas y las columnas en filas).

>>import numpy as np
>>print(array_3d)
>>print(" ")
>>ndarray_shape = array_3d.shape
>>print("la dimension de la matriz es: ",ndarray_shape)
>>print(" ")
>>ndarray_dtype = array_3d.dtype
>>print("El tipo de datos del contenido de la matriz es: ",ndarray_dtype)
>>print(" ")
>>ndarray_size = array_3d.size
>>print("La cantidad de elementos de la matriz es: ",ndarray_size)
>>print(" ")
>>ndarray_t = array_3d.T
>>print("La matriz transpuesta es: ",ndarray_t)

>>>
[[[1 2] [3 4] [5 6] [7 8]]] la dimension de la matriz es: (1, 4, 2) El tipo de datos del contenido de la matriz es: int64 La cantidad de elementos de la matriz es: 8 La matriz transpuesta es: [[[1] [3] [5] [7]] [[2] [4] [6] [8]]]

Indexación y segmentación

Acceda a elementos individuales de una matriz NumPy utilizando indexación y corte. La indexación en NumPy es similar a la indexación en listas de Python, excepto que se pueden usar múltiples índices para acceder a elementos en matrices multidimensionales.

>>import numpy as np >>print(array_3d) >>print(" ") >>print(array_3d[0,0])

>>>

[[[1 2] [3 4] [5 6] [7 8]]] [1 2]

El rebanado también puede usarse para acceder a subarreglos de un arreglo NumPy:

>># Rebanado >>import numpy as np >>a = np.array([(1,2,3),(4,5,6)]) >>print(a) >>print(" ") >>print(a[:,1:])

>>>

[[1 2 3]

 [4 5 6]]

 [[2 3]

 [5 6]]

Operaciones con arrays

Las matrices NumPy soportan muchas operaciones, incluyendo funciones matemáticas y aritméticas. Éstas incluyen la suma y multiplicación de matrices, que realiza aritmética elemento a elemento en matrices:

>># suma de matrices >>a = np.array([(1,2,3),(4,5,6)]) >>b = np.array([(1,2,3),(1,2,3)]) >>c = a + b >>print(c)

>>>

[[2 4 6] [5 7 9]]

Además, hay cerca de 100

funciones matemáticas útiles que se pueden aplicar a matrices individuales o múltiples.

Mutabilidad

Las matrices de NumPy son mutables, pero con ciertas limitaciones. Por ejemplo, un elemento existente de un array puede ser cambiado:

>># Mutabilidad de array >>a = np.array([(1, 2), (3, 4)]) >>a[1][1] = 100 >>a

>>>

array([[ 1, 2], [ 3, 100]])

Sin embargo, el array no puede alargarse o acortarse.

Cómo almacenan los datos en memoria las matrices NumPy

Las matrices NumPy funcionan asignando un bloque contiguo de memoria en el momento de la instanciación. La mayoría de las otras estructuras en Python no hacen esto; sus datos están dispersos por la memoria del sistema. Esto es lo que hace que los arrays de NumPy sean tan rápidos; todos los datos se almacenan juntos en una dirección concreta de la memoria del sistema.

Curiosamente, esto es también lo que impide que un array sea alargado o acortado: La memoria contigua está ocupada por otra información. No hay espacio para más datos en esa dirección de memoria. Sin embargo, los elementos existentes de la matriz pueden sustituirse por otros nuevos.

Diagrama de la memoria del sistema. Un array NumPy se sitúa directamente entre otras estructuras de datos. No hay espacio para añadir valores.

La única forma de alargar un array es copiar el array existente a una nueva dirección de memoria junto con los nuevos datos.

Nuevas versiones y funciones en Python para ciencia de datos

Nuevas versiones y funciones de Python

Fuente: Coursera & Google

Gestión de versiones: la práctica de comprobar y gestionar las versiones de Python y las bibliotecas para garantizar la compatibilidad y el comportamiento esperado del código.

Deprecación: el proceso por el cual el código se vuelve obsoleto y se elimina gradualmente, a menudo acompañado de advertencias en los entornos de desarrollo.

Entorno: el conjunto específico de herramientas, bibliotecas y configuraciones utilizadas para desarrollar y ejecutar código, que debe ser coherente entre los colaboradores.

Dinamismo: la capacidad de Python para evolucionar y mejorar con el tiempo, influenciada por los comentarios de los usuarios y las contribuciones de la comunidad.

Ya has aprendido que uno de los grandes puntos fuertes de Python es su dinamismo: está desarrollado y respaldado por una gran comunidad de usuarios. Esto lo convierte en un lenguaje que cambia y evoluciona . En otras palabras, el lenguaje y sus bibliotecas están en constante crecimiento, mejorando y respondiendo a los comentarios de los usuarios.

El dinamismo de Python, aunque es un punto fuerte, puede introducir complejidades. Esto puede plantear problemas cuando se pretende utilizar el código durante largos periodos de tiempo o cuando varias personas trabajan juntas en un proyecto. Un script o programa desarrollado en una versión de Python está a menudo ligado a ese entorno en particular, y ejecutarlo en una versión diferente puede conducir a un comportamiento inesperado. Esto se debe a que Python y sus librerías se actualizan con el tiempo. Así, si desarrollaste un proyecto que usaba, digamos, Python 2.7.4 en 2013, e intentas ejecutarlo ahora en Python 3.12.4, existe la posibilidad de que no se ejecute de la misma manera. Del mismo modo, los proyectos colaborativos pueden verse obstaculizados por los miembros del equipo que utilizan diferentes versiones de la biblioteca, lo que resulta en problemas de compatibilidad.

Anulación

El código inevitablemente evoluciona, se elimina gradualmente y se vuelve obsoleto. Este proceso se conoce como depreciación. Si estás trabajando en un Notebook de Jupyter, generalmente recibirás una advertencia si algo de lo que utilizas está programado para ser obsoleto en una futura versión. Tu código seguirá funcionando, pero es posible que no continúe haciéndolo en futuras versiones, o si lo hace, su comportamiento podría cambiar. Es mejor prestar atención a estas advertencias y cambiar el código para adaptarlo al cambio que se avecina, porque es más fácil hacerlo cuando se está escribiendo el código activamente que volver a él cuando se rompe e intentar averiguar qué se estaba haciendo en esa fase concreta del proyecto. Además, las pequeñas actualizaciones -por ejemplo, de Python 3.11.8 a 3.11.9- no serán tan perjudiciales como las grandes actualizaciones -por ejemplo, de Python 2.X a 3.X-, por lo que notarás más depreciación cuando haya versiones importantes.

Es importante tener en cuenta que puedes seguir utilizando versiones anteriores de Python y sus bibliotecas. No siempre tienes que actualizar tu código cada vez que hay una nueva versión. De hecho, las versiones antiguas suelen seguir recibiendo soporte mucho después de haber sido reemplazadas por versiones más recientes. Esto permite a las personas y organizaciones planificar las actualizaciones de su código a lo largo del tiempo. Mientras que puedes simplemente actualizar tu proyecto, es mucho más difícil para una gran empresa actualizar su base de código asegurándose de que nada se rompe.

Entornos

El conjunto particular de condiciones y configuraciones que utilizas para desarrollar código se conoce como entorno. Tu entorno incluye las herramientas, bibliotecas, dependencias, configuraciones, etc. que se utilizan para escribir y ejecutar tu código. Por lo tanto, cuando trabajas en un proyecto con un grupo de personas, es importante que todos compartáis el mismo entorno para que el código se ejecute de la misma manera para todos. Si usted está haciendo los laboratorios de este curso en Coursera, por lo general no tiene que preocuparse por el medio ambiente, ya que ha sido preconfigurado para usted. Pero si estás haciendo los laboratorios fuera de la plataforma Coursera, ten en cuenta que tu código podría ejecutarse de forma diferente a como lo haría en Coursera, dependiendo de tu entorno.

La gestión del entorno puede ser un proceso complejo y técnico, y no vamos a entrar mucho en ello en este curso porque su entorno ha sido preconfigurado para que pueda centrarse en el aprendizaje de otras habilidades. Si usted está interesado en aprender más acerca de la configuración del entorno o la creación y el trabajo en su propio entorno de desarrollo, Anaconda Navigator es un gran lugar para empezar. Anaconda Navigator es una interfaz gráfica de usuario gratuita, de código abierto y descargable que proporciona un conjunto de herramientas fáciles de usar para gestionar entornos. También tiene un conjunto de otras integraciones de características incorporadas como Jupyter notebooks, PyCharm, VSCode, y otras herramientas populares utilizadas por los profesionales de datos.

Comprueba qué versiones tienes

Intentamos mantener el código de este curso actualizado utilizando versiones estables recientes de Python y las librerías relevantes, pero actualizar todo en todos los cursos para cada nueva versión no es factible ni necesario. Si estás haciendo las actividades del Notebook de Jupyter en tu propio ordenador y no en Coursera, puedes encontrar ocasionalmente diferencias en cómo se ejecuta tu código comparado con cómo se demuestra en Coursera. Estas diferencias se deben probablemente al versionado.

Para comprobar qué versión de Python estás ejecutando en un Notebook de Jupyter, ejecuta el siguiente código en una celda del Notebook:

>>import sys >>print(sys.version)

En PPI vamos a modificar el codigo para tambien mostrar la fecha y hora

>>import datetime as dt >>from datetime import date as dt_date >>from datetime import datetime as dt_datetime >>import sys >>""" >>Esta seria la instrucción si solo se quisiera mostrar la fecha >>fecha = dtdate.today() >>print("La fecha actual es :",fecha) >>""" >>fecha_hora = dt_datetime.now() >>print("La fecha y hora actual es :",fecha_hora) >>print("La versión actual de python es :",sys.version)

>>>

La fecha y hora actual es : 2025-12-21 14:53:20.422684 La version actual de python es : 3.12.12 (main, Oct 10 2025, 08:52:57) [GCC 11.4.0]

Para comprobar qué versión de una librería estás usando, importa la librería y luego usa su atributo __version__ para acceder a su información de versión. Por ejemplo:

>>import numpy as np >>import pandas as pd

>>from datetime import datetime as dt_datetime >>fecha_hora = dt_datetime.now() >>print("La fecha y hora actual es :",fecha_hora) >>print(np.__version__) >>print(pd.__version__)

>>>

La fecha y hora actual es : 2025-12-21 14:59:25.571066 2.0.2 2.2.2

Puntos clave

Python evoluciona y crece en respuesta a sus usuarios y casos de uso. Esto significa que las actualizaciones de código pueden cambiar el comportamiento del código escrito en versiones anteriores. Entender cómo evaluar, gestionar y solucionar problemas de tu entorno de codificación es una parte importante de la codificación.


Entradas recientes

Matrices en Pyhon para ciencia de datos

  Guía de referencia: Matrices Fuente: Coursera & Google ASÍ COMO has aprendido, NumPy es una potente librería capaz de realizar cálculo...

Entradas Populares