Collections and Data Structures

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

Faites avancer l'itérateur pour obtenir le prochain élément. Si aucun élément ne reste, nothing doit être retourné. Sinon, un tuple de 2 éléments contenant le prochain élément et le nouvel état d'itération doit être retourné.

IteratorSize(itertype::Type) -> IteratorSize

Étant donné le type d'un itérateur, renvoie l'une des valeurs suivantes :

• SizeUnknown() si la longueur (nombre d'éléments) ne peut pas être déterminée à l'avance.
• HasLength() s'il y a une longueur fixe et finie.
• HasShape{N}() s'il y a une longueur connue plus une notion de forme multidimensionnelle (comme pour un tableau). Dans ce cas, N doit donner le nombre de dimensions, et la fonction axes est valide pour l'itérateur.
• IsInfinite() si l'itérateur produit des valeurs indéfiniment.

La valeur par défaut (pour les itérateurs qui ne définissent pas cette fonction) est HasLength(). Cela signifie que la plupart des itérateurs sont supposés implémenter length.

Ce trait est généralement utilisé pour sélectionner entre des algorithmes qui pré-allouent de l'espace pour leur résultat, et des algorithmes qui redimensionnent leur résultat de manière incrémentielle.

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

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

IteratorEltype(itertype::Type) -> IteratorEltype

Étant donné le type d'un itérateur, renvoie l'une des valeurs suivantes :

• EltypeUnknown() si le type des éléments produits par l'itérateur n'est pas connu à l'avance.
• HasEltype() si le type d'élément est connu, et eltype renverrait une valeur significative.

HasEltype() est la valeur par défaut, car on suppose que les itérateurs implémentent eltype.

Ce trait est généralement utilisé pour sélectionner entre des algorithmes qui pré-allouent un type de résultat spécifique, et des algorithmes qui choisissent un type de résultat en fonction des types des valeurs produites.

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

AbstractRange{T} <: AbstractVector{T}

Supertype pour les plages linéaires avec des éléments de type T. UnitRange, LinRange et d'autres types sont des sous-types de cela.

Tous les sous-types doivent définir step. Ainsi, LogRange n'est pas un sous-type de AbstractRange.

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

Supertype pour les plages ordinales avec des éléments de type T et des espacements de type S. Les étapes doivent toujours être des multiples exacts de oneunit, et T doit être un type "discret", qui ne peut pas avoir de valeurs inférieures à oneunit. Par exemple, les types Integer ou Date seraient qualifiés, tandis que Float64 ne le serait pas (puisque ce type peut représenter des valeurs inférieures à oneunit(Float64). UnitRange, StepRange, et d'autres types sont des sous-types de cela.

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

Supertype pour les plages avec une taille de pas de oneunit(T) avec des éléments de type T. UnitRange et d'autres types sont des sous-types de cela.

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

Des plages avec des éléments de type T avec un espacement de type S. L'écart entre chaque élément est constant, et la plage est définie en termes d'un start et d'un stop de type T et d'un step de type S. Ni T ni S ne doivent être des types à virgule flottante. La syntaxe a:b:c avec b != 0 et a, b, et c tous des entiers crée une StepRange.

Exemples

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<:Réel}

Un intervalle paramétré par un début et un fin de type T, rempli d'éléments espacés de 1 depuis début jusqu'à ce que fin soit dépassé. La syntaxe a:b avec a et b étant tous deux des Entiers crée un UnitRange.

Exemples

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}

Une plage avec len éléments espacés linéairement entre son start et stop. La taille de l'espacement est contrôlée par len, qui doit être un Integer.

Exemples

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

Comparé à l'utilisation de range, la construction directe d'un LinRange devrait avoir moins de surcharge mais ne tentera pas de corriger les erreurs de point flottant :

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

Voir aussi Logrange pour des points espacés logarithmiquement.

isempty(collection) -> Bool

Déterminez si une collection est vide (n'a aucun élément).

Exemples

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

Retourne true si aucune tâche n'attend sur la condition, false sinon.

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

Cette fonction fournit un indice de chemin rapide pour l'achèvement de l'itérateur. Cela est utile pour les itérateurs avec état qui souhaitent éviter que des éléments soient consommés s'ils ne vont pas être exposés à l'utilisateur (par exemple, lors de la vérification de l'achèvement dans isempty ou zip).

Les itérateurs avec état qui souhaitent opter pour cette fonctionnalité doivent définir une méthode isdone qui renvoie vrai/faux en fonction de l'état de l'itérateur. Les itérateurs sans état n'ont pas besoin d'implémenter cette fonction.

Si le résultat est missing, les appelants peuvent continuer et calculer iterate(x, state) === nothing pour obtenir une réponse définitive.

Voir aussi iterate, isempty

empty!(collection) -> collection

Supprime tous les éléments d'une collection.

Exemples

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} avec 2 entrées :
  "b" => 2
  "a" => 1

julia> empty!(A);

julia> A
Dict{String, Int64}()

empty!(c::Channel)

Vider un canal c en appelant empty! sur le tampon interne. Retourner le canal vide.

length(collection) -> Integer

Retourne le nombre d'éléments dans la collection.

Utilisez lastindex pour obtenir le dernier index valide d'une collection indexable.

Voir aussi : size, ndims, eachindex.

Exemples

julia> length(1:5)
5

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

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

Base.checked_length(r)

Calcule length(r), mais peut vérifier les erreurs de dépassement lorsque le résultat ne peut pas être contenu dans Union{Integer(eltype(r)),Int}.

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

Déterminez si un élément est dans la collection donnée, dans le sens où il est == à l'une des valeurs générées en itérant sur la collection. Retournez une valeur Bool, sauf si item est missing ou si collection contient missing mais pas item, auquel cas missing est retourné (logique à trois valeurs, correspondant au comportement de any et ==).

Certaines collections suivent une définition légèrement différente. Par exemple, les Sets vérifient si l'élément est isequal à l'un des éléments ; les Dicts recherchent des paires key=>value, et la key est comparée en utilisant isequal.

Pour tester la présence d'une clé dans un dictionnaire, utilisez haskey ou k in keys(dict). Pour les collections mentionnées ci-dessus, le résultat est toujours un Bool.

Lors de la diffusion avec in.(items, collection) ou items .∈ collection, à la fois item et collection sont diffusés, ce qui n'est souvent pas ce qui est prévu. Par exemple, si les deux arguments sont des vecteurs (et que les dimensions correspondent), le résultat est un vecteur indiquant si chaque valeur dans la collection items est in la valeur à la position correspondante dans collection. Pour obtenir un vecteur indiquant si chaque valeur dans items est dans collection, enveloppez collection dans un tuple ou un Ref comme ceci : in.(items, Ref(collection)) ou items .∈ Ref(collection).

Voir aussi : ∉, insorted, contains, occursin, issubset.

Exemples

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

Négation de ∈ et ∋, c'est-à-dire vérifie que item n'est pas dans collection.

Lors de la diffusion avec items .∉ collection, à la fois item et collection sont diffusés, ce qui n'est souvent pas ce qui est voulu. Par exemple, si les deux arguments sont des vecteurs (et que les dimensions correspondent), le résultat est un vecteur indiquant si chaque valeur dans collection items n'est pas dans la valeur à la position correspondante dans collection. Pour obtenir un vecteur indiquant si chaque valeur dans items n'est pas dans collection, enveloppez collection dans un tuple ou un Ref comme ceci : items .∉ Ref(collection).

Exemples

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)

Déterminez si le calcul x ∈ collection où collection::T peut être considéré comme une opération "rapide" (typiquement de complexité constante ou logarithmique). La définition hasfastin(x) = hasfastin(typeof(x)) est fournie pour la commodité afin que des instances puissent être passées au lieu de types. Cependant, la forme qui accepte un argument de type doit être définie pour les nouveaux types.

La valeur par défaut pour hasfastin(T) est true pour les sous-types de AbstractSet, AbstractDict et AbstractRange et false sinon.

eltype(type)

Détermine le type des éléments générés en itérant une collection du type donné. Pour les types de dictionnaires, cela sera un Pair{KeyType,ValType}. La définition eltype(x) = eltype(typeof(x)) est fournie pour la commodité afin que des instances puissent être passées au lieu de types. Cependant, la forme qui accepte un argument de type doit être définie pour les nouveaux types.

