Collections and Data Structures

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

Avanza el iterador para obtener el siguiente elemento. Si no quedan elementos, se debe devolver nothing. De lo contrario, se debe devolver una tupla de 2 elementos que contiene el siguiente elemento y el nuevo estado de iteración.

IteratorSize(itertype::Type) -> IteratorSize

Dado el tipo de un iterador, devuelve uno de los siguientes valores:

• SizeUnknown() si la longitud (número de elementos) no se puede determinar de antemano.
• HasLength() si hay una longitud fija y finita.
• HasShape{N}() si hay una longitud conocida más una noción de forma multidimensional (como para un arreglo). En este caso, N debe indicar el número de dimensiones, y la función axes es válida para el iterador.
• IsInfinite() si el iterador produce valores para siempre.

El valor predeterminado (para iteradores que no definen esta función) es HasLength(). Esto significa que se asume que la mayoría de los iteradores implementan length.

Este rasgo se utiliza generalmente para seleccionar entre algoritmos que pre-asignan espacio para su resultado y algoritmos que redimensionan su resultado de manera incremental.

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

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

IteratorEltype(itertype::Type) -> IteratorEltype

Dado el tipo de un iterador, devuelve uno de los siguientes valores:

• EltypeUnknown() si el tipo de elementos producidos por el iterador no se conoce de antemano.
• HasEltype() si el tipo de elemento es conocido, y eltype devolvería un valor significativo.

HasEltype() es el valor predeterminado, ya que se asume que los iteradores implementan eltype.

Este rasgo se utiliza generalmente para seleccionar entre algoritmos que pre-asignan un tipo específico de resultado y algoritmos que eligen un tipo de resultado basado en los tipos de los valores producidos.

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

AbstractRange{T} <: AbstractVector{T}

Supertipo para rangos lineales con elementos del tipo T. UnitRange, LinRange y otros tipos son subtipos de esto.

Todos los subtipos deben definir step. Por lo tanto, LogRange no es un subtipo de AbstractRange.

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

Supertipo para rangos ordinales con elementos de tipo T con espaciado(s) de tipo S. Los pasos deben ser siempre múltiplos exactos de oneunit, y T debe ser un tipo "discreto", que no puede tener valores menores que oneunit. Por ejemplo, los tipos Integer o Date calificarían, mientras que Float64 no lo haría (ya que este tipo puede representar valores menores que oneunit(Float64)). UnitRange, StepRange, y otros tipos son subtipos de esto.

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

Supertipo para rangos con un tamaño de paso de oneunit(T) con elementos del tipo T. UnitRange y otros tipos son subtipos de esto.

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

Rangos con elementos de tipo T con espaciado de tipo S. El paso entre cada elemento es constante, y el rango se define en términos de un start y stop de tipo T y un step de tipo S. Ni T ni S deben ser tipos de punto flotante. La sintaxis a:b:c con b != 0 y a, b, y c todos enteros crea un StepRange.

Ejemplos

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}

Un rango parametrizado por un start y stop de tipo T, lleno de elementos espaciados por 1 desde start hasta que se exceda stop. La sintaxis a:b con a y b ambos Integers crea un UnitRange.

Ejemplos

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}

Un rango con len elementos espaciados linealmente entre su start y stop. El tamaño del espaciado está controlado por len, que debe ser un Integer.

Ejemplos

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

En comparación con el uso de range, construir directamente un LinRange debería tener menos sobrecarga pero no intentará corregir errores de punto flotante:

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

Consulta también Logrange para puntos espaciados logarítmicamente.

isempty(collection) -> Bool

Determina si una colección está vacía (no tiene elementos).

Ejemplos

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

Devuelve true si no hay tareas esperando en la condición, false en caso contrario.

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

Esta función proporciona una pista de ruta rápida para la finalización del iterador. Esto es útil para iteradores con estado que desean evitar que los elementos sean consumidos si no van a ser expuestos al usuario (por ejemplo, al verificar si está terminado en isempty o zip).

Los iteradores con estado que desean optar por esta función deben definir un método isdone que devuelva verdadero/falso dependiendo de si el iterador ha terminado o no. Los iteradores sin estado no necesitan implementar esta función.

Si el resultado es missing, los llamadores pueden proceder a calcular iterate(x, state) === nothing para obtener una respuesta definitiva.

Véase también iterate, isempty

empty!(collection) -> collection

Elimina todos los elementos de una collection.

Ejemplos

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} con 2 entradas:
  "b" => 2
  "a" => 1

julia> empty!(A);

julia> A
Dict{String, Int64}()

empty!(c::Channel)

Vacía un Canal c llamando a empty! en el búfer interno. Devuelve el canal vacío.

length(collection) -> Integer

Devuelve el número de elementos en la colección.

Usa lastindex para obtener el último índice válido de una colección indexable.

Ver también: size, ndims, eachindex.

Ejemplos

julia> length(1:5)
5

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

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

Base.checked_length(r)

Calcula length(r), pero puede verificar errores de desbordamiento donde sea aplicable cuando el resultado no cabe en Union{Integer(eltype(r)),Int}.

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

Determina si un elemento está en la colección dada, en el sentido de que es == a uno de los valores generados al iterar sobre la colección. Devuelve un valor Bool, excepto si item es missing o collection contiene missing pero no item, en cuyo caso se devuelve missing (lógica de tres valores, coincidiendo con el comportamiento de any y ==).

Algunas colecciones siguen una definición ligeramente diferente. Por ejemplo, los Sets verifican si el elemento es isequal a uno de los elementos; los Dicts buscan pares key=>value, y la key se compara usando isequal.

Para probar la presencia de una clave en un diccionario, usa haskey o k in keys(dict). Para las colecciones mencionadas anteriormente, el resultado es siempre un Bool.

Al hacer broadcasting con in.(items, collection) o items .∈ collection, tanto item como collection se transmiten, lo cual a menudo no es lo que se pretende. Por ejemplo, si ambos argumentos son vectores (y las dimensiones coinciden), el resultado es un vector que indica si cada valor en la colección items está in el valor en la posición correspondiente en collection. Para obtener un vector que indique si cada valor en items está en collection, envuelve collection en una tupla o un Ref así: in.(items, Ref(collection)) o items .∈ Ref(collection).

Ver también: ∉, insorted, contains, occursin, issubset.

Ejemplos

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

Negación de ∈ y ∋, es decir, verifica que item no esté en collection.

Al hacer broadcasting con items .∉ collection, tanto item como collection se transmiten, lo cual a menudo no es lo que se pretende. Por ejemplo, si ambos argumentos son vectores (y las dimensiones coinciden), el resultado es un vector que indica si cada valor en collection items no está en el valor en la posición correspondiente en collection. Para obtener un vector que indique si cada valor en items no está en collection, envuelve collection en una tupla o un Ref así: items .∉ Ref(collection).

Ejemplos

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)

Determina si la computación x ∈ collection donde collection::T puede considerarse como una operación "rápida" (típicamente de complejidad constante o logarítmica). La definición hasfastin(x) = hasfastin(typeof(x)) se proporciona por conveniencia para que se puedan pasar instancias en lugar de tipos. Sin embargo, la forma que acepta un argumento de tipo debe definirse para nuevos tipos.

El valor predeterminado para hasfastin(T) es true para subtipos de AbstractSet, AbstractDict y AbstractRange y false en caso contrario.

eltype(type)

Determina el tipo de los elementos generados al iterar una colección del type dado. Para los tipos de diccionario, esto será un Pair{KeyType,ValType}. La definición eltype(x) = eltype(typeof(x)) se proporciona por conveniencia para que se puedan pasar instancias en lugar de tipos. Sin embargo, la forma que acepta un argumento de tipo debe definirse para nuevos tipos.

