CS50R: Representação de Dados (Aula 1) - Introdução à Programação com R

[Music] well hello one and all and welcome to cs's inroduction to programming with r my name is Carter zeni and I'm so excited to embark on this journey to learn this language called r with you now it's likely that you have never programmed before and if so that's okay but you might be asking what is a programing language actually anyway well it turns out a program language is Something that we humans had created to actually talk to computers and have them solve problems for us and you might have heard of lines of code things actually

tell computers what to do and you may have heard of programs being lines and lines and lines of code telling computer step by step what it is we want them to do and you might have heard as well there are other languages you could learn like C like python like R like JavaScript and so you could be asking Yourself why would I learn R well R it turns out is this language built from the ground up to work with data and so if you are interested in data or some of these fields here like data

science data visualization research or statistics or could be a language for you and although this course won't actually teach data science or statistics or the math behind them you will Emerge being able to use R for these disciplines now actually just recently researchers Used R to model how covid-19 was spread and this is a visualization built entirely in R to model how covid-19 was spread on a cruise ship you might have also heard of 538 these data journalists who actually write articles with data they use R to analyze data to write their articles and share

visualizations like this one so we actually understand insights from data to so without further Ado let's actually by writing our very first r program and to do that we'll Need what's called an integrated development environment or an IDE for short now code at the end of the day is just text and you could use any text editor to write code but it turns out that when you actually want to write lots and lots of code it's helpful to have a tool to do that with and that's what this IDE will be doing for us now

let me introduce you over here to this uh IDE called R studio now R studio is an IDE built exclusively and Particularly for R and here it is you'll notice off the bat that I have this kind of greater than sign here with a blinking cursor and this indicates what we're going to call the r console it's a place I can actually type R statements and have them run kind of line by line by line it's a great place for me to actually execute or to run one line of code at a time so let's

actually type our very first line of our code here to create this file called hello . R in Which will write actual full-fledged program so to create a file using this console in R Studio I can type file. create open parentheses and close parentheses and then the name of the file I want to create so here I'm going to create in this case hello. r just like that now notice that hello. r ends in. R and that is actually very particular you might have heard of files ending in like jpg for images or maybe CSV

for data files in R we denote our R Programs with this capital r here so let me run this R statement here by hitting enter and now I should see well I see true kind of in yelling at me right here what this means is that this file was created and we'll also see this kind of bracket one here which will become more parent as we go on but it turns out that because R works a lot with data and lists of data it's often handy when you have lots and lots of data to give

us an indicator of where in that list we are So we'll see this come in handy a bit more later but for now with this list of one value like true it just says one for now well where was this file created like I claim it was created but where was it created so R Studio has this file explorer that I can open on the side here and this file explorer shows me the contents of some particular folder on my computer even if you don't know much about computers you probably know about files and folders

and so here it seems Like I am inside of the users slj Harvard folder and inside of that folder R studio and R created for me this file called hello. R now R Studio works by default in a single folder and that folder it turns out is called our working directory if I ask R to create a file for me it will create that file in the working directory or if I ask it to find some data file file and read it into my R program it will first search in that working directory for me

here so Let's open up this R file and actually write our first R program I'll type I'll uh hit this hello. R file icon here let me close my File Explorer for now cuz it's not important at this point but now I'm introduced to this new component of R studio in this case my file editor so as we saw before this R console down here is great for writing single r statement single lines of R code but this hello. R file is great for writing more than one line of code tens of lines Hundreds of

lines creating a full-fledged program here so I have this blinking cursor which means I can just go ahead and type some text and let's type in some text that will be our very first R program I'll type print p r i NT followed by an opening parentheses and a closing one and inside those parentheses let me type hello comma space world just like this and now I've typed in some text my first line of R code I can save this file by clicking On this little save icon here or on Mac I could do command

Des or on Windows I could do controls so let me hit the save button here and now this program is saved on my computer I could run it if I wanted to now you may be used to running programs by double clicking on them or finding some icon and clicking on that to open the program and run it but I don't see those icons here and that is intentional this is a program we've made ourselves which will require a different Way of running it for us and even if you don't know much about computers you

probably know computers speak this language called binary or like ones and zeros and right now we just have p r i n t parentheses quotes hello world like that doesn't look like ones and zeros to me so there has to be a way to translate or interpret this R text we've written into ones and zeros the computer actually understands so R is more than a language it's also an interpreter that Takes this text we've written and converts it to the ones and zeros the computer understands now to kick off that process that interpretation process I

can actually click this button over here that says run so let me go down to the console first and let me clear the console so it's very clear what's happening here I'll type crl L to clear the console and now if if I go to this line of code line one and hit run I should see my first R program saying Hello to the world over here so let's take a step back first though and think about what it is we have just done so here in R we have created our very first program and

we've done so using something that's called a function now in languages like R and lots of others too you'll have access to these things called functions and functions let you tell the computer to take some action do something to solve some particular problem in this case our problem was Displaying some text and this function that we saw called print helped us do just that so let's go back and show you this program again I come back to our studio we saw that this function is called print you can probably guess that yourself here and we

know it's a function because I use these parentheses here this is convention in R to denote a function by by its name followed by parentheses followed by some particular input to that function now print when R The rers designed it it doesn't print some predetermined piece of text like it doesn't always print hello world doesn't always print hello to somebody else instead it prints the text that I want it to print and so we'll see as we learn programming together that these functions can take inputs and more precisely these inputs are called arguments to the

function they're inputs that change how the function actually runs now what is it that print did well Down Below on the console here I see that it printed hello comma world and this is what's known as the side effect of the function something visual that happened side effects could also be something that happens via audio something else I see whatever happens as the function is running that is known as its side effect and this is our first program in R so far but let's pause here and ask what questions we have on our our studio

or this first program we just Wrote called hello world so question about why we would use our studio as opposed to VSS code well if you're familiar with vs code you would know that it can work with a variety of languages like Python and c and others our studio though is tailor made to work with r and as we'll see later on in the course there's a lot of features of R Studio that make working with r much easier particularly with visualizations and plotting so we'll see that later on In the course as well um

also question about why would use r instead of python well python tends to be this really big language that can be used for lots and lots of things and you think of libraries in Python like numpy you can certainly do work like you would do in r with those libraries R Studio though is more of a u more of a precise tool it's built from the ground up to work with data whereas python is more of a general tool for solving lots of different Problems R then comes with some optimizations that make working with data

a little more efficiently um but in general you could use either python with numpy or other libraries or R to work with data overall now a question from Louise would you show us how to change the working directory for the console so a great question about actually changing the working directory we saw earlier that our studio defaults to having some kind of working directory but you could Change that if you wanted to well in R there is a function dedicated to changing that working directory and I can show you what that looks like over here

let me come back to my R Studio environment and in particular my console so changing the working directory that really only requires one line of R code so I could then clear my console down below here and execute that line of code in the console the function to do so is uh set WD just like this and then in Parentheses you can then type the path or the folder you want to change your working directory to so if you do want to do that you can use do it using the set WD function here now

we've completed our very first hello world program um but odds are things aren't always going to go as smoothly for you if you're just beginning with programming and even if you're more experienced you might encounter these things called Bugs or these errors in your code so let me Reproduce kind of uh intentionally here a bug that could happen in my program let's say as I was typing I didn't type print i instead typed PR let me save this program here and let me run it to see what happens I'll hit run and well now I

