Homograf di DataFrames.jl | juliablogger.com – Beragampengetahuan

Oleh: Blog Bogumił Kamiński

Repost dari:

Minggu lalu saya memposting tentang grafik, jadi saya pikir saya akan memposting tentang grafik hari ini.

Dari pelajaran bahasa Inggris Anda, Anda dapat mengingat bahwa homonim adalah kata-kata yang digunakan bersama
bentuk tulisan yang sama tetapi memiliki arti yang berbeda.

Dimulai dengan rilis Julia 1.9, kami memiliki homonim di DataFrames.jl. Ini
stack berfungsi dan saya akan membahasnya hari ini.

Posting ditulis di bawah Julia 1.9.1 dan DataFrames.jl 1.5.0.

Julia mendukung banyak kiriman. Ini berarti Anda dapat menentukan metode khusus
untuk fungsi yang sama tergantung pada jenis argumennya.

Misalnya jika Anda menulis 1 + 2 Dan 1.0 + 2.0 Berbagai metode internal
+ dipanggil, satu bekerja dengan bilangan bulat dan yang lainnya bekerja dengan pelampung.

Namun, ada satu aturan penting yang perlu diikuti. Jika Anda menambahkan metode
untuk beberapa fungsi, mereka harus melakukan operasi serupa secara konseptual. Misalnya,
1 + 2 pembuatan 3 Dan 1.0 + 2.0 pembuatan 3.0. Dalam kedua kasus, penambahan dibuat.

Alasan aturan ini sebaliknya ketika Anda melihat kode seperti f(x) Anda tidak akan
tahu apa fungsinya? f lakukan sampai Anda tahu jenisnya x.

Sayangnya, terkadang situasi seperti itu terjadi. Mari saya ceritakan sebuah cerita tentang stack
fungsi. Itu telah didefinisikan di DataFrames.jl selama bertahun-tahun dan digunakan untuk tampil
mengonversi bingkai data dari lebar ke panjang. Baru-baru ini, pengelola Julia memutuskan itu
masuk akal untuk menambahkan stack berfungsi untuk Base modul dan membuatnya menggabungkan
kumpulan array menjadi array yang lebih besar.

Dalam situasi seperti itu, sebagai pengelola DataFrames.jl, kami memiliki dua opsi:

1. memegang Base.stack Dan DataFrames.stack fungsi terpisah;
2. Mengerjakan stack dari DataFrames.jl tambahkan metode di Base.stack.

Secara umum, opsi pertama lebih disukai. Base.stack Dan DataFrames.stack
melakukan hal yang berbeda sehingga mereka harus fungsi yang terpisah. Namun, ada
masalah dengan pendekatan ini. Semua kode lama digunakan stack dari DataFrames.jl
akan berhenti bekerja dan pengguna harus menulis DataFrames.stack alih-alih.
Ini bukan yang kami inginkan, jadi kami memutuskan untuk memilih opsi 2, yaitu
menambahkan metode untuk Base.stack akan memproses data frame. Alasan mengapa kita
Keputusan untuk ini sangat rendah risiko kebingungan karena stack dari
DataFrames.jl selalu membutuhkan a AbstractDataFrame sebagai argumen pertamanya.
Anda bisa melihatnya di sini:

julia> using DataFrames

julia> methods(stack)
# 6 methods for generic function "stack" from Base:
 [1] stack(df::AbstractDataFrame)
     @ DataFrames ~\.julia\packages\DataFrames\LteEl\src\abstractdataframe\reshape.jl:136
 [2] stack(df::AbstractDataFrame, measure_vars)
     @ DataFrames ~\.julia\packages\DataFrames\LteEl\src\abstractdataframe\reshape.jl:136
 [3] stack(df::AbstractDataFrame, measure_vars, id_vars; variable_name, value_name, view, variable_eltype)
     @ DataFrames ~\.julia\packages\DataFrames\LteEl\src\abstractdataframe\reshape.jl:136
 [4] stack(iter; dims)
     @ abstractarray.jl:2743
 [5] stack(f, iter; dims)
     @ abstractarray.jl:2772
 [6] stack(f, xs, yzs...; dims)
     @ abstractarray.jl:2773

Pada saat yang sama standar Base.stack tidak bekerja dengan bingkai data sama sekali.

Oke, cukup teori. Mari kita lihat stack dari Base dan dari DataFrames.jl
beraksi.

Di sini saya akan fokus pada situasi yang paling sederhana (dan paling sering diperlukan).
Katakanlah Anda memiliki vektor dengan panjang vektor yang sama:

julia> x = [1:2, 3:4, 5:6]
3-element Vector{UnitRange{Int64}}:
 1:2
 3:4
 5:6

