Comment accéder à la dernière valeur d'un vecteur?

Supposons que j'ai un vecteur qui est imbriqué dans un dataframe un ou deux niveaux. Est-il une façon rapide et sale pour accéder à la dernière valeur, sans l'aide de la length() fonction? Quelque chose ala PERL $# spécial var?

Donc je voudrais quelque chose comme:

dat$vec1$vec2[$#]

au lieu de

dat$vec1$vec2[length(dat$vec1$vec2)]
InformationsquelleAutor user14008 | 2008-09-16
  1. 346

    - Je utiliser le tail fonction:

    tail(vector, n=1)

    La bonne chose avec tail est qu'il fonctionne sur dataframes trop, contrairement à la x[length(x)] idiome.

    • cependant x[longueur(x[,1]),] travaille sur dataframes ou x[dim(x)[1],]
    • Notez que pour des trames de données, la longueur(x) == ncol(x) donc c'est absolument faux, et dim(x)[1] peuvent plus descriptive être écrit nrow(x).
    • kpierce8 la suggestion de x[length(x[,1]),] est pas mal (notez la virgule dans le x sous-ensemble), mais il est certainement difficile.
    • Veuillez noter que mon indice de référence ci-dessous montre pour être plus lent que x[length(x)] par un facteur de 30 en moyenne pour les plus grands vecteurs!
    • Ne fonctionne pas si vous voulez ajouter des trucs à partir de vecteurs si tail(vector, n=1)-tail(vector, n=2)
    • Si vous souhaitez réaffecter les names d'un data.frame, tail malheureusement, ne fonctionne pas: df %>% names() %>% tail(n=1) %>% assign("Foo") quitte le colnames inchangé.

    InformationsquelleAutor lindelof
  2. 151

    De répondre ce n'est pas de l'esthétique mais orientés vers la performance de point de vue, j'ai mis toutes les suggestions ci-dessus par le biais d'un de référence. Pour être précis, j'ai examiné les suggestions

    • x[length(x)]
    • mylast(x), où mylast est une fonction C++ mis en œuvre par le biais de Rcpp,
    • tail(x, n=1)
    • dplyr::last(x)
    • x[end(x)[1]]]
    • rev(x)[1]

    et de les appliquer à des vecteurs aléatoires de différentes tailles (10^3, 10^4, 10^5, 10^6, et 10^7). Avant de nous pencher sur les chiffres, je pense qu'il devrait être clair que tout ce qui devient beaucoup plus lent, avec une plus grande taille d'entrée (c'est à dire, tout ce qui est en O(1)) n'est pas une option. Voici le code que j'ai utilisé:

    Rcpp::cppFunction('double mylast(NumericVector x) { int n = x.size(); return x[n-1]; }')
options(width=100)
for (n in c(1e3,1e4,1e5,1e6,1e7)) {
  x <- runif(n);
  print(microbenchmark::microbenchmark(x[length(x)],
                                       mylast(x),
                                       tail(x, n=1),
                                       dplyr::last(x),
                                       x[end(x)[1]],
                                       rev(x)[1]))}

    Il me donne

    Unit: nanoseconds
expr   min      lq     mean  median      uq   max neval
x[length(x)]   171   291.5   388.91   337.5   390.0  3233   100
mylast(x)  1291  1832.0  2329.11  2063.0  2276.0 19053   100
tail(x, n = 1)  7718  9589.5 11236.27 10683.0 12149.0 32711   100
dplyr::last(x) 16341 19049.5 22080.23 21673.0 23485.5 70047   100
x[end(x)[1]]  7688 10434.0 13288.05 11889.5 13166.5 78536   100
rev(x)[1]  7829  8951.5 10995.59  9883.0 10890.0 45763   100
Unit: nanoseconds
expr   min      lq     mean  median      uq    max neval
x[length(x)]   204   323.0   475.76   386.5   459.5   6029   100
mylast(x)  1469  2102.5  2708.50  2462.0  2995.0   9723   100
tail(x, n = 1)  7671  9504.5 12470.82 10986.5 12748.0  62320   100
dplyr::last(x) 15703 19933.5 26352.66 22469.5 25356.5 126314   100
x[end(x)[1]] 13766 18800.5 27137.17 21677.5 26207.5  95982   100
rev(x)[1] 52785 58624.0 78640.93 60213.0 72778.0 851113   100
Unit: nanoseconds
expr     min        lq       mean    median        uq     max neval
x[length(x)]     214     346.0     583.40     529.5     720.0    1512   100
mylast(x)    1393    2126.0    4872.60    4905.5    7338.0    9806   100
tail(x, n = 1)    8343   10384.0   19558.05   18121.0   25417.0   69608   100
dplyr::last(x)   16065   22960.0   36671.13   37212.0   48071.5   75946   100
x[end(x)[1]]  360176  404965.5  432528.84  424798.0  450996.0  710501   100
rev(x)[1] 1060547 1140149.0 1189297.38 1180997.5 1225849.0 1383479   100
Unit: nanoseconds
expr     min        lq        mean    median         uq      max neval
x[length(x)]     327     584.0     1150.75     996.5     1652.5     3974   100
mylast(x)    2060    3128.5     7541.51    8899.0     9958.0    16175   100
tail(x, n = 1)   10484   16936.0    30250.11   34030.0    39355.0    52689   100
dplyr::last(x)   19133   47444.5    55280.09   61205.5    66312.5   105851   100
x[end(x)[1]] 1110956 2298408.0  3670360.45 2334753.0  4475915.0 19235341   100
rev(x)[1] 6536063 7969103.0 11004418.46 9973664.5 12340089.5 28447454   100
Unit: nanoseconds
expr      min         lq         mean      median          uq       max neval
x[length(x)]      327      722.0      1644.16      1133.5      2055.5     13724   100
mylast(x)     1962     3727.5      9578.21      9951.5     12887.5     41773   100
tail(x, n = 1)     9829    21038.0     36623.67     43710.0     48883.0     66289   100
dplyr::last(x)    21832    35269.0     60523.40     63726.0     75539.5    200064   100
x[end(x)[1]] 21008128 23004594.5  37356132.43  30006737.0  47839917.0 105430564   100
rev(x)[1] 74317382 92985054.0 108618154.55 102328667.5 112443834.0 187925942   100

    Immédiatement les règles en ce qui concerne la rev ou end car ils sont clairement pas O(1) (et les expressions sont évaluées dans un non-paresseux de la mode). tail et dplyr::last ne sont pas loin d'être O(1) mais ils sont aussi beaucoup plus lent que mylast(x) et x[length(x)]. Depuis mylast(x) est plus lent que x[length(x)] et ne fournit pas de prestations (au contraire, il est personnalisé et ne gère pas un vecteur vide normalement), je pense que la réponse est claire: Veuillez utiliser x[length(x)].

    • ^ O(1) des solutions devraient être la seule réponse acceptable à cette question.
    • Merci pour le calendrier de tous ceux anon +1!
    • J'ai essayé mylastR=function(x) {x[length(x)} Il est plus rapide que mylast dans Rcpp, mais un temps plus lent que d'écrire x[length(x)] directement
    InformationsquelleAutor anonymous
  3. 109

    Si vous êtes à la recherche de quelque chose d'aussi beau que Python x de[-1] la notation, je pense que vous êtes hors de la chance. La norme de l'idiome est

    x[length(x)]

    mais il est assez facile d'écrire une fonction pour faire cela:

    last <- function(x) { return( x[length(x)] ) }

    Cette fonctionnalité manquante dans la R m'énerve trop!

    • belle idée d'offrir un exemple de fonction +1
    InformationsquelleAutor Gregg Lind
  4. 44

    Combinant lindelof du et Gregg Lind est idées:

    last <- function(x) { tail(x, n = 1) }

    De travail à l'invite de commandes, j'ai l'habitude d'omettre l' n=, c'est à dire tail(x, 1).

    Contrairement à last de la pastecs paquet, head et tail (à partir de utils) de travailler non seulement sur les vecteurs mais aussi sur des trames de données, etc., et aussi peut retourner des données "sans premier/dernier n éléments", par exemple 

    but.last <- function(x) { head(x, n = -1) }

    (Notez que vous devez utiliser head pour cela, au lieu de tail.)

    • Veuillez noter que mon indice de référence ci-dessous montre pour être plus lent que x[length(x)] par un facteur de 30 en moyenne pour les plus grands vecteurs!
    InformationsquelleAutor Florian Jenn
  5. 18

    La dplyr package inclut une fonction last():

    last(mtcars$mpg)
# [1] 21.4
    • En fait cela revient à x[[length(x)]] de nouveau.
    • Similaire sous le capot, mais avec cette réponse vous n'avez pas à écrire votre propre fonction last() et stocker cette fonction quelque part, comme plusieurs personnes l'ont fait ci-dessus. Vous obtenez l'amélioration de la lisibilité d'une fonction, avec la portabilité de venir de CRAN, de sorte que quelqu'un d'autre peut exécuter le code.
    • Peut aussi écrire que mtcars$mpg %>% last, selon vos préférences.
    • Malheureusement, il est nettement plus lent que x[[length(x)]], si!
    InformationsquelleAutor Sam Firke
  6. 17

    J'ai juste comparé ces deux approches sur des données de trame avec 663,552 lignes en utilisant le code suivant:

    system.time(
resultsByLevel$subject <- sapply(resultsByLevel$variable, function(x) {
s <- strsplit(x, ".", fixed=TRUE)[[1]]
s[length(s)]
})
)
user  system elapsed 
3.722   0.000   3.594

    et

    system.time(
resultsByLevel$subject <- sapply(resultsByLevel$variable, function(x) {
s <- strsplit(x, ".", fixed=TRUE)[[1]]
tail(s, n=1)
})
)
user  system elapsed 
28.174   0.000  27.662

    Donc, en supposant que vous travaillez avec des vecteurs, en accédant à la longueur de position est nettement plus rapide.

    • Pourquoi ne pas tester tail(strsplit(x,".",fixed=T)[[1]],1) pour le 2ème cas? Pour moi, le principal avantage de la tail est que vous pouvez l'écrire en une seule ligne. 😉
    InformationsquelleAutor scuerda
  7. 12

    Une autre façon est de prendre le premier élément de l'inversion de l'vecteur:

    rev(dat$vect1$vec2)[1]
    • Ce sera cher si!
    • Veuillez noter que ceci est une opération dont le coût de calcul est linéaire en la longueur de l'entrée; en d'autres termes, tout en O(n), il n'est pas O(1). Voir aussi ma référence ci-dessous pour les nombres réels.
    • À moins d'utiliser un itérateur
    • La droite. Mais dans ce cas, votre code ne fonctionne pas, serait-il? Si par itérateur vous dire ce qui est fourni par les itérateurs paquet, (1) vous ne pouvez pas utiliser [1] pour accéder au premier élément et (2), tandis que vous pouvez appliquer rev à un itérateur, il ne se comporte pas comme prévu: il traite de l'itérateur de l'objet en tant que liste de ses membres et renverse que des.
    InformationsquelleAutor James
  8. 10

    Paquet data.table comprend last fonction

    library(data.table)
last(c(1:10))
# [1] 10
    • En fait cela revient à x[[length(x)]] de nouveau.
    InformationsquelleAutor Enrique Pérez Herrero
  9. 9

    J'ai une autre méthode pour trouver le dernier élément dans un vecteur.
    Dire que le vecteur est a.

    > a<-c(1:100,555)
> end(a)      #Gives indices of last and first positions
[1] 101   1
> a[end(a)[1]]   #Gives last element in a vector
[1] 555

    Là vous allez!

    InformationsquelleAutor Akash
  10. 7

    Whats sur

    > a <- c(1:100,555)
> a[NROW(a)]
[1] 555
    • J'apprécie que NROW est-ce que vous attendez sur un beaucoup de différents types de données, mais c'est essentiellement le même que a[length(a)] que l'OP est dans l'espoir d'éviter. À l'aide de l'OP de l'exemple d'un vecteur imbriqué, dat$vec1$vec2[NROW(dat$vec1$vec2)] est toujours assez compliqué.
    • peut être écrite comme nrow
    • Remarque: Contrairement à nrow, NROW traite un vecteur tel que 1-colonne de la matrice.
    InformationsquelleAutor Kurt Ludikovsky
  11. 2

    La xts paquet fournit un last fonction:

    library(xts)
a <- 1:100
last(a)
[1] 100
    InformationsquelleAutor smoff