¿Qué vamos a aprender?

1. Tipos de claves: primaria, foránea y subrogada

2. ¿Qué es una relación?

3. Uniones de transformación

4. Uniones de filtrado

5. Operaciones con conjuntos

aeropuertos

Observations: 1,458
Variables: 8
$ codigo_aeropuerto <chr> "04G", "06A", "06C", "06N", "09J", "0A9", "0G6", ...
$ nombre            <chr> "Lansdowne Airport", "Moton Field Municipal Airpo...
$ latitud           <dbl> 41.13047, 32.46057, 41.98934, 41.43191, 31.07447,...
$ longitud          <dbl> -80.61958, -85.68003, -88.10124, -74.39156, -81.4...
$ altura            <dbl> 1044, 264, 801, 523, 11, 1593, 730, 492, 1000, 10...
$ zona_horaria      <dbl> -5, -6, -6, -5, -5, -5, -5, -5, -5, -8, -5, -6, -...
$ horario_verano    <chr> "A", "A", "A", "A", "A", "A", "A", "A", "U", "A",...
$ zona_horaria_iana <chr> "America/New_York", "America/Chicago", "America/C...

aerolineas

Permite observar el nombre completo de la aerolínea a partir de su código abreviado.

Observations: 16
Variables: 2
$ aerolinea <chr> "9E", "AA", "AS", "B6", "DL", "EV", "F9", "FL", "HA", "MQ...
$ nombre    <chr> "Endeavor Air Inc.", "American Airlines Inc.", "Alaska Ai...

aviones

Observations: 3,322
Variables: 9
$ codigo_cola <chr> "N10156", "N102UW", "N103US", "N104UW", "N10575", "N105...
$ anio        <int> 2004, 1998, 1999, 1999, 2002, 1999, 1999, 1999, 1999, 1...
$ tipo        <chr> "Fixed wing multi engine", "Fixed wing multi engine", "...
$ fabricante  <chr> "EMBRAER", "AIRBUS INDUSTRIE", "AIRBUS INDUSTRIE", "AIR...
$ modelo      <chr> "EMB-145XR", "A320-214", "A320-214", "A320-214", "EMB-1...
$ motores     <int> 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2...
$ asientos    <int> 55, 182, 182, 182, 55, 182, 182, 182, 182, 182, 55, 55,...
$ velocidad   <int> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA,...
$ tipo_motor  <chr> "Turbo-fan", "Turbo-fan", "Turbo-fan", "Turbo-fan", "Tu...

clima

Observations: 26,115
Variables: 15
$ origen           <chr> "EWR", "EWR", "EWR", "EWR", "EWR", "EWR", "EWR", "...
$ anio             <int> 2013, 2013, 2013, 2013, 2013, 2013, 2013, 2013, 20...
$ mes              <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,...
$ dia              <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,...
$ hora             <int> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16,...
$ temperatura      <dbl> 39.02, 39.02, 39.02, 39.92, 39.02, 37.94, 39.02, 3...
$ punto_rocio      <dbl> 26.06, 26.96, 28.04, 28.04, 28.04, 28.04, 28.04, 2...
$ humedad          <dbl> 59.37, 61.63, 64.43, 62.21, 64.43, 67.21, 64.43, 6...
$ direccion_viento <dbl> 270, 250, 240, 250, 260, 240, 240, 250, 260, 260, ...
$ velocidad_viento <dbl> 10.35702, 8.05546, 11.50780, 12.65858, 12.65858, 1...
$ velocidad_rafaga <dbl> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA...
$ precipitacion    <dbl> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,...
$ presion          <dbl> 1012.0, 1012.3, 1012.5, 1012.2, 1011.9, 1012.4, 10...
$ visibilidad      <dbl> 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10...
$ fecha_hora       <dttm> 2013-01-01 01:00:00, 2013-01-01 02:00:00, 2013-01...

Relaciones

• Recordemos que, se llaman datos relacionales a múltiples tablas de datos, ya que no solo importan los conjuntos de datos individuales, sino que también sus relaciones son importantes.

• Una clave primaria y su correspondiente clave foránea en otra tabla forman una relación.

• Las relaciones siempre se definen sobre un par de tablas. Todas las otras relaciones se construyen sobre esta idea simple: las relaciones entre tres o más tablas son siempre una propiedad de las relaciones entre cada par.

