Collections and Data Structures

iterate(iter [, state]) -> Union{Nothing, Tuple{Any, Any}}

Bewege den Iterator vorwärts, um das nächste Element zu erhalten. Wenn keine Elemente mehr vorhanden sind, sollte nothing zurückgegeben werden. Andernfalls sollte ein 2-Tupel des nächsten Elements und des neuen Iterationsstatus zurückgegeben werden.

IteratorSize(itertype::Type) -> IteratorSize

Gegeben ist der Typ eines Iterators, gibt eine der folgenden Werte zurück:

• SizeUnknown() wenn die Länge (Anzahl der Elemente) im Voraus nicht bestimmt werden kann.
• HasLength() wenn es eine feste, endliche Länge gibt.
• HasShape{N}() wenn eine bekannte Länge plus eine Vorstellung von mehrdimensionaler Form (wie bei einem Array) vorliegt. In diesem Fall sollte N die Anzahl der Dimensionen angeben, und die axes Funktion ist für den Iterator gültig.
• IsInfinite() wenn der Iterator Werte für immer liefert.

Der Standardwert (für Iteratoren, die diese Funktion nicht definieren) ist HasLength(). Das bedeutet, dass die meisten Iteratoren davon ausgehen, die length zu implementieren.

Dieses Merkmal wird allgemein verwendet, um zwischen Algorithmen zu wählen, die Platz für ihr Ergebnis vorab reservieren, und Algorithmen, die ihr Ergebnis schrittweise anpassen.

julia> Base.IteratorSize(1:5)
Base.HasShape{1}()

julia> Base.IteratorSize((2,3))
Base.HasLength()

IteratorEltype(itertype::Type) -> IteratorEltype

Gegeben ist der Typ eines Iterators, gibt einen der folgenden Werte zurück:

• EltypeUnknown() wenn der Typ der von dem Iterator erzeugten Elemente im Voraus nicht bekannt ist.
• HasEltype() wenn der Elementtyp bekannt ist und eltype einen sinnvollen Wert zurückgeben würde.

HasEltype() ist der Standard, da davon ausgegangen wird, dass Iteratoren eltype implementieren.

Dieses Merkmal wird allgemein verwendet, um zwischen Algorithmen zu wählen, die einen bestimmten Typ von Ergebnis vorab zuweisen, und Algorithmen, die einen Ergebnistyp basierend auf den Typen der erzeugten Werte auswählen.

julia> Base.IteratorEltype(1:5)
Base.HasEltype()

AbstractRange{T} <: AbstractVector{T}

Obertyp für lineare Bereiche mit Elementen des Typs T. UnitRange, LinRange und andere Typen sind Untertypen davon.

Alle Untertypen müssen step definieren. Daher ist LogRange kein Untertyp von AbstractRange.

OrdinalRange{T, S} <: AbstractRange{T}

Supertyp für ordinale Bereiche mit Elementen des Typs T und Abständen des Typs S. Die Schritte sollten immer exakte Vielfache von oneunit sein, und T sollte ein "diskreter" Typ sein, der keine Werte kleiner als oneunit haben kann. Zum Beispiel würden Integer oder Date Typen qualifizieren, während Float64 dies nicht tun würde (da dieser Typ Werte kleiner als oneunit(Float64) darstellen kann). UnitRange, StepRange und andere Typen sind Untertypen davon.

AbstractUnitRange{T} <: OrdinalRange{T, T}

Supertyp für Bereiche mit einer Schrittgröße von oneunit(T) mit Elementen des Typs T. UnitRange und andere Typen sind Untertypen davon.

StepRange{T, S} <: OrdinalRange{T, S}

Bereiche mit Elementen des Typs T mit Abständen des Typs S. Der Schritt zwischen jedem Element ist konstant, und der Bereich wird in Bezug auf einen start und stop des Typs T und einen step des Typs S definiert. Weder T noch S sollten Fließkommatypen sein. Die Syntax a:b:c mit b != 0 und a, b und c, die alle Ganzzahlen sind, erstellt einen StepRange.

Beispiele

julia> collect(StepRange(1, Int8(2), 10))
5-element Vector{Int64}:
 1
 3
 5
 7
 9

julia> typeof(StepRange(1, Int8(2), 10))
StepRange{Int64, Int8}

julia> typeof(1:3:6)
StepRange{Int64, Int64}

UnitRange{T<:Real}

Ein Bereich, der durch einen start und stop des Typs T parametrisiert ist, gefüllt mit Elementen, die um 1 von start bis stop verteilt sind, bis stop überschritten wird. Die Syntax a:b mit a und b, die beide Integer sind, erstellt einen UnitRange.

Beispiele

julia> collect(UnitRange(2.3, 5.2))
3-element Vector{Float64}:
 2.3
 3.3
 4.3

julia> typeof(1:10)
UnitRange{Int64}

LinRange{T,L}

Ein Bereich mit len linear verteilten Elementen zwischen start und stop. Die Größe des Abstands wird durch len gesteuert, das eine Integer sein muss.

Beispiele

julia> LinRange(1.5, 5.5, 9)
9-element LinRange{Float64, Int64}:
 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5

Im Vergleich zur Verwendung von range sollte die direkte Konstruktion eines LinRange weniger Overhead haben, wird jedoch nicht versuchen, Floating-Point-Fehler zu korrigieren:

julia> collect(range(-0.1, 0.3, length=5))
5-element Vector{Float64}:
 -0.1
  0.0
  0.1
  0.2
  0.3

julia> collect(LinRange(-0.1, 0.3, 5))
5-element Vector{Float64}:
 -0.1
 -1.3877787807814457e-17
  0.09999999999999999
  0.19999999999999998
  0.3

Siehe auch Logrange für logarithmisch verteilte Punkte.

isempty(collection) -> Bool

Bestimmen Sie, ob eine Sammlung leer ist (keine Elemente hat).

Beispiele

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

Gibt true zurück, wenn keine Aufgaben auf die Bedingung warten, andernfalls false.

isdone(itr, [state]) -> Union{Bool, Missing}

Diese Funktion bietet einen Schnellpfad-Hinweis für den Abschluss von Iteratoren. Dies ist nützlich für zustandsbehaftete Iteratoren, die vermeiden möchten, dass Elemente konsumiert werden, wenn sie nicht dem Benutzer angezeigt werden (z. B. beim Überprüfen auf Vollständigkeit in isempty oder zip).

Zustandsbehaftete Iteratoren, die diese Funktion nutzen möchten, sollten eine isdone-Methode definieren, die je nach Zustand des Iterators true/false zurückgibt. Zustandslose Iteratoren müssen diese Funktion nicht implementieren.

Wenn das Ergebnis missing ist, können die Aufrufer iterate(x, state) === nothing berechnen, um eine definitive Antwort zu erhalten.

Siehe auch iterate, isempty

empty!(collection) -> collection

Entfernt alle Elemente aus einer collection.

Beispiele

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} mit 2 Einträgen:
  "b" => 2
  "a" => 1

julia> empty!(A);

julia> A
Dict{String, Int64}()

empty!(c::Channel)

Leere einen Kanal c, indem du empty! auf dem internen Puffer aufrufst. Gib den leeren Kanal zurück.

length(collection) -> Ganzzahl

Gibt die Anzahl der Elemente in der Sammlung zurück.

Verwenden Sie lastindex, um den letzten gültigen Index einer indexierbaren Sammlung zu erhalten.

Siehe auch: size, ndims, eachindex.

Beispiele

julia> length(1:5)
5

julia> length([1, 2, 3, 4])
4

julia> length([1 2; 3 4])
4

Base.checked_length(r)

Berechnet length(r), prüft jedoch möglicherweise auf Überlauf-Fehler, wo anwendbar, wenn das Ergebnis nicht in Union{Integer(eltype(r)),Int} passt.

in(item, collection) -> Bool
∈(item, collection) -> Bool

Bestimmen Sie, ob ein Element in der gegebenen Sammlung enthalten ist, im Sinne, dass es == zu einem der Werte ist, die durch Iteration über die Sammlung erzeugt werden. Gibt einen Bool-Wert zurück, es sei denn, item ist missing oder collection enthält missing, aber nicht item, in diesem Fall wird missing zurückgegeben (dreiwertige Logik, die dem Verhalten von any und == entspricht).

Einige Sammlungen folgen einer leicht anderen Definition. Zum Beispiel überprüfen Sets, ob das Element isequal zu einem der Elemente ist; Dicts suchen nach key=>value-Paaren, und der key wird mit isequal verglichen.

Um das Vorhandensein eines Schlüssels in einem Wörterbuch zu testen, verwenden Sie haskey oder k in keys(dict). Für die oben genannten Sammlungen ist das Ergebnis immer ein Bool.

Beim Broadcasting mit in.(items, collection) oder items .∈ collection werden sowohl item als auch collection über die Elemente gebroadcastet, was oft nicht beabsichtigt ist. Wenn beide Argumente Vektoren sind (und die Dimensionen übereinstimmen), ist das Ergebnis ein Vektor, der angibt, ob jeder Wert in der Sammlung items im Wert an der entsprechenden Position in collection enthalten ist. Um einen Vektor zu erhalten, der angibt, ob jeder Wert in items in collection enthalten ist, wickeln Sie collection in ein Tupel oder ein Ref wie folgt ein: in.(items, Ref(collection)) oder items .∈ Ref(collection).

Siehe auch: ∉, insorted, contains, occursin, issubset.

Beispiele

julia> a = 1:3:20
1:3:19

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

julia> missing in Set([1, 2])
false

julia> (1=>missing) in Dict(1=>10, 2=>20)
missing

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

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

∉(item, collection) -> Bool
∌(collection, item) -> Bool

Negation von ∈ und ∋, d.h. überprüft, dass item nicht in collection ist.

Beim Broadcasting mit items .∉ collection werden sowohl item als auch collection überbroadcastet, was oft nicht beabsichtigt ist. Wenn beide Argumente Vektoren sind (und die Dimensionen übereinstimmen), ist das Ergebnis ein Vektor, der angibt, ob jeder Wert in der Sammlung items nicht im Wert an der entsprechenden Position in collection ist. Um einen Vektor zu erhalten, der angibt, ob jeder Wert in items nicht in collection ist, wickeln Sie collection in ein Tupel oder ein Ref wie folgt: items .∉ Ref(collection).

Beispiele

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

julia> [1, 2] .∉ [2, 3]
2-element BitVector:
 1
 1

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

Base.hasfastin(T)

Bestimmen Sie, ob die Berechnung x ∈ collection, wobei collection::T ist, als "schnelle" Operation betrachtet werden kann (typischerweise konstante oder logarithmische Komplexität). Die Definition hasfastin(x) = hasfastin(typeof(x)) wird zur Bequemlichkeit bereitgestellt, sodass Instanzen anstelle von Typen übergeben werden können. Die Form, die ein Typ-Argument akzeptiert, sollte jedoch für neue Typen definiert werden.

Der Standardwert für hasfastin(T) ist true für Subtypen von AbstractSet, AbstractDict und AbstractRange und false andernfalls.

eltype(type)

Bestimmen Sie den Typ der Elemente, die durch das Iterieren über eine Sammlung des angegebenen type erzeugt werden. Für Dictionary-Typen wird dies ein Pair{KeyType,ValType} sein. Die Definition eltype(x) = eltype(typeof(x)) wird zur Verfügung gestellt, damit Instanzen anstelle von Typen übergeben werden können. Die Form, die ein Typ-Argument akzeptiert, sollte jedoch für neue Typen definiert werden.

Siehe auch: keytype, typeof.

Beispiele

julia> eltype(fill(1f0, (2,2)))
Float32

julia> eltype(fill(0x1, (2,2)))
UInt8

indexin(a, b)

Gibt ein Array zurück, das den ersten Index in b für jeden Wert in a enthält, der ein Mitglied von b ist. Das Ausgabearray enthält nothing, wo immer a kein Mitglied von b ist.

Siehe auch: sortperm, findfirst.

Beispiele

julia> a = ['a', 'b', 'c', 'b', 'd', 'a'];

julia> b = ['a', 'b', 'c'];

julia> indexin(a, b)
6-element Vector{Union{Nothing, Int64}}:
 1
 2
 3
 2
  nothing
 1

julia> indexin(b, a)
3-element Vector{Union{Nothing, Int64}}:
 1
 2
 3

unique(itr)

Gibt ein Array zurück, das nur die einzigartigen Elemente der Sammlung itr enthält, wie durch isequal und hash bestimmt, in der Reihenfolge, in der das erste jedes Satzes von äquivalenten Elementen ursprünglich erscheint. Der Elementtyp des Eingangs wird beibehalten.

Siehe auch: unique!, allunique, allequal.

Beispiele

julia> unique([1, 2, 6, 2])
3-element Vector{Int64}:
 1
 2
 6

julia> unique(Real[1, 1.0, 2])
2-element Vector{Real}:
 1
 2

unique(f, itr)

Gibt ein Array zurück, das einen Wert aus itr für jeden einzigartigen Wert enthält, der durch die Anwendung von f auf die Elemente von itr erzeugt wird.

Beispiele

julia> unique(x -> x^2, [1, -1, 3, -3, 4])
3-element Vector{Int64}:
 1
 3
 4

Diese Funktionalität kann auch verwendet werden, um die Indizes der ersten Vorkommen einzigartiger Elemente in einem Array zu extrahieren:

julia> a = [3.1, 4.2, 5.3, 3.1, 3.1, 3.1, 4.2, 1.7];

