เพิ่ม ลบ และเปลี่ยนชื่อคอลัมน์ใน R โดยใช้ Dplyr

dplyr เป็นแพ็คเกจ R ยอดนิยมสำหรับการจัดการข้อมูล ทำให้ผู้ใช้ทำงานกับ data frame ได้ง่ายขึ้น งานทั่วไปเมื่อทำงานกับข้อมูลคือการเปลี่ยนชื่อคอลัมน์ ซึ่ง dplyr จัดการได้อย่างมีประสิทธิภาพโดยใช้ฟังก์ชัน rename()

ฟังก์ชัน rename() ใน dplyr มีประโยชน์อย่างยิ่งเมื่อต้องจัดการกับชุดข้อมูลที่มีคอลัมน์ที่มีชื่อไม่ชัดเจนหรือกำกวม dplyr ช่วยให้ผู้ใช้เข้าใจและดูแลรักษาโค้ดของตนได้ง่ายขึ้นด้วยการจัดเตรียมไวยากรณ์ที่ง่ายและไม่ซับซ้อนสำหรับการเปลี่ยนชื่อคอลัมน์

นอกจากนี้ ฟังก์ชันนี้สามารถใช้ร่วมกับการดำเนินการ dplyr อื่นๆ ได้อย่างง่ายดาย เช่น การกรองและการสรุป เพื่อสร้างเวิร์กโฟลว์การจัดการข้อมูลที่ราบรื่นใน R

คุณลักษณะเหล่านี้ยังมีอยู่ในPower Queryดังนั้นจึงไม่ซ้ำกับโปรแกรม R อย่างไรก็ตาม R จัดการพวกมันได้ดีกว่า

ในบทความต่อไปนี้ เราจะสำรวจรายละเอียดของฟังก์ชัน rename() ของ dplyr และแอปพลิเคชันต่างๆ โดยยกตัวอย่างว่าฟังก์ชันนี้มีประสิทธิภาพเพียงใดในการจัดการเฟรมข้อมูล

เราจะเรียนรู้วิธีเพิ่มและลบคอลัมน์ใน R โดยใช้ dyplr

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

เข้าสู่วิทยาการข้อมูลกันบ้าง ถึงเวลาพูดพร่ำเพรื่อ หรือเราควรจะบอกว่า เอาฐาน R มา!

สารบัญ

• ทำความเข้าใจเกี่ยวกับการเปลี่ยนชื่อ Dplyr
• การติดตั้งและการโหลด Dplyr
• ใช้ฟังก์ชันเปลี่ยนชื่อ Dplyr
  • ไวยากรณ์พื้นฐาน
  • การเปลี่ยนชื่อหลายคอลัมน์
  • การผูกมัดกับฟังก์ชัน Dplyr อื่น ๆ
• กรณีใช้งานการเปลี่ยนชื่อ Dplyr ทั่วไป
• การจัดการข้อผิดพลาดและ Edge Case
• ตัวอย่างเพิ่มเติมในโลกแห่งความเป็นจริง -การเพิ่ม ลบ และเปลี่ยนชื่อคอลัมน์
• ฟังก์ชันพื้นฐานสำหรับการทำงานของคอลัมน์
  • 1. เพิ่มคอลัมน์ใหม่ใน R
  • 2. เลือกคอลัมน์ใน R
  • 3. เปลี่ยนชื่อคอลัมน์ใน R
• คำสุดท้าย
• คำถามที่พบบ่อย
  • R และ Python ต่างกันอย่างไร
  • สตริคืออะไร?
  • Petal.Length ใน R คืออะไร?
  • DataFrame ใน R คืออะไร
  • ดบล ย่อมาจากอะไร ?

ทำความเข้าใจเกี่ยวกับการเปลี่ยนชื่อ Dplyr

แพ็คเกจ dplyr ใน R เป็น แพ็คเกจ tidyverse ที่ได้รับความนิยม สำหรับการจัดการข้อมูลที่มีชุดฟังก์ชันที่มีประโยชน์สำหรับการแปลงและจัดระเบียบชุดข้อมูล ในบรรดาฟังก์ชันเหล่านี้ ฟังก์ชัน rename() มีประโยชน์อย่างยิ่งเมื่อต้องแก้ไขชื่อคอลัมน์ใน data frame

