Este tutorial te mostrará cómo usar la función NumPy max, que verás en el código de Python como np.max.

A un alto nivel, quiero explicar la función y mostrarte cómo funciona. Siendo así, hay dos secciones principales en este tutorial: la sintaxis de NumPy max, y ejemplos de cómo usar NumPy max.

Si todavía estás empezando con NumPy, te recomiendo que leas todo el tutorial, de principio a fin. Dicho esto, si sólo quieres obtener una respuesta rápida a una pregunta, puedes saltar a la sección apropiada con uno de los siguientes enlaces:

• La sintaxis de NumPy max
• Ejemplos de cómo usar NumPy max

Ok. Con todo esto en mente, empecemos.

Primero, hablemos de NumPy y de la función NumPy max.

Una rápida introducción a la función NumPy max

Probablemente tengas claro que la función NumPy max es una función del módulo NumPy.

Pero si eres un verdadero principiante, puede que no sepas realmente qué es NumPy. Así que antes de hablar de la función np.max específicamente, vamos a hablar rápidamente de NumPy.

¿Qué es exactamente NumPy?

Numpy es un módulo de manipulación de datos para Python

Para decirlo de forma muy sencilla, NumPy es un paquete de manipulación de datos para el lenguaje de programación Python.

Si estás interesado en la ciencia de datos en Python, NumPy es muy importante. Esto se debe a que gran parte del trabajo de la ciencia de datos es simplemente la manipulación de datos. Ya sea que estés haciendo aprendizaje profundo o análisis de datos, una gran cantidad de trabajo en la ciencia de datos es sólo la limpieza de los datos, la preparación de los datos, y la exploración para asegurarse de que está bien para usar.

De nuevo, debido a la importancia de la manipulación de datos, NumPy es muy importante para la ciencia de datos en Python.

Numpy es un conjunto de herramientas para trabajar con datos numéricos

Sin embargo, específicamente, NumPy proporciona un conjunto de herramientas para trabajar con datos numéricos.

Python tiene otros kits de herramientas para trabajar con datos no numéricos y datos de tipo mixto (como el módulo Pandas). Pero si tienes cualquier tipo de datos numéricos que necesitas limpiar, modificar, remodelar o analizar, NumPy es probablemente el kit de herramientas que necesitas.

Aunque las funciones de NumPy pueden operar en una variedad de estructuras de datos, están construidas para operar en una estructura llamada array de NumPy. Los arrays NumPy no son más que un tipo especial de objeto de Python que contiene datos numéricos. Hay una variedad de maneras de crear arrays numpy, incluyendo la función np.array, la función np.ones, la función np.zeros y la función np.arange, junto con muchas otras funciones cubiertas en tutoriales anteriores aquí en Sharp Sight.

Importantemente, las matrices de NumPy están optimizadas para los cálculos numéricos. Así que hay un conjunto de herramientas en NumPy para realizar cálculos numéricos en matrices NumPy, como el cálculo de la media de una matriz NumPy, el cálculo de la mediana de una matriz NumPy, y así sucesivamente.

Esencialmente, NumPy le da un conjunto de herramientas para la creación de matrices de datos numéricos, y la realización de cálculos en los datos numéricos.

Uno de los cálculos que puede realizar es el cálculo del valor máximo de una matriz NumPy. Ahí es donde entra la función np.max.

NumPy max calcula el valor máximo de una matriz NumPy

La función numpy.max() calcula el valor máximo de los valores numéricos contenidos en una matriz NumPy. También puede calcular el valor máximo de las filas, columnas u otros ejes. Hablaremos de ello en la sección de ejemplos.

Sintácticamente, a menudo verás la función NumPy max en el código como np.max. Lo verás escrito así cuando el programador haya importado el módulo NumPy con el alias np.

Además, sólo para aclarar, debes saber que la función np.max es lo mismo que la función NumPy amax, AKA np.amax. Esencialmente np.max es un alias de np.amax. Aparte del nombre, son lo mismo.

Un ejemplo de alto nivel de cómo funciona np.max

Más adelante en este tutorial, te mostraré ejemplos concretos de cómo usar la función np.max, pero aquí mismo quiero darte una idea aproximada de lo que hace.

Por ejemplo, supón que tienes un array NumPy de 1 dimensión con cinco valores:

Podemos usar la función NumPy max para calcular el valor máximo:

Aunque este ejemplo muestra cómo la función np.max() opera en un array NumPy de 1 dimensión, opera de forma similar en arrays de 2 dimensiones y en arrays multidimensionales. De nuevo, te mostraré ejemplos completos de estos en la sección de ejemplos de este tutorial.

