Como formatar um número como porcentagem em R?

Uma das coisas que costumava me deixar perplexo como um novato em R era como formatar um número como uma porcentagem para impressão.

Por exemplo, exiba 0.12345como 12.345%. Eu tenho várias soluções alternativas para isso, mas nenhuma delas parece ser "newby friendly". Por exemplo:

set.seed(1)
m <- runif(5)

paste(round(100*m, 2), "%", sep="")
[1] "26.55%" "37.21%" "57.29%" "90.82%" "20.17%"

sprintf("%1.2f%%", 100*m)
[1] "26.55%" "37.21%" "57.29%" "90.82%" "20.17%"

Pergunta: Existe uma função R básica para fazer isso? Como alternativa, existe um pacote amplamente usado que fornece um invólucro conveniente?

Apesar de procurar algo assim em ?format, ?formatCe ?prettyNum, ainda não encontrei um invólucro adequadamente conveniente na base R. ??"percent"não produziu nada de útil. library(sos); findFn("format percent")retorna 1250 hits - mais uma vez não é útil. ggplot2tem uma função, percentmas isso não dá controle sobre a precisão do arredondamento.

Mais tarde:

Como apontado por @DzimitryM, percent()foi "aposentado" em favor de label_percent(), que é um sinônimo para a percent_format()função antiga .

label_percent() retorna uma função; portanto, para usá-la, você precisa de um par extra de parênteses.

library(scales)
x <- c(-1, 0, 0.1, 0.555555, 1, 100)
label_percent()(x)
## [1] "-100%"   "0%"      "10%"     "56%"     "100%"    "10 000%"

Personalize isso adicionando argumentos dentro do primeiro conjunto de parênteses.

label_percent(big.mark = ",", suffix = " percent")(x)
## [1] "-100 percent"   "0 percent"      "10 percent"    
## [4] "56 percent"     "100 percent"    "10,000 percent"

Uma atualização, vários anos depois:

Atualmente, há uma percentfunção no scalespacote, conforme documentado na resposta do krlmlr. Use isso em vez da minha solução enrolada à mão.

Tente algo como

percent <- function(x, digits = 2, format = "f", ...) {
  paste0(formatC(100 * x, format = format, digits = digits, ...), "%")
}

Com o uso, por exemplo,

x <- c(-1, 0, 0.1, 0.555555, 1, 100)
percent(x)

(Se preferir, altere o formato de "f"para "g".)

Confira o scalespacote. Costumava fazer parte ggplot2, eu acho.

library('scales')
percent((1:10) / 100)
#  [1] "1%"  "2%"  "3%"  "4%"  "5%"  "6%"  "7%"  "8%"  "9%"  "10%"

A lógica interna para detectar a precisão deve funcionar bem o suficiente para a maioria dos casos.

percent((1:10) / 1000)
#  [1] "0.1%" "0.2%" "0.3%" "0.4%" "0.5%" "0.6%" "0.7%" "0.8%" "0.9%" "1.0%"
percent((1:10) / 100000)
#  [1] "0.001%" "0.002%" "0.003%" "0.004%" "0.005%" "0.006%" "0.007%" "0.008%"
#  [9] "0.009%" "0.010%"
percent(sqrt(seq(0, 1, by=0.1)))
#  [1] "0%"   "32%"  "45%"  "55%"  "63%"  "71%"  "77%"  "84%"  "89%"  "95%" 
# [11] "100%"
percent(seq(0, 0.1, by=0.01) ** 2)
#  [1] "0.00%" "0.01%" "0.04%" "0.09%" "0.16%" "0.25%" "0.36%" "0.49%" "0.64%"
# [10] "0.81%" "1.00%"

Confira a percentfunção do formattablepacote:

library(formattable)
x <- c(0.23, 0.95, 0.3)
percent(x)
[1] 23.00% 95.00% 30.00%

Fiz alguns testes comparativos para acelerar essas respostas e fiquei surpreso ao ver percento scalespacote tão elogiado, dada a sua lentidão. Imagino que a vantagem seja seu detector automático para uma formatação adequada, mas se você souber como seus dados parecem, parece claro que deve ser evitado.