new_name = old_nameหากต้องการใช้ฟังก์ชัน rename() ให้ระบุชื่อ คอลัมน์ใหม่ตามด้วยชื่อเก่า ดังนี้ ตัวอย่างเช่น ให้เราพิจารณา data frame ตัวอย่างที่เราต้องการเปลี่ยนชื่อคอลัมน์ “old1” เป็น “new1” ไวยากรณ์จะมีลักษณะดังนี้:

library(dplyr)
df %>% rename(new1 = old1)

นอกจากนี้ ฟังก์ชัน rename_with() ช่วยให้คุณสามารถเปลี่ยนชื่อคอลัมน์โดยใช้ฟังก์ชันการแปลงที่ระบุ ตัวอย่างเช่น คุณอาจใช้ฟังก์ชันตัวบนเพื่อแปลงชื่อคอลัมน์ทั้งหมดเป็นตัวพิมพ์ใหญ่:

df %>% rename_with(toupper)

หากคุณต้องการเปลี่ยนชื่อหลายคอลัมน์พร้อมกัน dplyr มีสองวิธี อันแรกเกี่ยวข้องกับการใช้ฟังก์ชัน rename() โดยให้ชื่อคอลัมน์ใหม่และเก่าหลายรายการเป็นอาร์กิวเมนต์:

df %>% rename(new1 = old1, new2 = old2)

วิธีที่สองเกี่ยวข้องกับการใช้ฟังก์ชัน rename_with() ซึ่งคุณกำหนดอาร์เรย์ของชื่อคอลัมน์เก่าและใหม่:

new <- c('new1',="" 'new2')="" old=""><- c('old1',="" 'old2')="" df="" %="">% rename_with(~ new, all_of(old))

ทั้งสองวิธีตามที่แสดงในตัวอย่างข้างต้นจะให้ผลลัพธ์เหมือนกัน

การติดตั้งและการโหลด Dplyr

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

install.packages("dplyr")

หลังจากการติดตั้งเสร็จสิ้น คุณสามารถโหลดแพ็คเกจ dplyr ในสคริปต์ R ของคุณโดยใช้ฟังก์ชันไลบรารี:

library("dplyr")

เมื่อติดตั้งและโหลดแพ็คเกจ dplyr แล้ว ตอนนี้คุณสามารถใช้ฟังก์ชันการจัดการข้อมูลที่มีประสิทธิภาพ รวมถึงฟังก์ชัน rename() เพื่อเปลี่ยนชื่อคอลัมน์ใน data frame ของคุณ

ต่อไปนี้คือตัวอย่างการใช้ฟังก์ชัน rename() กับชุดข้อมูล iris ที่รู้จักกันดี สมมติว่าคุณต้องการเปลี่ยนชื่อคอลัมน์ “Sepal.Length” เป็น “sepal_length” คุณสามารถทำได้โดยใช้รหัสต่อไปนี้:

iris_renamed <- iris="" %="">%
  rename(sepal_length = Sepal.Length)

ในข้อมูลโค้ดนี้ ตัวดำเนินการ %>% ใช้เพื่อไพพ์ชุดข้อมูลม่านตาไปยังฟังก์ชัน rename() ชื่อคอลัมน์ใหม่ “sepal_length” ถูกกำหนดให้กับชื่อคอลัมน์เก่า “Sepal.Length” กรอบข้อมูลผลลัพธ์ที่มีคอลัมน์ที่เปลี่ยนชื่อแล้วจะถูกกำหนดให้กับชื่อตัวแปร iris_renamed

ฟังก์ชัน rename() ยังสามารถจัดการการเปลี่ยนชื่อหลายคอลัมน์พร้อมกันได้อีกด้วย ตัวอย่างเช่น ถ้าคุณต้องการเปลี่ยนชื่อทั้งคอลัมน์ "Sepal.Length" และ "Sepal.Width" เป็น "sepal_length" และ "sepal_width" ตามลำดับ คุณสามารถใช้รหัสต่อไปนี้:

iris_renamed <- iris="" %="">%
  rename(
    sepal_length = Sepal.Length,
    sepal_width = Sepal.Width
  )

ข้อมูลโค้ดนี้แสดงให้เห็นว่าการเปลี่ยนชื่อหลายคอลัมน์ใน data frame ทำได้ง่ายเพียงใดโดยใช้ฟังก์ชัน rename() ของ dplyr

