Tutorial de NumPy: Análisis de datos con Python

No te pierdas nuestra hoja de trucos de NumPy GRATIS al final de este post

NumPy es un paquete de análisis de datos de Python muy utilizado. Mediante el uso de NumPy, puede acelerar su flujo de trabajo, y la interfaz con otros paquetes en el ecosistema de Python, como scikit-learn, que utilizan NumPy bajo el capó. NumPy se desarrolló originalmente a mediados de la década de 2000, y surgió de un paquete aún más antiguo llamado Numeric. Esta longevidad significa que casi todos los paquetes de análisis de datos o de aprendizaje automático para Python aprovechan NumPy de alguna manera.

En este tutorial, recorreremos el uso de NumPy para analizar datos sobre la calidad del vino. Los datos contienen información sobre varios atributos de los vinos, como pH y fixed acidity, junto con una puntuación de calidad entre 0 y 10 para cada vino. La puntuación de calidad es la media de al menos 3 catadores humanos. A medida que aprendamos a trabajar con NumPy, intentaremos averiguar más sobre la calidad percibida del vino.

Los vinos que analizaremos son de la región de Minho en Portugal.

Los datos fueron descargados del Repositorio de Aprendizaje Automático de la UCI, y están disponibles aquí. Aquí están las primeras filas del archivo winequality-red.csv, que utilizaremos a lo largo de este tutorial:

"fixed acidity";"volatile acidity";"citric acid";"residual sugar";"chlorides";"free sulfur dioxide";"total sulfur dioxide";"density";"pH";"sulphates";"alcohol";"quality"7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4;57.8;0.88;0;2.6;0.098;25;67;0.9968;3.2;0.68;9.8;5

Los datos están en lo que voy a llamar formato ssv (valores separados por punto y coma) – cada registro está separado por un punto y coma (;), y las filas están separadas por una nueva línea. Hay 1600 filas en el archivo, incluyendo una fila de cabecera, y 12 columnas.

Antes de empezar, una nota rápida de la versión – vamos a utilizar Python 3.5. Nuestros ejemplos de código se harán usando Jupyter notebook.

Listas de listas para datos CSV

Antes de usar NumPy, primero intentaremos trabajar con los datos usando Python y el paquete csv. Podemos leer el archivo usando el objeto csv.reader, que nos permitirá leer y dividir todo el contenido del archivo ssv.

En el siguiente código, nosotros:

• Importamos la librería csv.
• Abrimos el archivo winequality-red.csv.
  • Con el archivo abierto, creamos un nuevo objeto csv.reader.
    • Introduzca el argumento de la palabra clave delimiter=";" para asegurarse de que los registros se dividen en el carácter de punto y coma en lugar del carácter de coma por defecto.
  • Llame al tipo de lista para obtener todas las filas del archivo.
  • Asigna el resultado a wines.

import csvwith open('winequality-red.csv', 'r') as f: wines = list(csv.reader(f, delimiter=';'))

Una vez que hemos leído los datos, podemos imprimir las primeras 3 filas:

print(wines)

, , ]

Los datos se han leído en una lista de listas. Cada lista interior es una fila del archivo ssv. Como habrás notado, cada elemento de toda la lista de listas se representa como una cadena, lo que dificultará los cálculos.

Vamos a formatear los datos en una tabla para facilitar su visualización:

Como puede ver en la tabla anterior, hemos leído en tres filas, la primera de las cuales contiene encabezados de columna. Cada fila después de la fila de cabecera representa un vino. El primer elemento de cada fila es el fixed acidity, el segundo es el volatile acidity, y así sucesivamente. Podemos encontrar la media quality de los vinos. El siguiente código hará:

• Extraer el último elemento de cada fila después de la fila de cabecera.
• Convertir cada elemento extraído en un float.
• Asignar todos los elementos extraídos a la lista qualities.
• Dividir la suma de todos los elementos de qualities entre el número total de elementos de qualities para obtener la media.

qualities =) for item in wines]sum(qualities) / len(qualities)

5.6360225140712945

Aunque hemos podido hacer el cálculo que queríamos, el código es bastante complejo, y no será divertido tener que hacer algo similar cada vez que queramos calcular una cantidad. Por suerte, podemos utilizar NumPy para facilitar el trabajo con nuestros datos.

