ประเภทข้อมูลใน R พร้อมตัวอย่าง

ประเภทข้อมูลใน R คืออะไร?

ต่อไปนี้เป็นประเภทข้อมูลหรือโครงสร้างข้อมูลในการเขียนโปรแกรม R:

• สเกลาร์
• เวกเตอร์ (ตัวเลข ตัวอักษร ตรรกะ)
• เมทริกซ์
• กรอบข้อมูล
• รายการ

รายการดังกล่าวเป็นการผสมผสานแนวคิดสองอย่างที่เกี่ยวข้องกัน และการแยกแนวคิดเหล่านั้นออกจากกันจะทำให้ส่วนที่เหลือของหน้านี้อ่านเข้าใจง่ายขึ้น A ประเภทข้อมูล อธิบายว่าค่าเดียวคืออะไร — ตัวเลข ข้อความ ค่าจริง หรือค่าเท็จ โครงสร้างข้อมูล อธิบายว่าค่าต่างๆ ถูกจัดเก็บไว้ด้วยกันกี่ค่าและอยู่ในรูปแบบใด สเกลาร์ เวกเตอร์ เมทริกซ์ เฟรมข้อมูล และลิสต์ ล้วนเป็นโครงสร้าง ค่าภายในโครงสร้างเหล่านั้นยังคงเป็นของประเภทพื้นฐานอย่างใดอย่างหนึ่งของ R

R ไม่มีชนิดข้อมูลสเกลาร์แยกต่างหาก: สเกลาร์เป็นเพียงเวกเตอร์ที่มีความยาวหนึ่ง ซึ่งเป็นเหตุผลว่าทำไมโค้ด R จำนวนมากจึงเขียนขึ้นสำหรับเวกเตอร์ทั้งหมดในคราวเดียว

ประเภทข้อมูลพื้นฐานใน R

ค่าทุกค่าใน R เป็นของชุดประเภทพื้นฐาน (อะตอมิก) จำนวนเล็กน้อย:

• 4.5 เป็นค่าทศนิยมที่เรียกว่าตัวเลข
• 4 ดูเหมือนจะเป็นจำนวนเต็ม แต่ R ยังคงเก็บค่าเป็นเลขฐานสอง ดังนั้นควรเขียน 4L เมื่อต้องการค่าเป็นจำนวนเต็มที่แท้จริง
• TRUE หรือ FALSE เป็นค่าบูลีน ซึ่งเรียกว่าค่าตรรกะในภาษา R
• ค่าที่อยู่ภายในเครื่องหมาย ” ” หรือ ' ' คือข้อความ (สตริง) ค่าเหล่านั้นเรียกว่าอักขระ

นอกจากนี้ยังมีอีกสองประเภทที่ทำให้ชุดข้อมูลสมบูรณ์ ค่าเชิงซ้อน เช่น 3+2i ประกอบด้วยส่วนจริงและส่วนจินตนาการ และค่าดิบซึ่งเก็บเป็นไบต์ ทั้งสองประเภทนี้พบได้ไม่บ่อยนักในการวิเคราะห์ในชีวิตประจำวัน แต่ก็มีอยู่ในชุดข้อมูลพื้นฐานของ R เอกสารประเภท() นอกเหนือจากประเภททั่วไปทั้งสี่ประเภทแล้ว

เราสามารถตรวจสอบชนิดของตัวแปรได้โดยใช้ฟังก์ชันของคลาส

ตัวอย่างที่ 1: ตรวจสอบตัวแปรตัวเลข

# Declare variables of different types
# Numeric
x <- 28
class(x)

Output:

## [1] "numeric"

ตัวอย่างที่ 2: ตรวจสอบตัวแปรอักขระ

# String
y <- "R is Fantastic"
class(y)

Output:

## [1] "character"

ตัวอย่างที่ 3: ตรวจสอบตัวแปรตรรกะ

# Boolean
z <- TRUE
class(z)

