Tambah, Alih Keluar & Namakan Semula Lajur Dalam R Menggunakan Dplyr

dplyr ialah pakej R yang popular untuk manipulasi data, menjadikannya lebih mudah bagi pengguna untuk bekerja dengan bingkai data. Tugas biasa apabila bekerja dengan data ialah menamakan semula lajur, yang dplyr mengendalikan dengan cekap menggunakan fungsi rename().

Fungsi rename() dalam dplyr amat berguna apabila berurusan dengan set data yang mempunyai lajur dengan nama yang tidak jelas atau samar-samar. Dengan menyediakan sintaks yang mudah dan intuitif untuk menamakan semula lajur, dplyr memudahkan pengguna memahami dan mengekalkan kod mereka.

Selain itu, fungsi ini boleh digabungkan dengan mudah dengan operasi dplyr lain, seperti penapisan dan ringkasan, untuk mencipta aliran kerja manipulasi data yang lancar dalam R.

Ciri ini juga tersedia dalam Power Query , jadi ciri ini bukan unik untuk program R. Walau bagaimanapun, R lebih baik dalam mengendalikannya.

Dalam artikel berikut, kami akan meneroka butiran fungsi rename() dplyr dan pelbagai aplikasinya, menunjukkan keberkesanannya dalam mengurus bingkai data.

Kami juga akan belajar cara menambah dan mengalih keluar lajur dalam R menggunakan dyplr.

Dengan mempelajari teknik ini, pengguna boleh meningkatkan kepraktisan usaha manipulasi data mereka, menghasilkan analisis yang lebih mantap dan bebas ralat dan berseronok sepanjang perjalanan!

Mari kita masuk ke dalam beberapa sains data, sudah tiba masanya untuk mencebik, atau patutkah kita katakan, bawa asas R!

Isi kandungan

• Memahami Dplyr Rename
• Memasang dan Memuatkan Dplyr
• Menggunakan Fungsi Nama Semula Dplyr
  • Sintaks Asas
  • Menamakan semula Berbilang Lajur
  • Merangkai dengan Fungsi Dplyr Lain
• Kes Penggunaan Nama Semula Dplyr Biasa
• Mengendalikan Ralat dan Kes Tepi
• Contoh Dunia Nyata Lagi -Menambah, Mengalih Keluar & Menamakan Semula Lajur
• Fungsi Asas Untuk Operasi Lajur
  • 1. Tambah Lajur Baharu Dalam R
  • 2. Pilih Lajur Dalam R
  • 3. Namakan Semula Lajur Dalam R
• Kata Akhir
• Soalan Lazim
  • Apakah perbezaan antara R dan Python?
  • Apakah str?
  • Apakah Petal.Length dalam R?
  • Apakah DataFrame dalam R?
  • Apakah maksud dbl?

Memahami Dplyr Rename

Pakej dplyr dalam R ialah pakej tidyverse popular untuk manipulasi data yang menawarkan satu set fungsi berguna untuk mengubah dan mengatur set data. Antara fungsi ini, fungsi rename() amat berguna apabila ia datang untuk mengubah suai nama lajur dalam bingkai data.

Untuk menggunakan fungsi rename(), hanya berikan nama lajur baharu diikuti dengan yang lama, seperti ini: new_name = old_name. Sebagai contoh, mari kita pertimbangkan contoh bingkai data di mana kita ingin menukar nama lajur "lama1" kepada "baru1". Sintaks akan kelihatan seperti ini:

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

Selain itu, fungsi rename_with() membenarkan anda menamakan semula lajur menggunakan fungsi transformasi yang ditentukan. Sebagai contoh, anda boleh menggunakan fungsi topper untuk menukar semua nama lajur kepada huruf besar:

df %>% rename_with(toupper)

Jika anda perlu menamakan semula berbilang lajur sekaligus, dplyr menyediakan dua kaedah. Yang pertama melibatkan penggunaan fungsi rename(), menyediakan berbilang nama lajur baharu dan lama sebagai argumen:

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

Kaedah kedua melibatkan penggunaan fungsi rename_with(), di mana anda menentukan tatasusunan nama lajur lama dan baharu:

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

Kedua-dua kaedah, seperti yang ditunjukkan dalam contoh di atas, akan menghasilkan hasil yang sama.