Véase también: keytype, typeof.

Ejemplos

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

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

indexin(a, b)

Devuelve un array que contiene el primer índice en b para cada valor en a que es un miembro de b. El array de salida contiene nothing donde quiera que a no sea un miembro de b.

Véase también: sortperm, findfirst.

Ejemplos

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)

Devuelve un array que contiene solo los elementos únicos de la colección itr, según lo determinado por isequal y hash, en el orden en que aparece por primera vez cada conjunto de elementos equivalentes. Se preserva el tipo de elemento de la entrada.

Véase también: unique!, allunique, allequal.

Ejemplos

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)

Devuelve un array que contiene un valor de itr para cada valor único producido por f aplicado a los elementos de itr.

Ejemplos

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

Esta funcionalidad también se puede utilizar para extraer los índices de las primeras ocurrencias de elementos únicos en un array:

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)

Devuelve regiones únicas de A a lo largo de la dimensión dims.

Ejemplos

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)

Selecciona un valor de A para cada valor único producido por f aplicado a los elementos de A, y luego devuelve el A modificado.

Ejemplos

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)

Elimina los elementos duplicados según lo determinado por isequal y hash, y luego devuelve el A modificado. unique! devolverá los elementos de A en el orden en que ocurren. Si no te importa el orden de los datos devueltos, entonces llamar a (sort!(A); unique!(A)) será mucho más eficiente siempre que los elementos de A se puedan ordenar.

Ejemplos

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! puede procesar datos ordenados de manera mucho más eficiente.

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

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

Devuelve true si todos los valores de itr son distintos cuando se comparan con isequal. O si todos los de [f(x) for x in itr] son distintos, para el segundo método.

Ten en cuenta que allunique(f, itr) puede llamar a f menos de length(itr) veces. El número preciso de llamadas se considera un detalle de implementación.

allunique puede utilizar una implementación especializada cuando la entrada está ordenada.

Consulta también: unique, issorted, allequal.

Ejemplos

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

Devuelve true si todos los valores de itr son iguales cuando se comparan con isequal. O si todos los de [f(x) for x in itr] son iguales, para el segundo método.

Ten en cuenta que allequal(f, itr) puede llamar a f menos de length(itr) veces. El número preciso de llamadas se considera un detalle de implementación.

Ver también: unique, allunique.

Ejemplos

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

Reduce la colección dada itr con el operador binario dado op. Si se proporciona, el valor inicial init debe ser un elemento neutro para op que se devolverá para colecciones vacías. No se especifica si init se utiliza para colecciones no vacías.

Para colecciones vacías, proporcionar init será necesario, excepto en algunos casos especiales (por ejemplo, cuando op es uno de +, *, max, min, &, |) cuando Julia puede determinar el elemento neutro de op.

Las reducciones para ciertos operadores de uso común pueden tener implementaciones especiales y deben usarse en su lugar: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr). Hay métodos eficientes para concatenar ciertos arreglos de arreglos llamando a reduce(vcat, arr) o reduce(hcat, arr).

La asociatividad de la reducción depende de la implementación. Esto significa que no puedes usar operaciones no asociativas como - porque no está definido si reduce(-,[1,2,3]) debe evaluarse como (1-2)-3 o 1-(2-3). Usa foldl o foldr en su lugar para garantizar la asociatividad izquierda o derecha.

Algunas operaciones acumulan error. El paralelismo será más fácil si la reducción se puede ejecutar en grupos. Las futuras versiones de Julia podrían cambiar el algoritmo. Ten en cuenta que los elementos no se reordenan si usas una colección ordenada.

Ejemplos

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

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

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

Reduce la función de 2 argumentos f a lo largo de las dimensiones de A. dims es un vector que especifica las dimensiones a reducir, y el argumento de palabra clave init es el valor inicial a utilizar en las reducciones. Para +, *, max y min, el argumento init es opcional.

La asociatividad de la reducción depende de la implementación; si necesitas una asociatividad particular, por ejemplo, de izquierda a derecha, deberías escribir tu propio bucle o considerar usar foldl o foldr. Consulta la documentación para reduce.

Ejemplos

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

Como reduce, pero con asociatividad izquierda garantizada. Si se proporciona, el argumento clave init se utilizará exactamente una vez. En general, será necesario proporcionar init para trabajar con colecciones vacías.

Véase también mapfoldl, foldr, accumulate.

Ejemplos

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

Como reduce, pero con asociatividad a la derecha garantizada. Si se proporciona, el argumento clave init se utilizará exactamente una vez. En general, será necesario proporcionar init para trabajar con colecciones vacías.

Ejemplos

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

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

maximum(f, itr; [init])

Devuelve el resultado más grande de llamar a la función f en cada elemento de itr.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser un elemento neutro para max (es decir, que sea menor o igual que cualquier otro elemento) ya que no está especificado si init se utiliza para colecciones no vacías.

Ejemplos

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

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

julia> maximum(sin, Real[]; init=-1.0)  # bien, ya que la salida de sin es >= -1
-1.0

maximum(itr; [init])

Devuelve el elemento más grande en una colección.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser un elemento neutro para max (es decir, que sea menor o igual que cualquier otro elemento) ya que no está especificado si init se utiliza para colecciones no vacías.

Ejemplos

julia> maximum(-20.5:10)
9.5

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

julia> maximum(())
ERROR: ArgumentError: reducir sobre una colección vacía no está permitido; considera proporcionar `init` al reductor
Stacktrace:
[...]

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

maximum(A::AbstractArray; dims)

Calcula el valor máximo de un array sobre las dimensiones dadas. Consulta también la función max(a,b) para obtener el máximo de dos o más argumentos, que se puede aplicar elemento por elemento a arrays a través de max.(a,b).

Consulta también: maximum!, extrema, findmax, argmax.

Ejemplos

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)

Calcula el valor máximo llamando a la función f en cada elemento de un array sobre las dimensiones dadas.

Ejemplos

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)

Calcula el valor máximo de A sobre las dimensiones singleton de r, y escribe los resultados en r.

Ejemplos

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

Devuelve el resultado más pequeño de llamar a la función f en cada elemento de itr.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser un elemento neutro para min (es decir, que sea mayor o igual que cualquier otro elemento) ya que no está especificado si init se utiliza para colecciones no vacías.

Ejemplos

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

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

julia> minimum(sin, Real[]; init=1.0)  # bien, ya que la salida de sin es <= 1
1.0

minimum(itr; [init])

Devuelve el elemento más pequeño en una colección.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser un elemento neutro para min (es decir, que sea mayor o igual que cualquier otro elemento) ya que no está especificado si init se utiliza para colecciones no vacías.

Ejemplos

julia> minimum(-20.5:10)
-20.5

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

julia> minimum([])
ERROR: ArgumentError: reducir sobre una colección vacía no está permitido; considera proporcionar `init` al reductor
Stacktrace:
[...]

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

minimum(A::AbstractArray; dims)

Calcula el valor mínimo de un array sobre las dimensiones dadas. Véase también la función min(a,b) para tomar el mínimo de dos o más argumentos, que se puede aplicar elemento a elemento a arrays a través de min.(a,b).

Véase también: minimum!, extrema, findmin, argmin.

Ejemplos

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 el valor mínimo llamando a la función f en cada elemento de un array sobre las dimensiones dadas.

Ejemplos

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)

Calcula el valor mínimo de A sobre las dimensiones singleton de r, y escribe los resultados en r.

Ejemplos

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)

Calcula tanto el elemento mínimo mn como el máximo mx en una sola pasada y los devuelve como una tupla de 2 elementos.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser una tupla de 2 elementos cuyos primeros y segundos elementos son elementos neutros para min y max respectivamente (es decir, que son mayores/menores o iguales a cualquier otro elemento). Como consecuencia, cuando itr está vacío, la tupla devuelta (mn, mx) satisfará mn ≥ mx. Cuando init es especificado, puede ser utilizado incluso para itr no vacío.