Output:

## [1] "logical"

โปรดสังเกตว่าฟังก์ชัน `class()` ตอบว่า "numeric" สำหรับค่า 28 แม้ว่า 28 จะไม่มีทศนิยมก็ตาม R เก็บค่านี้ไว้เป็นประเภท double และมีเพียงฟังก์ชัน `typeof()` เท่านั้นที่จะเปิดเผยข้อมูลนี้ได้ ความแตกต่างถัดไปที่ควรเรียนรู้คือวิธีการตั้งชื่อให้กับค่าเหล่านั้น

ตัวแปรใน R

ตัวแปรเป็นหนึ่งในองค์ประกอบพื้นฐานของ R ที่ใช้เก็บค่า และมีความสำคัญต่อทุกคนที่ทำงานด้านวิทยาศาสตร์ข้อมูล ตัวแปรใน R สามารถเก็บตัวเลข วัตถุ ผลลัพธ์ทางสถิติ เวกเตอร์ ชุดข้อมูล หรือการทำนายจากแบบจำลองได้ กล่าวคือ ทุกอย่างที่ R ส่งออกมา เราสามารถใช้ตัวแปรนั้นได้ในภายหลังโดยการเรียกชื่อของตัวแปรนั้น

ในการประกาศตัวแปรใน R เราต้องกำหนดชื่อตัวแปร ชื่อตัวแปรต้องไม่มีช่องว่าง เราสามารถใช้เครื่องหมาย _ เพื่อเชื่อมคำสองคำเข้าด้วยกันได้

ชื่อตัวแปรอาจประกอบด้วยตัวอักษร ตัวเลข จุด และขีดล่าง แต่ต้องขึ้นต้นด้วยตัวอักษรหรือจุด และคำสงวน เช่น TRUE, FALSE และ NULL ไม่สามารถใช้เป็นชื่อตัวแปรได้ ในการเพิ่มค่าให้กับตัวแปร ให้ใช้ <- หรือ =

นี่คือไวยากรณ์:

# First way to declare a variable:  use the `<-`
name_of_variable <- value
# Second way to declare a variable:  use the `=`
name_of_variable = value

ในบรรทัดคำสั่ง เราสามารถเขียนโค้ดต่อไปนี้เพื่อดูว่าจะเกิดอะไรขึ้น:

ตัวอย่างที่ 1: กำหนดค่าและพิมพ์ค่า

# Print variable x
x <- 42
x

Output:

## [1] 42

ตัวอย่างที่ 2: การประกาศตัวแปรตัวที่สอง

y  <- 10
y

Output:

## [1] 10

ตัวอย่างที่ 3: การใช้ตัวแปรสองตัวในนิพจน์เดียว

# We call x and y and apply a subtraction
x-y

Output:

## [1] 32

ตัวแปรที่เก็บค่าหลายค่าที่มีชนิดข้อมูลเดียวกันเรียกว่าเวกเตอร์ ซึ่งเป็นโครงสร้างที่ฟังก์ชันเกือบทุกฟังก์ชันในภาษา R ต้องการ

เวกเตอร์ใน R

เวกเตอร์คือชุดข้อมูลหนึ่งมิติที่ทุกองค์ประกอบมีชนิดข้อมูลเดียวกัน เราสามารถสร้างเวกเตอร์ด้วยชนิดข้อมูลพื้นฐานทั้งหมดของ R ที่ได้เรียนรู้ไปก่อนหน้านี้ วิธีที่ง่ายที่สุดในการสร้างเวกเตอร์ใน R คือการใช้ฟังก์ชัน c()

ตัวอย่างที่ 1: สร้างเวกเตอร์ตัวเลข

# Numerical
vec_num <- c(1, 10, 49)
vec_num

Output:

## [1]  1 10 49

ตัวอย่างที่ 2: สร้างเวกเตอร์ตัวอักษร