ใช้ฟังก์ชันเปลี่ยนชื่อ Dplyr

แพ็คเกจ dplyr ใน R เป็นเครื่องมือที่มีประสิทธิภาพสำหรับการจัดการข้อมูลเมื่อทำงานกับเฟรมข้อมูล หนึ่งในฟังก์ชันที่มีประโยชน์มากมายที่มีให้คือฟังก์ชันเปลี่ยนชื่อ ซึ่งช่วยให้คุณเปลี่ยนชื่อคอลัมน์ใน data frame ของคุณได้อย่างง่ายดาย

ไวยากรณ์พื้นฐาน

ไวยากรณ์พื้นฐานสำหรับการใช้ฟังก์ชันเปลี่ยนชื่อใน dplyr มีดังนี้:

library(dplyr)
your_dataframe %>% rename(new_column_name = old_column_name)

คำสั่งนี้จะเปลี่ยนชื่อคอลัมน์เก่าที่ระบุเป็นชื่อคอลัมน์ใหม่ที่ต้องการ โดยไม่ต้องเปลี่ยนคอลัมน์อื่นใน data frame

การเปลี่ยนชื่อหลายคอลัมน์

คุณยังสามารถเปลี่ยนชื่อหลายคอลัมน์พร้อมกันได้โดยใช้ฟังก์ชันเปลี่ยนชื่อเดียวกัน ในการทำเช่นนี้ เพียงคั่นแต่ละคอลัมน์โดยเปลี่ยนชื่อคู่ด้วยเครื่องหมายจุลภาค:

your_dataframe %>%
   rename(new_column1 = old_column1,
          new_column2 = old_column2,
          new_column3 = old_column3)

ใช้วิธีการนี้ คุณสามารถเปลี่ยนชื่อคอลัมน์ได้มากเท่าที่จำเป็นในคำสั่งเดียว

หรือคุณสามารถใช้rename_with()ฟังก์ชันเพื่อใช้การแปลงกับชื่อคอลัมน์ ฟังก์ชันนี้ใช้ data frame และฟังก์ชันที่จะใช้กับชื่อคอลัมน์เพื่อสร้างชื่อใหม่ ตัวอย่างเช่น:

your_dataframe %>%
  rename_with(.cols = c("old_column1", "old_column2"), .fn = toupper)

สิ่งนี้จะแปลงชื่อคอลัมน์ที่ระบุเป็นตัวพิมพ์ใหญ่

การผูกมัดกับฟังก์ชัน Dplyr อื่น ๆ

One of the strengths of dplyr is its ability to chain multiple actions together using the %>% operator. This allows you to perform a series of data manipulations in a concise and easy-to-read manner. When using the rename function, you can chain it along with other dplyr functions such as filter(), mutate(), and summarize() :

your_dataframe %>%
  filter(some_condition) %>%
  rename(new_column_name = old_column_name) %>%
  mutate(new_column = some_expression) %>%
  summarize(some_aggregation)

This example demonstrates a series of data manipulations where data filtering is done first, followed by renaming a column, creating a new column using mutate, and finally summarizing the data with an aggregation function.

By leveraging the power of dplyr’s rename function and chaining capabilities, R users can perform efficient and readable data manipulations on their data frames.

Common Dplyr Rename Use Cases

Dplyr is a powerful package in R that provides a set of functions for performing data manipulation tasks. One common task is renaming columns in a data frame. In this section, we will discuss some common use cases for the rename feature in dplyr.

1. Simple column renaming:

Renaming a single column is straightforward using the rename() function. The syntax is rename(dataframe, new_name = old_name). Here’s an example:

library(dplyr)
dataframe <- dataframe="" %="">% rename(new_column_name = old_column_name)

2. Renaming multiple columns:

You can also rename multiple columns in one function call by providing additional column mapping inside rename() function. Here’s an example:

dataframe <- dataframe="" %="">%
  rename(new_col_name1 = old_col_name1,
         new_col_name2 = old_col_name2)

3. Renaming columns using string functions:

You can rename columns using string functions, such as tolower() or toupper(), by using the rename_with() function. According to Stack Overflow, this function replaces the now superseded rename_if, rename_at and rename_all functions. Here’s an example:

dataframe <- dataframe="" %="">%
  rename_with(tolower)  # Converts column names to lowercase