Memasang dan Memuatkan Dplyr

Untuk mula menggunakan pakej dplyr untuk menamakan semula lajur, anda mesti terlebih dahulu memasang dan memuatkan pakej dalam persekitaran R anda. Memasang dplyr ialah proses mudah yang boleh dijalankan menggunakan arahan berikut:

install.packages("dplyr")

Selepas pemasangan selesai, anda boleh memuatkan pakej dplyr dalam skrip R anda menggunakan fungsi perpustakaan:

library("dplyr")

Dengan pakej dplyr dipasang dan dimuatkan, anda kini boleh menggunakan fungsi manipulasi data yang berkuasa, termasuk fungsi rename() untuk menamakan semula lajur dalam bingkai data anda.

Berikut ialah contoh menggunakan fungsi rename() dengan set data iris yang terkenal. Katakan anda ingin menamakan semula lajur "Sepal.Length" kepada "sepal_length". Anda boleh mencapai ini menggunakan kod berikut:

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

Dalam coretan kod ini, operator %>% digunakan untuk menyalurkan set data iris ke dalam fungsi rename(). Nama lajur baharu "sepal_length" diberikan kepada nama lajur lama "Sepal.Length". Bingkai data yang terhasil dengan lajur yang dinamakan semula kemudiannya diberikan kepada nama pembolehubah, iris_renamed.

Fungsi rename() juga boleh mengendalikan berbilang lajur yang menamakan semula sekaligus. Sebagai contoh, jika anda ingin menamakan semula kedua-dua lajur "Sepal.Length" dan "Sepal.Width" masing-masing kepada "sepal_length" dan "sepal_width", anda boleh menggunakan kod berikut:

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

Coretan kod ini menunjukkan betapa mudahnya untuk menamakan semula berbilang lajur dalam bingkai data menggunakan fungsi rename() dplyr.

Menggunakan Fungsi Nama Semula Dplyr

Pakej dplyr dalam R ialah alat yang berkuasa untuk manipulasi data apabila bekerja dengan bingkai data. Salah satu daripada banyak fungsi berguna yang disediakannya ialah fungsi menamakan semula, yang membolehkan anda menamakan semula lajur dengan mudah dalam bingkai data anda.

Sintaks Asas

Sintaks asas untuk menggunakan fungsi nama semula dalam dplyr adalah seperti berikut:

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

Perintah ini akan menamakan semula lajur lama yang ditentukan kepada nama lajur baharu yang dikehendaki, tanpa mengubah mana-mana lajur lain dalam bingkai data.

Menamakan semula Berbilang Lajur

Anda juga boleh menamakan semula berbilang lajur sekaligus menggunakan fungsi nama semula yang sama. Untuk melakukan ini, hanya pisahkan setiap lajur dengan menamakan semula pasangan dengan koma:

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

Menggunakan pendekatan ini, anda boleh menamakan semula seberapa banyak lajur yang diperlukan dalam satu pernyataan.

Sebagai alternatif, anda boleh menggunakan rename_with()fungsi untuk menggunakan transformasi pada nama lajur. Fungsi ini mengambil bingkai data dan fungsi yang akan digunakan pada nama lajur untuk menjana nama baharu. Sebagai contoh:

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

Ini akan menukar nama lajur yang ditentukan kepada huruf besar.

Merangkai dengan Fungsi Dplyr Lain

Salah satu kekuatan dplyr ialah keupayaannya untuk merantai pelbagai tindakan bersama-sama menggunakan %>%operator. Ini membolehkan anda melakukan satu siri manipulasi data dengan cara yang ringkas dan mudah dibaca. Apabila menggunakan fungsi nama semula, anda boleh merantainya bersama-sama dengan fungsi dplyr lain seperti filter(), mutate(), dan summarize():

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

Contoh ini menunjukkan satu siri manipulasi data yang mana penapisan data dilakukan dahulu, diikuti dengan menamakan semula lajur, mencipta lajur baharu menggunakan mutasi dan akhirnya meringkaskan data dengan fungsi pengagregatan.

Dengan memanfaatkan kuasa fungsi nama semula dplyr dan keupayaan rantaian, pengguna R boleh melakukan manipulasi data yang cekap dan boleh dibaca pada bingkai data mereka.

Kes Penggunaan Nama Semula Dplyr Biasa