Kita mungkin ingin mengubahnya menjadi sebuah matriks. Ada dua cara yang mungkin ingin Anda lakukan.
Yang pertama adalah menempatkan vektor ini sebagai baris dalam matriks yang dihasilkan, seperti ini:

julia> stack(x)
2×3 Matrix{Int64}:
 1  3  5
 2  4  6

Yang kedua adalah menempatkannya sebagai kolom (ini sering diperlukan, dan di masa lalu saya selalu
digunakan permutedims untuk mendapatkan ini, agak rumit):

julia> stack(x, dims=1)
3×2 Matrix{Int64}:
 1  2
 3  4
 5  6

Pola ketiga yang paling umum digunakan adalah saat Anda ingin menerapkan fungsi ke vektor
nilai dan fungsi ini mengembalikan vektor lain atau misalnya tuple. Mari kita lihat
pada contoh:

julia> using Statistics

julia> f(x) = [sum(x), mean(x)]
f (generic function with 1 method)

julia> f.(x)
3-element Vector{Vector{Float64}}:
 [3.0, 1.5]
 [7.0, 3.5]
 [11.0, 5.5]

Ini adalah cara penyiaran tradisional untuk menerapkan fungsi ke vektor tersebut.
Namun, Anda biasanya menginginkan hasilnya dalam bentuk matriks planar. Sekarang Anda dapat melakukan:

julia> stack(f.(x))
2×3 Matrix{Float64}:
 3.0  7.0  11.0
 1.5  3.5   5.5

ini dapat dibuat lebih sederhana dengan menulis:

julia> stack(f, x)
2×3 Matrix{Float64}:
 3.0  7.0  11.0
 1.5  3.5   5.5

Ringkasan, Base.stack adalah gadget kecil super bagus yang sangat berguna
jika Anda bekerja dengan array.

Di DataFrames.jl, stack Konversi data dari format lebar ke panjang.
Misalkan Anda memiliki kerangka data input berikut:

julia> df = DataFrame(year=[2020, 2021], Spring=1:2, Summer=3:4, Autumn=5:6, Winter=7:8)
2×5 DataFrame
 Row │ year   Spring  Summer  Autumn  Winter
     │ Int64  Int64   Int64   Int64   Int64
─────┼───────────────────────────────────────
   1 │  2020       1       3       5       7
   2 │  2021       2       4       6       8

Ini dalam format lebar. Untuk setiap tahun, Anda memiliki empat kolom untuk setiap musim yang berisi sejumlah nilai.
Misalkan kita menginginkan kerangka data yang sempit dengan kombinasi musiman tahun ini dan kolom dengan nilai.
Dengan DataFrames.stack cukup dengan mengirimkan kerangka data dan menentukan kolom mana yang berisi nilai sudah cukup:

julia> stack(df, Not(:year))
8×3 DataFrame
 Row │ year   variable  value
     │ Int64  String    Int64
─────┼────────────────────────
   1 │  2020  Spring        1
   2 │  2021  Spring        2
   3 │  2020  Summer        3
   4 │  2021  Summer        4
   5 │  2020  Autumn        5
   6 │  2021  Autumn        6
   7 │  2020  Winter        7
   8 │  2021  Winter        8

Atau, jika Anda ingin lebih mewah, Anda dapat mengubah nama kolom yang dihasilkan:

julia> stack(df, Not(:year), variable_name="season", value_name="number")
8×3 DataFrame
 Row │ year   season  number
     │ Int64  String  Int64
─────┼───────────────────────
   1 │  2020  Spring       1
   2 │  2021  Spring       2
   3 │  2020  Summer       3
   4 │  2021  Summer       4
   5 │  2020  Autumn       5
   6 │  2021  Autumn       6
   7 │  2020  Winter       7
   8 │  2021  Winter       8

Dalam posting ini saya memberikan contoh dasar Base.stack Dan DataFrames.stack menggunakan.
Saya sarankan melihat dokumentasi mereka untuk informasi yang lebih lengkap.
Namun, masalahnya adalah kedua fungsi tersebut cukup berguna dalam penyortiran data sehari-hari
berguna untuk mengenal mereka.

Selain itu, saya ingin menyoroti beberapa pertimbangan umum tentang desain kemasan di Julia
dan tantangan yang dihadapi pengelola. Dalam contoh spesifik dari stack kami memutuskan untuk istirahat
itu semua metode fungsi harus melakukan hal yang sama aturan mendukung kenyamanan pengguna dan membuat
pastikan kami menjaga kode DataFrames.jl lama berfungsi.

Terkait