Relaciones

Diagrama de relaciones entre las diferentes tablas del dataset vuelos:

• vuelos se conecta con aviones a través de la variable codigo_cola

• vuelos se conecta con aerolineas a través de la variable codigo_carrier.

• vuelos se conecta con aeropuertos de dos formas: a través de las variables origen y destino.

• vuelos se conecta con clima a través de las variables origen (es decir,la ubicación) más anio, mes, dia y hora.

Claves

• Las variables usadas para conectar cada par de variables se llaman claves (del inglés key).

• Una clave es una variable (o un conjunto de variables) que identifican de manera única una observación.

• En casos simples, una sola variable es suficiente para identificar una observación. Ejemplo: cada avión está identificado de forma única por su codigo_cola.

• En otros casos, se pueden necesitar múltiples variables. Ejemplo, para identificar una observación en clima se necesitan cinco variables: anio, mes, dia, hora y origen.

Claves

Existen diferentes tipos de claves:

• Una clave primaria identifica únicamente una observación en su propia tabla. Por ejemplo, codigo_cola es una clave primaria, ya que identifica de manera única cada avión en la tabla aviones.

• Una clave foránea identifica de manera única una observación en otra tabla. Por ejemplo, vuelos$codigo_cola es una clave foránea, ya que aparece en la tabla vuelos, y une cada vuelo con un único avión.

• Una clave subrogada, es aquella que tiene como único requisito almacenar un valor numérico único para cada fila de la tabla, el cual es totalmente independiente a los datos de negocio.

Importante: Una variable puede ser clave primaria y clave foránea a la vez. Por ejemplo, origen es parte de la clave primaria de la tabla clima y también una clave foránea de la tabla aeropuertos, es decir, permite que el clima se relacione con un determinado aeropuerto.

Joins

Una unión es una forma de conectar cada fila en x con cero, una o más filas en y.

Familias de verbos para trabajar entre pares de tablas:

1. Uniones de transformación (del inglés mutating joins), las cuales agregan nuevas variables a un data frame a partir de las observaciones coincidentes en otra tabla.

2. Uniones de filtro (del inglés filtering joins), las cuales filtran observaciones en un data frame con base en si coinciden o no con una observación de otra tabla.

3. Operaciones de conjuntos (del inglés set operations), las cuales tratan las observaciones como elementos de un conjunto.

Joins

Sintaxis:

tabla1 %>% TIPO_DE_UNION (tabla2, by = "key")

donde TIPO_DE_UNION puede ser:

• inner_join

• left_join

• right_join

• full_join

• anti_join

• semi_join

by (según) le indica a dplyr qué variable es la clave con la que se realizará la unión.

Uniones de transformación

La unión de transformación o mutating join permite combinar variables a partir de dos tablas.

1. Busca coincidencias de observaciones entre ambas tablas de acuerdo a su/s clave/s

2. Luego, copia las variables de una tabla a la otra.

Principalmente, existen dos tipos de unión:

Uniones de transformación

Las funciones de unión, tal como mutate(), agregan variables hacia la derecha, por lo que si tienes muchas variables inicialmente, las nuevas variables no se imprimirán.

Por lo tanto, crearemos un conjunto de datos más angosto para que sea más fácil ver qué es lo que está ocurriendo:

vuelos2 <- vuelos  %>%
  select (anio:dia, hora, origen, destino, codigo_cola, aerolinea) %>% head(7)
vuelos2

# A tibble: 7 x 8
   anio   mes   dia  hora origen destino codigo_cola aerolinea
  <int> <int> <int> <dbl> <chr>  <chr>   <chr>       <chr>    
1  2013     1     1     5 EWR    IAH     N14228      UA       
2  2013     1     1     5 LGA    IAH     N24211      UA       
3  2013     1     1     5 JFK    MIA     N619AA      AA       
4  2013     1     1     5 JFK    BQN     N804JB      B6       
5  2013     1     1     6 LGA    ATL     N668DN      DL       
6  2013     1     1     5 EWR    ORD     N39463      UA       
7  2013     1     1     6 EWR    FLL     N516JB      B6

Entendiendo las uniones de transformación

Una unión exterior mantiene las observaciones que aparecen en al menos una de las tablas. Existen tres tipos de uniones exteriores:

• Una unión izquierda (left join) mantiene todas las observaciones en x.

• Una unión derecha (right join) mantiene todas las observaciones en y.

• Una unión completa (full join) mantiene todas las observaciones en x e y.

Representación gráfica de las uniones exteriores

Unión por izquierda

Queremos incluir el nombre completo de la aerolínea en la tabla vuelos2.

¿Cómo lo hacemos?

Combinamos los datos de vuelos2 y aerolineas con un left_join() (union_izquierda):

union_tablas <-  vuelos2  %>%
     left_join (aerolineas, by = "aerolinea")

Unión por izquierda

El resultado de unir vuelos2 y aerolineas es la inclusión de una variable adicional, nombre en la primera tabla. Por esta razón llamamos unión de transformación a este tipo de unión.

# A tibble: 7 x 9
   anio   mes   dia  hora origen destino codigo_cola aerolinea nombre           
  <int> <int> <int> <dbl> <chr>  <chr>   <chr>       <chr>     <chr>            
1  2013     1     1     5 EWR    IAH     N14228      UA        United Air Lines~
2  2013     1     1     5 LGA    IAH     N24211      UA        United Air Lines~
3  2013     1     1     5 JFK    MIA     N619AA      AA        American Airline~
4  2013     1     1     5 JFK    BQN     N804JB      B6        JetBlue Airways  
5  2013     1     1     6 LGA    ATL     N668DN      DL        Delta Air Lines ~
6  2013     1     1     5 EWR    ORD     N39463      UA        United Air Lines~
7  2013     1     1     6 EWR    FLL     N516JB      B6        JetBlue Airways

Tablas

dplyr::band_members

# A tibble: 3 x 2
  name  band   
  <chr> <chr>  
1 Mick  Stones 
2 John  Beatles
3 Paul  Beatles

dplyr::band_instruments

# A tibble: 3 x 2
  name  plays 
  <chr> <chr> 
1 John  guitar
2 Paul  bass  
3 Keith guitar

Unión interna o Inner Join

band_members %>% inner_join(band_instruments)

# A tibble: 2 x 3
  name  band    plays 
  <chr> <chr>   <chr> 
1 John  Beatles guitar
2 Paul  Beatles bass

En algunos casos, no es necesario especificar la clave por la cual se realizará la unión.

Importante: La propiedad más importante de una unión interior es que las filas no coincidentes no se incluyen en el resultado.

Unión izquierda

band_members %>% left_join(band_instruments)

# A tibble: 3 x 3
  name  band    plays 
  <chr> <chr>   <chr> 
1 Mick  Stones  <NA>  
2 John  Beatles guitar
3 Paul  Beatles bass

Unión derecha

band_members %>% right_join(band_instruments)

# A tibble: 3 x 3
  name  band    plays 
  <chr> <chr>   <chr> 
1 John  Beatles guitar
2 Paul  Beatles bass  
3 Keith <NA>    guitar

Full Join

band_members %>% full_join(band_instruments)

# A tibble: 4 x 3
  name  band    plays 
  <chr> <chr>   <chr> 
1 Mick  Stones  <NA>  
2 John  Beatles guitar
3 Paul  Beatles bass  
4 Keith <NA>    guitar

Diagramas de Venn

Otra forma de ilustrar diferentes tipos de uniones es mediante un diagrama de Venn:

• Son útiles para recordar qué uniones preservan las observaciones en qué tabla

• Tienen una limitante importante: un diagrama de Venn no puede mostrar qué ocurre con las claves que no identifican de manera única una observación.

Uniones de filtrado

Las Uniones de filtrado unen observaciones de la misma forma que las uniones de transformación pero afectan a las observaciones, no a las variables.Además, uniones de filtro no duplican filas como lo hacen las uniones de transformación.

Tipos:

• semi_join: mantiene todas las observaciones en x con coincidencias en y. Las semi uniones son útiles para unir tablas resumen previamente filtradas con las filas originales.

• anti_join: descarta todas las observaciones en x con coincidencias en y.

Uniones de filtrado

Semi Join

band_members %>% semi_join(band_instruments)

# A tibble: 2 x 2
  name  band   
  <chr> <chr>  
1 John  Beatles
2 Paul  Beatles

Uniones de filtrado

Anti Join