4. Renaming columns based on a condition:

With rename_with(), you can apply custom renaming functions and even use conditions. The following example demonstrates renaming columns based on whether they contain a certain string:

rename_function <- function(x)="" {="" if="" (grepl("length",="" x))="" {="" return(paste0(x,="" "_length"))="" }="" else="" {="" return(paste0(x,="" "_default"))="" }="" }="" dataframe=""><- dataframe="" %="">% rename_with(rename_function)

Handling Errors and Edge Cases

While using the dplyr rename function to modify column names in a data frame, you might encounter some errors or edge cases due to duplicate column names, spaces in column names, or incorrect syntax. This section provides guidance on how to address these issues.

When dealing with duplicate column names, dplyr cannot rename the columns with the same output name. However, a workaround to unduplicate column names is to use the rename_all function from the dplyr package along with paste0:

d %>% rename_all(~paste0(., 1:2))

This code will append a number from 1 to 2 to each column name, ensuring there are no duplicates. More details can be found in this Stack Overflow discussion.

In case there are spaces in column names, you can use backticks to enclose the column names like this:

df %>% rename(foo = `test col`)

Finally, if you face issues related to dplyr not accepting the paste0() function as the old_name in rename(), a possible solution is to construct the new column names outside of the rename() function and then use them as input. A relevant discussion on a similar issue can be found in this Stack Overflow question.

By addressing these errors and edge cases, you will be better equipped to handle complex renaming scenarios in dplyr.

In this final section of our article about dplyr rename, we have discussed its importance in data manipulation tasks. The rename() function allows users to alter column names efficiently, leading to clearer and more concise data frames. This becomes particularly useful when dealing with large datasets or during data preprocessing steps.

การใช้แพ็คเกจ dplyr การเปลี่ยนชื่อคอลัมน์ใน R นั้นตรงไปตรงมา ไม่ใช่วิทยาศาสตร์ข้อมูลที่ยาก ลองดูด้านล่าง:

  rename(new_column_name = old_column_name)

ไวยากรณ์ง่ายๆ นี้ช่วยให้คุณแทนที่ชื่อคอลัมน์เก่าด้วยชื่อใหม่ ปรับปรุงความสามารถในการอ่านและสร้างความสอดคล้องในข้อมูลของคุณ นอกจากนี้ สามารถใช้ฟังก์ชัน rename_with() เพื่อแก้ไขชื่อคอลัมน์โดยใช้ฟังก์ชันเฉพาะ สิ่งนี้ให้การควบคุมและปรับแต่งการจัดการข้อมูลของคุณได้ดียิ่งขึ้น

ด้วยการใช้พลังของ dplyr และฟังก์ชันการเปลี่ยนชื่อ คุณสามารถจัดการข้อมูลของคุณได้อย่างมั่นใจและปรับปรุงความสามารถในการประมวลผลข้อมูลโดยรวม อย่าลืมใช้แหล่งข้อมูลที่เชื่อถือได้เสมอเมื่อเรียนรู้เทคนิคการเขียนโปรแกรม R ใหม่ เช่น

ด้วยการเปลี่ยนชื่อ dplyr ในชุดเครื่องมือของคุณ คุณก็พร้อมที่จะรับมือกับความท้าทายในการจัดการข้อมูลต่างๆ และพัฒนาความเชี่ยวชาญในการเขียนโปรแกรม R ของคุณต่อไป

ตัวอย่างเพิ่มเติมในโลกแห่งความเป็นจริง -การเพิ่ม ลบ และเปลี่ยนชื่อคอลัมน์

การดำเนินการคอลัมน์ช่วยให้คุณสามารถคำนวณ เพิ่ม ลบและเปลี่ยนชื่อคอลัมน์ใน R โดยใช้dplyr เปิดสคริปต์ R ใหม่ใน RStudio หากคุณ ไม่ทราบวิธี ให้คลิกที่ลิงก์เพื่อดูวิธีติดตั้ง RStudioและสร้างสคริปต์ R

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

ยิ่งไปกว่านั้น แพ็คเกจ Lahman ยังมีชุดข้อมูลที่ชื่อว่าTeamsโดยมีตัวพิมพ์ใหญ่ T แนวปฏิบัติที่ดีที่สุดสำหรับการตั้งชื่อแบบแผนใน R คือการใช้ตัวอักษรพิมพ์เล็ก ดังนั้นจึงจำเป็นต้องแปลงเป็นteam ก่อน ดังที่เห็นในภาพด้านล่าง