Voir aussi : keytype, typeof.

Exemples

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

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

indexin(a, b)

Renvoie un tableau contenant le premier index dans b pour chaque valeur dans a qui est membre de b. Le tableau de sortie contient nothing partout où a n'est pas membre de b.

Voir aussi : sortperm, findfirst.

Exemples

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)

Renvoie un tableau contenant uniquement les éléments uniques de la collection itr, tels que déterminés par isequal et hash, dans l'ordre où le premier de chaque ensemble d'éléments équivalents apparaît à l'origine. Le type d'élément de l'entrée est préservé.

Voir aussi : unique!, allunique, allequal.

Exemples

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)

Renvoie un tableau contenant une valeur de itr pour chaque valeur unique produite par f appliqué aux éléments de itr.

Exemples

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

Cette fonctionnalité peut également être utilisée pour extraire les indices des premières occurrences d'éléments uniques dans un tableau :

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)

Retourne les régions uniques de A le long de la dimension dims.

Exemples

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)

Sélectionne une valeur de A pour chaque valeur unique produite par f appliqué aux éléments de A, puis retourne le A modifié.

Exemples

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)

Supprime les éléments en double tels que déterminés par isequal et hash, puis retourne le A modifié. unique! retournera les éléments de A dans l'ordre dans lequel ils apparaissent. Si vous ne vous souciez pas de l'ordre des données retournées, alors appeler (sort!(A); unique!(A)) sera beaucoup plus efficace tant que les éléments de A peuvent être triés.

Exemples

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! peut traiter les données triées de manière beaucoup plus efficace.

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

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

Retourne true si toutes les valeurs de itr sont distinctes lorsqu'elles sont comparées avec isequal. Ou si toutes les valeurs de [f(x) for x in itr] sont distinctes, pour la deuxième méthode.

Notez que allunique(f, itr) peut appeler f moins de fois que length(itr). Le nombre précis d'appels est considéré comme un détail d'implémentation.

allunique peut utiliser une implémentation spécialisée lorsque l'entrée est triée.

Voir aussi : unique, issorted, allequal.

Exemples

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

Retourne true si toutes les valeurs de itr sont égales lorsqu'elles sont comparées avec isequal. Ou si toutes les valeurs de [f(x) for x in itr] sont égales, pour la deuxième méthode.

Notez que allequal(f, itr) peut appeler f moins de fois que length(itr). Le nombre précis d'appels est considéré comme un détail d'implémentation.

Voir aussi : unique, allunique.

Exemples

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])

Réduit la collection donnée itr avec l'opérateur binaire donné op. Si fourni, la valeur initiale init doit être un élément neutre pour op qui sera retourné pour les collections vides. Il n'est pas spécifié si init est utilisé pour les collections non vides.

Pour les collections vides, fournir init sera nécessaire, sauf dans certains cas spéciaux (par exemple, lorsque op est l'un de +, *, max, min, &, |) lorsque Julia peut déterminer l'élément neutre de op.

Les réductions pour certains opérateurs couramment utilisés peuvent avoir des implémentations spéciales et doivent être utilisées à la place : maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr). Il existe des méthodes efficaces pour concaténer certains tableaux de tableaux en appelant reduce(vcat, arr) ou reduce(hcat, arr).

L'associativité de la réduction dépend de l'implémentation. Cela signifie que vous ne pouvez pas utiliser des opérations non associatives comme - car il est indéfini si reduce(-,[1,2,3]) doit être évalué comme (1-2)-3 ou 1-(2-3). Utilisez foldl ou foldr à la place pour garantir l'associativité à gauche ou à droite.

Certaines opérations accumulent des erreurs. Le parallélisme sera plus facile si la réduction peut être exécutée par groupes. Les futures versions de Julia pourraient changer l'algorithme. Notez que les éléments ne sont pas réordonnés si vous utilisez une collection ordonnée.

Exemples

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

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

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

Réduit la fonction à 2 arguments f le long des dimensions de A. dims est un vecteur spécifiant les dimensions à réduire, et l'argument clé init est la valeur initiale à utiliser dans les réductions. Pour +, *, max et min, l'argument init est optionnel.

L'associativité de la réduction dépend de l'implémentation ; si vous avez besoin d'une associativité particulière, par exemple de gauche à droite, vous devriez écrire votre propre boucle ou envisager d'utiliser foldl ou foldr. Voir la documentation pour reduce.

Exemples

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])

Comme reduce, mais avec une associativité gauche garantie. Si fourni, l'argument clé init sera utilisé exactement une fois. En général, il sera nécessaire de fournir init pour travailler avec des collections vides.

Voir aussi mapfoldl, foldr, accumulate.

Exemples

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])

Comme reduce, mais avec une associativité droite garantie. Si fourni, l'argument clé init sera utilisé exactement une fois. En général, il sera nécessaire de fournir init pour travailler avec des collections vides.

Exemples

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

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

maximum(f, itr; [init])

Retourne le plus grand résultat de l'appel de la fonction f sur chaque élément de itr.

La valeur retournée pour un itr vide peut être spécifiée par init. Cela doit être un élément neutre pour max (c'est-à-dire qui est inférieur ou égal à tout autre élément) car il n'est pas spécifié si init est utilisé pour des collections non vides.

Exemples

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

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

julia> maximum(sin, Real[]; init=-1.0)  # bon, puisque la sortie de sin est >= -1
-1.0

maximum(itr; [init])

Retourne le plus grand élément d'une collection.

La valeur retournée pour un itr vide peut être spécifiée par init. Cela doit être un élément neutre pour max (c'est-à-dire qui est inférieur ou égal à tout autre élément) car il n'est pas précisé si init est utilisé pour des collections non vides.

Exemples

julia> maximum(-20.5:10)
9.5

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

julia> maximum(())
ERROR: ArgumentError: réduire sur une collection vide n'est pas autorisé ; envisagez de fournir `init` au réducteur
Stacktrace:
[...]

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

maximum(A::AbstractArray; dims)

Calcule la valeur maximale d'un tableau sur les dimensions données. Voir aussi la fonction max(a,b) pour prendre le maximum de deux ou plusieurs arguments, qui peut être appliquée élément par élément aux tableaux via max.(a,b).

Voir aussi : maximum!, extrema, findmax, argmax.

Exemples

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)

Calculez la valeur maximale en appelant la fonction f sur chaque élément d'un tableau sur les dimensions données.

Exemples

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)

Calculez la valeur maximale de A sur les dimensions singleton de r, et écrivez les résultats dans r.

Exemples

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])

Retourne le plus petit résultat de l'appel de la fonction f sur chaque élément de itr.

La valeur retournée pour un itr vide peut être spécifiée par init. Cela doit être un élément neutre pour min (c'est-à-dire qui est supérieur ou égal à tout autre élément) car il n'est pas spécifié si init est utilisé pour des collections non vides.

Exemples

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

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

julia> minimum(sin, Real[]; init=1.0)  # bon, puisque la sortie de sin est <= 1
1.0

minimum(itr; [init])

Retourne le plus petit élément d'une collection.

La valeur retournée pour un itr vide peut être spécifiée par init. Cela doit être un élément neutre pour min (c'est-à-dire qui est supérieur ou égal à tout autre élément) car il n'est pas précisé si init est utilisé pour des collections non vides.

Exemples

julia> minimum(-20.5:10)
-20.5

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

julia> minimum([])
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

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

minimum(A::AbstractArray; dims)

Calcule la valeur minimale d'un tableau sur les dimensions données. Voir aussi la fonction min(a,b) pour prendre le minimum de deux ou plusieurs arguments, qui peut être appliquée élément par élément aux tableaux via min.(a,b).

Voir aussi : minimum!, extrema, findmin, argmin.

Exemples

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)

Calcule la valeur minimale en appelant la fonction f sur chaque élément d'un tableau sur les dimensions données.

Exemples

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)

Calculez la valeur minimale de A sur les dimensions singleton de r, et écrivez les résultats dans r.

Exemples

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)

Calculez à la fois l'élément minimum mn et l'élément maximum mx en un seul passage, et renvoyez-les sous forme de tuple de 2 éléments.

