[[bot89:precurso:1textfun:inicio]]

Funções para manipulação e busca de textos

  • paste() - concatena texto
?paste #veja o help dessa funcao
 
#um vetor de texto
txt = c("banana","maça","pera")
#outro vetor
txt2 = LETTERS[1:3]
#concatenamos os textos par a par
paste(txt,txt2)
#mudamos o separador
paste(txt,txt2,sep="-")
 
#imagine que queremos juntar os elementos de um vetor
#num único texto, separados por ";"
paste(txt,collapse = ';') 
  • strsplit() - quebra um texto segundo um separador
?strsplit
 
txt = "Este é um texto com várias palavras"
strsplit(txt,split = " ")
#note que este é um objeto de classe lista
#entao para pegar o vetor de palavras
pl = strsplit(txt,split = " ")[[1]]
pl
length(pl) #numero de palavras no texto
  • Um exemplo prático
#um dado qualquer
spp = c("Ocotea guianensis","Ocotea longifolia","Licaria tenuicarpa")
dap = c(10,20,30)
dd = data.frame(ESPECIE=spp,DAP=dap,stringsAsFactors = F)
dd
 
#suponha que você tenha um dado desse jeito e queira separar genero de especie
 
#criamos um funcao
peganome <- function(x,qual=1,sep=" ") {
  #pega o texto e quebra segundo o separador informado
  xx = strsplit(x,split=sep)[[1]]
  #retorna o valor
  return(xx[qual])
}
 
#usamos essa funcao com o lapply para pegar o genero
lapply(dd$ESPECIE,peganome,qual=1)
#como é uma lista transformamos num vetor
gg = as.vector(lapply(dd$ESPECIE,peganome,qual=1),mode='character')
gg 
#ADICIONAMOS NO OBJETO ORIGINAL
dd$GENERO = gg
 
#usamos essa funcao com o lapply para pegar o epiteto
spp = as.vector(lapply(dd$ESPECIE,peganome,qual=2),mode='character')
spp
#adiciona
dd$SPP = spp
 
#mostra
dd
str(dd)
  • str_trim() - remove espaços em branco no início e final do texto (pacote stringr)
  • toupper() e tolower() - muda a caixa do texto
txt = "Um texto QUALQUER"
#transforma para caixa baixa
tolower(txt)
 
#caixa alta
toupper(txt)
 
#apenas a primeira letra em maiusculo
#temos que construir nossa funcao para isso
mudatexto <-function(x) {
  xx = strsplit(x,split="")[[1]]
  xx = tolower(xx)
  xx[1] = toupper(xx[1])
  xx = paste(xx,collapse = "")
  return(xx)
}
txt
mudatexto(txt)
 
txt2 = "   Outro texto com espacos em branco no inicio e fim     "
#note que há espaços em branco no início e final do texto
#remove isso
library(stringr) #precisa desse pacote para essa funcao apenas
str_trim(txt2)
  • gsub() - substitui ocorrência de um texto por outro
  • substr() - pega um pedaço do texto
  • nchar() - conta o número de caracteres num texto
#substitui palavras ou parte de palavras
txt = "Um texto que contém muita COISA"
gsub("m","M",txt)
gsub("que","o qual",txt)
 
#pega uma parte do texto
substr(txt,1,10)
substr(txt,11,20)
 
#qual o numero de caracteres num texto
nchar(txt)
substr(txt,nchar(txt)-10,nchar(txt)) #dez ultimos caracteres
  • Expressões Regulares são modelos lógicos para buscar caracteres em textos. É uma ferramenta muito poderosa usada em computação. Não é fácil entender e usar expressões regulares, mas é muito poderoso e importante conhecer os recursos. Aqui apenas um exemplo muito simples do uso de expressões regulares.
  • http://regexr.com - este site te ajuda a construir uma expressão regular.


txt = "Um texto com varios numeros 1 2 9 no meio e 5 7 8 20 3456"
txt
#imagine que eu queira apagar todos os números desse texto
gsub("[0-9]","",txt) #paga números de 0 a 9
 
#todas as letras minusculas
gsub("[a-z]","",txt)
 
#todas as letras
gsub("[a-z|A-Z]","",txt)
 
