Introducción a Numpy y Pandas

Recomendación: utilice el editor de escenas NSDT para crear rápidamente escenas de aplicaciones 3D

Si está trabajando en proyectos de ciencia de datos, los paquetes de Python le simplificarán la vida, ya que solo necesita unas pocas líneas de código para realizar operaciones complejas, como manipular datos y aplicar modelos de aprendizaje automático/aprendizaje profundo.

Al comenzar su viaje en ciencia de datos, se recomienda comenzar aprendiendo dos de los paquetes de Python más útiles: NumPy y Pandas. En este artículo, presentaremos estas dos bibliotecas. ¡Empecemos!

¿Qué es NumPy?

NumPy significa Numeric Python y se utiliza para cálculos eficientes en matrices y detrás de escena de modelos de aprendizaje automático. El componente básico de Numpy es una matriz, que es una estructura de datos muy similar a una lista, excepto que proporciona una gran cantidad de funciones matemáticas. En otras palabras, una matriz Numpy es un objeto de matriz multidimensional.

Crea una matriz de números

Podemos definir arrays NumPy usando listas o listas de listas:

import numpy as np
l = [[1,2,3],[4,5,6],[7,8,9]]
numpy_array = np.array(l)
numpy_array

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

A diferencia de una lista de listas, podemos visualizar una matriz de 3X3 con una sangría entre cada fila. Además, NumPy proporciona más de 40 funciones integradas para la creación de matrices.

Para crear una matriz llena de ceros, existe la función np.zeros, donde solo necesitas especificar la forma deseada:

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

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

Asimismo, podemos crear una matriz llena de unos:

ones_array = np.ones((3,4))
ones_array

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

También puedes crear la matriz identidad, que es una matriz cuadrada con 1 en la diagonal principal y 0 en los elementos fuera de la diagonal:

identity_array = np.identity(3)
identity_array

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

Además, NumPy proporciona diferentes funciones para crear matrices aleatorias. Para crear una matriz llena de muestras aleatorias distribuidas uniformemente en [0, 1], solo necesitamos la función np.random.rand:

random_array = np.random.rand(3,4)
random_array

array([[0.84449279, 0.71146992, 0.48159787, 0.04927379],
       [0.03428534, 0.26851667, 0.65718662, 0.52284251],
       [0.1380207 , 0.91146148, 0.74171469, 0.57325424]])

De manera similar a la función anterior, podemos definir una matriz con valores aleatorios, pero esta vez los tiempos se toman de una distribución normal estándar:

randn_array = np.random.randn(10)
randn_array

array([-0.68398432, -0.25466784,  0.27020797,  0.29632334, -0.20064897,
        0.7988508 ,  1.34759319, -0.41418478, -0.35223377, -0.10282884])

Si estamos interesados ​​en construir un array con enteros aleatorios pertenecientes al intervalo [bajo, alto], sólo necesitamos la función np.random.randint:

randint_array = np.random.randint(1,20,20)
randint_array

array([14,  3,  1,  2, 17, 15,  5, 17, 18,  9,  4, 19, 14, 14,  1, 10, 17,
       19,  4,  6])

Indexación y corte

Además de las funciones integradas para crear matrices, otra ventaja de NumPy es que puede seleccionar elementos de una matriz utilizando un conjunto de corchetes. Por ejemplo, podemos intentar tomar la primera fila de la matriz:

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

array([1, 2, 3])

Supongamos que queremos seleccionar el tercer elemento de la primera fila. En este caso, necesitamos especificar dos índices, el índice de la fila y el índice de la columna:

print(a1[0,2]) #3

Otra forma es usar a1[0][2], pero se considera ineficiente porque primero crea la matriz que contiene la primera fila y luego selecciona elementos de esa fila.

Además, podemos obtener sectores de una matriz con la sintaxis inicio:parada:paso entre paréntesis, que no incluye el índice de parada. Por ejemplo, queremos volver a seleccionar la primera fila, pero solo seleccionamos los dos primeros elementos:

print(a1[0,0:2]) 

[1 2]

Si preferimos seleccionar todas las filas pero queremos extraer el primer elemento de cada fila:

print(a1[:,0])

[1 4]

Además de los índices de matriz de números enteros, también existen índices de matriz booleanos, que se utilizan para seleccionar elementos de una matriz. Supongamos que solo queremos elementos que cumplan con los siguientes criterios:

a1>5

array([[False, False, False],
       [False, False,  True]])

Si filtramos la matriz según esta condición, la salida mostrará solo elementos Verdaderos:

a1[a1>5]

array([6])

Operaciones de matriz

Cuando se trabaja en proyectos de ciencia de datos, es común remodelar las matrices para darles nuevas formas sin cambiar los datos.

Por ejemplo, comenzamos con una matriz de dimensiones 2X3. Si no estamos seguros de la forma de una matriz, existen formas de atributos que pueden ayudarnos:

a1 = np.array([[1,2,3],[4,5,6]])
print(a1)
print('Shape of Array: ',a1.shape)

[[1 2 3]
 [4 5 6]]
Shape of Array:  (2, 3)

Para remodelar la matriz en dimensiones 3X2 simplemente podemos usar la función remodelar:

a1 = a1.reshape(3,2)
print(a1)
print('Shape of Array: ',a1.shape)

[[1 2]
 [3 4]
 [5 6]]
Shape of Array:  (3, 2)

Otra situación común es convertir una matriz multidimensional en una matriz unidimensional. Esto se puede lograr especificando -1 como forma:

a1 = a1.reshape(-1)
print(a1)
print('Shape of Array: ',a1.shape)

[1 2 3 4 5 6]
Shape of Array:  (6,)

Es posible que también necesites obtener la matriz transpuesta:

a1 = np.array([[1,2,3,4,5,6]])
print('Before shape of Array: ',a1.shape)
a1 = a1.T
print(a1)
print('After shape of Array: ',a1.shape)

Before shape of Array:  (1, 6)
[[1]
 [2]
 [3]
 [4]
 [5]
 [6]]
After shape of Array:  (6, 1)

Asimismo, puedes aplicar la misma transformación usando np.transpose(a1).

multiplicación de matrices

Si está intentando crear un algoritmo de aprendizaje automático desde cero, definitivamente necesitará calcular el producto matricial de dos matrices. Cuando la matriz tiene más de 1 dimensión, puedes usar la función np.matmul para hacer esto:

a1 = np.array([[1,2,3],[4,5,6]])
a2 = np.array([[1,2],[4,5],[7,8]])
print('Shape of Array a1: ',a1.shape)
print('Shape of Array a2: ',a2.shape)
a3 = np.matmul(a1,a2) 
# a3 = a1 @ a2
print(a3)
print('Shape of Array a3: ',a3.shape)

Shape of Array a1:  (2, 3)
Shape of Array a2:  (3, 2)
[[30 36]
 [66 81]]
Shape of Array a3:  (2, 2)

@ puede ser una alternativa más corta a np.matmul.

Si multiplica matrices con escalares, np.dot es la mejor opción:

a1 = np.array([[1,2,3],[4,5,6]])
a3 = np.dot(a1,2)
# a3 = a1 * 2
print(a3)
print('Shape of Array a3: ',a3.shape)

[[ 2  4  6]
 [ 8 10 12]]
Shape of Array a3:  (2, 3)

En este caso, * es la alternativa más corta a np.dot.

Funciones matemáticas

NumPy proporciona una amplia variedad de funciones matemáticas como funciones trigonométricas, funciones de redondeo, exponenciales, logaritmos, etc. Puedes encontrar la lista completa aquí. Le mostraremos las características más importantes que puede aplicar a su problema.

Los logaritmos exponenciales y naturales son definitivamente las transformaciones más populares y conocidas:

a1 = np.array([[1,2,3],[4,5,6]])
print(np.exp(a1))

[[  2.71828183   7.3890561   20.08553692]
 [ 54.59815003 148.4131591  403.42879349]]

a1 = np.array([[1,2,3],[4,5,6]])
print(np.log(a1))

[[0.         0.69314718 1.09861229]
 [1.38629436 1.60943791 1.79175947]]

Si queremos extraer los valores mínimo y máximo en una línea de código, solo necesitamos llamar a la siguiente función:

a1 = np.array([[1,2,3],[4,5,6]])
print(np.min(a1),np.max(a1))  # 1 6

También podemos calcular la raíz cuadrada de cada elemento de la matriz:

a1 = np.array([[1,2,3],[4,5,6]])
print(np.sqrt(a1))

[[1.         1.41421356 1.73205081]
 [2.         2.23606798 2.44948974]]

¿ Qué son los pandas ?

Pandas se basa en Numpy y es útil para manipular conjuntos de datos. Hay dos estructuras de datos principales: Series y DataFrame . Una secuencia es una serie de valores, mientras que un marco de datos es una tabla que contiene filas y columnas. En otras palabras, una secuencia es una columna de un marco de datos.

Crear series y marcos de datos.

Para construir una secuencia simplemente pasamos una lista de valores al método:

import pandas as pd
type_house = pd.Series(['Loft','Villa'])
type_house

0     Loft
1    Villa
dtype: object

Podemos crear un dataframe pasando un diccionario de objetos, donde las claves corresponden a los nombres de las columnas y los valores son las entradas de las columnas:

df = pd.DataFrame({'Price': [100000, 300000], 'date_construction': [1960, 2010]})
df.head()

Después de crear el marco de datos, podemos verificar el tipo de cada columna:

type(df.Price),type(df.date_construction)

(pandas.core.series.Series, pandas.core.series.Series)

Debe quedar claro que las columnas son estructuras de datos de tipo serie.

función de resumen