julia> i = unique(i -> a[i], eachindex(a))
4-element Vector{Int64}:
 1
 2
 3
 8

julia> a[i]
4-element Vector{Float64}:
 3.1
 4.2
 5.3
 1.7

julia> a[i] == unique(a)
true

unique(A::AbstractArray; dims::Int)

Gibt eindeutige Regionen von A entlang der Dimension dims zurück.

Beispiele

julia> A = map(isodd, reshape(Vector(1:8), (2,2,2)))
2×2×2 Array{Bool, 3}:
[:, :, 1] =
 1  1
 0  0

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

julia> unique(A)
2-element Vector{Bool}:
 1
 0

julia> unique(A, dims=2)
2×1×2 Array{Bool, 3}:
[:, :, 1] =
 1
 0

[:, :, 2] =
 1
 0

julia> unique(A, dims=3)
2×2×1 Array{Bool, 3}:
[:, :, 1] =
 1  1
 0  0

unique!(f, A::AbstractVector)

Wählt einen Wert aus A für jeden einzigartigen Wert, der durch f erzeugt wird, angewendet auf die Elemente von A, und gibt dann das modifizierte A zurück.

Beispiele

julia> unique!(x -> x^2, [1, -1, 3, -3, 4])
3-element Vector{Int64}:
 1
 3
 4

julia> unique!(n -> n%3, [5, 1, 8, 9, 3, 4, 10, 7, 2, 6])
3-element Vector{Int64}:
 5
 1
 9

julia> unique!(iseven, [2, 3, 5, 7, 9])
2-element Vector{Int64}:
 2
 3

unique!(A::AbstractVector)

Entfernen Sie doppelte Elemente, wie sie durch isequal und hash bestimmt werden, und geben Sie dann das modifizierte A zurück. unique! gibt die Elemente von A in der Reihenfolge zurück, in der sie auftreten. Wenn Ihnen die Reihenfolge der zurückgegebenen Daten egal ist, dann ist der Aufruf von (sort!(A); unique!(A)) viel effizienter, solange die Elemente von A sortiert werden können.

Beispiele

julia> unique!([1, 1, 1])
1-element Vector{Int64}:
 1

julia> A = [7, 3, 2, 3, 7, 5];

julia> unique!(A)
4-element Vector{Int64}:
 7
 3
 2
 5

julia> B = [7, 6, 42, 6, 7, 42];

julia> sort!(B);  # unique! kann sortierte Daten viel effizienter verarbeiten.

julia> unique!(B)
3-element Vector{Int64}:
  6
  7
 42

allunique(itr) -> Bool
allunique(f, itr) -> Bool

Gibt true zurück, wenn alle Werte aus itr unterschiedlich sind, wenn sie mit isequal verglichen werden. Oder wenn alle von [f(x) for x in itr] unterschiedlich sind, für die zweite Methode.

Beachten Sie, dass allunique(f, itr) f weniger als length(itr)-Mal aufrufen kann. Die genaue Anzahl der Aufrufe wird als Implementierungsdetail betrachtet.

allunique kann eine spezialisierte Implementierung verwenden, wenn die Eingabe sortiert ist.

Siehe auch: unique, issorted, allequal.

Beispiele

julia> allunique([1, 2, 3])
true

julia> allunique([1, 2, 1, 2])
false

julia> allunique(Real[1, 1.0, 2])
false

julia> allunique([NaN, 2.0, NaN, 4.0])
false

julia> allunique(abs, [1, -1, 2])
false

allequal(itr) -> Bool
allequal(f, itr) -> Bool

Gibt true zurück, wenn alle Werte aus itr gleich sind, wenn sie mit isequal verglichen werden. Oder wenn alle von [f(x) for x in itr] gleich sind, für die zweite Methode.

Beachten Sie, dass allequal(f, itr) f weniger als length(itr)-mal aufrufen kann. Die genaue Anzahl der Aufrufe wird als Implementierungsdetail betrachtet.

Siehe auch: unique, allunique.

Beispiele

julia> allequal([])
true

julia> allequal([1])
true

julia> allequal([1, 1])
true

julia> allequal([1, 2])
false

julia> allequal(Dict(:a => 1, :b => 1))
false

julia> allequal(abs2, [1, -1])
true

reduce(op, itr; [init])

Reduzieren Sie die gegebene Sammlung itr mit dem gegebenen binären Operator op. Wenn angegeben, muss der Anfangswert init ein neutrales Element für op sein, das für leere Sammlungen zurückgegeben wird. Es ist nicht spezifiziert, ob init für nicht-leere Sammlungen verwendet wird.

Für leere Sammlungen ist die Bereitstellung von init notwendig, außer in einigen Sonderfällen (z. B. wenn op einer von +, *, max, min, &, | ist), wenn Julia das neutrale Element von op bestimmen kann.

Reduktionen für bestimmte häufig verwendete Operatoren können spezielle Implementierungen haben und sollten stattdessen verwendet werden: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr). Es gibt effiziente Methoden zum Verketten bestimmter Arrays von Arrays, indem Sie reduce(vcat, arr) oder reduce(hcat, arr) aufrufen.

Die Assoziativität der Reduktion ist implementationsabhängig. Das bedeutet, dass Sie nicht-assoziative Operationen wie - nicht verwenden können, da nicht definiert ist, ob reduce(-,[1,2,3]) als (1-2)-3 oder 1-(2-3) ausgewertet werden sollte. Verwenden Sie stattdessen foldl oder foldr für garantierte linke oder rechte Assoziativität.

Einige Operationen akkumulieren Fehler. Parallelität wird einfacher, wenn die Reduktion in Gruppen ausgeführt werden kann. Zukünftige Versionen von Julia könnten den Algorithmus ändern. Beachten Sie, dass die Elemente nicht neu angeordnet werden, wenn Sie eine geordnete Sammlung verwenden.

Beispiele

julia> reduce(*, [2; 3; 4])
24

julia> reduce(*, [2; 3; 4]; init=-1)
-24

reduce(f, A::AbstractArray; dims=:, [init])

Reduziere die 2-Argumente-Funktion f entlang der Dimensionen von A. dims ist ein Vektor, der die zu reduzierenden Dimensionen angibt, und das Schlüsselwort-Argument init ist der Anfangswert, der in den Reduktionen verwendet werden soll. Für +, *, max und min ist das init-Argument optional.

Die Assoziativität der Reduktion ist implementationsabhängig; wenn Sie eine bestimmte Assoziativität benötigen, z. B. von links nach rechts, sollten Sie Ihre eigene Schleife schreiben oder in Betracht ziehen, foldl oder foldr zu verwenden. Siehe Dokumentation für reduce.

Beispiele