La valeur renvoyée pour un itr vide peut être spécifiée par init. Cela doit être un tuple de 2 éléments dont le premier et le deuxième éléments sont des éléments neutres pour min et max respectivement (c'est-à-dire qui sont supérieurs/inférieurs ou égaux à tout autre élément). En conséquence, lorsque itr est vide, le tuple renvoyé (mn, mx) satisfera mn ≥ mx. Lorsque init est spécifié, il peut être utilisé même pour un itr non vide.

Exemples

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)

Calculez à la fois le minimum mn et le maximum mx de f appliqué à chaque élément de itr et renvoyez-les sous forme de tuple de 2 éléments. Une seule passe est effectuée sur itr.

La valeur renvoyée pour un itr vide peut être spécifiée par init. Cela doit être un tuple de 2 éléments dont le premier et le deuxième éléments sont des éléments neutres pour min et max respectivement (c'est-à-dire qui sont supérieurs/inférieurs ou égaux à tout autre élément). Il est utilisé pour des collections non vides. Remarque : cela implique que, pour un itr vide, la valeur renvoyée (mn, mx) satisfait mn ≥ mx même si pour un itr non vide, elle satisfait mn ≤ mx. C'est un résultat "paradoxal" mais néanmoins attendu.

Exemples

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

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

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

Calcule les éléments minimum et maximum d'un tableau sur les dimensions données.

Voir aussi : minimum, maximum, extrema!.

Exemples

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}

Calcule le minimum et le maximum de f appliqué à chaque élément dans les dimensions données de A.

extrema!(r, A)

Calculez la valeur minimale et maximale de A sur les dimensions singleton de r, et écrivez les résultats dans r.

Exemples

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)

Les plages peuvent avoir plusieurs éléments maximaux. Dans ce cas, argmax renverra un index maximal, mais pas nécessairement le premier.

argmax(f, domaine)

Retourne une valeur x de domaine pour laquelle f(x) est maximisé. S'il y a plusieurs valeurs maximales pour f(x), alors la première sera trouvée.

domaine doit être un itérable non vide.

Les valeurs sont comparées avec isless.

Voir aussi argmin, findmax.

Exemples

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

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

argmax(itr)

Retourne l'index ou la clé de l'élément maximal dans une collection. S'il y a plusieurs éléments maximaux, le premier sera retourné.

La collection ne doit pas être vide.

Les indices sont du même type que ceux retournés par keys(itr) et pairs(itr).

Les valeurs sont comparées avec isless.

Voir aussi : argmin, findmax.

Exemples

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

Pour une entrée de tableau, renvoie les indices des éléments maximaux sur les dimensions données. NaN est considéré comme supérieur à toutes les autres valeurs sauf missing.

Exemples

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)

Les plages peuvent avoir plusieurs éléments minimaux. Dans ce cas, argmin renverra un index minimal, mais pas nécessairement le premier.

argmin(f, domaine)

Retourne une valeur x de domaine pour laquelle f(x) est minimisé. S'il y a plusieurs valeurs minimales pour f(x), alors la première sera trouvée.

domaine doit être un itérable non vide.

NaN est considéré comme inférieur à toutes les autres valeurs sauf missing.

Voir aussi argmax, findmin.

Exemples

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)

Renvoie l'index ou la clé de l'élément minimal dans une collection. S'il y a plusieurs éléments minimaux, le premier sera renvoyé.

La collection ne doit pas être vide.

Les indices sont du même type que ceux renvoyés par keys(itr) et pairs(itr).

NaN est considéré comme inférieur à toutes les autres valeurs sauf missing.

Voir aussi : argmax, findmin.

Exemples

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) -> indices

Pour une entrée de tableau, renvoie les indices des éléments minimum sur les dimensions données. NaN est considéré comme inférieur à toutes les autres valeurs sauf missing.

Exemples

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)

Retourne une paire d'une valeur dans le codomaine (sorties de f) et l'index ou la clé de la valeur correspondante dans le domain (entrées de f) telle que f(x) est maximisé. S'il y a plusieurs points maximaux, alors le premier sera retourné.

domain doit être un itérable non vide supportant keys. Les indices sont du même type que ceux retournés par keys(domain).

Les valeurs sont comparées avec isless.

Exemples

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)

Retourne l'élément maximal de la collection itr et son index ou clé. S'il y a plusieurs éléments maximaux, le premier sera retourné. Les valeurs sont comparées avec isless.

Les indices sont du même type que ceux retournés par keys(itr) et pairs(itr).

Voir aussi : findmin, argmax, maximum.

Exemples

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)

Pour une entrée de tableau, renvoie la valeur et l'index du maximum sur les dimensions données. NaN est considéré comme supérieur à toutes les autres valeurs sauf missing.

Exemples

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)

Pour une entrée de tableau, renvoie la valeur dans le codomaine et l'index de la valeur correspondante qui maximise f sur les dimensions données.

Exemples

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)

Retourne une paire d'une valeur dans le codomaine (sorties de f) et l'indice ou la clé de la valeur correspondante dans le domain (entrées de f) telle que f(x) est minimisé. S'il y a plusieurs points minimaux, alors le premier sera retourné.

domain doit être un itérable non vide.

Les indices sont du même type que ceux retournés par keys(domain) et pairs(domain).

NaN est considéré comme inférieur à toutes les autres valeurs sauf missing.

Exemples

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)

Retourne l'élément minimal de la collection itr et son index ou clé. S'il y a plusieurs éléments minimaux, le premier sera retourné. NaN est considéré comme inférieur à toutes les autres valeurs sauf missing.

Les indices sont du même type que ceux retournés par keys(itr) et pairs(itr).

Voir aussi : findmax, argmin, minimum.

Exemples

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)

Pour une entrée de tableau, renvoie la valeur et l'index du minimum sur les dimensions données. NaN est considéré comme inférieur à toutes les autres valeurs sauf missing.

Exemples

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)

Pour une entrée de tableau, renvoie la valeur dans le codomaine et l'index de la valeur correspondante qui minimise f sur les dimensions données.

Exemples

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)

Trouvez le maximum de A et l'indice linéaire correspondant le long des dimensions singleton de rval et rind, et stockez les résultats dans rval et rind. NaN est considéré comme supérieur à toutes les autres valeurs sauf missing.

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

Trouvez le minimum de A et l'indice linéaire correspondant le long des dimensions singleton de rval et rind, et stockez les résultats dans rval et rind. NaN est considéré comme inférieur à toutes les autres valeurs sauf missing.

sum(f, itr; [init])

Somme des résultats de l'appel de la fonction f sur chaque élément de itr.

Le type de retour est Int pour les entiers signés de moins de la taille de mot système, et UInt pour les entiers non signés de moins de la taille de mot système. Pour tous les autres arguments, un type de retour commun est trouvé auquel tous les arguments sont promus.

La valeur retournée pour un itr vide peut être spécifiée par init. Elle doit être l'identité additive (c'est-à-dire zéro) car il n'est pas précisé si init est utilisé pour des collections non vides.

Exemples

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

Notez la différence importante entre sum(A) et reduce(+, A) pour les tableaux avec un type d'élément entier petit :

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

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

Dans le premier cas, les entiers sont élargis à la taille de mot système et donc le résultat est 128. Dans le second cas, aucun élargissement n'a lieu et le débordement d'entier entraîne -128.

sum(itr; [init])

Retourne la somme de tous les éléments d'une collection.

Le type de retour est Int pour les entiers signés de moins que la taille de mot système, et UInt pour les entiers non signés de moins que la taille de mot système. Pour tous les autres arguments, un type de retour commun est trouvé auquel tous les arguments sont promus.

La valeur retournée pour un itr vide peut être spécifiée par init. Elle doit être l'identité additive (c'est-à-dire zéro) car il n'est pas spécifié si init est utilisé pour des collections non vides.

Voir aussi : reduce, mapreduce, count, union.

Exemples

julia> sum(1:20)
210

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

sum(A::AbstractArray; dims)

Somme des éléments d'un tableau sur les dimensions données.

Exemples

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)

Somme des résultats de l'appel de la fonction f sur chaque élément d'un tableau sur les dimensions données.

Exemples

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)

Somme des éléments de A sur les dimensions singleton de r, et écrivez les résultats dans r.

Exemples

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])

Renvoie le produit de f appliqué à chaque élément de itr.