band_members %>% anti_join(band_instruments)

# A tibble: 1 x 2
  name  band  
  <chr> <chr> 
1 Mick  Stones

Utilidad de las uniones de filtrado

• Las semi uniones son útiles para unir tablas resumen previamente filtradas con las filas originales.

Buscamos cada vuelo que fue a alguno de los destinos más populares:

vuelos %>%
  semi_join(destinos_populares)%>%
  head(3)

# A tibble: 3 x 19
   anio   mes   dia horario_salida salida_programa~ atraso_salida
  <int> <int> <int>          <int>            <int>         <dbl>
1  2013     1     1            554              600            -6
2  2013     1     1            554              558            -4
3  2013     1     1            557              600            -3
# ... with 13 more variables: horario_llegada <int>, llegada_programada <int>,
#   atraso_llegada <dbl>, aerolinea <chr>, vuelo <int>, codigo_cola <chr>,
#   origen <chr>, destino <chr>, tiempo_vuelo <dbl>, distancia <dbl>,
#   hora <dbl>, minuto <dbl>, fecha_hora <dttm>

Utilidad de las uniones de filtrado

• Las anti uniones son útiles para encontrar desajustes. Por ejemplo, al conectar aviones y vuelos, podría ser interesante saber que existen muchos vuelos que no tienen coincidencias en aviones:

vuelos %>%
  anti_join(aviones, by = "codigo_cola") %>%
  count(codigo_cola, sort = TRUE)%>% head(6)

# A tibble: 6 x 2
  codigo_cola     n
  <chr>       <int>
1 <NA>         2512
2 N725MQ        575
3 N722MQ        513
4 N723MQ        507
5 N713MQ        483
6 N735MQ        396

Operaciones de conjuntos

Tratan las observaciones como elementos de un conjunto.

• intersect(x, y): devuelve las observaciones comunes en x e y.

• union(x, y): devuelve las observaciones únicas en x e y.

• setdiff(x, y): devuelve las observaciones en x pero no en y.

Ejemplo:

df1 <- tribble(
  ~x, ~y,
  1, 1,
  2, 1
)
df2 <- tribble(
  ~x, ~y,
  1, 1,
  1, 2
)

Operaciones de conjuntos

Las cuatro posibilidades son:

intersect(df1, df2)

# A tibble: 1 x 2
      x     y
  <dbl> <dbl>
1     1     1

union(df1, df2)

# A tibble: 3 x 2
      x     y
  <dbl> <dbl>
1     1     1
2     2     1
3     1     2

Operaciones de conjuntos

setdiff(df1, df2)

# A tibble: 1 x 2
      x     y
  <dbl> <dbl>
1     2     1

setdiff(df2, df1)

# A tibble: 1 x 2
      x     y
  <dbl> <dbl>
1     1     2

Tabla Superhéroes

superheroes <- tibble::tribble(
       ~name, ~alignment,  ~gender,          ~publisher,
   "Magneto",      "bad",   "male",            "Marvel",
     "Storm",     "good", "female",            "Marvel",
  "Mystique",      "bad", "female",            "Marvel",
    "Batman",     "good",   "male",                "DC",
     "Joker",      "bad",   "male",                "DC",
  "Catwoman",      "bad", "female",                "DC",
   "Hellboy",     "good",   "male", "Dark Horse Comics"
  )

Tabla editoriales

publishers <- tibble::tribble(
  ~publisher, ~yr_founded,
        "DC",       1934L,
    "Marvel",       1939L,
     "Image",       1992L
  )

inner_join(superheroes, publishers)

tabla_inner <- superheroes %>% inner_join (publishers)

full_join(superheroes, publishers)

tabla_full <- superheroes %>% full_join (publishers)

left_join(superheroes, publishers)

tabla_left <-superheroes %>% left_join (publishers)

anti_join(superheroes, publishers)

tabla_anti <- superheroes %>% anti_join (publishers)

Fuentes:

• R para Ciencia de datos

• Primers de Rstudio

• Guía de referencia

• Slides de Robust tools de Danielle Navarro.

• STAT 545 - Chapter 15 de Jenny Bryan

➡️ Las slides fueron creadas con el paquete de R xaringan, utilizando el css propio summer_light.

➡️ Las imágenes fueron tomadas de Unplash.