julia> a = reshape(Vector(1:16), (4,4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reduce(max, a, dims=2)
4×1 Matrix{Int64}:
 13
 14
 15
 16

julia> reduce(max, a, dims=1)
1×4 Matrix{Int64}:
 4  8  12  16

foldl(op, itr; [init])

Wie reduce, aber mit garantierter linker Assoziativität. Wenn angegeben, wird das Schlüsselwort-Argument init genau einmal verwendet. Im Allgemeinen ist es notwendig, init bereitzustellen, um mit leeren Sammlungen zu arbeiten.

Siehe auch mapfoldl, foldr, accumulate.

Beispiele

julia> foldl(=>, 1:4)
((1 => 2) => 3) => 4

julia> foldl(=>, 1:4; init=0)
(((0 => 1) => 2) => 3) => 4

julia> accumulate(=>, (1,2,3,4))
(1, 1 => 2, (1 => 2) => 3, ((1 => 2) => 3) => 4)

foldr(op, itr; [init])

Wie reduce, aber mit garantierter rechter Assoziativität. Wenn das Schlüsselwort-Argument init bereitgestellt wird, wird es genau einmal verwendet. Im Allgemeinen ist es notwendig, init bereitzustellen, um mit leeren Sammlungen zu arbeiten.

Beispiele

julia> foldr(=>, 1:4)
1 => (2 => (3 => 4))

julia> foldr(=>, 1:4; init=0)
1 => (2 => (3 => (4 => 0)))

maximum(f, itr; [init])

Gibt das größte Ergebnis zurück, das durch den Aufruf der Funktion f auf jedes Element von itr erzielt wird.

Der zurückgegebene Wert für ein leeres itr kann durch init festgelegt werden. Es muss ein neutrales Element für max sein (d.h. das kleiner oder gleich jedem anderen Element ist), da nicht spezifiziert ist, ob init für nicht leere Sammlungen verwendet wird.

Beispiele

julia> maximum(length, ["Julion", "Julia", "Jule"])
6

julia> maximum(length, []; init=-1)
-1

julia> maximum(sin, Real[]; init=-1.0)  # gut, da die Ausgabe von sin >= -1 ist
-1.0

maximum(itr; [init])

Gibt das größte Element in einer Sammlung zurück.

Der zurückgegebene Wert für leeres itr kann durch init angegeben werden. Es muss ein neutrales Element für max sein (d.h. das kleiner oder gleich jedem anderen Element ist), da nicht spezifiziert ist, ob init für nicht-leere Sammlungen verwendet wird.

Beispiele

julia> maximum(-20.5:10)
9.5

julia> maximum([1,2,3])
3

julia> maximum(())
ERROR: ArgumentError: Reduzieren über eine leere Sammlung ist nicht erlaubt; ziehen Sie in Betracht, `init` an den Reducer zu übergeben
Stacktrace:
[...]

julia> maximum((); init=-Inf)
-Inf

maximum(A::AbstractArray; dims)

Berechne den maximalen Wert eines Arrays über die angegebenen Dimensionen. Siehe auch die max(a,b) Funktion, um das Maximum von zwei oder mehr Argumenten zu nehmen, die elementweise auf Arrays über max.(a,b) angewendet werden können.

Siehe auch: maximum!, extrema, findmax, argmax.

Beispiele

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

julia> maximum(A, dims=1)
1×2 Matrix{Int64}:
 3  4

julia> maximum(A, dims=2)
2×1 Matrix{Int64}:
 2
 4

maximum(f, A::AbstractArray; dims)

Berechne den maximalen Wert, indem die Funktion f auf jedes Element eines Arrays über die angegebenen Dimensionen angewendet wird.

Beispiele

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

julia> maximum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  16

julia> maximum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  4
 16

maximum!(r, A)

Berechne den maximalen Wert von A über die Singleton-Dimensionen von r und schreibe die Ergebnisse in r.

Beispiele

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

julia> maximum!([1; 1], A)
2-element Vector{Int64}:
 2
 4

julia> maximum!([1 1], A)
1×2 Matrix{Int64}:
 3  4

minimum(f, itr; [init])

Gibt das kleinste Ergebnis zurück, das durch den Aufruf der Funktion f auf jedes Element von itr erzielt wird.

Der zurückgegebene Wert für ein leeres itr kann durch init festgelegt werden. Es muss ein neutrales Element für min sein (d.h. das größer oder gleich jedem anderen Element ist), da nicht spezifiziert ist, ob init für nicht leere Sammlungen verwendet wird.

Beispiele

julia> minimum(length, ["Julion", "Julia", "Jule"])
4

julia> minimum(length, []; init=typemax(Int64))
9223372036854775807

julia> minimum(sin, Real[]; init=1.0)  # gut, da die Ausgabe von sin <= 1 ist
1.0

minimum(itr; [init])

Gibt das kleinste Element in einer Sammlung zurück.

Der zurückgegebene Wert für leeres itr kann durch init angegeben werden. Es muss ein neutrales Element für min sein (d.h. das größer oder gleich jedem anderen Element ist), da nicht spezifiziert ist, ob init für nicht-leere Sammlungen verwendet wird.

Beispiele

julia> minimum(-20.5:10)
-20.5

julia> minimum([1,2,3])
1

julia> minimum([])
ERROR: ArgumentError: Reduzieren über eine leere Sammlung ist nicht erlaubt; ziehen Sie in Betracht, `init` an den Reducer zu übergeben
Stacktrace:
[...]

julia> minimum([]; init=Inf)
Inf

minimum(A::AbstractArray; dims)

Berechne den Minimalwert eines Arrays über die angegebenen Dimensionen. Siehe auch die min(a,b) Funktion, um das Minimum von zwei oder mehr Argumenten zu nehmen, die elementweise auf Arrays über min.(a,b) angewendet werden können.

Siehe auch: minimum!, extrema, findmin, argmin.

Beispiele

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

julia> minimum(A, dims=1)
1×2 Matrix{Int64}:
 1  2

julia> minimum(A, dims=2)
2×1 Matrix{Int64}:
 1
 3

minimum(f, A::AbstractArray; dims)

Berechne den Minimalwert, indem die Funktion f auf jedes Element eines Arrays über die angegebenen Dimensionen angewendet wird.

Beispiele

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

julia> minimum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 1  4

julia> minimum(abs2, A, dims=2)
2×1 Matrix{Int64}:
 1
 9

minimum!(r, A)

Berechne den Minimalwert von A über die Einzel-Dimensionen von r und schreibe die Ergebnisse in r.

Beispiele

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

julia> minimum!([1; 1], A)
2-element Vector{Int64}:
 1
 3

julia> minimum!([1 1], A)
1×2 Matrix{Int64}:
 1  2

extrema(itr; [init]) -> (mn, mx)

Berechne sowohl das Minimum mn als auch das Maximum mx Element in einem einzigen Durchgang und gebe sie als 2-Tupel zurück.

Der zurückgegebene Wert für leeres itr kann durch init festgelegt werden. Es muss ein 2-Tupel sein, dessen erstes und zweites Element neutrale Elemente für min und max sind (d.h. die größer/kleiner oder gleich jedem anderen Element sind). Folglich wird das zurückgegebene (mn, mx) Tupel, wenn itr leer ist, die Bedingung mn ≥ mx erfüllen. Wenn init angegeben ist, kann es auch für nicht-leeres itr verwendet werden.

Beispiele

julia> extrema(2:10)
(2, 10)

julia> extrema([9,pi,4.5])
(3.141592653589793, 9.0)

julia> extrema([]; init = (Inf, -Inf))
(Inf, -Inf)

extrema(f, itr; [init]) -> (mn, mx)

Berechne sowohl das Minimum mn als auch das Maximum mx von f, angewendet auf jedes Element in itr, und gib sie als 2-Tupel zurück. Es wird nur ein Durchlauf über itr gemacht.

Der zurückgegebene Wert für ein leeres itr kann durch init spezifiziert werden. Es muss ein 2-Tupel sein, dessen erstes und zweites Element neutrale Elemente für min und max sind (d.h. die größer/kleiner als oder gleich jedem anderen Element sind). Es wird für nicht-leere Sammlungen verwendet. Hinweis: Es impliziert, dass für ein leeres itr der zurückgegebene Wert (mn, mx) die Bedingung mn ≥ mx erfüllt, obwohl für ein nicht-leeres itr die Bedingung mn ≤ mx erfüllt ist. Dies ist ein "paradoxer", aber dennoch erwarteter Effekt.

Beispiele

julia> extrema(sin, 0:π)
(0.0, 0.9092974268256817)

julia> extrema(sin, Real[]; init = (1.0, -1.0))  # gut, da -1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)

extrema(A::AbstractArray; dims) -> Array{Tuple}

Berechnet die minimalen und maximalen Elemente eines Arrays über die angegebenen Dimensionen.

Siehe auch: minimum, maximum, extrema!.

Beispiele

julia> A = reshape(Vector(1:2:16), (2,2,2))
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  5
 3  7

[:, :, 2] =
  9  13
 11  15

julia> extrema(A, dims = (1,2))
1×1×2 Array{Tuple{Int64, Int64}, 3}:
[:, :, 1] =
 (1, 7)

[:, :, 2] =
 (9, 15)

extrema(f, A::AbstractArray; dims) -> Array{Tuple}

Berechne das Minimum und Maximum von f, angewendet auf jedes Element in den angegebenen Dimensionen von A.

extrema!(r, A)

Berechne den minimalen und maximalen Wert von A über die Singleton-Dimensionen von r und schreibe die Ergebnisse in r.

Beispiele

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

julia> extrema!([(1, 1); (1, 1)], A)
2-element Vector{Tuple{Int64, Int64}}:
 (1, 2)
 (3, 4)

julia> extrema!([(1, 1);; (1, 1)], A)
1×2 Matrix{Tuple{Int64, Int64}}:
 (1, 3)  (2, 4)

argmax(r::AbstractRange)

Bereiche können mehrere maximale Elemente haben. In diesem Fall gibt argmax einen maximalen Index zurück, jedoch nicht unbedingt den ersten.

argmax(f, domain)

Gibt einen Wert x aus domain zurück, für den f(x) maximiert wird. Wenn es mehrere maximale Werte für f(x) gibt, wird der erste gefunden.

domain muss eine nicht leere Iterable sein.

Werte werden mit isless verglichen.

Siehe auch argmin, findmax.

Beispiele

julia> argmax(abs, -10:5)
-10

julia> argmax(cos, 0:π/2:2π)
0.0

argmax(itr)

Gibt den Index oder Schlüssel des maximalen Elements in einer Sammlung zurück. Wenn es mehrere maximale Elemente gibt, wird das erste zurückgegeben.

Die Sammlung darf nicht leer sein.

Die Indizes sind vom gleichen Typ wie die, die von keys(itr) und pairs(itr) zurückgegeben werden.

Werte werden mit isless verglichen.

Siehe auch: argmin, findmax.

Beispiele

julia> argmax([8, 0.1, -9, pi])
1

julia> argmax([1, 7, 7, 6])
2

julia> argmax([1, 7, 7, NaN])
4

argmax(A; dims) -> indices

Für eine Array-Eingabe gibt es die Indizes der maximalen Elemente über die angegebenen Dimensionen zurück. NaN wird als größer als alle anderen Werte außer missing behandelt.

Beispiele

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> argmax(A, dims=1)
1×2 Matrix{CartesianIndex{2}}:
 CartesianIndex(2, 1)  CartesianIndex(2, 2)

julia> argmax(A, dims=2)
2×1 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

argmin(r::AbstractRange)

Bereiche können mehrere minimale Elemente haben. In diesem Fall gibt argmin einen minimalen Index zurück, aber nicht unbedingt den ersten.

argmin(f, domain)

Gibt einen Wert x aus domain zurück, für den f(x) minimiert wird. Wenn es mehrere minimale Werte für f(x) gibt, wird der erste gefunden.

domain muss eine nicht leere Iterable sein.

NaN wird als kleiner als alle anderen Werte außer missing behandelt.

Siehe auch argmax, findmin.

Beispiele

julia> argmin(sign, -10:5)
-10

julia> argmin(x -> -x^3 + x^2 - 10, -5:5)
5

julia> argmin(acos, 0:0.1:1)
1.0

argmin(itr)

Gibt den Index oder Schlüssel des minimalen Elements in einer Sammlung zurück. Wenn es mehrere minimale Elemente gibt, wird das erste zurückgegeben.

Die Sammlung darf nicht leer sein.

Die Indizes sind vom gleichen Typ wie die, die von keys(itr) und pairs(itr) zurückgegeben werden.

NaN wird als kleiner als alle anderen Werte außer missing behandelt.

Siehe auch: argmax, findmin.

Beispiele

julia> argmin([8, 0.1, -9, pi])
3

julia> argmin([7, 1, 1, 6])
2

julia> argmin([7, 1, 1, NaN])
4

argmin(A; dims) -> Indizes

Für eine Array-Eingabe geben Sie die Indizes der minimalen Elemente über die angegebenen Dimensionen zurück. NaN wird als kleiner als alle anderen Werte außer missing behandelt.

Beispiele

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> argmin(A, dims=1)
1×2 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)

julia> argmin(A, dims=2)
2×1 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

findmax(f, domain) -> (f(x), index)

Gibt ein Paar aus einem Wert im Bildbereich (Ausgaben von f) und dem Index oder Schlüssel des entsprechenden Wertes im domain (Eingaben an f) zurück, sodass f(x) maximiert wird. Wenn es mehrere maximale Punkte gibt, wird der erste zurückgegeben.

domain muss ein nicht leeres iterierbares Objekt sein, das keys unterstützt. Indizes sind vom gleichen Typ wie die von keys(domain) zurückgegebenen.

Werte werden mit isless verglichen.

Beispiele

julia> findmax(identity, 5:9)
(9, 5)

julia> findmax(-, 1:10)
(-1, 1)

julia> findmax(first, [(1, :a), (3, :b), (3, :c)])
(3, 2)

julia> findmax(cos, 0:π/2:2π)
(1.0, 1)

findmax(itr) -> (x, index)

Gibt das maximale Element der Sammlung itr und seinen Index oder Schlüssel zurück. Wenn es mehrere maximale Elemente gibt, wird das erste zurückgegeben. Werte werden mit isless verglichen.

Indizes sind vom gleichen Typ wie die, die von keys(itr) und pairs(itr) zurückgegeben werden.

Siehe auch: findmin, argmax, maximum.

Beispiele

julia> findmax([8, 0.1, -9, pi])
(8.0, 1)

julia> findmax([1, 7, 7, 6])
(7, 2)

julia> findmax([1, 7, 7, NaN])
(NaN, 4)

findmax(A; dims) -> (maxval, index)

Für eine Array-Eingabe gibt es den Wert und den Index des Maximums über die angegebenen Dimensionen zurück. NaN wird als größer als alle anderen Werte außer missing behandelt.

Beispiele

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> findmax(A, dims=1)
([3.0 4.0], CartesianIndex{2}[CartesianIndex(2, 1) CartesianIndex(2, 2)])

julia> findmax(A, dims=2)
([2.0; 4.0;;], CartesianIndex{2}[CartesianIndex(1, 2); CartesianIndex(2, 2);;])

findmax(f, A; dims) -> (f(x), index)

Für eine Array-Eingabe gibt es den Wert im Bildbereich und den Index des entsprechenden Wertes zurück, der f über die gegebenen Dimensionen maximiert.

Beispiele

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

julia> findmax(abs2, A, dims=1)
([1.0 4.0], CartesianIndex{2}[CartesianIndex(1, 1) CartesianIndex(2, 2)])

julia> findmax(abs2, A, dims=2)
([1.0; 4.0;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 2);;])

findmin(f, domain) -> (f(x), index)

Gibt ein Paar aus einem Wert im Wertebereich (Ausgaben von f) und dem Index oder Schlüssel des entsprechenden Wertes im domain (Eingaben an f) zurück, sodass f(x) minimiert wird. Wenn es mehrere minimale Punkte gibt, wird der erste zurückgegeben.

domain muss ein nicht leeres iterierbares Objekt sein.

Indizes sind vom gleichen Typ wie die von keys(domain) und pairs(domain) zurückgegebenen.

NaN wird als kleiner als alle anderen Werte außer missing behandelt.

Beispiele

julia> findmin(identity, 5:9)
(5, 1)

julia> findmin(-, 1:10)
(-10, 10)

julia> findmin(first, [(2, :a), (2, :b), (3, :c)])
(2, 1)

julia> findmin(cos, 0:π/2:2π)
(-1.0, 3)

findmin(itr) -> (x, index)

Gibt das minimale Element der Sammlung itr und seinen Index oder Schlüssel zurück. Wenn es mehrere minimale Elemente gibt, wird das erste zurückgegeben. NaN wird als kleiner als alle anderen Werte außer missing behandelt.

Die Indizes sind vom gleichen Typ wie die, die von keys(itr) und pairs(itr) zurückgegeben werden.

Siehe auch: findmax, argmin, minimum.

Beispiele

julia> findmin([8, 0.1, -9, pi])
(-9.0, 3)

julia> findmin([1, 7, 7, 6])
(1, 1)

julia> findmin([1, 7, 7, NaN])
(NaN, 4)

findmin(A; dims) -> (minval, index)

Für eine Array-Eingabe gibt es den Wert und den Index des Minimums über die angegebenen Dimensionen zurück. NaN wird als kleiner als alle anderen Werte außer missing behandelt.

Beispiele

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> findmin(A, dims=1)
([1.0 2.0], CartesianIndex{2}[CartesianIndex(1, 1) CartesianIndex(1, 2)])

julia> findmin(A, dims=2)
([1.0; 3.0;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 1);;])

findmin(f, A; dims) -> (f(x), index)

Für eine Array-Eingabe gibt es den Wert im Wertebereich und den Index des entsprechenden Wertes zurück, der f über die angegebenen Dimensionen minimiert.

Beispiele

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

julia> findmin(abs2, A, dims=1)
([0.25 1.0], CartesianIndex{2}[CartesianIndex(2, 1) CartesianIndex(1, 2)])

julia> findmin(abs2, A, dims=2)
([1.0; 0.25;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 1);;])

findmax!(rval, rind, A) -> (maxval, index)

Finde das Maximum von A und den entsprechenden linearen Index entlang der Singleton-Dimensionen von rval und rind, und speichere die Ergebnisse in rval und rind. NaN wird als größer als alle anderen Werte außer missing behandelt.

findmin!(rval, rind, A) -> (minval, index)

Finde das Minimum von A und den entsprechenden linearen Index entlang der Singleton-Dimensionen von rval und rind, und speichere die Ergebnisse in rval und rind. NaN wird als kleiner als alle anderen Werte außer missing behandelt.

sum(f, itr; [init])

Summiere die Ergebnisse des Aufrufs der Funktion f für jedes Element von itr.

Der Rückgabetyp ist Int für vorzeichenbehaftete Ganzzahlen, die kleiner als die Systemwortgröße sind, und UInt für vorzeichenlose Ganzzahlen, die kleiner als die Systemwortgröße sind. Für alle anderen Argumente wird ein gemeinsamer Rückgabetyp gefunden, zu dem alle Argumente befördert werden.

Der Wert, der für ein leeres itr zurückgegeben wird, kann durch init angegeben werden. Es muss die additive Identität (d.h. null) sein, da nicht spezifiziert ist, ob init für nicht leere Sammlungen verwendet wird.

Beispiele

julia> sum(abs2, [2; 3; 4])
29

Beachte den wichtigen Unterschied zwischen sum(A) und reduce(+, A) für Arrays mit kleinem Ganzzahl-Elementtyp:

julia> sum(Int8[100, 28])
128

julia> reduce(+, Int8[100, 28])
-128

Im ersteren Fall werden die Ganzzahlen auf die Systemwortgröße erweitert, und daher ist das Ergebnis 128. Im letzteren Fall findet keine solche Erweiterung statt, und der Überlauf der Ganzzahlen führt zu -128.

sum(itr; [init])

Gibt die Summe aller Elemente in einer Sammlung zurück.

Der Rückgabetyp ist Int für vorzeichenbehaftete Ganzzahlen, die kleiner als die Systemwortgröße sind, und UInt für vorzeichenlose Ganzzahlen, die kleiner als die Systemwortgröße sind. Für alle anderen Argumente wird ein gemeinsamer Rückgabetyp gefunden, zu dem alle Argumente befördert werden.