Numpy 2-Dimensional Arrays

Con NumPy, trabajamos con arrays multidimensionales. Nos sumergiremos en todos los tipos posibles de arrays multidimensionales más adelante, pero por ahora, nos centraremos en los arrays bidimensionales. Una matriz bidimensional también se conoce como matriz, y es algo con lo que deberías estar familiarizado. De hecho, es sólo una forma diferente de pensar en una lista de listas. Una matriz tiene filas y columnas. Especificando un número de fila y un número de columna, podemos extraer un elemento de una matriz.

En la siguiente matriz, la primera fila es la fila de la cabecera, y la primera columna es la columna fixed acidity:

Si escogiéramos el elemento en la primera fila y la segunda columna, obtendríamos volatile acidity. Si elegimos el elemento en la tercera fila y la segunda columna, obtendríamos 0.88.

En un array de NumPy, el número de dimensiones se llama rango, y cada dimensión se llama eje. Así que las filas son el primer eje, y las columnas son el segundo eje.

Ahora que entiendes los fundamentos de las matrices, vamos a ver cómo podemos pasar de nuestra lista de listas a un array de NumPy.

Crear un array de NumPy

Podemos crear un array de NumPy utilizando la función numpy.array. Si pasamos una lista de listas, creará automáticamente un array NumPy con el mismo número de filas y columnas. Como queremos que todos los elementos del array sean elementos flotantes para facilitar el cálculo, dejaremos fuera la fila de cabecera, que contiene cadenas. Una de las limitaciones de NumPy es que todos los elementos de un array tienen que ser del mismo tipo, así que si incluimos la fila de cabecera, todos los elementos del array se leerán como cadenas. Como queremos poder hacer cálculos como encontrar la media quality de los vinos, necesitamos que los elementos sean todos flotantes.

En el siguiente código, nosotros:

• Importamos el paquete numpy.
• Pasamos la lista de listas wines a la función array, que la convierte en un array de NumPy.
  • Excluimos la fila de la cabecera con el corte de la lista.
  • Especificamos el argumento de la palabra clave dtype para asegurarnos de que cada elemento se convierte en un float. Nos adentraremos más en lo que es el dtype más adelante.

import csvwith open("winequality-red.csv", 'r') as f: wines = list(csv.reader(f, delimiter=";"))import numpy as npwines = np.array(wines, dtype=np.float)

¡Prueba a ejecutar el código anterior y ver qué pasa!

Si desplegamos wines, ahora obtendremos un array NumPy:

wines

array(,,,...,,,])

Podemos comprobar el número de filas y columnas de nuestros datos utilizando la propiedad shape de los arrays NumPy:

wines.shape

(1599, 12)

Métodos alternativos de creación de arrays NumPy

Hay una variedad de métodos que puedes utilizar para crear arrays NumPy. Para empezar, puedes crear un array donde cada elemento es cero. El siguiente código creará un arreglo con 3 filas y 4 columnas, donde cada elemento es 0, usando numpy.zeros:

import numpy as np

empty_array = np.zeros((3,4)) empty_array

Es útil crear un arreglo con todos los elementos cero en los casos en que necesitas un arreglo de tamaño fijo, pero no tienes ningún valor para él todavía.

También puedes crear un arreglo donde cada elemento es un número aleatorio usando numpy.random.rand. Aquí tienes un ejemplo:

np.random.rand(3,4)

array(,,])

Crear arrays llenos de números aleatorios puede ser útil cuando quieres probar rápidamente tu código con arrays de ejemplo.

Usando NumPy para leer en archivos

Es posible usar NumPy para leer directamente csv u otros archivos en arrays. Podemos hacerlo utilizando la función numpy.genfromtxt. Podemos utilizarla para leer nuestros datos iniciales sobre los vinos tintos.

En el siguiente código:

• Utiliza la función genfromtxt para leer el archivo winequality-red.csv.
• Especifica el argumento de la palabra clave delimiter=";" para que los campos se analicen correctamente.
• Especifica el argumento de la palabra clave skip_header=1 para que se salte la fila de la cabecera.

wines = np.genfromtxt("winequality-red.csv", delimiter=";", skip_header=1)

