PricingLoginStart free
R Academy · Pelajaran

Mengisih Bingkai Data mengikut Lajur

Isih keseluruhan bingkai data menggunakan order() dan arrange() dplyr.

Pelajaran 4 daripada 413 langkah

Mengisih Bingkai Data mengikut Lajur ialah pelajaran R Academy percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran R Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus R Academy merangkumi sejumlah 4 pelajaran.

Mengisih Bingkai Data Mengikut Satu Lajur

Cara piawai R asas untuk mengisih bingkai data ialah menggunakan order() pada lajur yang dikehendaki dan menggunakan indeks yang terhasil untuk menyusun semula baris. Koma selepas indeks memilih semua lajur.

df <- data.frame(
  name = c('Charlie', 'Alice', 'Bob', 'Diana'),
  age  = c(35, 28, 42, 31),
  salary = c(55000, 48000, 72000, 61000)
)
df[order(df$age), ]

Mengisih Menurun dengan Penafian

Untuk lajur berangka, nafikan lajur di dalam order() bagi membalikkan arah isihan. Tanda tolak membalikkan semua nilai supaya nilai yang asalnya maksimum menjadi minimum untuk tujuan pengisihan.

df <- data.frame(
  name   = c('Charlie', 'Alice', 'Bob', 'Diana'),
  salary = c(55000, 48000, 72000, 61000)
)
# Highest salary first
df[order(-df$salary), ]

Isihan Berbilang Lajur

Hantar berbilang lajur kepada order() untuk mengisih mengikut kriteria utama, kemudian kriteria sekunder. Argumen kedua memecahkan ikatan dalam argumen pertama. Ini menyerupai ORDER BY col1, col2 dalam SQL.

df <- data.frame(
  dept   = c('Eng', 'HR', 'Eng', 'HR', 'Eng'),
  name   = c('Zara', 'Bob', 'Alice', 'Eve', 'Mike'),
  salary = c(90000, 55000, 85000, 58000, 78000)
)
# Sort by dept, then by salary descending within dept
df[order(df$dept, -df$salary), ]

Mengisih Lajur Aksara

Mengisih mengikut lajur aksara berfungsi dengan cara yang sama — order() mengendalikan pengisihan leksikografi. Untuk tertib abjad terbalik, gunakan decreasing = TRUE dan bukannya penafian (penafian hanya berfungsi untuk nilai berangka).

df <- data.frame(
  city    = c('Paris', 'Athens', 'Berlin', 'London'),
  pop_mil = c(2.1, 0.6, 3.6, 9.0)
)
# Alphabetical by city
df[order(df$city), ]
# Reverse alphabetical
df[order(df$city, decreasing = TRUE), ]

Menetapkan Semula Nombor Baris Selepas Isihan

Selepas mengisih, nama baris mencerminkan kedudukan asal (contohnya, 3, 1, 4, 2). Untuk menetapkannya semula kepada integer berjujukan yang bermula daripada 1, tetapkan row.names(df) <- NULL atau bungkus hasilnya dalam data.frame().

df <- data.frame(
  x = c(30, 10, 20),
  y = c('c', 'a', 'b')
)
sorted <- df[order(df$x), ]
cat('Before reset:\n'); print(sorted)
row.names(sorted) <- NULL
cat('After reset:\n');  print(sorted)

Mengisih dengan Nilai NA

Apabila lajur isihan mengandungi NA, order() meletakkannya di hujung secara lalai. Gunakan na.last = FALSE untuk memindahkan baris NA ke bahagian atas, atau tapis baris tersebut terlebih dahulu.

df <- data.frame(
  name  = c('Alice', 'Bob', 'Carol', 'Dave'),
  score = c(85, NA, 92, NA)
)
cat('NAs last (default):\n')
print(df[order(df$score), ])
cat('NAs first:\n')
print(df[order(df$score, na.last = FALSE), ])

dplyr::arrange() sebagai Alternatif Moden

Pakej dplyr menyediakan arrange() sebagai alternatif yang lebih kemas. Walaupun dplyr bukan R asas, mengetahui sintaks ini membantu anda membaca kod R moden. Nota: isRunnable hanya bernilai true di sini untuk menunjukkan sintaks — dplyr mesti dipasang untuk menjalankannya.

# dplyr::arrange() syntax (requires dplyr installed)
# library(dplyr)
# df |> arrange(salary)           # ascending
# df |> arrange(desc(salary))     # descending
# df |> arrange(dept, desc(salary)) # multi-column

# Equivalent base R:
df <- data.frame(dept=c('A','B','A'), salary=c(50,70,60))
df[order(df$dept, -df$salary), ]