ฟังก์ชันพื้นฐานสำหรับการทำงานของคอลัมน์

1. เพิ่มคอลัมน์ใหม่ใน R

ฟังก์ชันแรกคือกลายพันธุ์ ( ) สิ่งนี้จะสร้างคอลัมน์ใหม่ตามคอลัมน์ที่มีอยู่

หากคุณต้องการคำนวณคอลัมน์ใหม่ คุณสามารถใช้ ฟังก์ชัน mutateต่อจากอาร์กิวเมนต์:

dfเป็นชื่อแทนสำหรับ data frame ทุกชนิด ดังนั้นเมื่อใช้งานจริง ให้แทนที่dfด้วยชื่อ data frame ที่คุณต้องการเปลี่ยน จากนั้น คุณวางตัวแปรใหม่ที่ต้องตั้งชื่อพร้อมกับสูตรสำหรับการสร้างคอลัมน์ใหม่

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

นี่คือสิ่งที่เกิดขึ้นหากคุณเรียกใช้ ฟังก์ชัน กลายพันธุ์โดยไม่มี dplyr:

คุณจะได้รับข้อความแสดงข้อผิดพลาดว่า "ไม่พบการกลายพันธุ์ของฟังก์ชัน"

ดังนั้นนี่คือวิธีนำ dplyr เข้าสู่ R คุณต้องเรียกใช้library (tidyverse) เท่านั้น

คุณจะเห็นว่าdplyrเป็นหนึ่งในฟังก์ชันมากมายในแพ็คเกจtidyverse อีกทางเลือกหนึ่งคือการเรียกใช้ไลบรารี(dplyr)

ตอนนี้ ถ้าคุณวางเคอร์เซอร์บนโค้ดที่มี ฟังก์ชัน mutateและเรียกใช้ คุณจะเห็น คอลัมน์ Wpctที่มีเปอร์เซ็นต์การชนะ

ในกรณีนี้ ผลลัพธ์ของ ฟังก์ชัน กลายพันธุ์ถูกรันเท่านั้น มันไม่ได้กำหนดให้กับข้อมูล

หากคุณต้องการกำหนดผลลัพธ์ของ ฟังก์ชัน การกลายพันธุ์ ให้กับ ทีมข้อมูลคุณต้องใช้ตัวดำเนินการกำหนด ( <-> ) เมื่อเสร็จแล้วให้เรียกใช้ จากนั้นในบรรทัดอื่นให้เรียกใช้head (ทีม) สิ่งนี้จะกำหนดผลลัพธ์ให้กับชุดข้อมูลของทีม

หากคุณต้องการตรวจสอบว่ามีคอลัมน์ใดบ้างในชุดข้อมูล ให้ใช้ฟังก์ชันnames ( ) นี่จะแสดงชื่อคอลัมน์ทั้งหมดในข้อมูล

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

2. เลือกคอลัมน์ใน R

ฟังก์ชันอื่นใน dplyr คือการเลือก ( ) มันวางหรือเลือกคอลัมน์ที่กำหนด อัลกอริทึมพื้นฐานของมันคือ:

คุณต้องป้อนชื่อเฟรมข้อมูลแล้วตามด้วยคอลัมน์ที่คุณต้องการเลือก

ตัวอย่างเช่น หากคุณต้องการเก็บคอลัมน์ yearID, wins และ loss ไว้ในชุดข้อมูล คุณจะต้องเรียกใช้:

จากนั้นคุณจะได้ผลลัพธ์ที่คุณต้องการ:

อย่างไรก็ตาม หากคุณไม่ได้ใช้ ฟังก์ชัน head ( )ผลลัพธ์จะแสดงแถวล่างสุดของคอลัมน์ ดังนั้น หากคุณต้องจัดการกับข้อมูลหลายแถว คุณจะต้องเลื่อนขึ้นอย่างต่อเนื่องเพื่อไปที่ด้านบนสุดของคอลัมน์

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

ตอนนี้ ถ้าคุณต้องการลบคอลัมน์ออกจากชุดข้อมูล คุณต้องใส่เครื่องหมายลบ ( – ) หน้าชื่อคอลัมน์ เท่านั้น

