Manejo de datos

library(knitr)
include_graphics("images.jpg")

Selección de elementos y filtros

Lo que haremos inicialmente será aprender a manipular dataframes (tablas de datos) en R. Por ejemplo:

# Importacion necesaria
library(datasets)

# Cargamos un conjunto de datos
df <- datasets::iris
# Vemos los primeros 5 registros con la funcion head()
head(df, 5)

Dado un dataframe, podremos acceder a cierto número de filas y columnas utilizando para ello df[] como sigue

# De la fila 1 a la 5 (izquierda de la coma)
# De la columna 1 a la 3 (derecha de la coma)
df[1:5, 1:3]

siguiendo con la misma lógica podemos acceder a un solo elemento del dataframe

# Elemento en la fila 1 y columna 1
df[1,1]
## [1] 5.1

Si dentro de los corchetes solo colocamos un número, lo que estaremos haciendo es acceder únicamente a los elementos de una columna:

# Los primeros 5 elementos de la segunda columna
head(df[2], 5)

Anteriormente obtuvimos los elementos de las primeras cinco filas y las primeras tres columnas df[1:5, 1:3], pero tambén podemos acceder solo a una fila en particular

# Elementos de la segunda fila y de 
# las primeras 4 columnas
df[2, 1:4]

o también

# Elementos de la primer y segunda fila y de 
# la tercer columna
df[1:2, 3]
## [1] 1.4 1.4

Finalmente

# Elementos de la primer y segunda fila para todas las columnas
# (colocamos una coma y dejamos el espacio en blanco)
df[1:2, ]

De manera alternativa, podemos acceder a los elementos de una columna en particular utilizando el símbolo $:

# Accedemos a los tres primeros elementos de la columna Petal.Width
head(df$Petal.Width, 3)
## [1] 0.2 0.2 0.2

Con base en dicha notación, podemos seleccionar elementos de un dataframe dada una condición

# Todos los elementos del dataframe que tengan en Petal.Width un numero mayor a 1.5. Colocamos una coma y dejamos un espacio en blanco debido a que queremos todas las columnas
df[df$Petal.Width > 1.5, ]

Así, podremos seleccionar datos dada una condición, para lo cual utilizaremos los operadores <, >, ==, <=, >=, y en realidad podremos combinarlos utilizando los operador booleanos: & (and, y) y | (or, o)

# Todos los elementos del dataframe que tengan en Petal.Width un numero mayor a 1.5 o que tengan un numero de Petal.Length mayor a 3
df[(df$Petal.Width <= 1.5) | (df$Petal.Length > 3), ]

Por otro lado, podemos ordenar un dataframe de acuerdo a los valores de una columna, utilizando la función order():

# Ordenamos de manera ascendente de acuerdo a los valores en Petal.Length
df[order(df$Petal.Length), ]

podemos ordenar de manera descendente configurando df[order(df$Petal.Length, decreasing = T), ]

Creación de dataframes

Hasta ahora hemos trabajado con dataframes ya creados, no osbtante, podemos crear manualmente nuestros dataframes, lo cual haremos utilizando vectores. Por ejemplo

# Creamos dos vectores:
# Un vector de nombres
nombre <- c("Ana", "Luna", "Fernando")

# Un vector de edades
edad <- c(32, 17, 40)

# Procederemos a crear el dataframe con la funcion data.frame
df_new  <- data.frame(
  "Nombres" = nombre,
  "Edades"  = edad 
)

df_new

donde, dentro de la función data.frame() colocamos en cadenas de texto los nombres que queremos asignarles a las columnas, después del símbolo de asignación (=) colocamos el vector que contiene la información para esa columna, y separamos por comas. Otro ejemplo

df_new_2 <- data.frame(
  "ID"     = 1:10,
  "Número" = sample(1:100, 10)
)
df_new_2

donde con 1:10 creamos la secuencia (la cual es un vector) de números enteros del 1 al 10; con sample(1:100, 10) estamos creando una secuancia de números enteros del 1 al 100, pero sólo serán seleccionados 10, y donde esta seleeción es de manera aleatoria.

Podemos agregar columnas nuevas a dataframes ya creados. Por ejemplo, colocaremos una columna nueva denominada "Número_2" al dataframe df_new_2, asignándole los valores del 1000 al 2000, pero solo tomando 10 de ellos de manera aleatoria. Para ello