Le type de retour est Int pour les entiers signés de moins de la taille de mot système, et UInt pour les entiers non signés de moins de la taille de mot système. Pour tous les autres arguments, un type de retour commun est trouvé auquel tous les arguments sont promus.

La valeur renvoyée pour un itr vide peut être spécifiée par init. Elle doit être l'identité multiplicative (c'est-à-dire un) car il n'est pas spécifié si init est utilisé pour des collections non vides.

Exemples

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

prod(itr; [init])

Retourne le produit de tous les éléments d'une collection.

Le type de retour est Int pour les entiers signés de moins que la taille de mot système, et UInt pour les entiers non signés de moins que la taille de mot système. Pour tous les autres arguments, un type de retour commun est trouvé auquel tous les arguments sont promus.

La valeur retournée pour un itr vide peut être spécifiée par init. Elle doit être l'identité multiplicative (c'est-à-dire un) car il n'est pas spécifié si init est utilisé pour des collections non vides.

Voir aussi : reduce, cumprod, any.

Exemples

julia> prod(1:5)
120

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

prod(A::AbstractArray; dims)

Multipliez les éléments d'un tableau sur les dimensions données.

Exemples

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)

Multipliez les résultats de l'appel de la fonction f sur chaque élément d'un tableau sur les dimensions données.

Exemples

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)

Multiplie les éléments de A sur les dimensions singleton de r, et écris les résultats dans r.

Exemples

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

Testez si des éléments d'une collection booléenne sont true, retournant true dès que la première valeur true dans itr est rencontrée (court-circuit). Pour court-circuiter sur false, utilisez all.

Si l'entrée contient des valeurs missing, retournez missing si toutes les valeurs non manquantes sont false (ou équivalemment, si l'entrée ne contient aucune valeur true), suivant la logique à trois valeurs.

Voir aussi : all, count, sum, |, , ||.

Exemples

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

Déterminez si le prédicat p renvoie true pour des éléments de itr, renvoyant true dès que le premier élément de itr pour lequel p renvoie true est rencontré (court-circuit). Pour court-circuiter sur false, utilisez all.

Si l'entrée contient des valeurs missing, renvoyez missing si toutes les valeurs non manquantes sont false (ou équivalemment, si l'entrée ne contient aucune valeur true), suivant la logique à trois valeurs.

Exemples

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)

Testez si des valeurs dans A le long des dimensions singleton de r sont true, et écrivez les résultats dans r.

Exemples

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

Testez si tous les éléments d'une collection booléenne sont true, retournant false dès que la première valeur false dans itr est rencontrée (court-circuit). Pour court-circuiter sur true, utilisez any.

Si l'entrée contient des valeurs missing, retournez missing si toutes les valeurs non manquantes sont true (ou équivalemment, si l'entrée ne contient aucune valeur false), suivant la logique à trois valeurs.

Voir aussi : all!, any, count, &, , &&, allunique.

Exemples

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

Déterminez si le prédicat p renvoie true pour tous les éléments de itr, renvoyant false dès que le premier élément de itr pour lequel p renvoie false est rencontré (court-circuit). Pour court-circuiter sur true, utilisez any.

Si l'entrée contient des valeurs missing, renvoyez missing si toutes les valeurs non manquantes sont true (ou équivalemment, si l'entrée ne contient aucune valeur false), suivant la logique à trois valeurs.

Exemples

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)

Testez si toutes les valeurs de A le long des dimensions singleton de r sont true, et écrivez les résultats dans r.

Exemples

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

Comptez le nombre d'éléments dans itr pour lesquels la fonction f renvoie true. Si f est omis, comptez le nombre d'éléments true dans itr (qui devrait être une collection de valeurs booléennes). init spécifie en option la valeur à partir de laquelle commencer le comptage et détermine donc également le type de sortie.

Voir aussi : any, sum.

Exemples

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,
)

Retourne le nombre de correspondances pour pattern dans string. Cela équivaut à appeler length(findall(pattern, string)) mais de manière plus efficace.

Si overlap=true, les séquences correspondantes sont autorisées à se chevaucher dans les indices de la chaîne d'origine, sinon elles doivent provenir de plages de caractères disjointes.

Exemples

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=:)

Comptez le nombre d'éléments dans A pour lesquels f renvoie true sur les dimensions données.

Exemples

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...) -> Rien

Appelle la fonction f sur chaque élément de l'itérable c. Pour plusieurs arguments itérables, f est appelé élément par élément, et l'itération s'arrête lorsque n'importe quel itérateur est terminé.

foreach doit être utilisé au lieu de map lorsque les résultats de f ne sont pas nécessaires, par exemple dans foreach(println, array).

Exemples

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, " avec ", y), tri, 'a':'z')
1 avec a
4 avec b
7 avec c

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

Transformez la collection c en appliquant f à chaque élément. Pour plusieurs arguments de collection, appliquez f élément par élément, et arrêtez-vous lorsque l'un d'eux est épuisé.

Voir aussi map!, foreach, mapreduce, mapslices, zip, Iterators.map.

Exemples

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

Lorsqu'il agit sur des tableaux multidimensionnels de la même ndims, ils doivent tous avoir les mêmes axes, et la réponse le sera aussi.

Voir aussi broadcast, qui permet des tailles non correspondantes.

Exemples

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))  # itère jusqu'à ce que le 3ème soit épuisé
3-element Vector{Float64}:
   2.0
  13.0
 102.0

map!(function, destination, collection...)

Comme map, mais stocke le résultat dans destination plutôt que dans une nouvelle collection. destination doit être au moins aussi grand que la plus petite collection.

Voir aussi : map, foreach, zip, copyto!.

Exemples

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))

Modifie dict en transformant chaque valeur de val en f(val). Notez que le type de dict ne peut pas être changé : si f(val) n'est pas une instance du type de valeur de dict, alors il sera converti en type de valeur si possible et sinon, une erreur sera levée.

Exemples

julia> d = Dict(:a => 1, :b => 2)
Dict{Symbol, Int64} avec 2 entrées :
  :a => 1
  :b => 2

julia> map!(v -> v-1, values(d))
ValueIterator pour un Dict{Symbol, Int64} avec 2 entrées. Valeurs :
  0
  1

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

Applique la fonction f à chaque élément(s) dans itrs, puis réduit le résultat en utilisant la fonction binaire op. Si fourni, init doit être un élément neutre pour op qui sera retourné pour les collections vides. Il n'est pas spécifié si init est utilisé pour les collections non vides. En général, il sera nécessaire de fournir init pour travailler avec des collections vides.

mapreduce est fonctionnellement équivalent à appeler reduce(op, map(f, itr); init=init), mais s'exécutera généralement plus rapidement car aucune collection intermédiaire n'a besoin d'être créée. Voir la documentation pour reduce et map.

Exemples

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

L'associativité de la réduction dépend de l'implémentation. De plus, certaines implémentations peuvent réutiliser la valeur de retour de f pour les éléments qui apparaissent plusieurs fois dans itr. Utilisez mapfoldl ou mapfoldr à la place pour garantir l'associativité gauche ou droite et l'invocation de f pour chaque valeur.

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

Comme mapreduce, mais avec une associativité gauche garantie, comme dans foldl. Si fourni, l'argument clé init sera utilisé exactement une fois. En général, il sera nécessaire de fournir init pour travailler avec des collections vides.

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

Comme mapreduce, mais avec une associativité à droite garantie, comme dans foldr. Si fourni, l'argument clé init sera utilisé exactement une fois. En général, il sera nécessaire de fournir init pour travailler avec des collections vides.

first(coll)

Obtenez le premier élément d'une collection itérable. Retournez le point de départ d'un AbstractRange même s'il est vide.

Voir aussi : only, firstindex, last.

Exemples

julia> first(2:2:10)
2

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

first(itr, n::Integer)

Obtenez les premiers n éléments de la collection itérable itr, ou moins d'éléments si itr n'est pas assez long.

Voir aussi : startswith, Iterators.take.

Exemples

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)

Obtenez une chaîne composée des premiers n caractères de s.

Exemples

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

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

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

last(coll)

Obtenez le dernier élément d'une collection ordonnée, si cela peut être calculé en O(1) temps. Cela est accompli en appelant lastindex pour obtenir le dernier index. Retournez le point final d'un AbstractRange même s'il est vide.