# Character 
vec_chr <- c("a", "b", "c")
vec_chr

Output:

## [1] "a" "b" "c"

ตัวอย่างที่ 3: สร้างเวกเตอร์เชิงตรรกะ

# Boolean 
vec_bool <-  c(TRUE, FALSE, TRUE)
vec_bool

Output:

##[1] TRUE FALSE TRUE

ถ้าฟังก์ชัน c() รับค่าที่มีประเภทต่างกัน ฟังก์ชันจะไม่เกิดข้อผิดพลาด มันจะแปลงค่าแต่ละองค์ประกอบให้เป็นประเภทที่ทั่วไปที่สุดที่มีอยู่โดยอัตโนมัติ ดังนั้น c(1, "a", TRUE) จึงกลายเป็นเวกเตอร์อักขระ นอกจากนี้ เรายังสามารถคำนวณทางคณิตศาสตร์บนเวกเตอร์ใน R ได้อีกด้วย

ตัวอย่างที่ 4: บวกเวกเตอร์สองตัวเข้าด้วยกันทีละองค์ประกอบ

# Create the vectors
vect_1 <- c(1, 3, 5)
vect_2 <- c(2, 4, 6)
# Take the sum of A_vector and B_vector
sum_vect <- vect_1 + vect_2
# Print out total_vector
sum_vect

Output:

[1]  3  7 11

การบวกจะทำงานทีละองค์ประกอบเนื่องจากเวกเตอร์ทั้งสองมีความยาวเท่ากัน เมื่อความยาวแตกต่างกัน R จะนำเวกเตอร์ที่สั้นกว่ามาใช้ซ้ำ จนกว่าจะตรงกับเวกเตอร์ที่ยาวกว่า และจะแจ้งเตือนเฉพาะเมื่อความยาวของเวกเตอร์ที่ยาวกว่าไม่ใช่ผลคูณของเวกเตอร์ที่สั้นกว่าเท่านั้น

ตัวอย่างที่ 5: หั่นองค์ประกอบห้าอย่างแรก

ใน R เราสามารถแบ่งเวกเตอร์ออกเป็นส่วนๆ ได้ ในบางครั้ง เราอาจสนใจเฉพาะห้าองค์ประกอบแรกของเวกเตอร์ เราสามารถใช้คำสั่ง [1:5] เพื่อแยกส่วนเหล่านั้นได้tract มีค่าตั้งแต่ 1 ถึง 5

# Slice the first five rows of the vector
slice_vector <- c(1,2,3,4,5,6,7,8,9,10)
slice_vector[1:5]

Output:

## [1] 1 2 3 4 5

ตัวอย่างที่ 6: สร้างช่วงโดยใช้เครื่องหมายโคลอน OperaTor

วิธีที่สั้นที่สุดในการสร้างช่วงของค่าคือการใช้เครื่องหมายโคลอน (:) คั่นระหว่างตัวเลขสองตัว ตัวอย่างเช่น จากตัวอย่างข้างต้น เราสามารถเขียน c(1:10) เพื่อสร้างเวกเตอร์ของค่าตั้งแต่หนึ่งถึงสิบได้

# Faster way to create adjacent values
c(1:10)

Output:

## [1]  1  2  3  4  5  6  7  8  9 10

เนื่องจากเวกเตอร์จะเปลี่ยนประเภทโดยไม่แจ้งให้ทราบเมื่อมีการผสมกัน จึงควรทราบวิธีการตรวจสอบและแปลงประเภทตามต้องการ

วิธีการตรวจสอบและแปลงชนิดข้อมูลใน R

ฟังก์ชันสามกลุ่มหลักตอบคำถามสามข้อที่เกิดขึ้นอยู่เสมอ ได้แก่ นี่คืออะไร นี่คือประเภทที่กำหนดหรือไม่ และสิ่งนี้สามารถกลายเป็นประเภทอื่นได้หรือไม่