Ejemplos

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)

Calcula tanto el mínimo mn como el máximo mx de f aplicado a cada elemento en itr y los devuelve como una tupla de 2 elementos. Solo se realiza un pase sobre itr.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser una tupla de 2 elementos cuyos primeros y segundos elementos son elementos neutros para min y max respectivamente (es decir, que son mayores/menores o iguales a cualquier otro elemento). Se utiliza para colecciones no vacías. Nota: implica que, para itr vacío, el valor devuelto (mn, mx) satisface mn ≥ mx aunque para itr no vacío satisface mn ≤ mx. Este es un resultado "paradójico" pero aún así esperado.

Ejemplos

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

julia> extrema(sin, Real[]; init = (1.0, -1.0))  # bien, ya que -1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)

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

Calcula los elementos mínimos y máximos de un array sobre las dimensiones dadas.

Ver también: minimum, maximum, extrema!.

Ejemplos

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}

Calcula el mínimo y el máximo de f aplicado a cada elemento en las dimensiones dadas de A.

extrema!(r, A)

Calcula el valor mínimo y máximo de A sobre las dimensiones singleton de r, y escribe los resultados en r.

Ejemplos

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)

Los rangos pueden tener múltiples elementos máximos. En ese caso, argmax devolverá un índice máximo, pero no necesariamente el primero.

argmax(f, domain)

Devuelve un valor x de domain para el cual f(x) está maximizado. Si hay múltiples valores máximos para f(x), se encontrará el primero.

domain debe ser un iterable no vacío.

Los valores se comparan con isless.

Véase también argmin, findmax.

Ejemplos

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

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

argmax(itr)

Devuelve el índice o clave del elemento máximo en una colección. Si hay múltiples elementos máximos, se devolverá el primero.

La colección no debe estar vacía.

Los índices son del mismo tipo que los devueltos por keys(itr) y pairs(itr).

Los valores se comparan con isless.

Véase también: argmin, findmax.

Ejemplos

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

Para una entrada de matriz, devuelve los índices de los elementos máximos sobre las dimensiones dadas. NaN se trata como mayor que todos los demás valores excepto missing.

Ejemplos

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)

Los rangos pueden tener múltiples elementos mínimos. En ese caso, argmin devolverá un índice mínimo, pero no necesariamente el primero.

argmin(f, domain)

Devuelve un valor x de domain para el cual f(x) es minimizado. Si hay múltiples valores mínimos para f(x), se encontrará el primero.

domain debe ser un iterable no vacío.

NaN se trata como menor que todos los demás valores excepto missing.

Véase también argmax, findmin.

Ejemplos

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)

Devuelve el índice o clave del elemento mínimo en una colección. Si hay múltiples elementos mínimos, se devolverá el primero.

La colección no debe estar vacía.

Los índices son del mismo tipo que los devueltos por keys(itr) y pairs(itr).

NaN se trata como menor que todos los demás valores excepto missing.

Véase también: argmax, findmin.

Ejemplos

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

Para una entrada de matriz, devuelve los índices de los elementos mínimos sobre las dimensiones dadas. NaN se trata como menor que todos los demás valores excepto missing.

Ejemplos

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)

Devuelve un par de un valor en el codominio (salidas de f) y el índice o clave del valor correspondiente en el domain (entradas a f) tal que f(x) está maximizado. Si hay múltiples puntos máximos, se devolverá el primero.

domain debe ser un iterable no vacío que soporte keys. Los índices son del mismo tipo que los devueltos por keys(domain).

Los valores se comparan con isless.

Ejemplos

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)

Devuelve el elemento máximo de la colección itr y su índice o clave. Si hay múltiples elementos máximos, se devolverá el primero. Los valores se comparan con isless.

Los índices son del mismo tipo que los devueltos por keys(itr) y pairs(itr).

Véase también: findmin, argmax, maximum.

Ejemplos

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)

Para una entrada de matriz, devuelve el valor y el índice del máximo sobre las dimensiones dadas. NaN se trata como mayor que todos los demás valores excepto missing.

Ejemplos

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)

Para una entrada de matriz, devuelve el valor en el codominio y el índice del valor correspondiente que maximiza f sobre las dimensiones dadas.

Ejemplos

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)

Devuelve un par de un valor en el codominio (salidas de f) y el índice o clave del valor correspondiente en el domain (entradas a f) tal que f(x) se minimiza. Si hay múltiples puntos mínimos, se devolverá el primero.

domain debe ser un iterable no vacío.

Los índices son del mismo tipo que los devueltos por keys(domain) y pairs(domain).

NaN se trata como menor que todos los demás valores excepto missing.

Ejemplos

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)

Devuelve el elemento mínimo de la colección itr y su índice o clave. Si hay múltiples elementos mínimos, se devolverá el primero. NaN se trata como menor que todos los demás valores excepto missing.

Los índices son del mismo tipo que los devueltos por keys(itr) y pairs(itr).

Véase también: findmax, argmin, minimum.

Ejemplos

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)

Para una entrada de matriz, devuelve el valor y el índice del mínimo sobre las dimensiones dadas. NaN se trata como menor que todos los demás valores excepto missing.

Ejemplos

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)

Para una entrada de matriz, devuelve el valor en el codominio y el índice del valor correspondiente que minimiza f sobre las dimensiones dadas.

Ejemplos

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)

Encuentra el máximo de A y el índice lineal correspondiente a lo largo de las dimensiones singleton de rval y rind, y almacena los resultados en rval y rind. NaN se trata como mayor que todos los demás valores excepto missing.

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

Encuentra el mínimo de A y el índice lineal correspondiente a lo largo de las dimensiones singleton de rval y rind, y almacena los resultados en rval y rind. NaN se trata como menor que todos los demás valores excepto missing.

sum(f, itr; [init])

Suma los resultados de llamar a la función f en cada elemento de itr.

El tipo de retorno es Int para enteros con signo de menos del tamaño de palabra del sistema, y UInt para enteros sin signo de menos del tamaño de palabra del sistema. Para todos los demás argumentos, se encuentra un tipo de retorno común al que se promueven todos los argumentos.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser la identidad aditiva (es decir, cero) ya que no está especificado si init se utiliza para colecciones no vacías.

Ejemplos

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

Nota la importante diferencia entre sum(A) y reduce(+, A) para arreglos con un tipo de elemento entero pequeño:

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

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

En el primer caso, los enteros se amplían al tamaño de palabra del sistema y, por lo tanto, el resultado es 128. En el segundo caso, no ocurre tal ampliación y el desbordamiento de enteros resulta en -128.

sum(itr; [init])

Devuelve la suma de todos los elementos en una colección.

El tipo de retorno es Int para enteros con signo de menos del tamaño de palabra del sistema, y UInt para enteros sin signo de menos del tamaño de palabra del sistema. Para todos los demás argumentos, se encuentra un tipo de retorno común al que se promueven todos los argumentos.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser la identidad aditiva (es decir, cero) ya que no está especificado si init se utiliza para colecciones no vacías.

Véase también: reduce, mapreduce, count, union.

Ejemplos

julia> sum(1:20)
210

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

sum(A::AbstractArray; dims)

Suma los elementos de un arreglo sobre las dimensiones dadas.

Ejemplos

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)

Suma los resultados de llamar a la función f en cada elemento de un array sobre las dimensiones dadas.

Ejemplos

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)

Suma los elementos de A sobre las dimensiones singleton de r, y escribe los resultados en r.

Ejemplos

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

Devuelve el producto de f aplicado a cada elemento de itr.

