ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


An introduction to the R programming language and its unique syntax.

Introduction to R Syntax

We mentioned Vectors when we introduced data types earlier. In R, vectors are a list-like structure that contain items of the same data type. 

Take a look here:
```R
spring_months <- c("March", "April","May","June")
```

In the example above, we created a new variable with the value of a new vector. We created this vector by separating four character strings with a comma and wrapping them inside `c()`.

A few things you should know how to do with vectors:
+ You can check the type of elements in a vector by using `typeof(vector_name)`
+ You can check the length of a vector by using `length(vector_name)`
+ You can access individual elements in the vector by using `[]` and placing the element position inside the brackets. For example, if we wanted to access the second element we would write: `vector_name[2]`. Note: In R, you start counting elements at position one, not zero.





Vectors

Working with conditionals means that we will be using logical, true or false values. In R, there are operators that work with logical values known as logical operators. We can use logical operators to add more sophisticated logic to our conditionals. There are three logical operators:

+ the AND operator (`&`)
+ the OR operator (`|`)
+ the NOT operator, otherwise known as the bang operator (`!`)

When we use the `&` operator, we are checking that two things are true:
```R
if (stopLight == 'green' & pedestrians == 0) {
  print('Go!');
} else {
  print('Stop');
}
```
When using the `&` operator, both conditions must evaluate to true for the entire condition to evaluate to true and execute. Otherwise, if either condition is false, the `&` condition will evaluate to false and the else block will execute.

If we only care about either condition being true, we can use the `|` operator:
```R
if (day == 'Saturday' | day == 'Sunday') {
  print('Enjoy the weekend!')
} else {
  print('Do some work.')
}
```
When using the `|` operator, only one of the conditions must evaluate to true for the overall statement to evaluate to true. In the code example above, if either `day == 'Saturday'` or `day == 'Sunday'` evaluates to true the if's condition will evaluate to true and its code block will execute. If the first condition in an `|` statement evaluates to true, the second condition won't even be checked. 

The `!` NOT operator reverses, or negates, the value of a TRUE value:
```R
excited <- TRUE
print(!excited) # Prints FALSE
```
Essentially, the `!` operator will either take a true value and pass back false, or it will take a false value and pass back true.

Logical operators are often used in conditional statements to add another layer of logic to our code.

Logical Operators

Congrats on finishing your first R lesson!

Here's a summary of some of the concepts you've learned:

+ R is a powerful statistical programming language with a large community of data enthusiasts.
+ You can calculate arithmetic with R and it will follow the normal order of operations
+ Data types allow us to classify different pieces of information.
+ You can store that information inside of variables
+ You can use conditional statements and operators to introduce logic to your code
+ You can call a function in R by using the `()` and passing in the correct arguments
+ R programmers have published lots of useful packages that specialize in different tasks, which are all available for you to use in your programs after you install them.

We hope you're as excited as we are about the possibilities of analyzing data now that you know some of the basics of programming with R.




Review

Functions are actions we can perform. R provides a number of functions, and you've actually been using a few of them even though you maybe didn't realize!

We _call_, or use, these functions by stating the name of the function and following it with an opening and closing parentheses: ie. `functionName()`. In addition, between the parenthesis, we usually pass in an _argument_, or a value that the function uses to conduct an action, i.e. `functionName(value)`. 

Does that syntax look a little familiar? When we have used `print()` we're calling the `print` function. When we made a vector, we actually used the combine `c()` function! Let's see `print()` and some real functions in action!

```R
sort(c(2,4,10,5,1)); # Outputs c(1,2,4,5,10)
length(c(2,4,10,5,1)); # Outputs 5
sum(5,15,10) #Outputs 30
```
Let's look at each of the lines above:
- On the first line, the `sort()` function is called with a parameter of the vector `c(2,4,10,5,1)`. The result is a sorted vector `c(1,2,4,5,10)` with the values in ascending order.
- On the second line, we called a function we've seen before: `length()` and it returned the value 5 because there were five items in the vector.
- On the third line, we called a function `sum()` which added up all of the arguments we passed to it.

Understanding how to call a function and what arguments it needs is a fundamental part of leveraging R as a tool to conduct analysis. Let's practice calling some useful functions!

Calling a Function