# Columna nueva         valores asignados
df_new_2["Número_2"] <- sample(1000:2000, 10)

# Veamos el dataframe
df_new_2

Para eliminar una columna, antes veamos otra forma de seleccionar elementos:

# Todas las filas, pero solo de la columna ID y Numero:
#          con un vector colocamos los nombres de las dos columnas de interes
df_new_2[, c('ID', 'Número')]

Así, si queremos un dataframe, por ejemplo, sin la columna Número_2 escribimos

# Reasignamos a df_new_2 el dataframe que solo considera a las columnas sin la columna Numero_2
df_new_2 <- df_new_2[, c('ID', 'Número')]
df_new_2

Podemos eliminar solo una fila utilizando el símbolo - como sigue

# Dentro del corchete, colocamos un -1 debido a que queremos eliminar la fila 1:
df_new_2[-1, ]

Graficación

Inicialmente, realizaremos un gráfico de dispersión entre dos columnas del dataframe df como sigue:

plot(x=df$Petal.Length, y=df$Petal.Width)

Luego, tenemos que en ese dataframe la información de cada fila corresponde a una especie en específico

df[ , c("Petal.Length", "Petal.Width", "Species")]

donde solo hay tres especies

# Con la funcion unique() obtenemos los valores diferentes en una columna
unique(df$Species)
## [1] setosa     versicolor virginica 
## Levels: setosa versicolor virginica

Así, podemos colorear el diagrama de dispersión anterior de acuerdo a cada especie:

# Agregamos el parametro col
plot(x=df$Petal.Length, y=df$Petal.Width, col=df$Species)

plot(x=df$Petal.Length, y=df$Petal.Width, col=df$Species,
     # Agregamos un titulo al grafico
     main = "Diagrama de dispersión")

Podemos agregar una leyenda para saber a qué especie corresponde cada color

plot(x=df$Petal.Length, y=df$Petal.Width, col=df$Species,
     main = "Diagrama de dispersión")
legend(x="topleft", legend = c("Setosa", "Versicolor", "Virginica"), fill=c("black", "red", "green"))
# Podemos agregar una cuadricula al grafico
grid()

donde

  • x especifica la ubicación donde se colocarán las etiquetas.
  • legend corresponde a las etiquetas que se mostrarán.
  • fill el color de las etiquetas.

Ahora graficaremos un histograma, el cual nos permite observar la distribución de datos numéricos usando barras

# Graficamos un histograma
hist(x=df$Petal.Length, main = "Histograma",
     # Cambiaremos la etiqueta del eje x
     xlab = "Petal Length")

Podemos cambiar el color

hist(x=df$Petal.Length, main = "Histograma",
     xlab = "Petal Length",
     col = "orange")

Finalmente, lo que haremos será definir una función que siga la regla \(f(x)=x^{2}\) y la graficaremos. Para crear una función escribiremos

nombre_de_la_funcion <- function(<<parametros>>){
  <<acciones que hace la funcion>>
  return(<<lo que regresa la funcion>>)
}

De tal manera

# Definimos la funcion
f <- function(x){
  return(x ** 2)
}

# Probamos la funcion
f(4)
## [1] 16

Ahora la graficaremos:

# Creamos una secuencia de valor del -5 al 5 con un paso o avance de 0.01
x_rango <- seq(-5, 5, 0.01)

# Graficamos
plot(x_rango, f(x_rango), col="purple", main = "Gráfico de f(x)=x^2")
# Agregamos una cuadricula
grid()

Manejo de datos en Python

library(knitr)
include_graphics("pylogo.png")

Para manejar datos como lo hicimos antes en R ocuparemos una librería de Python denominada Pandas, la cual nos permitirá trabajar con dataframes como lo hemos hecho antes. Para ello

Librería Pandas

# Cargamos la libreria y le asociamos un alias
import pandas as pd

# Importamos otra libreria la cual tiene conjuntos de datos integrados (como la libreria datasets de R)
import seaborn as sns

Luego, cargaremos el mismo conjunto de datos iris, pero ahora de la librería seaborn:

# Cargamos los datos
df = sns.load_dataset("iris")