หากต้องการตรวจสอบว่ามีการลบคอลัมน์ออกไปหรือไม่ คุณสามารถเปรียบเทียบชุดข้อมูลใหม่กับชุดข้อมูลเก่าได้ นี่คือวิธีการ:

ขั้นแรก กำหนดรหัส R ด้วย ฟังก์ชัน เลือกให้กับวัตถุ ในตัวอย่าง นี้ถูกกำหนดให้กับteam_short ในการนับจำนวนคอลัมน์ ให้ใช้ฟังก์ชันncol ( ) เรียกใช้ฟังก์ชันncolสำหรับทั้งteam_shortและteam

จากนั้นคุณจะเห็นว่าคอลัมน์หนึ่งถูกลบออกจากชุดข้อมูล

3. เปลี่ยนชื่อคอลัมน์ใน R

ฟังก์ชันคอลัมน์สุดท้ายใน dplyr คือrename ( ) และตามชื่อที่แนะนำ มันสามารถเปลี่ยนชื่อคอลัมน์ที่เลือกใน R

นี่คืออัลกอริทึมพื้นฐานของมัน:

และคุณจะสังเกตได้ว่ามันค่อนข้างจะสวนทางกับสัญชาตญาณ ชื่อใหม่มาก่อนในขณะที่ชื่อเก่ามาหลังจากนั้น เพื่อให้แน่ใจว่าจะไม่ทำให้สิ่งเหล่านั้นปะปนกัน

ตัวอย่างเช่น คอลัมน์ yearIDและdivID ปัจจุบัน จะถูกเปลี่ยนชื่อเป็นyear_idและDivision_idตามลำดับ ก่อนเรียกใช้โค้ด ตรวจสอบให้แน่ใจว่าได้กำหนดสิ่งนี้ให้กับวัตถุใหม่เพื่อไม่ให้รบกวนชุดข้อมูลเดิม

ในการตรวจสอบว่าคอลัมน์ที่เลือกเหล่านี้เปลี่ยนชื่อสำเร็จหรือไม่ ให้ใช้ฟังก์ชันnames ( )

คุณจะเห็นว่ามีการเปลี่ยนชื่อคอลัมน์จริงๆ

เคยสงสัยหรือไม่ว่า R มีประสิทธิภาพเพียงใดเมื่อใช้กับ LuckyTemplates ลองดูเทคนิคที่ยอดเยี่ยมนี้ ซึ่งจะช่วยให้คุณประหยัดเวลาได้มาก

คำสุดท้าย

บทช่วยสอนนี้ได้กล่าวถึงฟังก์ชัน dplyrพื้นฐานสามฟังก์ชันที่คุณสามารถใช้เพื่อดำเนินการกับคอลัมน์ คุณได้เรียนรู้วิธีเพิ่ม ลบ และเปลี่ยนชื่อคอลัมน์ใน R

ยังมีฟังก์ชันอื่นๆ ที่คุณยังไม่ได้สำรวจ แต่สิ่งสำคัญคือต้องรู้และคุ้นเคยกับการกลายพันธุ์ ( ) เลือก ( )และเปลี่ยนชื่อ ( )เนื่องจากเป็นสิ่งที่พบได้บ่อยที่สุด

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

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

R และ Python ต่างกันอย่างไร

สำหรับผู้เริ่มต้น ทั้ง R และ Python เป็นภาษาโปรแกรม แต่ python เป็นภาษาใช้งานทั่วไปมากกว่า และ R เป็นภาษาโปรแกรมเชิงสถิติ Python เป็นภาษาที่ใช้บ่อย เข้าใจได้ และหลากหลาย

สตริคืออะไร?

str แสดงโครงสร้างของวัตถุ r

Petal.Length ใน R คืออะไร?

Petal.length เป็นรูปแบบที่ใช้ใน R สำหรับการเล่าความสัมพันธ์ที่เรากำลังทดสอบ

DataFrame ใน R คืออะไร

กรอบข้อมูล R เป็นโครงสร้างข้อมูลแบบตารางที่ใช้กันทั่วไปในการจัดเก็บค่าของข้อมูลประเภทใดก็ได้

ดบล ย่อมาจากอะไร ?

Dbl ย่อมาจาก "double class" เป็นประเภทข้อมูลที่ใช้เก็บค่าตัวเลขที่มีจุดทศนิยม