Edición de «NumPy»

{{Ficha de software
|nombre = NumPy
|logo = NumPy logo 2020.svg
|captura =
|pie = 
|desarrollador = Proyecto comunitario
|autor=[[Travis Oliphant]]
|última_versión = 1.26.2
|fecha_última_versión =  20 de noviembre de 2023<ref name="github-releases">{{cite web|url=https://github.com/numpy/numpy/releases|title=Releases – numpy/numpy|via=[[GitHub]]|accessdate=2023-12-07}}</ref>
|sistema_operativo = [[Multiplataforma]]
|género = Software de análisis numérico
|modelo_desarrollo=|licencia = [[Licencia BSD#Nueva Licencia BSD o BSD modificada (de 3 cláusulas)|Nueva Licencia BSD]]<ref name="numpy_org">{{cite web |title=NumPy — NumPy |url=https://numpy.org/ |website=numpy.org |publisher=NumPy developers}}</ref>
|sitio_web = http://numpy.org/
|español = No
}}

'''NumPy''' (pronunciado {{AFIc-en|ˈ|n|ʌ|m|p|aɪ}} (numpai) o, a veces {{AFIc-en|ˈ|n|ʌ|m|p|i}}<ref>{{Cita web|url=http://www.physics.nyu.edu/pine/pymanual/html/apdx3/apdx3_resources.html|título=Python resources|fechaacceso=2017-04-07|autor=Pine|nombre=David|año=2014|editorial=Rutgers University}}</ref><ref>{{Cita web|url=https://www.reddit.com/r/Python/comments/2709pq/how_do_you_say_numpy/|título=How do you say numpy?|fechaacceso=2017-04-07|año=2015|editorial=Reddit}}</ref> (numpi)) es una biblioteca para el [[Python|lenguaje de programación Python]] que da soporte para crear [[Vector (informática)|vectores]] y [[Vector (informática)|matrices]] grandes multidimensionales, junto con una gran colección de [[Función matemática|funciones]] [[matemáticas]] de [[Lenguaje de alto nivel|alto nivel]] para operar con ellas. El precursor de NumPy, Numeric, fue creado originalmente por [[Jim Hugunin]] con contribuciones de varios otros desarrolladores. En 2005, [[Travis Oliphant]] creó NumPy incorporando características de la competencia Numarray en Numeric, con amplias modificaciones. NumPy es [[Software de código abierto|un software de código abierto]] y cuenta con muchos colaboradores. 

== Historia ==
El [[Python|lenguaje de programación Python]] no fue diseñado originalmente para computación numérica, pero atrajo la atención de la comunidad científica y de ingeniería desde el principio. En 1995 se fundó el grupo de interés especial (SIG) ''matrix-sig'' con el objetivo de definir un paquete de computación de [[Vector (informática)|vectores]]; entre sus miembros se encontraba el diseñador y mantenedor de Python [[Guido van Rossum]], quien extendió [[Sintaxis y semántica de Python|la sintaxis de Python]] (en particular la sintaxis de indexación) para facilitar la computación de vectores.<ref name="millman">{{Cita publicación|url=http://www.computer.org/csdl/mags/cs/2011/02/mcs2011020009.html|título=Python for Scientists and Engineers|apellidos=Millman|nombre=K. Jarrod|apellidos2=Aivazis|nombre2=Michael|publicación=Computing in Science and Engineering|volumen=13|número=2|páginas=9–12|año=2011}}</ref> 

Jim Fulton completó una implementación de un paquete para matrices, luego generalizado por Jim Hugunin y llamado ''Numeric'' (también conocido como las "extensiones numéricas de Python" o "NumPy"). Hugunin, estudiante de posgrado en el [[Instituto de Tecnología de Massachusetts]] (MIT), {{Rp|10}}se unió a la Corporación para Iniciativas de Investigación Nacional (CNRI) en 1997 para trabajar en [[Jython|JPython]], dejando a Paul Dubois del [[Laboratorio Nacional Lawrence Livermore]] (LLNL) para asumir el cargo de mantenedor. {{Rp|10}}Otros colaboradores tempranos incluyen a David Ascher, Konrad Hinsen y [[Travis Oliphant]]. {{Rp|10}} 

Se ''escribió'' un nuevo paquete llamado ''Numarray'' como reemplazo más flexible de Numeric.<ref name="cise">{{Cita publicación|título=The NumPy array: a structure for efficient numerical computation|url=https://archive.org/details/arxiv-1102.1523|apellidos=van der Walt|nombre=Stéfan|apellidos2=Colbert|nombre2=S. Chris|publicación=Computing in Science and Engineering|editorial=IEEE|bibcode=2011arXiv1102.1523V|apellidos3=Varoquaux|nombre3=Gaël|año=2011|arxiv=1102.1523}}</ref> Al igual que Numeric, actualmente también está obsoleto.<ref>{{Cita web|url=http://www.stsci.edu/resources/software_hardware/numarray|título=Numarray Homepage|fechaacceso=2006-06-24}}</ref><ref name="NumPyBook">{{Cita libro|título=Guide to NumPy|apellidos=Travis E. Oliphant|fecha=2006-12-07|url=https://archive.org/details/NumPyBook|fechaacceso=2017-02-02}}</ref> Numarray tenía operaciones más rápidas para matrices grandes, pero era más lento que Numeric para las pequeñas,<ref>{{Cita web|url=https://mail.scipy.org/pipermail/numpy-discussion/2004-January/002645.html|título=<nowiki>[Numpy-discussion]</nowiki> Status of Numeric|fechaacceso=2017-02-02|autor=Travis Oliphant and other SciPy developers|fechaarchivo=3 de febrero de 2017|urlarchivo=https://web.archive.org/web/20170203162034/https://mail.scipy.org/pipermail/numpy-discussion/2004-January/002645.html|deadurl=yes}}</ref> por lo que durante un tiempo ambos paquetes se usaron en paralelo para diferentes casos de uso. La última versión de Numeric (v24.2) se publicó el 11 de noviembre de 2005, mientras que la última versión de Numarray (v1.5.2) se publicó el 24 de agosto de 2006.<ref>{{Cita web|url=http://sourceforge.net/project/showfiles.php?group_id=1369|título=NumPy Sourceforge Files|fechaacceso=2008-03-24}}</ref> 

Había un deseo de incluir Numeric en la biblioteca estándar de Python, pero Guido van Rossum decidió que el código no se podía mantener en su estado en ese momento. {{Cuándo|fecha=October 2013}}<ref>{{Cita web|url=https://scipy.github.io/old-wiki/pages/History_of_SciPy.html|título=History_of_SciPy - SciPy wiki dump|sitioweb=scipy.github.io}}</ref> A principios de 2005, el desarrollador de NumPy, Travis Oliphant, quería unificar la comunidad en torno a un solo paquete de arreglo y portó las características de Numarray a Numeric, lanzando el resultado como NumPy 1.0 en 2006.<ref name="cise"/> Este nuevo proyecto formaba parte de [[SciPy]]. Para evitar instalar el gran paquete SciPy solo para obtener un objeto de matriz, este nuevo paquete se separó y se llamó NumPy. El soporte para Python 3 se añadió en 2011 con la versión 1.5.0 de NumPy.<ref>{{Cita web|url=http://sourceforge.net/projects/numpy/files//NumPy/1.5.0/NOTES.txt/view|título=NumPy 1.5.0 Release Notes|fechaacceso=2011-04-29}}</ref> 

En 2011, [[PyPy]] comenzó a desarrollar una implementación de la API NumPy para PyPy.<ref>{{Cita web|url=http://morepypy.blogspot.com/2011/10/numpy-funding-and-status-update.html|título=PyPy Status Blog: NumPy funding and status update|fechaacceso=2011-12-22}}</ref> Todavía no es totalmente compatible con NumPy.<ref>{{Cita web|url=http://buildbot.pypy.org/numpy-status/latest.html|título=NumPyPy Status|fechaacceso=2013-10-14}}</ref> 

== Características ==
NumPy apunta a la implementación de Python de referencia [[CPython]], un intérprete de [[código de bytes]] no optimizador. Los algoritmos matemáticos escritos para esta versión de Python a menudo se ejecutan mucho más lento que los equivalentes [[Compilador|compilados]]. NumPy aborda el problema de la lentitud en parte al proporcionar matrices multidimensionales, funciones y operadores que operan de manera eficiente en matrices, lo que requiere reescribir algo de código, principalmente [[ Bucle interior |bucles internos]], usando NumPy. 

El uso de NumPy en Python brinda una funcionalidad comparable a [[MATLAB]], ya que ambos se interpretan,<ref>{{Cita web|url=https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html|título=NumPy for Matlab users|fechaacceso=2017-02-02|autor=The SciPy Community|fechaarchivo=20 de mayo de 2017|urlarchivo=https://web.archive.org/web/20170520093610/https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html|deadurl=yes}}</ref> y ambos permiten al usuario escribir programas rápidos siempre que la mayoría de las operaciones funcionen en vectores o matrices en lugar de [[Variable (programación)|escalares]]. En comparación, MATLAB cuenta con una gran cantidad de cajas de herramientas adicionales, en particular [[Simulink]], mientras que NumPy está intrínsecamente integrado con Python, un lenguaje de programación más moderno y completo. Además, se encuentran disponibles paquetes complementarios de Python; [[SciPy]] es una biblioteca que agrega más funcionalidad similar a MATLAB y [[Matplotlib]] es un paquete de trazado que proporciona una funcionalidad de trazado similar a MATLAB. Internamente, tanto MATLAB como NumPy se basan en [[Basic Linear Algebra Subprograms|BLAS]] y [[LAPACK]] para cálculos de álgebra lineal eficientes. 

Los [[Binding|bindings]] de Python de la ampliamente utilizada biblioteca de [[Visión artificial|visión por computadora]] [[OpenCV]] utilizan matrices NumPy para almacenar y operar con datos. Dado que las imágenes con múltiples canales se representan simplemente como matrices tridimensionales, indexar, cortar o [[Máscara (informática)|enmascarar]] con otras matrices son formas muy eficientes de acceder a píxeles específicos de una imagen. La matriz NumPy como estructura de datos universal en OpenCV para imágenes, [[ Detección de puntos de interés |puntos de características]] extraídos, [[Núcleo (procesamiento digital de imágenes)|núcleos de filtrado]] y muchos más simplifica enormemente el flujo de trabajo de programación y la [[Depurador|depuración]] . 

=== La estructura de datos ndarray ===
La funcionalidad principal de NumPy es su estructura de datos "ndarray", para una matriz de ''n'' dimensiones. Estas matrices son vistas escalonadas de la memoria.<ref name="cise"/> A diferencia de la estructura de datos de lista incorporada de Python, estas matrices se escriben de forma homogénea: todos los elementos de una única matriz deben ser del mismo tipo. 

Dichas matrices también pueden ser vistas en búferes de memoria asignados por extensiones de [[C (lenguaje de programación)|C]] o [[C++]], [[Cython]] y [[Fortran]] al intérprete CPython sin la necesidad de copiar datos, lo que brinda un mayor grado de compatibilidad con las bibliotecas numéricas existentes. Esta funcionalidad es explotada por el paquete [[SciPy]], que incluye varias de estas bibliotecas (en particular [[Basic Linear Algebra Subprograms|BLAS]] y [[LAPACK]]). NumPy tiene soporte incorporado para ndarrays [[Archivo proyectado en memoria|mapeados en]] memoria.<ref name="cise"/> 

=== Limitaciones ===
Insertar o agregar entradas a una matriz no es tan trivialmente posible como lo es con las listas de Python. La <tt>rutina np.pad(...)</tt> para extender matrices crea nuevas matrices con la forma deseada y los valores de relleno, copia la matriz dada en la nueva y la devuelve. La <tt>operación np.concatenate([a1, a2])de</tt> NumPy no vincula realmente las dos matrices, sino que devuelve una nueva, llena con las entradas de ambas matrices dadas en secuencia. La remodelación de las dimensiones de una matriz con <tt>np.reshape(...)</tt> solo es posible siempre que el número de elementos de la matriz no cambie. Estas circunstancias se originan en el hecho de que las matrices de NumPy deben ser vistas en búferes de memoria contiguos. Un paquete de reemplazo llamado Blaze intenta superar esta limitación.<ref>{{Cita web|url=https://blaze.readthedocs.io/|título=Blaze Ecosystem Docs|fechaacceso=2016-07-17|sitioweb=Read the Docs}}</ref> 

Los algoritmos que no se pueden expresar como una operación vectorizada normalmente se ejecutarán lentamente porque deben implementarse en "Python puro", mientras que la vectorización puede aumentar la complejidad de la memoria de algunas operaciones de constante a lineal, porque se deben crear matrices temporales que sean tan grandes como las entradas. Varios grupos han implementado la compilación en tiempo de ejecución de código numérico para evitar estos problemas. Las soluciones de código abierto que interactúan con NumPy incluyen <code>scipy.weave</code>, numexpr<ref>{{Cita web|url=https://github.com/pydata/numexpr|título=numexpr|fechaacceso=2014-03-08|autor=Francesc Alted}}</ref> y [[Numba]].<ref>{{Cita web|url=http://numba.pydata.org/|título=Numba|fechaacceso=2014-03-08}}</ref> [[Cython]] y [[Pythran]] son otras alternativas de compilación estática.

== Ejemplos ==

; Creación de matrices 
<syntaxhighlight lang="numpy">
>>> import numpy as np
>>> x = np.array([1, 2, 3])
>>> x
array([1, 2, 3])
>>> y = np.arange(10)  # como en Python list(range(10)), pero devuelve una matriz de numpy
>>> y
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
</syntaxhighlight>

; Operaciones básicas 
<syntaxhighlight lang="numpy">
>>> a = np.array([1, 2, 3, 6])
>>> b = np.linspace(0, 2, 4)  # crea un vector con cuatro puntos equiespaciados, desde 0 hasta 2.
>>> c = a - b
>>> c
array([ 1.        ,  1.33333333,  1.66666667,  4.        ])
>>> a**2
array([ 1,  4,  9, 36])
</syntaxhighlight>

; Funciones universales 
<syntaxhighlight lang="numpy">
>>> a = np.linspace(-np.pi, np.pi, 100) 
>>> b = np.sin(a)
>>> c = np.cos(a)
</syntaxhighlight>

; Álgebra lineal 
<syntaxhighlight lang="numpy">
>>> from numpy.random import rand
>>> from numpy.linalg import solve, inv
>>> a = np.array([[1, 2, 3], [3, 4, 6.7], [5, 9.0, 5]])
>>> a.transpose()
array([[ 1. ,  3. ,  5. ],
       [ 2. ,  4. ,  9. ],
       [ 3. ,  6.7,  5. ]])
>>> inv(a)
array([[-2.27683616,  0.96045198,  0.07909605],
       [ 1.04519774, -0.56497175,  0.1299435 ],
       [ 0.39548023,  0.05649718, -0.11299435]])
>>> b =  np.array([3, 2, 1])
>>> solve(a, b)  # resuelve la ecuación ax = b
array([-4.83050847,  2.13559322,  1.18644068])
>>> c = rand(3, 3) * 20  # crea una matriz de 3x3 con valores aleatorios en el intervalo [0,1] escalados por 20
>>> c
array([[  3.98732789,   2.47702609,   4.71167924],
       [  9.24410671,   5.5240412 ,  10.6468792 ],
       [ 10.38136661,   8.44968437,  15.17639591]])
>>> np.dot(a, c)  # multiplicación de matrices
array([[  53.61964114,   38.8741616 ,   71.53462537],
       [ 118.4935668 ,   86.14012835,  158.40440712],
       [ 155.04043289,  104.3499231 ,  195.26228855]])
>>> a @ c # notación alternativa desde Python 3.5 y NumPy 1.10
array([[  53.61964114,   38.8741616 ,   71.53462537],
       [ 118.4935668 ,   86.14012835,  158.40440712],
       [ 155.04043289,  104.3499231 ,  195.26228855]])
</syntaxhighlight>

; Tensores 
<syntaxhighlight lang="numpy">
>>> M = np.zeros(shape=(2, 3, 5, 7, 11))
>>> T = np.transpose(M, (4, 2, 1, 3, 0))
>>> T.shape
(11, 5, 3, 7, 2)
</syntaxhighlight>

; Incorporación con OpenCV 
<syntaxhighlight lang="numpy">
>>> import numpy as np
>>> import cv2
>>> r = np.reshape(np.arange(256*256)%256,(256,256))  # matriz de píxeles 256x256 con un gradiente horizontal de 0 a 255, para el canal del color rojo
>>> g = np.zeros_like(r)  # matriz del mismo tamaño que r pero rellena de ceros, para el canal del color verde
>>> b = r.T # matriz r traspuesta que genera un gradiente vertical, para el canal del color azul
>>> cv2.imwrite('gradients.png', np.dstack([b,g,r]))  # las imágenes OpenCV se interpretan como BGR, la matriz agrupada se escribirá en un archivo PNG de 8 bit llamado 'gradients.png'
True
</syntaxhighlight>

;<nowiki> Búsqueda Nearest-Neighbor: algoritmo de Python iterativo y versión vectorizada de NumPy </nowiki>
<syntaxhighlight lang="numpy">
>>> # # # Python iterativo puro # # #
>>> points = [[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]]
>>> qPoint = [4,5,3]
>>> minIdx = -1
>>> minDist = -1
>>> for idx, point in enumerate(points):  # itera sobre todos los puntos
        dist = sum([(dp-dq)**2 for dp,dq in zip(point,qPoint)])**0.5  # calcula la distancia euclídea desde cada punto a q
        if dist < minDist or minDist < 0:  # si se requiere, actualiza la distancia mínima y el índice del punto correspondiente
            minDist = dist
            minIdx = idx

>>> print('Punto más cercano a q: {0}'.format(points[minIdx]))
Punto más cercano a q: [3, 4, 4]

>>> # # # Vectorización equivalente en NumPy # # #
>>> import numpy as np
>>> points = np.array([[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]])
>>> qPoint = np.array([4,5,3])
>>> minIdx = np.argmin(np.linalg.norm(points-qPoint,axis=1))  # calcula todas las distancias euclídeas de una vez y devuelve el índice de la menor de ellas
>>> print('Punto más cercano a q: {0}'.format(points[minIdx]))
Punto más cercano a q: [3 4 4]
</syntaxhighlight>

== Véase también ==

* [[SciPy]]
* [[Matplotlib]]

* [[Programación con matrices]] 

== Referencias ==
{{Listaref|2}}

== Otras lecturas ==

* {{Cita libro|apellidos=Bressert|nombre=Eli|título=Scipy and Numpy: An Overview for Developers.|año=2012|editorial=O'Reilly|isbn=978-1-4493-0546-8}}
* {{Cita libro|nombre=Wes|apellidos=McKinney|título=Python for Data Analysis : Data Wrangling with Pandas, NumPy, and IPython|ubicación=Sebastopol|editorial=O'Reilly|año=2017|edición=2nd|isbn=978-1-4919-5766-0}}
* {{Cita libro|nombre=Jake|apellidos=VanderPlas|capítulo=Introduction to NumPy|páginas=[https://archive.org/details/pythondatascienc0000vand/page/33 33]–96|título=Python Data Science Handbook: Essential Tools for Working with Data|url=https://archive.org/details/pythondatascienc0000vand|ubicación=|editorial=O'Reilly|año=2016|isbn=978-1-4919-1205-8}}

== Enlaces externos ==

* [https://web.archive.org/web/20120120095953/http://numpy.scipy.org/ Sitio oficial de NumPy] (en inglés)

:* [https://web.archive.org/web/20070927015018/http://www.scipy.org/History_of_SciPy/ Historia de NumPy] (en inglés)
:* [http://www.scipy.org/Cookbook/BuildingArrays Introducción a las matrices en NumPy] {{Wayback|url=http://www.scipy.org/Cookbook/BuildingArrays |date=20100612210049 }} (en inglés)
:* [https://web.archive.org/web/20120209130654/http://www.scipy.org/NumPy_for_Matlab_Users NumPy para usuarios de Matlab] (en inglés)

* [http://matplotlib.sourceforge.net/ Matplotlib, paquete para graficar con NumPy] (en inglés)

{{control de autoridades}}
[[Categoría:Software que utiliza la licencia BSD]]
[[Categoría:Software científico libre]]
[[Categoría:Software de análisis numérico]]
[[Categoría:Bibliotecas de Python]]