El tipo de retorno es Int para enteros con signo de menos del tamaño de palabra del sistema, y UInt para enteros sin signo de menos del tamaño de palabra del sistema. Para todos los demás argumentos, se encuentra un tipo de retorno común al que se promueven todos los argumentos.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser la identidad multiplicativa (es decir, uno) ya que no está especificado si init se utiliza para colecciones no vacías.

Ejemplos

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

prod(itr; [init])

Devuelve el producto de todos los elementos de una colección.

El tipo de retorno es Int para enteros con signo de menos del tamaño de palabra del sistema, y UInt para enteros sin signo de menos del tamaño de palabra del sistema. Para todos los demás argumentos, se encuentra un tipo de retorno común al que se promueven todos los argumentos.

El valor devuelto para itr vacío puede ser especificado por init. Debe ser la identidad multiplicativa (es decir, uno) ya que no está especificado si init se utiliza para colecciones no vacías.

Véase también: reduce, cumprod, any.

Ejemplos

julia> prod(1:5)
120

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

prod(A::AbstractArray; dims)

Multiplica los elementos de un array a lo largo de las dimensiones dadas.

Ejemplos

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)

Multiplica los resultados de llamar a la función f en cada elemento de un array sobre las dimensiones dadas.

Ejemplos

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)

Multiplica los elementos de A sobre las dimensiones singleton de r, y escribe los resultados en r.

Ejemplos

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

Prueba si algún elemento de una colección booleana es true, devolviendo true tan pronto como se encuentra el primer valor true en itr (circuito corto). Para hacer un circuito corto en false, usa all.

Si la entrada contiene valores missing, devuelve missing si todos los valores no faltantes son false (o, de manera equivalente, si la entrada no contiene ningún valor true), siguiendo la lógica de tres valores.

Véase también: all, count, sum, |, , ||.

Ejemplos

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

Determina si el predicado p devuelve true para algún elemento de itr, devolviendo true tan pronto como se encuentra el primer elemento en itr para el cual p devuelve true (circuito corto). Para hacer un circuito corto en false, usa all.

Si la entrada contiene valores de missing, devuelve missing si todos los valores no faltantes son false (o, de manera equivalente, si la entrada no contiene ningún valor true), siguiendo la lógica de tres valores.

Ejemplos

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)

Prueba si algún valor en A a lo largo de las dimensiones singleton de r es true, y escribe los resultados en r.

Ejemplos

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

Prueba si todos los elementos de una colección booleana son true, devolviendo false tan pronto como se encuentra el primer valor false en itr (circuito corto). Para hacer un circuito corto en true, usa any.

Si la entrada contiene valores missing, devuelve missing si todos los valores no faltantes son true (o, de manera equivalente, si la entrada no contiene ningún valor false), siguiendo la lógica de tres valores.

Véase también: all!, any, count, &, , &&, allunique.

Ejemplos

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

Determina si el predicado p devuelve true para todos los elementos de itr, devolviendo false tan pronto como se encuentra el primer elemento en itr para el cual p devuelve false (circuito corto). Para hacer un circuito corto en true, usa any.

Si la entrada contiene valores missing, devuelve missing si todos los valores no faltantes son true (o, de manera equivalente, si la entrada no contiene ningún valor false), siguiendo la lógica de tres valores.

Ejemplos

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)

Prueba si todos los valores en A a lo largo de las dimensiones singleton de r son true, y escribe los resultados en r.

Ejemplos

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

Cuenta el número de elementos en itr para los cuales la función f devuelve true. Si se omite f, cuenta el número de elementos true en itr (que debe ser una colección de valores booleanos). init especifica opcionalmente el valor desde el cual comenzar a contar y, por lo tanto, también determina el tipo de salida.

Véase también: any, sum.

Ejemplos

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

Devuelve el número de coincidencias para pattern en string. Esto es equivalente a llamar a length(findall(pattern, string)) pero más eficiente.

Si overlap=true, las secuencias coincidentes pueden superponerse en los índices de la cadena original, de lo contrario, deben ser de rangos de caracteres disjuntos.

Ejemplos

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

Cuenta el número de elementos en A para los cuales f devuelve true sobre las dimensiones dadas.

Ejemplos

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

Llama a la función f en cada elemento del iterable c. Para múltiples argumentos iterables, f se llama elemento por elemento, y la iteración se detiene cuando cualquier iterador ha terminado.

foreach debe usarse en lugar de map cuando no se necesitan los resultados de f, por ejemplo en foreach(println, array).

Ejemplos

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

map(f, c...) -> colección

Transforma la colección c aplicando f a cada elemento. Para múltiples argumentos de colección, aplica f elemento por elemento, y detente cuando cualquiera de ellos se agote.

Ver también map!, foreach, mapreduce, mapslices, zip, Iterators.map.

Ejemplos

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

Al actuar sobre arreglos multidimensionales del mismo ndims, todos deben tener los mismos axes, y la respuesta también lo tendrá.

Véase también broadcast, que permite tamaños desiguales.

Ejemplos

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))  # itera hasta que el 3º se agote
3-element Vector{Float64}:
   2.0
  13.0
 102.0

map!(función, destino, colección...)

Como map, pero almacena el resultado en destino en lugar de en una nueva colección. destino debe ser al menos tan grande como la colección más pequeña.

Véase también: map, foreach, zip, copyto!.

Ejemplos

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

Modifica dict transformando cada valor de val a f(val). Ten en cuenta que el tipo de dict no puede ser cambiado: si f(val) no es una instancia del tipo de valor de dict, entonces se convertirá al tipo de valor si es posible y, de lo contrario, se generará un error.

Ejemplos

julia> d = Dict(:a => 1, :b => 2)
Dict{Symbol, Int64} con 2 entradas:
  :a => 1
  :b => 2

julia> map!(v -> v-1, values(d))
ValueIterator para un Dict{Symbol, Int64} con 2 entradas. Valores:
  0
  1

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

Aplica la función f a cada elemento(s) en itrs, y luego reduce el resultado usando la función binaria op. Si se proporciona, init debe ser un elemento neutro para op que se devolverá para colecciones vacías. No se especifica si init se utiliza para colecciones no vacías. En general, será necesario proporcionar init para trabajar con colecciones vacías.

mapreduce es funcionalmente equivalente a llamar a reduce(op, map(f, itr); init=init), pero en general se ejecutará más rápido ya que no es necesario crear una colección intermedia. Consulta la documentación de reduce y map.

Ejemplos

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

La asociatividad de la reducción depende de la implementación. Además, algunas implementaciones pueden reutilizar el valor de retorno de f para elementos que aparecen múltiples veces en itr. Usa mapfoldl o mapfoldr en su lugar para garantizar la asociatividad izquierda o derecha y la invocación de f para cada valor.

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

Como mapreduce, pero con asociatividad izquierda garantizada, como en foldl. Si se proporciona, el argumento clave init se utilizará exactamente una vez. En general, será necesario proporcionar init para trabajar con colecciones vacías.

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

Como mapreduce, pero con asociatividad a la derecha garantizada, como en foldr. Si se proporciona, el argumento de palabra clave init se utilizará exactamente una vez. En general, será necesario proporcionar init para trabajar con colecciones vacías.

first(coll)

Obtiene el primer elemento de una colección iterable. Devuelve el punto de inicio de un AbstractRange incluso si está vacío.

Véase también: only, firstindex, last.

Ejemplos

julia> first(2:2:10)
2

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

first(itr, n::Integer)

Obtiene los primeros n elementos de la colección iterable itr, o menos elementos si itr no es lo suficientemente largo.

Véase también: startswith, Iterators.take.

Ejemplos

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)

Obtiene una cadena que consiste en los primeros n caracteres de s.