# Three different views of the same value
x <- 28
class(x)      # "numeric"  -- the class used for method dispatch
typeof(x)     # "double"   -- how R stores the value internally
mode(x)       # "numeric"  -- the older S-style mode

# Ask a yes/no question about a type
is.numeric(x)     # TRUE
is.character(x)   # FALSE

# Convert between types
as.character(x)   # "28"
as.integer("28")  # 28 stored as an integer
as.numeric("abc") # NA, with a coercion warning

กฎสองข้อนี้อธิบายถึงความประหลาดใจส่วนใหญ่ได้ที่นี่ ข้อแรก ฟังก์ชัน `class()` รายงานคลาสที่ใช้สำหรับการเรียกใช้เมธอด ในขณะที่ `typeof()` รายงานการจัดเก็บภายใน ซึ่งเป็นเหตุผลว่าทำไม 28 จึงเป็น "numeric" สำหรับฟังก์ชันหนึ่ง และเป็น "double" สำหรับอีกฟังก์ชันหนึ่ง ข้อที่สอง การแปลงที่ไม่สำเร็จจะไม่หยุดสคริปต์: `as.numeric("abc")` ส่งคืนค่า `NA` และพิมพ์คำเตือนการแปลง ดังนั้นค่า `NA` ที่ไม่แสดงขึ้นมาหลังจากนำเข้าจึงมักเป็นปัญหาเกี่ยวกับประเภทข้อมูล ตรรกะเดียวกันนี้ใช้ในการขับเคลื่อน... ปัจจัยซึ่งจัดเก็บหมวดหมู่ในรูปแบบรหัสจำนวนเต็ม พร้อมด้วยตารางระดับ

เมื่อกำหนดประเภทต่างๆ เสร็จแล้ว ขั้นตอนต่อไปคือการกำหนดตัวดำเนินการที่ทำงานกับประเภทเหล่านั้น

R เลขคณิต Operaโปร

เราจะมาดูตัวดำเนินการทางคณิตศาสตร์พื้นฐานในภาษา R กันก่อน ต่อไปนี้คือตัวดำเนินการทางคณิตศาสตร์ในภาษา R และความหมายของแต่ละตัว:

ตัวดำเนินการเหล่านี้ทั้งหมดเป็นแบบเวกเตอร์ ดังนั้นนิพจน์เดียวกันจึงสามารถใช้ได้กับค่าเดียวหรือทั้งคอลัมน์ก็ได้

ตัวอย่างที่ 1: การบวก

# An addition
3 + 4

Output:

## [1] 7

คุณสามารถคัดลอกและวางโค้ด R ด้านบนลงใน... ได้อย่างง่ายดาย RStudio คอนโซล ในบทความนี้ ผลลัพธ์จะแสดงในบรรทัดที่ขึ้นต้นด้วย ## ตัวอย่างเช่น ถ้าเราเขียนโค้ด print("Guru99") คอนโซลพิมพ์ [1] "Guru99" ซึ่งหน้านี้จะแสดงเป็น ## [1] "Guru99"

เครื่องหมาย ## แสดงถึงบรรทัดของผลลัพธ์ที่พิมพ์ และตัวเลขในวงเล็บเหลี่ยม ([1]) คือดัชนีของค่าแรกในบรรทัดนั้น ไม่ใช่ส่วนหนึ่งของผลลัพธ์

ประโยคที่ขึ้นต้นด้วย # คือข้อความแสดงความคิดเห็น เราสามารถใช้ # ภายในสคริปต์ R เพื่อเพิ่มบันทึกใดๆ ก็ได้ และ R จะไม่สนใจข้อความนั้นในระหว่างการทำงาน

ตัวอย่างที่ 2: การคูณ

# A multiplication
3*5

Output:

## [1] 15

ตัวอย่างที่ 3: การหาร

# A division
(5+5)/2

Output:

## [1] 5

ตัวอย่างที่ 4: การยกกำลัง