see down in my console error in PR uh parenthesis hello world could not find function PR in this case so this error is hopefully telling me like look there is no function called PR and hopefully by seeing this I should then Actually know well I didn't mean to type PR I meant to type print instead so I can go back and fix it and this process of actually going back and fixing our programs is known as debug finding those bugs in our code and getting rid of them by uh looking through these errors and talking

to a colleague or trying to fix them overall so here let me go back and clear my terminal my uh console down below I'll run this line of our code or run this line of um this program here Again and I'll see once again hello world so this is a pretty good program but I argue we could do a little bit better with it like we don't have to say hello to everyone we could try to say hello to a particular user and so our next step here will be to actually ask the user for

their name and then say hello to that particular user now to get user input there is a function in R for that it's not print it's instead called read line so let's use the read line Function here I'll type re e a d read line this is all one word and then parentheses opening and closing and it turns out that read line takes an argument to this argument will then be the prompt it prompts the user with so I'll ask the user what's your name just like this and I'll save the file here so let

me go down and clear my console I'll then run this line of our code and I'll see what's your name I could type in this case my name is Carter hit enter And I see Carter so it's not so much a greeing as much it is just kind of saying my name back to me I think we could still do better than that as well let me clear here my console and ideally I want to say something like this I want to say hello Carter so I could use print again maybe on line two now

I choose to say print and then hello comma Carter and I'll save this file again well now I have not just one line of R code but two and when R goes to interpret this Program it will read these lines of code top to bottom left to right executing each function along the way way but it turns out that this run button over here it says run but what it really does is it only runs one line of R code at a time for example I could run just line one or I could run just

line two but what we have here is really a full-fledged program it's more than one line of code it's two so to run the entire program I need to use a different Approach a different button in this case and that button is this source button up top here Source in this case means to run the entire source file here so let me go ahead and source and let me say what's my name my name is Carter and I see Hello Carter but there might still be a bug in this program let's try it one more

time let me clear the console I'll Source again and what if my name was like Mario from the Nintendo Universe I could type well my name is Mario h Hello Carter okay let's try it again I'll do source and I'll do uh maybe my name is Princess Peach so Princess Peach here and well still hello Carter so it seems to me like we need to do something more Dynamic than just printing out hello Carter we need to actually print what the user has given us at the console so for that we'll actually need this new

uh Concept in programming called a return value functions don't just have arguments and Side effects they also have return values and in this case readline will return to us as its return value the user input you could think of it a bit like a metaphor of asking your friend to go out and ask somebody for their name and they might write it down and return it back to you the programmer so you can use it later on in your code that's kind of what return values are in this case but if I have a return

value I'm going to need some place to store it some Place to reuse it later on in my code and for that we'll need something called a variable or an object a variable is some name for a value that could change so let's see how we could use both return values and objects in R to make this program more Dynamic let me go to line one here and let me try to give this return value of readline a name I could reuse later on well if the user types in Carter I want to refer to

that value via some name and maybe the right Name is just simply name so I'll type name here and now if I want to store the return value of readline that is whatever the user typed in inside this object called name I could use this syntax these particular characters here the less than sign and a Dash and notice if we read this kind of right to left first readline will run as a function it will prompt the user for their input the user will type that input in and then readline will come back to us

and give Us back whatever the value is that the user typed in and then these of code over here name space less than this Dash here will store it underneath this name called name this Arrow this left word arrow is called the assignment operator we're assigning whatever return value from readline to this new object called name so let me just for now get rid of this line two and just focus on this particular piece right now let me Source this file and now let me say my name is Mario I'll hit enter and I see

nothing yet cuz there's no print but now if I open up this new pane in our studio let me go ahead and go to my environment pane I'll actually see what the value is for this object we created called name so it seems like our studio is telling me that I have this object called name and its value now is Mario this is part of our environment the environment is the place we actually store our objects while our program is running so we can Then reuse them later on in our code so I've kind of

captured this user input and stored it in this object called name but let's see how we could use it now I'll come back to our studio and let me go back to line two and let me now print in this case let me print hello comma name just like this I'll kind of close my environment over here and now let me Source this particular file I'll type uh Mario it's my name and now hit enter and I see well hello name so this Isn't exactly what we wanted I actually printed out literally hello comma name

so I think we'll need to find some other solution here we solved one problem which was getting the user input and storing it somewhere but I mean how do we reuse that later on well if I'm being observant I might notice that what I'm really trying to do is combine some pieces of text like this text here is how hello comma space and the text I'm trying to combine is whatever the user Typed in or that is whatever is being stored in this name object I have over here so I'm trying to combine hello commas

space and this text from the user Mario now this is a common problem in programming trying to combine pieces of text so common that it actually has its own particular name this is called string concatenation where concatenation means combining together these various pieces of text or these strings so let's break it down and here of course we have The very first part of our greeting this is some piece of text or from here on out called a string a string because it's kind of characters strung together into one piece of text strings begin and end

with these double quotes here so I have hello comma space and that is one particular string but then the user comes in and they type in their own string let's say like Carter and now my t ask is to combine these together into a single string and print that back out To the user so my goal here is to effectively this turn these two separate strings into one individual string now R handily enough comes with a function to do just this so let's explore that function here this function is actually called paste paste is in

PA a s and paste allows me to concatenate various strings so let's try this one here if I want to use paste I use it the same way I would any other function I could use the function name and then Opening and closing parentheses and then paste will take as input any number of strings I want to concatenate or paste together in this case so let's say the first string as we said is hello comma space now the next string is something new it's actually going to be whatever is stored in this name object over

here so if I want to provide another input to paste I should actually separate it now with a comma so after the first input to paste the first argument I'll then give It a second input or a second argument and this one will be literally name in this case this object we stored that has that value the user themselves typed in and now paste its return value will be the combined version of these two strings so let's try it maybe I'll store the return value inside its own object called greeting I'll use the left Arrow

this assignment operator to store the return value of paste in this object called greeting and then down in print Here I won't print hello name literally I'll instead print whatever is stored in the object called greeting so as I run this let me open up my environment so we can see how these values change over time let me go ahead and click Source here my name in this case is Carter I'll hit enter and I see Hello Carter so if I go back to my my um environment here I see I not only have this

object called name storing Carter I also have this object called greeting storing the Concatenated versions of in this case the string hello uh comma space and then the string Carter itself but if you're being particular particularly observant here what do you notice as a bug in this program let me ask our audience here what do you notice as a bug in this program there are two spaces yeah there are two spaces so I only wanted one space but it seems I have somehow gotten two like greeting here has hello comma space space Carter so why

is that well I Could spend a lot of time kind of banging my head wondering why is this not working or I could look at something called documentation so programmers when they write functions like paste they also write documentation that tells me exactly how to use paste and what the effected output of paste might be so let's look then at the documentation for paste I can actually access documentation if I use this special character in R called the question mark And if you uh want to remember this I trying to think of like just being

confused like what do I do the question mark is that sybol then I follow with the function name in this case paste so now over on the right hand side let me make this bigger for us over here I'll actually see the documentation for paste whoever created this function called paste helpfully wrote this documentation to guide me on how to use paste itself so I'll see up top the goal of paste is To concatenate strings like we just talked about that much is obvious but down below I think is the helpful part this down below

will tell me what kinds of inputs paste could potentially take and I'll see the same thing we saw before paste Follow by some parentheses with various what we'll call parameters here so these are still inputs to paste but they're potential inputs and because they're potential ones we'll call them parameters arguments are the actual Values we passed to paste parameters are the potential ones here now I see if I go down here some dot dot dots these dot dot dots mean that paste could take really any particular number of arguments that could be any number of