Der Wert, der für leeres itr zurückgegeben wird, kann durch init angegeben werden. Es muss die additive Identität (d.h. null) sein, da nicht spezifiziert ist, ob init für nicht leere Sammlungen verwendet wird.

Siehe auch: reduce, mapreduce, count, union.

Beispiele

julia> sum(1:20)
210

julia> sum(1:20; init = 0.0)
210.0

sum(A::AbstractArray; dims)

Summiere Elemente eines Arrays über die angegebenen Dimensionen.

Beispiele

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

julia> sum(A, dims=1)
1×2 Matrix{Int64}:
 4  6

julia> sum(A, dims=2)
2×1 Matrix{Int64}:
 3
 7

sum(f, A::AbstractArray; dims)

Summiere die Ergebnisse des Aufrufs der Funktion f auf jedes Element eines Arrays über die angegebenen Dimensionen.

Beispiele

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

julia> sum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 10  20

julia> sum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  5
 25

sum!(r, A)

Summiere die Elemente von A über die Einzel-Dimensionen von r und schreibe die Ergebnisse in r.

Beispiele

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

julia> sum!([1; 1], A)
2-element Vector{Int64}:
 3
 7

julia> sum!([1 1], A)
1×2 Matrix{Int64}:
 4  6

prod(f, itr; [init])

Gibt das Produkt von f zurück, das auf jedes Element von itr angewendet wird.

Der Rückgabewert ist Int für vorzeichenbehaftete Ganzzahlen, die kleiner als die Systemwortgröße sind, und UInt für vorzeichenlose Ganzzahlen, die kleiner als die Systemwortgröße sind. Für alle anderen Argumente wird ein gemeinsamer Rückgabewert gefunden, zu dem alle Argumente befördert werden.

Der Wert, der für leeres itr zurückgegeben wird, kann durch init angegeben werden. Es muss die multiplikative Identität (d.h. eins) sein, da nicht spezifiziert ist, ob init für nicht leere Sammlungen verwendet wird.

Beispiele

julia> prod(abs2, [2; 3; 4])
576

prod(itr; [init])

Gibt das Produkt aller Elemente einer Sammlung zurück.

Der Rückgabewert ist Int für vorzeichenbehaftete Ganzzahlen, die kleiner als die Systemwortgröße sind, und UInt für vorzeichenlose Ganzzahlen, die kleiner als die Systemwortgröße sind. Für alle anderen Argumente wird ein gemeinsamer Rückgabewert gefunden, zu dem alle Argumente befördert werden.

Der Wert, der für leere itr zurückgegeben wird, kann durch init angegeben werden. Es muss die multiplikative Identität (d.h. eins) sein, da nicht spezifiziert ist, ob init für nicht leere Sammlungen verwendet wird.

Siehe auch: reduce, cumprod, any.

Beispiele

julia> prod(1:5)
120

julia> prod(1:5; init = 1.0)
120.0

prod(A::AbstractArray; dims)

Multipliziere Elemente eines Arrays über die angegebenen Dimensionen.

Beispiele

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

julia> prod(A, dims=1)
1×2 Matrix{Int64}:
 3  8

julia> prod(A, dims=2)
2×1 Matrix{Int64}:
  2
 12

prod(f, A::AbstractArray; dims)

Multiplizieren Sie die Ergebnisse des Aufrufs der Funktion f für jedes Element eines Arrays über die angegebenen Dimensionen.

Beispiele

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

