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


Learn the basics of loading, selecting, filtering and arranging data frames in R with dplyr.

Introduction to Data Frames in R

Sometimes rather than specify what columns you want to select from a data frame, it's easier to state what columns you do not want to select. `dplyr`'s `select()` function also enables you to do just that! Consider a `customers` data frame that contains biographical information for the customers of your business:

<div class="narrative-table-container">

|name|address|phone|age|
|-|-|-|-|
|Martha Jones|123 Main St.|234-567-8910|28|
|Rose Tyler|456 Maple Ave.|212-867-5309|22|
|Donna Noble|789 Broadway|949-123-4567|35|
|Amy Pond|98 West End Ave.|646-555-1234|29|
|Clara Oswald|54 Columbus Ave.|714-225-1957|31|

</div>
<br>

You are interested in analyzing where your customers live and how old they are. For your analysis, you do not care about the `name` and `phone` associated with a customer, only their `address` and `age`. To exclude the columns you do not need:

```r
customers %>%
  select(-name,-phone)
```
* the data frame `customers` is piped into `select()`
* the columns to remove, prepended with a `-`, are given as arguments
* a new data frame without the `name` and `phone` columns is returned

Excluding Columns

When you have data in a CSV, you can load it into a data frame in R using `readr`'s `read_csv()` function:

```r
df <- read_csv('my_csv_file.csv')
```
* In the example above, the `read_csv()` function is called
* The CSV file `my_csv_file.csv` is passed in as an argument
* A data frame containing the data from `my_csv_file.csv` is returned

You can also save data from a data frame to a CSV using `readr`'s `write_csv()` function:

```r
write_csv(df,'new_csv_file.csv')
```

In the example above, `write_csv()` takes two arguments:
* `df`, which represents a data frame object
* `new_csv_file.csv`, the name of the CSV file that will hold the data from the data frame

By default, this method will save the CSV file to your current directory.

Loading and Saving CSVs

When you load a new data frame from a CSV, you want to get an understanding of what the data looks like.

If the data frame is small, you can display it by typing its name `df`. If the data frame is larger, it can be helpful to inspect a few rows of the data frame without having to look at the rest of it.

The `head()` function returns the first 6 rows of a data frame. If you want to see more rows, you can pass an additional argument `n` to `head()`. For example, `head(df,8)` will show the first `8` rows.

The function `summary()` will return summary statistics such as mean, median, minimum and maximum for each numeric column while providing class and length information for non-numeric columns.


Inspecting Data Frames

There you have it! With the power of readr and dplyr in your hands, you can now:
* load data from a CSV into a data frame
* inspect the data frame with `head()` and `summary()`
* `select()` the columns you want to analyze
* `filter()` the rows with comparison and logical operators
* `arrange()` rows in ascending or descending order

You've also been exposed to the pipe `%>%`, a powerful tool for chaining function calls, as well as the general principles of data manipulation.

Now that you are well on your way to being a dplyr master, let's combine what you have learned together to perform an analysis and see the true power of the pipe!

Review

Sometimes all the data you want is in your data frame, but it's all unorganized! Step in the handy dandy dplyr function `arrange()`! `arrange()` will sort the rows of a data frame in ascending order by the column provided as an argument.

For numeric columns, ascending order means from lower to higher numbers. For character columns, ascending order means alphabetical order from A to Z.

Let's look back at the `customers` data frame for your company:

<div class="narrative-table-container">
<div class="narrative-table-scroll">

|name|age|address|phone|
|-|-|-|-|
|Martha Jones|28|123 Main St.|234-567-8910|
|Rose Tyler|22|456 Maple Ave.|212-867-5309|
|Donna Noble|35|789 Broadway|949-123-4567|
|Amy Pond|29|98 West End Ave.|646-555-1234|
|Clara Oswald|31|54 Columbus Ave.|714-225-1957|

</div>
</div>
<br>

To arrange the customers in ascending order by name:

```r
customers %>%
  arrange(name)
```
* the `customers` data frame is piped into `arrange()`
* the column to order by, `name`, is given as an argument
* a new data frame is returned with rows in ascending order by `name`

`arrange()` can also order rows by descending order! To arrange the customers in descending order by age:

```r
customers %>%
  arrange(desc(age))
```
* the `customers` data frame is again piped into `arrange()`
* the column to order by, `age`, is given as an argument to `desc()`, which is then given as an argument to `arrange()`
* a new data frame is returned with rows in descending order by `age`

If multiple arguments are provided to `arrange()`, it will order the rows by the column given as the first argument and use the additional columns to break ties in the values of preceding columns.

Arranging Rows

Filtering Rows with Logic II

A data frame is an R object that stores tabular data in a table structure made up of rows and columns. You can think of a data frame as a spreadsheet or as a SQL table. While data frames can be created in R, they are usually imported with data from a CSV, an Excel spreadsheet, or a SQL query.

