Julia Language
Verständnis

Array-Verständnis

Grundlegende Syntax

Julias Array-Verständnis verwendet die folgende Syntax:

[expression for element = iterable]

Beachten Sie, dass wie bei for Schleifen alle = , in und ∈ für das Verständnis akzeptiert werden.

Dies entspricht in etwa der Erstellung eines leeren Arrays und der Verwendung einer for Schleife zum push! Artikel dazu.

result = []
for element in iterable
    push!(result, expression)
end

Die Art eines Array-Verständnisses ist jedoch so eng wie möglich, was für die Leistung besser ist.

Um beispielsweise ein Feld der Quadrate der Ganzzahlen von 1 bis 10 , kann der folgende Code verwendet werden.

squares = [x^2 for x=1:10]

Dies ist ein sauberer, prägnanter Ersatz für die längere Version for -loop.

squares = []
for x in 1:10
    push!(squares, x^2)
end

Bedingtes Array-Verständnis

Vor dem Julia 0.5 gibt es keine Möglichkeit, Bedingungen innerhalb der Array-Verhältnisse zu verwenden. Aber es stimmt nicht mehr. In Julia 0.5 können wir die Bedingungen innerhalb der folgenden Bedingungen verwenden:

julia> [x^2 for x in 0:9 if x > 5] 
4-element Array{Int64,1}:
 36
 49
 64
 81

Quelle des obigen Beispiels finden Sie hier .

Wenn wir ein verschachteltes Listenverständnis verwenden möchten:

julia>[(x,y) for x=1:5 , y=3:6 if y>4 && x>3 ]
4-element Array{Tuple{Int64,Int64},1}:
 (4,5)
 (5,5)
 (4,6)
 (5,6)

Mehrdimensionale Arrayverstehen

Verschachtelte for Schleifen können verwendet werden, um mehrere eindeutige iterierbare Elemente zu durchlaufen.

result = []
for a = iterable_a
    for b = iterable_b
        push!(result, expression)
    end
end

In ähnlicher Weise können mehrere Iterationsspezifikationen zu einem Arrayverständnis geliefert werden.

[expression for a = iterable_a, b = iterable_b]

Beispielsweise kann das Folgende verwendet werden, um das kartesische Produkt von 1:3 und 1:2 zu erzeugen.

julia> [(x, y) for x = 1:3, y = 1:2]
3×2 Array{Tuple{Int64,Int64},2}:
 (1,1)  (1,2)
 (2,1)  (2,2)
 (3,1)  (3,2)

Abgeflachte mehrdimensionale Array-Verhältnisse sind ähnlich, außer dass sie die Form verlieren. Zum Beispiel,

julia> [(x, y) for x = 1:3 for y = 1:2]
6-element Array{Tuple{Int64,Int64},1}:
 (1, 1)
 (1, 2)
 (2, 1)
 (2, 2)
 (3, 1)
 (3, 2)

ist eine abgeflachte Variante. Der syntaktische Unterschied besteht darin, dass anstelle eines Kommas ein zusätzliches for verwendet wird.

Generatorverständnisse

Generatorenverstehen haben ein ähnliches Format wie Arrayverstehen, verwenden jedoch Klammern () anstelle von eckigen Klammern [] .

(expression for element = iterable)

Ein solcher Ausdruck gibt ein Generator Objekt zurück.

julia> (x^2 for x = 1:5)
Base.Generator{UnitRange{Int64},##1#2}(#1,1:5)

Funktionsargumente

Generatorenverständnisse können als einziges Argument für eine Funktion bereitgestellt werden, ohne dass zusätzliche Klammern erforderlich sind.

julia> join(x^2 for x = 1:5)
"1491625"

Wenn jedoch mehr als ein Argument angegeben wird, benötigt das Generatorverständnis seinen eigenen Satz von Klammern.

julia> join(x^2 for x = 1:5, ", ")
ERROR: syntax: invalid iteration specification

julia> join((x^2 for x = 1:5), ", ")
"1, 4, 9, 16, 25"