Voir aussi first, endswith.

Exemples

julia> last(1:2:10)
9

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

last(itr, n::Integer)

Obtenez les derniers n éléments de la collection itérable itr, ou moins d'éléments si itr n'est pas assez long.

Exemples

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)

Obtenez une chaîne composée des derniers n caractères de s.

Exemples

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

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

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

front(x::Tuple)::Tuple

Retourne un Tuple consistant de tous les composants sauf le dernier de x.

Voir aussi : first, tail.

Exemples

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

julia> Base.front(())
ERROR: ArgumentError: Cannot call front on an empty tuple.

tail(x::Tuple)::Tuple

Renvoie un Tuple contenant tous les composants sauf le premier de x.

Voir aussi : front, rest, first, Iterators.peel.

Exemples

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

julia> Base.tail(())
ERROR: ArgumentError: Cannot call tail on an empty tuple.

step(r)

Obtenez la taille du pas d'un objet AbstractRange.

Exemples

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)

Renvoie un Array de tous les éléments d'une collection ou d'un itérateur. Pour les dictionnaires, renvoie un Vector de key=>value Pairs. Si l'argument est de type tableau ou est un itérateur avec le trait HasShape, le résultat aura la même forme et le même nombre de dimensions que l'argument.

Utilisé par les compréhensions pour transformer une expression génératrice en un Array. Ainsi, sur les générateurs, la notation entre crochets peut être utilisée au lieu d'appeler collect, voir le deuxième exemple.

Exemples

Collecter des éléments d'une collection UnitRange{Int64} :

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

Collecter des éléments d'un générateur (même sortie que [x^2 for x in 1:3]) :

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

collect(type_d_element, collection)

Renvoie un Array avec le type d'élément donné de tous les éléments d'une collection ou d'un itérable. Le résultat a la même forme et le même nombre de dimensions que collection.

Exemples

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

filter(f, a)

Renvoie une copie de la collection a, en supprimant les éléments pour lesquels f est false. La fonction f reçoit un argument.

Voir aussi : filter!, Iterators.filter.

Exemples

julia> a = 1:10
1:10

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

filter(f)

Créez une fonction qui filtre ses arguments avec la fonction f en utilisant filter, c'est-à-dire une fonction équivalente à x -> filter(f, x).

La fonction retournée est de type Base.Fix1{typeof(filter)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

Exemples

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)

Retourne une copie de d, en supprimant les éléments pour lesquels f est false. La fonction f reçoit des paires key=>value.

Exemples

julia> d = Dict(1=>"a", 2=>"b")
Dict{Int64, String} avec 2 entrées :
  2 => "b"
  1 => "a"

julia> filter(p->isodd(p.first), d)
Dict{Int64, String} avec 1 entrée :
  1 => "a"

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

Renvoie un vecteur similaire au tableau enveloppé par l'itérateur SkipMissing donné, mais avec tous les éléments manquants et ceux pour lesquels f renvoie false supprimés.

Exemples

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)

Met à jour la collection a, en supprimant les éléments pour lesquels f est false. La fonction f reçoit un argument.

Exemples

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

filter!(f, d::AbstractDict)

Met à jour d, en supprimant les éléments pour lesquels f est false. La fonction f reçoit des paires key=>value.

Exemples

julia> d = Dict(1=>"a", 2=>"b", 3=>"c")
Dict{Int64, String} avec 3 entrées :
  2 => "b"
  3 => "c"
  1 => "a"

julia> filter!(p->isodd(p.first), d)
Dict{Int64, String} avec 2 entrées :
  3 => "c"
  1 => "a"

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

Renvoie une copie de la collection A où, pour chaque paire old=>new dans old_new, toutes les occurrences de old sont remplacées par new. L'égalité est déterminée en utilisant isequal. Si count est spécifié, alors remplace au maximum count occurrences au total.

Le type d'élément du résultat est choisi en utilisant la promotion (voir promote_type) en fonction du type d'élément de A et des types des valeurs new dans les paires. Si count est omis et que le type d'élément de A est un Union, le type d'élément du résultat n'inclura pas les types singleton qui sont remplacés par des valeurs d'un type différent : par exemple, Union{T,Missing} deviendra T si missing est remplacé.

Voir aussi replace!, splice!, delete!, insert!.

Exemples

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])

Retourne une copie de A où chaque valeur x dans A est remplacée par new(x). Si count est spécifié, alors remplace au maximum count valeurs au total (les remplacements étant définis comme new(x) !== x).

Exemples

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} with 2 entries:
  3 => 4
  1 => 3

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

Pour chaque paire old=>new dans old_new, remplacez toutes les occurrences de old dans la collection A par new. L'égalité est déterminée en utilisant isequal. Si count est spécifié, alors remplacez au maximum count occurrences au total. Voir aussi replace.

Exemples

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} with 3 elements:
  0
  2
  3

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

Remplace chaque élément x dans la collection A par new(x). Si count est spécifié, alors remplace au maximum count valeurs au total (les remplacements étant définis comme new(x) !== x).

Exemples

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} with 2 entries:
  3 => 4
  1 => 3

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

Base.rest(collection[, itr_state])

Fonction générique pour prendre la queue de collection, à partir d'un état d'itération spécifique itr_state. Retourne un Tuple, si collection elle-même est un Tuple, un sous-type de AbstractVector, si collection est un AbstractArray, un sous-type de AbstractString si collection est un AbstractString, et un itérateur arbitraire, revenant à Iterators.rest(collection[, itr_state]), sinon.

Peut être surchargé pour des types de collection définis par l'utilisateur afin de personnaliser le comportement de slurping in assignments en position finale, comme a, b... = collection.

Voir aussi : first, Iterators.rest, Base.split_rest.

Exemples

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)

Fonction générique pour diviser la queue de collection, à partir d'un état d'itération spécifique itr_state. Renvoie un tuple de deux nouvelles collections. La première contient tous les éléments de la queue sauf les n derniers, qui constituent la deuxième collection.

Le type de la première collection suit généralement celui de Base.rest, sauf que le cas de repli n'est pas paresseux, mais est collecté de manière proactive dans un vecteur.

Peut être surchargé pour des types de collection définis par l'utilisateur afin de personnaliser le comportement de l'absorption dans les affectations en position non finale, comme a, b..., c = collection.

Voir aussi : Base.rest.

Exemples

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...)

Récupère la ou les valeurs stockées à la clé ou à l'index donné dans une collection. La syntaxe a[i,j,...] est convertie par le compilateur en getindex(a, i, j, ...).

Voir aussi get, keys, eachindex.

Exemples

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} avec 2 entrées :
  "b" => 2
  "a" => 1

julia> getindex(A, "a")
1

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

Stockez la valeur donnée à la clé ou à l'index donné dans une collection. La syntaxe a[i,j,...] = x est convertie par le compilateur en (setindex!(a, x, i, j, ...); x).

Exemples

julia> a = Dict("a"=>1)
Dict{String, Int64} avec 1 entrée :
  "a" => 1

julia> setindex!(a, 2, "b")
Dict{String, Int64} avec 2 entrées :
  "b" => 2
  "a" => 1

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

Retourne le premier index de collection. Si d est donné, retourne le premier index de collection le long de la dimension d.

Les syntaxes A[begin] et A[1, begin] se traduisent par A[firstindex(A)] et A[1, firstindex(A, 2)], respectivement.

Voir aussi : first, axes, lastindex, nextind.

Exemples

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

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

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

Retourne le dernier index de collection. Si d est donné, retourne le dernier index de collection le long de la dimension d.

Les syntaxes A[end] et A[end, end] se traduisent par A[lastindex(A)] et A[lastindex(A, 1), lastindex(A, 2)], respectivement.

Voir aussi : axes, firstindex, eachindex, prevind.

Exemples

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

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

AbstractDict{K, V}

Supertype pour les types similaires à des dictionnaires avec des clés de type K et des valeurs de type V. Dict, IdDict et d'autres types sont des sous-types de celui-ci. Un AbstractDict{K, V} devrait être un itérateur de Pair{K, V}.

Dict([itr])

Dict{K,V}() construit une table de hachage avec des clés de type K et des valeurs de type V. Les clés sont comparées avec isequal et hachées avec hash.

Étant donné un seul argument itérable, construit un Dict dont les paires clé-valeur sont tirées de 2-uplets (clé,valeur) générés par l'argument.