Pero antes de ver los ejemplos de código, echemos un vistazo rápido a la sintaxis y los parámetros de np.max.

La sintaxis de numpy max

La sintaxis de la función np.max es bastante sencilla, aunque algunos de los parámetros de la función pueden ser un poco confusos.

Aquí hablaremos de la estructura sintáctica de la función, y también explicaré los parámetros importantes.

Una nota rápida

Una nota rápida antes de empezar a revisar la sintaxis.

Sintácticamente, el nombre propio de la función es numpy.max().

Dicho esto, a menudo verás la función en el código como np.max().

¿Por qué?

Comúnmente, al comienzo de un programa que utiliza el módulo NumPy, los programadores importarán la función NumPy como np. Usted verá literalmente una línea de código en el programa que dice import numpy as np. Efectivamente, esto importa el módulo NumPy con el alias np. Esto permite al programador referirse a NumPy como np en el código, lo que les permite referirse a la función numpy.max como np.max.

Habiendo dicho esto, vamos a echar un vistazo más de cerca a la sintaxis.

Una explicación de la sintaxis

A un alto nivel, la sintaxis de np.max es bastante sencilla.

Está el nombre de la función – np.max() – y dentro de la función, hay varios parámetros que nos permiten controlar el comportamiento exacto de la función.

Veamos más de cerca los parámetros de np.max, porque los parámetros son los que realmente dan un control de grano fino de la función.

Los parámetros de np.max

La función numpy.max tiene cuatro parámetros principales:

• a
• axis
• out
• keepdims

Hablemos de cada uno de estos parámetros individualmente.

a (obligatorio)

El parámetro a permite especificar los datos sobre los que operará la función np.max. Esencialmente, especifica el array de entrada a la función.

En muchos casos, este array de entrada será un array propio de NumPy. Dicho esto, numpy.max (y la mayoría de las otras funciones de NumPy) operará sobre cualquier «secuencia tipo array» de datos. Eso significa que el argumento del parámetro a puede ser una lista de Python, una tupla de Python, o una de varias otras secuencias de Python.

Tenga en cuenta que usted necesita proporcionar algo a este argumento. Es necesario.

eje (opcional)

El parámetro axisle permite especificar el eje sobre el que calculará los valores máximos.

Dicho de forma más sencilla, el parámetro eje le permite calcular los máximos de fila y los máximos de columna.

Explicaré cómo hacerlo con más detalle en la sección de ejemplos más adelante, pero permíteme explicar rápidamente cómo funciona el parámetro axis.

Un rápido repaso a los ejes de los arrays

A un alto nivel, necesitas entender que los arrays de NumPy tienen ejes.

Los ejes son como direcciones a lo largo del array de NumPy. En un array de 2 dimensiones, el eje 0 es el eje que apunta hacia abajo de las filas y el eje 1 es el eje que apunta horizontalmente a través de las columnas.

El parámetro del array especifica el eje para calcular los máximos

Entonces, ¿cómo se relaciona esto con el parámetro axis?

Cuando usamos el parámetro axis en la función numpy.max, estamos especificando el eje a lo largo del cual encontrar los máximos.

Esto nos permite efectivamente calcular los máximos de columna y los máximos de fila.

Déjame mostrarte lo que quiero decir.

Recuerda que el eje 0 es el eje que apunta hacia abajo, hacia las filas.

Cuando usamos el código np.max(axis = 0) en un array, estamos diciendo efectivamente a NumPy que calcule los valores máximos en esa dirección… la dirección del eje 0.

Efectivamente, cuando ponemos axis = 0, estamos especificando que queremos calcular los máximos de la columna.

De forma similar, recuerda que en un array de 2 dimensiones, el eje 1 apunta horizontalmente. Por lo tanto, cuando usamos NumPy max con axis = 1, le estamos diciendo a NumPy que calcule los máximos horizontalmente, en la dirección del eje 1.

Esto calcula efectivamente los máximos de las filas.

Mostraré ejemplos concretos de código de cómo hacer esto, más adelante en la sección de ejemplos.

Tenga en cuenta que el parámetro eje es opcional. Si no se especifica un eje, NumPy max encontrará el valor máximo en todo el array de NumPy.

out (opcional)

El parámetro out permite especificar un array de salida especial donde almacenar la salida de np.max.

No es habitual utilizar este parámetro (sobre todo si eres principiante) por lo que no vamos a hablar de ello en el tutorial.

outEs un parámetro opcional.

mantenerdimensiones (opcional)