winesTerminará teniendo el mismo aspecto que si lo leyéramos en una lista y luego lo convirtiéramos en un array de flotantes. NumPy escogerá automáticamente un tipo de datos para los elementos de un array basándose en su formato.

Indexación de Arrays NumPy

Ahora sabemos cómo crear arrays, pero a menos que podamos recuperar resultados de ellos, no hay mucho que podamos hacer con NumPy. Podemos utilizar la indexación de arrays para seleccionar elementos individuales, grupos de elementos o filas y columnas enteras. Una cosa importante a tener en cuenta es que al igual que las listas de Python, NumPy está indexado a cero, lo que significa que el índice de la primera fila es 0, y el índice de la primera columna es 0. Si queremos trabajar con la cuarta fila, usaríamos el índice 3, si queremos trabajar con la segunda fila, usaríamos el índice 1, y así sucesivamente. Volveremos a trabajar con la matriz wines:

Seleccionemos el elemento de la fila 3 y la columna 4. En el código siguiente, pasamos el índice 2 como índice de la fila, y el índice 3 como índice de la columna. Esto recupera el valor de la cuarta columna de la tercera fila:

wines

2.2999999999999998

Como estamos trabajando con un array bidimensional en NumPy, especificamos 2 índices para recuperar un elemento. El primer índice es el de la fila, o eje 1, y el segundo índice es el de la columna, o eje 2. Cualquier elemento en wines puede ser recuperado usando los índices 2.

Cortar Arrays NumPy

Si en cambio queremos seleccionar los tres primeros elementos de la cuarta columna, podemos hacerlo usando dos puntos (:). Los dos puntos indican que queremos seleccionar todos los elementos desde el índice inicial hasta el índice final, pero sin incluirlo. Esto también se conoce como un corte:

wines

array()

Al igual que con el corte de la lista, es posible omitir el 0 para recuperar sólo todos los elementos desde el principio hasta el elemento 3:

wines

array()

Podemos seleccionar una columna entera especificando que queremos todos los elementos, desde el primero hasta el último. Para ello, basta con utilizar los dos puntos (:), sin índices iniciales ni finales. El siguiente código seleccionará toda la cuarta columna:

wines

array()

Seleccionamos una columna entera arriba, pero también podemos extraer una fila entera:

wines

array()

Si llevamos nuestra indexación al extremo, podemos seleccionar toda la matriz usando dos dos puntos para seleccionar todas las filas y columnas en wines. Este es un gran truco de fiesta, pero no tiene muchas buenas aplicaciones:

wines

array(,,<br />,<br />...,,,<br />])

Asignación de valores a arrays de NumPy

También podemos utilizar la indexación para asignar valores a ciertos elementos de los arrays. Podemos hacer esto asignando directamente al valor indexado:

wines = 10

Podemos hacer lo mismo para las rebanadas. Para sobrescribir una columna entera, podemos hacer esto:

wines = 50

El código anterior sobrescribe todos los valores de la undécima columna con 50.

Arrays NumPy de 1 dimensión

Hasta ahora, hemos trabajado con arrays de 2 dimensiones, como wines. Sin embargo, NumPy es un paquete para trabajar con arrays multidimensionales. Uno de los tipos más comunes de arrays multidimensionales es el array unidimensional, o vector. Como habrás notado arriba, cuando cortamos wines, recuperamos un array unidimensional. Una matriz unidimensional sólo necesita un índice para recuperar un elemento. Cada fila y columna de un array bidimensional es un array unidimensional. Al igual que una lista de listas es análoga a una matriz bidimensional, una sola lista es análoga a una matriz unidimensional. Si cortamos los vinos y sólo recuperamos la tercera fila, obtenemos una matriz unidimensional:

third_wine = wines

Así es como se ve third_wine:

11.2000.2800.5601.9000.07517.00060.0000.9983.1600.5809.8006.000

Podemos recuperar elementos individuales de third_wine usando un solo índice. El siguiente código mostrará el segundo elemento de third_wine:

third_wine

0.28000000000000003

La mayoría de las funciones de NumPy con las que hemos trabajado, como numpy.random.rand, se pueden utilizar con arrays multidimensionales. Así es como usaríamos numpy.random.rand para generar un vector aleatorio:

np.random.rand(3)

array()

Antes, cuando llamábamos a np.random.rand, pasábamos una forma para un array bidimensional, por lo que el resultado era un array bidimensional. Esta vez, pasamos una forma para una matriz unidimensional. La forma especifica el número de dimensiones y el tamaño de la matriz en cada dimensión. Una forma de (10,10) será una matriz bidimensional con 10 filas y 10 columnas. Una forma de (10,) será un array de 1 dimensión con 10 elementos.

Donde NumPy se vuelve más complejo es cuando empezamos a tratar con arrays que tienen más de 2 dimensiones.

Arrays NumPy de N dimensiones

Esto no ocurre muy a menudo, pero hay casos en los que querrás tratar con arrays que tienen más de 3 dimensiones. Una forma de pensar en esto es como una lista de listas de listas. Digamos que queremos almacenar las ganancias mensuales de una tienda, pero queremos ser capaces de buscar rápidamente los resultados para un trimestre, y para un año. Las ganancias de un año podrían ser las siguientes:

La tienda ganó 0 en enero, 5 en febrero, y así sucesivamente. Podemos dividir estas ganancias por trimestre en una lista de listas:

year_one = , , , ]

Podemos recuperar las ganancias de enero llamando a year_one. Si queremos los resultados de todo un trimestre, podemos llamar a year_one o a year_one. Ahora tenemos un array, o matriz, de 2 dimensiones. ¿Pero qué pasa si ahora queremos añadir los resultados de otro año? Tenemos que añadir una tercera dimensión:

earnings = , , , ], , , , ]]

Podemos recuperar los resultados de enero del primer año llamando a earnings. Ahora necesitamos tres índices para recuperar un solo elemento. Una matriz tridimensional en NumPy es muy parecida. De hecho, podemos convertir earnings en una matriz y luego obtener las ganancias de enero del primer año:

earnings = np.array(earnings)earnings

500

También podemos encontrar la forma de la matriz:

earnings.shape

(2, 4, 3)

La indexación y el corte funcionan exactamente igual con una matriz tridimensional, pero ahora tenemos un eje extra que pasar. Si quisiéramos obtener las ganancias de enero de todos los años, podríamos hacer lo siguiente:

earnings

array()

Si quisiéramos obtener las ganancias del primer trimestre de ambos años, podríamos hacer lo siguiente:

earnings

array(,])

Añadir más dimensiones puede facilitar mucho la consulta de tus datos si están organizados de una determinada manera. A medida que pasamos de arrays tridimensionales a arrays cuatridimensionales y más grandes, se aplican las mismas propiedades, y se pueden indexar y rebanar de las mismas maneras.

Tipos de datos de NumPy

Como mencionamos anteriormente, cada array de NumPy puede almacenar elementos de un solo tipo de datos. Por ejemplo, wines contiene sólo valores float. NumPy almacena valores utilizando sus propios tipos de datos, que son distintos de los tipos de Python como float y str. Esto se debe a que el núcleo de NumPy está escrito en un lenguaje de programación llamado C, que almacena los datos de forma diferente a los tipos de datos de Python. Los tipos de datos de NumPy se mapean entre Python y C, lo que nos permite utilizar los arrays de NumPy sin ningún problema de conversión.

Puedes encontrar el tipo de datos de un array de NumPy accediendo a la propiedad dtype:

wines.dtype

dtype('float64')

NumPy tiene varios tipos de datos diferentes, que en su mayoría se mapean con los tipos de datos de Python, como float, y str. Puedes encontrar una lista completa de los tipos de datos de NumPy aquí, pero aquí hay algunos importantes:

• float – datos numéricos de punto flotante.
• int – datos enteros.
• string – datos de caracteres.
• object – objetos de Python.

Los tipos de datos terminan además con un sufijo que indica cuántos bits de memoria ocupan. Así, int32 es un tipo de datos entero de 32 bits, y float64 es un tipo de datos flotante de 64 bits.

Conversión de tipos de datos

Puedes utilizar el método numpy.ndarray.astype para convertir un array a un tipo diferente. El método realmente copiará el array, y devolverá un nuevo array con el tipo de datos especificado. Por ejemplo, podemos convertir wines al tipo de datos int:

wines.astype(int)

