R에서는 스크립트 끝에서 전역 변수 목록을 검색하고이를 반복하고 싶습니다. 내 코드는 다음과 같습니다.
#declare a few sample variables
a<-10
b<-"Hello world"
c<-data.frame()
#get all global variables in script and iterate over them
myGlobals<-objects()
for(i in myGlobals){
print(typeof(i)) #prints 'character'
}내 문제가 있다는 것입니다 typeof(i)항상 반환 character도 변수 불구 a하고 c문자 변수가 없습니다. for 루프 내에서 원래 유형의 변수를 어떻게 얻을 수 있습니까?
답변
get에서 반환 된 객체의 문자 이름이 아닌 값을 가져 오는 데를 사용해야 합니다 ls.
x <- 1L
typeof(ls())
[1] "character"
typeof(get(ls()))
[1] "integer"또는 제시된 문제에 대해 다음을 사용할 수 있습니다 eapply.
eapply(.GlobalEnv,typeof)
$x
[1] "integer"
$a
[1] "double"
$b
[1] "character"
$c
[1] "list"답변
전역 개체 아래에 숨겨져있을 때 변수 유형을 가져 오는 방법 :
필요한 모든 것은 기본 유형에 대한 R 매뉴얼에 있습니다 : https://cran.r-project.org/doc/manuals/R-lang.html#Basic-types
귀하의 object()요구는로 침투 할 get(...)안으로 볼 수 있습니다 전에. 예:
a <- 10
myGlobals <- objects()
for(i in myGlobals){
typeof(i) #prints character
typeof(get(i)) #prints integer
}R에있는 변수 유형을 얻는 방법
예를 들어 R 함수typeof 에는 최대 깊이에서 유형을 제공하는 편향이 있습니다.
library(tibble)
#expression notes type
#----------------------- -------------------------------------- ----------
typeof(TRUE) #a single boolean: logical
typeof(1L) #a single numeric with L postfixed: integer
typeof("foobar") #A single string in double quotes: character
typeof(1) #a single numeric: double
typeof(list(5,6,7)) #a list of numeric: list
typeof(2i) #an imaginary number complex
#So far so good, but those who wish to keep their sanity go no further
typeof(5 + 5L) #double + integer is coerced: double
typeof(c()) #an empty vector has no type: NULL
typeof(!5) #a bang before a double: logical
typeof(Inf) #infinity has a type: double
typeof(c(5,6,7)) #a vector containing only doubles: double
typeof(c(c(TRUE))) #a vector of vector of logicals: logical
typeof(matrix(1:10)) #a matrix of doubles has a type: list
#Strangeness ahead, there be dragons: step carefully:
typeof(substr("abc",2,2))#a string at index 2 which is 'b' is: character
typeof(c(5L,6L,7L)) #a vector containing only integers: integer
typeof(c(NA,NA,NA)) #a vector containing only NA: logical
typeof(data.frame()) #a data.frame with nothing in it: list
typeof(data.frame(c(3))) #a data.frame with a double in it: list
typeof(c("foobar")) #a vector containing only strings: character
typeof(pi) #builtin expression for pi: double
#OK, I'm starting to get irritated, however, I am also longsuffering:
typeof(1.66) #a single numeric with mantissa: double
typeof(1.66L) #a double with L postfixed double
typeof(c("foobar")) #a vector containing only strings: character
typeof(c(5L, 6L)) #a vector containing only integers: integer
typeof(c(1.5, 2.5)) #a vector containing only doubles: double
typeof(c(1.5, 2.5)) #a vector containing only doubles: double
typeof(c(TRUE, FALSE)) #a vector containing only logicals: logical
#R is really cramping my style, killing my high, irritation is increasing:
typeof(factor()) #an empty factor has default type: integer
typeof(factor(3.14)) #a factor containing doubles: integer
typeof(factor(T, F)) #a factor containing logicals: integer
typeof(Sys.Date()) #builtin R dates: double
typeof(hms::hms(3600)) #hour minute second timestamp double
typeof(c(T, F)) #T and F are builtins: logical
typeof(1:10) #a builtin sequence of numerics: integer
typeof(NA) #The builtin value not available: logical
#The R coolaid punchbowl has been spiked: stay frosty and keep your head low:
typeof(c(list(T))) #a vector of lists of logical: list
typeof(list(c(T))) #a list of vectors of logical: list
typeof(c(T, 3.14)) #a vector of logicals and doubles: double
typeof(c(3.14, "foo")) #a vector of doubles and characters: character
typeof(c("foo",list(T))) #a vector of strings and lists: list
typeof(list("foo",c(T))) #a list of strings and vectors: list
typeof(TRUE + 5L) #a logical plus an integer: integer
typeof(c(TRUE, 5L)[1]) #The true is coerced to 1 integer
typeof(c(c(2i), TRUE)[1])#logical coerced to complex: complex
typeof(c(NaN, 'batman')) #NaN's in a vector don't dominate: character
typeof(5 && 4) #doubles are coerced by order of && logical
typeof(8 < 'foobar') #string and double is coerced logical
typeof(list(4, T)[[1]]) #a list retains type at every index: double
typeof(list(4, T)[[2]]) #a list retains type at every index: logical
typeof(2 ** 5) #result of exponentiation double
typeof(0E0) #exponential lol notation double
typeof(0x3fade) #hexidecimal double
typeof(paste(3, '3')) #paste promotes types to string character
typeof(3 + 四) #R pukes on unicode error
typeof(iconv("a", "latin1", "UTF-8")) #UTF-8 characters character
typeof(5 == 5) #result of a comparison: logicalR에있는 변수의 클래스를 얻는 방법
R 함수class 는 예를 들어 컨테이너 유형이나 유형을 캡슐화하는 구조를 제공하는 편향이 있습니다.
library(tibble)
#expression notes class
#--------------------- ---------------------------------------- ---------
class(matrix(1:10)) #a matrix of doubles has a class: matrix
class(factor("hi")) #factor of items is: factor
class(TRUE) #a single boolean: logical
class(1L) #a single numeric with L postfixed: integer
class("foobar") #A single string in double quotes: character
class(1) #a single numeric: numeric
class(list(5,6,7)) #a list of numeric: list
class(2i) #an imaginary complex
class(data.frame()) #a data.frame with nothing in it: data.frame
class(Sys.Date()) #builtin R dates: Date
class(sapply) #a function is function
class(charToRaw("hi")) #convert string to raw: raw
class(array("hi")) #array of items is: array
#So far so good, but those who wish to keep their sanity go no further
class(5 + 5L) #double + integer is coerced: numeric
class(c()) #an empty vector has no class: NULL
class(!5) #a bang before a double: logical
class(Inf) #infinity has a class: numeric
class(c(5,6,7)) #a vector containing only doubles: numeric
class(c(c(TRUE))) #a vector of vector of logicals: logical
#Strangeness ahead, there be dragons: step carefully:
class(substr("abc",2,2))#a string at index 2 which is 'b' is: character
class(c(5L,6L,7L)) #a vector containing only integers: integer
class(c(NA,NA,NA)) #a vector containing only NA: logical
class(data.frame(c(3))) #a data.frame with a double in it: data.frame
class(c("foobar")) #a vector containing only strings: character
class(pi) #builtin expression for pi: numeric
#OK, I'm starting to get irritated, however, I am also longsuffering:
class(1.66) #a single numeric with mantissa: numeric
class(1.66L) #a double with L postfixed numeric
class(c("foobar")) #a vector containing only strings: character
class(c(5L, 6L)) #a vector containing only integers: integer
class(c(1.5, 2.5)) #a vector containing only doubles: numeric
class(c(TRUE, FALSE)) #a vector containing only logicals: logical
#R is really cramping my style, killing my high, irritation is increasing:
class(factor()) #an empty factor has default class: factor
class(factor(3.14)) #a factor containing doubles: factor
class(factor(T, F)) #a factor containing logicals: factor
class(hms::hms(3600)) #hour minute second timestamp hms difftime
class(c(T, F)) #T and F are builtins: logical
class(1:10) #a builtin sequence of numerics: integer
class(NA) #The builtin value not available: logical
#The R coolaid punchbowl has been spiked: stay frosty and keep your head low:
class(c(list(T))) #a vector of lists of logical: list
class(list(c(T))) #a list of vectors of logical: list
class(c(T, 3.14)) #a vector of logicals and doubles: numeric
class(c(3.14, "foo")) #a vector of doubles and characters: character
class(c("foo",list(T))) #a vector of strings and lists: list
class(list("foo",c(T))) #a list of strings and vectors: list
class(TRUE + 5L) #a logical plus an integer: integer
class(c(TRUE, 5L)[1]) #The true is coerced to 1 integer
class(c(c(2i), TRUE)[1])#logical coerced to complex: complex
class(c(NaN, 'batman')) #NaN's in a vector don't dominate: character
class(5 && 4) #doubles are coerced by order of && logical
class(8 < 'foobar') #string and double is coerced logical
class(list(4, T)[[1]]) #a list retains class at every index: numeric
class(list(4, T)[[2]]) #a list retains class at every index: logical
class(2 ** 5) #result of exponentiation numeric
class(0E0) #exponential lol notation numeric
class(0x3fade) #hexidecimal numeric
class(paste(3, '3')) #paste promotes class to string character
class(3 + 四) #R pukes on unicode error
class(iconv("a", "latin1", "UTF-8")) #UTF-8 characters character
class(5 == 5) #result of a comparison: logicalstorage.mode변수 의 데이터 얻기
R 변수가 디스크에 기록되면 데이터 레이아웃이 다시 변경되며 데이터의storage.mode . 이 함수 storage.mode(...)는이 낮은 수준의 정보를 표시 합니다 . R 객체의 모드, 클래스 및 유형을 참조하십시오 . 디스크에서 데이터를 할당하고 읽을 때 발생하는 왕복 캐스트 / 강제 때문에 발생하는 지연을 이해하려고하지 않는 한 R의 storage.mode에 대해 걱정할 필요가 없습니다.
R의 트라이어드 타이핑 시스템에 대한 이념 :
R의 오리 타이핑 시스템에는 불확실성이 있습니다. 비유로, 세라믹 컵을 고려하십시오. 액체를 담는 데 사용하거나 야구 공과 같은 발사체로 사용할 수 있습니다. 컵의 목적은 사용 가능한 속성과 컵에 작용하는 기능에 따라 다릅니다. 이러한 유형의 유동성은 프로그래머가 한 함수에서 다른 함수로 모든 종류의 출력을 리디렉션 할 수있는 더 큰 여유를 허용하며 R은 사용자의 마음을 읽고 합리적인 작업을 수행하기 위해 많은 시간을 할애 할 것입니다.
아이디어는 초보자 프로그래머는 브라운 운동을 통해 R 프로그램을 작성할 때, 그들은 바와 같이, 그들이 통과하려고 시도한다는 것입니다 googah.blimflarg로 vehicle.subspaceresponder(...). 유형 오류를 퍼뜨리는 대신 R 프로그램은 체조를 수행하여 유형을 변형 한 다음 놀랍도록 유용한 작업을 수행합니다. 초보자 프로그래머는 자신의 블로그에 코드를 게시하고 “내가 3 줄의 R 코드로했던 엄청난 일을보세요! 어떻게해야할지 모르겠지만 실제로 수행합니다!”라고 말합니다.
답변
class (x)를 사용하여 변수 유형을 확인할 수 있습니다. 데이터 프레임의 모든 변수 유형을 확인해야하는 경우 sapply (x, class)를 사용할 수 있습니다.
답변
> mtcars %>%
+ summarise_all(typeof) %>%
+ gather
key value
1 mpg double
2 cyl double
3 disp double
4 hp double
5 drat double
6 wt double
7 qsec double
8 vs double
9 am double
10 gear double
11 carb double나는 시도 class하고 typeof기능하지만 모두 실패합니다.
답변
본질적으로 당신이 원했던 것의 역을 수행하도록 설계된, 여기 내 툴킷 장난감 중 하나가 있습니다.
lstype<-function(type='closure'){
inlist<-ls(.GlobalEnv)
if (type=='function') type <-'closure'
typelist<-sapply(sapply(inlist,get),typeof)
return(names(typelist[typelist==type]))
}답변
lapply (your_dataframe, class)는 다음과 같은 것을 제공합니다.
$ tikr [1] “인자”
$ Date [1] “날짜”
$ Open [1] “숫자”
$ High [1] “숫자”
… 등
답변