El parámetro keepdims es un poco confuso, por lo que se necesitará un poco de esfuerzo para entenderlo.

En definitiva, el parámetro keepdims mantiene las dimensiones de la salida igual que las dimensiones de la entrada.

Para entender por qué esto puede ser necesario, echemos un vistazo a cómo funciona típicamente la función numpy.max.

Cuando se utiliza np.max en un array típico de NumPy, la función reduce el número de dimensiones. Resume los datos.

Por ejemplo, digamos que tienes un array NumPy de 1 dimensión. Usted utiliza NumPy max en la matriz.

Cuando se utiliza np.max en una matriz de 1-d, la salida será un solo número. Un valor escalar … no un array de 1-d.

Esencialmente, las funciones como NumPy max (así como numpy.median, numpy.mean, etc) resumen los datos, y al resumir los datos, estas funciones producen salidas que tienen un número reducido de dimensiones.

Sin embargo, a veces se quiere que la salida tenga el mismo número de dimensiones. Hay ocasiones en las que si la entrada es una matriz 1-d, quiere que la salida sea una matriz 1-d (incluso si la matriz de salida tiene un solo valor en ella).

Puede hacer esto el parámetro keepdims.

Por defecto, keepdims se establece en False. Por lo tanto, por defecto (como se ha comentado anteriormente), las dimensiones de la salida no serán las mismas que las de la entrada. Por defecto, las dimensiones de la salida serán menores (porque np.max resume los datos).

Pero si se establece keepdims = True, la salida tendrá las mismas dimensiones que la entrada.

Esto es un poco abstracto sin un ejemplo concreto, así que te mostraré un ejemplo de este comportamiento más adelante en la sección de ejemplos.

Y en realidad, ahora que hemos revisado los parámetros, este es un buen punto para empezar a ver los ejemplos de NumPy max.

Ejemplos: cómo usar la función numpy max

En esta sección, voy a mostrarte ejemplos concretos de cómo usar la función NumPy max.

Te mostraré varias variaciones de cómo encontrar el valor máximo de un array. Te mostraré cómo encontrar el valor máximo de un array 1-d, cómo encontrar el valor máximo de un array 2-d, y cómo trabajar con varios de los parámetros importantes de numpy.max.

Ejecuta este código primero

Antes de empezar, hay algunas cosas preliminares que debes hacer para configurarte correctamente.

En primer lugar, necesitas tener NumPy instalado correctamente en tu ordenador.

Importar numpy

En segundo lugar, necesitas tener NumPy importado en tu entorno de trabajo.

Puedes importar NumPy con el siguiente código:

import numpy as np

Nota que hemos importado NumPy como np. Eso significa que nos referiremos a NumPy en nuestro código con el alias np.

Ok, ahora que esto ha terminado, veamos algunos ejemplos.

Calcular el máximo de un array unidimensional

Empezaremos de forma sencilla.

Aquí, vamos a calcular el valor máximo de un array de 1d NumPy.

Para ello, primero crearemos un array de 1 dimensión que contenga algunos enteros al azar. Para crear este array, utilizaremos la función numpy.random.randint(). Ten en cuenta que necesitas usar la función np.random.seed() para que tu matriz de NumPy contenga los mismos enteros que los de este ejemplo.

np.random.seed(22)np_array_1d = np.random.randint(size = 5, low = 0, high = 99)

Esta sintaxis creará una matriz de 1 dimensión llamada np_array_1d.

Podemos imprimir np_array_1d utilizando la función print().

print(np_array_1d)

Y aquí está la salida:

Visualmente, podemos identificar el valor máximo, que es 84.

Pero vamos a hacer eso con un poco de código.

Aquí, vamos a calcular el valor máximo de nuestra matriz NumPy mediante el uso de la función np.max().

np.max(np_array_1d)

Que produce la siguiente salida:

84

Este es un ejemplo extremadamente simple, pero ilustra la técnica. Obviamente, cuando el array tiene sólo 5 elementos, puedes inspeccionar visualmente el array y encontrar el valor máximo. Pero esta técnica funcionará si tienes un array con miles de valores (¡o más!).

Calcular el máximo de un array 2-d

A continuación, vamos a calcular el máximo de un array 2-d.

Para ello, obviamente necesitamos un array de 2 dimensiones con el que trabajar, así que primero crearemos un array de 2 dimensiones de NumPy.

Para crear nuestro array de 2 dimensiones, vamos a utilizar la función np.random.choice(). Esencialmente, esta función va a dibujar una muestra aleatoria de los enteros entre 0 y 8, sin reemplazo. Después de ejecutar np.random.choice(), vamos a utilizar el método reshape() para remodelar los enteros en una matriz bidimensional con 3 filas y 3 columnas.

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

