Have you tried using the other function families associated with rename, such as rename_ator rename_all, which can receive a function (like the ones @mpaladino recommended)?

The example is more descriptive:

library(tidyverse)

data <- head(iris, 3)
data
#>   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
#> 1          5.1         3.5          1.4         0.2  setosa
#> 2          4.9         3.0          1.4         0.2  setosa
#> 3          4.7         3.2          1.3         0.2  setosa

data %>% rename_at(2, function(x) "2da varaible")
#>   Sepal.Length 2da varaible Petal.Length Petal.Width Species
#> 1          5.1          3.5          1.4         0.2  setosa
#> 2          4.9          3.0          1.4         0.2  setosa
#> 3          4.7          3.2          1.3         0.2  setosa


antiguos <- names(data)
antiguos
#> [1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width" 
#> [5] "Species"

nuevos <- str_replace_all(str_to_lower(names(data)), "\\.", "_")
nuevos <- str_c(nuevos, stringi::stri_rand_strings(length(nuevos), 2), sep = "_")
nuevos
#> [1] "sepal_length_nP" "sepal_width_Ws"  "petal_length_r4" "petal_width_pY" 
#> [5] "species_4O"

data %>% rename_all(function(x) nuevos[which(antiguos %in% x)])
#>   sepal_length_nP sepal_width_Ws petal_length_r4 petal_width_pY species_4O
#> 1             5.1            3.5             1.4            0.2     setosa
#> 2             4.9            3.0             1.4            0.2     setosa
#> 3             4.7            3.2             1.3            0.2     setosa


data %>% rename_all(str_to_upper)
#>   SEPAL.LENGTH SEPAL.WIDTH PETAL.LENGTH PETAL.WIDTH SPECIES
#> 1          5.1         3.5          1.4         0.2  setosa
#> 2          4.9         3.0          1.4         0.2  setosa
#> 3          4.7         3.2          1.3         0.2  setosa

I frequently have the same problem parsing survey databases: the variable names are the question, so they are long, with spaces in between and special characters. Awful to be repeating them all the time, no matter how autocomplete RStudio has.

It is a somewhat long answer, hopefully it will serve for your case and for us to share strategies to deal with this problem.

As you mention dplyr::rename()it doesn't work with index numbers. This has to do in part with Wickham's philosophy, which comes more from dealing with relational databases where index numbers have no place, and also with issues of non-standard evaluation used by the tidyverse. Those functions are easy to use: you don't need to use quotes around strings and you don't need to explicitly create arrays using them c()to make multiple calls, but for that reason they have trouble mixing numbers and strings in function arguments. That's why tidyversecolumn names are always used and almost never index numbers. select()is an exception.

Preamble

First, a more general comment: I don't think it's a good practice to use index numbers to do subsetting data.frameor manipulations like renaming. Why? Because that works if your data structure is stable and the index numbers and names always match. But if you are using the operator%>%you are treating your data structure dynamically (within the chain of functions). So you run the risk that when you eliminate a variable the following ones are located one number less and if you apply a change based on index numbers the result will not be what you are looking for. I am a bit exaggerated with this, although there are contexts in which it is not so risky, I prefer never to use what is potentially a bad practice, to "forget" how to do it and not resort to that "shortcut" in another context in which which is risky.

Preferred option: a dictionary and use short names.

The alternative I use is to generate a set of short names for my database columns, so when I'm manipulating them I call them by short name. For that I make -or import if it is available in the source from which I get the data- a set diccionarioof variables. A simple data.framewith at least two columns, Variableand Etiqueta. Variableis the short name, which I use to refer to that column during data manipulation, etiquetaa long and very descriptive name that I use in charts or tables.

If you want, you can build it in Excel or similar, export it to .csv and import it in the R session you need or generate it directly in R. By convention in the R environment I always call it diccionario.

In practice I use the dictionary together with two simple ad hoc functions: nombrar_largo()and nombrar_corto(). The first is responsible for making the match and changing names from short to long, the second the reverse. As written they don't fail when there is a mismatch in the number of columns (i.e. you could use them after a select()) and they also don't fail if there are new columns (leave them unchanged), but they do require that the order of the column names in xand that of the rows in dfit is equal to .

What they allow you is to do all the processing and manipulation with the short names and when you want, for example, to generate a graph in which the long names are, you simply add them nombrar_largo() %>%to the appropriate place in your chain of functions and that's it.

Here is a practical example of a database that I am working with and that you can download here: http://portalanterior.ine.mx/archivos2/s/DECEYEC/EducacionCivica/Base_datos_Informe_Pais.xlsx

# El data.frame que analizo se llama basecalidad y la tabla de equivalencias entre variables y etiquetas se llama diccionario. 


diccionario %>% slice(10:15)  #Una parte del diccionario, para entender la estructura.