Exemples

julia> Dict([("A", 1), ("B", 2)])
Dict{String, Int64} avec 2 entrées :
  "B" => 2
  "A" => 1

Alternativement, une séquence d'arguments de paires peut être passée.

julia> Dict("A"=>1, "B"=>2)
Dict{String, Int64} avec 2 entrées :
  "B" => 2
  "A" => 1

IdDict([itr])

IdDict{K,V}() construit une table de hachage en utilisant objectid comme hachage et === comme égalité avec des clés de type K et des valeurs de type V. Voir Dict pour plus d'aide et IdSet pour la version ensemble de cela.

Dans l'exemple ci-dessous, les clés de Dict sont toutes isequal et sont donc hachées de la même manière, elles sont donc écrasées. L'IdDict hache par identifiant d'objet, et préserve donc les 3 clés différentes.

Exemples

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

julia> IdDict(true => "yes", 1 => "no", 1.0 => "maybe")
IdDict{Any, String} with 3 entries:
  true => "yes"
  1.0  => "maybe"
  1    => "no"

WeakKeyDict([itr])

WeakKeyDict() construit une table de hachage où les clés sont des références faibles à des objets qui peuvent être collectés par le ramasse-miettes même lorsqu'ils sont référencés dans une table de hachage.

Voir Dict pour plus d'aide. Notez que, contrairement à Dict, WeakKeyDict ne convertit pas les clés lors de l'insertion, car cela impliquerait que l'objet clé n'était référencé nulle part avant l'insertion.

Voir aussi WeakRef.

ImmutableDict

ImmutableDict est un dictionnaire implémenté comme une liste chaînée immuable, qui est optimal pour les petits dictionnaires construits à partir de nombreuses insertions individuelles. Notez qu'il n'est pas possible de supprimer une valeur, bien qu'elle puisse être partiellement remplacée et cachée en insérant une nouvelle valeur avec la même clé.

ImmutableDict(KV::Pair)

Créez une nouvelle entrée dans le ImmutableDict pour une paire clé => valeur

• utilisez (clé => valeur) in dict pour voir si cette combinaison particulière est dans l'ensemble des propriétés
• utilisez get(dict, clé, défaut) pour récupérer la valeur la plus récente pour une clé particulière

PersistentDict

PersistentDict est un dictionnaire implémenté comme un trie mappé par tableau de hachage, qui est optimal pour les situations où vous avez besoin de persistance, chaque opération renvoie un nouveau dictionnaire distinct du précédent, mais l'implémentation sous-jacente est efficace en termes d'espace et peut partager le stockage entre plusieurs dictionnaires distincts.

PersistentDict(KV::Pair)

Exemples

julia> dict = Base.PersistentDict(:a=>1)
Base.PersistentDict{Symbol, Int64} avec 1 entrée :
  :a => 1

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

julia> dict3 = Base.PersistentDict(dict, :a=>2)
Base.PersistentDict{Symbol, Int64} avec 1 entrée :
  :a => 2

haskey(collection, key) -> Bool

Déterminez si une collection a une correspondance pour une key donnée.

Exemples

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} avec 2 entrées :
  'a' => 2
  'b' => 3

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

Retourne la valeur stockée pour la clé donnée, ou la valeur par défaut donnée si aucune correspondance pour la clé n'est présente.

Exemples

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)

Retourne la valeur stockée pour la clé donnée, ou si aucune correspondance pour la clé n'est présente, retourne f(). Utilisez get! pour également stocker la valeur par défaut dans le dictionnaire.

Ceci est destiné à être appelé en utilisant la syntaxe de bloc do

get(dict, key) do
    # valeur par défaut calculée ici
    time()
end

get!(collection, key, default)

Retourne la valeur stockée pour la clé donnée, ou si aucune correspondance pour la clé n'est présente, stocke key => default, et retourne default.

Exemples

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} avec 4 entrées :
  "c" => 3
  "b" => 2
  "a" => 1
  "d" => 4

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

Retourne la valeur stockée pour la clé donnée, ou si aucune correspondance pour la clé n'est présente, stocke key => f(), et retourne f().

Ceci est destiné à être appelé en utilisant la syntaxe de bloc do.

Exemples

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} with 1 entry:
  2 => 4

getkey(collection, key, default)

Retourne la clé correspondant à l'argument key si elle existe dans collection, sinon retourne default.

Exemples

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> getkey(D, 'a', 1)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> getkey(D, 'd', 'a')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

delete!(collection, key)

Supprime la correspondance pour la clé donnée dans une collection, le cas échéant, et renvoie la collection.

Exemples

julia> d = Dict("a"=>1, "b"=>2)
Dict{String, Int64} avec 2 entrées :
  "b" => 2
  "a" => 1

julia> delete!(d, "b")
Dict{String, Int64} avec 1 entrée :
  "a" => 1

julia> delete!(d, "b") # d reste inchangé
Dict{String, Int64} avec 1 entrée :
  "a" => 1

pop!(collection, key[, default])

Supprime et retourne le mappage pour key s'il existe dans collection, sinon retourne default, ou lance une erreur si default n'est pas spécifié.

Exemples

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)

Pour un itérateur ou une collection qui a des clés et des valeurs (par exemple, des tableaux et des dictionnaires), renvoie un itérateur sur les clés.

values(iterator)

Pour un itérateur ou une collection qui a des clés et des valeurs, renvoie un itérateur sur les valeurs. Cette fonction renvoie simplement son argument par défaut, puisque les éléments d'un itérateur général sont normalement considérés comme ses "valeurs".

Exemples

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

julia> values(d)
ValueIterator for a Dict{String, Int64} with 2 entries. Values:
  2
  1

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

values(a::AbstractDict)

Renvoie un itérateur sur toutes les valeurs d'une collection. collect(values(a)) renvoie un tableau de valeurs. Lorsque les valeurs sont stockées en interne dans une table de hachage, comme c'est le cas pour Dict, l'ordre dans lequel elles sont renvoyées peut varier. Mais keys(a), values(a) et pairs(a) itèrent tous a et renvoient les éléments dans le même ordre.

Exemples

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} avec 2 entrées :
  'a' => 2
  'b' => 3

julia> collect(values(D))
Vecteur{Int64} de 2 éléments :
 2
 3

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

Un itérateur qui accède à chaque élément du tableau A, retournant i => x, où i est l'indice de l'élément et x = A[i]. Identique à pairs(A), sauf que le style de l'indice peut être sélectionné. Également similaire à enumerate(A), sauf que i sera un indice valide pour A, tandis que enumerate compte toujours à partir de 1, indépendamment des indices de A.

Spécifier IndexLinear() garantit que i sera un entier ; spécifier IndexCartesian() garantit que i sera un Base.CartesianIndex ; spécifier IndexStyle(A) choisit celui qui a été défini comme le style d'indexation natif pour le tableau A.

La mutation des limites du tableau sous-jacent invalidera cet itérateur.

Exemples

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

Voir aussi IndexStyle, axes.

pairs(collection)

Renvoie un itérateur sur des paires clé => valeur pour toute collection qui associe un ensemble de clés à un ensemble de valeurs. Cela inclut les tableaux, où les clés sont les indices du tableau. Lorsque les entrées sont stockées en interne dans une table de hachage, comme c'est le cas pour Dict, l'ordre dans lequel elles sont renvoyées peut varier. Mais keys(a), values(a) et pairs(a) itèrent tous a et renvoient les éléments dans le même ordre.

Exemples

julia> a = Dict(zip(["a", "b", "c"], [1, 2, 3]))
Dict{String, Int64} avec 3 entrées :
  "c" => 3
  "b" => 2
  "a" => 1

julia> pairs(a)
Dict{String, Int64} avec 3 entrées :
  "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
Vecteur de 3 éléments{Pair{Symbol, Int64}} :
 :a => 1
 :b => 2
 :c => 3

julia> (;a=1, b=2, c=3) |> collect
Vecteur de 3 éléments{Int64} :
 1
 2
 3

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

Fusionner les propriétés du visage initial et des autres, les visages ultérieurs ayant la priorité.

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