array(,,,...,,,])

Como puedes ver arriba, todos los elementos del array resultante son enteros. Observe que hemos utilizado el tipo de datos de Python int en lugar de un tipo de datos de NumPy al convertir wines. Esto se debe a que varios tipos de datos de Python, incluyendo float, int y string, se pueden utilizar con NumPy, y se convierten automáticamente a los tipos de datos de NumPy.

Podemos comprobar la propiedad name del dtype del array resultante para ver a qué tipo de datos ha mapeado NumPy el array resultante:

int_wines = wines.astype(int)int_wines.dtype.name

'int64'

El array se ha convertido a un tipo de datos entero de 64 bits. Esto permite valores enteros muy largos, pero ocupa más espacio en la memoria que almacenar los valores como enteros de 32 bits.

Si quieres más control sobre cómo se almacena el array en la memoria, puedes crear directamente objetos de tipo NumPy como numpyint32:

np.int32

numpy.int32

Puedes utilizarlos directamente para convertir entre tipos:

wines.astype(np.int32)

array(,,,...,,,], dtype=int32)

Operaciones con arrays de NumPy

NumPy simplifica la realización de operaciones matemáticas con arrays. Esta es una de las principales ventajas de NumPy, y facilita bastante la realización de cálculos.

Matemáticas sobre arrays

Si se realiza alguna de las operaciones matemáticas básicas (/, *, -, +, ^) con un array y un valor, se aplicará la operación a cada uno de los elementos del array.

Digamos que queremos añadir 10 puntos a cada puntuación de calidad porque estamos borrachos y nos sentimos generosos. Así es como lo haríamos:

wines + 10

array()

Nótese que la operación anterior no cambiará la matriz wines – devolverá una nueva matriz unidimensional en la que se ha añadido 10 a cada elemento de la columna de calidad de los vinos.

Si en cambio hiciéramos +=, modificaríamos la matriz en su lugar:

wines += 10wines

array()

Todas las demás operaciones funcionan igual. Por ejemplo, si queremos multiplicar cada una de las puntuaciones de calidad por 2, podríamos hacerlo así:

wines * 2

array()

Multiple Array Math

También es posible hacer operaciones matemáticas entre arrays. Esto aplicará la operación a pares de elementos. Por ejemplo, si sumamos la columna quality a sí misma, esto es lo que obtenemos:

wines + wines

array()

Nota que esto es equivalente a wines * 2 – esto es porque NumPy suma cada par de elementos. El primer elemento del primer array se añade al primer elemento del segundo array, el segundo al segundo, y así sucesivamente.

También podemos usar esto para multiplicar arrays. Digamos que queremos elegir un vino que maximice el contenido de alcohol y la calidad (queremos emborracharnos, pero tenemos clase). Multiplicaríamos alcohol por quality, y seleccionaríamos el vino con la puntuación más alta:

wines * wines

array()

Todas las operaciones comunes (/, *, -, +, ^) funcionarán entre arrays.

Difusión

A menos que los arrays sobre los que operes tengan exactamente el mismo tamaño, no es posible hacer operaciones por elementos. En casos como este, NumPy realiza la difusión para tratar de emparejar los elementos. Esencialmente, la difusión implica unos cuantos pasos:

• Se compara la última dimensión de cada array.
  • Si las longitudes de las dimensiones son iguales, o una de las dimensiones tiene longitud 1, entonces seguimos adelante.
  • Si las longitudes de las dimensiones no son iguales, y ninguna de las dimensiones tiene longitud 1, entonces hay un error.
• Continúa comprobando las dimensiones hasta que el array más corto se quede sin dimensiones.

Por ejemplo, las dos formas siguientes son compatibles:

A: (50,3)B (3,)

Esto se debe a que la longitud de la dimensión final del array A es 3, y la longitud de la dimensión final del array B es 3. Son iguales, así que esa dimensión está bien. El array B se queda entonces sin elementos, así que estamos bien, y los arrays son compatibles para las operaciones matemáticas.

Las dos formas siguientes también son compatibles:

A: (1,2)B (50,2)

La última dimensión coincide, y A tiene una longitud 1 en la primera dimensión.

Estas dos matrices no son compatibles:

A: (50,50)B: (49,49)