# Exponentiation
2^5

Output:

## [1] 32

ตัวอย่างที่ 5: โมดูลัส

# Modulo
28%%6

Output:

## [1] 4

การคำนวณทางคณิตศาสตร์ให้ผลลัพธ์เป็นตัวเลข ส่วนกลุ่มตัวดำเนินการถัดไปจะให้ผลลัพธ์เป็นค่าจริงและค่าเท็จแทน

R เชิงสัมพันธ์ (การเปรียบเทียบ) Operaโปร

ตัวดำเนินการเชิงสัมพันธ์จะเปรียบเทียบค่าสองค่าและส่งคืนผลลัพธ์เชิงตรรกะ ตัวดำเนินการเหล่านี้เป็นตัวดำเนินการที่สร้างเงื่อนไขที่ใช้สำหรับการกรอง และมีการแปลงเป็นเวกเตอร์ในลักษณะเดียวกับตัวดำเนินการทางคณิตศาสตร์ทุกประการ

a <- 10
b <- 3

a > b     # TRUE
a < b     # FALSE
a >= 10   # TRUE
a <= 3    # FALSE
a == b    # FALSE
a != b    # TRUE

# Relational operators are vectorised
scores <- c(45, 78, 90, 62)
scores >= 60   # FALSE TRUE TRUE TRUE

สองวิธีนี้จะช่วยประหยัดเวลาได้ ใช้ == สำหรับการเปรียบเทียบ และ <- สำหรับการกำหนดค่า เพราะการใช้ = ตัวเดียวภายในเงื่อนไขเป็นข้อผิดพลาดทั่วไปของมือใหม่ และควรหลีกเลี่ยงการใช้ == กับตัวเลขทศนิยม: การปัดเศษของเลขทศนิยมหมายความว่า 0.1 + 0.2 == 0.3 เป็นเท็จ ดังนั้น isTRUE(all.equal(0.1 + 0.2, 0.3)) จึงเป็นการทดสอบที่ปลอดภัย การเปรียบเทียบ... เฟรมข้อมูลที่เรียงลำดับแล้ว ปฏิบัติตามกฎเดียวกัน

อาร์ ลอจิก Operaโปร

ด้วยตัวดำเนินการตรรกะ เราต้องการส่งค่ากลับเข้าไปในเวกเตอร์โดยอิงตามเงื่อนไขตรรกะ ตารางด้านล่างแสดงรายการตัวดำเนินการตรรกะที่มีอยู่ใน R

คำสั่งเชิงตรรกะใน R จะอยู่ภายในวงเล็บเหลี่ยม [] เราสามารถเพิ่มคำสั่งเงื่อนไขได้มากเท่าที่ต้องการ แต่เราต้องใส่ไว้ในวงเล็บ เราสามารถใช้โครงสร้างนี้เพื่อสร้างคำสั่งเงื่อนไขได้:

variable_name[(conditional_statement)]

โดยใช้ variable_name เพื่ออ้างอิงถึงตัวแปรที่เราต้องการใช้ในคำสั่งนั้น เราจะสร้างคำสั่งตรรกะขึ้นมา เช่น variable_name > 0 สุดท้าย เราใช้เครื่องหมายวงเล็บเหลี่ยมเพื่อทำให้คำสั่งตรรกะเสร็จสมบูรณ์ ตัวอย่างของคำสั่งตรรกะมีดังนี้

ตัวอย่างที่ 1: เปรียบเทียบองค์ประกอบทุกตัวของเวกเตอร์

# Create a vector from 1 to 10
logical_vector <- c(1:10)
logical_vector>5

Output:

## [1]FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

ในผลลัพธ์ข้างต้น R จะอ่านแต่ละค่าและเปรียบเทียบกับเงื่อนไข logical_vector>5 หากค่ามากกว่าห้าอย่างชัดเจน เงื่อนไขจะเป็น TRUE มิฉะนั้นจะเป็น FALSE R จะส่งคืนเวกเตอร์ของ TRUE และ FALSE