strings I want to concatenate in this case I then have over here though this named parameter called sep and it says sep equals quote unquote with a space in the middle now this is what's called a named parameter it has a given name Because it has a special uh use case in this case of of paste now the equal sign means the default value for this parameter is going to be this value here the quote space unquote so it seems like this parameter called sep might be what's making this extra space actually happen in my

output and if I go back to the documentation over here let me scroll down a little bit so we can see I'll go down to the arguments and you can see that sep is in fact a character String to separate the terms so my job now is to think about what would I change the value of sep to B to remove that extra space well I can go back to my program and ideally I don't want anything any characters to default separate the strings I just want to have them put together with no spaces in

between so to use this named parameter called sep I can then have another input to paste I could follow with a comma just like this and then use that named Parameter sep in this case and set it equal to some new kind of value in this case quote unquote or really no spaces at all so let's try this now I'll um clear my console I'll run source and I'll type Carter again and now I'll see hello comma space only one space Carter now if you're like me you might think I'm going to often want to

concatenate strings that don't have any spaces in between them and it's going to be a lot of typing to always type comma SE equals quote unquote if you're writing many lines of code you don't want to do this over and over and over again and in fact some R users got tired of just this and they wrote their own function where the default is sep equals quote unquote nothing this function is called simply paste zero paste zero where zero means there's nothing between these concatenated strings I now don't need to supply the input set because

the default will always be no particular Space at all now I'll rerun this program source and say Carter and I'll get that same output now one other way to do this because there's always more than one way to do something is I could maybe just omit the space Al together like I could say hello comma and make that my string and I could then assume that paste will go ahead and actually add the space in for me I could run Source just like this type in Carter and now I'll see Hello Carter again completing our

program here So let me pause and ask what questions we have on paste string catenation or our program so far uh so what's the difference between uh the paste function and the cat function because I think both of them are used for string condation yeah good so if you are famili or familiar with r you you might have also heard of this function called cat and Cat itself stands for concatenation um cat and paste have two uh similar use cases they both involve Combining strings together but they have slightly different outputs so cat has the

side effect of printing whatever you've concatenated to the console uh paste on the other hand does not paste only returns to you kind of silently the concatenated version therein and you can then use that later on in your code cat I believe doesn't actually return to you the result just kind of prints it to the screen as a side effect so two very different use cases but the same kind of Goal here all right let's continue and let's keep improving our program here so one thing you might notice is that I have this object called

greeting and I'm just on the next line using that very same object and this seems just a little bit redundant because I'm just storing this value from paste in reading and immediately giving it back to this function called print well to have this same result and actually reduce some number of lines of code I could do the Following I could actually remove the idea of storing the result of paste in any given object and I could simply run paste and immediately pass the value or the return value from paste as the input to print now

this is arguably the most complicated line of code we've seen so far so let's break it down just a little bit this what we're doing right here is known as function composition I'm making one function run and then immediately passing the output of that function as Input to the next so this is our line of R code and we said before that R runs lines of code kind of line by line top to bottom left to right and that's mostly true but in this case we see there's more than one function to run or action

to take on this particular line of code so what is r to do well what R will always do is look first for the function that is innermost in the parentheses so in this case that is the paste zero function that is Concatenating or combining hello um comma space and then name over here now what this will do is make the return value of hello comma let's say space Carter and then pass that immediately as input into print just like this and once that's done print can then do its job and of course just print

out something like hello Carter so always think about the innermost function running first and passing its return value as the input to the next innermost function and so on And so forth so let's go ahead and try this out I'll come back to our studio here and here I have paste as opposed to paste zero but kind of the same thing as we saw before let me go ahead and hit cck Source here I'll type Carter and we'll see that I get the very same result without storing in this case an additional object now an

extension of this might be the following I could take read line I could take read line and notice how it's just simply storing the Value in name which I immediately pass as input to paste I could do this I could take readline and put this right there and now I have three functions nested inside of each other but let me actually ask you why might this not be a good idea let's think about other people who might read this code or think about working together on projects like why might I not want to do this

or go this far with the design of my code here as uh I think because it doesn't Explain the code perfectly uh to the user yeah it's kind of hard to read like if I saw this line of code here I would have to kind of think to myself okay which function is happening first well it looks like it might be readline and then what happens next okay paste happens next so it's a lot for me to think of as I'm reading this program and even though it is shorter I would say it's not necessarily

better so these are questions about the design of programs Which way to write the code is better um we have the same result so they're both correct but there are still different ways to design it and trade-offs to consider in terms of readability as well so let's come back and let's try to fix up this program a little bit I would argue that it's probably cleaner if we instead have readline on a separate separate line of code I'll put this first on line one and I'll go back to storing this object called name and I'll

Pass it in as input to paste here just like this now we just talked about the idea of making our code more readable and it turns out that R comes with a feature that can let me do just that I can actually Leave myself some notes to self called comments that will help me understand my code using the English language so if I want to write a comment or a note to my myself in my code I can do so by typing this hashtag here followed by a space and I can then type The comment

I want to type I could say maybe this line asks user this line asks user for asks user for name just like this and the next line well what does this line of code do this line of code says hello to user just like that now comments by convention go on the line above the line of code they are talking about so in this case I know this comment on line one refers to the code on line two and this comment on line four refers to the line of code on line Five but comments are

very helpful when you actually are working on a larger project you come back later don't know what you did comments can then help you understand exactly what to do and what you had done prior as well so this was our hello world program we said hello to the world we said hello to some users let's get working with some data now and and in one case we might want to work with data in terms of let's say counting votes for an election So let's go ahead and try to simulate an election between some fictional characters

from the Nintendo Universe in this case Mario Peach and Bowser so to create this new program I'll in I'll go go to my console again and I'll type file. create and in this case I want to count some votes so I'll call this program count. R just like this I'll hit enter and I'll see that this file was created so now if I open up open up my window over here and go to files I Should now see that count. R is available to me as a file to write this program in I'll open up

count. R and now I have a blank slate of a program to write so we have three candidates to keep track of votes for uh Mario Peach and Bowser so let's let the user actually type in those votes and return to them or print out the total number of votes that happened in this election so maybe I will ask the user using readline to enter votes for Mario just like this And I'll also ask the user to enter votes for peach just like this Princess Peach and I'll also use readline to ask the user to

enter votes for Bowser just like this now it's likely I'll want to use whatever the user types in later on in my code so why don't I store the return value of readline in an object I could reuse later on maybe I'll call this one Mario and this one peach uh and this one let's go for Bowser just like this so I'll save it and again the goal Was to kind of add up these total number of votes well maybe I'll make a new object called total to store those total number of votes and I'll

um have something that will assign that total number here well it turns out that to actually add data together I can use in R this plus sign plus operator so I'll say Mario plus Peach plus Bowser and that should return to me the total number of votes the user actually entered in the console and if I want to Then print that back out to the user well I could use print and paste again so I'll use print paste and then total votes no space no paste will actually add it for me and then total itself

down below here so a few things we've seen before and a few new things um what's new is this arithmetic we've seen now we just Ed this plus operator to add together some numbers and R has more than just the plus operator it has several others as well it has addition As we just saw with a plus sign subtraction with this minus sign or a dash multiplication with this star or asterisk operator and division just like this with the forward slash here there are other operators 2 that we'll talk about later on in the course

