 This clip will show you how to ingest multiple CSV files into a single data frame, and I'll use this in other examples to show you how to use custom functions to iterate over data frames as you manage your analysis and workflow. So we're going to start off in the file 01, iterate, ingest, it's an R Markdown file, we're going to open it up in the RStudio project. And then also note that other files in this project file include the data directory, it has a series of files in it, and our goal is to ingest three CSV files that you see listed there in the middle of that screen. So we use the read underscore CSV function, which is part of the reader library, which is part of the tidyverse, and it is a vectorized function. So we'll load both tidyverse and library FS, FS is used for manipulating your file system. And then we'll inline 25, we'll use the dir underscore LS function to list the files in the data directory, that same data directory we just talked about, and specifically the files that end in dot CSV. That will return a vector of three elements. So there's element one, there's element two, and element three, each one of those has been edited by me for brevity, and they're each 1000 line in length CSV files, and we're going to ingest them into one big 3000 line length data frame. So we use read underscore CSV, we can use the first argument of that vector that we just created, and R will automatically, or read underscore CSV will automatically iterate over each one of those elements, and we'll add a variable called ID equals, using the argument ID equals file name, which will create a variable called file name, which will identify each row and the file that it came from, it will ingest an order, so it'll ingest from the first file name, the first 1000 rows, and then so on. As read underscore CSV works, it guesses as to the data types of the variables. So you'll see that there are five variables that are characters, six variables that are double numeric, and two variables that are date time. When we take a look at that data frame, you'll see that it is a 3000 row data frame, and the first variable is the name of the file. So that takes up the first 1000 rows, and then if we take a look at the end of this data frame, just the tail of this data frame, and look at the last six rows, you'll see a different file name listed, and that's from the last 1000 rows, and literally just the last six. Okay, so looking back at the full data frame, you'll notice that R ingested all three of these files into a single data frame and took those educated guesses about the data types for each variable. Now one of the challenges you might run into is that when you ingest multiple files, R will make guesses and sometimes make different guesses for different files and have the same variable name, so you can force that coercion. You can say here that start underscore station underscore ID is a double numeric data type, and that's the data type we would probably want, but just to give you an example, maybe it's some other kind of value and we want them all to be character, we can coerce all of the variables that are start underscore station underscore ID to be character data type, or we can coerce them all to be something else, and that's how you do that, with the argument call underscore types. Okay, so now if I did that and we scroll and we look at start underscore station underscore ID, you can see now the data type is actually listed as a character data type, this handy when you're ingesting multiple files. So that's the setup and we'll talk more about how that kind of operation can be extended to more custom environments.