Dplyr ialah pakej berkuasa dalam R yang menyediakan satu set fungsi untuk melaksanakan tugas manipulasi data. Satu tugas biasa ialah menamakan semula lajur dalam bingkai data. Dalam bahagian ini, kita akan membincangkan beberapa kes penggunaan biasa untuk ciri nama semula dalam dplyr.

1. Penamaan semula lajur ringkas:

Menamakan semula satu lajur adalah mudah menggunakan rename()fungsi tersebut. Sintaksnya ialah rename(dataframe, new_name = old_name). Berikut ialah contoh:

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

2. Menamakan semula berbilang lajur:

Anda juga boleh menamakan semula berbilang lajur dalam satu panggilan fungsi dengan menyediakan pemetaan lajur tambahan di dalam rename()fungsi. Berikut ialah contoh:

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

3. Menamakan semula lajur menggunakan fungsi rentetan:

Anda boleh menamakan semula lajur menggunakan fungsi rentetan, seperti tolower()atau toupper(), dengan menggunakan rename_with()fungsi tersebut. Menurut Stack Overflow , fungsi ini menggantikan fungsi rename_ifdan fungsi rename_atyang kini digantikan rename_all. Berikut ialah contoh:

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

4. Menamakan semula lajur berdasarkan syarat:

Dengan rename_with(), anda boleh menggunakan fungsi penamaan semula tersuai dan juga menggunakan syarat. Contoh berikut menunjukkan menamakan semula lajur berdasarkan sama ada ia mengandungi rentetan tertentu:

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

Mengendalikan Ralat dan Kes Tepi

Semasa menggunakan fungsi nama semula dplyr untuk mengubah suai nama lajur dalam bingkai data, anda mungkin menghadapi beberapa ralat atau kes tepi disebabkan nama lajur pendua, ruang dalam nama lajur atau sintaks yang salah. Bahagian ini menyediakan panduan tentang cara menangani isu ini.

Apabila berurusan dengan nama lajur pendua, dplyr tidak boleh menamakan semula lajur dengan nama output yang sama. Walau bagaimanapun, penyelesaian untuk menyahgandakan nama lajur adalah dengan menggunakan fungsi rename_alldaripada pakej dplyr bersama-sama dengan paste0:

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

Kod ini akan menambahkan nombor daripada 1 hingga 2 pada setiap nama lajur, memastikan tiada pendua. Butiran lanjut boleh didapati dalam perbincangan Stack Overflow ini .

Sekiranya terdapat ruang dalam nama lajur, anda boleh menggunakan tanda belakang untuk melampirkan nama lajur seperti ini:

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

Akhir sekali, jika anda menghadapi masalah yang berkaitan dengan dplyr tidak menerima fungsi paste0()sebagai old_name dalam rename(), penyelesaian yang mungkin adalah untuk membina nama lajur baharu di luar fungsi rename()dan kemudian menggunakannya sebagai input. Perbincangan yang berkaitan tentang isu yang sama boleh didapati dalam soalan Stack Overflow ini .

Dengan menangani ralat dan kes kelebihan ini, anda akan lebih bersedia untuk mengendalikan senario penamaan semula yang kompleks dalam dplyr.

Dalam bahagian akhir artikel kami tentang nama semula dplyr ini, kami telah membincangkan kepentingannya dalam tugas manipulasi data. Fungsi rename() membolehkan pengguna mengubah nama lajur dengan cekap, membawa kepada bingkai data yang lebih jelas dan ringkas. Ini menjadi amat berguna apabila berurusan dengan set data yang besar atau semasa langkah prapemprosesan data.

Menggunakan pakej dplyr, menamakan semula lajur dalam R adalah mudah, ia bukan sains data keras, lihat perkara di bawah:

  rename(new_column_name = old_column_name)

Sintaks mudah ini membolehkan anda menggantikan nama lajur lama dengan yang baharu, meningkatkan kebolehbacaan dan memastikan konsistensi dalam data anda. Selain itu, fungsi rename_with() boleh digunakan untuk mengubah suai nama lajur menggunakan fungsi tertentu. Ini menawarkan kawalan yang lebih besar dan penyesuaian manipulasi data anda.