Ejemplos

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

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

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

last(coll)

Obtiene el último elemento de una colección ordenada, si se puede calcular en O(1) tiempo. Esto se logra llamando a lastindex para obtener el último índice. Devuelve el punto final de un AbstractRange incluso si está vacío.

Véase también first, endswith.

Ejemplos

julia> last(1:2:10)
9

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

last(itr, n::Integer)

Obtiene los últimos n elementos de la colección iterable itr, o menos elementos si itr no es lo suficientemente largo.

Ejemplos

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)

Obtiene una cadena que consiste en los últimos n caracteres de s.

Ejemplos

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

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

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

front(x::Tuple)::Tuple

Devuelve un Tuple que consiste en todos los componentes de x excepto el último.

Véase también: first, tail.

Ejemplos

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

julia> Base.front(())
ERROR: ArgumentError: No se puede llamar a front en un tuple vacío.

tail(x::Tuple)::Tuple

Devuelve un Tuple que consiste en todos menos el primer componente de x.

Véase también: front, rest, first, Iterators.peel.

Ejemplos

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

julia> Base.tail(())
ERROR: ArgumentError: No se puede llamar a tail en una tupla vacía.

step(r)

Obtiene el tamaño del paso de un objeto AbstractRange.

Ejemplos

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)

Devuelve un Array de todos los elementos en una colección o iterador. Para diccionarios, devuelve un Vector de key=>value Pairs. Si el argumento es similar a un array o es un iterador con el rasgo HasShape, el resultado tendrá la misma forma y número de dimensiones que el argumento.

Utilizado por comprensiones para convertir una expresión generadora en un Array. Así, en generadores, se puede usar la notación de corchetes en lugar de llamar a collect, ver segundo ejemplo.

Ejemplos

Recoger elementos de una colección UnitRange{Int64}:

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

Recoger elementos de un generador (mismo resultado 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(tipo_de_elemento, colección)

Devuelve un Array con el tipo de elemento dado de todos los elementos en una colección o iterable. El resultado tiene la misma forma y número de dimensiones que colección.

Ejemplos

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

filter(f, a)

Devuelve una copia de la colección a, eliminando los elementos para los cuales f es false. La función f recibe un argumento.

Véase también: filter!, Iterators.filter.

Ejemplos

julia> a = 1:10
1:10

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

filter(f)

Crea una función que filtra sus argumentos con la función f usando filter, es decir, una función equivalente a x -> filter(f, x).

La función devuelta es de tipo Base.Fix1{typeof(filter)}, que se puede usar para implementar métodos especializados.

Ejemplos

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)

Devuelve una copia de d, eliminando elementos para los cuales f es false. La función f recibe pares key=>value.

Ejemplos

julia> d = Dict(1=>"a", 2=>"b")
Dict{Int64, String} con 2 entradas:
  2 => "b"
  1 => "a"

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

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

Devuelve un vector similar al array envuelto por el iterador SkipMissing dado, pero con todos los elementos faltantes y aquellos para los cuales f devuelve false eliminados.

Ejemplos

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)

Actualiza la colección a, eliminando elementos para los cuales f es false. La función f recibe un argumento.

Ejemplos

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

filter!(f, d::AbstractDict)

Actualiza d, eliminando elementos para los cuales f es false. La función f recibe pares key=>value.

Ejemplos

julia> d = Dict(1=>"a", 2=>"b", 3=>"c")
Dict{Int64, String} con 3 entradas:
  2 => "b"
  3 => "c"
  1 => "a"

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

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

Devuelve una copia de la colección A donde, para cada par old=>new en old_new, todas las ocurrencias de old son reemplazadas por new. La igualdad se determina usando isequal. Si se especifica count, entonces se reemplazarán como máximo count ocurrencias en total.

El tipo de elemento del resultado se elige usando promoción (ver promote_type) basado en el tipo de elemento de A y en los tipos de los valores new en los pares. Si se omite count y el tipo de elemento de A es un Union, el tipo de elemento del resultado no incluirá tipos singleton que son reemplazados por valores de un tipo diferente: por ejemplo, Union{T,Missing} se convertirá en T si missing es reemplazado.

Ver también replace!, splice!, delete!, insert!.

Ejemplos

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

Devuelve una copia de A donde cada valor x en A es reemplazado por new(x). Si se especifica count, entonces reemplaza como máximo count valores en total (los reemplazos se definen como new(x) !== x).

Ejemplos

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

Para cada par old=>new en old_new, reemplaza todas las ocurrencias de old en la colección A por new. La igualdad se determina usando isequal. Si se especifica count, entonces reemplaza como máximo count ocurrencias en total. Véase también replace.

Ejemplos

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

Reemplaza cada elemento x en la colección A por new(x). Si se especifica count, entonces reemplaza como máximo count valores en total (los reemplazos se definen como new(x) !== x).

Ejemplos

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

Función genérica para tomar la cola de collection, comenzando desde un estado de iteración específico itr_state. Devuelve un Tuple, si collection es un Tuple, un subtipo de AbstractVector, si collection es un AbstractArray, un subtipo de AbstractString si collection es un AbstractString, y un iterador arbitrario, recurriendo a Iterators.rest(collection[, itr_state]), de lo contrario.

Se puede sobrecargar para tipos de colección definidos por el usuario para personalizar el comportamiento de slurping in assignments en la posición final, como a, b... = collection.

Véase también: first, Iterators.rest, Base.split_rest.

Ejemplos

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)

Función genérica para dividir la cola de collection, comenzando desde un estado de iteración específico itr_state. Devuelve una tupla de dos nuevas colecciones. La primera contiene todos los elementos de la cola menos los n últimos, que constituyen la segunda colección.

El tipo de la primera colección generalmente sigue el de Base.rest, excepto que el caso por defecto no es perezoso, sino que se recopila de manera ansiosa en un vector.

Se puede sobrecargar para tipos de colección definidos por el usuario para personalizar el comportamiento de slurping en asignaciones en posición no final, como a, b..., c = collection.

Véase también: Base.rest.

Ejemplos

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

Recupera el(los) valor(es) almacenado(s) en la clave o índice dado dentro de una colección. La sintaxis a[i,j,...] es convertida por el compilador a getindex(a, i, j, ...).

Véase también get, keys, eachindex.

Ejemplos

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} con 2 entradas:
  "b" => 2
  "a" => 1

julia> getindex(A, "a")
1

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

Almacena el valor dado en la clave o índice dado dentro de una colección. La sintaxis a[i,j,...] = x es convertida por el compilador a (setindex!(a, x, i, j, ...); x).

Ejemplos

julia> a = Dict("a"=>1)
Dict{String, Int64} con 1 entrada:
  "a" => 1

julia> setindex!(a, 2, "b")
Dict{String, Int64} con 2 entradas:
  "b" => 2
  "a" => 1

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

Devuelve el primer índice de collection. Si se proporciona d, devuelve el primer índice de collection a lo largo de la dimensión d.

Las sintaxis A[begin] y A[1, begin] se traducen a A[firstindex(A)] y A[1, firstindex(A, 2)], respectivamente.

Véase también: first, axes, lastindex, nextind.

Ejemplos

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

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

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

Devuelve el último índice de collection. Si se proporciona d, devuelve el último índice de collection a lo largo de la dimensión d.

Las sintaxis A[end] y A[end, end] se traducen a A[lastindex(A)] y A[lastindex(A, 1), lastindex(A, 2)], respectivamente.

Véase también: axes, firstindex, eachindex, prevind.

Ejemplos

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

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

AbstractDict{K, V}

Supertipo para tipos similares a diccionarios con claves del tipo K y valores del tipo V. Dict, IdDict y otros tipos son subtipos de este. Un AbstractDict{K, V} debería ser un iterador de Pair{K, V}.