Mengisih Faktor Mengikut Tertib Tahap

Lajur faktor diisih mengikut tertib tahap, bukannya mengikut abjad. Ini membolehkan anda menentukan tertib isihan tersuai dengan menetapkan tahap faktor secara eksplisit sebelum mengisih.

df <- data.frame(
  priority = factor(c('Low', 'High', 'Medium', 'High', 'Low'),
                    levels = c('Low', 'Medium', 'High')),
  task = c('T1', 'T2', 'T3', 'T4', 'T5')
)
# Sorts by factor level (Low < Medium < High)
df[order(df$priority), ]

Mengisih dan Memilih Baris Teratas

Corak yang lazim ialah mengisih bingkai data dan kemudian mengambil N baris teratas dengan head(), atau N baris terbawah dengan tail(). Ini ialah padanan R asas bagi ORDER BY ... LIMIT N dalam SQL.

df <- data.frame(
  product = c('A', 'B', 'C', 'D', 'E'),
  revenue = c(1200, 4500, 890, 3100, 2750)
)
# Top 3 by revenue
top3 <- head(df[order(-df$revenue), ], 3)
row.names(top3) <- NULL
print(top3)

Isihan di Tempat berbanding Isihan yang Diumpukkan

Pengisihan tidak mengubah suai bingkai data asal — sebaliknya, ia mengembalikan bingkai data baharu. Sentiasa umpukkan hasilnya kepada pemboleh ubah (sama ada pemboleh ubah baharu atau tulis ganti yang asal). Menulis ganti yang asal adalah wajar apabila anda tidak lagi memerlukan versi yang belum diisih.

df <- data.frame(
  x = c(3, 1, 4, 1, 5, 9),
  y = c('c', 'a', 'd', 'b', 'e', 'i')
)
# Safe: assign to new variable
df_sorted <- df[order(df$x), ]
# Or overwrite original:
df <- df[order(df$x), ]
row.names(df) <- NULL
print(df)

Aliran Kerja Pengisihan Lengkap

Berikut ialah aliran kerja pengisihan bingkai data yang lengkap dan realistik: isih pekerja mengikut nama jabatan dalam tertib menaik, kemudian mengikut gaji dalam tertib menurun, tetapkan semula indeks baris, dan paparkan hasilnya dengan kemas.

employees <- data.frame(
  name   = c('Alice', 'Bob', 'Carol', 'Dave', 'Eve'),
  dept   = c('IT', 'HR', 'IT', 'HR', 'IT'),
  salary = c(85000, 58000, 92000, 63000, 78000)
)
result <- employees[order(employees$dept, -employees$salary), ]
row.names(result) <- NULL
print(result)

Semakan Pantas

Bagaimanakah anda mengisih bingkai data df mengikut lajur berangka df$salary dalam tertib menurun menggunakan R asas?

Jawab dalam pelajaran interaktif

Mengisih Bingkai Data: Kesimpulan Utama

Kesimpulan utama untuk mengisih bingkai data:

  • Idiom R asas: df[order(df$col), ]
  • Berangka menurun: nafikan dengan - di dalam order(-df$col)
  • Aksara menurun: gunakan argumen decreasing = TRUE
  • Berbilang lajur: order(df$a, df$b) — isihan sekunder memecahkan ikatan
  • Faktor diisih mengikut tertib tahap yang ditakrifkan, bukannya mengikut abjad
  • Tetapkan semula nama baris dengan row.names(df) <- NULL selepas mengisih
  • Alternatif moden: dplyr::arrange() dengan desc() untuk tertib menurun
df <- data.frame(
  name = c('Zara', 'Ana', 'Bob', 'Ana'),
  score = c(90, 85, 92, 88)
)
# Sort by name asc, score desc
result <- df[order(df$name, -df$score), ]
row.names(result) <- NULL
print(result)
Percuma untuk bermula

Pelajari R dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
43
Pelajaran
159
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengisih Bingkai Data mengikut Lajur” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran R Academy, termasuk “Mengisih Bingkai Data mengikut Lajur”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus R Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mengisih Bingkai Data mengikut Lajur”?

Isih keseluruhan bingkai data menggunakan order() dan arrange() dplyr. Anda berlatih R Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan R Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran R Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Mengisih Bingkai Data mengikut Lajur” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Mengisih Vektor dengan sort()
  2. order() untuk Susunan Fleksibel
  3. Menentukan Kedudukan Nilai dengan rank()
  4. Mengisih Bingkai Data mengikut Lajur
← Kembali ke R Academy