Julia-Arrays

Ein Array ist eine Sammlung von Elementen desselben Datentyps, die in einer bestimmten Reihenfolge angeordnet sind; es kann ein eindimensionales Array oder ein mehrdimensionales Array sein.

Julia unterstützt Array-Datenstrukturen, die eine geordnete Sammlung speichern können, deren Größe nicht festgelegt ist und deren Elemente vom gleichen oder von unterschiedlichen Typen sein können.

Julia-Arrays sind veränderliche, typisierte Sammlungen, die für Listen, Vektoren, Tabellen und Matrizen verwendet werden.

Die Indexschlüssel von Julia-Arrays können durch ganze Zahlen dargestellt werden, und die Größe eines Arrays ist nicht festgelegt.

Julia bietet viele Funktionen, die uns bei der Arbeit mit Arrays helfen, wie das Hinzufügen von Elementen zu Arrays, das Zusammenführen von Arrays usw.

Julia-Arrays verwenden eckige Klammern[...]zum Angeben, und mehrere Elemente verwenden Kommas,, um sie zu trennen.

Die Syntax zum Erstellen eines eindimensionalen Arrays (d. h. eines Vektors) ist:

[A, B, C, ...]

Erstellen eindimensionaler Arrays

Das folgende Beispiel erstellt ein einfaches eindimensionales Array:

Beispiel

julia> arr = [1,2,3]
3-elementiger Vector{Int64}:
1
2
3

Im obigen Beispiel haben wir ein eindimensionales Array mit 3 Elementen erstellt, jedes Element ist eine 64-Bit-Ganzzahl, und dieses eindimensionale Array ist an die Variablearr gebunden..

Die Typen der Array-Elemente können auch unterschiedlich sein:

Beispiel

julia> arr =[1, "EXAMPLE", 2.5, pi]
4-elementiger Vector{Any}:
1
"BEISPIEL"
2.5
π = 3.1415926535897...

Im obigen Beispiel haben wir ein eindimensionales Array mit 4 Elementen unterschiedlicher Typen erstellt.piist eine Konstanteπ, jedes Element ist eine 64-Bit-Ganzzahl, und dieses eindimensionale Array ist an die Variablearr gebunden..

Natürlich können Sie den Typ auch erzwingen:

Beispiel

julia> arr = Int64[1,2,3]
3-elementiger Vector{Int64}:
1
2
3
julia> arr2 = String["Taobao","EXAMPLE","GOOGLE"]
3-elementiger Vector{String}:
"Taobao"
"BEISPIEL"
"GOOGLE"

Das Array im obigen Beispielarrist auf nur Ganzzahlen beschränkt,arr2ist auf nur Zeichenketten beschränkt.

Wir können auch ein leeres Array erstellen:

Beispiel

julia> arr = Int64[]
Int64[]

julia> arr2 = String[]
String[]

Auf das erstellte Array kann direkt über Indexwerte zugegriffen werden. Der erste Wert hat den Index 1 (nicht 0), der zweite hat den Index 2, und so weiter. Der letzte kann mitenddargestellt werden:

Beispiel

julia> arr = Int64[1,2,3]
3-elementiger Vector{Int64}:
1
2
3

julia> arr[2]
2
julia> arr2 = String["Taobao","EXAMPLE","GOOGLE"]
3-elementiger Vector{String}:
"Taobao"
"BEISPIEL"
"GOOGLE"

julia> arr2[1]
"Taobao"

julia> arr2[end]
"GOOGLE"

Angeben von Array-Typen und -Dimensionen

Wir können auch die folgende Syntax verwenden, um den Typ und die Dimensionen eines Arrays anzugeben:

Array{type}(undef, dims...)

undefgibt an, dass das Array nicht initialisiert ist.

dims...kann ein einzelnes oder mehrere Tupel von Dimensionen oder eine Menge von Werten sein, wenn Dimensionen als variable Argumente übergeben werden.

dims...Die Zahl gibt die Anzahl der Elemente an; bei mehreren Dimensionen werden Kommas verwendet,,um sie zu trennen.

Beispiel

julia> array = Array{Int64}(undef, 3) # stellt ein eindimensionales Array mit 3 Elementen dar
3-elementiger Vector{Int64}:
4834342704
4377305096
0

julia> array = Array{Int64}(undef, 3, 3, 3) # stellt ein 3-dimensionales Array dar, mit 3 Elementen in jeder Dimension
3×3×3 Array{Int64, 3}:
[:, :, 1] =
4562265712 0 0
1 0 0
0 0 0

[:, :, 2] =
0 0 0
0 0 0
0 0 0

[:, :, 3] =
0 0 0
0 0 0
0 0 0

Im obigen Beispiel setzen wir den Typ des Arrays in geschweifte Klammern{}, undef wird verwendet, um das Array als nicht initialisiert festzulegen, statt einen bekannten Wert zu verwenden; deshalb erhalten wir Zufallszahlen in der Ausgabe.