but for now these four will help you do some basic arithmetic that can help us solve some uh really interesting problems in this case so let's come back let's run our program I'll come back to our studio and I think that this should work I'll go ahead and run source and I'll enter votes in this case for Mario maybe I'll say Mario has 100 votes and Peach has 150 and Bowser has 120 and now I should see the total number of votes that were cast in this election I'll hit enter and I'll see one another

error it says error in Mario plus Peach non-numeric argument to Binary operator H the other error element was easier to understand this one's less Easy so at least it tells me where the error happened it said it happened in Mario plus Peach so it seems like maybe on line five here when I tried to add the user's input for Mario to the user's input for peach and it says the reason a non-numeric argument to the binary operator so the binary operator I'll tell you is this plus sign here but the non-numeric argument it seems like

it's telling us that Mario and Peach those aren't numbers at all so let's take a Peek at our environment where we stored those actual objects let me take a peak over here and what will we see if I go to environment maybe remove this down below here I see some old some old things here like greeting and name that I didn't get rid of before but I I also see Bowser Mario Peach and what do you notice well it seems like before we had let's say greeting that was a character string and we knew it

was a character string because it had quotes around it Right but we see the same thing now for Bowser and for Mario and for peach which implies to me that these are still character strings they're not so much numbers now I think R is now telling me that it needs numbers to be able to add these things together it can't add the character 120 with the character 100 these need to be actual numbers so let's see what we can do about that let's come back to our studio here and let's actually introduce this new idea

of a Data type or a storage mode in R we have various ways of storing data we've seen one so far called a character string but there are lots of others too among them are these characters we just saw and then double and integer these are both numbers double refers to a decimal number like a 1.5 for instance integer refers to a whole number like just one plain and simple and there are more too but these are the ones that matter here so it seems to me like readline when it Returns us the input from

the user it returned a data type of character or a storage mode of character but what I really need to to add these numbers together is a double or an integer these numeric storage modes down here so let's see if there are functions that could help us actually are so there among them are um uh this idea of as. character as. double and as. integer these are functions that actually take some particular object and convert them to The storage mode we want so I could give as input to as do integer some object and it

will return to me then that same object but now as as integer and this is known as coersion changing the storage mode of an object using a function like this to convert it to some particular new storage mode so let's try these out I'll come to our studio again and I will then try to convert this data to an integer before I actually add it together let's on line Five and Below Let me go ahead and use as. integer I'll type as. integer Mario and as. integer Peach and as. integer Bowser well in this case

hopefully that should work let me go and hit Source again and I'll enter Let Me Clear My terminal first I'll enter 100 votes for Mario 150 for peach and 120 for Bowser and I still see that they're not numeric so one common mistake is that simply running the function here is not Enough to change change this particular object I need to then reassign the return value of this of this function to the object itself so for instance if I want to update the value of Mario I need to reassign it as the return value of

as. integer or I need to update the value of peach by reassigning it as the return value of this function here and same with Bowser as well and now I think if I run this fingers crossed let me come my console again run source and I'll choose 100 for Mario 150 for peach 120 for Bowser and I'll see the total votes was 370 now this is a bit of a longer program we've seen before this is like 11 lines total there's probably a way to actually clean this up a little bit though one way would

be to immediately try to convert the input from the user to an integer so I could use function composition and I could instead immediately pass pass the return value Of readline as the input of as. integer and same for peach and same for Bowser let me actually clean this up have a parentheses there and a parentheses here and now I can get rid of lines 5 through 7 and now it's just a little bit shorter and I'd argue that this is actually a good use of this particular um function composition because now I'm immediately seeing

that okay I want an integer from the user let me go ahead and try this again I'll click source and now I'll see 100 150 120 and I still see 370 now this is pretty good but let's think of a a corner case or some other scenario where there are more than three candidates well in this case I don't want to be stuck always typing plus you know plus plus some new candidate what I want to use instead is likely a function called sum now R because it works so often with data has this function

called called sum that can take as input any number of numeric arguments and sum them Up for me so let's use sum instead in uh total here I actually want to return the result of calling sum with three arguments three inputs the first is Mario second is Peach and the third is Bowser so now some will look at all three of these numbers add them up and store them now in total so I'll clear the console run source and I'll type in 100 votes for Mario 150 for peach and 120 for Bowser and now I'll

see total votes was 370 as well so we've improved Our program so far and we've seen how to use these storage modes to add data together now what questions do we have on this program here or storage modes in general can we enter an argument like an array to this some function yes I heard you mention this idea of an array and if if you're familiar with other programming language you might have heard this idea of an array like some list of data and the question is could we give some not these three separate Values

but actually an array or some list of data uh in fact we can and I suggest we actually take like a 5 minute break and come back to learn more about these structures we can use to represent data just like that see you in five well we're back and so we've seen so far how to write programs that take user input but odds are as you write more our programs you won rely so much on the user to actually enter data for you for you you'll instead read data from a file Like a CSV file

for instance so let's take a look way at ways you can actually represent data and how to use those representations now in R well you often find data is stored in these things called tables and here is an example table I'm trying to represent here candidates like Mario Peach and Bowser and the number of votes they received at the poll so this is actual physical polling location and VIA mail from mail-in ballots let's say so notice how This table has both rows this kind of horizontal orientation and columns this vertical orientation in particular there are

three columns with names so one is candidate where I have the names of my candidates in this case Mario Peach and Bowser over here I have this column called pole represent presenting the number of ballots or votes that Mario Peach and Bowser received at the actual physical polling location so let's say Mario got 37 votes Peach 43 and Bowser 84 now well for the male column there's also going to be some numbers here as well let's say Mario got 63 mailin votes peach got 107 mailin votes and Bowser 36 so this then is our table

of rows and columns and one kind of analysis we might want to do on this table is called a tabulation that is figuring out how many votes we received by poll or by mail and also how many votes each candidate received so we could ask the question how many votes did Mario Receive overall that would be a tabulation along these rows here we could also ask how many votes we receive at the actual physical polling location that would be a tabulation along Ong this column here so these are two questions we actually answer using R

but r at least immediately doesn't give us a way to represent a table exactly like this if you want to store this data kind of long term you need to do so in a file and one popular way of representing data Like this inside of a file is to use a CSV file or a comma separated values file so here is the same representation of that data but now as a CSV file notice here I have those same column names candidate pole and mail and I still have those same column values Mario Peach Bowser 37

4384 and so on but what you might notice is that the columns are now separated using these commas and that makes sense this is a comma separated values file or A CSV file every row is still on its own Row in the file but now these columns are presented now with these commas so let's see how we could use R to read in this CSV file and give us an actual table of data to work with I'll come to our studio here and one of the first things I actually might want to do is clean

up my working space if I want to see what's currently in my environment I can type this function LS at the console and hit enter and now I'll see all the Objects that I still have in my environment some from some prior programs now I probably want to get rid of these as I'm writing some brand new program so to do that I could use this function called RM which stands for remove whereas LS stands for list I could use RM and it turns out that RM takes a named argument called list that is the

list of values I want to remove from my environment and I'll say that this list is what was the result of Calling LS that is it will include Bowser greeting Mario name Peach and total all of these prior objects I no longer want anymore so I'll enter on this and I'll type LS again and now I'll see character parentheses zero which basically says there's nothing here right now there's an empty string nothing at all in my environment so now my environment is clean there are no objects here let me actually create a new program one

