Tuple-ök ebben a kurzusban:

A(z) Tuple-ök fogalomról

A Tuple sok szempontból nagyon hasonlít a Vector-hoz (egydimenziós array). Van azonban néhány fontos különbség.

• A tuple-öket kerek zárójelbe ( ) írjuk a szögletes zárójel [ ] helyett, bár a zárójelek elhagyhatók, ha a jelentés egyértelmű.
• A tuple-öknek nem kell homogénnek lenniük: az egyes elemek típusát külön tárolja.
• A tuple-ök módosíthatatlanok.

A módosíthatatlanság több fordítóoptimalizálást tesz lehetővé, és gyorsabbá teszi a tuple-öket a vektoroknál, ezért ott érdemes előnyben részesíteni őket, ahol nincs szükség módosíthatóságra.

julia> t = (3, 5.2, "xyz")
(3, 5.2, "xyz")

# Non-homogeneous:
julia> dump(t)
Tuple{Int64, Float64, String}
  1: Int64 3
  2: Float64 5.2
  3: String "xyz"

julia> t[2]
5.2

# Immutable:
julia> t[2] = 7.3
ERROR: MethodError: no method matching setindex!(::Tuple{Int64, Float64, String}

Létezik egy Tuple() konstruktor is, amely bármely bejárható gyűjteményt tuple-lé alakít. Hasznos, hogy a stringet karakterekből álló, bejárható gyűjteményként kezeli.

julia> Tuple("Julia")
('J', 'u', 'l', 'i', 'a')

Bármely tuple esetén elérhetjük az elemeket index alapján, vagy végigmehetünk rajtuk egy ciklussal.

Bármely tisztán numerikus tuple használható olyan matematikai függvényekben, mint a sum(), pontosan úgy, mint a tömbök.

Kicsomagolás

Egy tuple kicsomagolható az egyes elemeire többszörös értékadással. A nem szükséges elemekhez használd alulvonást _ dummy változóként.

julia> tup = (1, "Julia", true)
(1, "Julia", true)

julia> num, name, _ = tup
(1, "Julia", true)

julia> uppercase(name), 2num
("JULIA", 2)

Ahhoz, hogy egy tuple összes elemét átmásoljuk egy másik tuple-be (vagy általánosabban egy gyűjteménybe), a splat operátor ... szolgál a kicsomagolásra. Erről részletesebben a Függvények fogalomban lesz szó.

julia> new_tup = (tup..., π, '😊')
(1, "Julia", true, π, '😊')

Nevesített tuple-ök

A Tuple csak értékeket tartalmaz. A NamedTuple minden értéket összepárosít egy névvel.

Az egyes mezők ezután „pont” jelöléssel érhetők el:

julia> nt = (a = 1, b = 7.3)
(a = 1, b = 7.3)

julia> dump(nt)
@NamedTuple{a::Int64, b::Float64}
  a: Int64 1
  b: Float64 7.3

julia> nt.b
7.3

A nevet belsőleg Symbol típusként tárolja (ez egy módosíthatatlan típus, és a név elé kettőspont : kerül), így egy alternatív szintaxis is elérhető:

julia> nt[:b]
7.3

Néha hasznos két lépésre bontani egy nevesített tuple létrehozását:

1. Definiáld a mezőket egyéni adattípusként.
2. Használd ezt konstruktorként, hogy egy tuple-t nevesített tuple-lé alakíts.

# Step 1
julia> Student = NamedTuple{(:name, :grade), Tuple{String, Int}}
@NamedTuple{name::String, grade::Int64}

julia> typeof(Student)
DataType

# Step 2
julia> s = Student( ("Helen", 3) )
(name = "Helen", grade = 3)

julia> dump(s)
@NamedTuple{name::String, grade::Int64}
  name: String "Helen"
  grade: Int64 3

Meglepően sok más módja is van egy nevesített tuple létrehozásának, ezért nézd meg a dokumentációt, ha érdekel.

Könnyen megszerezhetők külön a nevek (más néven „kulcsok”) vagy az értékek:

julia> keys(s)
(:name, :grade)

julia> values(s)
("Helen", 3)

Vedd észre, hogy a nevesített tuple-ön végzett iteráció csak az értékeket adja vissza, a neveket pedig figyelmen kívül hagyja.

Ha az iterációban a nevekre is szükség van, több lépésre lesz szükség. A NamedTuple átalakítható Pairs elemekből álló Vector-vá (a Pair-ok egy másik fogalom témája).

julia> pairs(s)
pairs(::NamedTuple) with 2 entries:
  :name  => "Helen"
  :grade => 3

julia> collect(pairs(s))
2-element Vector{Pair{Symbol, Any}}:
  :name => "Helen"
  :grade => 3

A nevesített tuple így meglehetősen hasonlít egy szótárra. Néhány fontos dologban azonban különbözik a Julia [Dict][dict] típusától:

• A Dict módosítható, a NamedTuple pedig, akárcsak bármely tuple, módosíthatatlan.
• A Dict rugalmas abban, milyen típusú kulcsokat fogad el; a NamedTuple kulcsként csak szimbólumokat használhat.

A tuple-ök (nevesítettek vagy sem) nagyon gyakori módja a strukturált adatok függvényekhez való átadásának és onnan való visszakapásának. A módosíthatatlanság ebben az esetben előnyös: adatbiztonságot nyújt, és lehetővé teszi az agresszívabb fordítóoptimalizálást.