Las longitudes de las dimensiones no son iguales, y ninguna de las dos matrices tiene una longitud de dimensión igual a 1.

Hay una explicación detallada de la emisión aquí, pero vamos a repasar algunos ejemplos para ilustrar el principio:

wines * np.array()

------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython -input-40-821086ccaf65> in <module>()----> 1 wines * np.array()ValueError: operands could not be broadcast together with shapes (1599,12) (2,)</module></ipython>

El ejemplo anterior no funcionó porque las dos matrices no tienen una dimensión final coincidente. He aquí un ejemplo en el que la última dimensión sí coincide:

array_one = np.array( , ])array_two = np.array()array_one + array_two

array(,])

Como puede ver, array_two se ha emitido en cada fila de array_one. Aquí hay un ejemplo con nuestros datos de wines:

rand_array = np.random.rand(12)wines + rand_array

array(,,,...,,,])

Los elementos de rand_array se difunden a través de cada fila de wines, por lo que la primera columna de wines tiene el primer valor en rand_array añadido a ella, y así sucesivamente.

Métodos de Array de NumPy

Además de las operaciones matemáticas comunes, NumPy también tiene varios métodos que se pueden utilizar para cálculos más complejos en arrays. Un ejemplo de esto es el método numpy.ndarray.sum. Esto encuentra la suma de todos los elementos de un array por defecto:

wines.sum()

9012.0

El total de todos nuestros índices de calidad es 154.1788. Podemos pasar el argumento de la palabra clave axis al método sum para encontrar sumas sobre un eje. Si llamamos a sum a través de la matriz wines, y pasamos axis=0, encontraremos las sumas sobre el primer eje de la matriz. Esto nos dará la suma de todos los valores de cada columna. Esto puede parecer al revés, que las sumas sobre el primer eje nos den la suma de cada columna, pero una forma de pensar en esto es que el eje especificado es el que «se va». Así que si especificamos axis=0, queremos que las filas se vayan, y queremos encontrar las sumas para cada uno de los ejes restantes a través de cada fila:

wines.sum(axis=0)

array()

Podemos verificar que hemos hecho la suma correctamente comprobando la forma. La forma debe ser 12, correspondiente al número de columnas:

wines.sum(axis=0).shape

(12,)

Si pasamos axis=1, encontraremos las sumas sobre el segundo eje del array. Esto nos dará la suma de cada fila:

wines.sum(axis=1)

array()

Hay varios otros métodos que se comportan como el método sum, incluyendo:

• numpy.ndarray.mean – encuentra la media de un array.
• numpy.ndarray.std – encuentra la desviación estándar de un array.
• numpy.ndarray.min – encuentra el valor mínimo de un array.
• numpy.ndarray.max – encuentra el valor máximo en una matriz.

Puedes encontrar una lista completa de métodos de matrices aquí.

NumPy Array Comparisons

NumPy hace posible comprobar si las filas coinciden con ciertos valores utilizando operaciones de comparación matemática como <, >, >=, <=, y ==. Por ejemplo, si queremos ver qué vinos tienen una calificación de calidad superior a 5, podemos hacer lo siguiente:

wines > 5

array(, dtype=bool)

Obtenemos una matriz booleana que nos dice cuáles de los vinos tienen una calificación de calidad superior a 5. Podemos hacer algo similar con los demás operadores. Por ejemplo, podemos ver si algún vino tiene una calificación de calidad igual a 10:

wines == 10

array(, dtype=bool)

Subsetting

Una de las cosas potentes que podemos hacer con una matriz booleana y una matriz NumPy es seleccionar sólo ciertas filas o columnas de la matriz NumPy. Por ejemplo, el siguiente código sólo seleccionará las filas de wines en las que la calidad sea superior a 7:

high_quality = wines > 7wines

array(,,])

Seleccionamos sólo las filas en las que high_quality contiene un valor True, y todas las columnas. Este subconjunto hace que sea sencillo filtrar matrices para determinados criterios. Por ejemplo, podemos buscar vinos con mucho alcohol y de alta calidad. Para especificar múltiples condiciones, tenemos que colocar cada condición entre paréntesis, y separar las condiciones con un ampersand (&):

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines

array(,,,,,,,,,,,,,,,])