called tabulate so I'll Do file. create tabulate R to represent how we're to tabulate this table of data and find the number of votes for each candidate and each voting method let me do enter here and I'll see that file was created for me I'll go to my file explorer and open up tabulate do R so actually notice here in my file explorer I do have this file named votes. CSV if I click on it I can actually see if I click view file here what's inside this file and notice here I have the same

Exact thing we saw on the slides candidate comma pole comma mail and then one row for every Row in my data set so our goal then is to read this CSV and store it in R so you can actually get back a table of data to work with now entirely in R what one function I could use to read data from a file like this is actually called read.table read.table and I can give read.table the name of the file I want to read or to open to load inside of R so that file Name was

votes. CSV and because votes. CSV is in that working directory I can just refer to it by its plain and simple name so a read. table has a return value it's going to give me back a table of data so I'm going to actually store that let's say in this table called votes and now let me run just this line of our code I can do that by hitting run over here or on map I could type command enter on Windows I could type control enter I'll do command enter on Mac and Now I see

according to the console I have now read the votes um data table here so if I want to see what it looks like there are a few ways to do that I could actually look at my environment let's try that first I'll go to environment and I'll see the following that votes seems to have four observations of one variable hm so observations actually refers to the number of rows in this table I've gotten back and variable refers to the number Of columns I've gotten back and you might already be thinking this doesn't seem right cuz

I thought it had at least three rows and I thought it had at least three columns and I seem to have four rows and one column so something might be wrong here if we want to see exactly what happened I can use this function called view capital V and I can pass as input the object I want to view in this case if I run this line of our code I should now see a separate tab that shows Me exactly what is stored in this object and I would say these results are not good this

is not what I want to look like because again we only have one column that R seems to have named V1 and instead of three rows there are four where one row is actually the names of the columns that I wanted uh to be the case this is just not what we want so it seems like read.table needs more information on how to read this particular file and one thing it might Need to know is what is the separator between each of my columns well because this is a CSV file that separator is none other

than a comma so read.table like paste takes a named argument called sep and this will set to be an actual comma so now read.table knows to look for the commas and use those to identify what is a column inside of this data file so let me then rerun this line of code and now view it and I'll see we're getting better so here I have three Columns although one is called V1 one is called V2 there is called V3 and I still have four rows so it's not quite there but we're getting close one other

argument to read.table is in fact this one called header header so header um can be either true or false yes or no do the column names exist in this file in this case they do so I'll say header equals true I'm essentially saying that yes the column names are inside this file you should look for them and you Should use them so let me rerun this I'll rerun line one and now line two and now I think we're in a pretty good place so R actually has stored inside its environment this table for me to

use I see three columns candidate pole and male and now three rows um I could do something to make this a little more readable often we have lots of arguments to these functions it's better to put them on separate lines so according to the style guide for r that kind of tells Me how I should be structuring my file I should do something a bit like this I should put each argument on a new line in my code and then make sure that this closing parentheses is all the way against the left hand side so

this allows me to more quickly see what arguments I have ofly to read.table but the result is exactly the same of course now CSV files are pretty popular and it doesn't make sense to me to always be writing sep equals comma Header equals true and in fact people who work with r they come up with their own function called read.csv to make this much easier for us as programmers so instead of read.table which can work on a variety of of actual data files I'm I might instead use read. CSV because of course I have simply

a CSV here so let's try this I'll run just read. CSV given the file name hit enter here and enter here and it's the same result but now with much less typing much fewer Arguments read. CSV just seems to know more naturally how to read these files called CSV files Okay so we've successfully read this CSV file but the next question is what exactly has it given back to us like certainly it's a table but in R this table has a special name and this special name is a data frame now a data frame is

what we're going to call a data structure some way of organizing our data that Allows us to do things with it much more quickly and those things for a data frame might involve accessing The Columns or accessing the rows or performing things like tabulations as we'll see in just a little bit so here again is our data frame but now it's called votes just like this and let's say I want you want to access some particular columns or some particular rows of this data frame well because it is a data frame R gives me some

special Syntax some special actual characters I could type to access those columns and those rows now one way is to use what we call bracket notation where I could take the name of this data frame use brackets and then Supply the number of the row and the number of the column that I want to see so for instance let's say I wanted to access this particular value Mario in the First Column and the first row well in that case I could type votes bracket 1 comma space one for the first Value in the first row

and the First Column but more often you'll actually want to actually you want to access not just one particular value but all the values in a column or all the values in a row and to do that you can simply omit one or the other the row or the column value so here to access all the candidates I could type votes bracket comma space one omitting the row number but only supplying the column number the First Column here that will give me this List of Mario Peach and Bowser what if I wanted the poll numbers

well I could do votes uh comma 2 and that would give me 37 43 84 and same for male but now with number three so let's try it in R I'll come back over to our studio and go back to my program and our goal again was to sum up let's say the number of votes we got at the polls so I could at least see those values if I do votes bracket and then comma two just like this Let Me Clear My console and run this line and Now I see those same values 37

4384 same thing here 37 4384 even even though in my console they're kind of turned on their side like this these are in fact the same values I've seen in my table but what could go wrong here well if we think about this what's to stop me from rearranging these columns from maybe making mail second column and poll the third if my program can't update based on that kind of rearrangement it's not a very good program so there is Another way to actually access columns in this case using their names so instead of the number

of the column I want to access I can use its name which is much more robust if I change the ordering of the columns I can still access the column I want to access now the Syntax for this looks a bit as follows I would use the data frame's name votes followed by a dollar sign and then I would get back in this case uh the I would actually type the name of The column I want to access and I would then get access to that particular column so votes dollar sign candidate that gives me

access to this column of candidates same thing with poll votes dollar sign poll and same thing with mail votes dollar sign mail this dollar sign has nothing to do with currency it's just a way to actually access a column by a a particular name that it has so let's come back to our studio and try that out now let's say I want to Access the the um the poll column well instead of using the bracket notation with the comma to I could use votes dollar sign pole and now let me clear my terminal my console

down below let me run source and oops let me actually instead run this particular line here I'll get 3743 84 just as we saw before so let me pause here and ask what questions we have about these data frames so far can I ask if I can get some particular uh value from some Particular row by accessing the the votes uh or the the main column votes bracket or dollar sign the column and dollar signs the value yeah great question so we saw earlier there's some syntax can get us access to some particular value in

this data frame let's see that in Action a little bit here too so I'll come back to our studio and let's say we want to access um Mario's number of votes they received at the polls so this would be the second Column and the first row and in R we tend to index things that is start counting from one so the second column and the first row so here let me go ahead and try to access that particular value I could say votes like we saw before open and close brackets and I know again this

is the first row so I'll put that as the one here and then the column number which in this case was the second column counting from one so two this should if I hit enter on this line Of code or command enter should show me that in fact Mario has 37 votes at the polls I could do the same for peach let's say Peach has 43 Bowser Bowser has 84 so that is a way to actually access individual values in our data frame one other way to do this though is take advantage of another data

structure so it turns out that when I access the uh Columns of data frame what we're getting back is no longer a data frame What we're getting back instead is what R calls a vector a vector is simply a list of data that is all of the same storage mode if you've heard of arrays in C's in C or lists in Python a vector is a similar idea but simply a list of values all of the same storage mode so to visualize this let's go back to our data frame here and let's say I want

to access this particular column of votes I could access it using votes dollar sign candidate and when I do that what I Really get back is this separate structure that is just the values from that particular column and now because this is a new structure I could actually use that same bracket notation to ask for particular values from this list of data now again we start counting from one in R so this is our first value second and third if I want the first value the first candidate I could use votes dollar sign candidate and

