r语言 read_html,R软件中读入纯文本文件的方法read.table（）和scan（）函数

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, R 2.10.0 this

can be a compressed file (see

Alternatively, file can be a readable text-mode

Ctrl-D on

Unix and Ctrl-Z on Windows. Any pushback on

stdin() will be cleared before return.)

file can also be a complete URL.

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 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 row.names is missing,

the rows are numbered.

Using row.names = NULL forces row numbering.

Missing or NULL row.names generate row

names that are considered to be ‘automatic’ (and not preserved by

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 colClasses = "character".

Note that as.is is specified per column (not per

variable) and so includes the column of row names (if any) and any

columns to be skipped.

na.strings

a character vector of strings which are to be interpreted as

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 NA (the default, when

"NULL" (when the column is skipped), one of

the atomic vector classes (logical, integer, numeric, complex,

character, raw), or "factor", "Date" or

"POSIXct". Otherwise there needs to be an

as method (from package methods) for conversion from "character"

to the specified formal class.

Note that colClasses is specified per column (not

per variable) and so includes the column of row names (if any).

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

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

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

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

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

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 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 (

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

Note

The columns referred to in as.is and

colClasses include the column of row names (if

any).

Because this function uses 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 —

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.

http://tools.ietf.org/html/rfc4180

for the IANA definition of CSV files (which requires comma as

separator and CRLF line endings).

[Package utils version 2.12.1 Index]

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 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 absolute path. Tilde-expansion is

performed where supported. When running R from a script,

file="stdin" can be used to refer to the process's

stdin file stream.

As from R 2.10.0 this can be a

compressed file (see

Alternatively, file can be a sep = "\n".

file can also be a complete URL.

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 encoding argument.

what

the type of what gives the type of data to be

read. The supported types are logical,

integer, numeric, complex,

character, raw and 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 NULL or a character string containing just

one single-byte character.

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 (

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 strip.white is of length 1, it applies to all

fields; otherwise, if strip.white[i] is

TRUE and the i-th field is of

mode character (because what[i] is) then the leading

and trailing white space from field i is stripped.

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

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

‘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

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

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

References

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The

New S Language. Wadsworth & Brooks/Cole.

See Also

Quotes for the details of C-style escape

sequences.

Examples

cat("TITLE extra line", "2 3 5 7", "11 13 17", file="ex.data", sep="\n")

pp

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

[Package base version 2.12.1 Index]