Construit une collection fusionnée à partir des collections données. Si nécessaire, les types de la collection résultante seront promus pour s'adapter aux types des collections fusionnées. Si la même clé est présente dans une autre collection, la valeur pour cette clé sera celle qu'elle a dans la dernière collection listée. Voir aussi mergewith pour un traitement personnalisé des valeurs avec la même clé.

Exemples

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} avec 2 entrées :
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} avec 2 entrées :
  "bar" => 4711
  "baz" => 17

julia> merge(a, b)
Dict{String, Float64} avec 3 entrées :
  "bar" => 4711.0
  "baz" => 17.0
  "foo" => 0.0

julia> merge(b, a)
Dict{String, Float64} avec 3 entrées :
  "bar" => 42.0
  "baz" => 17.0
  "foo" => 0.0

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

Construit un nouveau tuple nommé en fusionnant deux ou plusieurs existants, de manière associative à gauche. La fusion se fait de gauche à droite, entre des paires de tuples nommés, et ainsi l'ordre des champs présents dans les tuples nommés les plus à gauche et les plus à droite prend la même position que celle trouvée dans le tuple nommé le plus à gauche. Cependant, les valeurs sont prises à partir des champs correspondants dans le tuple nommé le plus à droite qui contient ce champ. Les champs présents uniquement dans le tuple nommé le plus à droite d'une paire sont ajoutés à la fin. Un fallback est implémenté pour le cas où un seul tuple nommé est fourni, avec la signature merge(a::NamedTuple).

Exemples

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)

Interprète un itérable de paires clé-valeur comme un tuple nommé, et effectue une fusion.

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...)

Construisez une collection fusionnée à partir des collections données. Si nécessaire, les types de la collection résultante seront promus pour s'adapter aux types des collections fusionnées. Les valeurs ayant la même clé seront combinées à l'aide de la fonction de combinaison. La forme curried mergewith(combine) renvoie la fonction (args...) -> mergewith(combine, args...).

La méthode merge(combine::Union{Function,Type}, args...) en tant qu'alias de mergewith(combine, args...) est toujours disponible pour la compatibilité ascendante.

Exemples

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} avec 2 entrées :
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} avec 2 entrées :
  "bar" => 4711
  "baz" => 17

julia> mergewith(+, a, b)
Dict{String, Float64} avec 3 entrées :
  "bar" => 4753.0
  "baz" => 17.0
  "foo" => 0.0

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

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

Met à jour la collection avec des paires des autres collections. Voir aussi merge.

Exemples

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

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

julia> merge!(d1, d2);

julia> d1
Dict{Int64, Int64} avec 3 entrées :
  4 => 5
  3 => 4
  1 => 4

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

Met à jour la collection avec des paires provenant des autres collections. Les valeurs ayant la même clé seront combinées à l'aide de la fonction de combinaison. La forme curryée mergewith!(combine) renvoie la fonction (args...) -> mergewith!(combine, args...).

La méthode merge!(combine::Union{Function,Type}, args...) en tant qu'alias de mergewith!(combine, args...) est toujours disponible pour la compatibilité ascendante.

Exemples

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

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

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

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 4
  1 => 6

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

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 0
  3 => 0
  1 => 0

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

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

Suggérez que la collection s réserve une capacité d'au moins n éléments. C'est-à-dire que si vous vous attendez à devoir ajouter beaucoup de valeurs à s, vous pouvez éviter le coût de la réallocation incrémentale en le faisant une fois au départ ; cela peut améliorer les performances.

Si first est true, alors tout espace supplémentaire est réservé avant le début de la collection. De cette façon, les appels ultérieurs à pushfirst! (au lieu de push!) peuvent devenir plus rapides. Fournir ce mot-clé peut entraîner une erreur si la collection n'est pas ordonnée ou si pushfirst! n'est pas pris en charge pour cette collection.

Si shrink=true (par défaut), la capacité de la collection peut être réduite si sa capacité actuelle est supérieure à n.

Voir aussi resize!.

Remarques sur le modèle de performance

Pour les types qui prennent en charge sizehint!,

1. Les méthodes push! et append! peuvent généralement (mais ne sont pas tenues de) préallouer un stockage supplémentaire. Pour les types implémentés dans Base, elles le font généralement, en utilisant une heuristique optimisée pour un cas d'utilisation général.
2. sizehint! peut contrôler cette préallocation. Encore une fois, cela le fait généralement pour les types dans Base.
3. empty! est presque sans coût (et O(1)) pour les types qui prennent en charge ce type de préallocation.

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

Renvoie le type de clé d'un tableau. Cela est égal à l'eltype du résultat de keys(...), et est fourni principalement pour la compatibilité avec l'interface de dictionnaire.

Exemples

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

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

keytype(type)

Obtenez le type de clé d'un type de dictionnaire. Se comporte de manière similaire à eltype.

Exemples

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

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

Retourne le type de valeur d'un tableau. Cela est identique à eltype et est fourni principalement pour la compatibilité avec l'interface de dictionnaire.

Exemples

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

valtype(type)

Obtenez le type de valeur d'un type de dictionnaire. Se comporte de manière similaire à eltype.

Exemples

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

AbstractSet{T}

Supertype pour les types similaires à des ensembles dont les éléments sont de type T. Set, BitSet et d'autres types sont des sous-types de cela.

Set{T} <: AbstractSet{T}

Les Set sont des conteneurs mutables qui fournissent des tests d'appartenance rapides.

Les Set ont des implémentations efficaces des opérations sur les ensembles telles que in, union et intersect. Les éléments d'un Set sont uniques, comme déterminé par la définition de isequal des éléments. L'ordre des éléments dans un Set est un détail d'implémentation et ne peut pas être pris en compte.

Voir aussi : AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

Exemples

julia> s = Set("aaBca")
Set{Char} avec 3 éléments :
  'a'
  'c'
  'B'

julia> push!(s, 'b')
Set{Char} avec 4 éléments :
  'a'
  'b'
  'B'
  'c'

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

julia> -0.0 in s # isequal(0.0, -0.0) est faux
false

julia> NaN in s # isequal(NaN, NaN) est vrai
true

BitSet([itr])

Construit un ensemble trié d'Ints généré par l'objet itérable donné, ou un ensemble vide. Implémenté sous forme de chaîne de bits, et donc conçu pour des ensembles d'entiers denses. Si l'ensemble doit être clairsemé (par exemple, contenant quelques très grands entiers), utilisez Set à la place.

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

IdSet{T}() construit un ensemble (voir Set) en utilisant === comme égalité avec des valeurs de type T.

Dans l'exemple ci-dessous, les valeurs sont toutes isequal donc elles sont écrasées dans l'ordinaire Set. L'IdSet compare par === et préserve donc les 3 valeurs différentes.

Exemples

julia> Set(Any[true, 1, 1.0])
Set{Any} avec 1 élément :
  1.0

julia> IdSet{Any}(Any[true, 1, 1.0])
IdSet{Any} avec 3 éléments :
  1.0
  1
  true

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

Construit un objet contenant tous les éléments distincts de tous les arguments.

Le premier argument contrôle le type de conteneur qui est retourné. Si c'est un tableau, il maintient l'ordre dans lequel les éléments apparaissent pour la première fois.

Le symbole Unicode ∪ peut être tapé en écrivant \cup puis en appuyant sur tab dans le REPL Julia, et dans de nombreux éditeurs. C'est un opérateur infixe, permettant s ∪ itr.

Voir aussi unique, intersect, isdisjoint, vcat, Iterators.flatten.

Exemples

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...)

Construit l'union des ensembles passés et écrase s avec le résultat. Maintient l'ordre avec les tableaux.

Exemples

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

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

julia> a
Set{Int64} avec 5 éléments :
  5
  4
  7
  3
  1

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

Construit l'ensemble contenant les éléments qui apparaissent dans tous les arguments.

Le premier argument contrôle le type de conteneur qui est retourné. Si c'est un tableau, il maintient l'ordre dans lequel les éléments apparaissent pour la première fois.

Le symbole Unicode ∩ peut être tapé en écrivant \cap puis en appuyant sur tab dans le REPL Julia, et dans de nombreux éditeurs. C'est un opérateur infixe, permettant s ∩ itr.

Voir aussi setdiff, isdisjoint, issubset, issetequal.

Exemples

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} with 1 element:
  2.0

setdiff(s, itrs...)

