Bienvenido, soy Luis y aquí les traigo este nuevo post.
Índice
- 1 Una guía práctica para usar funciones de matriz
- 2 Configuración
- 3 Ver esquema
- 4 Funciones de matriz
- 4.1 array_contains
- 4.2 array_distinct
- 4.3 array_except
- 4.4 array_intersect
- 4.5 array_join
- 4.6 array_max
- 4.7 array_min
- 4.8 array_position
- 4.9 array_remove
- 4.10 array_repeat
- 4.11 array_sort
- 4.12 matriz_union
- 4.13 arrays_overlap
- 4.14 arrays_zip
- 4.15 concat
- 4.16 element_at
- 4.17 aplanar
- 4.18 map_from_arrays
- 4.19 reverse
- 4.20 barajar
- 4.21 size
- 4.22 slice
- 4.23 sort_array
- 4.24 explode
- 4.25 posexplode
- 5 Referencia
Una guía práctica para usar funciones de matriz
En esta publicación, aprenderemos sobre las funciones de matriz de Apache Spark utilizando ejemplos que muestran cómo funciona cada función.
A tener en cuenta: los ejemplos que siguen utilizan la API de Scala. Para su fácil referencia, un cuaderno Zeppelin exportado como un archivo JSON y también un archivo Scala están disponibles en GitHub.
Configuración
Primero necesitamos importar las funciones que exploraremos en este blog.
Creemos algunos Spark DataFrames que usaremos para aprender sobre las diversas funciones de matriz.
Aquí hemos creado dos DataFrames df y full_df que contienen dos columnas y tres columnas respectivamente.
Ver esquema
Comprobemos el esquema del DataFrame anterior full_df
La salida muestra que col1 es cuerda tipo y array_col1 y array_col2 son formación tipo:
root |-- col1: string (nullable = true) |-- array_col1: array (nullable = true) | |-- element: integer (containsNull = true) |-- array_col2: array (nullable = true) | |-- element: integer (containsNull = true)
Del mismo modo para DataFramedf, el esquema se ve así:
root |-- col1: string (nullable = true) |-- array_col2: array (nullable = true) | |-- element: integer (containsNull = true)
En los ejemplos que siguen usaremos df para funciones que toman una sola matriz como entrada y df_full para funciones que toman dos matrices como entrada.
Funciones de matriz
array_contains
Si necesitamos encontrar un elemento en particular presente en la matriz, podemos usar array_contains función. Esta función devuelve verdadero si el valor está presente en la matriz y falso en caso contrario.
Salida:
+----+------------------+------+ |col1| array_col2|result| +----+------------------+------+ | x| [1, 2, 3, 7, 7]| true| | z|[3, 2, 8, 9, 4, 9]| true| | a| [4, 5, 2, 8]| false| +----+------------------+------+
Estamos buscando el valor ‘3’ en la columna de la matriz array_col2 y conseguir cierto para las dos primeras filas donde está presente ‘3’ y falso para la última columna porque ‘3’ no está presente.
array_distinct
Esta función devuelve solo valores distintos de una matriz y elimina los valores duplicados.
Salida:
+----+------------------+---------------+ |col1| array_col2| result| +----+------------------+---------------+ | x| [1, 2, 3, 7, 7]| [1, 2, 3, 7]| | z|[3, 2, 8, 9, 4, 9]|[3, 2, 8, 9, 4]| | a| [4, 5, 2, 8]| [4, 5, 2, 8]| +----+------------------+---------------+
Los valores duplicados se eliminaron y solo están presentes valores distintos de la columna de matriz result.
array_except
Esta función devuelve los elementos de la primera matriz que no están presentes en la segunda matriz. Esto es lógicamente equivalente a establecer una operación de resta .
Salida:
+----+------------------+------------------+---------+ |col1| array_col1| array_col2| result| +----+------------------+------------------+---------+ | x| [4, 6, 7, 9, 2]| [1, 2, 3, 7, 7]|[4, 6, 9]| | z|[7, 5, 1, 4, 7, 1]|[3, 2, 8, 9, 4, 9]|[7, 5, 1]| | a| [3, 8, 5, 3]| [4, 5, 2, 8]| [3]| +----+------------------+------------------+---------+
Columna result contiene elementos que solo están presentes en array_col1 pero no en array_col2. Por ejemplo, en la primera fila el result la columna contiene [4, 6, 9] porque estos elementos están presentes en array_col1 pero no en array_col2.
array_intersect
Esta función devuelve elementos comunes de ambas matrices. Esto es lógicamente equivalente a establecer la operación de intersección .
Salida:
+----+------------------+------------------+------+ |col1| array_col1| array_col2|result| +----+------------------+------------------+------+ | x| [4, 6, 7, 9, 2]| [1, 2, 3, 7, 7]|[7, 2]| | z|[7, 5, 1, 4, 7, 1]|[3, 2, 8, 9, 4, 9]| [4]| | a| [3, 8, 5, 3]| [4, 5, 2, 8]|[8, 5]| +----+------------------+------------------+------+
Columna result contiene los elementos que son comunes en ambas columnas de la matriz (array_col1 y array_col2). Por ejemplo, en la primera fila el result la columna contiene [7, 2] porque estos elementos están presentes en ambosarray_col1 y array_col2.
array_join
Esta función une todos los elementos de la matriz según el delimitador definido como segundo argumento.
Salida:
+----+------------------+-----------+ |col1| array_col2| result| +----+------------------+-----------+ | x| [1, 2, 3, 7, 7]| 1,2,3,7,7| | z|[3, 2, 8, 9, 4, 9]|3,2,8,9,4,9| | a| [4, 5, 2, 8]| 4,5,2,8| +----+------------------+-----------+
Columna result contiene una cadena que es una concatenación de todos los elementos de la matriz utilizando un delimitador especificado (coma en este ejemplo).
A tener en cuenta: si hay valores nulos, podemos reemplazarlos con un tercer argumento (nullReplacement) con cualquier valor de cadena.
array_max
Esta función devuelve el valor máximo de una matriz.
Salida:
+----+------------------+------+ |col1| array_col2|result| +----+------------------+------+ | x| [1, 2, 3, 7, 7]| 7| | z|[3, 2, 8, 9, 4, 9]| 9| | a| [4, 5, 2, 8]| 8| +----+------------------+------+
Columna result contiene el valor máximo de cada matriz en una fila. Por ejemplo, en la primera fila el result la columna contiene ‘7’ porque este es el elemento máximo en la matriz [1, 2, 3, 7, 7].
array_min
Esta función devuelve el valor mínimo de una matriz.
Salida:
+----+------------------+------+ |col1| array_col2|result| +----+------------------+------+ | x| [1, 2, 3, 7, 7]| 1| | z|[3, 2, 8, 9, 4, 9]| 2| | a| [4, 5, 2, 8]| 2| +----+------------------+------+
Columna result contiene el valor mínimo de cada matriz en una fila. Por ejemplo, en la primera fila el result la columna contiene ‘1’ porque este es el elemento mínimo en la matriz [1, 2, 3, 7, 7].
array_position
Esta función devuelve la posición de la primera aparición de un elemento especificado. Si el elemento no está presente, devuelve 0.
Intentemos encontrar la posición del elemento, digamos ‘7’ de la columna array_col2.
Salida:
+----+------------------+------+ |col1| array_col2|result| +----+------------------+------+ | x| [1, 2, 3, 7, 7]| 4| | z|[3, 2, 8, 9, 4, 9]| 0| | a| [4, 5, 2, 8]| 0| +----+------------------+------+
En la primera fila obtenemos la posición ‘4’ porque el ‘7’ aparece la primera vez en la posición cuatro. Para el resto de las filas, obtenemos ‘0’ porque ‘7’ no está presente.
array_remove
Esta función elimina todas las apariciones de un elemento de una matriz.
Eliminemos el elemento ‘7’ de la columna array_col2.
Salida:
+----+------------------+------------------+ |col1| array_col2| result| +----+------------------+------------------+ | x| [1, 2, 3, 7, 7]| [1, 2, 3]| | z|[3, 2, 8, 9, 4, 9]|[3, 2, 8, 9, 4, 9]| | a| [4, 5, 2, 8]| [4, 5, 2, 8]| +----+------------------+------------------+
Todas las apariciones del elemento ‘7’ se eliminan de la matriz.
array_repeat
Esta función crea una matriz que se repite según lo especificado por el segundo argumento.
Salida:
+----+------------------+----------------------------------------+ |col1|array_col2 |result | +----+------------------+----------------------------------------+ |x |[1, 2, 3, 7, 7] |[[1, 2, 3, 7, 7], [1, 2, 3, 7, 7]] | |z |[3, 2, 8, 9, 4, 9]|[[3, 2, 8, 9, 4, 9], [3, 2, 8, 9, 4, 9]]| |a |[4, 5, 2, 8] |[[4, 5, 2, 8], [4, 5, 2, 8]] | +----+------------------+----------------------------------------+
Matriz de array_col2 se repitió 2 veces en result columna. Por ejemplo, en la primera fila el result la columna contiene la matriz [1, 2, 3, 7, 7] dos veces.
array_sort
Esta función ordena los elementos de una matriz en orden ascendente.
Salida:
+----+------------------+------------------+ |col1| array_col2| result| +----+------------------+------------------+ | x| [1, 2, 3, 7, 7]| [1, 2, 3, 7, 7]| | z|[3, 2, 8, 9, 4, 9]|[2, 3, 4, 8, 9, 9]| | a| [4, 5, 2, 8]| [2, 4, 5, 8]| +----+------------------+------------------+
Matriz en columna result se ordenó en orden ascendente. Por ejemplo, en la última fila el resultado de la columna contiene [2, 4, 5, 8] que se clasifica en orden ascendente.
matriz_union
Esta función devuelve la unión de todos los elementos de las matrices de entrada.
Salida:
+------------------+------------------+------------------------+ |array_col1 |array_col2 |result | +------------------+------------------+------------------------+ |[4, 6, 7, 9, 2] |[1, 2, 3, 7, 7] |[4, 6, 7, 9, 2, 1, 3] | |[7, 5, 1, 4, 7, 1]|[3, 2, 8, 9, 4, 9]|[7, 5, 1, 4, 3, 2, 8, 9]| |[3, 8, 5, 3] |[4, 5, 2, 8] |[3, 8, 5, 4, 2] | +------------------+------------------+------------------------+
A tener en cuenta: dejó caer el col1 para ajustar el resultado aquí en el bloque de código.
Columna result contiene la unión de matrices de la columna array_col1 y array_col2 y contiene solo valores distintos.
arrays_overlap
Esta función comprueba si al menos un elemento es común / se superpone en las matrices. Devuelve verdadero si al menos un elemento es común en la matriz y falso en caso contrario. Devuelve nulo si al menos una de las matrices es nula.
Salida:
+----+------------------+------------------+------+ |col1|array_col1 |array_col2 |result| +----+------------------+------------------+------+ |x |[4, 6, 7, 9, 2] |[1, 2, 3, 7, 7] |true | |z |[7, 5, 1, 4, 7, 1]|[3, 2, 8, 9, 4, 9]|true | |a |[3, 8, 5, 3] |[4, 5, 2, 8] |true | +----+------------------+------------------+------+
Todos los valores en result columna son true porque tenemos al menos un elemento común en array_col1 y array_col2 para todas las filas. Por ejemplo, en la primera fila el result la columna es true porque los elementos ‘2’ y ‘7’ están presentes en ambas columnas array_col1 y array_col2.
arrays_zip
Esta función fusiona el elemento i-ésimo de una matriz y devuelve matriz .
Dado que ambas columnas de la matriz tienen el mismo número de valores, eliminemos algunos valores de una columna de la matriz y veamos cómo se comporta con diferentes valores en la matriz con la operación zip.
Primero, eliminaremos el elemento ‘2’ de la columna de la matriz array_col2 y luego intenta comprimir la columna array_col1 con columna recién creada new_array_col
Salida:
+------------------+---------------+-------------------------------+ |array_col1 |new_array_col |result | +------------------+---------------+-------------------------------+ |[4, 6, 7, 9, 2] |[1, 3, 7, 7] |[[4, 1], [6, 3] ..., [2,]] | |[7, 5, 1, 4, 7, 1]|[3, 8, 9, 4, 9]|[[7, 3], [5, 8] ..., [1,]] | |[3, 8, 5, 3] |[4, 5, 8] |[[3, 4], ... [3,]] | +------------------+---------------+-------------------------------+
En la primera fila, primer elemento de result la columna es [4, 1] que es un zip del primer elemento de la matriz array_col1 (4) y new_array_col (1). Además, el último elemento de result la columna es [2,] (que es un zip del quinto elemento) y el segundo valor está en blanco porque no hay un quinto elemento en la primera fila de la columna new_array_col.
Comprobemos el tipo de result columnas también.
Salida:
root |-- result: array (nullable = true) | |-- element: struct (containsNull = false) | | |-- array_col1: integer (nullable = true) | | |-- new_array_col: integer (nullable = true)
El tipo de columna de resultado es matriz .
concat
Esta función concatena todos los elementos de ambos arreglos en uno solo.
Salida:
+------------------+------------------+----------------------------+ |array_col1 |array_col2 |result | +------------------+------------------+----------------------------+ |[4, 6, 7, 9, 2] |[1, 2, 3, 7, 7] |[4, 6, 7, 9, ..., 3, 7, 7] | |[7, 5, 1, 4, 7, 1]|[3, 2, 8, 9, 4, 9]|[7, 5, 1, 4, ..., 9, 4, 9] | |[3, 8, 5, 3] |[4, 5, 2, 8] |[3, 8, 5, 3, 4, 5, 2, 8] | +------------------+------------------+----------------------------+
Columna result contiene la matriz que es una concatenación de matrices en columnas array_col1 y array_col2.
A tener en cuenta: Para ajustar la salida, eliminamos algunos elementos de result columna de la pantalla.
element_at
Esta función devuelve el elemento en un índice especificado.
Intentemos obtener el primer elemento de cada matriz.
Salida:
+----+------------------+------+ |col1|array_col2 |result| +----+------------------+------+ |x |[1, 2, 3, 7, 7] |1 | |z |[3, 2, 8, 9, 4, 9]|3 | |a |[4, 5, 2, 8] |4 | +----+------------------+------+
Columna result contiene el primer elemento de cada matriz. Por ejemplo, en la primera fila el result contiene ‘1’ porque este es el primer elemento de la matriz [1, 2, 3, 7, 7].
aplanar
Esta función devuelve una única matriz de una matriz de matrices. Si una matriz tiene más de 2 niveles de profundidad, elimina un nivel de anidación de una matriz.
Primero generemos la matriz anidada usando la función array_repeat como se discutió anteriormente y luego aplanar la matriz anidada.
Salida:
+-----------------------------------+------------------------------+ |repeat |result | +-----------------------------------+------------------------------+ |[[1, 2, 3, 7, 7], [1, 2, 3, 7, 7]] |[1, 2, 3, 7, 7, 1, 2, 3, 7, 7]| |[[3, 2, 8, 9, 4], [3, 2, 8, 9, 4]] |[3, 2, 8, 9, 4, 3, 2, 8, 9, 4]| |[[4, 5, 2, 8], [4, 5, 2, 8]] |[4, 5, 2, 8, 4, 5, 2, 8] | +----------------------------------------+-------------------------+
Columna result contiene todos los valores de una matriz de matrices de la columna repeat pero en una sola matriz.
map_from_arrays
Esta función crea una columna de mapa. Los elementos de la primera columna se utilizarán para las claves y la segunda columna se utilizará para los valores.
Salida:
+ ------------------ + ------------------ + ----------- --------- + | array_col1 | array_col2 | resultado | + ------------------ + ------------------ + ----------- --------- + | [4, 6, 7, 9, 2]| [1, 2, 3, 7, 7]|[4 -> 1, 6 -> 2, ...| |[7, 5, 1, 4, 7, 1]|[3, 2, 8, 9, 4, 9]|[7 -> 3, 5 -> 2, ...| | [3, 8, 5, 3]| [4, 5, 2, 8]|[3 -> 4, 8 -> 5, ...| +------------------+------------------+--------------------+
La columna resultcontiene el mapa generado a partir de ambas matrices de entrada. El primer elemento en la primera fila es 4 -> 1donde ‘4’ es una clave que es el primer elemento de la primera columna array_col1y ‘1’ es el valor de la clave que es el primer elemento de la segunda columna array_col2.
reverse
Esta función invierte el orden de los elementos en la matriz de entrada.
Salida:
+----+------------------+------------------+ |col1| array_col2| result| +----+------------------+------------------+ | x| [1, 2, 3, 7, 7]| [7, 7, 3, 2, 1]| | z |[3, 2, 8, 9, 4, 9]|[9, 4, 9, 8, 2, 3]| | a | [4, 5, 2, 8]| [8, 2, 5, 4]| + ---- + ------------------ + ------------------ +
Columna result contiene el reverso de la matriz presente en la columna array_col2. Por ejemplo, en la primera fila, result contiene [7, 7, 3, 2, 1] que es el reverso de la matriz [1, 2, 3, 7, 7] de la columna aray_col2 .
barajar
Esta función baraja los elementos de la matriz de forma aleatoria.
Salida:
+----+------------------+------------------+ |col1| array_col2| result| +----+------------------+------------------+ | x| [1, 2, 3, 7, 7]| [2, 7, 1, 7, 3]| | z|[3, 2, 8, 9, 4, 9]|[3, 8, 9, 4, 9, 2]| | a| [4, 5, 2, 8]| [8, 4, 2, 5]| +----+------------------+------------------+
Columna result contiene elementos mezclados de la columna array_col2. En otras palabras, el orden de los elementos en result la columna es aleatoria. Por ejemplo, en la primera fila el result la columna contiene [2, 7, 1, 7, 3] que es la salida aleatoria de array [1, 2, 3, 7, 7] de la columna array_col2.
A tener en cuenta: intente ejecutar la función de reproducción aleatoria varias veces. El orden de valores en el result La columna será diferente para cada ejecución.
size
Esta función devuelve varios elementos en una matriz o mapa.
Salida:
+----+------------------+------+ |col1| array_col2|result| +----+------------------+------+ | x| [1, 2, 3, 7, 7]| 5| | z|[3, 2, 8, 9, 4, 9]| 6| | a| [4, 5, 2, 8]| 4| +----+------------------+------+
Columna result contiene el tamaño (número de elementos) de una matriz en la columna array_col2. Por ejemplo, en la primera fila el result columna contiene ‘5’ porque el número de elementos en [1, 2, 3, 7, 7] es 5.
slice
Esta función divide la matriz en una submatriz. Podemos especificar el inicio del índice como segundo argumento y el número de elementos como tercer argumento.
A tener en cuenta: Las matrices en Spark comienzan con el índice 1. También admite la indexación negativa para acceder a los elementos del último.
Intentemos crear una submatriz de 3 elementos a partir del índice 2.
Salida:
+----+------------------+---------+ |col1| array_col2| result| +----+------------------+---------+ | x| [1, 2, 3, 7, 7]|[2, 3, 7]| | z|[3, 2, 8, 9, 4, 9]|[2, 8, 9]| | a| [4, 5, 2, 8]|[5, 2, 8]| +----+------------------+---------+
En primera fila result contiene submatriz [2, 3, 7] que se crea con 3 elementos del índice 2 en [1, 2, 3, 7, 7].
sort_array
Esta función ordena la matriz en orden ascendente de forma predeterminada. Sin embargo, podemos ordenar en orden descendente con el segundo argumento como asc=false.
Salida:
+----+------------------+------------------+ |col1| array_col2| result| +----+------------------+------------------+ | x| [1, 2, 3, 7, 7]| [7, 7, 3, 2, 1]| | z|[3, 2, 8, 9, 4, 9]|[9, 9, 8, 4, 3, 2]| | a| [4, 5, 2, 8]| [8, 5, 4, 2]| +----+------------------+------------------+
Columna result se ordena en orden descendente. Por ejemplo, en la primera fila el result la columna contiene [7, 7, 3, 2, 1] que es el resultado ordenado descendente de la matriz[1, 2, 3, 7, 7] de la columna array_col2 .
explode
Esta función crea una nueva fila para cada elemento de una matriz o mapa.
Primero creemos una nueva columna con menos valores para explotar.
Salida:
+----+---------+ |col1|slice_col| +----+---------+ | x| [1, 2]| | z| [3, 2]| | a| [4, 5]| +----+---------+
slice_col contiene 2 elementos en una matriz. Entonces, al explotar, esto genera 2 filas para cada matriz.
Ahora intentemos explotar la columna slice_col.
Salida:
+----+---------+------+ |col1|slice_col|result| +----+---------+------+ | x| [1, 2]| 1| | x| [1, 2]| 2| | z| [3, 2]| 3| | z| [3, 2]| 2| | a| [4, 5]| 4| | a| [4, 5]| 5| +----+---------+------+
Al explotar, se generan 2 filas para cada elemento de una matriz en la columna slice_col.
posexplode
Esta función crea una nueva fila para cada elemento con la posición de una matriz o mapa.
Primero creemos una nueva columna con menos valores para explotar.
Ahora intentemos explotar el slice_col con un puesto también.
Salida:
+----+---------+---+---+ |col1|slice_col|pos|col| +----+---------+---+---+ |x |[1, 2] |0 |1 | |x |[1, 2] |1 |2 | |z |[3, 2] |0 |3 | |z |[3, 2] |1 |2 | |a |[4, 5] |0 |4 | |a |[4, 5] |1 |5 | +----+---------+---+---+
Aquí se generaron 2 columnas más como pos (representar posición) y col (representar el valor del elemento).
Espero que haya disfrutado aprendiendo a trabajar con varias funciones de Array en Apache Spark. Para una fácil referencia, un cuaderno que contiene los ejemplos anteriores está disponible en GitHub.
Referencia
Añadir comentario