julia> prod(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  64

julia> prod(abs2, A, dims=2)
2×1 Matrix{Int64}:
   4
 144

prod!(r, A)

Multipliziere die Elemente von A über die Einzel-Dimensionen von r und schreibe die Ergebnisse in r.

Beispiele

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

julia> prod!([1; 1], A)
2-element Vector{Int64}:
  2
 12

julia> prod!([1 1], A)
1×2 Matrix{Int64}:
 3  8

any(itr) -> Bool

Überprüfen, ob Elemente einer booleschen Sammlung true sind, und true zurückgeben, sobald der erste true-Wert in itr gefunden wird (Kurzschluss). Um bei false einen Kurzschluss zu machen, verwenden Sie all.

Wenn die Eingabe missing Werte enthält, geben Sie missing zurück, wenn alle nicht fehlenden Werte false sind (oder äquivalent, wenn die Eingabe keinen true-Wert enthält), gemäß der dreiwertigen Logik.

Siehe auch: all, count, sum, |, , ||.

Beispiele

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> any(a)
true

julia> any((println(i); v) for (i, v) in enumerate(a))
1
true

julia> any([missing, true])
true

julia> any([false, missing])
missing

any(p, itr) -> Bool

Bestimmen Sie, ob das Prädikat p für irgendein Element von itr true zurückgibt, und geben Sie true zurück, sobald das erste Element in itr gefunden wird, für das p true zurückgibt (Short-Circuiting). Um bei false einen Short-Circuit zu machen, verwenden Sie all.

Wenn die Eingabe missing Werte enthält, geben Sie missing zurück, wenn alle nicht fehlenden Werte false sind (oder äquivalent, wenn die Eingabe keinen true Wert enthält), gemäß der dreiwertigen Logik.

Beispiele

julia> any(i->(4<=i<=6), [3,5,7])
true

julia> any(i -> (println(i); i > 3), 1:10)
1
2
3
4
true

julia> any(i -> i > 0, [1, missing])
true

julia> any(i -> i > 0, [-1, missing])
missing

julia> any(i -> i > 0, [-1, 0])
false

any!(r, A)

Überprüfen Sie, ob Werte in A entlang der Singleton-Dimensionen von r true sind, und schreiben Sie die Ergebnisse in r.

Beispiele

julia> A = [true false; true false]
2×2 Matrix{Bool}:
 1  0
 1  0

julia> any!([1; 1], A)
2-element Vector{Int64}:
 1
 1

julia> any!([1 1], A)
1×2 Matrix{Int64}:
 1  0

all(itr) -> Bool

Überprüfen, ob alle Elemente einer booleschen Sammlung true sind, und false zurückgeben, sobald der erste false-Wert in itr gefunden wird (Short-Circuiting). Um bei true einen Short-Circuit zu machen, verwenden Sie any.

Wenn die Eingabe missing Werte enthält, geben Sie missing zurück, wenn alle nicht fehlenden Werte true sind (oder äquivalent, wenn die Eingabe keinen false-Wert enthält), gemäß der dreiwertigen Logik.

Siehe auch: all!, any, count, &, , &&, allunique.

Beispiele

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> all(a)
false

julia> all((println(i); v) for (i, v) in enumerate(a))
1
2
false

julia> all([missing, false])
false

julia> all([true, missing])
missing

all(p, itr) -> Bool

Bestimmen Sie, ob das Prädikat p für alle Elemente von itr true zurückgibt, und geben Sie false zurück, sobald das erste Element in itr gefunden wird, für das p false zurückgibt (Short-Circuiting). Um bei true einen Short-Circuit zu machen, verwenden Sie any.

Wenn die Eingabe missing Werte enthält, geben Sie missing zurück, wenn alle nicht fehlenden Werte true sind (oder äquivalent, wenn die Eingabe keinen false Wert enthält), gemäß der dreiwertigen Logik.

Beispiele

julia> all(i->(4<=i<=6), [4,5,6])
true

julia> all(i -> (println(i); i < 3), 1:10)
1
2
3
false

julia> all(i -> i > 0, [1, missing])
missing

julia> all(i -> i > 0, [-1, missing])
false

julia> all(i -> i > 0, [1, 2])
true

all!(r, A)

Überprüfen Sie, ob alle Werte in A entlang der Singleton-Dimensionen von r true sind, und schreiben Sie die Ergebnisse in r.

Beispiele

julia> A = [true false; true false]
2×2 Matrix{Bool}:
 1  0
 1  0

julia> all!([1; 1], A)
2-element Vector{Int64}:
 0
 0

julia> all!([1 1], A)
1×2 Matrix{Int64}:
 1  0

count([f=identity,] itr; init=0) -> Integer

Zähle die Anzahl der Elemente in itr, für die die Funktion f true zurückgibt. Wenn f weggelassen wird, zähle die Anzahl der true-Elemente in itr (das sollte eine Sammlung von booleschen Werten sein). init gibt optional den Wert an, von dem aus gezählt werden soll, und bestimmt somit auch den Ausgabetyp.

Siehe auch: any, sum.

Beispiele

julia> count(i->(4<=i<=6), [2,3,4,5,6])
3

julia> count([true, false, true, true])
3

julia> count(>(3), 1:7, init=0x03)
0x07

count(
    pattern::Union{AbstractChar,AbstractString,AbstractPattern},
    string::AbstractString;
    overlap::Bool = false,
)

Gibt die Anzahl der Übereinstimmungen für pattern in string zurück. Dies entspricht dem Aufruf von length(findall(pattern, string)), ist jedoch effizienter.

Wenn overlap=true, dürfen die übereinstimmenden Sequenzen sich in den Indizes des ursprünglichen Strings überlappen, andernfalls müssen sie aus disjunkten Zeichenbereichen stammen.

Beispiele

julia> count('a', "JuliaLang")
2

julia> count(r"a(.)a", "cabacabac", overlap=true)
3

julia> count(r"a(.)a", "cabacabac")
2

count([f=identity,] A::AbstractArray; dims=:)

Zähle die Anzahl der Elemente in A, für die f true zurückgibt, über die angegebenen Dimensionen.

Beispiele

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

julia> count(<=(2), A, dims=1)
1×2 Matrix{Int64}:
 1  1

julia> count(<=(2), A, dims=2)
2×1 Matrix{Int64}:
 2
 0

foreach(f, c...) -> Nichts

Rufen Sie die Funktion f für jedes Element des iterierbaren c auf. Bei mehreren iterierbaren Argumenten wird f elementweise aufgerufen, und die Iteration stoppt, wenn ein Iterator beendet ist.

foreach sollte anstelle von map verwendet werden, wenn die Ergebnisse von f nicht benötigt werden, zum Beispiel in foreach(println, array).

Beispiele

julia> tri = 1:3:7; res = Int[];

julia> foreach(x -> push!(res, x^2), tri)

julia> res
3-element Vector{Int64}:
  1
 16
 49

julia> foreach((x, y) -> println(x, " mit ", y), tri, 'a':'z')
1 mit a
4 mit b
7 mit c

map(f, c...) -> Sammlung

Transformiere die Sammlung c, indem f auf jedes Element angewendet wird. Bei mehreren Sammlungsargumenten f elementweise anwenden und stoppen, wenn eine von ihnen erschöpft ist.

Siehe auch map!, foreach, mapreduce, mapslices, zip, Iterators.map.

Beispiele

julia> map(x -> x * 2, [1, 2, 3])
3-element Vector{Int64}:
 2
 4
 6

julia> map(+, [1, 2, 3], [10, 20, 30, 400, 5000])
3-element Vector{Int64}:
 11
 22
 33

map(f, A::AbstractArray...) -> N-array

Wenn man auf mehrdimensionale Arrays mit derselben ndims wirkt, müssen sie alle dieselben axes haben, und das Ergebnis wird ebenfalls so sein.

Siehe auch broadcast, das unterschiedliche Größen erlaubt.

Beispiele

julia> map(//, [1 2; 3 4], [4 3; 2 1])
2×2 Matrix{Rational{Int64}}:
 1//4  2//3
 3//2  4//1

julia> map(+, [1 2; 3 4], zeros(2,1))
ERROR: DimensionMismatch

julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # iteriert, bis das 3. erschöpft ist
3-element Vector{Float64}:
   2.0
  13.0
 102.0

map!(funktion, ziel, sammlung...)

Wie map, aber speichert das Ergebnis in ziel anstelle einer neuen Sammlung. ziel muss mindestens so groß sein wie die kleinste Sammlung.

Siehe auch: map, foreach, zip, copyto!.

Beispiele

julia> a = zeros(3);

julia> map!(x -> x * 2, a, [1, 2, 3]);

julia> a
3-element Vector{Float64}:
 2.0
 4.0
 6.0

julia> map!(+, zeros(Int, 5), 100:999, 1:3)
5-element Vector{Int64}:
 101
 103
 105
   0
   0

map!(f, values(dict::AbstractDict))

Modifiziert dict, indem jeder Wert von val in f(val) umgewandelt wird. Beachten Sie, dass der Typ von dict nicht geändert werden kann: Wenn f(val) kein Beispiel des Wertetyps von dict ist, wird es, wenn möglich, in den Wertetyp umgewandelt, andernfalls wird ein Fehler ausgelöst.

Beispiele

julia> d = Dict(:a => 1, :b => 2)
Dict{Symbol, Int64} mit 2 Einträgen:
  :a => 1
  :b => 2

julia> map!(v -> v-1, values(d))
ValueIterator für ein Dict{Symbol, Int64} mit 2 Einträgen. Werte:
  0
  1

mapreduce(f, op, itrs...; [init])

Wenden Sie die Funktion f auf jedes Element(e) in itrs an und reduzieren Sie dann das Ergebnis mit der binären Funktion op. Wenn angegeben, muss init ein neutrales Element für op sein, das für leere Sammlungen zurückgegeben wird. Es ist nicht festgelegt, ob init für nicht-leere Sammlungen verwendet wird. Im Allgemeinen ist es notwendig, init bereitzustellen, um mit leeren Sammlungen zu arbeiten.

mapreduce ist funktional äquivalent zu einem Aufruf von reduce(op, map(f, itr); init=init), wird jedoch im Allgemeinen schneller ausgeführt, da keine Zwischenkollektion erstellt werden muss. Siehe Dokumentation für reduce und map.

Beispiele

julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
14

Die Assoziativität der Reduktion ist implementationsabhängig. Darüber hinaus können einige Implementierungen den Rückgabewert von f für Elemente wiederverwenden, die mehrfach in itr erscheinen. Verwenden Sie stattdessen mapfoldl oder mapfoldr für garantierte linke oder rechte Assoziativität und die Ausführung von f für jeden Wert.

mapfoldl(f, op, itr; [init])

Wie mapreduce, aber mit garantierter linker Assoziativität, wie in foldl. Wenn angegeben, wird das Schlüsselwort-Argument init genau einmal verwendet. Im Allgemeinen ist es notwendig, init bereitzustellen, um mit leeren Sammlungen zu arbeiten.

mapfoldr(f, op, itr; [init])

Wie mapreduce, aber mit garantierter rechter Assoziativität, wie in foldr. Wenn angegeben, wird das Schlüsselwortargument init genau einmal verwendet. Im Allgemeinen ist es notwendig, init bereitzustellen, um mit leeren Sammlungen zu arbeiten.

first(coll)

Holen Sie sich das erste Element einer iterierbaren Sammlung. Gibt den Startpunkt eines AbstractRange zurück, auch wenn er leer ist.

Siehe auch: only, firstindex, last.

Beispiele

julia> first(2:2:10)
2

julia> first([1; 2; 3; 4])
1

first(itr, n::Integer)

Holen Sie sich die ersten n Elemente der iterierbaren Sammlung itr, oder weniger Elemente, wenn itr nicht lang genug ist.

Siehe auch: startswith, Iterators.take.

Beispiele

julia> first(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "foo"
 "bar"

julia> first(1:6, 10)
1:6

julia> first(Bool[], 1)
Bool[]

first(s::AbstractString, n::Integer)

Holen Sie sich eine Zeichenkette, die aus den ersten n Zeichen von s besteht.

Beispiele

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

last(coll)

Holen Sie sich das letzte Element einer geordneten Sammlung, wenn es in O(1) Zeit berechnet werden kann. Dies wird erreicht, indem lastindex aufgerufen wird, um den letzten Index zu erhalten. Gibt den Endpunkt eines AbstractRange zurück, auch wenn er leer ist.

Siehe auch first, endswith.

Beispiele

julia> last(1:2:10)
9

julia> last([1; 2; 3; 4])
4

last(itr, n::Integer)

Holen Sie sich die letzten n Elemente der iterierbaren Sammlung itr, oder weniger Elemente, wenn itr nicht lang genug ist.

Beispiele

julia> last(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "bar"
 "qux"

julia> last(1:6, 10)
1:6

julia> last(Float64[], 1)
Float64[]

last(s::AbstractString, n::Integer)

Holen Sie sich eine Zeichenkette, die aus den letzten n Zeichen von s besteht.

Beispiele

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

front(x::Tuple)::Tuple

Gibt ein Tuple zurück, das aus allen Komponenten von x besteht, außer der letzten.

Siehe auch: first, tail.

Beispiele

julia> Base.front((1,2,3))
(1, 2)

julia> Base.front(())
ERROR: ArgumentError: Kann front nicht auf einem leeren Tuple aufrufen.

tail(x::Tuple)::Tuple

Gibt ein Tuple zurück, das aus allen Komponenten von x besteht, außer der ersten.

Siehe auch: front, rest, first, Iterators.peel.

Beispiele

julia> Base.tail((1,2,3))
(2, 3)

julia> Base.tail(())
ERROR: ArgumentError: Kann tail nicht auf einem leeren Tuple aufrufen.

step(r)

Holen Sie sich die Schrittgröße eines AbstractRange Objekts.

Beispiele

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

julia> step(range(2.5, stop=10.9, length=85))
0.1

collect(collection)

Gibt ein Array aller Elemente in einer Sammlung oder einem Iterator zurück. Für Wörterbücher wird ein Vector von key=>value Pairs zurückgegeben. Wenn das Argument array-ähnlich ist oder ein Iterator mit dem HasShape Trait ist, hat das Ergebnis die gleiche Form und Anzahl der Dimensionen wie das Argument.

Wird von Komprehensionen verwendet, um einen Generatorausdruck in ein Array umzuwandeln. Daher kann bei Generatoren die eckige Klammernotation anstelle des Aufrufs von collect verwendet werden, siehe zweites Beispiel.

Beispiele

Sammeln von Elementen aus einer UnitRange{Int64}-Sammlung:

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

Sammeln von Elementen aus einem Generator (gleiche Ausgabe wie [x^2 for x in 1:3]):

julia> collect(x^2 for x in 1:3)
3-element Vector{Int64}:
 1
 4
 9

collect(element_type, collection)

Gibt ein Array mit dem angegebenen Elementtyp aller Elemente in einer Sammlung oder iterierbaren Struktur zurück. Das Ergebnis hat die gleiche Form und Anzahl der Dimensionen wie collection.

Beispiele

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

filter(f, a)

Gibt eine Kopie der Sammlung a zurück, wobei Elemente entfernt werden, für die f false ist. Die Funktion f erhält ein Argument.

Siehe auch: filter!, Iterators.filter.

Beispiele

julia> a = 1:10
1:10

julia> filter(isodd, a)
5-element Vector{Int64}:
 1
 3
 5
 7
 9

filter(f)

Erstellen Sie eine Funktion, die ihre Argumente mit der Funktion f unter Verwendung von filter filtert, d.h. eine Funktion, die äquivalent zu x -> filter(f, x) ist.

Die zurückgegebene Funktion ist vom Typ Base.Fix1{typeof(filter)}, die verwendet werden kann, um spezialisierte Methoden zu implementieren.

Beispiele

julia> (1, 2, Inf, 4, NaN, 6) |> filter(isfinite)
(1, 2, 4, 6)

julia> map(filter(iseven), [1:3, 2:4, 3:5])
3-element Vector{Vector{Int64}}:
 [2]
 [2, 4]
 [4]

filter(f, d::AbstractDict)

Gibt eine Kopie von d zurück, wobei Elemente entfernt werden, für die f false ist. Die Funktion f erhält key=>value Paare.

Beispiele

julia> d = Dict(1=>"a", 2=>"b")
Dict{Int64, String} mit 2 Einträgen:
  2 => "b"
  1 => "a"

julia> filter(p->isodd(p.first), d)
Dict{Int64, String} mit 1 Eintrag:
  1 => "a"

filter(f, itr::SkipMissing{<:AbstractArray})

Gibt einen Vektor zurück, der dem Array ähnelt, das vom gegebenen SkipMissing-Iterator umschlossen ist, jedoch mit allen fehlenden Elementen und denen, für die f false zurückgibt, entfernt.

Beispiele

julia> x = [1 2; missing 4]
2×2 Matrix{Union{Missing, Int64}}:
 1         2
  missing  4

julia> filter(isodd, skipmissing(x))
1-element Vector{Int64}:
 1

filter!(f, a)

Aktualisiert die Sammlung a, indem Elemente entfernt werden, für die f false ist. Die Funktion f erhält ein Argument.

Beispiele

julia> filter!(isodd, Vector(1:10))
5-element Vector{Int64}:
 1
 3
 5
 7
 9

filter!(f, d::AbstractDict)

Aktualisiert d, indem Elemente entfernt werden, für die f false ist. Die Funktion f erhält key=>value Paare.

Beispiele

julia> d = Dict(1=>"a", 2=>"b", 3=>"c")
Dict{Int64, String} mit 3 Einträgen:
  2 => "b"
  3 => "c"
  1 => "a"

julia> filter!(p->isodd(p.first), d)
Dict{Int64, String} mit 2 Einträgen:
  3 => "c"
  1 => "a"

replace(A, old_new::Pair...; [count::Integer])

Gibt eine Kopie der Sammlung A zurück, in der für jedes Paar old=>new in old_new alle Vorkommen von old durch new ersetzt werden. Die Gleichheit wird mit isequal bestimmt. Wenn count angegeben ist, werden höchstens count Vorkommen insgesamt ersetzt.

Der Elementtyp des Ergebnisses wird unter Verwendung von Promotion (siehe promote_type) basierend auf dem Elementtyp von A und den Typen der new-Werte in den Paaren gewählt. Wenn count weggelassen wird und der Elementtyp von A ein Union ist, wird der Elementtyp des Ergebnisses keine Singleton-Typen enthalten, die durch Werte eines anderen Typs ersetzt werden: Zum Beispiel wird Union{T,Missing} zu T, wenn missing ersetzt wird.

Siehe auch replace!, splice!, delete!, insert!.

Beispiele

julia> replace([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Vector{Int64}:
 0
 4
 1
 3

julia> replace([1, missing], missing=>0)
2-element Vector{Int64}:
 1
 0

replace(new::Union{Function, Type}, A; [count::Integer])

Gibt eine Kopie von A zurück, in der jeder Wert x in A durch new(x) ersetzt wird. Wenn count angegeben ist, werden höchstens count Werte insgesamt ersetzt (Ersetzungen werden definiert als new(x) !== x).

Beispiele

julia> replace(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 2
 2
 6
 4

julia> replace(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64, Int64} mit 2 Einträgen:
  3 => 4
  1 => 3

replace!(A, old_new::Pair...; [count::Integer])

Für jedes Paar old=>new in old_new ersetze alle Vorkommen von old in der Sammlung A durch new. Die Gleichheit wird mit isequal bestimmt. Wenn count angegeben ist, dann ersetze höchstens count Vorkommen insgesamt. Siehe auch replace.

Beispiele

julia> replace!([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Vector{Int64}:
 0
 4
 1
 3

julia> replace!(Set([1, 2, 3]), 1=>0)
Set{Int64} mit 3 Elementen:
  0
  2
  3

replace!(new::Union{Function, Type}, A; [count::Integer])

Ersetze jedes Element x in der Sammlung A durch new(x). Wenn count angegeben ist, dann ersetze höchstens count Werte insgesamt (Ersatz wird definiert als new(x) !== x).

Beispiele

julia> replace!(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 2
 2
 6
 4

julia> replace!(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64, Int64} mit 2 Einträgen:
  3 => 4
  1 => 3

julia> replace!(x->2x, Set([3, 6]))
Set{Int64} mit 2 Elementen:
  6
  12

Base.rest(collection[, itr_state])

Generische Funktion zum Abrufen des Endes von collection, beginnend von einem bestimmten Iterationszustand itr_state. Gibt ein Tuple zurück, wenn collection selbst ein Tuple ist, einen Untertyp von AbstractVector, wenn collection ein AbstractArray ist, einen Untertyp von AbstractString, wenn collection ein AbstractString ist, und einen beliebigen Iterator, der andernfalls auf Iterators.rest(collection[, itr_state]) zurückfällt.

Kann für benutzerdefinierte Sammlungstypen überladen werden, um das Verhalten von slurping in assignments in der letzten Position anzupassen, wie a, b... = collection.

Siehe auch: first, Iterators.rest, Base.split_rest.

Beispiele

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

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.rest(a, state)
(1, [3, 2, 4])

Base.split_rest(collection, n::Int[, itr_state]) -> (rest_but_n, last_n)

Generische Funktion zum Teilen des Endes von collection, beginnend von einem bestimmten Iterationszustand itr_state. Gibt ein Tupel von zwei neuen Sammlungen zurück. Die erste enthält alle Elemente des Endes, außer den n letzten, die die zweite Sammlung bilden.

Der Typ der ersten Sammlung folgt im Allgemeinen dem von Base.rest, mit der Ausnahme, dass der Fallback-Fall nicht faul ist, sondern eifrig in einen Vektor gesammelt wird.

Kann für benutzerdefinierte Sammlungstypen überladen werden, um das Verhalten von slurping in assignments in nicht-finaler Position anzupassen, wie a, b..., c = collection.

Siehe auch: Base.rest.

Beispiele

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

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.split_rest(a, 1, state)
(1, ([3, 2], [4]))

getindex(collection, key...)

Ruft den Wert(e) ab, die am angegebenen Schlüssel oder Index innerhalb einer Sammlung gespeichert sind. Die Syntax a[i,j,...] wird vom Compiler in getindex(a, i, j, ...) umgewandelt.

Siehe auch get, keys, eachindex.

Beispiele

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} mit 2 Einträgen:
  "b" => 2
  "a" => 1

julia> getindex(A, "a")
1

setindex!(collection, value, key...)

Speichert den angegebenen Wert am angegebenen Schlüssel oder Index innerhalb einer Sammlung. Die Syntax a[i,j,...] = x wird vom Compiler in (setindex!(a, x, i, j, ...); x) umgewandelt.

Beispiele

julia> a = Dict("a"=>1)
Dict{String, Int64} mit 1 Eintrag:
  "a" => 1

julia> setindex!(a, 2, "b")
Dict{String, Int64} mit 2 Einträgen:
  "b" => 2
  "a" => 1

firstindex(collection) -> Integer
firstindex(collection, d) -> Integer

Gibt den ersten Index von collection zurück. Wenn d angegeben ist, gibt den ersten Index von collection entlang der Dimension d zurück.

Die Syntaxen A[begin] und A[1, begin] werden zu A[firstindex(A)] und A[1, firstindex(A, 2)] übersetzt.

Siehe auch: first, axes, lastindex, nextind.

Beispiele

julia> firstindex([1,2,4])
1

julia> firstindex(rand(3,4,5), 2)
1

lastindex(collection) -> Ganzzahl
lastindex(collection, d) -> Ganzzahl

Gibt den letzten Index von collection zurück. Wenn d angegeben ist, gibt den letzten Index von collection entlang der Dimension d zurück.

Die Syntaxen A[end] und A[end, end] werden zu A[lastindex(A)] und A[lastindex(A, 1), lastindex(A, 2)] umgewandelt.

Siehe auch: axes, firstindex, eachindex, prevind.

Beispiele

julia> lastindex([1,2,4])
3

julia> lastindex(rand(3,4,5), 2)
4

AbstractDict{K, V}

Obertyp für dictionary-ähnliche Typen mit Schlüsseln vom Typ K und Werten vom Typ V. Dict, IdDict und andere Typen sind Untertypen davon. Ein AbstractDict{K, V} sollte ein Iterator von Pair{K, V} sein.

Dict([itr])

Dict{K,V}() konstruiert eine Hash-Tabelle mit Schlüsseln vom Typ K und Werten vom Typ V. Schlüssel werden mit isequal verglichen und mit hash gehasht.

Bei einem einzelnen iterierbaren Argument wird ein Dict konstruiert, dessen Schlüssel-Wert-Paare aus 2-Tupeln (key,value) stammen, die vom Argument erzeugt werden.

Beispiele

julia> Dict([("A", 1), ("B", 2)])
Dict{String, Int64} mit 2 Einträgen:
  "B" => 2
  "A" => 1

Alternativ kann eine Sequenz von Paar-Argumenten übergeben werden.

julia> Dict("A"=>1, "B"=>2)
Dict{String, Int64} mit 2 Einträgen:
  "B" => 2
  "A" => 1

IdDict([itr])

IdDict{K,V}() konstruiert eine Hash-Tabelle unter Verwendung von objectid als Hash und === als Gleichheit mit Schlüsseln vom Typ K und Werten vom Typ V. Siehe Dict für weitere Hilfe und IdSet für die Set-Version davon.

Im folgenden Beispiel sind die Dict-Schlüssel alle isequal und werden daher gleich gehasht, sodass sie überschrieben werden. Das IdDict hasht nach Objekt-ID und bewahrt somit die 3 verschiedenen Schlüssel.

Beispiele

julia> Dict(true => "yes", 1 => "no", 1.0 => "maybe")
Dict{Real, String} mit 1 Eintrag:
  1.0 => "maybe"

julia> IdDict(true => "yes", 1 => "no", 1.0 => "maybe")
IdDict{Any, String} mit 3 Einträgen:
  true => "yes"
  1.0  => "maybe"
  1    => "no"

WeakKeyDict([itr])

WeakKeyDict() konstruiert eine Hashtabelle, in der die Schlüssel schwache Referenzen auf Objekte sind, die möglicherweise garbage collected werden, selbst wenn sie in einer Hashtabelle referenziert werden.

Siehe Dict für weitere Hilfe. Beachten Sie, dass WeakKeyDict im Gegensatz zu Dict die Schlüssel bei der Einfügung nicht konvertiert, da dies implizieren würde, dass das Schlüsselobjekt zuvor nirgendwo referenziert wurde.

Siehe auch WeakRef.

ImmutableDict

ImmutableDict ist ein Wörterbuch, das als unveränderliche verkettete Liste implementiert ist, was optimal für kleine Wörterbücher ist, die über viele einzelne Einfügungen erstellt werden. Es ist zu beachten, dass es nicht möglich ist, einen Wert zu entfernen, obwohl er teilweise überschrieben und verborgen werden kann, indem ein neuer Wert mit demselben Schlüssel eingefügt wird.

ImmutableDict(KV::Pair)

Erstellen Sie einen neuen Eintrag im ImmutableDict für ein key => value Paar

• verwenden Sie (key => value) in dict, um zu sehen, ob diese spezielle Kombination im Eigenschaften-Set enthalten ist
• verwenden Sie get(dict, key, default), um den aktuellsten Wert für einen bestimmten Schlüssel abzurufen

PersistentDict

PersistentDict ist ein Wörterbuch, das als Hash-Array-mapped Trie implementiert ist, was optimal für Situationen ist, in denen Sie Persistenz benötigen. Jede Operation gibt ein neues Wörterbuch zurück, das von dem vorherigen getrennt ist, aber die zugrunde liegende Implementierung ist speichereffizient und kann Speicherplatz über mehrere separate Wörterbücher hinweg teilen.

!!! Hinweis Es verhält sich wie ein IdDict.

PersistentDict(KV::Pair)

Beispiele

julia> dict = Base.PersistentDict(:a=>1)
Base.PersistentDict{Symbol, Int64} mit 1 Eintrag:
  :a => 1

julia> dict2 = Base.delete(dict, :a)
Base.PersistentDict{Symbol, Int64}()

julia> dict3 = Base.PersistentDict(dict, :a=>2)
Base.PersistentDict{Symbol, Int64} mit 1 Eintrag:
  :a => 2

haskey(collection, key) -> Bool

Bestimmen Sie, ob eine Sammlung eine Zuordnung für einen gegebenen key hat.

Beispiele

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} mit 2 Einträgen:
  'a' => 2
  'b' => 3

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

Gibt den Wert zurück, der für den angegebenen Schlüssel gespeichert ist, oder den angegebenen Standardwert, wenn keine Zuordnung für den Schlüssel vorhanden ist.

Beispiele

julia> d = Dict("a"=>1, "b"=>2);

julia> get(d, "a", 3)
1

julia> get(d, "c", 3)
3

get(f::Union{Function, Type}, collection, key)

Gibt den Wert zurück, der für den angegebenen Schlüssel gespeichert ist, oder wenn keine Zuordnung für den Schlüssel vorhanden ist, gibt f() zurück. Verwenden Sie get!, um auch den Standardwert im Wörterbuch zu speichern.

Dies ist dazu gedacht, mit der do-Block-Syntax aufgerufen zu werden

get(dict, key) do
    # Standardwert hier berechnet
    time()
end

get!(collection, key, default)

Gibt den Wert zurück, der für den angegebenen Schlüssel gespeichert ist, oder wenn keine Zuordnung für den Schlüssel vorhanden ist, speichere key => default und gebe default zurück.

Beispiele

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> get!(d, "a", 5)
1

julia> get!(d, "d", 4)
4

julia> d
Dict{String, Int64} mit 4 Einträgen:
  "c" => 3
  "b" => 2
  "a" => 1
  "d" => 4

get!(f::Union{Function, Type}, collection, key)

Gibt den Wert zurück, der für den angegebenen Schlüssel gespeichert ist, oder wenn keine Zuordnung für den Schlüssel vorhanden ist, speichere key => f(), und gebe f() zurück.

Dies ist dazu gedacht, mit der do-Block-Syntax aufgerufen zu werden.

Beispiele

julia> squares = Dict{Int, Int}();

julia> function get_square!(d, i)
           get!(d, i) do
               i^2
           end
       end
get_square! (generic function with 1 method)

julia> get_square!(squares, 2)
4

julia> squares
Dict{Int64, Int64} mit 1 Eintrag:
  2 => 4

getkey(collection, key, default)

Gibt den Schlüssel zurück, der dem Argument key entspricht, wenn er in collection vorhanden ist, andernfalls wird default zurückgegeben.

Beispiele

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} mit 2 Einträgen:
  'a' => 2
  'b' => 3

julia> getkey(D, 'a', 1)
'a': ASCII/Unicode U+0061 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

julia> getkey(D, 'd', 'a')
'a': ASCII/Unicode U+0061 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

delete!(collection, key)

Löschen Sie die Zuordnung für den angegebenen Schlüssel in einer Sammlung, falls vorhanden, und geben Sie die Sammlung zurück.

Beispiele

julia> d = Dict("a"=>1, "b"=>2)
Dict{String, Int64} mit 2 Einträgen:
  "b" => 2
  "a" => 1

julia> delete!(d, "b")
Dict{String, Int64} mit 1 Eintrag:
  "a" => 1

julia> delete!(d, "b") # d bleibt unverändert
Dict{String, Int64} mit 1 Eintrag:
  "a" => 1

pop!(collection, key[, default])

Löschen und Rückgabe der Zuordnung für key, wenn sie in collection vorhanden ist, andernfalls Rückgabe von default oder Auslösen eines Fehlers, wenn default nicht angegeben ist.

Beispiele

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

keys(iterator)

Für einen Iterator oder eine Sammlung, die Schlüssel und Werte hat (z. B. Arrays und Dictionaries), gibt einen Iterator über die Schlüssel zurück.

values(iterator)

Für einen Iterator oder eine Sammlung, die Schlüssel und Werte hat, gibt es einen Iterator über die Werte zurück. Diese Funktion gibt standardmäßig einfach ihr Argument zurück, da die Elemente eines allgemeinen Iterators normalerweise als seine "Werte" betrachtet werden.

Beispiele

julia> d = Dict("a"=>1, "b"=>2);

julia> values(d)
ValueIterator für ein Dict{String, Int64} mit 2 Einträgen. Werte:
  2
  1

julia> values([2])
1-element Vector{Int64}:
 2

values(a::AbstractDict)

Gibt einen Iterator über alle Werte in einer Sammlung zurück. collect(values(a)) gibt ein Array von Werten zurück. Wenn die Werte intern in einer Hash-Tabelle gespeichert sind, wie es bei Dict der Fall ist, kann die Reihenfolge, in der sie zurückgegeben werden, variieren. Aber keys(a), values(a) und pairs(a) iterieren alle a und geben die Elemente in derselben Reihenfolge zurück.

Beispiele

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} mit 2 Einträgen:
  'a' => 2
  'b' => 3

julia> collect(values(D))
2-element Vector{Int64}:
 2
 3

pairs(IndexLinear(), A)
pairs(IndexCartesian(), A)
pairs(IndexStyle(A), A)

Ein Iterator, der auf jedes Element des Arrays A zugreift und i => x zurückgibt, wobei i der Index für das Element und x = A[i] ist. Identisch zu pairs(A), mit dem Unterschied, dass der Stil des Index ausgewählt werden kann. Ähnlich wie enumerate(A), mit dem Unterschied, dass i ein gültiger Index für A sein wird, während enumerate immer von 1 zählt, unabhängig von den Indizes von A.

Die Angabe von IndexLinear() stellt sicher, dass i eine ganze Zahl ist; die Angabe von IndexCartesian() stellt sicher, dass i ein Base.CartesianIndex ist; die Angabe von IndexStyle(A) wählt denjenigen aus, der als der native Indexierungsstil für das Array A definiert wurde.

Die Mutation der Grenzen des zugrunde liegenden Arrays macht diesen Iterator ungültig.

Beispiele

julia> A = ["a" "d"; "b" "e"; "c" "f"];

julia> for (index, value) in pairs(IndexStyle(A), A)
           println("$index $value")
       end
1 a
2 b
3 c
4 d
5 e
6 f

julia> S = view(A, 1:2, :);

julia> for (index, value) in pairs(IndexStyle(S), S)
           println("$index $value")
       end
CartesianIndex(1, 1) a
CartesianIndex(2, 1) b
CartesianIndex(1, 2) d
CartesianIndex(2, 2) e

Siehe auch IndexStyle, axes.

pairs(collection)

Gibt einen Iterator über key => value Paare für jede Sammlung zurück, die eine Menge von Schlüsseln einer Menge von Werten zuordnet. Dazu gehören Arrays, bei denen die Schlüssel die Array-Indizes sind. Wenn die Einträge intern in einer Hash-Tabelle gespeichert sind, wie es bei Dict der Fall ist, kann die Reihenfolge, in der sie zurückgegeben werden, variieren. Aber keys(a), values(a) und pairs(a) iterieren alle über a und geben die Elemente in derselben Reihenfolge zurück.

Beispiele

julia> a = Dict(zip(["a", "b", "c"], [1, 2, 3]))
Dict{String, Int64} mit 3 Einträgen:
  "c" => 3
  "b" => 2
  "a" => 1

julia> pairs(a)
Dict{String, Int64} mit 3 Einträgen:
  "c" => 3
  "b" => 2
  "a" => 1

julia> foreach(println, pairs(["a", "b", "c"]))
1 => "a"
2 => "b"
3 => "c"

julia> (;a=1, b=2, c=3) |> pairs |> collect
3-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2
 :c => 3

julia> (;a=1, b=2, c=3) |> collect
3-element Vector{Int64}:
 1
 2
 3

merge(initial::Face, others::Face...)

Fügen Sie die Eigenschaften des initial Gesichts und der anderen hinzu, wobei die späteren Gesichter Vorrang haben.

merge(d::AbstractDict, others::AbstractDict...)

Konstruiere eine zusammengeführte Sammlung aus den gegebenen Sammlungen. Falls notwendig, werden die Typen der resultierenden Sammlung angehoben, um die Typen der zusammengeführten Sammlungen zu berücksichtigen. Wenn der gleiche Schlüssel in einer anderen Sammlung vorhanden ist, wird der Wert für diesen Schlüssel der Wert sein, den er in der letzten aufgelisteten Sammlung hat. Siehe auch mergewith für eine benutzerdefinierte Handhabung von Werten mit dem gleichen Schlüssel.

Beispiele

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} mit 2 Einträgen:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} mit 2 Einträgen:
  "bar" => 4711
  "baz" => 17

julia> merge(a, b)
Dict{String, Float64} mit 3 Einträgen:
  "bar" => 4711.0
  "baz" => 17.0
  "foo" => 0.0

julia> merge(b, a)
Dict{String, Float64} mit 3 Einträgen:
  "bar" => 42.0
  "baz" => 17.0
  "foo" => 0.0

merge(a::NamedTuple, bs::NamedTuple...)

Konstruiere ein neues benanntes Tupel, indem zwei oder mehr vorhandene in einer linksassoziativen Weise zusammengeführt werden. Das Zusammenführen erfolgt von links nach rechts, zwischen Paaren von benannten Tupeln, und daher nehmen die Reihenfolge der Felder, die sowohl im links- als auch im rechtsseitigen benannten Tupel vorhanden sind, die gleiche Position ein, wie sie im linksseitigen benannten Tupel gefunden werden. Werte werden jedoch aus übereinstimmenden Feldern im rechtsseitigen benannten Tupel entnommen, das dieses Feld enthält. Felder, die nur im rechtsseitigen benannten Tupel eines Paares vorhanden sind, werden am Ende angehängt. Eine Rückfalloption wird implementiert, wenn nur ein einzelnes benanntes Tupel bereitgestellt wird, mit der Signatur merge(a::NamedTuple).

Beispiele

julia> merge((a=1, b=2, c=3), (b=4, d=5))
(a = 1, b = 4, c = 3, d = 5)

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

merge(a::NamedTuple, iterable)

Interpretieren Sie ein Iterable von Schlüssel-Wert-Paaren als benanntes Tupel und führen Sie eine Zusammenführung durch.

julia> merge((a=1, b=2, c=3), [:b=>4, :d=>5])
(a = 1, b = 4, c = 3, d = 5)

mergewith(combine, d::AbstractDict, others::AbstractDict...)
mergewith(combine)
merge(combine, d::AbstractDict, others::AbstractDict...)

Konstruiere eine zusammengeführte Sammlung aus den gegebenen Sammlungen. Falls notwendig, werden die Typen der resultierenden Sammlung angehoben, um die Typen der zusammengeführten Sammlungen zu berücksichtigen. Werte mit demselben Schlüssel werden mithilfe der Kombinationsfunktion kombiniert. Die curried Form mergewith(combine) gibt die Funktion (args...) -> mergewith(combine, args...) zurück.

Die Methode merge(combine::Union{Function,Type}, args...) als Alias von mergewith(combine, args...) ist weiterhin verfügbar für die Abwärtskompatibilität.

Beispiele

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} mit 2 Einträgen:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} mit 2 Einträgen:
  "bar" => 4711
  "baz" => 17

julia> mergewith(+, a, b)
Dict{String, Float64} mit 3 Einträgen:
  "bar" => 4753.0
  "baz" => 17.0
  "foo" => 0.0

julia> ans == mergewith(+)(a, b)
true

merge!(d::AbstractDict, others::AbstractDict...)

Aktualisiere die Sammlung mit Paaren aus den anderen Sammlungen. Siehe auch merge.

Beispiele

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> merge!(d1, d2);

julia> d1
Dict{Int64, Int64} mit 3 Einträgen:
  4 => 5
  3 => 4
  1 => 4

mergewith!(combine, d::AbstractDict, others::AbstractDict...) -> d
mergewith!(combine)
merge!(combine, d::AbstractDict, others::AbstractDict...) -> d

Aktualisieren Sie die Sammlung mit Paaren aus den anderen Sammlungen. Werte mit dem gleichen Schlüssel werden mit der Kombinationsfunktion kombiniert. Die curried Form mergewith!(combine) gibt die Funktion (args...) -> mergewith!(combine, args...) zurück.

Die Methode merge!(combine::Union{Function,Type}, args...) als Alias von mergewith!(combine, args...) ist weiterhin aus Gründen der Abwärtskompatibilität verfügbar.

Beispiele

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> mergewith!(+, d1, d2);

julia> d1
Dict{Int64, Int64} mit 3 Einträgen:
  4 => 5
  3 => 4
  1 => 6

julia> mergewith!(-, d1, d1);

julia> d1
Dict{Int64, Int64} mit 3 Einträgen:
  4 => 0
  3 => 0
  1 => 0

julia> foldl(mergewith!(+), [d1, d2]; init=Dict{Int64, Int64}())
Dict{Int64, Int64} mit 3 Einträgen:
  4 => 5
  3 => 0
  1 => 4

sizehint!(s, n; first::Bool=false, shrink::Bool=true) -> s

Schlagen Sie vor, dass die Sammlung s Kapazität für mindestens n Elemente reserviert. Das heißt, wenn Sie erwarten, dass Sie viele Werte in s einfügen müssen, können Sie die Kosten für inkrementelle Neuzuweisungen vermeiden, indem Sie dies einmal im Voraus tun; dies kann die Leistung verbessern.

Wenn first auf true gesetzt ist, wird zusätzlicher Platz vor dem Beginn der Sammlung reserviert. Auf diese Weise können nachfolgende Aufrufe von pushfirst! (anstatt von push!) schneller werden. Das Bereitstellen dieses Schlüssels kann zu einem Fehler führen, wenn die Sammlung nicht geordnet ist oder wenn pushfirst! für diese Sammlung nicht unterstützt wird.

Wenn shrink=true (der Standard), kann die Kapazität der Sammlung reduziert werden, wenn ihre aktuelle Kapazität größer als n ist.

Siehe auch resize!.

Hinweise zum Leistungsmodell

Für Typen, die sizehint! unterstützen,

1. push! und append! Methoden können im Allgemeinen (aber sind nicht verpflichtet) zusätzlichen Speicher vorab zu reservieren. Für Typen, die in Base implementiert sind, tun sie dies typischerweise, indem sie eine Heuristik verwenden, die für einen allgemeinen Anwendungsfall optimiert ist.
2. sizehint! kann diese Vorabreservierung steuern. Auch hier tut es dies typischerweise für Typen in Base.
3. empty! ist nahezu kostenfrei (und O(1)) für Typen, die diese Art der Vorabreservierung unterstützen.

keytype(T::Type{<:AbstractArray})
keytype(A::AbstractArray)

Gibt den Schlüsseltyp eines Arrays zurück. Dies entspricht dem eltype des Ergebnisses von keys(...) und wird hauptsächlich zur Kompatibilität mit der Dictionary-Schnittstelle bereitgestellt.

Beispiele

julia> keytype([1, 2, 3]) == Int
true

julia> keytype([1 2; 3 4])
CartesianIndex{2}

keytype(type)

Erhalte den Schlüsseltyp eines Dictionary-Typs. Verhält sich ähnlich wie eltype.

Beispiele

julia> keytype(Dict(Int32(1) => "foo"))
Int32

valtype(T::Type{<:AbstractArray})
valtype(A::AbstractArray)

Gibt den Werttyp eines Arrays zurück. Dies ist identisch zu eltype und wird hauptsächlich zur Kompatibilität mit der Dictionary-Schnittstelle bereitgestellt.

Beispiele

julia> valtype(["one", "two", "three"])
String

valtype(type)

Erhalte den Werttyp eines Dictionary-Typs. Verhält sich ähnlich wie eltype.

Beispiele

julia> valtype(Dict(Int32(1) => "foo"))
String

AbstractSet{T}

Obertyp für set-ähnliche Typen, deren Elemente vom Typ T sind. Set, BitSet und andere Typen sind Untertypen davon.

Set{T} <: AbstractSet{T}

Sets sind veränderliche Container, die schnelle Mitgliedschaftstests ermöglichen.

Sets haben effiziente Implementierungen von Mengenoperationen wie in, union und intersect. Elemente in einem Set sind einzigartig, wie durch die Definition von isequal der Elemente bestimmt. Die Reihenfolge der Elemente in einem Set ist ein Implementierungsdetail und kann nicht darauf vertraut werden.

Siehe auch: AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

Beispiele

julia> s = Set("aaBca")
Set{Char} mit 3 Elementen:
  'a'
  'c'
  'B'

julia> push!(s, 'b')
Set{Char} mit 4 Elementen:
  'a'
  'b'
  'B'
  'c'

julia> s = Set([NaN, 0.0, 1.0, 2.0]);

julia> -0.0 in s # isequal(0.0, -0.0) ist falsch
falsch

julia> NaN in s # isequal(NaN, NaN) ist wahr
wahr

BitSet([itr])

Konstruiere eine sortierte Menge von Ints, die durch das gegebene iterable Objekt erzeugt wird, oder eine leere Menge. Implementiert als Bit-String und daher für dichte Ganzzahlenmengen ausgelegt. Wenn die Menge spärlich sein wird (zum Beispiel, wenn sie einige sehr große Ganzzahlen enthält), verwende stattdessen Set.

IdSet{T}([itr])
IdSet()

IdSet{T}() konstruiert eine Menge (siehe Set), die === als Gleichheit mit Werten des Typs T verwendet.

Im folgenden Beispiel sind die Werte alle isequal, sodass sie in der gewöhnlichen Set überschrieben werden. Das IdSet vergleicht mit === und bewahrt somit die 3 unterschiedlichen Werte.

Beispiele

julia> Set(Any[true, 1, 1.0])
Set{Any} mit 1 Element:
  1.0

julia> IdSet{Any}(Any[true, 1, 1.0])
IdSet{Any} mit 3 Elementen:
  1.0
  1
  true

union(s, itrs...)
∪(s, itrs...)

Konstruiere ein Objekt, das alle unterschiedlichen Elemente aus allen Argumenten enthält.

Das erste Argument steuert, welche Art von Container zurückgegeben wird. Wenn dies ein Array ist, wird die Reihenfolge beibehalten, in der die Elemente zuerst erscheinen.

Unicode ∪ kann eingegeben werden, indem \cup geschrieben und dann die Tabulatortaste im Julia REPL und in vielen Editoren gedrückt wird. Dies ist ein infix Operator, der s ∪ itr ermöglicht.

Siehe auch unique, intersect, isdisjoint, vcat, Iterators.flatten.

Beispiele

julia> union([1, 2], [3])
3-element Vector{Int64}:
 1
 2
 3

julia> union([4 2 3 4 4], 1:3, 3.0)
4-element Vector{Float64}:
 4.0
 2.0
 3.0
 1.0

julia> (0, 0.0) ∪ (-0.0, NaN)
3-element Vector{Real}:
   0
  -0.0
 NaN

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

union!(s::Union{AbstractSet,AbstractVector}, itrs...)

Konstruiere die union der übergebenen Mengen und überschreibe s mit dem Ergebnis. Behalte die Reihenfolge bei Arrays bei.

Beispiele

julia> a = Set([3, 4, 5]);

julia> union!(a, 1:2:7);

julia> a
Set{Int64} mit 5 Elementen:
  5
  4
  7
  3
  1

intersect(s, itrs...)
∩(s, itrs...)

Konstruiere die Menge, die diejenigen Elemente enthält, die in allen Argumenten erscheinen.

Das erste Argument steuert, welche Art von Container zurückgegeben wird. Wenn dies ein Array ist, wird die Reihenfolge beibehalten, in der die Elemente zuerst erscheinen.

Unicode ∩ kann eingegeben werden, indem \cap geschrieben und dann die Tabulatortaste im Julia REPL und in vielen Editoren gedrückt wird. Dies ist ein infix Operator, der s ∩ itr ermöglicht.

Siehe auch setdiff, isdisjoint, issubset, issetequal.

Beispiele

julia> intersect([1, 2, 3], [3, 4, 5])
1-element Vector{Int64}:
 3

julia> intersect([1, 4, 4, 5, 6], [6, 4, 6, 7, 8])
2-element Vector{Int64}:
 4
 6

julia> intersect(1:16, 7:99)
7:16

julia> (0, 0.0) ∩ (-0.0, 0)
1-element Vector{Real}:
 0

julia> intersect(Set([1, 2]), BitSet([2, 3]), 1.0:10.0)
Set{Float64} mit 1 Element:
  2.0

setdiff(s, itrs...)

Konstruiere die Menge der Elemente in s, die jedoch nicht in einem der Iterierbaren in itrs enthalten sind. Behalte die Reihenfolge mit Arrays bei.

Siehe auch setdiff!, union und intersect.

Beispiele

julia> setdiff([1,2,3], [3,4,5])
2-element Vector{Int64}:
 1
 2

setdiff!(s, itrs...)

Entferne aus der Menge s (in-place) jedes Element aus jedem Iterable von itrs. Behalte die Reihenfolge bei Arrays bei.

Beispiele

julia> a = Set([1, 3, 4, 5]);

julia> setdiff!(a, 1:2:6);

julia> a
Set{Int64} mit 1 Element:
  4

symdiff(s, itrs...)

Konstruiere die symmetrische Differenz der Elemente in den übergebenen Mengen. Wenn s kein AbstractSet ist, wird die Reihenfolge beibehalten.

Siehe auch symdiff!, setdiff, union und intersect.

Beispiele

julia> symdiff([1,2,3], [3,4,5], [4,5,6])
3-element Vector{Int64}:
 1
 2
 6

julia> symdiff([1,2,1], [2, 1, 2])
Int64[]

symdiff!(s::Union{AbstractSet,AbstractVector}, itrs...)

Konstruiere die symmetrische Differenz der übergebenen Mengen und überschreibe s mit dem Ergebnis. Wenn s ein Array ist, bleibt die Reihenfolge erhalten. Beachte, dass in diesem Fall die Häufigkeit der Elemente wichtig ist.

intersect!(s::Union{AbstractSet,AbstractVector}, itrs...)

Kreuzt alle übergebenen Mengen und überschreibt s mit dem Ergebnis. Behalte die Reihenfolge bei Arrays bei.

issubset(a, b) -> Bool
⊆(a, b) -> Bool
⊇(b, a) -> Bool

Bestimmen Sie, ob jedes Element von a auch in b enthalten ist, unter Verwendung von in.

Siehe auch ⊊, ⊈, ∩, ∪, contains.

Beispiele

julia> issubset([1, 2], [1, 2, 3])
true

julia> [1, 2, 3] ⊆ [1, 2]
false

julia> [1, 2, 3] ⊇ [1, 2]
true

in!(x, s::AbstractSet) -> Bool

Wenn x in s ist, gibt true zurück. Andernfalls wird x in s eingefügt und false zurückgegeben. Dies ist äquivalent zu in(x, s) ? true : (push!(s, x); false), könnte jedoch eine effizientere Implementierung haben.

Siehe auch: in, push!, Set

Beispiele

julia> s = Set{Any}([1, 2, 3]); in!(4, s)
false

julia> length(s)
4

julia> in!(0x04, s)
true

julia> s
Set{Any} mit 4 Elementen:
  4
  2
  3
  1

⊈(a, b) -> Bool
⊉(b, a) -> Bool

Negation von ⊆ und ⊇, d.h. überprüft, dass a keine Teilmenge von b ist.

Siehe auch issubset (⊆), ⊊.

Beispiele

julia> (1, 2) ⊈ (2, 3)
true

julia> (1, 2) ⊈ (1, 2, 3)
false

⊊(a, b) -> Bool
⊋(b, a) -> Bool

Bestimmt, ob a eine Teilmenge von b ist, aber nicht gleich b.

Siehe auch issubset (⊆), ⊈.

Beispiele

julia> (1, 2) ⊊ (1, 2, 3)
true

julia> (1, 2) ⊊ (1, 2)
false

issetequal(a, b) -> Bool

Bestimmen Sie, ob a und b die gleichen Elemente haben. Entspricht a ⊆ b && b ⊆ a, ist aber effizienter, wenn möglich.

Siehe auch: isdisjoint, union.

Beispiele

julia> issetequal([1, 2], [1, 2, 3])
false

julia> issetequal([1, 2], [2, 1])
true

issetequal(x)

Erstellen Sie eine Funktion, die ihr Argument mit x unter Verwendung von issetequal vergleicht, d.h. eine Funktion, die äquivalent zu y -> issetequal(y, x) ist. Die zurückgegebene Funktion ist vom Typ Base.Fix2{typeof(issetequal)}, die verwendet werden kann, um spezialisierte Methoden zu implementieren.

isdisjoint(a, b) -> Bool

Bestimmen Sie, ob die Sammlungen a und b disjunkt sind. Entspricht isempty(a ∩ b), ist aber effizienter, wenn möglich.

Siehe auch: intersect, isempty, issetequal.

Beispiele

julia> isdisjoint([1, 2], [2, 3, 4])
false

julia> isdisjoint([3, 1], [2, 4])
true

isdisjoint(x)

Erstellen Sie eine Funktion, die ihr Argument mit x unter Verwendung von isdisjoint vergleicht, d.h. eine Funktion, die äquivalent zu y -> isdisjoint(y, x) ist. Die zurückgegebene Funktion ist vom Typ Base.Fix2{typeof(isdisjoint)}, die verwendet werden kann, um spezialisierte Methoden zu implementieren.

push!(collection, items...) -> collection

Fügen Sie ein oder mehrere items in collection ein. Wenn collection ein geordnetes Container ist, werden die Elemente am Ende (in der angegebenen Reihenfolge) eingefügt.

Beispiele

julia> push!([1, 2, 3], 4, 5, 6)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

Wenn collection geordnet ist, verwenden Sie append!, um alle Elemente einer anderen Sammlung hinzuzufügen. Das Ergebnis des vorhergehenden Beispiels ist äquivalent zu append!([1, 2, 3], [4, 5, 6]). Für AbstractSet-Objekte kann stattdessen union! verwendet werden.

Siehe sizehint! für Hinweise zum Leistungsmodell.

Siehe auch pushfirst!.

pop!(collection) -> item

Entfernt ein Element aus collection und gibt es zurück. Wenn collection ein geordnetes Container ist, wird das letzte Element zurückgegeben; für ungeordnete Container wird ein beliebiges Element zurückgegeben.

Siehe auch: popfirst!, popat!, delete!, deleteat!, splice! und push!.

Beispiele

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

julia> pop!(A)
3

julia> A
2-element Vector{Int64}:
 1
 2

julia> S = Set([1, 2])
Set{Int64} mit 2 Elementen:
  2
  1

julia> pop!(S)
2

julia> S
Set{Int64} mit 1 Element:
  1

julia> pop!(Dict(1=>2))
1 => 2

pop!(collection, key[, default])

Löschen und Rückgabe der Zuordnung für key, wenn sie in collection vorhanden ist, andernfalls Rückgabe von default oder Auslösen eines Fehlers, wenn default nicht angegeben ist.

Beispiele

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

popat!(a::Vector, i::Integer, [default])

Entfernt das Element an der angegebenen i und gibt es zurück. Nachfolgende Elemente werden verschoben, um die resultierende Lücke zu füllen. Wenn i kein gültiger Index für a ist, wird default zurückgegeben oder ein Fehler ausgelöst, wenn default nicht angegeben ist.

Siehe auch: pop!, popfirst!, deleteat!, splice!.

Beispiele

julia> a = [4, 3, 2, 1]; popat!(a, 2)
3

julia> a
3-element Vector{Int64}:
 4
 2
 1

julia> popat!(a, 4, missing)
missing

julia> popat!(a, 4)
ERROR: BoundsError: attempt to access 3-element Vector{Int64} at index [4]
[...]

pushfirst!(collection, items...) -> collection

Fügen Sie ein oder mehrere items am Anfang von collection ein.

Diese Funktion wird in vielen anderen Programmiersprachen unshift genannt.

Beispiele

julia> pushfirst!([1, 2, 3, 4], 5, 6)
6-element Vector{Int64}:
 5
 6
 1
 2
 3
 4

popfirst!(collection) -> item

Entfernt das erste item aus collection.

Diese Funktion wird in vielen anderen Programmiersprachen shift genannt.

Siehe auch: pop!, popat!, delete!.

Beispiele

julia> A = [1, 2, 3, 4, 5, 6]
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

julia> popfirst!(A)
1

julia> A
5-element Vector{Int64}:
 2
 3
 4
 5
 6

insert!(a::Vector, index::Integer, item)

Fügen Sie ein item in a an dem angegebenen index ein. index ist der Index von item im resultierenden a.

Siehe auch: push!, replace, popat!, splice!.

Beispiele

julia> insert!(Any[1:6;], 3, "here")
7-element Vector{Any}:
 1
 2
  "here"
 3
 4
 5
 6

deleteat!(a::Vector, i::Integer)

Entfernt das Element an der angegebenen i und gibt das modifizierte a zurück. Nachfolgende Elemente werden verschoben, um die resultierende Lücke zu füllen.

Siehe auch: keepat!, delete!, popat!, splice!.

Beispiele

julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
5-element Vector{Int64}:
 6
 4
 3
 2
 1

deleteat!(a::Vector, inds)

Entfernt die Elemente an den durch inds angegebenen Indizes und gibt das modifizierte a zurück. Nachfolgende Elemente werden verschoben, um die resultierende Lücke zu füllen.

inds kann entweder ein Iterator oder eine Sammlung von sortierten und einzigartigen Ganzzahlindizes oder ein boolescher Vektor der gleichen Länge wie a sein, wobei true Einträge anzeigt, die gelöscht werden sollen.

Beispiele

julia> deleteat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Vector{Int64}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], [true, false, true, false, true, false])
3-element Vector{Int64}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
ERROR: ArgumentError: indices must be unique and sorted
Stacktrace:
[...]