#todas as minúculas e numeros
gsub("[a-z|0-9]","",txt)
  • Remover acentos e padronizar textos podem ser importantes quando estamos comparando dados. Por exemplo, quando queremos verificar se os nomes que aparecem numa coluna estão padronizados, ou queremos padronizá-los
  • Não há uma função específica, mas como tudo pode ser feito no R, uma solução para isso é mostrada aqui.
txt = "Palavrão ou bobalhão têm acentos"
#convertemos quebrando acentos
xx = iconv(txt, to="ASCII//TRANSLIT") 
xx
#apagamos os acentos sozinhos
xx = gsub("[~|^|~|\"|'|`]","",xx)
xx
 
#podemos colocar isso numa funcao
removeacentos <- function(x) {
  xx = iconv(x, to="ASCII//TRANSLIT") 
  xx = gsub("[~|^|~|\"|'|`]","",xx)
  return(xx)
}
 
#usando a funcao criada
removeacentos(txt)
 
txt2 = "macarrão também tem acentos, né?"
removeacentos(txt2)

Expressões Regulares

  • Quotes - veja o help (?Quotes)
  • Entender isso é muito importante porque é fonte frequente de erros quando escrevemos códigos.
  • Algumas funções que buscam por padrões interpretam expressões regulares (regular expressions) para buscar por padrões em objetos de texto:
    • gsub() e grep() - são duas funções parecidas, que buscam por um padrão (argumento pattern) em textos. Enquanto gsub() busca e permite substituir o padrão por outro texto, grep() retorna o índice do elemento que contém o padrão de interesse.
    • Esse argumento pattern pode ser um texto simples ou uma expressão regular, então é importante que você entenda um pouco sobre isso.
    • Expressões regulares podem ser bem complexas e até existem sites que te permitem entender e gerar uma expressão regular para uma busca especifica (veja aqui, por exemplo).
  • Metacaracteres são caracteres que numa expressão regular tem um significado especial e por isso não são interpretados como tal. Alguns metacaracteres são:
    • "." encontra qualquer coisa que exista.
    • "+" encontra o item que prece esse meta-caractere uma ou mais vezes
    • "*" encontra o item que prece esse meta-caractere 0 ou mais vezes
    • "^" encontra qualquer espaço vazio no início da linha. Quando usado numa expressão de classe de caractere (veja abaixo), econtra qualquer caractere exceto aqueles que seguem esse metacaractere.
    • "$" encontra qualquer espaço vazio no final da linha.
    • "|" operador que significa OR (ou) para ser usado em buscas do tipo, busca isso OU aquilo.
    • "(", ")" para agrupamentos.
    • "[", "]" define classes de caracteres em expressões regulares (veja abaixo)
  • Suponha que você importe ao R um conjunto de dados de uma planilha, usando por exemplo, read.table(), e que os nomes das colunas no original tinham muitos espaços em branco. Como o R não aceita espaços em branco ele substitui espaços por pontos, então os nomes das colunas do data.frame dos dados tem muitos pontos, algumas vezes em sequência. Suponha também que isso acontece toda vez que você importa dados ao R e já está cansado disso e você quer colocar no seu script um comando que elimina esses pontos, para não se preocupar com isso no editor de planilhas onde estão os seus dados.
#vamos criar um data.frame que simule esta situação
Número.....da.......árvore=c(1,10,15)
Diâmetro..cm. = c(10,15,20)
Altura.....m.... = c(15,20,39)
dados = data.frame(Número.....da.......árvore,Diâmetro..cm.,Altura.....m....)
class(dados)
dim(dados)
colnames(dados)
#nome de colunas, que também neste caso pode ser obtido com
names(dados)
 
#então digamos que eu queira substituir pontos multiplos por apenas 1 ponto. como eu quero manter 1 ponto eu poderia repetir várias vezes um substituicao de dois pontos por um ponto:
gsub(pattern="..",replacement=".",nn) 
#estranho né? tudo virou ponto
 
#isso é porque . é um metacaractere e o R não interpreta isso como ponto. Ponto significa pega 'pega qualquer caractere' numa expressão regular
 
#pelo fato de ponto ser um metacaractere, precisamos indicar que queremos o caractere ponto e não o metacaractere. Você faz isso usando uma ou duas barras invertidas (backslash)
gsub(pattern="\\.\\.",replacement=".",nn)
 