then bracket one that will give me Mario I Could use votes dollar sign candidate and then bracket 2 that will can to be Peach and same thing with Bowser here so we're kind of taking out or extracting this new vector and we're able to access individual values in it now one example I like to use is example of building blocks here so here we have our very own data frame composed of nine individual pieces of data now when I ask for some particular column from this data frame what I'm effectively doing is taking out One

column and treating it as a separate object I can use in my program now again if I want the first value in this Vector I would simply take the one from the top the second the second one down the third one the third one down now in R we also see that when we print out vectors see them in our console they aren't always kind of vertically arranged like this often they'll be a bit more like this or I might take um in this case kind of put it on its side a bit like this

or I Would now get a B and C kind of left to right like this even though in our data frame it was top to bottom we might get it represented kind of side by side a bit like this so same thing ultimately and there's this idea of kind of extracting this Vector from our data frame so let's try that now in R I'll come back to our studio and let's go ahead and try to access maybe the first value of the poll column now we saw before I could simply use uh bracket one On

this new Vector that I've created by accessing the poll column of votes let me hit command enter and I'll see 37 let me do the second value and I'll see 43 so I think with this we could start to answer one question we had which was how many votes did we get at the polls in total well one way to answer this is to say let's sum up votes dollar sign poll the first value in that poll Vector then let's find that second value as well then let's find that third value just Like this and

sum all of those up and if I hit command enter here I'll see I have 164 votes at the polls but just like we saw before there's probably something that could be better designed about this particular um line of code here and that is if I had more than three candidates like I'd be talking a really really long line of code here so what I could instead do is this I could give some to our earlier question the vector itself simply votes dollar sign pole which we Know is a list of values a vector I

could give that entire Vector to sum that will then know what to do with it and return to me in fact the sum sum of each of those elements of the vector so we call sum here vectorized sum knows what to do when it gets not just a single value as input but an entire vector and R is really built from the ground up with these vectorized functions that can take whole lists of data and operate on them very very Efficiently in this case so here we've answered that question of how many votes we get

at the poll let's think that next one which was how many votes we get in the male well I could do now sum sum and then give the male column which is in fact a vector and have that summed up and we'll see we got 206 votes now in the mail Okay so we've seen vectors and we've seen data frames but we still have one other question to answer which was How many votes did each candidate get now to do that we have to some sum up uh uh sum values across columns here 37 +

63 is Mario's votes 43 + 107 is Peach's votes and 84 plus 36 that's Bowser's votes so let's try it I could maybe find um treat two separate columns here I could do votes and what's that one poll okay votes poll get the first value for Mario and add up let's say the first value in mail a bit like this and that I would argue is Mario's total number of Votes what if we did maybe the second value in pole for peach and let's say the second value in mail also for peach 150 so that's

Peach's total number of votes let's do votes and the third uh element in the poll column and the third element in the male column and that would then be Bowser's votes and I hope you can tell by me being kind of bored while I'm doing this this is like not the best way to do this there is actually a better way that takes Advantage of uh a feature of vectors in R which is Vector arithmetic so not only are vectors hand representing lists of data we can use them to efficiently perform math as well so

if I wanted to sum up all of these vectors and find out what how many votes each candidate got I could simplify this and simply type the following votes dollar sign poll Plus in this case votes dollar sign mail and that would be it but let's visualize this and see why exactly this works so We said we had this idea of vector arithmetic and here again is our data frame so I want to effectively sum up these two columns and return to myself a new total for each candidate for every Row in fact that I

have well to do that I can take out these two vectors pole and male and think of them separately now now I want to add these together like we said 37 + 63 that's Mario's votes 43 + 107 that's Peach's votes well to add these I could use use the plus Sign just like this but if you're new it's not quite obvious what's going to happen here I mean how could I add up these three numbers and these two numbers and what is the structure of what I get back in the end well it turns

out that R uses a new Vector as the result of this and it actually computes the new values element wise element wise meaning it goes top to bottom in each vector and adds those two corresponding elements together so first it looks at The first element in each the of each each column here the pole column and the male column 37 + 63 is 100 then it goes to the next one 43 + 107 is 150 then it goes to the next one here 84 + 36 is now 120 and we now have a brand new

vector by adding up or summing together these two distinct vectors overall to go back to our visualization here of these blocks so you could think of me taking a data frame just like this and kind of extracting these two vectors here let's Say this one and let's say this one let me put this one to the side for now and I want to do some math with these so in this case I'll look at the first element in each Vector in this case four and in this case one or four and one what is the

addition here well 4 + 1 is five so the first element my new Vector would be five then I go to the next two elements here in this case I have five and two what's five + 2 that's seven so the second element my new Vector would be Seven and then later on what do I have I have six and three those added together would be nine my third element in my new Vector would in fact be nine so Vector arithmetic gives us in the end a new vector by actually adding or um in this

case yeah adding these element elements together kind of element wise in the end so let's go back and see how this looks in our studio I'll come back to Studio here and I will then hit enter on this line of code and we'll see that I get Back a vector of three elements 100 150 and 120 so let's pause here and ask what questions do we have on these vectors or vector arithmetic how the sum is being printed without printed on Terminal without using the print function ah good question so you've noticed that when I

um press command enter for instance I'm see the results whatever is stored in this object in my Console without using print and that in fact is a feature of R and R Studio that when I run some particular line of code I can then see the return value of that particular line or whatever it computes for me down in my console it's kind of a handy feature of these things called idees that let me actually understand what's going on in my code all the more clearly good question I have a question uh for in data

frames so uh when we uh in the dollar notation the it returns a Vector what about in the bracket rotation suppose we are taking a for a row one comma does it also return a vector a great question so we just saw with the dollar notation we get back a vector does it do the same thing then with bracket notation so in fact it does let me show you how it works in our studio I'll come back over here and let's say I wanted to um sum up these two columns still but I don't want

to use their names for whatever reason Instead use their bracket um uh kind of representations here so I'll take the the second column of my table here using comma 2 and I'll add together in this case the third column just like this I'll hit enter oops hit enter and I'll see I get back the same result so these each one of these is in fact a vector um where you should be careful though is that there is some notation looks a bit like this um votes in this case uh bracket one notice how It's I'm

not actually asking for a row and a column I'm only asking for some number one this will give me back in this case the data frame but now only the First Column of that data frame so this to be clear is not a vector this is the same data frame but now it's only that single column of that data frame so be careful here um you won't often use this notation but you could get back a data frame if if you use that kind of notation Overall okay a good question and let's now keep going

towards solving our problem of tabulating this data so we saw before that simply adding the mail uh the poll column in votes and the male column in votes would give us the total number of votes for each candidate but I would argue that if I run line three here and I just get back some numbers it's not super clear which candidate these votes belong to so I can actually go ahead and add a new Column to my data frame that includes these particular values here one for Mario one for peach and one for Bowser and

as long as my Vector is of the same number is of the same length as my number of rows in my data frame I should be able to actually add this as a new column to my data frame Now to create this new column I could simply kind of wish it into existence a bit like this I could say votes dollar sign total and I know there is no column called total but I can kind of make one I could say let's assign this Vector to be the new column total in the votes data frame

if I run this line I'll see I don't get a result but I do at least in vot see there is a new column called total that now includes those same elements in my Vector top to bottom okay Okay so we've solved that problem and our next step might be to now save this file again to keep track of it later on to share it with a friend And to do that I could use the write. CSV function we saw read. CSV but we also have write.csv to actually save this file as a CSV let