keepat!(a::Vector, inds)
keepat!(a::BitVector, inds)

Entferne die Elemente an allen Indizes, die nicht durch inds angegeben sind, und gebe das modifizierte a zurück. Die behaltenen Elemente werden verschoben, um die resultierenden Lücken zu füllen.

inds muss ein Iterator von sortierten und einzigartigen ganzzahligen Indizes sein. Siehe auch deleteat!.

Beispiele

julia> keepat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Vector{Int64}:
 6
 4
 2

keepat!(a::Vector, m::AbstractVector{Bool})
keepat!(a::BitVector, m::AbstractVector{Bool})

Die In-Place-Version der logischen Indizierung a = a[m]. Das heißt, keepat!(a, m) bei Vektoren gleicher Länge a und m entfernt alle Elemente aus a, für die m am entsprechenden Index false ist.

Beispiele

julia> a = [:a, :b, :c];

julia> keepat!(a, [true, false, true])
2-element Vector{Symbol}:
 :a
 :c

julia> a
2-element Vector{Symbol}:
 :a
 :c

splice!(a::Vector, index::Integer, [replacement]) -> item

Entfernt das Element am angegebenen Index und gibt das entfernte Element zurück. Nachfolgende Elemente werden nach links verschoben, um die entstandene Lücke zu füllen. Wenn angegeben, werden Ersatzwerte aus einer geordneten Sammlung anstelle des entfernten Elements eingefügt.

