# Convert characters to expressions in R

Convert characters to expressions in R, we’ll demonstrate how to generate expressions, translate characters into expressions, then translate expressions back into characters in this tutorial.

The expression, parse, and deparse R programming functions serve as the foundation for this tutorial. So let’s look at the definitions of the functions and the fundamental R syntax first:

Simple R Syntax:

```expression(character)
parse(text = character)
deparse(expression)```

An R object belonging to the expression class is created by the expression function.

An R object of the character class is transformed into an R object of the expression class using the parse function.

An R object of the expression class is transformed into an R object of the character class using the deparse function.

Machine Learning Archives – Data Science Tutorials

We’ll give you five instances of expressions, parses, and deparses in R in the next article. Let’s begin straight away!

### Example 1: Create an R expression (expression Function)

We’ll demonstrate how to use the expression function to build an R expression in the first case:

```Z <- expression(2^2)
Z
expression(2^2)```

The expression 2^2 was constructed using the previous R code, and it was saved in the data object x1. Using the class function, we can confirm the class of this data object.

`class(Z)                        `

“expression”

Good looking! Now that we have the eval function, we might evaluate this expression.

```eval(Z)
4
2^2 = 4```

The eval function, however, is outside the purview of this lesson. Check out this lesson to learn more about eval in R.

### Example 2: Using the parse function, convert a character string to an R expression.

We frequently come across expressions that R stores as character classes. We must change our data object’s character class to an expression class if we wish to evaluate such an expression.

We’ll give an illustration. Let’s start by making an example data object:

```Z2 <- "2^2"
Z2
"2^2"```

As you can see from the class function, the class character in our example data is:

```class(x2)
"character"```

Use the parse function to transform this character string into an expression:

```Z <- parse(text = Z2)
Z
expression(2^2)```

Let’s verify our data’s class once more:

```class(x2)
"expression"```

With the data item Z2 now being an expression, the eval function can be used to evaluate it (as demonstrated in Example 1).

### Example 3: Use the deparse function to convert an expression string to a character.

The conversion in Example 2 can also be performed in the opposite direction, going from expression to character class.

We are going to use data object Z2 from Example 2, which we transformed into an expression.

We can change this R expression back to the character class using the deparse function and place it in the fresh data object z3:

```z3 <- deparse(x2)
z3                               ```
`"structure(expression(2^2), srcfile = <environment>, wholeSrcref = structure(c(1L, " "0L, 2L, 0L, 0L, 0L, 1L, 2L), srcfile = <environment>, class = \"srcref\"))"`

Let’s use the class function to check the outcome:

```class(z3)
"character"```

z3 is a character string – looks good.

Because it has more details about the expression, this character string is not the same as our original input object Z2 (as constructed in Example 2).

Informing labels for data sets and charts, for example, can be done using this.

What is neural network in machine learning? »