Create a matrix with two columns.
Create a vector with the row names 
8th
and 
9th
.
Use this vector as row indices for the data frame 
baskets.df
.
Assign the values in the matrix to the rows with names 
8th
and 
9th
. Because
these rows don’t exist yet, R will create them automatically.
Actually, you don’t need to construct the matrix first; you can just use a
vector instead. Exactly as with matrices, data frames are filled column wise.
So, the following code gives you exactly the same result:
> baskets.df[c(‘8th’,’9th’), ] <- c(3,8,9,4)
This process works only for data frames, though. If you try to do the same
thing with matrices, you get an error. In the case of matrices, you can only use
indices that exist already in the original object.
You have multiple equally valid options for adding observations to a data
frame. Which option you choose depends on your personal choice and the
situation. If you have a matrix or data frame with extra observations, you can
use 
rbind()
. If you have a vector with row names and a set of values, using
the indices may be easier.
Adding variables to a data frame
A data frame also can be extended with new variables. You may, for example,
get data from another player on Granny’s team. Or you may want to calculate a
new variable from the other variables in the dataset, like the total sum of baskets
made in each game (see also Chapter 13).
Adding a single variable
Pdf text search - search text inside PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Learn how to search text in PDF document and obtain text content and location information
how to search pdf files for text; pdf make text searchable
Pdf text search - VB.NET PDF Text Search Library: search text inside PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Learn How to Search Text in PDF Document and Obtain Text Content and Location Information in VB.NET application
can't select text in pdf file; convert pdf to searchable text online
There are three main ways of adding a variable. Similar to the case of adding
observations, you can use either the 
cbind()
function or the indices. We illustrate
both methods later in this section.
You also can use the dollar sign to add an extra variable. Imagine that Granny
asked you to add the number of baskets of her friend Gabrielle to the data frame.
First, you would create a vector with that data like this:
> baskets.of.Gabrielle <- c(11,5,6,7,3,12,4,5,9)
To create an extra variable named 
Gabrielle
with that data, you simply do
the following:
> baskets.df$Gabrielle <- baskets.of.Gabrielle
If you wanted to check whether this worked, but you didn’t want to display
the complete data frame, you could use the 
head()
function. This function
takes two arguments: the object you want to display and the number of rows
you want to see. To see the first four rows of the new data frame, 
baskets.df
,
use the following code:
> head(baskets.df, 4)
Granny Geraldine Gabrielle
1st     12         5        11
2nd      4         4         5
3rd      5         2         6
4th      6         4         7
Adding multiple variables using cbind
As we mention earlier, you can pretend your data frame is a matrix and use
the 
cbind()
function to do this. Contrary to when you use 
rbind()
on data frames,
you don’t even need to worry about the row or column names. Let’s create a new
data frame with the goals for Gertrude and Guinevere. You can combine both into a
data frame by typing the following code in the editor and running it in the console:
> new.df <- data.frame(
+   Gertrude  =  c(3,5,2,1,NA,3,1,1,4),
+   Guinevere =  c(6,9,7,3,3,6,2,10,6)
+ )
C# Word - Search and Find Text in Word
C# Word - Search and Find Text in Word. Learn How to Search Text in PDF Document and Obtain Text Content and Location Information. Overview.
how to make a pdf document text searchable; search a pdf file for text
C# PowerPoint - Search and Find Text in PowerPoint
C# PowerPoint - Search and Find Text in PowerPoint. Learn How to Search Text in PDF Document and Obtain Text Content and Location Information. Overview.
select text in pdf reader; how to select text in pdf reader
Although the row names of the data frames 
new.df
and 
baskets.df
differ, R
will ignore this and just use the row names of the first data frame in the 
cbind()
function, as you can see from the output of the following code:
> head(cbind(baskets.df, new.df), 4)
Granny Geraldine Gabrielle Gertrude Guinevere
1st     12         5        11        3         6
2nd      4         4         5        5         9
3rd      5         2         6        2         7
4th      6         4         7        1         3
When using a data frame or a matrix with column names, R will use those as
the names of the variables. If you use 
cbind()
to add a vector to a data frame, R
will use the vector’s name as a variable name unless you specify one yourself, as
you did with 
rbind()
.
If you bind a matrix without column names to the data frame, R will
automatically use the column numbers as names. That will cause a bit of trouble
though, because plain numbers are invalid object names and, hence, more difficult
to use as variable names. In this case, you’d better use the indices.
Whenever you want to use a data frame and don’t want to continuously
have to type its name followed by 
$
, you can use the functions 
with()
and
within()
, as explained in Chapter 13. With the 
within()
function, you also can
easily add variables to a data frame.
Combining Different Objects in a List
In the previous sections, you discover how much data frames and matrices are
treated alike by many R functions. But contrary to what you would expect, data
frames are not a special case of matrices but a special case of lists. A list is a very
general and flexible type of object in R. Many statistical functions you use in
Chapters 14 and 15 give a list as output. Lists also can be very helpful to group
different types of objects, or to carry out operations on a complete set of different
objects. You do the latter in Chapter 9.
Creating a list
C# PDF delete text Library: delete, remove text from PDF file in
The following C# coding example illustrates how to perform PDF text deleting function in your .NET project, according to search option. // Open a document.
how to select text on pdf; how to select all text in pdf file
C# PDF replace text Library: replace text in PDF content in C#.net
The following C# coding example illustrates how to perform PDF text replacing function in your .NET project, according to search option. // Open a document.
convert pdf to searchable text; pdf search and replace text
It shouldn’t come as a surprise that you create a list with the 
list()
function.
You can use 
list()
function in two ways: to create an unnamed list or to create a
named list. The difference is small; in both cases, think of a list as a big box filled
with a set of bags containing all kinds of different stuff. If these bags are labeled
instead of numbered, you have a named list.
Creating an unnamed list
Creating an unnamed list is as easy as using the 
list()
function and putting
all the objects you want in that list between the 
()
. In the previous sections, you
worked with the matrix 
baskets.team
, containing the number of baskets Granny
and Geraldine scored this basketball season. If you want to combine this matrix
with a character vector indicating which season we’re talking about here, you
simply do the following:
> baskets.list <- list(baskets.team, ‘2010-2011’)
If you look now at the object 
baskets.list
, you see the following output:
> baskets.list
[[1]]
1st 2nd 3rd 4th 5th 6th
Granny     12   4   5   6   9   3
Geraldine   5   4   2   4  12   9
[[2]]
[1] “2010-2011”
The object 
baskets.list
contains two elements: the matrix and the season.
The numbers between the 
[[]]
indicate the “bag number” of each element.
Creating a named list
In order to create a labeled, or named, list, you simply add the labels before
the values between the 
()
of the 
list()
function, like this:
> baskets.nlist <- list(scores=baskets.team, season=’2010-2011’)
This is exactly the same thing you do with data frames in the “Manipulating
Values in a Data Frame” section, earlier in this chapter. And that shouldn’t surprise
VB.NET PDF replace text library: replace text in PDF content in vb
The following coding example illustrates how to perform PDF text replacing function in your VB.NET project, according to search option.
find text in pdf files; pdf text select tool
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
PDF Read. Text: Extract Text from PDF. Text: Search Text in PDF. Image: Extract Image from PDF. Easy to search PDF text in whole PDF document.
search pdf documents for text; pdf text search
you, because data frames are, in fact, a special kind of named lists.
If you look at the named list 
baskets.nlist
, you see the following output:
> baskets.nlist
$scores
1st 2nd 3rd 4th 5th 6th
Granny     12   4   5   6   9   3
Geraldine   5   4   2   4  12   9
$season
[1] “2010-2011”
Now the 
[[]]
moved out and made a place for the 
$
followed by the name of
the element. In fact, this begins to look a bit like a data frame.
Data frames are nothing but a special type of named lists, so all the tricks
in the following sections can be applied to data frames as well. We repeat: All
the tricks in the following sections — really, all of them — can be used on data
frames as well.
Playing with the names of elements
Just as with data frames, the names of a list are accessed using the 
names()
function, like this:
> names(baskets.nlist)
[1] “scores” “season”
This means that you also can use the 
names()
function to add names to the
elements or change the names of the elements in the list in much the same way
you do with data frames.
Getting the number of elements
Data frames are lists, so it’s pretty obvious that the number of elements in a
list is considered the length of that list. So, to know how many elements you have
in 
baskets.list
, you simply do the following:
C# PDF Text Highlight Library: add, delete, update PDF text
The following C# coding example illustrates how to perform PDF text highlight function in your .NET project, according to search option. // Open a document.
how to make a pdf file text searchable; make pdf text searchable
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Page: Rotate a PDF Page. PDF Read. Text: Extract Text from PDF. Text: Search Text in PDF. Easy to search PDF text in whole PDF document.
select text in pdf reader; search a pdf file for text
> length(baskets.list)
[1] 2
Extracting elements from lists
The display of both the unnamed list 
baskets.list
and the named list
baskets.nlist
show already that the way to access elements in a list differs from
the methods you’ve used until now.
That’s not completely true, though. In the case of a named list, you can access
the elements using the 
$
, as you do with data frames. For both named and
unnamed lists, you can use two other methods to access elements in a list:
Using 
[[]]
gives you the element itself.
Using 
[]
gives you a list with the selected elements.
Using [[]]
If you need only a single element and you want the element itself, you can
use 
[[]]
, like this:
> baskets.list[[1]]
1st 2nd 3rd 4th 5th 6th
Granny     12   4   5   6   9   3
Geraldine   5   4   2   4  12   9
If you have a named list, you also can use the name of the element as an
index, like this:
> baskets.nlist[[‘scores’]]
1st 2nd 3rd 4th 5th 6th
Granny     12   4   5   6   9   3
Geraldine   5   4   2   4  12   9
In each case, you get the element itself returned. Both methods give you the
original matrix 
baskets.team
.
You can’t use logical vectors or negative numbers as indices when using
[[]]
. You can use only a single value — either a (positive) number or an
element name.
Using []
You can use 
[]
to extract either a single element or multiple elements from a
list, but in this case the outcome is always a list. 
[]
are more flexible than 
[[]]
,
because you can use all the tricks you also use with vector and matrix indices. 
[]
can work with logical vectors and negative indices as well.
So, if you want all elements of the list 
baskets.list
except for the first one,
you can use the following code:
> baskets.list[-1]
[[1]]
[1] “season 2010-2011”
Or if you want all elements of 
baskets.nlist
where the name equals
‘season’
, you can use the following code:
> baskets.nlist[names(baskets.nlist)==’season’]
$season
[1] “2010-2011”
Note that, in both cases, the returned value is a list, even if it contains only
one element. R simplifies arrays by default, but the same doesn’t count for lists.
Changing the elements in lists
Much like all other objects we cover up to this point, lists aren’t static objects.
You can change elements, add elements, and remove elements from them in a
pretty straightforward matter.
Changing the value of elements
Assigning a new value to an element in a list is pretty straightforward. You use
either the 
$
or the 
[[]]
to access that element, and simply assign a new value. If
you want to replace the scores in the list 
baskets.nlist
with the data frame
baskets.df
, for example, you can use any of the following options:
> baskets.nlist[[1]] <- baskets.df
> baskets.nlist[[‘scores’]] <- baskets.df
> baskets.nlist$scores <- baskets.df
If you use 
[]
, the story is a bit different. You can change elements using 
[]
as
well, but you have to assign a list of elements. So, to do the same as the preceding
options using 
[]
, you need to use following code:
> baskets.nlist[1] <- list(baskets.df)
All these options have exactly the same result, so you may wonder why you
would ever use the last option. Simple: Using 
[]
allows you to change more than
one element at once. You can change both the season and the scores in
baskets.list
with the following line of code:
> baskets.list[1:2] <- list(baskets.df, ‘2009-2010’)
This line replaces the first element in 
baskets.list
with the value of
baskets.df
, and the second element of 
baskets.list
with the character value
‘2009-2010’
.
Removing elements
Removing elements is even simpler: Just assign the 
NULL
value to the element.
In most cases, the element is simply removed. To remove the first element from
baskets.nlist
, you can use any of these (and more) options:
> baskets.nlist[[1]] <- NULL
> baskets.nlist$scores <- NULL
> baskets.nlist[‘scores’] <- NULL
Using single brackets, you again have the possibility of deleting more than one
element at once. Note that, in this case, you don’t have to create a list with the
value 
NULL
first. To the contrary, if you were to do so, you would give the element
the value 
NULL
instead of removing it, as shown in the following example:
> baskets.nlist <- list(scores=baskets.df, season=’2010-2011’)
> baskets.nlist[‘scores’] <- list(NULL)
> baskets.nlist
$scores
NULL
$season
[1] “2010-2011”
Adding extra elements using indices
In the section “Adding variables to a data frame,” earlier in this chapter, you
use either the 
$
or indices to add extra variables. Lists work the same way; to add
an element called 
players
to the list 
baskets.nlist
, you can use any of the
following options:
> baskets.nlist$players <- c(‘Granny’,’Geraldine’)
> baskets.nlist[[‘players’]] <- c(‘Granny’,’Geraldine’)
> baskets.nlist[‘players’] <- list(c(‘Granny’,’Geraldine’))
Likewise, to add the same information as a third element to the list
baskets.list
, you can use any of the following options:
> baskets.list[[3]] <- c(‘Granny’,’Geraldine’)
> baskets.list[3] <- list(c(‘Granny’,’Geraldine’))
These last options require you to know exactly how many elements a list has
before adding an extra element. If 
baskets.list
contained three elements already,
you would overwrite that one instead of adding a new one.
Combining lists
If you wanted to add elements to a list, it would be nice if you could do so
without having to worry about the indices at all. For that, the only thing you need is
a function you use extensively in all the previous chapters, the 
c()
function.
That’s right, the 
c()
function — which is short for concatenate — does a lot
more than just creating vectors from a set of values. The 
c()
function can combine
different types of objects and, thus, can be used to combine lists into a new list as
well.
In order to be able to add the information about the players, you have to
create a list first. To make sure you have the same output, you have to rebuild the
original 
baskets.list
as well. You can do both using the following code:
> baskets.list <- list(baskets.team,’2010-2011’)
> players <- list(rownames(baskets.team))
Then you can combine this 
players
list with the list 
goal.list
like this:
> c(baskets.list, players)
[[1]]
1st 2nd 3rd 4th 5th 6th
Granny     12   4   5   6   9   3
Geraldine   5   4   2   4  12   9
[[2]]
[1] “2010-2011”
[[3]]
[1] “Granny”    “Geraldine”
If any of the lists contains names, these names are preserved in the new
object as well.
Reading the output of str() for lists
Many people who start with R get confused by lists in the beginning. There’s
really no need for that — there are only two important parts in a list: the elements
and the names. And in the case of unnamed lists, you don’t even have to worry
about the latter. But if you look at the structure of 
baskets.list
in the following
output, you can see why people often shy away from lists.
> str(baskets.list)
List of 2
$ : num [1:2, 1:6] 12 5 4 4 5 2 6 4 9 12 ...
..- attr(*, “dimnames”)=List of 2
.. ..$ : chr [1:2] “Granny” “Geraldine”
.. ..$ : chr [1:6] “1st” “2nd” “3rd” “4th” ...
$ : chr “2010-2011”
This really looks like some obscure code used by the secret intelligence
services during World War II. Still, when you know how to read it, it’s pretty easy to
read. So let’s split up the output to see what’s going on here:
The first line simply tells you that 
baskets.list
is a list with two elements.
Documents you may be interested
Documents you may be interested