Siehe auch: replace, delete!, deleteat!, pop!, popat!.

Beispiele

julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
2

julia> A
5-element Vector{Int64}:
 6
 5
 4
 3
 1

julia> splice!(A, 5, -1)
1

julia> A
5-element Vector{Int64}:
  6
  5
  4
  3
 -1

julia> splice!(A, 1, [-1, -2, -3])
6

julia> A
7-element Vector{Int64}:
 -1
 -2
 -3
  5
  4
  3
 -1

Um replacement vor einem Index n einzufügen, ohne Elemente zu entfernen, verwenden Sie splice!(collection, n:n-1, replacement).

splice!(a::Vector, indices, [replacement]) -> items

Entfernt Elemente an den angegebenen Indizes und gibt eine Sammlung der entfernten Elemente zurück. Nachfolgende Elemente werden nach links verschoben, um die entstehenden Lücken zu füllen. Wenn angegeben, werden Ersatzwerte aus einer geordneten Sammlung anstelle der entfernten Elemente eingefügt; in diesem Fall muss indices ein AbstractUnitRange sein.

Um replacement vor einem Index n einzufügen, ohne Elemente zu entfernen, verwenden Sie splice!(collection, n:n-1, replacement).

Beispiele

julia> A = [-1, -2, -3, 5, 4, 3, -1]; splice!(A, 4:3, 2)
Int64[]

