zoukankan      html  css  js  c++  java
  • R

    一. 两种基本数据结构

    1. 概念
      (1)原子向量:包含单个数据类型的数组
      (2)泛型向量:也称为列表,是原子向量的集合。列表是递归的包含其他列表的

    2. 原子向量
      (1)原子向量是用c()函数组合起来的元素一维数组

      > paceed <- c(TRUE,TRUE)
      > paceed
      [1] TRUE TRUE
      

    (2)R没有标量型数据:标量是一个单一元素。即

    ```R
    k<-2 是 k<-c(2) 的简写
    ```
    

    (3)许多R的数据类型都是带有特定属性的原子向量
        i. 矩阵是一个带有dim属性的原子向量。dim属性包含2个元素(行数和列数)

    ```R
    > x <- c(1,2,3,4,5,6,7,8,9,0)  # 向量
    > class(x)
    [1] "numeric"
    > x
     [1] 1 2 3 4 5 6 7 8 9 0
     
    > attr(x,"dim") <- c(2,5)      # 为向量增加dim属性:attr方法
    > x
         [,1] [,2] [,3] [,4] [,5]
    [1,]    1    3    5    7    9
    [2,]    2    4    6    8    0
    
    > class(x)                      # x类型
    [1] "matrix"
    > attributes(x)                 # x的属性
    $dim
    [1] 2 5
    
    # 增加dimnames属性
    > attr(x,"dimnames") <- list(c("A1","A2"),c("B1","B2","B3","B4","B5"))
    > x
       B1 B2 B3 B4 B5
    A1  1  3  5  7  9
    A2  2  4  6  8  0
    ```
    

    ii. 矩阵可以通过取出dim属性,变成一维数组

    ```R
    > attr(x,"dim") <- NULL
    > x
     [1] 1 2 3 4 5 6 7 8 9 0
    ```
    
    1. 泛型向量
      > head(iris)
        Sepal.Length Sepal.Width Petal.Length Petal.Width Species
      1          5.1         3.5          1.4         0.2  setosa
      2          4.9         3.0          1.4         0.2  setosa
      3          4.7         3.2          1.3         0.2  setosa
      4          4.6         3.1          1.5         0.2  setosa
      5          5.0         3.6          1.4         0.2  setosa
      6          5.4         3.9          1.7         0.4  setosa
      
      > attributes(iris)
      
      > unclass(iris)
      

    (1) 索引
          i. 提取向量中的元素,使用下标来取。R的下标从1开始

    ```R
    > x <- c(20,30,40)  # 声明向量
    > x[3]              # x[3]:取第3个元素
    [1] 40
    > x[c(1,2)]         # 取2个元素:c(2,3)
    [1] 20 30
    ```
    

    ii. 有命名的原子变量可以使用名字提取成分

    ```R
    > x <- c(A=20,B=30,C=40)   # 命名的原子向量
    > x                        # x打印
         A  B  C 
        20 30 40 
    > x[c("A","B")]            # 用命名提取
         A  B 
        20 30 
    ```
    

    二. 流程控制

    1. for循环
      (1)语法结构
      for (var in seq){
          statements
      }
      

    (2)例子
    ```R
    > for(i in 1:5){
    + print (1:i)
    + }
    [1] 1
    [1] 1 2
    [1] 1 2 3
    [1] 1 2 3 4
    [1] 1 2 3 4 5

    ```
    
    1. if与else
      (1)语法
      if(condition){
          statement1
      }else{
          statement2
      }
      

    (2)ifelse() 函数
          i. ifelse() 是 if的量化版本,可以对向量中的每个元素进行流程判断
          ii. 代码示例
    R > pvalues <- c(.087,.0018,.0054,.1572,.0183,.5386) # 声明向量 > pvalues [1] 0.0870 0.0018 0.0054 0.1572 0.0183 0.5386 > result <- ifelse(pvalues<.015,"Significant","Not significant") # ifelse函数 > result # 判断结果 [1] "Not significant" "Significant" "Significant" "Not significant" [5] "Not significant" "Not significant"
    (3)等价的显式循环
    R > results <- vector(mode="character",length=length(pvalues)) # 声明结果 > for(i in 1:length(pvalues)){ # 显式循环 + if (pvalues[i]<0.5) + results[i] <- "signnificant" + else + results[i] <- "Not Significant" + } > > results [1] "signnificant" "signnificant" "signnificant" "signnificant" [5] "signnificant" "Not Significant"

    三. 创建函数

    1. 函数的声明方式

      functionName <- function( parameters )
                      { statements   
                        return value } 
      
      > f <- function(x,y,z=1){
      +   result <- x + 2*y + 3*z
      +   return(result)
      + }
      > f(1,2)
      [1] 8
      > args(f)           # args返回函数的参数和默认值,用户交互式R终端
      function (x, y, z = 1) 
      NULL
      > formals(f)        # formals,用于代码中获取函数参数
      $x
      
      
      $y
      
      
      $z
      [1] 1
      
      
    2. 环境变量
      (1)生命新的环境,在环境中设置变量,从环境中取变量

      > myenv <- new.env()
      > assign("x","Homer",env=myenv)
      > ls(myenv)
      [1] "x"
      > x
      [1] 5
      > get("x",env=myenv)
      [1] "Homer"
      > get("x")
      [1] 5
      
      

    (2)查看环境的父环境
    R > parent.env(myenv) # 顶级环境的父环境为空 <environment: R_GlobalEnv>

    四. 面向对象编程

    1. 泛型函数
      (1)R使用对象的类来确定,当一个泛型函数被调用时,应该采用什么样的行动。
      > mymethod <- function(x,...) UseMethod("mymethod")
      > mymethod.a <- function(x) print("Using A")
      > mymethod.b <- function(x) print("Using B")
      > mymethod.default <- function(x) print("Using Default")
      
      > class(x) <- "a"
      > mymethod(x)
      [1] "Using A"
      
      > class(x) <- c("c","a","b")      # 当一个对象被分为2个类型时,泛型函数取第一个存在于泛型函数列表的类型
      > mymethod(x)
      [1] "Using A"                     # x的类型为c,a,b:c不在myfunction的类型表里面,取后面的类型a
      
      

    五. 数据结构

    1. 向量
      (1)是存储同一种数据类型的一位数组
      a <- c(1,2,3,5,6,-2)           # c:组合函数
      print(a)
      (1)标量:致函一个元素的向量 
      b <- 3
      print(b)
      

    (2)不同类型的标量,存在于一个数组中,会类型转换:(布尔->int->字符串)

    ```R
    c <- c(TRUE,TRUE,'a',2)   # "TRUE" "TRUE" "a" "2"
    print(c)
    ```
    

    (3)方括号中指明数字,来取向量的第几个元素 ###

    ```R
    print( a[2] )      # 2
    print( a[c(2,3)] ) # 2 3 : 访问a第2和第3个元素
    print( a[2:4] )    # 2 3 5
    ```
    
    1. 矩阵是存储同一种数据类型的二维数组

      y <- matrix(1:20 , nrow=5 , ncol=4 , byrow=TRUE)     # 行填充
      print(y)
      
    2. 数组是存储同一种数据类型的三维数组

      dim1 <- c("A1","A2")              # 行
      dim2 <- c("B1","B2","B3")         # 列
      dim3 <- c("C1","C2","C3","C4")   # 面
      z <- array(1:24 , c(2,3,4) , dimnames=list(dim1,dim2,dim3))
      print(z)
      print(z[1,2,3])
      
    3. 数据框和矩阵类似,是一种二维数组,但数据框的每列,类型可以不一样 ,列内元素类型一致

      col1 <- c(1,2,3,4)
      col2 <- c("zhangsan","lisi","wangwu","zhaoliu")
      col3 <- c("Poor","Improved","Excellent","Poor")
      df <- data.frame(col1,col2,col3)
      print(df[1:2])  # 打印第1,2列
      
    4. 因子

      diabets <- c("Type1","Type2","Type1","Type1") #因子
      print(diabets)
      # 用factor函数后,将向量转换成有序的因子:内部存储为(1,2,1,1),并做映射 1<->Type1, 2<->Type2
      diabets <- factor(diabets,ordered=TRUE)  # 排序的有序性
      print(diabets)
      
    5. 列表:各种对象的有序集合

      g <- "My First List"
      h <- c(25,26,27,34)
      j <- matrix(1:10,nrow=5)     ### 数组
      k <- c("one","two","three")
      
      mylist <- list(title=g,ages=h,j,k)
      print(mylist$title)
      print(mylist$ages)
      print(mylist[[3]])
      
  • 相关阅读:
    python 包管理工具 pip 的配置
    Python 变量作用域 LEGB (下)—— Enclosing function locals
    Python 变量作用域 LEGB (上)—— Local,Global,Builtin
    2020 Java 面试题 小结 (答案慢慢补上,有错误请指出)
    mysql 根据日期(date)做年,月,日分组统计查询
    jvm指令
    正则表达式 分割地址 获取省市区详细地址
    .Net 异常记录
    WCF设计服务协议(一)
    plsql ORA-01789:查询块具有不正确的结果列数
  • 原文地址:https://www.cnblogs.com/moonlord/p/6039154.html
Copyright © 2011-2022 走看看