加载中…R软件中读入纯文本文件的方法read.table（）和scan（）函数
(2011-07-26 16:36:04)
标签：
杂谈 |
分类： R软件学习 |
| read.table {utils} | R Documentation |
Data Input
Description
Reads a file in table format and creates a data frame from it, with cases corresponding to lines and variables to fields in the file.
Usage
read.table(file, header = FALSE, sep = "", quote = "\"'",
dec = ".", row.names, col.names,
as.is = !stringsAsFactors,
na.strings = "NA", colClasses = NA, nrows = -1,
skip = 0, check.names = TRUE, fill = !blank.lines.skip,
strip.white = FALSE, blank.lines.skip = TRUE,
comment.char = "#",
allowEscapes = FALSE, flush = FALSE,
stringsAsFactors = default.stringsAsFactors(),
fileEncoding = "", encoding = "unknown")
read.csv(file, header = TRUE, sep = ",", quote="\"", dec=".",
fill = TRUE, comment.char="", ...)
read.csv2(file, header = TRUE, sep = ";", quote="\"", dec=",",
fill = TRUE, comment.char="", ...)
read.delim(file, header = TRUE, sep = "\t", quote="\"", dec=".",
fill = TRUE, comment.char="", ...)
read.delim2(file, header = TRUE, sep = "\t", quote="\"", dec=",",
fill = TRUE, comment.char="", ...)
Arguments
file |
the name of the file which the data are to be read from. Each
row of the table appears as one line of the file. If it does not
contain an absolute path, the file name is
relative to the current working directory, getwd().
Tilde-expansion is performed where supported. As from R 2.10.0 this
can be a compressed file (see file).
Alternatively,
|
header |
a logical value indicating whether the file contains the names
of the variables as its first line. If missing, the value is
determined from the file format: header is set to
TRUE if and only if the first row contains one fewer
field than the number of columns. |
sep |
the field separator character. Values on each line of the file
are separated by this character. If sep = "" (the
default for read.table) the separator is ‘white
space’, that is one or more spaces, tabs, newlines or carriage
returns. |
quote |
the set of quoting characters. To disable quoting altogether,
use quote = "". See scan
for the behaviour on quotes embedded in quotes. Quoting is only
considered for columns read as character, which is all of them
unless colClasses is specified. |
dec |
the character used in the file for decimal points. |
row.names |
a vector of row names. This can be a vector giving the actual
row names, or a single number giving the column of the table which
contains the row names, or character string giving the name of the
table column containing the row names.
If there is a header and the first row contains one fewer field
than the number of columns, the first column in the input is used
for the row names. Otherwise if Using |
col.names |
a vector of optional names for the variables. The default is to
use "V" followed by the column number. |
as.is |
the default behavior of read.table is to convert
character variables (which are not converted to logical, numeric or
complex) to factors. The variable as.is controls the
conversion of columns not otherwise specified by
colClasses. Its value is either a vector of logicals
(values are recycled if necessary), or a vector of numeric or
character indices which specify which columns should not be
converted to factors.
Note: to suppress all conversions including those of numeric
columns, set Note that |
na.strings |
a character vector of strings which are to be interpreted as
NA
values. Blank fields are also considered to be missing values in
logical, integer, numeric and complex fields. |
colClasses |
character. A vector of classes to be assumed for the columns.
Recycled as necessary, or if the character vector is named,
unspecified values are taken to be NA.
Possible values are Note that |
nrows |
integer: the maximum number of rows to read in. Negative and other invalid values are ignored. |
skip |
integer: the number of lines of the data file to skip before beginning to read data. |
check.names |
logical. If TRUE then the names of the variables
in the data frame are checked to ensure that they are syntactically
valid variable names. If necessary they are adjusted (by
make.names)
so that they are, and also to ensure that there are no
duplicates. |
fill |
logical. If TRUE then in case the rows have
unequal length, blank fields are implicitly added. See
‘Details’. |
strip.white |
logical. Used only when sep has been specified,
and allows the stripping of leading and trailing white space from
character fields (numeric fields are
always stripped). See scan
for further details, remembering that the columns may include the
row names. |
blank.lines.skip |
logical: if TRUE blank lines in the input are
ignored. |
comment.char |
character: a character vector of length one containing a single
character or an empty string. Use "" to turn off the
interpretation of comments altogether. |
allowEscapes |
logical. Should C-style escapes such as \n be processed or read verbatim (the default)? Note
that if not within quotes these could be interpreted as a delimiter
(but not as a comment character). For more details see
scan. |
flush |
logical: if TRUE, scan will flush to
the end of the line after reading the last of the fields requested.
This allows putting comments after the last field. |
stringsAsFactors |
logical: should character vectors be converted to factors? Note
that this is overridden by as.is and
colClasses, both of which allow finer control. |
fileEncoding |
character string: if non-empty declares the encoding used on a
file (not a connection) so the character data can be re-encoded.
See file
and ‘Note’. |
encoding |
encoding to be assumed for input strings. It is used to mark
character strings as known to be in Latin-1 or UTF-8 (see
Encoding):
it is not used to re-encode the input, but allows R to handle
encoded strings in their native encoding (if one of those two). See
‘Value’. |
... |
Further arguments to be passed to read.table. |
Details
This function is the principal means of reading tabular data into R.
Unless colClasses is specified, all columns are
read as character columns and then converted using type.convert
to logical, integer, numeric, complex or (depending on
as.is) factor as appropriate. Quotes are (by default)
interpreted in all fields, so a column of values like
"42" will result in an integer column.
A field or line is ‘blank’ if it contains nothing (except whitespace if no separator is specified) before a comment character or the end of the field or line.
If row.names is not specified and the header line
has one less entry than the number of columns, the first column is
taken to be the row names. This allows data frames to be read in
from the format in which they are printed. If
row.names is specified and does not refer to the first
column, that column is discarded from such files.
The number of data columns is determined by looking at the first
five lines of input (or the whole file if it has less than five
lines), or from the length of col.names if it is
specified and is longer. This could conceivably be wrong if
fill or blank.lines.skip are true, so
specify col.names if necessary.
read.csv and read.csv2 are identical
to read.table except for the defaults. They are
intended for reading ‘comma separated value’ files (‘.csv’) or (read.csv2) the variant used
in countries that use a comma as decimal point and a semicolon as
field separator. Similarly, read.delim and
read.delim2 are for reading delimited files,
defaulting to the TAB character for the delimiter. Notice that
header = TRUE and fill = TRUE in these
variants, and that the comment character is disabled.
The rest of the line after a comment character is skipped;
quotes are not processed in comments. Complete comment lines are
allowed provided blank.lines.skip = TRUE; however,
comment lines prior to the header must have the comment character
in the first non-blank column.
Quoted fields with embedded newlines are supported except after a comment character.
Value
A data frame (data.frame)
containing a representation of the data in the file.
Empty input is an error unless col.names is
specified, when a 0-row data frame is returned: similarly giving
just a header line if header = TRUE results in a 0-row
data frame. Note that in either case the columns will be logical
unless colClasses was supplied.
Character strings in the result (including factor levels) will
have a declared encoding if encoding is
"latin1" or "UTF-8".
Memory usage
These functions can use a surprising amount of memory when reading large files. There is extensive discussion in the ‘R Data Import/Export’ manual, supplementing the notes here.
Less memory will be used if colClasses is specified
as one of the six atomic
vector classes. This can be particularly so when reading a column
that takes many distinct numeric values, as storing each distinct
value as a character string can take up to 14 times as much memory
as storing it as an integer.
Using nrows, even as a mild over-estimate, will
help memory usage.
Using comment.char = "" will be appreciably faster
than the read.table default.
read.table is not the right tool for reading large
matrices, especially those with many columns: it is designed to
read data frames which may have columns of very different
classes. Use scan
instead for matrices.
Note
The columns referred to in as.is and
colClasses include the column of row names (if
any).
Because this function uses pushBack
it can only handle character strings which can be represented in
the current locale. So although fileEncoding can be
used to specify the encoding of the input file (or a connection can
be specified which re-encodes), the implied re-encoding must be
possible. This is not a problem in UTF-8 locales, but it can be on
Windows — readLines
or scan
can be used to avoid this limitation since they have special
provisions to convert input to UTF-8.
References
Chambers, J. M. (1992) Data for models. Chapter 3 of Statistical Models in S eds J. M. Chambers and T. J. Hastie, Wadsworth & Brooks/Cole.
See Also
The ‘R Data Import/Export’ manual.
scan,
type.convert,
read.fwf
for reading fixed width formatted input;
write.table;
data.frame.
count.fields
can be useful to determine problems with reading files which result
in reports of incorrect record lengths.
http://tools.ietf.org/html/rfc4180 for the IANA definition of CSV files (which requires comma as separator and CRLF line endings).
| scan {base} | R Documentation |
Read Data Values
Description
Read data into a vector or list from the console or file.
Usage
scan(file = "", what = double(0), nmax = -1, n = -1, sep = "",
quote = if(identical(sep, "\n")) "" else "'\"", dec = ".",
skip = 0, nlines = 0, na.strings = "NA",
flush = FALSE, fill = FALSE, strip.white = FALSE,
quiet = FALSE, blank.lines.skip = TRUE, multi.line = TRUE,
comment.char = "", allowEscapes = FALSE,
fileEncoding = "", encoding = "unknown")
Arguments
file |
the name of a file to read data values from. If the specified
file is "", then input is taken from the keyboard (or
whatever stdin()
reads if input is redirected or R is embedded). (In this case
input can be terminated by a blank line or an EOF signal,
Ctrl-D on Unix and Ctrl-Z on Windows.)
Otherwise, the file name is interpreted relative to the
current working directory (given by As from R 2.10.0 this can be a
compressed file (see Alternatively,
To read a data file not in the current encoding (for example a
Latin-1 file in a UTF-8 locale or conversely) use a |
what |
the type of what gives the type of data to be
read. The supported types are logical,
integer, numeric, complex,
character, raw and list. If
what is a list, it is assumed that the lines of the
data file are records each containing length(what)
items (‘fields’) and the list components should have elements which
are one of the first six types listed or NULL, see
section ‘Details’ below. |
nmax |
integer: the maximum number of data values to be read, or if
what is a list, the maximum number of records to be
read. If omitted or not positive or an invalid value for an integer
(and nlines is not set to a positive value),
scan will read to the end of file. |
n |
integer: the maximum number of data values to be read, defaulting to no limit. Invalid values will be ignored. |
sep |
by default, scan expects to read white-space delimited input
fields. Alternatively, sep can be used to specify a
character which delimits fields. A field is always delimited by an
end-of-line marker unless it is quoted.
If specified this should be the empty character string (the
default) or |
quote |
the set of quoting characters as a single character string or
NULL. In a multibyte locale the quoting characters
must be ASCII (single-byte). |
dec |
decimal point character. This should be a character string
containing just one single-byte character. (NULL and a
zero-length character vector are also accepted, and taken as the
default.) |
skip |
the number of lines of the input file to skip before beginning to read data values. |
nlines |
if positive, the maximum number of lines of data to be read. |
na.strings |
character vector. Elements of this vector are to be interpreted
as missing (NA)
values. Blank fields are also considered to be missing values in
logical, integer, numeric and complex fields. |
flush |
logical: if TRUE, scan will flush to
the end of the line after reading the last of the fields requested.
This allows putting comments after the last field, but precludes
putting more that one record on a line. |
fill |
logical: if TRUE, scan will
implicitly add empty fields to any lines with fewer fields than
implied by what. |
strip.white |
vector of logical value(s) corresponding to items in the
what argument. It is used only when sep
has been specified, and allows the stripping of leading and
trailing white space from character fields
(numeric fields are always stripped).
If |
quiet |
logical: if FALSE (default), scan() will print a
line, saying how many items have been read. |
blank.lines.skip |
logical: if TRUE blank lines in the input are
ignored, except when counting skip and
nlines. |
multi.line |
logical. Only used if what is a list. If
FALSE, all of a record must appear on one line (but
more than one record can appear on a single line). Note that using
fill = TRUE implies that a record will terminated at
the end of a line. |
comment.char |
character: a character vector of length one containing a single
character or an empty string. Use "" to turn off the
interpretation of comments altogether (the default). |
allowEscapes |
logical. Should C-style escapes such as \n be processed (the default) or read verbatim? Note
that if not within quotes these could be interpreted as a delimiter
(but not as a comment character).
The escapes which are interpreted are the control characters \a, \b, \f, \n, \r, \t, \v and octal and hexadecimal representations like \040 and \0x2A. Any other escaped character is treated as itself, including backslash. |
fileEncoding |
character string: if non-empty declares the encoding used on a
file (not a connection nor the keyboard) so the character data can
be re-encoded. See file. |
encoding |
encoding to be assumed for input strings. If the value is
"latin1" or "UTF-8" it is used to mark
character strings as known to be in Latin-1 or UTF-8: it is not
used to re-encode the input (see fileEncoding. See
also ‘Details’. |
Details
The value of what can be a list of types, in which
case scan returns a list of vectors with the types
given by the types of the elements in what. This
provides a way of reading columnar data. If any of the types is
NULL, the corresponding field is skipped (but a
NULL component appears in the result).
The type of what or its components can be one of
the six atomic vector types or NULL (see
is.atomic).
‘White space’ is defined for the purposes of this function as one or more contiguous characters from the set space, horizontal tab, carriage return and line feed. It does not include form feed or vertical tab, but in Latin-1 and Windows 8-bit locales 'space' includes non-breaking space.
Empty numeric fields are always regarded as missing values.
Empty character fields are scanned as empty character vectors,
unless na.strings contains "" when they
are regarded as missing values.
The allowed input for a numeric field is optional whitespace
followed either NA or an optional sign followed by a
decimal or hexadecimal constant (see NumericConstants),
or NaN, Inf or infinity
(ignoring case). Out-of-range values are recorded as
Inf, -Inf or 0.
For an integer field the allowed input is optional whitespace,
followed by either NA or an optional sign and one or
more digits (0-9): all out-of-range
values are converted to NA_integer_.
If sep is the default (""), the
character \ in a quoted string escapes
the following character, so quotes may be included in the string by
escaping them.
If sep is non-default, the fields may be quoted in
the style of ‘.csv’ files where
separators inside quotes ('' or "") are
ignored and quotes may be put inside strings by doubling them.
However, if sep = "\n" it is assumed by default that
one wants to read entire lines verbatim.
Quoting is only interpreted in character fields and in
NULL fields (which might be skipping character
fields).
Note that since sep is a separator and not a
terminator, reading a file by scan("foo", sep="\n",
blank.lines.skip=FALSE) will give an empty final line if the
file ends in a linefeed and not if it does not. This might not be
what you expected; see also readLines.
If comment.char occurs (except inside a quoted
character field), it signals that the rest of the line should be
regarded as a comment and be discarded. Lines beginning with a
comment character (possibly after white space with the default
separator) are treated as blank lines.
There is a line-length limit of 4095 bytes when reading from the console (which may impose a lower limit: see ‘An Introduction to R’).
There is a check for a user interrupt every 1000 lines if
what is a list, otherwise every 10000 items.
If file is a character string and
fileEncoding is non-default, or it it is a
not-already-open connection
with a non-default encoding argument, the text is
converted to UTF-8 and declared as such (and the
encoding argument to scan is ignored).
See the examples of readLines.
Value
if what is a list, a list of the same length and
same names (as any) as what.
Otherwise, a vector of the type of what.
Character strings in the result will have a declared encoding if
encoding is "latin1" or
"UTF-8".
Note
The default for multi.line differs from S. To read
one record per line, use flush = TRUE and
multi.line = FALSE. (Note that quoted character
strings can still include embedded newlines.)
If number of items is not specified, the internal mechanism
re-allocates memory in powers of two and so could use up to three
times as much memory as needed. (It needs both old and new copies.)
If you can, specify either n or nmax
whenever inputting a large vector, and nmax or
nlines when inputting a large list.
Using scan on an open connection to read partial
lines can lose chars: use an explicit separator to avoid this.
Having nul bytes in fields (including \0 if allowEscapes = TRUE) may lead to
interpretation of the field being terminated at the
nul. They not normally present in text files – see
readBin.
References
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language. Wadsworth & Brooks/Cole.
See Also
read.table
for more user-friendly reading of data matrices; readLines
to read a file a line at a time. write.
Quotes for the details of C-style escape
sequences.
readChar
and readBin
to read fixed or variable length character strings or binary
representations of numbers a few at a time from a connection.
Examples
cat("TITLE extra line", "2 3 5 7", "11 13 17", file="ex.data", sep="\n")
pp <- scan("ex.data", skip = 1, quiet= TRUE)
scan("ex.data", skip = 1)
scan("ex.data", skip = 1, nlines=1) # only 1 line after the skipped one
scan("ex.data", what = list("","","")) # flush is F -> read "7"
scan("ex.data", what = list("","",""), flush = TRUE)
unlink("ex.data") # tidy up
喜欢
0
赠金笔