Tes kontainer Grand Julia. Bisakah Anda mendapatkan skor sempurna? – Beragampengetahuan

Oleh: Blog Bogumił Kamiński

Repost dari:

Wadah adalah objek yang mengelompokkan beberapa nilai menjadi satu.
Di Julia, contoh wadah adalah vektor atau kamus.

Untuk memastikan kemudahan bekerja dengan kontainer, Julia memperkenalkan empat
menampilkan:

• pengulangan;
• pengindeksan;
• Himpunan;
• penyiaran.

Mereka dijelaskan di bagian Layout dari Julia Notebook.
Namun, deskripsi ini agak teknis dan terutama ditujukan untuk pengembang
membuat jenis wadah baru. Jadi saya berpikir untuk menulis posting
bertujuan untuk menjelaskan antarmuka ini dengan contoh dari sudut pandang pengguna.

Materi yang disajikan di sini disusun menjadi dua bagian.

Bagian satu adalah dasar-dasar yang harus Anda miliki. Saya coba kumpulkan dalam artikel ini
informasi yang paling relevan.

Bagian kedua disusun sebagai tes untuk menguji pemahaman Anda tentang apa yang telah dibahas
menampilkan. Ada sepuluh pertanyaan dalam ujian (ditambah satu pertanyaan bonus).
Apakah Anda tahu jawaban untuk mereka semua?

Post diuji di Julia 1.8.5 dan DataFrames.jl 1.4.4.

ulang

Iterasi adalah antarmuka yang paling tidak menuntut. Ini memastikan bahwa Anda bisa mendapatkan elemen
berurutan dari wadah.

Sebagian besar wadah dapat diubah, termasuk: larik, kamus, set,
I/O buffer dan string.

Jika beberapa wadah mendukung iterasi maka itu dapat digunakan for lingkaran,
pemahaman dan fungsi lebih tinggi lainnya yang hanya mengandalkan pengulangan nilai
sama foreach.

Berikut adalah contoh dasar pengulangan tuple:

julia> t = (1, 2, 3)
(1, 2, 3)

julia> for v in t
           println(v)
       end
1
2
3

julia> [v for v in t]
3-element Vector{Int64}:
 1
 2
 3

Fitur penting dari antarmuka iteratif adalah ia juga berfungsi untuk
koleksi berubah saat mengulanginya. Contoh dasarnya adalah membaca
data dari IOBuffer:

julia> buf = IOBuffer(join('a':'d', '\n'))
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=7, maxsize=Inf, ptr=1, mark=-1)

julia> foreach(println, eachline(buf))
a
b
c
d

julia> foreach(println, eachline(buf))

julia>

Perhatikan bahwa dengan mengulangi buf baris demi baris, kami mengubahnya. Oleh karena itu,
begitu kita mengulanginya, kita tidak mendapatkan hasil apa pun.

Saat Anda menggunakan antarmuka berulang, penting untuk selalu memiliki pola pikir itu
Anda dijamin dapat membaca satu elemen dari koleksi satu kali.

pengindeksan

Pengindeksan memungkinkan Anda untuk mengakses elemen dari wadah dengan pengenalnya
biasa disebut dengan indeks. Ini, secara default, berarti Anda dapat membaca yang sama
elemen beberapa kali tanpa masalah (berlawanan dengan iterasi).

Fitur utama dari antarmuka ini adalah mendukung antarmuka yang nyaman x[i] sintaksis
untuk mendapatkan elemen dari wadah. Sekali lagi, mari kita berikan contoh sederhana:

julia> d = Dict(v => '0'+v for v in s)
Dict{Int64, Char} with 4 entries:
  4 => '4'
  2 => '2'
  3 => '3'
  1 => '1'

julia> d[3]
'3': ASCII/Unicode U+0033 (category Nd: Number, decimal digit)

Dalam praktiknya di Julia, antarmuka ini diimplementasikan dalam beberapa cara.
Yang paling penting dari mereka adalah sebagai berikut.

Pertama, pengindeksan hanya dapat mendukung membaca atau membaca dan menulis data
ke wadah. Contoh entri dari a Vector dapat bermutasi, tapi jangkauan
hanya dibaca:

julia> v1 = [1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> v1[2] = 12
12

julia> v2 = 1:3
1:3

julia> v2[2] = 12
ERROR: CanonicalIndexError: setindex! not defined for UnitRange{Int64}

Pelajaran yang perlu diingat: jangan berasumsi bahwa objek yang dapat diindeks selalu dapat ditulis.

Rasa kedua adalah antarmuka pengindeksan reguler yang mengasumsikannya
dapat memesan indeks yang valid dan menentukan indeks pertama dan terakhir. Ini bisa jadi
Penambangan nyaman menggunakan begin dan end kata kunci saat mengindeks:

julia> v1[begin]
1

julia> v1[end]
3

Namun, dukungan ini tidak dijamin oleh semua objek yang mendukung pengindeksan.
Contoh dasarnya adalah kamus:

julia> d[end]
ERROR: MethodError: no method matching lastindex(::Dict{Int64, Char})

Jadi hal kedua yang perlu diingat adalah Anda tidak dapat menganggap semua akun dapat diindeks
Objek akan membantu lulus begin dan end kata kunci saat pengindeksan.

Himpunan

Array memindahkan sintaks pengindeksan lebih jauh dengan mengizinkan beberapa nilai untuk diteruskan
x[i, j, ...] sintaks dan juga memperkenalkan konsep CartesianIndex
pengindeksan. Biasanya, tipe yang mendukung keikutsertaan antarmuka array adalah subtipe dari
AbstractArray. Fitur penting dari array adalah bahwa mereka mendefinisikan
ukuran dan kegunaan size fungsi orang bisa mendapatkannya. Penggunaan serupa
axes fungsi satu bisa mendapatkan indeks yang valid sepanjang dimensi.

Ini contohnya:

julia> mat = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> size(mat)
(2, 3)

julia> axes(mat)
(Base.OneTo(2), Base.OneTo(3))

julia> mat[1, 2]
2

julia> mat[CartesianIndex(1, 2)]
2

Fitur penting yang sering dibutuhkan adalah iterasi pada semua elemen .
sebuah array. Anda bisa mendapatkan iterator dari indeks tersebut menggunakan eachindex
Konstan.

Penting untuk diingat bahwa fungsi ini hanya dijamin untuk kembali
nilai adalah indeks yang valid untuk sebuah array. Jenis indikator ini ditentukan
berdasarkan penilaian efisiensi pengindeksan. Ini contohnya:

julia> for idx in eachindex(mat)
           print(idx, " ")
       end
1 2 3 4 5 6
julia> for idx in eachindex(@view mat[1:2, 2:3])
           print(idx, " ")
       end
CartesianIndex(1, 1) CartesianIndex(2, 1) CartesianIndex(1, 2) CartesianIndex(2, 2)

Fitur penting di sini adalah meskipun mat adalah matriks, dan mendukung
meneruskan metrik ke semua dimensi saat mengindeks seperti mat[1, 2] atau
mat[CartesianIndex(1, 2)] kita melihat itu eachindex(mat) mengembalikan indeks bilangan bulat
(karena mereka lebih cepat). Indikator semacam itu disebut indeks linier dan
didukung oleh semua array di Julia. Karenanya Anda dapat menulis:

Ini adalah fitur penting untuk diingat, jadi izinkan saya menekankan kembali: sembarang larik
Julia dapat diindeks menggunakan indeks bilangan bulat unik, yang disebut indeks linier.

Fitur kedua, yang agak mengejutkan, untuk diingat, adalah Anda dapat menambahkan suka
banyak jejak 1 saat mengindeks array apa pun yang Anda inginkan tanpa memengaruhi
hasil (lebih seperti itu 1s diabaikan):

julia> mat[2, 2]
5

julia> mat[2, 2, 1, 1, 1]
5

Di sini Anda dapat menemukan lebih banyak penjelasan tentang topik ini.

Penyiaran

Penyiaran adalah cara mudah untuk melakukan operasi pada array. Di dalam
khususnya memungkinkan untuk menggabungkan array dengan ukuran berbeda menjadi satu
kerja. Aturannya adalah sebagai berikut: ketika Anda beroperasi pada dua array no
dapatkan ukuran yang tepat, lalu perluas ukuran menjadi panjang 1 sesuai kebutuhan
panjang dengan mengulangi nilai sesuai kebutuhan. Berikut adalah contoh cepat:

julia> ["a" "b"] .^ [1, 2, 3]
3×2 Matrix{String}:
 "a"    "b"
 "aa"   "bb"
 "aaa"  "bbb"

Kami mengambil matriks ["a" "b"] memiliki baris dan dua kolom dan vektor
memiliki satu kolom dan tiga baris. Seperti yang Anda lihat deretan matriks
diulang tiga kali. Demikian pula, kolom vektor diulang
dua kali. Dengan cara ini ukuran kedua objek cocok dan bisa kita lakukan
menghitung. Khususnya, milik kita [1, 2, 3] vektor hanya memiliki satu dimensi sehingga
kolom size ditambahkan ke dalamnya dengan menyiarkan dan mengaturnya 1 (sebisa kamu
ingat ketika kita membahas pengindeksan array, Anda diizinkan untuk meletakkan 1S
tidak mempengaruhi hasil).

Penyiaran di Julia dilakukan dengan menggunakan a .Anda dapat membaca lebih lanjut tentang itu
di sini. Ini adalah sintaks yang sangat nyaman. Untuk alasan ini orang mulai
untuk menggunakannya dalam berbagai konteks. Karena popularitas ini, masalah langsung
muncul bahwa siaran juga berguna jika tidak berfungsi
dengan array. Ini contohnya:

julia> ["a"] .^ [1, 2, 3]
3-element Vector{String}:
 "a"
 "aa"
 "aaa"

Sementara ini bekerja secara tertulis ["a"] sangat tidak nyaman. Jadi disiarkan
telah diperpanjang untuk memungkinkan array tidak berpartisipasi dalam operasi. kamu bisa begitu
menulis:

julia> "a" .^ [1, 2, 3]
3-element Vector{String}:
 "a"
 "aa"
 "aaa"

Di mana "a" berpura-pura adalah array dengan panjang 1 di semua dimensi
ditentukan oleh wadah lain. Ini berpura-pura dilakukan di
kasus di mana berguna untuk memikirkan nilai yang diberikan sebagai array. Spesial,
dan kasus yang paling umum adalah ketika nilai yang diasumsikan adalah besaran skalar. Termudah
cara memikirkan besaran skalar adalah ia memiliki 0 dimensi (sangat efisien dalam segala hal
ukuran itu dapat dianggap sebagai panjang 1 dan cocok
diperluas).

Terkadang Anda ingin suatu nilai diperlakukan sebagai skalar meskipun itu bukan skalar.
Dalam kasus seperti itu, Anda dapat membungkusnya dengan Ref. Ref membuat 0objek -dimensi
bertindak sebagai skalar. Ini contohnya:

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

julia> r = Ref(x)
Base.RefValue{Vector{Int64}}([1, 2, 3])

julia> size(r)
()

julia> r[]
3-element Vector{Int64}:
 1
 2
 3

Perhatikan bahwa kita dapat mengekstrak nilai yang disimpan di r dengan mengindeks tanpa melewati
indeks apa pun (karena 0 dimensi). Sekarang mari kita lihat kapan ini terjadi
berguna:

julia> [1, 2, 3] .∈ [1, 3, 4]
3-element BitVector:
 1
 0
 0

julia> [1, 2, 3] .∈ Ref([1, 3, 4])
3-element BitVector:
 1
 0
 1

Kegiatan pertama tidak terlalu membantu. Ini setara dengan menulis
[1 ∈ 1, 2 ∈ 3, 3 in ∈ 4], yang mungkin bukan yang kita inginkan. Pada kegiatan kedua
kami melindungi vektor kedua dengan Ref biar bisa dipakai secara keseluruhan
untuk setiap elemen dari [1, 2, 3] vektor.

menggunakan Ref juga diperlukan saat beberapa objek tidak memiliki perilaku default
bahwa itu berpura-pura menjadi array yang diimplementasikan. Contoh umum adalah standar
kamus:

julia> haskey.(d, [1, 2, 5])
ERROR: ArgumentError: broadcasting over dictionaries and `NamedTuple`s is reserved

julia> haskey.(Ref(d), [1, 2, 5])
3-element BitVector:
 1
 1
 0

Sekarang setelah Anda memahami iterasi, pengindeksan (termasuk array
pengindeksan), dan siaran.

1. Apa urutan iterasi dari array?
2. Apakah tupel dapat disiarkan?
3. Apakah angka dapat diulang dan diindeks?
4. Apakah nomor atom dapat diubah, dapat diindeks, atau dapat disiarkan?
5. Menjadi Set iterable, dapat diindeks, atau dapat disiarkan?
6. Menjadi Dict iterable, dapat diindeks, atau dapat disiarkan?
7. Dinamakan tuple sebagai iterable, indexable, atau broadcastable?
8. Apa istimewanya iterasi string, pengindeksan, dan penyiaran?
9. Menjadi Pair iterable, dapat diindeks, atau dapat disiarkan?
10. Menjadi pairs(["a", "b", "c"]) iterable, dapat diindeks, atau dapat disiarkan?
11. Pertanyaan tambahan: adalah DataFrame iterable, dapat diindeks, atau dapat disiarkan? (itu adalah
    satu-satunya bukan dari Base Julia dalam daftar, tapi aku tidak bisa menolak
    godaan untuk memasukkannya)

1. Apa urutan iterasi dari array?

Dengan array, Anda harus ingat bahwa array diulang dalam urutan utama kolom
(sama seperti dalam pengindeksan linier yang kita bahas):

julia> x = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> for v in x
           print(v, " ")
       end
1 3 2 4

2. Apakah dataset dapat disiarkan?

Ya, Anda dapat menggunakan tupel dalam siaran. Mereka ditangani dengan cara yang sama
dalam bentuk vektor. Satu-satunya perbedaan adalah jika Anda hanya memainkan satu set data, Anda
hasilnya adalah tupe, sedangkan jika Anda mencampur tupel dengan ukuran array
setidaknya 1 Anda mendapatkan larik:

julia> 1 .+ (1, 2, 3)
(2, 3, 4)

julia> fill(1) .+ (1, 2, 3) # fill(1) produces 0-dimensional array
(2, 3, 4)

julia> [1] .+ (1, 2, 3) # here [1] is 1-dimensional array
3-element Vector{Int64}:
 2
 3
 4

3. Apakah angka dapat diulang dan diindeks?

Itu benar. Mereka dianggap wadah 0 dimensi.

julia> x = 1
1

julia> for v in x
           println(v)
       end
1

julia> x[]
1

julia> x[1, 1, 1]
1

julia> size(x)
()

julia> axes(x)
()

4. Apakah nomor atom dapat diulang, dapat diindeks, atau dapat disiarkan?

Tidak. Mereka hanya mendukung pengindeksan tanpa argumen yang diteruskan:

julia> x = Threads.Atomic{Int}(1)
Base.Threads.Atomic{Int64}(1)

julia> for v in x
           println(v)
       end
ERROR: MethodError: no method matching iterate(::Base.Threads.Atomic{Int64})

julia> x[]
1

julia> x[1]
ERROR: MethodError: no method matching getindex(::Base.Threads.Atomic{Int64}, ::Int64)

julia> x .+ 1
ERROR: MethodError: no method matching length(::Base.Threads.Atomic{Int64})

5. Apakah Set iterable, dapat diindeks, atau dapat disiarkan?

Iterable dan broadcastable, tetapi tidak dapat diindeks:

julia> s = Set([1, 2, 3])
Set{Int64} with 3 elements:
  2
  3
  1

julia> for v in s
           println(v)
       end
2
3
1

julia> s .+ 1
3-element Vector{Int64}:
 3
 4
 2

Perhatikan bahwa ketika Anda mengulang atau menyiarkan Set urutan nilai pengembalian
tidak dapat didefinisikan. Ini adalah jebakan umum saat melakukan siaran:

julia> s
Set{Int64} with 3 elements:
  2
  3
  1

julia> [1, 2, 3] .∈ s # note the iteration order of s
3-element BitVector:
 0
 0
 0

julia> [1, 2, 3] .∈ Ref(s) # this is what you really wanted
3-element BitVector:
 1
 1
 1

6. Apakah Dict iterable, dapat diindeks, atau dapat disiarkan?

Iterable dan sebagian dapat diindeks, tetapi tidak dapat dimainkan:

julia> d = Dict(v => '0'+v for v in s)
Dict{Int64, Char} with 4 entries:
  4 => '4'
  2 => '2'
  3 => '3'
  1 => '1'

julia> foreach(println, d)
4 => '4'
2 => '2'
3 => '3'
1 => '1'

julia> foreach(show, keys(d))
4231

julia> foreach(show, values(d))
'4''2''3''1'

Untuk kamus, hal dasar yang harus diingat adalah iterasi atas kamus akan kembali
nilai-nilai inti PairS. Jika Anda hanya menginginkan kuncinya, gunakan keys untuk membuat ceruk
iterator. Demikian juga untuk mendapatkan nilai menggunakan values Konstan. Juga urutan dari
ulang standar Dict tidak dapat didefinisikan.

julia> d[1]
'1': ASCII/Unicode U+0031 (category Nd: Number, decimal digit)

Mereka mungkin diindeks sebagian, karena tidak mendukung firstindex dan
lastindex metode.

Akhirnya, mereka tidak dapat disiarkan:

julia> d .+ 1
ERROR: ArgumentError: broadcasting over dictionaries and `NamedTuple`s is reserved

7. Apakah tuple bernama dapat diulang, dapat diindeks, atau dapat disiarkan?

Mereka dapat diubah, dapat diindeks tetapi tidak disiarkan:

julia> nt = (a=1, b=2, c=3)
(a = 1, b = 2, c = 3)

julia> foreach(println, nt)
1
2
3

julia> foreach(println, pairs(nt))
:a => 1
:b => 2
:c => 3

julia> nt[end]
3

julia> nt .+ 1
ERROR: ArgumentError: broadcasting over dictionaries and `NamedTuple`s is reserved

Perhatikan bahwa jika Anda ingin mendapatkan nilai kunci berulang dalam tupel bernama, Anda harus melakukannya
menggunakan pairs Konstan.

8. Apa istimewanya iterasi string, pengindeksan, dan penyiaran?

Saat Anda mengulangi string, Anda mendapatkan karakter. Pengindeksan string didukung, tetapi
belum tentu kontinyu. Mereka mendukung pengindeksan byte, seperti yang saya miliki
penjelasan rinci dalam artikel ini. Dalam siaran, mereka berperilaku seperti a
tanpa arah:

julia> str = "1₂3"
"1₂3"

julia> foreach(display, str)
'1': ASCII/Unicode U+0031 (category Nd: Number, decimal digit)
'₂': Unicode U+2082 (category No: Number, other)
'3': ASCII/Unicode U+0033 (category Nd: Number, decimal digit)

julia> collect(eachindex(str))
3-element Vector{Int64}:
 1
 2
 5

julia> str[2]
'₂': Unicode U+2082 (category No: Number, other)

julia> str[5]
'3': ASCII/Unicode U+0033 (category Nd: Number, decimal digit)

julia> string.(["a", "b"], str)
2-element Vector{String}:
 "a1₂3"
 "b1₂3"

Perhatian, karakter itu '₂' memiliki indeks 2, tetapi indeks valid berikutnya adalah 5,
karena '₂' memakan waktu tiga byte.

9. Apakah Pair iterable, dapat diindeks, atau dapat disiarkan?

Iterable dan dapat diindeks. Dalam siaran, ini dianggap sebagai skalar:

julia> p = :a => sin
:a => sin

julia> foreach(display, p)
:a
sin (generic function with 14 methods)

julia> p[1]
:a

julia> p[end]
sin (generic function with 14 methods)

julia> tuple.(p, (1, 2))
((:a => sin, 1), (:a => sin, 2))

10. Apakah pairs(["a", "b", "c"]) iterable, dapat diindeks, atau dapat disiarkan?

Iterable dan sebagian dapat diindeks, tetapi tidak disiarkan, meskipun demikian
memiliki panjang, dimensi dan poros:

julia> pv = pairs(["a", "b", "c"])
pairs(::Vector{String})(...):
  1 => "a"
  2 => "b"
  3 => "c"

julia> foreach(println, pv)
1 => "a"
2 => "b"
3 => "c"

julia> pv[1]
"a"

julia> pv[3]
"c"

julia> length(pv)
3

julia> size(pv)
(3,)

julia> axes(pv)
(Base.OneTo(3),)

julia> identity.(pv)
ERROR: ArgumentError: broadcasting over dictionaries and `NamedTuple`s is reserved

11. Apakah DataFrame iterable, dapat diindeks, atau dapat disiarkan?

Kerangka data yang dapat diindeks (tetapi selalu membutuhkan pengindeksan dua arah)
dan dapat disiarkan, tetapi tidak dapat diulang. Untuk mengulanginya
Anda harus memilih apakah ingin mengulang baris atau kolom:

julia> using DataFrames

julia> df = DataFrame(a=1:3, b=11:13)
3×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1     11
   2 │     2     12
   3 │     3     13

julia> df[2, 1]
2

julia> df[end, end]
13

julia> df[1]
ERROR: ArgumentError: syntax df[column] is not supported use df[!, column] instead

julia> df .^ 2
3×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1    121
   2 │     4    144
   3 │     9    169

julia> foreach(println, df)
ERROR: AbstractDataFrame is not iterable. Use eachrow(df) to get a row iterator or eachcol(df) to get a column iterator

julia> foreach(println, eachrow(df))
DataFrameRow
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1     11
DataFrameRow
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   2 │     2     12
DataFrameRow
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   3 │     3     13

julia> foreach(println, eachcol(df))
[1, 2, 3]
[11, 12, 13]

Saya harap Anda menemukan contoh yang saya sertakan dalam posting bermanfaat dan kemudian
bacalah, kemampuan Anda untuk bekerja dengan wadah di Julia telah meningkat!

Terkait