R语言基础定义（2.6.1版）：核心对象与结构详解

需积分: 10 126 浏览量更新于2024-07-22 收藏 398KB PDF 举报

R语言定义（RLanguageDeﬁnition Version 2.6.1, 2007-11-26）是一份详尽的文档，由R Development Core Team编撰，用于介绍和规范R编程语言。该版本的R语言是国际通用的，主要针对初学者和专业开发人员，提供了对R语言基础结构、数据类型、对象和特殊功能的深入理解。 1. **入门与介绍** R语言定义首先提供了一个简短的介绍，让读者了解其背景和用途。R语言是一款专门用于统计分析和图形绘制的强大工具，尤其在大数据处理和机器学习领域受到广泛应用。 2. **基本数据类型** - **向量** (Vectors): R中的基本数据结构，用于存储同类型的数据，如整数、浮点数或字符，可以是一维或多维的。 - **列表** (Lists): 结构更为灵活，允许存储不同类型或不同长度的数据元素，每个元素可以是任何类型的R对象。 - **语言对象** (Language Objects): 包括符号对象（Symbols）、表达式对象（Expressions）、函数对象（Functions）等，这些对象是R语言程序执行的基础。 - **NULL**: R中的特殊值，表示缺失或无值，通常用作函数参数的默认值或某些操作的结果。 3. **内置对象与特殊形式** 提供了关于R语言内置对象的详细描述，如基础数学函数、逻辑运算符等。此外，还介绍了特殊形式，如`.`（点运算符）用于访问对象的属性或方法，`...`（省略号）用于处理可变数量的参数。 4. **其他重要概念** - **承诺对象** (Promise objects): 在R语言中，异步计算可能会产生承诺对象，它们代表了未来可能的结果，直到实际计算完成时才会被评估。 - **环境（Environment）**: R的执行环境中包含了变量和函数，环境的概念对于理解函数作用域和闭包至关重要。 5. **版权与许可** 文档明确了许可条款，允许用户在保留原版权信息和许可声明的前提下复制和分发R语言手册的原文或修改版本。翻译版本也需遵循相似条件，但翻译的许可通知需得到R Development Core Team的批准。这份R Language Definition文档是理解和使用R语言的基石，通过阅读和理解其中的内容，用户能够掌握R的基本语法、对象体系以及核心编程原则，从而高效地进行数据分析和编程实践。

Chapter 2: Objects 5

2.1.7 Builtin objects and special forms

These two kinds of object contain the builtin functions of R, i.e., those that are displayed as

.Primitive in code listings (as well as those accessed via the .Internal function and hence not

user-visible as objects). The diﬀerence between the two lies in the argument handling. Builtin

functions have all their arguments evaluated and passed to the internal function, in accordance

with call-by-value, whereas special functions pass the unevaluated arguments to the internal

function.

From the R language, these objects are just another kind of function, except that their

deﬁnition cannot be listed. The typeof function can distinguish them from interpreted functions.

2.1.8 Promise objects

Promise objects are part of R’s lazy evaluation mechanism. They contain three slots: a value,

an expression, and an environment. When a function is called the arguments are matched and

then each of the formal arguments is bound to a promise. The expression that was given for

that formal argument and a pointer to the environment the function was called from are stored

in the promise.

Until that argument is accessed there is no value associated with the promise. When the

argument is accessed, the stored expression is evaluated in the stored environment, and the result

is returned. The result is also saved by the promise. The substitute function will extract the

content of the expression slot. This allows the programmer to access either the value or the

expression associated with the promise.

Within the R language, promise objects are almost only seen implicitly. (In an upcoming

release they will never be visible to R code, as they will always be evaluated when accessed.)

Actual function arguments are of this type. There is also a delayedAssign function that will

make a promise out of an expression. There is generally no way in R code to check whether an

object is a promise or not, nor is there a way to use R code to determine the environment of a

promise.

2.1.9 Dot-dot-dot

The ‘...’ object type is stored as a type of pairlist. The components of ‘...’ can be accessed

in the usual pairlist manner from C code, but is not easily accessed as an object in interpreted

code. The object can be captured as a list, so for example in table one sees

args <- list(...)

## ....