Dengan memanfaatkan kuasa dplyr dan fungsi penamaan semula, anda boleh memanipulasi data anda dengan yakin dan meningkatkan keupayaan pemprosesan data secara keseluruhan. Ingat untuk sentiasa menggunakan sumber yang boleh dipercayai apabila mempelajari teknik pengaturcaraan R baharu, seperti

Dengan nama semula dplyr dalam kit alat anda, anda serba lengkap untuk menangani pelbagai cabaran manipulasi data dan terus memajukan kepakaran pengaturcaraan R anda.

Contoh Dunia Nyata Lagi -Menambah, Mengalih Keluar & Menamakan Semula Lajur

Operasi lajur membolehkan anda mengira, menambah, mengalih keluar dan menamakan semula lajur dalam R menggunakan dplyr . Buka skrip R baharu dalam RStudio. Jika anda tidak tahu caranya, klik pada pautan untuk mengetahui cara memasang RStudio dan mencipta skrip R .

Untuk demonstrasi ini, pakej dataset Lahman digunakan. Ini mengandungi rekod besbol sejak lebih seratus tahun. Ia adalah set data yang baik untuk digunakan untuk latihan. Anda boleh memuat turunnya dengan melakukan carian google pantas.

Selain itu, pakej Lahman mempunyai set data berlabel Teams , dengan huruf besar T. Amalan terbaik untuk menamakan konvensyen dalam R ialah menggunakan huruf kecil. Jadi ini perlu ditukar dahulu kepada pasukan , seperti yang dilihat dalam imej di bawah.

Fungsi Asas Untuk Operasi Lajur

1. Tambah Lajur Baharu Dalam R

Fungsi pertama ialah mutasi ( ) . Ini mencipta lajur baharu berdasarkan lajur sedia ada.

Jika anda ingin mengira lajur baharu, anda boleh menggunakan fungsi mutasi mengikut hujah:

df ialah nama tetap untuk sebarang jenis bingkai data. Jadi apabila dalam penggunaan sebenar, gantikan df dengan nama bingkai data yang anda ingin mutasi. Kemudian, anda meletakkan pembolehubah baharu yang perlu dinamakan bersama-sama dengan formula untuk mendapatkan lajur baharu.

Sebagai contoh, fungsi mutasi akan digunakan untuk mencari peratusan kemenangan bagi setiap lajur. Dalam set data Lahman, terdapat lajur Menang dan Kalah. Untuk mendapatkan peratusan, bahagikan Kemenangan dengan jumlah Menang dan Kalah. Tetapi sebelum anda boleh melakukannya, anda perlu membawa pakej dplyr.

Inilah yang berlaku jika anda menjalankan fungsi mutasi tanpa dplyr:

Anda akan mendapat ralat mengatakan "tidak dapat mencari mutasi fungsi".

Jadi, inilah cara untuk membawa masuk dplyr ke dalam R. Anda hanya perlu menjalankan perpustakaan (tidyverse) .

Anda akan melihat bahawa dplyr adalah antara banyak fungsi dalam pakej tidyverse . Pilihan lain ialah menjalankan perpustakaan (dplyr) .

Sekarang jika anda meletakkan kursor anda pada kod dengan fungsi mutasi dan menjalankannya, anda akan melihat lajur Wpct yang mengandungi peratusan kemenangan.

Dalam keadaan ini, hasil daripada fungsi mutasi hanya dijalankan; ia tidak diberikan kepada data.

Jika anda ingin memberikan hasil fungsi mutasi kepada pasukan data , anda perlu menggunakan pengendali tugasan ( <-> ). Setelah selesai, jalankan. Kemudian dalam barisan lain, lari kepala (pasukan) . Ini akan memberikan hasil kepada set data pasukan .

Jika anda ingin menyemak lajur yang tersedia dalam set data, gunakan fungsi nama ( ) . Ini akan menyenaraikan semua nama lajur dalam data.

Anda juga boleh menggunakan fungsi sedia ada sebagai sebahagian daripada fungsi mutasi . Sebagai contoh, anda boleh mengambil log set data tertentu menggunakan fungsi log ( ) .

2. Pilih Lajur Dalam R

Satu lagi fungsi dalam dplyr ialah pilih ( ) . Ia sama ada menjatuhkan atau memilih lajur yang diberikan. Algoritma asasnya ialah:

Anda perlu memasukkan nama bingkai data dan kemudian lajur yang anda mahu pilih.

Contohnya, jika anda ingin menyimpan lajur yearID, kemenangan dan kerugian dalam set data, anda hanya perlu menjalankan:

Anda kemudian akan mendapat hasil yang anda inginkan:

Walau bagaimanapun, jika anda tidak menggunakan fungsi kepala ( ) , hasilnya akan menunjukkan baris bawah lajur. Jadi, jika anda berurusan dengan berbilang baris data, anda perlu terus menatal ke atas untuk sampai ke bahagian atas lajur.

Amalan terbaik ialah menggunakan fungsi kepala bersama-sama dengan pilihan. Supaya apabila anda menjalankan kod, hasilnya akan menunjukkan baris atas lajur terlebih dahulu.

Sekarang jika anda ingin mengalih keluar lajur daripada set data, anda hanya perlu meletakkan tanda tolak ( – ) sebelum nama lajur.

Untuk menyemak sama ada lajur memang telah dialih keluar, anda boleh membandingkan set data baharu daripada yang lama. Begini cara melakukannya:

Pertama, tetapkan kod R dengan fungsi pilih kepada objek. Dalam contoh ini, ia telah diberikan kepada teams_short . Untuk mengira bilangan lajur, gunakan fungsi ncol ( ) . Jalankan fungsi ncol untuk kedua-dua teams_short dan teams .

Anda kemudian akan melihat bahawa satu lajur telah dialih keluar daripada set data.

3. Namakan Semula Lajur Dalam R

Fungsi lajur terakhir dalam dplyr ialah menamakan semula ( ) . Dan seperti namanya, ia boleh menamakan semula lajur yang dipilih dalam R.

Ini adalah algoritma asasnya:

Dan anda akan perasan bahawa ia agak berlawanan dengan intuisi; nama baru didahulukan manakala nama lama didahulukan selepas itu. Jadi pastikan anda tidak mencampur adukkan perkara tersebut.

Sebagai contoh, lajur yearID dan divID semasa akan dinamakan semula kepada year_id dan division_id , masing-masing. Sebelum menjalankan kod, pastikan anda menetapkan ini kepada objek baharu supaya tidak mengganggu set data asal.

Untuk menyemak sama ada lajur yang dipilih ini telah berjaya ditukar nama, gunakan fungsi nama ( ) .

Anda akan melihat bahawa lajur sememangnya telah dinamakan semula.

Pernah terfikir betapa hebatnya R apabila digunakan dengan LuckyTemplates, lihat teknik hebat ini, ia akan menjimatkan banyak masa.

Kata Akhir

Tutorial ini telah membincangkan tiga fungsi dplyr asas yang anda boleh gunakan untuk melaksanakan operasi lajur. Khususnya, anda mempelajari cara menambah, mengalih keluar dan menamakan semula lajur dalam R.

Masih terdapat fungsi lain yang anda masih belum terokai. Tetapi penting untuk mengetahui dan membiasakan diri dengan mutasi ( ) , pilih ( ) dan namakan semula ( ) kerana ia adalah yang paling biasa.

Teknik penyuntingan lajur ini juga boleh dilakukan dalam Power Query. Tetapi sangat bagus untuk mempunyai pengetahuan tentang cara melakukan ini dalam dplyr juga. Ini pasti akan membantu anda apabila anda beralih kepada menganalisis set data statistik.

Soalan Lazim

Apakah perbezaan antara R dan Python?

Sebagai permulaan, kedua-dua R dan Python adalah bahasa pengaturcaraan, tetapi python lebih kepada bahasa penggunaan umum dan R ialah bahasa pengaturcaraan statistik. Python ialah bahasa yang lebih biasa digunakan, difahami dan serba boleh.

Apakah str?

str hanya memaparkan struktur r objek

Apakah Petal.Length dalam R?

Petal.length ialah format yang digunakan di seluruh R untuk menceritakan perhubungan yang sedang kami uji.

Apakah DataFrame dalam R?

Bingkai R Data ialah struktur data jadual yang biasa digunakan untuk menyimpan nilai sebarang jenis data.

Apakah maksud dbl?

Dbl bermaksud "kelas berganda" ia adalah jenis data yang digunakan untuk menyimpan nilai berangka yang mengandungi titik perpuluhan.