ตัวอย่างที่ 2: เก็บเฉพาะองค์ประกอบที่ตรงกันเท่านั้น

ในตัวอย่างด้านล่าง เราต้องการแสดงtracสำหรับค่าต่างๆ ที่ตรงตามเงื่อนไข 'ต้องมากกว่าห้าอย่างเคร่งครัด' นั้น เราสามารถใส่เงื่อนไขไว้ในวงเล็บเหลี่ยม โดยมีเวกเตอร์ที่บรรจุค่าเหล่านั้นอยู่ข้างหน้า

# Print value strictly above 5
logical_vector[(logical_vector>5)]

Output:

## [1]  6  7  8  9 10

ตัวอย่างที่ 3: การรวมสองเงื่อนไขเข้าด้วยกัน

# Print 5 and 6
logical_vector <- c(1:10)
logical_vector[(logical_vector>4) & (logical_vector<7)]

Output:

## [1] 5 6

ตัวอย่างที่ 3 ใช้เครื่องหมายแอมเปอร์แซนด์เดี่ยว & โดยเจตนา ตัวดำเนินการอักขระเดี่ยว & และ | เปรียบเทียบองค์ประกอบเวกเตอร์ทีละองค์ประกอบและส่งคืนเวกเตอร์ ซึ่งเป็นสิ่งที่การเลือกย่อยต้องการ ตัวดำเนินการอักขระคู่ && และ || ส่งคืนค่าเดียวและอยู่ในเงื่อนไข if() และ while() เนื่องจาก 4.3.0 Rการส่งอาร์กิวเมนต์ที่มีความยาวมากกว่าหนึ่งองค์ประกอบไปยัง && หรือ || จะถือเป็นข้อผิดพลาด ไม่ใช่คำเตือน ดังนั้นตัวดำเนินการทั้งสองประเภทจึงไม่สามารถใช้แทนกันได้อีกต่อไป ตัวดำเนินการ ! ใช้สำหรับปฏิเสธเงื่อนไข และ xor() ใช้สำหรับดำเนินการ Exclusive OR

การมอบหมายงาน R Operaโปร

ตัวดำเนินการกำหนดค่าจะผูกค่าเข้ากับชื่อ ภาษา R มีตัวดำเนินการเหล่านี้มากกว่าภาษาโปรแกรมส่วนใหญ่ และความแตกต่างเหล่านี้มีความสำคัญเมื่อโค้ดถูกนำไปใช้งานจริง ฟังก์ชั่น.

# Left assignment -- the idiomatic form
count <- 5

# Equals sign: works, but reserve it for function arguments
count = 5
round(3.14159, digits = 2)

# Right assignment
5 -> count

# Superassignment, used inside functions to reach an outer scope
count <<- 5

คู่มือการเขียนโค้ดแนะนำให้ใช้ <- สำหรับการสร้างอ็อบเจ็กต์ และ = สำหรับการตั้งชื่ออาร์กิวเมนต์ภายในฟังก์ชันเรียกใช้ เนื่องจากจะทำให้เห็นความแตกต่างระหว่างสองบทบาทนี้ได้อย่างชัดเจน ควรใช้ <<- อย่างระมัดระวัง เพราะมันจะเปลี่ยนแปลงอ็อบเจ็กต์ภายนอกฟังก์ชันปัจจุบัน และทำให้โค้ดเข้าใจยากขึ้น เมื่อเข้าใจเรื่องการกำหนดค่าและชนิดข้อมูลแล้ว ขั้นตอนต่อไปคือ... นำเข้าข้อมูลจริง และเรชาping มันด้วย ดีพลีร์; ภาพรวมภาษา R ช่วยให้เข้าใจบริบทของชุดเครื่องมือทั้งหมดได้ดียิ่งขึ้น

คำถามที่พบบ่อย