Erstellen zweidimensionaler Arrays und Matrizen

Wir können die Kommas zwischen den Array-Elementen weglassen,oder zwei Doppelpunkte verwenden;;, auf diese Weise können wir ein zweidimensionales Array erstellen, wie im folgenden Beispiel:

Beispiel

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

Hinweis:Die Ausgabe in der ersten Zeile1×4 Matrix{Int64}:, 1x4 repräsentiert eine Matrix mit einer Zeile und vier Spalten.

Obwohl es nur eine Zeile hat, ist es dennoch ein zweidimensionales Array, weil Julia nur Spaltenvektoren erkennt, keine sogenannten Zeilenvektoren.

Um eine weitere Zeile hinzuzufügen, fügen Sie einfach ein Semikolon;hinzu, siehe folgendes Beispiel:

Beispiel

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

Sie können auch Doppelpunkte:und Leerzeichen verwenden, um dies zu erreichen, siehe folgendes Beispiel:

Beispiel

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

Hinweis:Die Ausgabe in der ersten Zeile2×2 Matrix{Int64}:, 2×2 steht für eine Matrix mit zwei Zeilen und zwei Spalten.

Wir können auch eindimensionale Arrays gleicher Länge in eckigen Klammern[]einbetten und sie mit Leerzeichen trennen, um ein zweidimensionales Array zu erstellen:

Beispiel

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

2x3steht für ein Array mit zwei Zeilen und drei Spalten.

Im Folgenden verwenden wir flexibel Semikolons;und Leerzeichen , um ein zweidimensionales Array mit zwei Zeilen und drei Spalten sowie eines mit drei Zeilen und zwei Spalten zu erstellen:

Beispiel

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

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

Verwenden von Range-Funktionen zum Erstellen von Arrays

Ellipse ...

Sie können die Ellipse...verwenden, um ein Array zu erstellen, wie im folgenden Beispiel:

Beispiel

julia> [0:10...]
11-elementiger Vector{Int64}:
0
1
2
3
4
5
6
7
8
9
10

collect()-Funktion

Die Syntax der collect()-Funktion lautet wie folgt:

collect(start:step:stop)

start ist der Startwert, step ist die Schrittweite und stop ist der Endwert.

Diese Funktion gibt ein Array zurück.

Im folgenden Beispiel ist der Wert 1, die Schrittweite 2 und der Endwert 13:

Beispiel

julia> collect(1:2:13)
7-elementiger Vector{Int64}:
1
3
5
7
9
11
13

Die Funktion collect() kann auch einen Typ angeben, mit folgender Syntax:

collect(element_type, start:step:stop)

Das folgende Beispiel erstellt ein Gleitkomma-Array:

Beispiel

julia> collect(Float64, 1:2:5)
3-Element Vector{Float64}:
1.0
3.0
5.0

range()-Funktion

Die Funktion range() kann einen Intervallbereich erzeugen und eine Schrittweite angeben, was praktisch für den Aufruf durch die Funktion collect() ist.

Die Syntax der Funktion range() lautet wie folgt:

range(start, stop, length) range(start, stop; length, step) range(start; length, stop, step) range(;start, length, stop, step)

start ist der Startwert, step ist die Schrittweite, stop ist der Endwert und length ist die Länge.

Beispiel

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

Wenn length nicht angegeben ist undstop - startkein ganzzahliges Vielfaches von step ist, wird eine Range erzeugt, die vor stop endet.

julia> range(1, 3.5, step=2)
1.0:2.0:3.0

Arrays mit range() und collect() erstellen:

Beispiel

julia> collect(range(1,stop=10))
10-elementiger Vector{Int64}:
1
2
3
4
5
6
7
8
9
10
julia> collect(range(1, length=15, stop=150))
15-Element Vector{Float64}:
1.0
11.642857142857142
22.285714285714285
32.92857142857143
43.57142857142857
54.214285714285715
64.85714285714286
75.5
86.14285714285714
96.78571428571429
107.42857142857143
118.07142857142857
128.71428571428572
139.35714285714286
150.0

Arrays mit Comprehensions und Generatoren erstellen

Eine weitere nützliche Möglichkeit, Arrays zu erstellen, ist die Verwendung von Comprehensions.

Die Syntax von Array-Comprehensions lautet wie folgt:

A = [ F(x,y,...) for x=rx, y=ry, ... ]

F(x,y,...) wird für jeden Wert der Variablen x, y usw. in den gegebenen Listen ausgewertet. Die Werte können als beliebiges iterierbares Objekt angegeben werden, sind aber üblicherweise Bereiche wie 1:n oder 2:(n-1) oder explizite Array-Werte wie [1.2, 3.4, 5.7]. Das Ergebnis ist ein N-dimensionales dichtes Array, dessen Dimensionen durch Verkettung der Dimensionen der Variablenbereiche rx, ry usw. erhalten werden, wobei jede Auswertung von F(x,y,...) einen Skalar zurückgibt.