Dict([itr])

Dict{K,V}() construye una tabla hash con claves del tipo K y valores del tipo V. Las claves se comparan con isequal y se hash con hash.

Dado un único argumento iterable, construye un Dict cuyas parejas clave-valor se toman de tuplas de 2 elementos (clave, valor) generadas por el argumento.

Ejemplos

julia> Dict([("A", 1), ("B", 2)])
Dict{String, Int64} con 2 entradas:
  "B" => 2
  "A" => 1

Alternativamente, se puede pasar una secuencia de argumentos en pareja.

julia> Dict("A"=>1, "B"=>2)
Dict{String, Int64} con 2 entradas:
  "B" => 2
  "A" => 1

IdDict([itr])

IdDict{K,V}() construye una tabla hash utilizando objectid como hash y === como igualdad con claves del tipo K y valores del tipo V. Consulta Dict para más ayuda y IdSet para la versión de conjunto de esto.

En el ejemplo a continuación, las claves de Dict son todas isequal y, por lo tanto, se hashan de la misma manera, así que se sobrescriben. El IdDict hash por id de objeto, y por lo tanto preserva las 3 claves diferentes.

Ejemplos

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

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

WeakKeyDict([itr])

WeakKeyDict() construye una tabla hash donde las claves son referencias débiles a objetos que pueden ser recolectados por el recolector de basura incluso cuando están referenciados en una tabla hash.

Consulta Dict para más ayuda. Ten en cuenta que, a diferencia de Dict, WeakKeyDict no convierte las claves al insertarlas, ya que esto implicaría que el objeto clave no estaba referenciado en ningún lugar antes de la inserción.

Consulta también WeakRef.

ImmutableDict

ImmutableDict es un diccionario implementado como una lista enlazada inmutable, que es óptima para diccionarios pequeños que se construyen a través de muchas inserciones individuales. Tenga en cuenta que no es posible eliminar un valor, aunque se puede sobrescribir parcialmente y ocultar insertando un nuevo valor con la misma clave.

ImmutableDict(KV::Pair)

Crea una nueva entrada en el ImmutableDict para un par clave => valor

• use (clave => valor) in dict para ver si esta combinación particular está en el conjunto de propiedades
• use get(dict, clave, por_defecto) para recuperar el valor más reciente para una clave particular

PersistentDict

PersistentDict es un diccionario implementado como un trie mapeado de matriz hash, que es óptimo para situaciones donde necesitas persistencia, cada operación devuelve un nuevo diccionario separado del anterior, pero la implementación subyacente es eficiente en espacio y puede compartir almacenamiento entre múltiples diccionarios separados.

PersistentDict(KV::Pair)

Ejemplos

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

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

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

haskey(collection, key) -> Bool

Determina si una colección tiene un mapeo para una key dada.

Ejemplos

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

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

Devuelve el valor almacenado para la clave dada, o el valor predeterminado dado si no hay un mapeo para la clave presente.

Ejemplos

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)

Devuelve el valor almacenado para la clave dada, o si no hay un mapeo para la clave, devuelve f(). Usa get! para también almacenar el valor predeterminado en el diccionario.

Esto está destinado a ser llamado usando la sintaxis de bloque do

get(dict, key) do
    # valor predeterminado calculado aquí
    time()
end

get!(collection, key, default)

Devuelve el valor almacenado para la clave dada, o si no hay un mapeo para la clave, almacena key => default, y devuelve default.

Ejemplos

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} con 4 entradas:
  "c" => 3
  "b" => 2
  "a" => 1
  "d" => 4

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

Devuelve el valor almacenado para la clave dada, o si no hay un mapeo para la clave, almacena key => f(), y devuelve f().

Esto está destinado a ser llamado utilizando la sintaxis de bloque do.

Ejemplos

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)

Devuelve la clave que coincide con el argumento key si existe en collection, de lo contrario devuelve default.

Ejemplos

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

julia> getkey(D, 'a', 1)
'a': ASCII/Unicode U+0061 (categoría Ll: Letra, minúscula)

julia> getkey(D, 'd', 'a')
'a': ASCII/Unicode U+0061 (categoría Ll: Letra, minúscula)

delete!(collection, key)

Elimina la asignación para la clave dada en una colección, si existe, y devuelve la colección.

Ejemplos

julia> d = Dict("a"=>1, "b"=>2)
Dict{String, Int64} con 2 entradas:
  "b" => 2
  "a" => 1

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

julia> delete!(d, "b") # d permanece sin cambios
Dict{String, Int64} con 1 entrada:
  "a" => 1

pop!(collection, key[, default])

Elimina y devuelve el mapeo para key si existe en collection, de lo contrario devuelve default, o lanza un error si default no está especificado.

Ejemplos

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)

Para un iterador o colección que tiene claves y valores (por ejemplo, arreglos y diccionarios), devuelve un iterador sobre las claves.

values(iterator)

Para un iterador o colección que tiene claves y valores, devuelve un iterador sobre los valores. Esta función simplemente devuelve su argumento por defecto, ya que los elementos de un iterador general se consideran normalmente sus "valores".

Ejemplos

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)

Devuelve un iterador sobre todos los valores en una colección. collect(values(a)) devuelve un array de valores. Cuando los valores se almacenan internamente en una tabla hash, como es el caso de Dict, el orden en que se devuelven puede variar. Pero keys(a), values(a) y pairs(a) iteran sobre a y devuelven los elementos en el mismo orden.

Ejemplos

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

julia> collect(values(D))
Vector{Int64} de 2 elementos:
 2
 3

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

Un iterador que accede a cada elemento del arreglo A, devolviendo i => x, donde i es el índice del elemento y x = A[i]. Idéntico a pairs(A), excepto que se puede seleccionar el estilo del índice. También es similar a enumerate(A), excepto que i será un índice válido para A, mientras que enumerate siempre cuenta desde 1 independientemente de los índices de A.

Especificar IndexLinear() asegura que i será un entero; especificar IndexCartesian() asegura que i será un Base.CartesianIndex; especificar IndexStyle(A) elige el que se ha definido como el estilo de indexación nativo para el arreglo A.

La mutación de los límites del arreglo subyacente invalidará este iterador.

Ejemplos

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

Ver también IndexStyle, axes.

pares(colección)

Devuelve un iterador sobre pares clave => valor para cualquier colección que mapea un conjunto de claves a un conjunto de valores. Esto incluye arreglos, donde las claves son los índices del arreglo. Cuando las entradas se almacenan internamente en una tabla hash, como es el caso de Dict, el orden en que se devuelven puede variar. Pero keys(a), values(a) y pairs(a) iteran sobre a y devuelven los elementos en el mismo orden.

Ejemplos

julia> a = Dict(zip(["a", "b", "c"], [1, 2, 3]))
Dict{String, Int64} con 3 entradas:
  "c" => 3
  "b" => 2
  "a" => 1

julia> pairs(a)
Dict{String, Int64} con 3 entradas:
  "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
Vector{Pair{Symbol, Int64}} de 3 elementos:
 :a => 1
 :b => 2
 :c => 3

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

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

Fusiona las propiedades de la cara initial y others, dando prioridad a las caras posteriores.

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

Construye una colección combinada a partir de las colecciones dadas. Si es necesario, los tipos de la colección resultante se promoverán para acomodar los tipos de las colecciones combinadas. Si la misma clave está presente en otra colección, el valor para esa clave será el valor que tiene en la última colección listada. Véase también mergewith para el manejo personalizado de valores con la misma clave.

Ejemplos

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} con 2 entradas:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} con 2 entradas:
  "bar" => 4711
  "baz" => 17

julia> merge(a, b)
Dict{String, Float64} con 3 entradas:
  "bar" => 4711.0
  "baz" => 17.0
  "foo" => 0.0