Construit l'ensemble des éléments dans s mais pas dans aucun des itérables dans itrs. Maintient l'ordre avec des tableaux.

Voir aussi setdiff!, union et intersect.

Exemples

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

setdiff!(s, itrs...)

Supprime de l'ensemble s (sur place) chaque élément de chaque itérable de itrs. Maintient l'ordre avec les tableaux.

Exemples

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

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

julia> a
Set{Int64} with 1 element:
  4

symdiff(s, itrs...)

Construit la différence symétrique des éléments dans les ensembles passés. Lorsque s n'est pas un AbstractSet, l'ordre est maintenu.

Voir aussi symdiff!, setdiff, union et intersect.

Exemples

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...)

Construit la différence symétrique des ensembles passés en paramètres et écrase s avec le résultat. Lorsque s est un tableau, l'ordre est maintenu. Notez que dans ce cas, la multiplicité des éléments est importante.

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

Intersectionnez tous les ensembles passés et écrasez s avec le résultat. Maintenez l'ordre avec les tableaux.

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

Déterminez si chaque élément de a est également dans b, en utilisant in.

Voir aussi ⊊, ⊈, ∩, ∪, contains.

Exemples

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

Si x est dans s, retourne true. Sinon, ajoute x à s et retourne false. Cela équivaut à in(x, s) ? true : (push!(s, x); false), mais peut avoir une implémentation plus efficace.

Voir aussi : in, push!, Set

Exemples

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

julia> length(s)
4

julia> in!(0x04, s)
true

julia> s
Set{Any} with 4 elements:
  4
  2
  3
  1

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

Négation de ⊆ et ⊇, c'est-à-dire vérifie que a n'est pas un sous-ensemble de b.

Voir aussi issubset (⊆), ⊊.

Exemples

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

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

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

Détermine si a est un sous-ensemble de, mais pas égal à, b.

Voir aussi issubset (⊆), ⊈.

Exemples

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

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

issetequal(a, b) -> Bool

Déterminez si a et b ont les mêmes éléments. Équivalent à a ⊆ b && b ⊆ a mais plus efficace lorsque c'est possible.

Voir aussi : isdisjoint, union.

Exemples

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

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

issetequal(x)

Créez une fonction qui compare son argument à x en utilisant issetequal, c'est-à-dire une fonction équivalente à y -> issetequal(y, x). La fonction retournée est de type Base.Fix2{typeof(issetequal)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

isdisjoint(a, b) -> Bool

Déterminez si les collections a et b sont disjointes. Équivalent à isempty(a ∩ b) mais plus efficace lorsque c'est possible.

Voir aussi : intersect, isempty, issetequal.

Exemples

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

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

isdisjoint(x)

Créez une fonction qui compare son argument à x en utilisant isdisjoint, c'est-à-dire une fonction équivalente à y -> isdisjoint(y, x). La fonction retournée est de type Base.Fix2{typeof(isdisjoint)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

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

Insérer un ou plusieurs items dans collection. Si collection est un conteneur ordonné, les éléments sont insérés à la fin (dans l'ordre donné).

Exemples

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

Si collection est ordonné, utilisez append! pour ajouter tous les éléments d'un autre conteneur. Le résultat de l'exemple précédent est équivalent à append!([1, 2, 3], [4, 5, 6]). Pour les objets AbstractSet, union! peut être utilisé à la place.

Voir sizehint! pour des notes sur le modèle de performance.

Voir aussi pushfirst!.

pop!(collection) -> item

Supprime un élément dans collection et le retourne. Si collection est un conteneur ordonné, le dernier élément est retourné ; pour les conteneurs non ordonnés, un élément arbitraire est retourné.

Voir aussi : popfirst!, popat!, delete!, deleteat!, splice!, et push!.

Exemples

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} with 2 elements:
  2
  1

julia> pop!(S)
2

julia> S
Set{Int64} with 1 element:
  1

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

pop!(collection, key[, default])

Supprime et retourne le mappage pour key s'il existe dans collection, sinon retourne default, ou lance une erreur si default n'est pas spécifié.

Exemples

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])

Supprime l'élément à l'index i donné et le retourne. Les éléments suivants sont décalés pour combler le vide résultant. Lorsque i n'est pas un index valide pour a, retourne default, ou lance une erreur si default n'est pas spécifié.

Voir aussi : pop!, popfirst!, deleteat!, splice!.

Exemples

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

Insère un ou plusieurs items au début de collection.

Cette fonction est appelée unshift dans de nombreux autres langages de programmation.

Exemples

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

popfirst!(collection) -> item

Supprime le premier item de collection.

Cette fonction s'appelle shift dans de nombreux autres langages de programmation.

Voir aussi : pop!, popat!, delete!.

Exemples

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)

Insérer un item dans a à l'index donné. index est l'index de item dans le a résultant.

Voir aussi : push!, replace, popat!, splice!.

Exemples

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

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

Supprime l'élément à l'index i donné et retourne le a modifié. Les éléments suivants sont décalés pour combler le vide résultant.

Voir aussi : keepat!, delete!, popat!, splice!.

Exemples

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

deleteat!(a::Vector, inds)

Supprime les éléments aux indices donnés par inds, et retourne le a modifié. Les éléments suivants sont décalés pour combler le vide résultant.

inds peut être soit un itérateur, soit une collection d'indices entiers triés et uniques, ou un vecteur booléen de la même longueur que a avec true indiquant les entrées à supprimer.

Exemples

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)

Supprime les éléments à tous les indices qui ne sont pas donnés par inds, et retourne le a modifié. Les éléments qui sont conservés sont décalés pour remplir les espaces résultants.

inds doit être un itérateur d'indices entiers triés et uniques. Voir aussi deleteat!.

Exemples

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})

La version en place de l'indexation logique a = a[m]. C'est-à-dire que keepat!(a, m) sur des vecteurs de même longueur a et m supprimera tous les éléments de a pour lesquels m à l'index correspondant est false.

Exemples

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

Supprime l'élément à l'index donné et retourne l'élément supprimé. Les éléments suivants sont décalés vers la gauche pour combler le vide résultant. Si spécifié, les valeurs de remplacement d'une collection ordonnée seront insérées à la place de l'élément supprimé.

Voir aussi : replace, delete!, deleteat!, pop!, popat!.

Exemples

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

Pour insérer replacement avant un index n sans supprimer d'éléments, utilisez splice!(collection, n:n-1, replacement).

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

Supprime les éléments aux indices spécifiés et renvoie une collection contenant les éléments supprimés. Les éléments suivants sont décalés vers la gauche pour combler les espaces résultants. Si spécifié, les valeurs de remplacement d'une collection ordonnée seront insérées à la place des éléments supprimés ; dans ce cas, indices doit être un AbstractUnitRange.

Pour insérer replacement avant un index n sans supprimer d'éléments, utilisez splice!(collection, n:n-1, replacement).

Exemples

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

Redimensionne a pour contenir n éléments. Si n est inférieur à la longueur actuelle de la collection, les premiers n éléments seront conservés. Si n est supérieur, les nouveaux éléments ne sont pas garantis d'être initialisés.

Exemples

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.

Pour un conteneur ordonné collection, ajoutez les éléments de chaque collections à la fin de celui-ci.

Exemples

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

Utilisez push! pour ajouter des éléments individuels à collection qui ne sont pas déjà dans une autre collection. Le résultat de l'exemple précédent est équivalent à push!([1, 2, 3], 4, 5, 6).

Voir sizehint! pour des notes sur le modèle de performance.

Voir aussi vcat pour les vecteurs, union! pour les ensembles, et prepend! et pushfirst! pour l'ordre opposé.

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

Insère les éléments de chaque collections au début de a.

Lorsque collections spécifie plusieurs collections, l'ordre est maintenu : les éléments de collections[1] apparaîtront le plus à gauche dans a, et ainsi de suite.

Exemples

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

Construisez un objet Pair de type Pair{typeof(x), typeof(y)}. Les éléments sont stockés dans les champs first et second. Ils peuvent également être accessibles via l'itération (mais un Pair est traité comme un "scalaire" unique pour les opérations de diffusion).

Voir aussi Dict.

Exemples

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)}

Transforme un conteneur indexable en une vue de dictionnaire des mêmes données. Modifier l'espace des clés des données sous-jacentes peut invalider cet objet.