Podemos combinar el subconjunto y la asignación para sobrescribir ciertos valores en una matriz:

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines = 20

Modificar matrices de NumPy

Podemos cambiar la forma de las matrices conservando todos sus elementos. Esto a menudo puede facilitar el acceso a los elementos del array. La remodelación más simple es voltear los ejes, por lo que las filas se convierten en columnas, y viceversa. Podemos lograr esto con la función numpy.transpose:

np.transpose(wines).shape

(12, 1599)

Podemos usar la función numpy.ravel para convertir un arreglo en una representación unidimensional. Esencialmente aplanará un array en una larga secuencia de valores:

wines.ravel()

array()

Aquí tenemos un ejemplo en el que podemos ver la ordenación de numpy.ravel:

array_one = np.array( , ])array_one.ravel()

array()

Por último, podemos utilizar la función numpy.reshape para remodelar un array con una forma determinada que especifiquemos. El siguiente código convertirá la segunda fila de wines en un array bidimensional con 2 filas y 6 columnas:

wines.reshape((2,6))

array(,])

Combinando arrays de NumPy

Con NumPy, es muy común combinar múltiples arrays en un único array unificado. Podemos utilizar numpy.vstack para apilar verticalmente múltiples arrays. Piensa que los elementos del segundo array se añaden como nuevas filas al primer array. Podemos leer el conjunto de datos winequality-white.csv que contiene información sobre la calidad de los vinos blancos, y luego combinarlo con nuestro conjunto de datos existente, wines, que contiene información sobre los vinos tintos.

En el siguiente código, nosotros:

• Leemos en winequality-white.csv.
• Muestra la forma de white_wines.

white_wines = np.genfromtxt("winequality-white.csv", delimiter=";", skip_header=1)white_wines.shape

(4898, 12)

Como puedes ver, tenemos atributos para 4898 vinos. Ahora que tenemos los datos de los vinos blancos, podemos combinar todos los datos de los vinos.

En el siguiente código, nosotros:

• Utilizamos la función vstack para combinar wines y white_wines.
• Muestra la forma del resultado.

all_wines = np.vstack((wines, white_wines))all_wines.shape

(6497, 12)

Como puedes ver, el resultado tiene 6497 filas, que es la suma del número de filas de wines y el número de filas de red_wines.

Si queremos combinar arrays horizontalmente, donde el número de filas permanece constante, pero las columnas se unen, entonces podemos usar la función numpy.hstack. Los arrays que combinamos deben tener el mismo número de filas para que esto funcione.

Por último, podemos usar numpy.concatenate como una versión de propósito general de hstack y vstack. Si queremos concatenar dos arrays, los pasamos a concatenate, y luego especificamos el argumento de la palabra clave axis que queremos concatenar a lo largo. La concatenación a lo largo del primer eje es similar a vstack, y la concatenación a lo largo del segundo eje es similar a hstack:

np.concatenate((wines, white_wines), axis=0)

array(,,,...,,,])

Hoja de trucos gratis de NumPy

Si estás interesado en aprender más sobre NumPy, echa un vistazo a nuestro curso interactivo sobre NumPy y Pandas. Puedes registrarte y hacer las primeras misiones de forma gratuita.

También puedes llevar tus conocimientos de NumPy al siguiente nivel con nuestra hoja de trucos de NumPy gratuita!

Lectura adicional

Ahora deberías tener un buen conocimiento de NumPy, y de cómo aplicarlo a un conjunto de datos.

Si quieres profundizar más, aquí hay algunos recursos que pueden ser útiles:

• NumPy Quickstart – tiene buenos ejemplos de código y cubre la mayoría de la funcionalidad básica de NumPy.
• Python NumPy Tutorial – un gran tutorial sobre NumPy y otras bibliotecas de Python.
• Visual NumPy Introduction – una guía que utiliza el juego de la vida para ilustrar los conceptos de NumPy.

En nuestro próximo tutorial, nos sumergimos más en Pandas, una biblioteca que se basa en NumPy y hace que el análisis de datos sea aún más fácil. Resuelve dos de los mayores puntos de dolor que son que:

• No puedes mezclar múltiples tipos de datos en un array.
• Tienes que recordar qué tipo de datos contiene cada columna.

.