# Vemos los primeros 5 elementos con la funcion .head()
df.head(5)
##    sepal_length  sepal_width  petal_length  petal_width species
## 0           5.1          3.5           1.4          0.2  setosa
## 1           4.9          3.0           1.4          0.2  setosa
## 2           4.7          3.2           1.3          0.2  setosa
## 3           4.6          3.1           1.5          0.2  setosa
## 4           5.0          3.6           1.4          0.2  setosa

Luego, podemos obtener la información de una columna en particular

# Dentro de los corchetes colocamos el nombre de la columna
df["sepal_length"]
## 0      5.1
## 1      4.9
## 2      4.7
## 3      4.6
## 4      5.0
##       ... 
## 145    6.7
## 146    6.3
## 147    6.5
## 148    6.2
## 149    5.9
## Name: sepal_length, Length: 150, dtype: float64

si queremos acceder a información de más de una columna colocaremos los nombres de dichas columnas dentro otros corchetes:

# Dentro de los corchetes colocamos el nombre de las columnas
df[["sepal_length", "sepal_width"]]
##      sepal_length  sepal_width
## 0             5.1          3.5
## 1             4.9          3.0
## 2             4.7          3.2
## 3             4.6          3.1
## 4             5.0          3.6
## ..            ...          ...
## 145           6.7          3.0
## 146           6.3          2.5
## 147           6.5          3.0
## 148           6.2          3.4
## 149           5.9          3.0
## 
## [150 rows x 2 columns]

Podemos obtener la información de las primeras 9 filas:

# En Python las numeraciones comienzan con el cero.
df[0:9]
##    sepal_length  sepal_width  petal_length  petal_width species
## 0           5.1          3.5           1.4          0.2  setosa
## 1           4.9          3.0           1.4          0.2  setosa
## 2           4.7          3.2           1.3          0.2  setosa
## 3           4.6          3.1           1.5          0.2  setosa
## 4           5.0          3.6           1.4          0.2  setosa
## 5           5.4          3.9           1.7          0.4  setosa
## 6           4.6          3.4           1.4          0.3  setosa
## 7           5.0          3.4           1.5          0.2  setosa
## 8           4.4          2.9           1.4          0.2  setosa

o las primeras 5 filas de una sola columna

# Primero seleccionamos la columna y despues entre corchetes colocamos el rango 0:5 para seleccionar las primeras 5 filas
df["petal_length"][0:5]
## 0    1.4
## 1    1.4
## 2    1.3
## 3    1.5
## 4    1.4
## Name: petal_length, dtype: float64

Nota: En R escribíamos df$Petal_Length para acceder a los elementos de una columna, en Python escribimos df["petal_length"].

Asimismo, podemos seleccionar elementos del dataframe dada una condición:

# Colocamos nombre del dataframe, luego, entre corchetes 
# accedemos a la columna sepal_width y ponemos la condicion
df[df["sepal_width"] > 4]
##     sepal_length  sepal_width  petal_length  petal_width species
## 15           5.7          4.4           1.5          0.4  setosa
## 32           5.2          4.1           1.5          0.1  setosa
## 33           5.5          4.2           1.4          0.2  setosa

o también

# Elementos que tengan un numero mayor de 3.5 de sepal_width
# y (and, &) que tenga un numero mayor de 4.5 de sepal_length
df[(df["sepal_width"] > 3.5) & (df["sepal_length"] > 4.5) ]
##      sepal_length  sepal_width  petal_length  petal_width    species
## 4             5.0          3.6           1.4          0.2     setosa
## 5             5.4          3.9           1.7          0.4     setosa
## 10            5.4          3.7           1.5          0.2     setosa
## 14            5.8          4.0           1.2          0.2     setosa
## 15            5.7          4.4           1.5          0.4     setosa
## 16            5.4          3.9           1.3          0.4     setosa
## 18            5.7          3.8           1.7          0.3     setosa
## 19            5.1          3.8           1.5          0.3     setosa
## 21            5.1          3.7           1.5          0.4     setosa
## 22            4.6          3.6           1.0          0.2     setosa
## 32            5.2          4.1           1.5          0.1     setosa
## 33            5.5          4.2           1.4          0.2     setosa
## 37            4.9          3.6           1.4          0.1     setosa
## 44            5.1          3.8           1.9          0.4     setosa
## 46            5.1          3.8           1.6          0.2     setosa
## 48            5.3          3.7           1.5          0.2     setosa
## 109           7.2          3.6           6.1          2.5  virginica
## 117           7.7          3.8           6.7          2.2  virginica
## 131           7.9          3.8           6.4          2.0  virginica