Data frames have rows and columns. Each column has a name and stores the values of one variable. Each row contains a set of values, one from each column. The data stored in a data frame can be of many different types: numeric, character, logical, or NA.

A data frame containing the address, age and name of students in a class could look like this:

<div class="narrative-table-container"> <div class="narrative-table-scroll">

|address|age|name|
|-|-|-|
|123 Main St.|34|John Smith|
|456 Maple Ave.|28|Jane Doe|
|789 Broadway|51|Joe Schmo|

</div>
</div>
<br>

As seen in the first row, the column names of this data frame are `address`, `age`, and `name`.

Note: when working with `dplyr`, you might see functions that take a data frame as an argument and output something called a tibble. Tibbles are modern versions of data frames in R, and they operate in essentially the same way. The terms tibble and data frame are often used interchangeably. Here on Codecademy we will use the term data frame!

What is a Data Frame?

Data lies at the heart of nearly every problem in the business world and society. Having the right tools to manipulate data and organize it in a meaningful way is integral to performing data analyses and discovering unique insights!

The dplyr package in R is designed to make data manipulation tasks simpler and more intuitive than working with base R functions only. Called a "grammar of data manipulation," dplyr provides functions that solve many challenges that arise when organizing tabular data (i.e., data in a table with rows and columns). Tabular data has a lot of the same functionality as tables from SQL or Excel, but dplyr adds the power of R. 

In addition to learning how to load data into R with the readr package, this lesson will introduce how to perform the following data manipulation tasks with dplyr:
* select columns of a table
* filter rows of a table
* arrange rows of a table in order

dplyr and readr are a part of the tidyverse, a collection of R packages designed for data science. In this and future lessons, you will use different packages of the tidyverse to more easily analyze and visualize data!

The tidyverse is a package itself, and it can be imported at the top of your file if you need to use any of the packages it contains.

In our lessons, however, we will explicitly import the packages within the tidyverse that we are using. To get started with readr and dplyr, you can import them at the top of your `.Rmd` R-markdown file or `.R` script:

```r
library(readr)
library(dplyr)
```


Introduction

Suppose you have a data frame called `customers`, which contains the ages of your business's customers:

<div class='narrative-table-container'>

|name|age|gender|
|-|-|-|
|Rebecca Erikson|35|F|
|Thomas Roberson|28|M|
|Diane Ochoa|42|NA|

</div>
<br>

For your analysis, you only care about the age and gender of your customers, not their names. The data frame you want looks like this:

<div class='narrative-table-container'>

|age|gender|
|-|-|
|35|F|
|28|M|
|42|NA|

</div>
<br>
 
You can select the appropriate columns for your analysis using `dplyr`'s `select()` function:

```r
select(customers,age,gender)
```
* `select()` takes a data frame as its first argument
* all additional arguments are the desired columns to select
* `select()` returns a new data frame containing only the desired columns

But what about the pipe `%>%`, you ask? Great question. You can simplify the readability of your code by using the pipe:

```r
customers %>%
  select(age,gender)
```

When using the pipe, you can read the code as: from the `customers` table, `select()` the `age` and `gender` columns. From now on we will use the pipe symbol where appropriate to simplify our code.

Selecting Columns

One of the most appealing aspects of dplyr is the ability to easily manipulate data frames. Each of the dplyr functions you will explore takes a data frame as its first argument.

The _pipe operator_, or `%>%`, helps increase the readability of data frame code by piping the value on its left into the first argument of the function that follows it. For example:

```r
df %>%
  head()
```

pipes the data frame `df` into the first argument of `head()`, becoming

```r
head(df)
```

The true power of pipes comes from the ability to link multiple function calls together. Once you learn some of dplyr's functions, we'll revisit pipes and see how they are so useful!

Note: the pipe operator is *not* a part of base R. It comes from the `magrittr` package, but do not worry about loading magrittr in your code. Any time you load a package from the tidyverse, like dplyr, `%>%` will automatically be loaded!

Piping

Filtering Rows with Logic I

When working with data frames, most of the time you will load in data from an existing data set. One of the most common formats for big datasets is the _CSV_.

_CSV (comma separated values)_ is a text-only spreadsheet format.  You can find CSVs in lots of places such as:
* online datasets from governments and companies (here's an example from <a href="https://catalog.data.gov/dataset?res_format=CSV" target="_blank" rel="noopener noreferrer">data.gov</a>)
* exported from Excel or Google Sheets
* exported from SQL

The first row of a CSV contains column headings. All subsequent rows contain values. Each column heading and each variable is separated by a comma:

```
column1,column2,column3
value1,value2,value3
value4,value5,value6
```
That example CSV represents the following table:

<div class="narrative-table-container">

|column1|column2|column3|
|-|-|-|
|value1|value2|value3|
|value4|value5|value6|

</div>
<br>