#diminuiu o número de pontos, mas preciso fazer isso várias vezes para ficar com um único ponto
nn2 = gsub(pattern="\\.\\.",replacement=".",nn) 
nn2 = gsub(pattern="\\.\\.",replacement=".",nn2)
nn2
nn2 = gsub(pattern="\\.\\.",replacement=".",nn2)
nn2
#pronto consegui
 
#note que isso fica restrito a quantos pontos tem nos meus dados, e portanto, não é um método genérico ou eficiente em termos de programação, por o número que vezes que isso deve ser feito irá variar dependendo do conjunto de dados.
 
#seria mais fácil adicionar um metacaractere (+) e fazer isso uma única vez, sem necessidade de repetição:
nn
nn2 = gsub(pattern="\\.+",replacement=".",nn)
nn2
#procurar por qualquer letra+
txt = "qualqueeeeeer palavra"
gsub("e+","E",txt)
 
#da mesma forma se eu quiser buscar pelo caractere + ao invés de usar o metacaractere, preciso usar a barra invertida:
txt = c("um texto com simbolo +","sem o simbolo")
gsub("+","MAIS",txt) #nao funciona
gsub("\\+","MAIS",txt) #funciona
  • Algumas classes de caracteres em buscas com expressões regulares:
    • [0-9] - números em textos
    • [a-z] - caracteres minúsculos
    • [A-Z] - caracteres maiúsculos
    • [a-zA-Z] - caracteres do alfabeto
    • [^a-zA-Z] - não alfabéticos
    • [a-zA-Z0-9] - alfa-numéricos
    • [ \t\n\r\f\v] - de espaçamento: quebra de linha, tabulação, etc.
    • []$*+.?[^{|(\\#%&~_/⇔✬!,:;❵\")}@-] - caracteres de pontuação
  • Elas permitem fazer buscas complexas.
  • Suponha que precisa substituir todos os valores que não contenham letras ou números por NA:
#suponha um vetor de palavras (nomes de cores neste exemplo)
vt = colors()
vt
#podemos mostrar os valores que contém branco:
grep("white",vt,value=TRUE)
 
#se eu coloco white numa expressao regular
grep("[white]",vt,value=TRUE)
#neste caso significa pegue qualquer elemento que contenha uma das letras indicadas: w, h, i, t ou e. Por isso a lista aumentou
 
#pega só cores que tenham número
grep("[0-9]",vt,value=TRUE)
 
#neste caso é o mesmo que nao-alfabeticos
grep("[^a-zA-Z]",vt,value=TRUE)
 
#que tenham caracteres maiusculos
grep("[A-Z]",vt,value=TRUE) #nao tem nenhum neste vetor
 
#minusculos
grep("[a-z]",vt,value=TRUE) 
  • O uso do backslash \ (barra invertida) indica ao R que a expressão regular espare lidar com tabulações, quebra de linhas e outros símbolos. Isso é fundamental se você quer incluir/buscar num texto por aspas, parênteses, colchetes, barras, metacaracteres, etc.
?Quotes #leia atentamente esse help
#criar um texto com aspas
txt = "Um texto que tem "aspas" no meio" 
#note que isso não funciona, porque aspas é usado para abrir e fechar textos
#mas eu posso combinar aspas simples e duplas para fazer isso
txt = 'Um texto que tem "aspas" no meio'
txt
#veja que o R adicionou uma \ antes das aspas do texto, criando um escape character, que indica ao R que não interprete aquilo como abertura ou fechamento de textos
#entao eu posso fazer isso
txt = "Um texto que tem \"aspas\" "
txt
#também funciona
 
#isso é importante quando buscamos valores
txt = c("com \"aspas\"","outro objeto")
grep("\"",txt) #qual elemento tem aspas
txt[grep("\"",txt)]
 
#barras
txt = c("com \\ barras","sem barras")
txt
grep("\\\\",txt) #isso é mais complicado, veja o número de barras que preciso para buscar por 1 barra num texto, porque barra desse jeito é o código que ele usa para buscar por códigos, então complica né?
 
#parentesis
txt = c("sem parenteses","com ()")
grep("(",txt) #isso não funciona por parentesis é usado para abrir e fechar funcoes, o R se atrapalha
grep("\\(",txt) #assim funciona
grep("\\)",txt) 

  • bot89/precurso/1textfun/inicio.txt
  • Última modificação: 15/15/2020 20:15
  • por perdiz