for (a in args) {

## ....

If a function has ‘...’ as a formal argument then any actual arguments that do not match a

formal argument are matched with ‘...’.

2.1.10 Environments

Environments can be thought of as consisting of two things. A frame, consisting of a set of

symbol-value pairs, and an enclosure, a pointer to an enclosing environment. When R looks

up the value for a symbol the frame is examined and if a matching symbol is found its value

will be returned. If not, the enclosing environment is then accessed and the process repeated.

Environments form a tree structure in which the enclosures play the role of parents. The tree

of environments is rooted in an empty environment, available through emptyenv(), which has

no parent. It is the direct parent of the environment of the base package (available through

the baseenv() function). Formerly baseenv() had the special value NULL, but as from version

2.4.0, the use of NULL as an environment is defunct.

Chapter 2: Objects 6

Environments are created implicitly by function calls, as described in Section 2.1.5 [Function

objects], page 4 and Section 3.5.2 [Lexical environment], page 20. In this case the environment

contains the variables local to the function (including the arguments), and its enclosure is the

environment of the currently called function. Environments may also be created directly by

new.env. The frame content of an environment can be accessed and manipulated by use of ls,

get and assign as well as eval and evalq.

The parent.env function may be used to access the enclosure of an environment.

Unlike most other R objects, environments are not copied when passed to functions or used

in assignments. Thus, if you assign the same environment to several symbols and change one,

the others will change too. In particular, assigning attributes to an environment can lead to

surprises.

2.1.11 Pairlist objects

Pairlist objects are similar to Lisp’s dotted-pair lists. They are used extensively in the internals

of R, but are rarely visible in interpreted code, although they are returned by formals, and can

be created by (e.g.) the pairlist function. A zero-length pairlist is NULL, as would be expected

in Lisp but in contrast to a zero-length list. Each such object has three slots, a CAR value,

a CDR value and a TAG value. The TAG value is a text string and CAR and CDR usually

represent, respectively, a list item (head) and the remainder (tail) of the list with a NULL

object as terminator (the CAR/CDR terminology is traditional Lisp and originally referred to

the address and decrement registers on an early 60’s IBM computer).

Pairlists are handled in the R language in exactly the same way as generic vectors (“lists”). In

particular, elements are accessed using the same [[]] syntax. The use of pairlists is deprecated

since generic vectors are usually more eﬃcient to use. When an internal pairlist is accessed from

R it is generally (including when subsetted) converted to a generic vector.

In a very few cases pairlists are user-visible: one is .Options.

2.1.12 The “Any” type

It is not really possible for an object to be of “Any” type, but it is nevertheless a valid type

value. It gets used in certain (rather rare) circumstances, e.g. as.vector(x, "any"), indicating

that type coercion should not be done.

2.2 Attributes

All objects except NULL can have one or more attributes attached to them. Attributes are stored

as a pairlist where all elements are named, but should be thought of as a set of name=value

pairs. A listing of the attributes can be obtained using attributes and set by attributes<-,

individual components are accessed using attr and attr<-.

Some attributes have special accessor functions (e.g. levels<- for factors) and these should

be used when available. In addition to hiding details of implementation they may perform

additional operations. R attempts to intercept calls to attr<- and to attributes<- that

involve the special attributes and enforces the consistency checks.

Matrices and arrays are simply vectors with the attribute dim and optionally dimnames

attached to the vector.

Attributes are used to implement the class structure used in R. If an object has a class

attribute then that attribute will be examined during evaluation. The class structure in R is

described in detail in Chapter 5 [Object-oriented programming], page 26.

Chapter 2: Objects 7

2.2.1 Names

A names attribute, when present, labels the individual elements of a vector or list. When an

object is printed the names attribute, when present, is used to label the elements. The names

attribute can also be used for indexing purposes, for example, quantile(x)["25%"].

One may get and set the names using names and names<- constructions. The latter will

perform the necessary consistency checks to ensure that the names attribute has the proper

type and length.

Pairlists and one-dimensional arrays are treated specially. For pairlist objects, a virtual names

attribute is used; the names attribute is really constructed from the tags of the list components.

For one-dimensional arrays the names attribute really accesses dimnames[[1]].

2.2.2 Dimensions

The dim attribute is used to implement arrays. The content of the array is stored in a vector

in column-major order and the dim attribute is a vector of integers specifying the respective

extents of the array. R ensures that the length of the vector is the product of the lengths of the

dimensions. The length of one or more dimensions may be zero.

A vector is not the same as a one-dimensional array since the latter has a dim attribute of

length one, whereas the former has no dim attribute.

2.2.3 Dimnames

Arrays may name each dimension separately using the dimnames attribute which is a list of

character vectors. The dimnames list may itself have names which are then used for extent

headings when printing arrays.

2.2.4 Classes

R has an elaborate class system, controlled via the class attribute. This attribute is a character

vector containing the list of classes that an object inherits from. This forms the basis of the

“generic methods” functionality in R.

This attribute can be accessed and manipulated virtually without restriction by users. There

is no checking that an object actually contains the components that class methods expect. Thus,

altering the class attribute should be done with caution, and when they are available speciﬁc

creation and coercion functions should be preferred.

2.2.5 Time series attributes

The tsp attribute is used to hold parameters of time series, start, end, and frequency. This

construction is mainly used to handle series with periodic substructure such as monthly or

quarterly data.

2.2.6 Copying of attributes

Whether attributes should be copied when an object is altered is a complex area, but there are

some general rules (Becker, Chambers & Wilks, 1988, pp. 144–6).

Scalar functions (those which operate element-by-element on a vector and whose output is

similar to the input) should preserve attributes (except perhaps class).

Binary operations normally copy most attributes from the longer argument (and if they are

of the same length from both, preferring the values on the ﬁrst). Here ‘most’ means all except

the names, dim and dimnames which are set appropriately by the code for the operator.

Subsetting (other than by an empty index) generally drops all attributes except names, dim

and dimnames which are reset as appropriate. On the other hand, subassignment generally

preserves attributes even if the length is changed. Coercion drops all attributes.

剩余59页未读，继续阅读

zhaodm1991

粉丝: 0
资源: 2

R语言基础定义（2.6.1版）：核心对象与结构详解

R Language Definition.pdf

R language definition

《R语言定义》：《The_R_language_definition》中文版（草稿）_R-lang-cn.zip

R_doc

数据库系统原理：BDB3 SQL语言_R.ppt

libthrift-r959516.jar.zip

android-sdk_r24.4.1-windows

android-3.1_r03.zip

build-tools_r29-windows.zip

build-tools_r23.0.2-linux.zip

最新资源