Aqui estão os resultados da tentativa de formatar uma lista de 100.000 porcentagens em (0,1) para uma porcentagem em 2 dígitos:

library(microbenchmark)
x = runif(1e5)
microbenchmark(times = 100L, andrie1(), andrie2(), richie(), krlmlr())
# Unit: milliseconds
#   expr       min        lq      mean    median        uq       max
# 1 andrie1()  91.08811  95.51952  99.54368  97.39548 102.75665 126.54918 #paste(round())
# 2 andrie2()  43.75678  45.56284  49.20919  47.42042  51.23483  69.10444 #sprintf()
# 3  richie()  79.35606  82.30379  87.29905  84.47743  90.38425 112.22889 #paste(formatC())
# 4  krlmlr() 243.19699 267.74435 304.16202 280.28878 311.41978 534.55904 #scales::percent()

Assim, sprintfsurge como um vencedor claro quando queremos adicionar um sinal de porcentagem. Por outro lado, se apenas queremos multiplicar o número e a ronda (passe de proporção para porcentagem sem "%", então round()é mais rápido:

# Unit: milliseconds
#        expr      min        lq      mean    median        uq       max
# 1 andrie1()  4.43576  4.514349  4.583014  4.547911  4.640199  4.939159 # round()
# 2 andrie2() 42.26545 42.462963 43.229595 42.960719 43.642912 47.344517 # sprintf()
# 3  richie() 64.99420 65.872592 67.480730 66.731730 67.950658 96.722691 # formatC()

Você pode usar o pacote de escalas apenas para esta operação (sem carregá-lo com require ou library)

scales::percent(m)

Aqui está minha solução para definir uma nova função (principalmente para que eu possa brincar com Curry e Compose :-)):

library(roxygen)
printpct <- Compose(function(x) x*100, Curry(sprintf,fmt="%1.2f%%"))

Vendo como scalable::percentjá havia se mostrado mais lento e Liliana Pacheco oferecendo outra solução, fui em frente e tentei compará-lo com algumas das outras opções com base no exemplo de Michael:

library(microbenchmark)
library(scales)
library(formattable)

x<-runif(1e5)

lilip <- function() formattable::percent(x,2)
krlmlr <- function() scales::percent(x)
andrie1 <- function() paste0(round(x,4) * 100, '%')

microbenchmark(times=100L,lilip(), krlmlr(), andrie1())

Estes são os resultados que obtive:

Unit: microseconds
      expr        min          lq        mean      median          uq        max neval
   lilip()    194.562    373.7335    772.5663    889.7045    950.4035   1611.537   100
  krlmlr() 226270.845 237985.6560 260194.9269 251581.0235 280704.2320 373022.180   100
 andrie1()  87916.021  90437.4820  92791.8923  92636.8420  94448.7040 102543.252   100

Eu não tenho idéia, porém, por que o meu krlmlr()e andrie1()realizada de modo muito pior do que no exemplo de MichaelChirico. Alguma pista?

try this~

data_format <- function(data,digit=2,type='%'){
if(type=='d') {
    type = 'f';
    digit = 0;
}
switch(type,
    '%' = {format <- paste("%.", digit, "f%", type, sep='');num <- 100},
    'f' = {format <- paste("%.", digit, type, sep='');num <- 1},
    cat(type, "is not a recognized type\n")
)
sprintf(format, num * data)
}

Esta função pode transformar os dados em porcentagens por colunas

percent.colmns = function(base, columnas = 1:ncol(base), filas = 1:nrow(base)){
    base2 = base
    for(j in columnas){
        suma.c = sum(base[,j])
        for(i in filas){
            base2[i,j] = base[i,j]*100/suma.c
        }
    }
    return(base2)
}

A tidyverseversão é esta:

> library(tidyverse)

> set.seed(1)
> m <- runif(5)
> dt <- as.data.frame(m)

> dt %>% mutate(perc=scales::percent(m,accuracy=0.001))
          m    perc
1 0.2655087 26.551%
2 0.3721239 37.212%
3 0.5728534 57.285%
4 0.9082078 90.821%
5 0.2016819 20.168%

Parece arrumado, como de costume.