Julia: Arrays, Tupel, Dicts und Mengen

Kurz: Arrays sind das Arbeitspferd von Julia: dynamisch, typisiert (Vector{Int64}) und mehrdimensional. Indizes beginnen bei 1, end ist das letzte Element.

Teil des Kurses Julia

Kapitel 4 von 8 im Kurs Julia (Abschnitt „Datenstrukturen“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Arrays

Arrays sind das Arbeitspferd von Julia: dynamisch, typisiert (Vector{Int64}) und mehrdimensional. Indizes beginnen bei 1, end ist das letzte Element.

v = [5, 3, 9, 1]
println(v, " ", length(v), " ", v[1], " ", v[end], " ", v[2:3], " ", v[[1, 4]])
push!(v, 7); pushfirst!(v, 0)
println(v)
letztes = pop!(v); erstes = popfirst!(v)
println(letztes, " ", erstes, " ", v)
append!(v, [20, 30]); insert!(v, 2, 99); deleteat!(v, 2)
println(v)
println(sort(v), " ", sort(v, rev = true), " ", reverse(v), " ", sortperm(v))
println(sum(v), " ", prod([1, 2, 3, 4]), " ", maximum(v), " ", minimum(v), " ", extrema(v))
println(findall(>(5), v), " ", findfirst(==(9), v), " ", v[v .> 5], " ", count(iseven, v))
println(any(>(25), v), " ", all(>(0), v), " ", 9 in v, " ", unique([1, 2, 2, 3, 1]))
println(zeros(3), " ", ones(Int, 2), " ", fill(7, 3), " ", collect(1:2:9), " ", range(0, 1, length = 5))
println(cumsum(1:5), " ", diff([1, 4, 9]), " ", vcat([1, 2], [3]), " ", [1, 2] == [1, 2])
println(first(v, 2), " ", last(v, 2), " ", length(similar(v)), " ", eltype(v), " ", typeof([1, 2.5, 3]))
println(join(v[1:3], ", "), " ", string.(1:3), " ", isempty([]), " ", Int[])

Ausgabe:

[5, 3, 9, 1] 4 5 1 [3, 9] [5, 1]
[0, 5, 3, 9, 1, 7]
7 0 [5, 3, 9, 1]
[5, 3, 9, 1, 20, 30]
[1, 3, 5, 9, 20, 30] [30, 20, 9, 5, 3, 1] [30, 20, 1, 9, 3, 5] [4, 2, 1, 3, 5, 6]
68 24 30 1 (1, 30)
[3, 5, 6] 3 [9, 20, 30] 2
true true true [1, 2, 3]
[0.0, 0.0, 0.0] [1, 1] [7, 7, 7] [1, 3, 5, 7, 9] 0.0:0.25:1.0
[1, 3, 6, 10, 15] [3, 5] [1, 2, 3] true
[5, 3] [20, 30] 6 Int64 Vector{Float64}
5, 3, 9 ["1", "2", "3"] true Int64[]

Matrizen

A = [1 2 3; 4 5 6]                   # 2x3-Matrix: Leerzeichen trennen Spalten, ; Zeilen
println(A, " ", size(A), " ", A[2, 3], " ", A[:, 2], " ", A[1, :])
B = A'                                # transponieren
println(B, " ", size(B))
println(A * B)                        # Matrixprodukt
println(A .* 2, " ", A .+ [10, 20])   # elementweise, Broadcasting über Spalten
println(sum(A), " ", sum(A, dims = 1), " ", sum(A, dims = 2), " ", maximum(A, dims = 2))
println(reshape(1:6, 2, 3), " ", hcat([1, 2], [3, 4]), " ", vcat(A, [7 8 9]))
println([i * j for i in 1:3, j in 1:3])
using LinearAlgebra
M = [2.0 1.0; 1.0 3.0]
println(det(M), " ", inv(M), " ", M \ [3.0, 5.0], " ", tr(M), " ", eigvals(M) .|> x -> round(x, digits = 4))
println(I(2), " ", diagm([1, 2, 3]), " ", norm([3, 4]), " ", dot([1, 2, 3], [4, 5, 6]), " ", cross([1, 0, 0], [0, 1, 0]))

Ausgabe:

[1 2 3; 4 5 6] (2, 3) 6 [2, 5] [1, 2, 3]
[1 4; 2 5; 3 6] (3, 2)
[14 32; 32 77]
[2 4 6; 8 10 12] [11 12 13; 24 25 26]
21 [5 7 9] [6; 15;;] [3; 6;;]
[1 3 5; 2 4 6] [1 3; 2 4] [1 2 3; 4 5 6; 7 8 9]
[1 2 3; 2 4 6; 3 6 9]
5.0 [0.6 -0.2; -0.2 0.4] [0.8, 1.4] 5.0 [1.382, 3.618]
Bool[1 0; 0 1] [1 0 0; 0 2 0; 0 0 3] 5.0 32 [0, 0, 1]

Die Matrixoperationen (*, \, inv, det, eigvals) stecken im Paket LinearAlgebra der Standardbibliothek.

Tupel und NamedTuple

Ein Tupel ist unveränderlich und kann Verschiedenes enthalten:

t = (1, "zwei", 3.0)
println(t, " ", t[2], " ", length(t), " ", typeof(t))
a, b, c = t
println(a, " ", b, " ", c)
a, b = b, a                           # Tauschen
println(a, " ", b)
person = (name = "Mia", alter = 17)   # NamedTuple
println(person.name, " ", person[:alter], " ", keys(person), " ", values(person))
println(merge(person, (alter = 18, ort = "Berlin")))
first, rest... = [1, 2, 3, 4]
println(first, " ", rest)

Ausgabe:

(1, "zwei", 3.0) zwei 3 Tuple{Int64, String, Float64}
1 zwei 3.0
zwei 1
Mia 17 (:name, :alter) ("Mia", 17)
(name = "Mia", alter = 18, ort = "Berlin")
1 [2, 3, 4]

Dictionaries und Mengen

alter = Dict("Mia" => 17, "Tom" => 25)
alter["Zoe"] = 31
println(alter["Mia"], " ", get(alter, "Ben", 0), " ", haskey(alter, "Tom"), " ", length(alter))
delete!(alter, "Tom")
for name in sort(collect(keys(alter)))            # Reihenfolge sortieren!
    println(name, " => ", alter[name])
end
println(sort(collect(values(alter))), " ", sort(collect(pairs(alter))))
println(Dict(:a => 1, :b => 2)[:a], " ", get!(alter, "Neu", 5), " ", sort(collect(keys(alter))))
zaehler = Dict{Char, Int}()
for c in "mississippi"
    zaehler[c] = get(zaehler, c, 0) + 1
end
println(sort(collect(zaehler)))
println(maximum(values(zaehler)), " ", sort([k for (k, n) in zaehler if n == 4]))
gruppen = Dict{Int, Vector{String}}()
for w in ["ein", "kleiner", "langer", "Satz", "mit", "drei"]
    push!(get!(gruppen, length(w), String[]), w)
end
println(sort(collect(gruppen)))
 
s = Set([3, 1, 2, 3, 1])
println(length(s), " ", 2 in s, " ", sort(collect(union(s, Set([9])))), " ", sort(collect(intersect(s, Set([1, 9])))), " ", sort(collect(setdiff(s, Set([1])))))
println(issubset(Set([1]), s), " ", sort(collect(symdiff(Set([1, 2]), Set([2, 3])))))

Ausgabe:

17 0 true 3
Mia => 17
Zoe => 31
[17, 31] ["Mia" => 17, "Zoe" => 31]
1 5 ["Mia", "Neu", "Zoe"]
['i' => 4, 'm' => 1, 'p' => 2, 's' => 4]
4 ['i', 's']
[3 => ["ein", "mit"], 4 => ["Satz", "drei"], 6 => ["langer"], 7 => ["kleiner"]]
3 true [1, 2, 3, 9] [1] [2, 3]
true [1, 3]

Hinweis

Die Reihenfolge der Einträge in Dict und Set ist nicht festgelegt. Sortiere (sort(collect(...))), wenn die Ausgabe stabil sein soll. Für Einfügereihenfolge gibt es OrderedDict im Paket OrderedCollections.

Merke

• Vector/Matrix: Indizes ab 1; push!, pop!, sort, sum, findall, Slicing v[2:3]
• Matrizen [1 2; 3 4], A * B, A', A \ b; LinearAlgebra für det, inv, eigvals
• Tupel (unveränderlich), NamedTuple (name = "Mia"), Entpacken a, b = t
• Dict("a" => 1), get, haskey, delete!; Set für Mengen
• Reihenfolge in Dict/Set nicht garantiert

Übungsaufgabe

Berechne für eine 3×3-Matrix die Determinante und löse ein lineares Gleichungssystem mit \.

Quiz zur Selbstkontrolle

Wie schreibt man eine 2×2-Matrix?

• [1 2; 3 4] (richtig)
• [[1, 2], [3, 4]]
• (1 2; 3 4)
• matrix(1, 2, 3, 4)

Was ist der Unterschied zwischen Tupel und Array?

• Tupel sind unveränderlich (richtig)
• Tupel sind schneller zu ändern
• Tupel enthalten nur Zahlen
• Es gibt keinen

Wie bestimmt man die Anzahl der Dict-Einträge?

• length(d) (richtig)
• d.size
• count(d)
• size(d, 1)

Weiter im Kurs

Zurück: Funktionen und Mehrfachverteilung

Weiter: Structs, Module und Fehler

Alle Kapitel: Julia im Überblick