Beispiel

julia> [n^2 for n in 1:10]
10-elementiger Vector{Int64}:
1
4
9
16
25
36
49
64
81
100

Ein zweidimensionales Array erstellen:

Beispiel

julia> [n*m for n in 1:10, m in 1:10]
10×10 Matrix{Int64}:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100

Comprehensions können auch ohne eckige Klammern geschrieben werden, wodurch ein Objekt namens Generator entsteht.

Das folgende Beispiel erstellt ein Array:

Beispiel

julia> collect(n^2 for n in 1:5)
5-elementiger Vector{Int64}:
1
4
9
16
25

Der folgende Ausdruck summiert eine Sequenz, ohne Speicher zu allozieren:

Beispiel

julia> sum(1/n^2 for n=1:1000)
1.6439345666815615

Grundlegende Funktionen für Julia-Arrays

Funktion	Beschreibung
`eltype(A)`	`A`der Typ der Elemente in
`length(A)`	`A`die Anzahl der Elemente in
`ndims(A)`	`A`die Dimension von
`size(A)`	ein Tupel, das enthält`A`ein Tupel mit der Anzahl der Elemente in jeder Dimension
`size(A,n)`	`A`Nein.`n`die Anzahl der Elemente in Dimension
`axes(A)`	ein Tupel, das enthält`A`ein Tupel gültiger Indizes
`axes(A,n)`	Nein.`n`der Bereich gültiger Indizes für Dimension
`eachindex(A)`	ein effizienter Iterator für den Zugriff auf`A`jede Position in
`stride(A,k)`	auf der`k`Stride auf Dimension (Abstand im linearen Index zwischen benachbarten Elementen)
`strides(A)`	ein Tupel, das den Stride für jede Dimension enthält

Konstruktion und Initialisierung in Julia

Julia bietet viele Funktionen zum Konstruieren und Initialisieren von Arrays. In den folgenden Funktionen kann das Argument dims ... ein Tupel sein, um die Dimensionen darzustellen, oder eine variable Anzahl von Ganzzahlwerten als Dimensionen. Das erste Argument der meisten Funktionen repräsentiert den Elementtyp T des Arrays. Wenn der Typ T weggelassen wird, ist er standardmäßig Float64.

Funktion	Beschreibung
`Array{T}(undef, dims...)`	Ein dichtes Array, das nicht initialisiert ist`Array`
`zeros(T, dims...)`	Ein Array mit lauter Nullen`Array`
`ones(T, dims...)`	Ein Array, bei dem alle Elemente gleich 1 sind`Array`
`trues(dims...)`	Ein Array, dessen jedes Element ist`true`von`BitArray`
`falses(dims...)`	Ein Array, dessen jedes Element ist`false`von`BitArray`
`reshape(A, dims...)`	Ein Array, das dasselbe enthält`A`Array mit denselben Daten, aber unterschiedlichen Dimensionen
`copy(A)`	copy`A`
`deepcopy(A)`	tiefe Kopie, d. h. Kopieren`A`, und rekursives Kopieren seiner Elemente
`similar(A, T, dims...)`	Ein Array mit demselben`A`ein nicht initialisiertes Array mit demselben Typ (hier bezieht sich auf dense, sparse usw.), aber mit dem angegebenen Elementtyp und den angegebenen Dimensionen. Der zweite und der dritte Parameter sind beide optional; wenn sie weggelassen werden, werden sie standardmäßig auf den Elementtyp und`A`die Dimensionen von.
`reinterpret(T, A)`	und`A`Ein Array mit denselben Binärdaten, aber der Elementtyp ist`T`
`rand(T, dims...)`	Ein zufälliges`Array`, die Elementwerte sind $[0, 1)$ gleichmäßig im halboffenen Intervall verteilt und einer unabhängigen und identischen Verteilung erster Ordnung folgend^[1]
`randn(T, dims...)`	Ein zufälliges`Array`, die Elemente sind standardnormalverteilt, unabhängig und identisch verteilt
`Matrix{T}(I, m, n)`	`m`line`n`Einheitsmatrix mit Spalten (muss zuerst ausgeführt werden`using LinearAlgebra`um zu verwenden`I`）
`range(start, stop=stop, length=n)`	from`start`auf`stop`with`n`Bereich linear beabstandeter Elemente
`fill!(A, x)`	Mit dem Wert`x`das Array füllen`A`
`fill(x, dims...)`	Ein Array gefüllt mit`x`gefüllt`Array`

zeros()Erzeuge eine Array-Instanz, alle Anfangswerte der Elemente sind 0:

Beispiel

julia> zeros(Int8, 2, 3)
2×3 Matrix{Int8}:
0 0 0
0 0 0

julia> zeros(Int8, (2, 3))
2×3 Matrix{Int8}:
0 0 0
0 0 0

julia> zeros((2, 3))
2×3 Matrix{Float64}:
0.0 0.0 0.0
0.0 0.0 0.0

Weitere Erweiterungen