El operador or es el mismo en Python que en R, esto es, el símbolo es |.

Por otro lado, podemos crear los dataframes en Python:

# Creamos el dataframe con la funcion pd.DataFrame().
# Dentro de los parentesis colocaremos llaves
df_new = pd.DataFrame({
  # nombre   |los elementos de esta columna
  # de la    |los colocaremos entre  
  # columna  |corchetes
  "Nombres": ["Luis", "Ana", "Fer"],
  "Edades" : [25, 30, 16]
})

# Veamos el dataframe
df_new
##   Nombres  Edades
## 0    Luis      25
## 1     Ana      30
## 2     Fer      16

De manera análoga en R, podremos agregar columnas nuevas:

# Importacion necesaria para crear vectores (arrays)
import numpy as np

# Columna nueva     | rango de numeros del 0 al 2
df_new["Columna nueva"] = np.arange(0, 3, 1)

# Veamos de nuevo el dataframe
df_new
##   Nombres  Edades  Columna nueva
## 0    Luis      25              0
## 1     Ana      30              1
## 2     Fer      16              2

Graficación

Con la librería Pandas podemos realizar de manera directa gráficos. Por ejemplo, para un diagrama de dispersión escribiremos nombre_del_dataframe.plot.scatter(x=, y=), donde en x colocamos el nombre de la columna del dataframe nombre_del_dataframe que queremos que sea la variable independiente y en y la columna que queremos que sea la variable dependiente. Así:

df.plot.scatter(x = "sepal_length", y = "sepal_width")

Podemos cambiar el color y agregar un título

df.plot.scatter(x = "sepal_length", y = "sepal_width", color="darkblue", title="Diagrama de dispersión")

Podemos graficar un histograma seleccionando primer la columna de interés, después colocamos .plot.hist() como sigue

df["sepal_length"].plot.hist()

Finalmente, también podemos definir la función \(f(x)=x^{2}\) en Python y después graficarla. Primero definimos la función. En este caso la estructura es:

def nombre_funcion(parametros):
  acciones_a_realizar
  return valor_a_regresar

Luego:

# Definimos la funcion
def f(x):
  return x ** 2

# Probamos implementando un bucle for
for i in range(5):
  print(f(i))
## 0
## 1
## 4
## 9
## 16

Para graficar la función anterior nos vandremos de otra librería de graficación:

# Importación necesaria
import matplotlib.pyplot as plt

# Creamos el rando de graficacion de -5 a 5 con un paso de 0.01
x_rango = np.arange(-5,5, 0.01)

Luego, para graficar escribimos

# Creamos el grafico
plt.plot(x_rango, f(x_rango), color="red")
# Configuramos el titulo
plt.title
# Configuramos la etiqueta del eje x
plt.xlabel("Eje x")
# Configuramos la etiqueta del eje y
plt.ylabel("Eje y")
# Configuramos una cuadricula
plt.grid()
# Mostramos el grafico
plt.show()

Ejercicios

R

Considerando la librería datasets, carga el conjunto de datos cars. Luego

  1. Realiza un gráfico de dispersión entre las dos columnas de dicho conjunto de datos. Deberás cambiar el color, agregarle un título y una cuadrícula al gráfico; además, cambia las etiquetas de los ejes.

  2. Obtene información de dicho dataframe para aquellos registros donde speed sea mayor a 10 y donde dist sea menor a 20.

  3. Obtén la información de las primeras 5 filas del dataframe, pero solo de la columna dist. Para obtener dicha información deberás de emplear dos formas distintas.

  4. Al dataframe anterior, agrégale una nueva columna denominada id que contenga el rango de números del 1 al 50.

  5. Crear un dataframe con la información de tu preferencia.

  6. Define una función referente a la función matemática \(f(x)=x^{3}\) y gráficala.

Python

De la librería seaborn, carga el conjunto de datos tips.

  1. Realiza un gráfico de dispersión entre las columnas tip y total_bill.

  2. Obtén la información del dataframe para aquellos registros donde tip sea mayor a 5 y donde smoker sea igual (==) a "No".

  3. Define una función referente a la función matemática \(f(x)=x^{3}\) y grafícala.