Yang Baru di DataFrames.jl 1.5 – Beragampengetahuan
Oleh: Blog Bogumił Kamiński
Repost dari:
Tujuan artikel ini sederhana: saya ingin berdiskusi
fungsi baru terpenting yang disediakan DataFrames.jl 1.5.
Perubahan yang saya sebutkan hari ini adalah:
- lebih bertenaga
Colspemilih; - mengatur urutan kelompok
groupby; - atur urutan baris dalam gabungan;
- opsi baru untuk menangani baris duplikat di
unique; - Mengerjakan
flattenfungsi pengenalan skalar.
Post telah diuji di Julia 1.9.0-rc1 dan DataFrames.jl 1.5.0.
Itu Cols pemilih telah menerima dua fitur baru:
- kemampuan untuk menggabungkan pemilih fungsi kondisional dengan pemilih lainnya;
- baru
operatorargumen kata kunci.
Izinkan saya menjelaskan keduanya dengan contoh. Mulailah dengan menggunakan pemilih fungsi bersyarat.
Inilah perilaku lama yang didukung:
julia> using DataFrames
julia> df = DataFrame(x1=1, x2=2, y1=3, y2=4)
1×4 DataFrame
Row │ x1 x2 y1 y2
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
1 │ 1 2 3 4
julia> select(df, Cols(startswith("x")))
1×2 DataFrame
Row │ x1 x2
│ Int64 Int64
─────┼──────────────
1 │ 1 2
Itu startswith("x") Fungsi bersyarat diperlukan sebagai satu-satunya argumen untuk Cols.
Sekarang Anda memiliki fleksibilitas untuk menggabungkannya dengan penyeleksi lain:
julia> select(df, Cols(startswith("x"), r"2"))
1×3 DataFrame
Row │ x1 x2 y2
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 4
julia> select(df, Cols(startswith("x"), endswith("2")))
1×3 DataFrame
Row │ x1 x2 y2
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 4
julia> select(df, Cols(startswith("x"), :y2))
1×3 DataFrame
Row │ x1 x2 y2
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 4
Perubahan kedua adalah operator argumen kata kunci. secara default Colsketika melewati beberapa argumen
kehilangan persatuan mereka:
julia> select(df, Cols(startswith("x"), endswith("2")))
1×3 DataFrame
Row │ x1 x2 y2
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 4
Namun, Anda dapat melewati operator lain yang menentukan bagaimana kolom dipilih satu per satu
argumen harus digabungkan. Misalnya, Anda dapat mengambil persimpangan mereka:
julia> select(df, Cols(startswith("x"), endswith("2"), operator=intersect))
1×1 DataFrame
Row │ x2
│ Int64
─────┼───────
1 │ 2
atau atur perbedaannya:
julia> select(df, Cols(startswith("x"), endswith("2"), operator=setdiff))
1×1 DataFrame
Row │ x1
│ Int64
─────┼───────
1 │ 1
sebelum grouby saat kamu lewat sort=true Urutkan grup dalam urutan menaik.
Ini contohnya:
julia> df = DataFrame(id=["a", "c", "b"], row=1:3)
3×2 DataFrame
Row │ id row
│ String Int64
─────┼───────────────
1 │ a 1
2 │ c 2
3 │ b 3
julia> show(groupby(df, :id, sort=true), allgroups=true)
GroupedDataFrame with 3 groups based on key: id
Group 1 (1 row): id = "a"
Row │ id row
│ String Int64
─────┼───────────────
1 │ a 1
Group 2 (1 row): id = "b"
Row │ id row
│ String Int64
─────┼───────────────
1 │ b 3
Group 3 (1 row): id = "c"
Row │ id row
│ String Int64
─────┼───────────────
1 │ c 2
Sekarang Anda dapat menggunakan pass in sort kumpulan argumen kata kunci apa pun sort diterima sebagai tuple bernama.
Misalnya, jika Anda ingin grup diurutkan dalam urutan terbalik, lakukan:
julia> show(groupby(df, :id, sort=(rev=true,)), allgroups=true)
GroupedDataFrame with 3 groups based on key: id
Group 1 (1 row): id = "c"
Row │ id row
│ String Int64
─────┼───────────────
1 │ c 2
Group 2 (1 row): id = "b"
Row │ id row
│ String Int64
─────┼───────────────
1 │ b 3
Group 3 (1 row): id = "a"
Row │ id row
│ String Int64
─────┼───────────────
1 │ a 1
Secara default, operasi gabungan tidak menjamin urutan baris dalam keluaran
(sama seperti basis data):
julia> df_left = DataFrame(id=[1, 2, 4, 5], left=1:4)
4×2 DataFrame
Row │ id left
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 4 3
4 │ 5 4
julia> df_right = DataFrame(id=[2, 1, 3, 6, 7], right=1:5)
5×2 DataFrame
Row │ id right
│ Int64 Int64
─────┼──────────────
1 │ 2 1
2 │ 1 2
3 │ 3 3
4 │ 6 4
5 │ 7 5
julia> outerjoin(df_left, df_right, on=:id)
7×3 DataFrame
Row │ id left right
│ Int64 Int64? Int64?
─────┼─────────────────────────
1 │ 2 2 1
2 │ 1 1 2
3 │ 4 3 missing
4 │ 5 4 missing
5 │ 3 missing 3
6 │ 6 missing 4
7 │ 7 missing 5
Namun, pengguna sering menginginkan hasil mengikuti urutan baris dari salah satu tabel sumber.
Ini sekarang dapat dicapai dengan menggunakan order argumen kata kunci.
Jika Anda ingin hasilnya memiliki baris dalam urutan di sebelah kiri tabel (lalu tambahkan
baris yang tidak cocok dari tabel kanan di akhir, jika perlu) lakukan:
julia> outerjoin(df_left, df_right, on=:id, order=:left)
7×3 DataFrame
Row │ id left right
│ Int64 Int64? Int64?
─────┼─────────────────────────
1 │ 1 1 2
2 │ 2 2 1
3 │ 4 3 missing
4 │ 5 4 missing
5 │ 3 missing 3
6 │ 6 missing 4
7 │ 7 missing 5
Opsi yang sama tersedia jika Anda ingin mempertahankan urutan baris tabel yang benar:
julia> outerjoin(df_left, df_right, on=:id, order=:right)
7×3 DataFrame
Row │ id left right
│ Int64 Int64? Int64?
─────┼─────────────────────────
1 │ 2 2 1
2 │ 1 1 2
3 │ 3 missing 3
4 │ 6 missing 4
5 │ 7 missing 5
6 │ 4 3 missing
7 │ 5 4 missing
secara default unique (dan fungsi terkait unique! Dan nonunique) disimpan
baris duplikat pertama jika ada duplikat. Ini contohnya:
julia> df = DataFrame(a=[1, 2, 3, 1, 2, 4], id=1:6)
6×2 DataFrame
Row │ a id
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
4 │ 1 4
5 │ 2 5
6 │ 4 6
julia> unique(df, :a)
4×2 DataFrame
Row │ a id
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
4 │ 4 6
Namun, terkadang pengguna menginginkan perilaku yang berbeda. Dua lagi saat ini didukung.
Jika Anda ingin menyimpan baris duplikat terakhir sebagai gantinya keep=:last:
julia> unique(df, :a, keep=:last)
4×2 DataFrame
Row │ a id
│ Int64 Int64
─────┼──────────────
1 │ 3 3
2 │ 1 4
3 │ 2 5
4 │ 4 6
Sementara, jika Anda tidak ingin menyimpan baris duplikat, lewati keep=:noduplicates:
julia> unique(df, :a, keep=:noduplicates)
2×2 DataFrame
Row │ a id
│ Int64 Int64
─────┼──────────────
1 │ 3 3
2 │ 4 6
Itu flatten fungsi ini sering berguna ketika seseorang ingin menghapus kolom
tahan koleksi (misalnya vektor). Ini contohnya:
julia> df = DataFrame(id=1:3, col=[["a", "b"], ["c", "d"], ["e", "f"]])
3×2 DataFrame
Row │ id col
│ Int64 Array…
─────┼───────────────────
1 │ 1 ["a", "b"]
2 │ 2 ["c", "d"]
3 │ 3 ["e", "f"]
julia> flatten(df, :col)
6×2 DataFrame
Row │ id col
│ Int64 String
─────┼───────────────
1 │ 1 a
2 │ 1 b
3 │ 2 c
4 │ 2 d
5 │ 3 e
6 │ 3 f
Namun, terkadang kolom seperti itu mungkin berisi nilai yang tidak ditetapkan dan kami tidak ingin mencoba memperluasnya.
Kasus yang paling umum adalah missing:
julia> df = DataFrame(id=1:3, col=[["a", "b"], missing, ["e", "f"]])
3×2 DataFrame
Row │ id col
│ Int64 Array…?
─────┼───────────────────
1 │ 1 ["a", "b"]
2 │ 2 missing
3 │ 3 ["e", "f"]
julia> flatten(df, :col)
ERROR: MethodError: no method matching length(::Missing)
Seperti yang Anda lihat, operasinya gagal missing bukan satu set panjang (karenanya tidak dapat diperluas).
Anda sekarang dapat menentukan itu missing adalah kuantitas yang, ketika ditemui, tidak boleh diperluas.
Anda melakukannya dengan melewati scalar=Missing argumen kata kunci:
julia> flatten(df, :col, scalar=Missing)
5×2 DataFrame
Row │ id col
│ Int64 String?
─────┼────────────────
1 │ 1 a
2 │ 1 b
3 │ 2 missing
4 │ 3 e
5 │ 3 f
Saya harap Anda menemukan tambahan baru yang diperkenalkan di DataFrames.jl berguna untuk tugas penyortiran data Anda!
Terkait
Software Terbaru Saat Ini
Aplikasi yang sedang trend saat ini
object oriented programming, programming language, programming adalah, web programming, belajar programming, tournament software, software, software adalah, contoh software, apa itu software, pengertian software, aplikasi, aplikasi penghasil uang, aplikasi bokep, aplikasi video, programming
#Yang #Baru #DataFrames.jl