julia> A
8-element Vector{Int64}:
 -1
 -2
 -3
  2
  5
  4
  3
 -1

resize!(a::Vector, n::Integer) -> Vector

Ändert die Größe von a, um n Elemente zu enthalten. Wenn n kleiner als die aktuelle Länge der Sammlung ist, werden die ersten n Elemente beibehalten. Wenn n größer ist, ist nicht garantiert, dass die neuen Elemente initialisiert sind.

Beispiele

julia> resize!([6, 5, 4, 3, 2, 1], 3)
3-element Vector{Int64}:
 6
 5
 4

julia> a = resize!([6, 5, 4, 3, 2, 1], 8);

julia> length(a)
8

julia> a[1:6]
6-element Vector{Int64}:
 6
 5
 4
 3
 2
 1

append!(collection, collections...) -> collection.

Für einen geordneten Container collection füge die Elemente jeder collections am Ende hinzu.

Beispiele

julia> append!([1], [2, 3])
3-element Vector{Int64}:
 1
 2
 3

julia> append!([1, 2, 3], [4, 5], [6])
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

Verwende push!, um einzelne Elemente zu collection hinzuzufügen, die nicht bereits in einer anderen Sammlung enthalten sind. Das Ergebnis des vorhergehenden Beispiels ist äquivalent zu push!([1, 2, 3], 4, 5, 6).

Siehe sizehint! für Hinweise zum Leistungsmodell.

Siehe auch vcat für Vektoren, union! für Mengen und prepend! sowie pushfirst! für die entgegengesetzte Reihenfolge.

prepend!(a::Vector, collections...) -> collection

Fügen Sie die Elemente jeder collections am Anfang von a ein.

Wenn collections mehrere Sammlungen angibt, bleibt die Reihenfolge erhalten: Die Elemente von collections[1] erscheinen am weitesten links in a, und so weiter.

Beispiele

julia> prepend!([3], [1, 2])
3-element Vector{Int64}:
 1
 2
 3

julia> prepend!([6], [1, 2], [3, 4, 5])
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

Pair(x, y)
x => y

Konstruiere ein Pair-Objekt mit dem Typ Pair{typeof(x), typeof(y)}. Die Elemente werden in den Feldern first und second gespeichert. Sie können auch über Iteration zugegriffen werden (aber ein Pair wird für Broadcast-Operationen als ein einzelner "Skalar" behandelt).

Siehe auch Dict.

Beispiele

julia> p = "foo" => 7
"foo" => 7

julia> typeof(p)
Pair{String, Int64}

julia> p.first
"foo"

julia> for x in p
           println(x)
       end
foo
7

julia> replace.(["xops", "oxps"], "x" => "o")
2-element Vector{String}:
 "oops"
 "oops"

Base.Pairs(values, keys) <: AbstractDict{eltype(keys), eltype(values)}

Transformiert einen indexierbaren Container in eine Dictionary-Ansicht der gleichen Daten. Die Modifizierung des Schlüsselraums der zugrunde liegenden Daten kann dieses Objekt ungültig machen.