Echemos un vistazo imprimiendo el array, np_array_2d.

print(np_array_2d)

 ]

Como puedes ver, se trata de un array bidimensional con 3 filas y 3 columnas. Contiene los enteros de 0 a 8, dispuestos aleatoriamente en el array.

Ahora, calculemos el valor máximo del array:

np.max(np_array_2d)

Lo que produce la siguiente salida:

8

De nuevo, este es un ejemplo muy simple, pero puedes usar esto con un array 2D mucho más grande y funcionará de la misma manera. Una vez que aprendas a usar esta técnica, ¡inténtalo con matrices más grandes!

A continuación, vamos a hacer algo más complicado.

… en los siguientes ejemplos, calcularemos los máximos de las columnas y los máximos de las filas.

Calcular el valor máximo de las columnas de un array 2-d

En primer lugar: calcularemos los valores máximos de las columnas de un array.

Para ello, necesitamos utilizar el parámetro axis. Específicamente, necesitamos establecer axis = 0 dentro de la función numpy.max.

Repasemos rápidamente por qué.

El parámetro axis especifica qué eje quieres resumir

Recuerda que los arrays de NumPy tienen ejes, y que los ejes son como direcciones a lo largo del array. En un array de 2 dimensiones, el eje 0 es el que apunta hacia abajo, y el eje 1 es el que apunta horizontalmente.

Podemos utilizar estos ejes para definir la dirección a lo largo de la cual utilizar np.max.

Así que digamos que queremos calcular los valores máximos de las columnas. Esto equivale a calcular las medias hacia abajo.

Esencialmente, para calcular los máximos de las columnas, tenemos que calcular los máximos en la dirección del eje-0.

Calcular el máximo con el eje = 0

Déjame mostrarte cómo.

Aquí, vamos a volver a crear nuestra matriz NumPy 2-d. Este es el mismo que el array NumPy 2-d que creamos en un ejemplo anterior, así que si ya ejecutaste ese código, no necesitas ejecutarlo de nuevo.

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

Y podemos imprimirlo:

print(np_array_2d)

 ]

Una vez más, este es un array 2-d con 3 filas y 3 columnas. Contiene los enteros de 0 a 8, dispuestos aleatoriamente en el array.

Ahora, calculemos los máximos de las columnas usando numpy.max con axis = 0.

# CALCULATE COLUMN MAXIMAnp.max(np_array_2d, axis = 0)

Lo que produce el siguiente array de salida:

array()

Evaluemos lo que pasó aquí.

Al establecer axis = 0, especificamos que queremos que la función NumPy max calcule los valores máximos hacia abajo a lo largo del eje 0.

Es bastante sencillo siempre que entiendas los ejes de NumPy y cómo funcionan en las funciones de NumPy.

Calcular los máximos de fila con eje = 1

De forma similar, podemos calcular los máximos de fila poniendo el parámetro axis en axis = 1.

Aquí está el código para crear el conjunto de datos 2-d de nuevo:

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

print(np_array_2d)

 ]

Y ahora vamos a calcular los máximos de fila:

np.max(np_array_2d, axis = 1)

Con la siguiente salida:

array()

Esto debería tener sentido si ya has leído y entendido los ejemplos anteriores.

Cuando ponemos axis = 1, le estamos diciendo a numpy.max que calcule los valores máximos en la dirección del eje 1. Como el eje 1 es el eje que corre horizontalmente a lo largo del arreglo, esto calcula efectivamente los valores máximos a lo largo de las filas de un arreglo 2-d:

De nuevo, esto es bastante sencillo, siempre y cuando entiendas realmente los ejes de los arreglos de NumPy. Si todavía tienes problemas para entender los ejes, te recomiendo que revises nuestro tutorial sobre los ejes de los arrays de NumPy.

Cómo usar el parámetro keepdims con np.max

Por último, vamos a echar un vistazo al parámetro keepdims.

Antes de hacerlo, déjame explicarte por qué lo necesitamos.

Como he señalado anteriormente, la función NumPy max resume los datos cuando se utiliza. De hecho, muchas de las funciones de NumPy que calculan estadísticas de resumen (como np.mean, np.median, np.min, etc) resumen los datos por su propia naturaleza. Cuando calculas un estadístico de resumen, por definición estás resumiendo los datos.

Esto tiene importantes consecuencias relacionadas con las dimensiones de los datos.

Cuando resumes tus datos con una función como numpy.max, la salida de la función tendrá un número reducido de dimensiones.