me try it I'll say write. CSV and I'll call this one um let's say totals. CSV for the total number of votes now write. CSV actually needs two arguments one is the file name like we just said here but even before that it needs to know what data frame to write to the file so in this case it's our votes data frame Now by convention In its documentation we see the first argument to write. CSV is that data frame the second is the name of the file itself so let me clear my console let me

run wr. CSV and now if I go to my file explorer I should see down below oops totals. CSV and now let me view file and I should see something a bit like my data frame there's a few other features here though I see that um there's like these numbers here one 2 3 and this empty number up this empty Value up here these are in fact the row names of this data frame so not only do data frames have column names like we saw here they also have row names and by default they start

counting at one and going to two then three then four and so on and I can actually tell wr. CSV whether or not I want those row names printed in my CSV you often won't um because it kind of makes it a wacky format where we have this empty value up here and it's probably just not worth it For you so you could specify the following you could say row. names row. names equals false meaning that wr. CSV should not write any row names to the CSV even though they exist in data frame so let

me go ahead and clear my console I'll do command enter here and now I should see if I go back to totals. CSV I now have much cleaner CSV without those particular row names if I did though want to access those in R I could use these functions I could say call names Votes which will return to me the columns I have inside of my votes data frame or row names votes which gives me access to the row names of this particular data frame as well all right so you've seen here how we've been able

to save this data frame how to read data from a file and save it back to a file as well what we'll do next is actually take advantage of online data sets data other folks have written for us and use those to explore Data in r as well see you all in five well we're back and so we've seen a few examples of how to use R so far we've seen seen how to take user input and actually deal with that in our own programs we've also found how to use data we put in our

own file for ourselves but often when you use R you'll be working with not your own data but somebody else's and so we'll do exactly that here for the rest of lecture now you may have heard 538 as Mentioned earlier in lecture they work a lot with data and they often put that data online for others to use and analyze themselves in fact they worked on a poll that asked people in the US about their voting habits do they plan to vote how often do they vote um what encourages them or motivates them to vote

or what are the reasons they actually don't vote in the first place so here I have the URL that actually includes this data file online on the Internet somewhere else and if you look at the end here you'll see the file name non-voters data.csv so this tells me that this data even though it is online is still stored in that same familiar file format called a CSV and now on the second line of code I can still use read CSV all I'm doing now though is telling read CSV where to look where to go find

this data file on the internet and bring it down for me here in my own R environment and I'm storing the result Now that data frame as a data frame called voters so let's take a peek and see what's inside I'll come to our studio over here and let me do the uh function view view and I'll view voters and whoops let me actually let me first run these lines of code so let me run line one to create a new object called URL let me run line two to actually load that data and now

once I have those objects loaded let me go ahead and view voters and this is the data frame it is A big one uh if we scroll all the way to the side you'll see lots of numbers lots of columns if you scroll down you'll see lots and lots of rows and one question you might have is well just how many rows and columns are there in this data frame one way to answer that at least in our code itself is to use these functions n row and N call which stands for number of rows

or number of columns respectively so let me try n row to get a sense of how many rows we have in this Data frame I'll do n row voters and it seems like down my console here there are 5,836 rows of data now each row of data represents a particular voter or maybe a non-voter somebody who lives in the US and was asked to fill out this poll um where they talk about why they vote or why they don't vote but in the end each row is its own voter now let's see how many columns

we have n call voters it seems like we have 119 columns which is A lot of columns each column in this case represents a question asked to that voter and if I go back to the voter's view here I might see like q1 for instance it seems like the voter who is given the ID 47 470,000 01 answered one to question one and so it's a little Arcane right now but thankfully 538 has given us a tool we can use to interpret some of this data in fact that tool is called a code book and

you might often use the same in your Own work with data analysis where a code book tells you exactly what questions or columns mean in some particular context so in this case I do see q1 or q21 or q22 and if I'm new to this data set I don't know what the heck that means but I could look in the code book that 538 gave me in which case they say q1 ask participants this Q2 ask participants this and so on and so forth for all questions we have inside our data set so let's actually

take a peek At one particular column I know this column exists because I looked in the code book to find it out um there's a column called voter uncore category that actually tells us how each voter represented themselves in terms of their voting habits so to access that column as we saw before I could use voters the name of data frame followed by a dollar sign followed by the name of the column voter category and if I hit hit command enter here we'll I'll see at least some Of the results from that column some of

the elements here and now you'll actually see why that bracket one that we saw initially is kind of useful now as we work with bigger and bigger data sets notice that that bracket notation tells us exactly where in our list or our Vector we are notice how this one here means this always that is the first element in our Vector of all of these respons responses this always well that's the seventh element and our Vector of all these responses and same thing for this rarely SL never that is the 13th element and so on and

so forth all the way down now there's more than what looks to be 900 or about a thousand entries in our Vector here we just can't print all of them because it would be a really really long output to our console now I'm curious I saw a lot of values here but I want to know exactly what ways voters could have categorized themselves like out of all of these Responses what are the unique ones and turns out R has a function called unique that I can use to actually figure out what are those unique values

in this Vector so let me give this Vector called a voter category or the column voter category from voters to this function called unique just like this I'll do command enter to run this line and now I'll see I only get back three elements always sporadic or rarely slash Never So it seems like voters could have Categorized themselves in one of three categories they always vote they sporadically or occasionally vote um or they rarely SL never vote at all so interesting data here there's another actual column I'm interested in too um which is happens to

be question 22 so if I look at that here I'll type voters question 22 and hit command enter and here I'll see all the responses for this particular question and it seems to me like I'm seeing some numbers but also These Nas and before we dive into that let's take a peek at what this question is actually asking users so it turns out this question 22 is asking users this you previously indicated that you are not registered to vote which of the following reasons best describes why you are not registered to vote and user given

several responses 1 through 7even I believe where one was I don't have time two was I don't trust the political system three was I don't know and so on And so forth and it seems to me like when we saw this data set we had some numbers here 1 through 7 but we also had a lot of these Nas and I'm curious if you have a sense of what those Nas might be there're certainly not any of these options what do you think those Naas might represent in this particular column of data here uh not

answered or not accustomed to be in the list a great guess so maybe it means something like not answered or There's just no data there and in fact if we look at the context of this question we can actually figure it out like you did um it says you previously indicated you are not registered to vote so in the US we often have to register ourselves to be able to vote but some people have done that and some people haven't it seems like this question was asked to only those participants who did not register to

vote or who were not currently registered to vote so it would Make sense then people who actually are registered couldn't have answered that question and in which case we don't want to have like a empty string or some s number there we could instead use one of R's special values now R comes with these Special values to indicate something very special in this case NA means not available there could be data here but there isn't that's what na in particular means there are others too um you might see INF and negative INF these Mean infinity

or negative Infinity numbers that are so big r can't represent them appropriately well we saw an here for not available we also have n lowercase a n which stands for not a number you could think of if I tried to ask you well what is infinity divided infinity and you probably look at me confused you would say that's not a number and I would say yes that's exactly correct R says n an is that result in this particular case and we Also have this value called null capital N L which is similar in spirit to

na but slightly different uh Na as we said before stands for not available there could be data here but there isn't null is simply a special value meaning absolutely nothing I can have a vector of Nas meaning that maybe I have five Naas in this Vector there are five places data could be but I can't have a vector of null null is literally nothing it means absolutely nothing at all so Different slightly from na in this case so let's go back to our um our studio here and let's take a peek at this particular um