Now that you know how R classifies some of the basic information types, let's figure out how to store them. In programming, variables allow us to store information and associate that information with a name. In R, we _assign_ variables by using the assignment operator, an arrow sign (`<-`) made with a carat and a dash.

```R
full_name <-"Natalia Rodríguez Nuñez"
```

In the example above, we store the string value "Natalia Rodríguez Nuñez" in a variable called `full_name`. Variables can't have spaces or symbols in their names other than an underscore (`_`). They can't begin with numbers but they can have numbers after the first letter (e.g., `cool_variable_5` is OK). 

It's no coincidence we call these creatures "variables". If we need to update a variable but perform the same logical process on it, we can change its value! For example, take the variable `message_string`:

```py
# Greeting
message_string <- "Hello there"
print(message_string)

# Farewell
message_string <- "Hasta la vista"
print(message_string)
```

Above, we create the variable `message_string`, assign a welcome message, and print the greeting. After we greet the user, we want to wish them goodbye. We then update `message_string` to a departure message and print that out.

Note: You can also use `=` instead of `<-` to assign a value but R-tists(R programmers) prefer to do it with an arrow.




Variables

In R, we will often perform a task based on a condition. For example, if we are analyzing data for the summer, then we will only want to look at data that falls in June, July, and August.

We can perform a task based on a condition using an if statement:

```R
if (TRUE) {
  print('This message will print!')
} 
```
Notice in the example above, we have an _if_ statement. The if statement is composed of:


+ The if keyword followed by a set of parentheses `()` which is followed by a code block, or block statement, indicated by a set of curly braces `{}`.
+ Inside the parentheses `()`, a condition is provided that evaluates to `TRUE` or `FALSE`.
+ If the condition evaluates to true, the code inside the curly braces `{}` runs, or executes.
+ If the condition evaluates to false, the code inside the block won't execute.

Knowing how to use if statements will help you introduce logic in your data analysis. There is also a way to add an _else statement_. An else statement must be paired with an if statement, and together they are referred to as an if...else statement.
```R
if (TRUE) {
   print("Go to sleep!")
} else {
   print("Wake up!")
}
```

In the example above, the else statement:
+ Uses the else keyword following the code block of an if statement.
+ Has a code block that is wrapped by a set of curly braces `{}`.
+ The code inside the else statement code block will execute when the if statement's condition evaluates to false.
These if...else statements allow us to automate solutions to yes-or-no questions, also known as binary decisions.

Conditionals

R's popularity is also largely due to the many fantastic packages available in the language! A package is a bundle of code that makes coding certain tasks easier. There are all sorts of packages for all sorts of purposes, ranging from visualizing and cleaning data, to ordering pizza or posting a tweet.  In fact, most R-grammers (R programmers) use packages when they code. This is why you might hear them differentiate packages from "Base R." Base R refers the R language by itself and all that it can do without importing any packages. 

Base R is very powerful, but most of the time, you'll want to import a package to make your life easier. You only need to run this command the first time you install a package, after that there is no need to run it:
```R
install.packages('package-name')
```
 To import a package you simply:
```R
library(package-name)
```
You can look up documentation for different packages available in R at the [CRAN](https://cran.r-project.org/) (Comprehensive R Archive Network).

In this lesson, we coded in Base R but let's practice importing one of the most popular R packages: dplyr. Dplyr is a package used to clean, process, and organize data which you will use as you learn about R. 

Importing Packages

Ahoy! We R excited for you to start your learning adventure with a language built for data enthusiasts! The R community is made up of people passionate about the intersection of numbers, data, analysis, and code. In this lesson, we will introduce you to some basic R syntax and discuss how R  classifies data types so that it can mathematically process them in analysis.

But before you go any further, let's talk about how R is different from most programming languages. Unlike with other languages, most beginners who want to learn R do so because they want to analyze data. In this way, R is more of a tool to understand data than a programming language used to build software applications. Our approach to teaching you R will be similar to teaching you how to use a new tool.

What is the tool for? R is powerful for conducting statistics and other specialized data analysis. It was invented by scientists for statistical computing and a community of specialized packages has been built around the language. 

Some housekeeping: over the next exercises you'll be conducting all of your work inside R-notebook files. You'll see the **.Rmd** file format will allow you to write blocks of code and see their output as a webpage. You will see the blocks wrapped inside the following syntax:

```R
This is regular markdown text that will render as regular text.
` ` `{r}
7 + 7 # This is R code
` ` `
```

This format allows you to group blocks of code with common logic, see their output, and then render all of it together as an HTML file that can be viewed on a browser as a static webpage. The `.Rmd` format is the preferred standard in the data science industry. 

Note: This lesson assumes no prior coding knowledge and will introduce programming concepts as you need them in order to continue using R as a tool to conduct analysis. 

Image of female-identifying pirate juggling data science symbols such as math, graphs, and numbers.

Why R?

Let's start with the basic syntax for mathematical calculations in R. R performs addition, subtraction, multiplication, and division with `+`, `-`, `*`, and `/`:

```R
# Results in "500"
573 - 74 + 1

# Results in "50"
25 * 2

# Results in "2"
10 / 5
```

Mathematical operations in R follow the standard mathematical [order of operations](https://en.wikipedia.org/wiki/Order_of_operations). Let's write your first line of R code and calculate some basic math!

Calculations

Ironically, the second thing we're going to do is show you how to tell R to ignore a part of your program. We promise it's very useful to know how to do this. Text written in a program but not run by the computer is called a _comment_. R interprets anything after a `#` as a comment.

Why would anyone want the computer to ignore a part of their file? Multiple reasons! Comments can: 

 * Provide context for why something is written the way it is:
```R
# This code will be used to count the number of times anyone tweets the word persnickety
persnickety_count <- 0
```

 * Help other people reading the code understand it faster: 
```R
# This code will calculate the likelihood that it will rain tomorrow
complicated_rain_calculation_for_tomorrow()
```

 * Ignore a line of code and see how a program will run without it:
```R
# useful_value <- old_sloppy_code()
useful_value <- new_clean_code()
```

Annotating or documenting your code can help other people read your program later! It could also help your future-self understand the code when you go back and read an old file trying to remember how it works. Documenting your code will help others reproduce it, and it will help you become a better programmer too. Note: In R notebooks, you're also allowed to add documentation using markdown text outside the code blocks.


Comments

When writing conditional statements, sometimes we need to use different types of operators to compare values. These operators are called comparison operators.

Here is a list of some handy comparison operators and their syntax:

+ Less than: `<`
+ Greater than: `>`
+ Less than or equal to: `<=`
+ Greater than or equal to: `>=`
+ Is equal to: `==`
+ Is NOT equal to: `!=`

Comparison operators compare the value on the left with the value on the right. For instance:
```R
10 < 12 # Evaluates to TRUE
```
It can be helpful to think of comparison statements as questions. When the answer is "yes", the statement evaluates to true, and when the answer is "no", the statement evaluates to false. The code above would be asking: is 10 less than 12? Yes! So 10 < 12 evaluates to true.



Comparison Operators

Now that you know how to calculate basic math and add comments explaining your code, let's dive into how R "thinks about" different types of data. In R and in programming, _data types_ are the classifications we give different kinds of information pieces.  In  this lesson, we will explore the following R data types:
1. _Numeric_: Any number with or without a decimal point: `23`, `0.03`and the numeric null value `NA`. 
2. _Character_: Any grouping of characters on your keyboard (letters, numbers, spaces, symbols, etc.) or text. Most strings are surrounded by single quotes: `' ... '` or double quotes `" ... "`, though we prefer single quotes. Sometimes you will hear this type referred to as "string."
3. _Logical_: This data type only has two possible values&mdash; either `TRUE` or `FALSE` (without quotes). It’s helpful to think of logical types or booleans as on and off switches or as the answers to a "yes" or "no" question.
4. _Vectors_: A list of related data that is all the same type.
5. _NA_:  This data type represents the absence of a value, and is represented by the keyword `NA` (without quotes) but it has its own significance in the context of the different types. That is there is a numeric NA, a character NA, and a logical NA.

Let's get comfortable with checking the data type of the following:
```R
class(2) # numeric
class('hello') # character
class('23') #character
class (FALSE) #logical
class(NA) #logical
```
In the example above, notice that the third line is labeled a character type. Why? Because the characters `23` are in quotes, so it gets classified as a character. 