Por ejemplo, digamos que estás calculando el valor máximo de un arreglo de 2 dimensiones. Si usas numpy.max en este arreglo de 2 dimensiones (sin el parámetro axis), entonces la salida será un solo número, un escalar. Los escalares tienen cero dimensiones. Dos dimensiones de entrada, cero dimensión de salida.

La función NumPy max reduce efectivamente las dimensiones entre la entrada y la salida.

A veces, sin embargo, no quieres un número reducido de dimensiones. Puede haber situaciones en las que necesitas que la salida tenga técnicamente las mismas dimensiones que la entrada (incluso si la salida es un solo número).

Puedes forzar ese comportamiento utilizando el parámetro keepdims.

Configurar keepdims igual a true (y mantener las mismas dimensiones)

Por defecto, el parámetro keepdims se establece en False. Como acabo de explicar, esto significa que la salida no necesita tener las mismas dimensiones que la entrada, por defecto.

Pero si estableces keepdims = True, esto obligará a que la salida tenga el mismo número de dimensiones que la entrada.

Esto puede confundirte, así que vamos a ver un ejemplo sólido.

Primero, vamos a crear un array de 2 dimensiones.

Este es el mismo array que creamos antes, así que si ya ejecutaste este código, no necesitas volver a ejecutarlo. Esencialmente, este código crea un array 2-d con los números del 0 al 8, dispuestos aleatoriamente en un array de 3 por 3.

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

Sólo para que quede claro, echemos un vistazo imprimiéndolo:

print(np_array_2d)

Y aquí está el array:

 ]

De nuevo, este array sólo contiene los enteros del 0 al 8, dispuestos aleatoriamente en un array NumPy de 3 por 3.

¿Y cuántas dimensiones tiene?

Probablemente sea obvio para ti, pero podemos recuperar directamente el número de dimensiones extrayendo el atributo ndim del array.

np_array_2d.ndim

Y esto nos dice el número de dimensiones:

2

Así, np_array_2d es un array de 2 dimensiones.

Ahora, usemos np.max para calcular el valor máximo del array.

np.max(np_array_2d)

El valor máximo es 8.

¿Y cuántas dimensiones tiene la salida? Podemos comprobarlo consultando el atributo ndim al final de la función np.max():

np.max(np_array_2d).ndim

¿Cuántas dimensiones tiene la salida?

0.

La salida de np.max es el valor máximo (8), que es un escalar. Este escalar tiene dimensiones cero.

Rejecutar np.max con keepdims = True

Ahora, volvamos a ejecutar el código con keepdims = True.

np.max(np_array_2d, keepdims = True)

Que produce la siguiente salida:

array(])

Y comprobemos las dimensiones:

np.max(np_array_2d, keepdims = True).ndim

2

Aquí, cuando ejecutamos np.max sobre np_array_2d con keepdims = True, la salida tiene 2 dimensiones.

Tenga en cuenta que el valor máximo es el mismo: 8. Sólo que las dimensiones de la salida son diferentes. Al poner keepdims = True, cambiamos la estructura de la salida… en lugar de ser un escalar, la salida es en realidad un array NumPy de 2 dimensiones con un único valor (8).

Si quieres aprender ciencia de datos en Python, aprende NumPy

Si has leído otros tutoriales aquí en el blog de ciencia de datos de Sharp Sight, sabes lo importante que es la manipulación de datos.

Si te tomas en serio el aprendizaje de la ciencia de datos, realmente necesitas dominar los fundamentos de la manipulación de datos. Una gran parte del flujo de trabajo de la ciencia de datos es simplemente la limpieza y la manipulación de los datos de entrada.

Si usted está trabajando en Python, una de las habilidades esenciales que necesita saber entonces es NumPy. Numpy es fundamental para limpiar, manipular y explorar tus datos.

Si quieres aprender ciencia de datos en Python, aprende NumPy y apréndelo bien.

Para más tutoriales de ciencia de datos en Python, apúntate a nuestra lista de correo electrónico

Dicho esto, si quieres aprender NumPy y ciencia de datos en Python, apúntate a nuestra lista de correo electrónico.

Aquí, en el blog de Sharp Sight, publicamos regularmente tutoriales de ciencia de datos.

Cuando te registres, obtendrás tutoriales gratuitos sobre:

• NumPy
• Pandas
• Base Python
• Scikit learn
• Aprendizaje automático
• Aprendizaje profundo
• … y más.

Cuando publiquemos tutoriales, te los enviaremos directamente a tu bandeja de entrada.

¿Quieres aprender ciencia de datos en Python? Apúntate ahora.