julia> merge(b, a)
Dict{String, Float64} con 3 entradas:
  "bar" => 42.0
  "baz" => 17.0
  "foo" => 0.0

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

Construye un nuevo tuple nombrado al fusionar dos o más existentes, de manera asociativa a la izquierda. La fusión procede de izquierda a derecha, entre pares de tuples nombrados, y por lo tanto el orden de los campos presentes en los tuples nombrados más a la izquierda y más a la derecha ocupa la misma posición que se encuentra en el tuple nombrado más a la izquierda. Sin embargo, los valores se toman de los campos coincidentes en el tuple nombrado más a la derecha que contiene ese campo. Los campos presentes solo en el tuple nombrado más a la derecha de un par se añaden al final. Se implementa un fallback para cuando solo se suministra un solo tuple nombrado, con la firma merge(a::NamedTuple).

Ejemplos

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)

Interpreta un iterable de pares clave-valor como un tuple nombrado y realiza una fusión.

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

Construye una colección combinada a partir de las colecciones dadas. Si es necesario, los tipos de la colección resultante se promoverán para acomodar los tipos de las colecciones combinadas. Los valores con la misma clave se combinarán utilizando la función combinadora. La forma curried mergewith(combine) devuelve la función (args...) -> mergewith(combine, args...).

El método merge(combine::Union{Function,Type}, args...) como un alias de mergewith(combine, args...) sigue disponible por compatibilidad hacia atrás.

Ejemplos

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} con 2 entradas:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} con 2 entradas:
  "bar" => 4711
  "baz" => 17

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

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

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

Actualiza la colección con pares de las otras colecciones. Ver también merge.

Ejemplos

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

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

julia> merge!(d1, d2);

julia> d1
Dict{Int64, Int64} con 3 entradas:
  4 => 5
  3 => 4
  1 => 4

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

Actualiza la colección con pares de las otras colecciones. Los valores con la misma clave se combinarán utilizando la función combinadora. La forma curried mergewith!(combine) devuelve la función (args...) -> mergewith!(combine, args...).

El método merge!(combine::Union{Function,Type}, args...) como un alias de mergewith!(combine, args...) sigue disponible por compatibilidad hacia atrás.

Ejemplos

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

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

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

julia> d1
Dict{Int64, Int64} con 3 entradas:
  4 => 5
  3 => 4
  1 => 6

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

julia> d1
Dict{Int64, Int64} con 3 entradas:
  4 => 0
  3 => 0
  1 => 0

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

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

Sugiere que la colección s reserve capacidad para al menos n elementos. Es decir, si esperas que vas a tener que agregar muchos valores a s, puedes evitar el costo de la realocación incremental haciéndolo una vez al principio; esto puede mejorar el rendimiento.

Si first es true, entonces se reserva espacio adicional antes del inicio de la colección. De esta manera, las llamadas subsiguientes a pushfirst! (en lugar de push!) pueden volverse más rápidas. Suministrar esta palabra clave puede resultar en un error si la colección no está ordenada o si pushfirst! no es compatible con esta colección.

Si shrink=true (el valor predeterminado), la capacidad de la colección puede reducirse si su capacidad actual es mayor que n.

Ver también resize!.

Notas sobre el modelo de rendimiento

Para tipos que soportan sizehint!,

1. Los métodos push! y append! generalmente pueden (pero no están obligados a) preasignar almacenamiento adicional. Para tipos implementados en Base, típicamente lo hacen, utilizando una heurística optimizada para un caso de uso general.
2. sizehint! puede controlar esta preasignación. Nuevamente, típicamente lo hace para tipos en Base.
3. empty! es casi sin costo (y O(1)) para tipos que soportan este tipo de preasignación.

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

Devuelve el tipo de clave de un arreglo. Esto es igual al eltype del resultado de keys(...), y se proporciona principalmente por compatibilidad con la interfaz de diccionario.

Ejemplos

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

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

keytype(type)

Obtiene el tipo de clave de un tipo de diccionario. Se comporta de manera similar a eltype.

Ejemplos

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

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

Devuelve el tipo de valor de un arreglo. Esto es idéntico a eltype y se proporciona principalmente por compatibilidad con la interfaz de diccionario.

Ejemplos

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

valtype(type)

Obtiene el tipo de valor de un tipo de diccionario. Se comporta de manera similar a eltype.

Ejemplos

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

AbstractSet{T}

Supertipo para tipos similares a conjuntos cuyos elementos son del tipo T. Set, BitSet y otros tipos son subtipos de este.

Set{T} <: AbstractSet{T}

Los Set son contenedores mutables que proporcionan una prueba de pertenencia rápida.

Los Set tienen implementaciones eficientes de operaciones de conjunto como in, union e intersect. Los elementos en un Set son únicos, según lo determinado por la definición de isequal de los elementos. El orden de los elementos en un Set es un detalle de implementación y no se puede confiar en él.

Véase también: AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

Ejemplos

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

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

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

julia> -0.0 in s # isequal(0.0, -0.0) es falso
false

julia> NaN in s # isequal(NaN, NaN) es verdadero
true

BitSet([itr])

Construye un conjunto ordenado de Ints generado por el objeto iterable dado, o un conjunto vacío. Implementado como una cadena de bits, y por lo tanto diseñado para conjuntos de enteros densos. Si el conjunto será disperso (por ejemplo, conteniendo unos pocos enteros muy grandes), utiliza Set en su lugar.

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

IdSet{T}() construye un conjunto (ver Set) utilizando === como igualdad con valores del tipo T.

En el ejemplo a continuación, los valores son todos isequal por lo que se sobrescriben en el Set ordinario. El IdSet compara por === y por lo tanto preserva los 3 valores diferentes.

Ejemplos

julia> Set(Any[true, 1, 1.0])
Set{Any} con 1 elemento:
  1.0

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

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

Construye un objeto que contenga todos los elementos distintos de todos los argumentos.

El primer argumento controla qué tipo de contenedor se devuelve. Si este es un array, mantiene el orden en el que los elementos aparecen por primera vez.

El Unicode ∪ se puede escribir escribiendo \cup y luego presionando tab en el REPL de Julia, y en muchos editores. Este es un operador infijo, permitiendo s ∪ itr.

Véase también unique, intersect, isdisjoint, vcat, Iterators.flatten.

Ejemplos

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

Construye la union de los conjuntos pasados y sobrescribe s con el resultado. Mantiene el orden con los arreglos.

Ejemplos

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

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

julia> a
Set{Int64} con 5 elementos:
  5
  4
  7
  3
  1

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

Construye el conjunto que contiene aquellos elementos que aparecen en todos los argumentos.

El primer argumento controla qué tipo de contenedor se devuelve. Si este es un array, mantiene el orden en el que los elementos aparecen por primera vez.

El Unicode ∩ se puede escribir escribiendo \cap y luego presionando tab en el REPL de Julia, y en muchos editores. Este es un operador infijo, permitiendo s ∩ itr.

Véase también setdiff, isdisjoint, issubset, issetequal.

Ejemplos

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

Construye el conjunto de elementos en s pero no en ninguno de los iterables en itrs. Mantiene el orden con arreglos.

Véase también setdiff!, union y intersect.

Ejemplos

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

setdiff!(s, itrs...)

Elimina del conjunto s (in situ) cada elemento de cada iterable de itrs. Mantiene el orden con arreglos.

Ejemplos

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

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

julia> a
Set{Int64} con 1 elemento:
  4

symdiff(s, itrs...)

Construye la diferencia simétrica de los elementos en los conjuntos pasados. Cuando s no es un AbstractSet, se mantiene el orden.

Véase también symdiff!, setdiff, union y intersect.

Ejemplos

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