this particular column so it seems like have a lot of Nas and one thing I'm interested in is what kinds of unique values are we seeing inside of this particular column so I could use unique again and hit command enter and now I'll see if I clear my terminal run it again I'll see clearly that I have several different possible values here I Have na 7 6 21 1 4 5 and 3 and this makes sense like we saw earlier that people were given several options 1 through 7 and we have people who didn't respond

either with na or 1 through 7 for those other responses there what we don't have actually is -1 and I actually tried kind of hard to figure out why negative 1 is here and I couldn't so sometimes data is just messy there are values you don't know um and can't deal with so just keep that in Mind as you work with data sets other people have given you now one more column that I found interesting um was this one so it was voters question 21 question 21 and the question uh 21 asked this it said

there will be an election for President members of US Senate House Representatives and other state local offices do you plan to vote in that election ction and it gave people a few response a few potential options here uh one meant yes two meant no three meant Unsure or undecided I don't know if I'll vote in that election so let's see what we actually got back as responses for this particular question I'll come back to our studio here and why don't we take a peek at voters question 21 I'll hit command enter and here is the

first 1,000 or so entries to this particular question so we see a lot of ones which could mean yeses I see some twos which could mean no three unsure undecided I do see a Negative one down here which seems showing up for some unknown reason but we could get a better sense if I used unique so I use unique voters question 21 and now I'll see again my unique responses are 1 2 3 or -1 so at this point I'm kind of getting tired of looking at my Vector here and and trying to convert in

my head between these ones twos 3es negative 1es to the actual responses participants gave and it turns out there is a way in R to make It much easier for myself to work with data that's exactly like this this data has some set number of categories of responses as we saw with unique here the categories are in this case 1 2 3 or negative 1 those are the only possible values that could be stored in this vector and we also know that one two and three correspond to some real life actual phrase that pitchin actually

responded to in this poll so to help us represent this kind of data we can use Something that R calls a factor a factor now I can create a factor using the factor function and a factor function takes a vector like the one I just have one I just had here and converts it into a factor so let's try that I'll say Factor voters q21 just like this and I'll hit enter again command enter and I'll see a very similar thing if I scroll up I have all the same data everything is just as it

was but now down below I see levels levels and what Does that look like to you well we just saw before we have several unique categories of data inside this Vector negative 1 1 2 and three and it seems like this Factor took those unique values and made it this Factor's level so the unique possible categories of data inside of this Factor here so factors are great for representing this categorical data data that can actually be in one category or another now one thing I could do is try to make it Easier to read these

categories as English phrases and to do that I could pass Factor another argument this one called labels so not only do I give it my Vector that has certain categories of data I also give it some labels to apply to each of those categories one after the other so here let me use labels as the argument and let me give it a vector itself so we saw before down below that we have a a a set of levels number of categories in this Data - 1 1 2 and 3 But now I could actually give

those uh levels those categories some particular name so I'll give it a vector itself and I'll connect make a vector in R using this C function which stand for combine I'll create this Vector where -1 let's say maps to or corresponds to this value as a question mark I don't know what the heck it is maybe one though we saw was yes and two was no and three was unsure or undecided exactly like this so now notice that when I look at my levels Negative one that corresponds to the first label question mark what the

heck is it I don't know then yes that corresponds to the uh level one then level two corresponds to no level three corresponds to unsure or undecided and now if I clear my console and run this particular line of code well now I have something much more user friendly I can actually see not ones twos and threes but now labels for those ones twos and threes and here I see yes unsure Undecided no let me see if I can find a question mark here um yep there's one so 517 seems to be a question mark

So now I've converted this Vector into my own Factor now it's also not a good idea to have data we don't know what to do with like I said this negative one I really don't know where it came from and in that case I could tell this Factor when it's being created to exclude that value all together I could use the exclude uh parameter the argument here and say I Want to exclude some Vector of given values that are part of this Vector I want to just take out all together so I'll say -1 is

the value I want to exclude this is a vector of length one but the value I want to exclude in this case is -1 and now I can actually remove this uh label here because my only categories will now be yes no unsure undecided or underneath the hood that one two or three so let me clear my console again let me rerun Factor here And now let me see well now my is getting much cleaner I have yes no unsure undecided and if I go back to that 517 that we saw a question mark in

up here let me see if I can find it again 517 almost there I see now it's an NA which stands for of course not available we excluded it all together from this particular Factor so what questions do we have now on taking vectors and converting into these factors that involve categories of data And labeling those categories of data uh why have we used Factor instead of s factor like before so we've just seen here this function called Factor but there is a function called as. Factor um similar to what we saw before as. character

or as. integer or as. double we could use I think either one to get the same result um in general though let me look at the documentation let me go back to our studio here let me pull up the documentation for Factor Let Me Clear My console let me do question mark Factor so this is here how we're supposed to use that factor function we can see here some of the arguments the um actual parameters I gave like the um labels here as well let's now try to find the documentation for as. factor as. factor

let me go back over here type as. factor and now I'll actually see I'll see the same documentation page and so to me this is symbolizing that these are very closely related if I were to Scroll down here I could see I think I see it here is. factor as. factor are the membership and coion function for these classes so essentially if you want to make a new factor from a vector you would use Factor if you have something that you want to convert to a factor that is already something else entirely like maybe not

even Vector you might be able to use as. Factor so I hope that at least gives you some idea of the Difference between as. factor and Factor as the function itself all right what other questions do we have let's take a few more how is a factor different from a table ah good question so we saw that a table has rows and columns in it um a factor though is simply a list of data a bit like a vector it's onedimensional and let me show you some slides that could hopefully actually help you visualize factors

in general so if I Come back over here let me find the right slide to go to um here in general is this idea of a factor so we had of course this Vector that was previously only ones twos 3es and twos and On's negative 1 but when we converted to a factor we did the following we found the unique categories of data in this Vector just like this 1 2 3 and - 1 what we then did is we sought out those categories and called them essentially levels the categories of our data are The

levels here and we applied some label to each of those levels basically saying -1 becomes question mark one becomes yes two becomes no three becomes unsure SL undecided now notice that this Factor here is still a vector well still kind of onedimensional it's a list of data it's not two- dimensional like a data frame was or a table was it's only onedimensional and when we apply these labels we convert these ones twos 3es Negative 1es instead to yes no unsure and question mark and if we exclude something like we did with negative 1 we would

then get na instead of negative 1 in the end so I hope that helps at least a little bit answering that question let's take one more here I wanted to understand whether like just like you showed how to exclude a negative value what if I want to there are number of negative values on the data free and I want to exclude all of the negative Values ah good question so the first part is you want to represent negative values and how do you do that and the second part is how do we exclude those negative

values let's say another kind of similar case is let's say we have lots of Na values how do we get rid of them so let me answer your first one and actually tee up that second question for next lecture so come back to our studio and let's try presenting some negative values here um we saw before that I had This idea of negative one if I want to have some negative value in our studio I can simply put a negative or a dash in front of any particular value so here let's say is -1 but

to your question then of how we could exclude these values we don't want that's a problem of filtering or subsetting our data which we actually learn about next lecture so we've seen so far how to represent data in R how to take all kinds of data like votes um tables of votes and represent Them in R to manipulate them and so on what we'll see next time is how to actually transform that data removing values we don't want adding data we do and for that we'll see you all next time