De ahora en adelante, demostraremos el potencial de Pandas utilizando el conjunto de datos para compartir bicicletas disponible en Kaggle . Podemos importar archivos CSV a través de:

df = pd.read_csv('/kaggle/input/bike-sharing-demand/train.csv')
df.head()

Pandas permite leer no sólo archivos CSV, sino también archivos Excel, JSON, Parquet y otros tipos de archivos. Puedes encontrar la lista completa aquí.

Desde el resultado, podemos visualizar las primeras cinco filas del marco de datos. Si queremos mostrar las últimas cuatro filas del conjunto de datos, usamos el método tail():

df.tail(4)

Unas pocas filas no son suficientes para comprender bien los datos que tenemos. Una buena manera de comenzar su análisis es observar la forma de su conjunto de datos:

df.shape                    #(10886, 12)

Tenemos 10886 filas y 12 columnas. ¿Quieres ver los nombres de las columnas? Hacer esto es muy intuitivo:

df.columns

Hay una manera de visualizar toda esta información en una salida única:

df.info()

Si queremos mostrar estadísticas para cada columna, podemos usar el método describe:

df.describe()

También es importante extraer información de campos categóricos. Podemos encontrar los valores únicos y la cantidad de valores únicos para la columna de temporada:

df.season.unique(),df.season.nunique()

Producción:

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

Podemos ver que los valores son 1, 2, 3, 4. Entonces, hay cuatro valores posibles. Esta validación es crucial para comprender las variables categóricas y proteger contra el posible ruido contenido en la columna.

Para mostrar la frecuencia de cada nivel, podemos usar el método value_counts():

df.season.value_counts()

El último paso debería ser comprobar si faltan valores en cada columna:

df.isnull().sum()

Afortunadamente, no nos faltan valores en estos campos.

Indexación y corte

Al igual que en Numpy, existe una selección basada en índices para seleccionar datos de estructuras de datos. Hay dos formas principales de obtener entradas de un marco de datos:

• ILOC selecciona elementos según la posición del número entero
• LOC Obtiene un elemento basado en una etiqueta o matriz booleana.

Para seleccionar la primera fila, iloc es su mejor opción:

df.iloc[0]

Si queremos seleccionar todas las filas y solo la segunda columna, podemos hacer lo siguiente:

df.iloc[:,1]

También puedes seleccionar más columnas al mismo tiempo:

df.iloc[0:3,[0,1,2,5]]

Seleccionar columnas según el índice se vuelve complejo. Es mejor especificar nombres de columnas. Esto se puede hacer usando loc:

df.loc[0:3,['datetime','season','holiday','temp']]

Al igual que Numpy, los marcos de datos se pueden filtrar según las condiciones. Por ejemplo, queremos devolver todas las filas donde el clima es igual a 1:

df[df.weather==1]

Si queremos devolver una salida que contenga columnas específicas, podemos usar loc:

df.loc[df.weather==1,['season','holiday']]

Crear nueva variable

La creación de nuevas variables tiene un gran impacto a la hora de extraer más información de los datos y mejorar la interpretabilidad. Podemos crear una nueva variable categórica basada en los valores de los días de la semana:

df['workingday_c'] = df['workingday'].apply(lambda x: 'work' if x==1 else 'relax')
df[['workingday','workingday_c']].head()

Si tiene varias condiciones, es mejor utilizar un diccionario y un mapa de métodos para asignar los valores:

diz_season = {1:'winter',2:'spring',3:'summer',4:'fall'}
df['season_c'] = df['season'].map(lambda x: diz_season[x])
df[['season','season_c']].head()

Agrupar y ordenar

Es posible que desee agrupar sus datos según columnas categóricas. Esto se puede hacer mediante agrupación:

df.groupby('season_c').agg({'count':['median','max']})

Para cada nivel de la temporada podemos observar los valores medianos y máximos de bicicletas alquiladas. Este resultado puede resultar confuso si no ordena por columnas. Podemos hacer esto usando el método sort_values():

df.groupby('season_c').agg({'count':['median','max']}).reset_index().sort_values(by=('count', 'median'),ascending=False)

Ahora el resultado tiene más sentido. Podemos deducir que el mayor número de bicicletas se alquilan en verano, mientras que el invierno no es un buen mes para alquilar bicicletas.

Conclusión

¡Eso es todo! Espero que esta guía te haya resultado útil para aprender los conceptos básicos de NumPy y Pandas. A menudo se estudian por separado, pero puede resultar revelador comprender primero NumPy y luego Pandas, que está construido sobre NumPy.

Por supuesto, hay algunos métodos que no cubrí en este tutorial, pero el objetivo es cubrir los métodos más importantes y populares en ambas bibliotecas. El código se puede encontrar en Kaggle. ¡Gracias por leer! ¡Que tenga un lindo día!

Enlace original: Introducción a Numpy y Pandas (mvrlink.com)