plots - Zip o enumerar en R?

text in r

Question

¿Cuáles son los equivalentes R para estas listas de comprensión de Python?

[(i,j) for i,j in zip(index, Values)]
[(i,j) for i,j in enumerate(Values)]
[(i,j) for i,j in enumerate(range(10,20))]   %MWE, indexing or enumerating to 
                                            %keep up with the index, there may 
                                            %be some parameter to look this up

Ejemplo con salida

>>> [(i,j) for i,j in enumerate(range(10,20))]
[(0, 10), (1, 11), (2, 12), (3, 13), (4, 14), (5, 15), (6, 16), (7, 17), (8, 18), (9, 19)]

He resuelto este problema anteriormente con un truco en R pero ya no recuerdo, la primera idea fue itertools -pkg, pero espero encontrar una manera más idiomática de hacer las cosas.

Answer 1

Ha habido algunas discusiones sobre la comprensión de la lista para R, por ejemplo, here o there . El paquete hash incluso ofrece una estructura tipo diccionario. Sin embargo, como otros dijeron, es difícil tratar de asignar las instalaciones de un idioma a otro (incluso si esto es lo que realmente ofrece la comparación de los lenguajes de programación ) sin una comprensión clara de a qué se supone que debe estar acostumbrado. Por ejemplo, puedo imitar Python zip() en R de la siguiente manera:

Pitón

In [1]: x = [1,2,3]
In [2]: y = [4,5,6]
In [3]: zip(x, y)
Out[3]: [(1, 4), (2, 5), (3, 6)]

R

> x <- 1:3
> y <- 4:6
> list(x, y)                     # gives a simple list
> as.list(paste(x, y))           # three tuples, as a list of characters
> mapply(list, x, y, SIMPLIFY=F) # gives a list of 3 tuples
> rbind(x, y)                    # gives a 2x3 matrix 

Como se puede ver, esto realmente depende de lo que quieras hacer con el resultado después.

Answer 2

Respuesta para enumerate python:

En R, se ordena una lista (ver esta respuesta ). Por lo tanto, todo lo que necesita es indexar cualquiera de las teclas (usando names()[i] ) o valores (usando [[i]] ).

Usar seq_along (alternativamente puede hacer for(i in 1:length(mylist)){...} ):

> mylist <- list(''a''=10,''b''=20,''c''=30)
> for (i in seq_along(mylist)){
+   print(paste(i,names(mylist)[i],mylist[[i]]))
+ }
[1] "1 a 10"
[1] "2 b 20"
[1] "3 c 30"

Respuesta para python zip :

Vea una de las respuestas anteriores para imitar la lista de tuplas. Mi preferencia es hacia un marco de datos como se muestra en la respuesta de BondedDust:

> x <- 1:3
> y <- 4:6
> data.frame(x=x, y=y)
  x y
1 1 4
2 2 5
3 3 6

Answer 3

Si esa es la representación de impresión de Python de una matriz, entonces este código:

j <- 10:20
matrix(c(seq_along(j), j), ncol=2)
#------------
      [,1] [,2]
 [1,]    1   10
 [2,]    2   11
 [3,]    3   12
 [4,]    4   13
 [5,]    5   14
 [6,]    6   15
 [7,]    7   16
 [8,]    8   17
 [9,]    9   18
[10,]   10   19
[11,]   11   20

Todavía estamos dejando a aquellos de nosotros que no somos usuarios de Python en la oscuridad con respecto a la estructura de su salida deseada. Utiliza el término "lista" pero el resultado sugiere un conjunto ordenado de tuplas.

Dada la orientación de @ chi, también podríamos sugerir el uso de la estructura de "dataframe" muy centrada en R

x <- 1:3
y <- 4:6
dfrm <- data.frame(x=x, y=y)

... que tiene la flexibilidad de una lista en términos de tipos de columnas y las características de acceso de una matriz en términos de indexación de filas y columnas. O uno podría usar la solicitud de hhh y crear los valores indexados implícitamente del vector j, 10:20 , usando el vector de rownames que comienza en "1" por defecto, pero que podría ser alterado para convertirse en un vector de caracteres comenzando en "0"

dfrm <- data.frame(j=10:20)
dfrm[3, ]
#[1] 12

 rownames(dfrm) <- 0:10
 dfrm["0",]
# [1] 10

Desafortunadamente, el incauto encontrará que dfrm [0,] no es una llamada feliz, devolviendo el vector de longitud 0.

Answer 4

# similar to python. return a list of list. Short sequences get recycled.
zip <- function(...){ 
    all.list <- list(...)
    ele.names <- names(all.list)
    max.length <- max(sapply(all.list, length))
    lapply(0:(max.length - 1), function(i) {
        res <- lapply(all.list, function(l) l[i %% length(l) + 1]) 
        names(res) <- ele.names
        res
    })
}