# A tibble: 6 x 2
Variable                                                                                                                                                                                            Etiqueta
<chr>                                                                                                                                                                                               <chr>
  1       p2          P2. En su opinión, si una persona mata a alguien y las autoridades no hacen nada, ¿los miembros de la comunidad tienen derecho o no tienen derecho de hacer justica con sus propias manos?
  2       p3 P3. Tomando en cuenta lo que sucede en su comunidad, ¿está muy de acuerdo, algo de acuerdo, algo en desacuerdo o muy en desacuerdo  con la frase La policía hace de mi colonia un lugar más seguro?
  3       p4                                             P4. En lo relativo al cumplimiento de las leyes vigentes en su estado y en el país, ¿cuál de las siguientes frases se acerca más a lo que usted piensa?
  4       p5                           P5.  En su opinión, qué es más importante: ¿Qué las autoridades respeten los derechos humanos o que las autoridades capturen a personas acusadas de cometer algún delito?
  5       p6                                                                                                                                     P6.  ¿Cuál de las siguientes situaciones considera que es peor?
  6     p7_1                                               P7. Por favor dígame,  si en los últimos doce meses usted  Ha cambiado los lugares a donde va de compras  por temor a ser víctima de la delincuencia.


nombrar_largo <- function(x){
  nombres <- diccionario [diccionario$Variable %in% colnames(x),"Etiqueta"]$Etiqueta
  colnames(x) <- nombres
  return(x)
}

nombrar_corto <- function(x){
  nombres <- diccionario [diccionario$Etiqueta %in% colnames(x), "Variable"]$Variable
  colnames(x) <- nombres
  return(x)
}

# Uso

basecalidad %>% 
  nombrar_largo() %>%      #Regresa la misma base con nombres largos. 
  select(-proy, -edo) %>%  #Quito dos columnas.
  nombrar_corto()          #Sigue funcionando.

These functions can be improved, since they require some fixed names: Dictionary, Label, Variable and they also have the order problem. However, as they work, I have not put my hands on them. They are also a bit slow for very wide bases, because it %in%is quite lazy. But since they work for what I need them for, I haven't started to improve them.

Alternative method with functionnombrar()

If it's too much work to do the dictionary and you prefer a faster solution (in the short term) you can use a variation of the function setNames(), which I called nombrar(). setNames()takes two arguments, a data.frameand a vector of names, the problem is that it doesn't handle index numbers well. So I modified it a bit so that it takes a third argument: a numeric vector with the indices. I also changed the order of the arguments: the first is the data.frame, so using %>%lo you can leave it empty, the second a numeric array with the indices, and the third a character array with whatever names you like for the variables selected by number.

nombrar <- function (object = nm, index, nm) 
{
  names(object)[index] <- nm
  object
}
# Uso:

basecalidad %>% 
  nombrar(c(1, 5, 6), c("Nombre de la uno", "Nombre de la cinco", "Nombre de la seis"))

Of course, for each use you have to make sure that the index vector and the name vector have the same length and match by location. But by having a as input data.frameand returning the same structure as output you can use it with the operator %>%.

Option 3: Use an gsub()ad hoc

Sometimes the short name we are looking for is in the long and awkward names and it is just a matter of removing what is left over with a regular expression or directly a string. It can be used on your database gsub()vector , in this case I use setNames() to wrap the process in a function. names()In your case it would be something like:

df %>%
   setNames(gsub("Código.Penal.Federal..CPF._Delitos.contra.la.salud_", "", .))
#No arme la estructura de datos y no lo pude probar. Un `dput(head(datos))`  ayudaría. 

Cheers!

Going through some old R notes, I came up with an answer that may be useful to those who give this post a read. The solution is to use the operator %>%and base functions R.

I will use the base mtcars to exemplify.

First, let's look at database variable names.

head(mtcars, 3)
               mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4     21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag 21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
Datsun 710    22.8   4  108  93 3.85 2.320 18.61  1  1    4    1

Suppose I am interested in selecting the variables mpg, cyl and hp (remember that the nature of the problem is to change names for variables with not very simple names, but it works the same way anyway)

library(dplyr)

head(mtcars) %>%
+   subset(select=c(1:2,4)) %>% 
+   setNames(c("millas","cilindros", "caballos")) 
                  millas cilindros caballos
Mazda RX4           21.0         6      110
Mazda RX4 Wag       21.0         6      110
Datsun 710          22.8         4       93
Hornet 4 Drive      21.4         6      110
Hornet Sportabout   18.7         8      175
Valiant             18.1         6      105

As can be seen, the result is the desired one. The crux of all this is to use subsetand setNameswhich are R code base functions. An alternative solution and also quite effective.

I hope someone finds it useful.

With the function colnames()it is very easy to do what you say, for example if the first column of my dataset I want to be called "Date" the instruction is colnames(data)[1]="Fecha"where the 1 indicates that it is the first column to which you want to change the name