Construye la diferencia simétrica de los conjuntos pasados y sobrescribe s con el resultado. Cuando s es un arreglo, se mantiene el orden. Ten en cuenta que en este caso la multiplicidad de los elementos es importante.

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

Intersecar todos los conjuntos pasados y sobrescribir s con el resultado. Mantener el orden con arreglos.

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

Determina si cada elemento de a también está en b, utilizando in.

Véase también ⊊, ⊈, ∩, ∪, contains.

Ejemplos

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á en s, devuelve true. Si no, agrega x a s y devuelve false. Esto es equivalente a in(x, s) ? true : (push!(s, x); false), pero puede tener una implementación más eficiente.

Véase también: in, push!, Set

Ejemplos

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

julia> length(s)
4

julia> in!(0x04, s)
true

julia> s
Set{Any} con 4 elementos:
  4
  2
  3
  1

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

Negación de ⊆ y ⊇, es decir, verifica que a no sea un subconjunto de b.

Véase también issubset (⊆), ⊊.

Ejemplos

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

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

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

Determina si a es un subconjunto de, pero no igual a, b.

Véase también issubset (⊆), ⊈.

Ejemplos

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

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

issetequal(a, b) -> Bool

Determina si a y b tienen los mismos elementos. Equivalente a a ⊆ b && b ⊆ a pero más eficiente cuando es posible.

Véase también: isdisjoint, union.

Ejemplos

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

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

issetequal(x)

Crea una función que compara su argumento con x utilizando issetequal, es decir, una función equivalente a y -> issetequal(y, x). La función devuelta es de tipo Base.Fix2{typeof(issetequal)}, que se puede utilizar para implementar métodos especializados.

isdisjoint(a, b) -> Bool

Determina si las colecciones a y b son disjuntas. Equivalente a isempty(a ∩ b) pero más eficiente cuando es posible.

Véase también: intersect, isempty, issetequal.

Ejemplos

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

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

isdisjoint(x)

Crea una función que compara su argumento con x usando isdisjoint, es decir, una función equivalente a y -> isdisjoint(y, x). La función devuelta es de tipo Base.Fix2{typeof(isdisjoint)}, que se puede usar para implementar métodos especializados.

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

Inserta uno o más items en collection. Si collection es un contenedor ordenado, los elementos se insertan al final (en el orden dado).

Ejemplos

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

Si collection es ordenado, usa append! para agregar todos los elementos de otro contenedor a él. El resultado del ejemplo anterior es equivalente a append!([1, 2, 3], [4, 5, 6]). Para objetos AbstractSet, se puede usar union! en su lugar.

Consulta sizehint! para notas sobre el modelo de rendimiento.

Consulta también pushfirst!.

pop!(colección) -> elemento

Elimina un elemento en colección y lo devuelve. Si colección es un contenedor ordenado, se devuelve el último elemento; para contenedores desordenados, se devuelve un elemento arbitrario.

Véase también: popfirst!, popat!, delete!, deleteat!, splice!, y push!.

Ejemplos

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} con 2 elementos:
  2
  1

julia> pop!(S)
2

julia> S
Set{Int64} con 1 elemento:
  1

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

pop!(collection, key[, default])

Elimina y devuelve el mapeo para key si existe en collection, de lo contrario devuelve default, o lanza un error si default no está especificado.

Ejemplos

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

Elimina el elemento en el índice dado i y lo devuelve. Los elementos subsiguientes se desplazan para llenar el hueco resultante. Cuando i no es un índice válido para a, devuelve default, o lanza un error si default no está especificado.

Véase también: pop!, popfirst!, deleteat!, splice!.

Ejemplos

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

julia> a
Vector{Int64} de 3 elementos:
 4
 2
 1

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

julia> popat!(a, 4)
ERROR: BoundsError: intento de acceder a Vector{Int64} de 3 elementos en el índice [4]
[...]

pushfirst!(colección, elementos...) -> colección

Inserta uno o más elementos al principio de colección.

Esta función se llama unshift en muchos otros lenguajes de programación.

Ejemplos

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

popfirst!(colección) -> elemento

Elimina el primer elemento de colección.

Esta función se llama shift en muchos otros lenguajes de programación.

Ver también: pop!, popat!, delete!.

Ejemplos

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)

Inserta un item en a en el índice dado index. index es el índice de item en el resultado de a.

Véase también: push!, replace, popat!, splice!.

Ejemplos

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

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

Elimina el elemento en el índice dado i y devuelve el a modificado. Los elementos posteriores se desplazan para llenar el hueco resultante.

Véase también: keepat!, delete!, popat!, splice!.

Ejemplos

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

deleteat!(a::Vector, inds)

Elimina los elementos en los índices dados por inds, y devuelve el a modificado. Los elementos subsiguientes se desplazan para llenar el hueco resultante.

inds puede ser un iterador o una colección de índices enteros únicos y ordenados, o un vector booleano de la misma longitud que a con true indicando las entradas a eliminar.

Ejemplos

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)

Elimina los elementos en todos los índices que no están dados por inds, y devuelve el a modificado. Los elementos que se mantienen se desplazan para llenar los huecos resultantes.

inds debe ser un iterador de índices enteros únicos y ordenados. Ver también deleteat!.

Ejemplos

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 versión en el lugar de la indexación lógica a = a[m]. Es decir, keepat!(a, m) en vectores de igual longitud a y m eliminará todos los elementos de a para los cuales m en el índice correspondiente es false.

Ejemplos

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

Elimina el elemento en el índice dado y devuelve el elemento eliminado. Los elementos subsiguientes se desplazan a la izquierda para llenar el espacio resultante. Si se especifica, los valores de reemplazo de una colección ordenada se insertarán en lugar del elemento eliminado.

Véase también: replace, delete!, deleteat!, pop!, popat!.

Ejemplos

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

Para insertar replacement antes de un índice n sin eliminar ningún elemento, usa splice!(collection, n:n-1, replacement).

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

Elimina elementos en los índices especificados y devuelve una colección que contiene los elementos eliminados. Los elementos subsiguientes se desplazan a la izquierda para llenar los huecos resultantes. Si se especifica, los valores de reemplazo de una colección ordenada se insertarán en lugar de los elementos eliminados; en este caso, indices debe ser un AbstractUnitRange.

Para insertar replacement antes de un índice n sin eliminar ningún elemento, usa splice!(collection, n:n-1, replacement).

Ejemplos

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

Redimensiona a para contener n elementos. Si n es menor que la longitud actual de la colección, se conservarán los primeros n elementos. Si n es mayor, no se garantiza que los nuevos elementos estén inicializados.

Ejemplos

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.

Para un contenedor ordenado collection, agrega los elementos de cada collections al final de él.

Ejemplos

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

Usa push! para agregar elementos individuales a collection que no estén ya en otra colección. El resultado del ejemplo anterior es equivalente a push!([1, 2, 3], 4, 5, 6).

Consulta sizehint! para notas sobre el modelo de rendimiento.

Consulta también vcat para vectores, union! para conjuntos, y prepend! y pushfirst! para el orden opuesto.

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

Inserta los elementos de cada collections al principio de a.

Cuando collections especifica múltiples colecciones, se mantiene el orden: los elementos de collections[1] aparecerán más a la izquierda en a, y así sucesivamente.

Ejemplos

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

Construya un objeto Pair con el tipo Pair{typeof(x), typeof(y)}. Los elementos se almacenan en los campos first y second. También se pueden acceder a través de la iteración (pero un Pair se trata como un único "escalar" para las operaciones de difusión).

Véase también Dict.

Ejemplos

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

Transforma un contenedor indexable en una vista de Diccionario de los mismos datos. Modificar el espacio de claves de los datos subyacentes puede invalidar este objeto.