Ввод/вывод и сеть

Общие операции ввода/вывода

Base.STDOUTКонстанта

STDOUT

Глобальная переменная, ссылающаяся на стандартный поток вывода.

Base.STDERRКонстанта

STDERR

Глобальная переменная, ссылающаяся на стандартный поток ошибок.

Base.STDINКонстанта

STDIN

Глобальная переменная, ссылающаяся на стандартный поток ввода.

Base.openФункция

open(filename::AbstractString, [read::Bool, write::Bool, create::Bool, truncate::Bool, append::Bool]) -> IOStream

Открывает файл в режиме, заданном пятью булевыми аргументами. По умолчанию файлы открываются только для чтения. Возвращает поток для доступа к файлу.

open(filename::AbstractString, [mode::AbstractString]) -> IOStream

Альтернативный синтаксис для open, где используется строковый спецификатор режима вместо пяти булевых значений. Значения mode соответствуют значениям из fopen(3) или Perl open, и эквивалентны установке следующих булевых групп:

open(f::Function, args...)

Применяет функцию f к результату open(args...) и закрывает полученный дескриптор файла по завершении.

Пример: open(readstring, "file.txt")

open(command, mode::AbstractString="r", stdio=DevNull)

Запустить command асинхронно и вернуть кортеж (stream,process). Если mode равно "r", то stream считывает данные со стандартного вывода процесса, а stdio необязательно указывает стандартный поток ввода процесса. Если mode равно "w", то stream записывает данные в стандартный ввод процесса, а stdio необязательно указывает стандартный поток вывода процесса.

open(f::Function, command, mode::AbstractString="r", stdio=DevNull)

Аналогично open(command, mode, stdio), но вызывает f(stream) для полученного потока чтения или записи, затем закрывает поток и ждет завершения процесса. Возвращает значение, возвращенное f.

Base.IOBufferТип

IOBuffer([data,],[readable::Bool=true, writable::Bool=true, [maxsize::Int=typemax(Int)]])

Создаёт IOBuffer, который может работать с предварительно существующим массивом. Если заданы аргументы readable/writable, они ограничивают возможность чтения или записи в буфер соответственно. Последний аргумент необязательно задаёт размер, после которого буфер больше не может увеличиваться.

IOBuffer() -> IOBuffer

Создаёт буфер ввода-вывода в памяти.

IOBuffer(size::Int)

Создаёт IOBuffer фиксированного размера. Буфер не будет динамически увеличиваться.

IOBuffer(string::String)

Создаёт для чтения только IOBuffer на данных, лежащих в основе заданной строки.

julia> io = IOBuffer("Haho");

julia> String(take!(io))
"Haho"

julia> String(take!(io))
"Haho"

Base.take!Метод

take!(b::IOBuffer)

Получить содержимое IOBuffer как массив без копирования. После этого IOBuffer сбрасывается в исходное состояние.

Base.fdioФункция

fdio([name::AbstractString, ]fd::Integer[, own::Bool=false]) -> IOStream

Создаёт IOStream объект из целочисленного дескриптора файла. Если own равно true, закрытие этого объекта закроет лежащий в основе дескриптор. По умолчанию IOStream закрывается при сборе мусора. name позволяет связать дескриптор с именованным файлом.

Base.flushФункция

flush(stream)

Записать все буферизованные записи в заданный поток.

Base.closeФункция

close(stream)

Закрыть поток ввода/вывода. Сначала выполняется flush.

Base.writeФункция

write(stream::IO, x)
write(filename::AbstractString, x)

Записать каноническое двоичное представление значения в заданный поток или файл. Возвращает количество записанных байтов.

Вы можете записать несколько значений с помощью одного вызова write. То есть следующее эквивалентно:

write(stream, x, y...)
write(stream, x) + write(stream, y...)

Base.readФункция

read(filename::AbstractString, args...)

Открыть файл и прочитать его содержимое. args передаётся в read: это эквивалентно open(io->read(io, args...), filename).

read(stream::IO, T, dims)

Прочитать ряд значений типа T из stream, в каноническом двоичном представлении. dims является либо кортежем, либо рядом целых чисел, задающих размер Array{T} для возврата.

read(s::IO, nb=typemax(Int))

Прочитать не более nb байтов из s, возвращая Vector{UInt8} прочитанных байтов.

read(s::IOStream, nb::Integer; all=true)

Прочитать не более nb байтов из s, возвращая Vector{UInt8} прочитанных байтов.

Если all равно true (по умолчанию), эта функция будет неоднократно блокироваться, пытаясь прочитать все запрошенные байты, пока не произойдёт ошибка или не будет достигнут конец файла. Если all равно false, выполняется не более одного вызова read, и количество возвращаемых данных зависит от устройства. Обратите внимание, что не все типы потоков поддерживают параметр all.

read(stream::IO, T)

Прочитать одно значение типа T из stream, в каноническом двоичном представлении.

Base.read!Функция

read!(stream::IO, array::Union{Array, BitArray})
read!(filename::AbstractString, array::Union{Array, BitArray})

Считывает двоичные данные из потока ввода/вывода или файла, заполняя array.

Base.readbytes!Функция

readbytes!(stream::IO, b::AbstractVector{UInt8}, nb=length(b))

Прочитать не более nb байтов из stream в b, вернув количество прочитанных байтов. Размер b увеличится при необходимости (то есть если nb больше, чем length(b), и можно прочитать достаточно байтов), но никогда не уменьшится.

readbytes!(stream::IOStream, b::AbstractVector{UInt8}, nb=length(b); all::Bool=true)

Прочитать не более nb байтов из stream в b, вернув количество прочитанных байтов. Размер b увеличится при необходимости (то есть если nb больше, чем length(b), и можно прочитать достаточно байтов), но никогда не уменьшится.

См. read для описания параметра all.

Base.unsafe_readФункция

unsafe_read(io::IO, ref, nbytes::UInt)

Скопировать nbytes из объекта потока IO в ref (преобразованный в указатель).

Рекомендуется, чтобы подтипы T<:IO переопределили следующее сигнатуру метода для обеспечения более эффективных реализаций: unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

Base.unsafe_writeФункция

unsafe_write(io::IO, ref, nbytes::UInt)

Скопировать nbytes из ref (преобразованного в указатель) в объект IO.

Рекомендуется, чтобы подтипы T<:IO переопределили следующее сигнатуру метода для обеспечения более эффективных реализаций: unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

Base.positionФункция

position(s)

Получить текущую позицию потока.

Base.seekФункция

seek(s, pos)

Переместить указатель потока в заданную позицию.

Base.seekstartФункция

seekstart(s)

Переместить указатель потока в начало.

Base.seekendФункция

seekend(s)

Переместить указатель потока в конец.

Base.skipФункция

skip(s, offset)

Переместить указатель потока относительно текущей позиции.

Base.markФункция

mark(s)

Добавить метку в текущую позицию потока s. Возвращает помеченную позицию.

См. также unmark, reset, ismarked.

Base.unmarkФункция

unmark(s)

Удалить метку из потока s. Возвращает true если поток был помечен, false в противном случае.

См. также mark, reset, ismarked.

Base.resetФункция

reset(s)

Восстановить поток s до ранее помеченной позиции и удалить метку. Возвращает ранее помеченную позицию. Выбрасывает ошибку, если поток не помечен.

См. также mark, unmark, ismarked.

Base.ismarkedФункция

ismarked(s)

Возвращает true если поток s помечен.

См. также mark, unmark, reset.

Base.eofФункция

eof(stream) -> Bool

Проверяет, находится ли поток ввода-вывода в конце файла. Если поток еще не исчерпан, эта функция будет блокироваться для ожидания дополнительных данных при необходимости, а затем вернёт false. Поэтому всегда безопасно прочитать один байт после того, как функция eof вернёт значение false. eof вернёт false до тех пор, пока буферизированные данные не будут доступны, даже если удалённый конец соединения закрыт.

Base.isreadonlyФункция

isreadonly(stream) -> Bool

Определить, является ли поток только для чтения.

Base.iswritableФункция

iswritable(io) -> Bool

Возвращает true если указанный объект IO записывается (если это можно определить).

Base.isreadableФункция

isreadable(io) -> Bool

Возвращает true если указанный объект IO читается (если это можно определить).

Base.isopenФункция

isopen(object) -> Bool

Определить, закрыт ли объект (например, поток, таймер или mmap). После закрытия объект не будет генерировать новые события. Однако закрытый поток может содержать данные для чтения в своем буфере. Используйте eof для проверки возможности чтения данных. Используйте poll_fd для уведомления о том, когда поток может быть записываемым или читаемым.

Base.Serializer.serializeФункция

serialize(stream, value)

Записать произвольное значение в поток в непрозрачном формате, чтобы его можно было прочитать обратно с помощью deserialize. Прочитанное значение будет максимально идентичным исходному. В общем случае этот процесс не будет работать, если чтение и запись выполняются различными версиями Julia или экземпляром Julia с другим системным образом. Ptr значения сериализуются как все нулевые битовые шаблоны (NULL).

Base.Serializer.deserializeФункция

deserialize(stream)

Прочитать значение, записанное с помощью serialize. deserialize предполагает, что двоичные данные, прочитанные из stream, корректны и были сериализованы совместимой реализацией serialize. Она была разработана с целью простоты и производительности и не проверяет прочитанные данные. Неправильные данные могут привести к завершению процесса. Вызывающий код должен обеспечить целостность и корректность данных, прочитанных из stream.

Base.Grisu.print_shortestФункция

print_shortest(io, x)

Вывести кратчайшее возможное представление числа x, с минимальным количеством последовательных ненулевых цифр, гарантируя, что оно будет обработано до точного совпадения.

Base.fdФункция

fd(stream)

Возвращает дескриптор файла, который лежит в основе потока или файла. Обратите внимание, что эта функция применяется только к синхронным File и IOStream потокам, а не к асинхронным потокам.

Base.redirect_stdoutФункция

redirect_stdout([stream]) -> (rd, wr)

Создать трубу, в которую будет перенаправлен весь вывод C и Julia уровня STDOUT. Возвращает кортеж (rd, wr) представляющий концы трубы. Данные, записанные в STDOUT, теперь могут быть прочитаны из конца трубы rd. Конец трубы wr предоставлен для удобства, если старый объект STDOUT был кэширован пользователем и должен быть заменён в другом месте.

Base.redirect_stdoutМетод

redirect_stdout(f::Function, stream)

Запустить функцию f с перенаправлением STDOUT на stream. По завершении, STDOUT восстанавливается к своему предыдущему значению.

Base.redirect_stderrФункция

redirect_stderr([stream]) -> (rd, wr)

Подобно redirect_stdout, но для STDERR.

Base.redirect_stderrМетод

redirect_stderr(f::Function, stream)

Запустить функцию f с перенаправлением STDERR на stream. По завершении, STDERR восстанавливается к своему предыдущему значению.

Base.redirect_stdinФункция

redirect_stdin([stream]) -> (rd, wr)

Подобно redirect_stdout, но для STDIN. Обратите внимание, что порядок возвращаемой кортежи всё ещё (rd, wr), т.е. данные, которые нужно прочитать из STDIN могут быть записаны в wr.

Base.redirect_stdinМетод

redirect_stdin(f::Function, stream)

Запустить функцию f с перенаправлением STDIN на stream. По завершении, STDIN восстанавливается к своему предыдущему значению.

Base.readchompФункция

readchomp(x)

Прочитать всё содержимое x как строку и удалить единственный символ новой строки в конце. Эквивалентно chomp!(readstring(x)).

Base.truncateФункция

truncate(file,n)

Изменить размер файла или буфера, указанного первым аргументом, на ровно n байтов, заполняя ранее не выделенное пространство символом '\0' если файл или буфер увеличивается.

Base.skipcharsФункция

skipchars(stream, predicate; linecomment::Char)

Переместить поток до символа, для которого predicate возвращает false. Например, skipchars(stream, isspace) пропустит все пробелы. Если задан ключевой аргумент linecomment, также будут пропущены символы от указанного символа до конца строки.

Base.DataFmt.countlinesФункция

countlines(io::IO, eol::Char='\n')

Прочитать io до конца потока/файла и посчитать количество строк. Для указания файла передайте имя файла в качестве первого аргумента. Маркеры EOL, отличные от '\n', поддерживаются путём передачи их в качестве второго аргумента.

Base.PipeBufferФункция

PipeBuffer(data::Vector{UInt8}=UInt8[],[maxsize::Int=typemax(Int)])

Объект IOBuffer, который позволяет читать и выполняет записи путем добавления. Поиск и обрезка не поддерживаются. См. IOBuffer для доступных конструкторов. Если data задано, создаёт PipeBuffer для работы с вектором данных, необязательно указывая размер, после которого подлежащий Array не может быть увеличен.

Base.readavailableФункция

readavailable(stream)

Прочитать все доступные данные в потоке, блокируя задачу только если данные недоступны. Результатом является Vector{UInt8,1}.

Base.IOContextТип

IOContext

IOContext предоставляет механизм для передачи параметров конфигурации вывода между методами show.

Короче говоря, это неизменяемый словарь, который является подклассом IO. Он поддерживает стандартные операции со словарями, такие как getindex, и также может использоваться как поток ввода-вывода.

Base.IOContextМетод

IOContext(io::IO, KV::Pair)

Создать IOContext, который оборачивает заданный поток, добавляя указанную пару key=>value в свойства этого потока (обратите внимание, что io может быть сам по себе IOContext).

• используйте (key => value) in dict для проверки, есть ли данное сочетание в наборе свойств

• используйте get(dict, key, default) для получения последнего значения для определённого ключа

Следующие свойства часто используются:

• :compact: Булево значение, указывающее, что небольшие значения должны отображаться более компактно, например, числа должны отображаться с меньшим количеством цифр. Это устанавливается при выводе элементов массива.

• :limit: Булево значение, указывающее, что контейнеры должны быть усечены, например, показывая … вместо большинства элементов.

• :displaysize: Tuple{Int,Int}, задающий размер для текстового вывода в строках и столбцах. Это можно использовать для переопределения размера отображения для вызываемых функций, но для получения размера экрана используйте функцию displaysize.

julia> function f(io::IO)
           if get(io, :short, false)
               print(io, "short")
           else
               print(io, "loooooong")
           end
       end
f (generic function with 1 method)

julia> f(STDOUT)
loooooong
julia> f(IOContext(STDOUT, :short => true))
short

Base.IOContextМетод

IOContext(io::IO, context::IOContext)

Создать IOContext, который оборачивает альтернативный IO, но наследует свойства context.

Текстовый ввод-вывод

Base.showМетод

show(x)

Записать информативное текстовое представление значения в текущий поток вывода. Новые типы должны перегрузить show(io, x), где первый аргумент — поток. Представление, используемое show , обычно включает специфичные для Julia форматирование и информацию о типе.

Base.showcompactФункция

showcompact(x)

Показать компактное представление значения.

Это используется для вывода элементов массивов без повторения информации о типе (что было бы избыточно с той, что выводится один раз для всего массива) и без перевода строки внутри представления элемента.

Чтобы предложить компактное представление, отличное от стандартного, пользовательский тип должен проверить get(io, :compact, false) в своём методе show.

Base.showallФункция

showall(x)

Аналогично show, но отображает все элементы массивов.

Base.summaryФункция

summary(x)

Возвращает строку с кратким описанием значения. По умолчанию возвращает string(typeof(x)), например, Int64.

Для массивов возвращает строку с информацией о размере и типе, например, 10-element Array{Int64,1}.

julia> summary(1)
"Int64"

julia> summary(zeros(2))
"2-element Array{Float64,1}"

Base.printФункция

print(io::IO, x)

Записывает в io (или в стандартный поток вывода STDOUT, если io не указан) каноническое (не украшенное) текстовое представление значения, если оно есть, в противном случае вызывает show. Представление, используемое функцией print включает минимальную форматирование и старается избежать деталей, специфичных для Julia.

julia> print("Hello World!")
Hello World!
julia> io = IOBuffer();

julia> print(io, "Hello World!")

julia> String(take!(io))
"Hello World!"

Base.printlnФункция

println(io::IO, xs...)

Выводит (используя print) xs, а затем новую строку. Если io не указан, выводит в STDOUT.

Base.print_with_colorФункция

print_with_color(color::Union{Symbol, Int}, [io], xs...; bold::Bool = false)

Выводит xs в цвете, указанном в виде символа.

color может принимать значения :normal, :default, :bold, :black, :blue, :cyan, :green, :light_black, :light_blue, :light_cyan, :light_green, :light_magenta, :light_red, :light_yellow, :magenta, :nothing, :red, :white, или :yellow, или целое число от 0 до 255 включительно. Обратите внимание, что не все терминалы поддерживают 256 цветов. Если ключевое слово bold задано как true, результат будет выведен жирным шрифтом.

Base.infoФункция

info([io, ] msg..., [prefix="INFO: "])

Отображает информационное сообщение. Аргумент msg — строка, описывающая отображаемую информацию. Ключевой аргумент prefix может использоваться для переопределения добавления префикса msg по умолчанию.

julia> info("hello world")
INFO: hello world

julia> info("hello world"; prefix="MY INFO: ")
MY INFO: hello world

См. также logging.

Base.warnФункция

warn([io, ] msg..., [prefix="WARNING: ", once=false, key=nothing, bt=nothing, filename=nothing, lineno::Int=0])

Отображает предупреждение. Аргумент msg — строка, описывающая отображаемое предупреждение. Установите once в значение true и укажите key, чтобы отобразить msg только в первый раз, когда warn вызывается. Если bt не nothing, отображается трассировка стека. Если filename не nothing, отображаются и он, и lineno.

См. также logging.

warn(msg)

Отображает предупреждение. Аргумент msg — строка, описывающая отображаемое предупреждение.

julia> warn("Beep Beep")
WARNING: Beep Beep

Base.loggingФункция

logging(io [, m [, f]][; kind=:all])
logging([; kind=:all])

Перенаправляет вывод информационных, предупреждающих и/или ошибочных сообщений в io, переопределяя ранее заданные параметры. При необходимости перенаправить поток только для модуля m, или конкретно для функции f внутри m. kind может принимать значения :all (по умолчанию), :info, :warn, или :error. См. Base.log_{info,warn,error}_to для текущего набора перенаправлений. Вызов logging без аргументов (или только с аргументом kind) сбросит все настройки.

Base.Printf.@printfМакрос

@printf([io::IOStream], "%Fmt", args...)

Выводит args, используя спецификатор формата C printf() со следующими особенностями: Inf и NaN последовательно выводятся как Inf и NaN для флагов %a, %A, %e, %E, %f, %F, %g, и %G. Кроме того, если число с плавающей точкой одинаково близко к численным значениям двух возможных строк вывода, выбирается строка вывода, более удалённая от нуля.

Необязательно, первый аргумент может быть IOStream для перенаправления вывода.

Примеры

julia> @printf("%f %F %f %F\n", Inf, Inf, NaN, NaN)
Inf Inf NaN NaN


julia> @printf "%.0f %.1f %f\n" 0.5 0.025 -0.0078125
1 0.0 -0.007813

Base.Printf.@sprintfМакрос

@sprintf("%Fmt", args...)

Возвращает отформатированный вывод @printf как строку.

Примеры

julia> s = @sprintf "this is a %s %15.1f" "test" 34.567;

julia> println(s)
this is a test            34.6

Base.sprintФункция

sprint(f::Function, args...)

Вызывает заданную функцию с потоком ввода-вывода и дополнительными аргументами. Всё, что записывается в этот поток ввода-вывода, возвращается в виде строки.

julia> sprint(showcompact, 66.66666)
"66.6667"

Base.showerrorФункция

showerror(io, e)

Отображает описание объекта исключения.

Base.dumpФункция

dump(x)

Отображает все части представления значения.

Base.readstringФункция

readstring(stream::IO)
readstring(filename::AbstractString)

Считывает всё содержимое потока ввода-вывода или файла в виде строки. Текст предполагается закодированным в UTF-8.

Base.readlineФункция

readline(stream::IO=STDIN; chomp::Bool=true)
readline(filename::AbstractString; chomp::Bool=true)

Считывает одну строку текста из указанного потока ввода-вывода или файла (по умолчанию STDIN). При чтении из файла текст предполагается закодированным в UTF-8. Строки ввода завершаются '\n' или "\r\n" или концом потока ввода. Если chomp равно true (как по умолчанию), эти символы новой строки удаляются из строки перед возвращением. Если chomp равно false, они возвращаются как часть строки.

Base.readuntilФункция

readuntil(stream::IO, delim)
readuntil(filename::AbstractString, delim)

Считывает строку из потока ввода-вывода или файла до и включая заданный разделительный байт. Текст предполагается закодированным в UTF-8.

Base.readlinesФункция

readlines(stream::IO=STDIN; chomp::Bool=true)
readlines(filename::AbstractString; chomp::Bool=true)

Считывает все строки из потока ввода-вывода или файла как вектор строк. Поведение эквивалентно сохранению результата чтения readline многократно с теми же аргументами и сохранению полученных строк в виде вектора строк.

Base.eachlineФункция

eachline(stream::IO=STDIN; chomp::Bool=true)
eachline(filename::AbstractString; chomp::Bool=true)

Создаёт итерируемый EachLine объект, который будет выводить каждую строку из потока ввода-вывода или файла. Итерация вызывает readline для аргумента потока многократно с chomp , определяя, удалять ли символы конца строки. При вызове с именем файла файл открывается один раз в начале итерации и закрывается в конце. Если итерация прервана, файл будет закрыт при удалении объекта EachLine из памяти.

Base.DataFmt.readdlmМетод

readdlm(source, delim::Char, T::Type, eol::Char; header=false, skipstart=0, skipblanks=true, use_mmap, quotes=true, dims, comments=true, comment_char='#')

Считайте матрицу из источника, где каждая строка (разделенная eol) задаёт одну строку, а элементы разделены заданным разделителем. Источник может быть текстовым файлом, потоком или массивом байтов. Для использования отображаемых в памяти файлов можно передать представление массива байтов отображаемого сегмента в качестве источника.

Если T является числовым типом, результат — массив этого типа, причём любые нечисловые элементы интерпретируются как NaN для чисел с плавающей запятой или как ноль. Другие полезные значения T включают String, AbstractString, и Any.

Если header является true, первая строка данных будет считана как заголовок, и вместо только data_cells будет возвращена кортеж (data_cells, header_cells).

Указание skipstart пропустит соответствующее количество начальных строк из входных данных.

Если skipblanks является true, пустые строки во входных данных будут проигнорированы.

Если use_mmap является true, файл, указанный source, будет отображён в памяти для потенциального ускорения. По умолчанию это true, за исключением Windows. В Windows, вы можете указать true, если файл большой и будет прочитан только один раз, а не записан.

Если quotes является true, столбцы, заключенные в двойные кавычки ("), могут содержать новые строки и разделители столбцов. Двойные кавычки внутри цитируемого поля должны быть экранированы ещё одной двойной кавычкой. Указание dims как кортежа ожидаемых строк и столбцов (включая заголовок, если он есть) может ускорить чтение больших файлов. Если comments является true, строки, начинающиеся с comment_char, и текст, следующий за comment_char в любой строке, будут проигнорированы.

Base.DataFmt.readdlmМетод

readdlm(source, delim::Char, eol::Char; options...)

Если все данные числовые, результатом будет числовой массив. Если некоторые элементы не могут быть обработаны как числа, возвращается разнородный массив чисел и строк.

Base.DataFmt.readdlmМетод

readdlm(source, delim::Char, T::Type; options...)

Разделитель конца строки принимается как \n.

Base.DataFmt.readdlmМетод

readdlm(source, delim::Char; options...)

Разделитель конца строки принимается как \n. Если все данные числовые, результатом будет числовой массив. Если некоторые элементы не могут быть обработаны как числа, возвращается разнородный массив чисел и строк.

Base.DataFmt.readdlmМетод

readdlm(source, T::Type; options...)

Столбцы предполагаются разделенными одной или несколькими пробелами. Разделитель конца строки принимается как \n.

Base.DataFmt.readdlmМетод

readdlm(source; options...)

Столбцы предполагаются разделенными одной или несколькими пробелами. Разделитель конца строки принимается как \n. Если все данные числовые, результатом будет числовой массив. Если некоторые элементы не могут быть обработаны как числа, возвращается разнородный массив чисел и строк.

Base.DataFmt.writedlmФункция

writedlm(f, A, delim='\t'; opts)

Запишите A (вектор, матрицу или итерируемое множество итерируемых строк) в виде текста в f (строка имени файла или поток IO) с использованием заданного разделителя delim (по умолчанию табуляция, но может быть любым печатаемым объектом Julia, обычно Char или AbstractString).

Например, два вектора x и y одинаковой длины могут быть записаны как два столбца табулированного текста в f с помощью writedlm(f, [x y]) или writedlm(f, zip(x, y)).

Base.DataFmt.readcsvФункция

readcsv(source, [T::Type]; options...)

Эквивалентно readdlm с delim установленным в запятую и типом, опционально определенным T.

Base.DataFmt.writecsvФункция

writecsv(filename, A; opts)

Эквивалентно writedlm с delim установленным в запятую.

Base.Base64.Base64EncodePipeТип

Base64EncodePipe(ostream)

Возвращает новый поток ввода только для записи, который преобразует все байты, записанные в него, в байты ASCII в формате base64, записанные в ostream. Вызов close на потоке Base64EncodePipe необходим для завершения кодирования (но не закрывает ostream).

julia> io = IOBuffer();

julia> iob64_encode = Base64EncodePipe(io);

julia> write(iob64_encode, "Hello!")
6

julia> close(iob64_encode);

julia> str = String(take!(io))
"SGVsbG8h"

julia> String(base64decode(str))
"Hello!"

Base.Base64.Base64DecodePipeТип

Base64DecodePipe(istream)

Возвращает новый поток ввода только для чтения, который декодирует данные в формате base64, считанные из istream.

julia> io = IOBuffer();

julia> iob64_decode = Base64DecodePipe(io);

julia> write(io, "SGVsbG8h")
8

julia> seekstart(io);

julia> String(read(iob64_decode))
"Hello!"

Base.Base64.base64encodeФункция

base64encode(writefunc, args...)
base64encode(args...)

Принимая функцию типа write writefunc, которая принимает поток ввода в качестве первого аргумента, base64encode(writefunc, args...) вызывает writefunc для записи args... в строку base64 и возвращает строку. base64encode(args...) эквивалентна base64encode(write, args...); она преобразует свои аргументы в байты с помощью стандартных функций write и возвращает строку в формате base64.

См. также base64decode.

Base.Base64.base64decodeФункция

base64decode(string)

Декодирует строку base64 string и возвращает массив декодированных байтов.

См. также base64encode

julia> b = base64decode("SGVsbG8h")
6-element Array{UInt8,1}:
 0x48
 0x65
 0x6c
 0x6c
 0x6f
 0x21

julia> String(b)
"Hello!"

Base.displaysizeФункция

displaysize(io) -> (lines, columns)

Возвращает номинальный размер экрана, который можно использовать для отображения вывода в этот объект io.

Мультимедийный ввод/вывод

Так же, как вывод текста осуществляется с помощью print, и пользовательские типы могут указывать своё текстовое представление переопределением show, Julia предоставляет стандартный механизм для вывода богатой мультимедийной информации (например, изображений, форматированного текста или даже аудио и видео), состоящий из трёх частей:

• Функция display(x) для запроса наиболее богатого доступного мультимедийного отображения объекта Julia x (с резервным текстовым отображением).

• Перегрузка show позволяет указывать произвольные мультимедийные представления (с ключами стандартных MIME-типов) пользовательских типов.

• Мультимедийные возможности отображения могут быть зарегистрированы путём наследования от универсального типа Display и добавления их в стек отображений с помощью pushdisplay.

Базовая среда выполнения Julia предоставляет только текстовое отображение, но более богатые отображения могут быть включены путём загрузки внешних модулей или использованием графических сред Julia (таких как IPython-based IJulia notebook).

Base.Multimedia.displayФункция

display(x)
display(d::Display, x)
display(mime, x)
display(d::Display, mime, x)

Отображает x с использованием самого верхнего подходящего отображения в стеке отображений, как правило, используя наиболее богатый поддерживаемый мультимедийный вывод для x, с текстовым выводом STDOUT как резервным вариантом. Вариант display(d, x) пытается отобразить x на заданном отображении d только, бросая исключение MethodError если d не может отобразить объекты этого типа.

Также существуют два варианта с аргументом mime (строка типа MIME, например "image/png"), которые пытаются отобразить x с запрошенным типом MIME только, выбрасывая MethodError, если этот тип не поддерживается ни одним из отображений, ни x. В этих вариантах можно также предоставить «сырые» данные в запрошенном типе MIME, передав x::AbstractString (для типов MIME с текстовым хранением, таких как text/html или application/postscript) или x::Vector{UInt8} (для бинарных типов MIME).

Base.Multimedia.redisplayФункция

redisplay(x)
redisplay(d::Display, x)
redisplay(mime, x)
redisplay(d::Display, mime, x)

По умолчанию, функции redisplay просто вызывают display. Однако некоторые бэкэнды отображения могут переопределять redisplay для изменения существующего отображения x (если таковое имеется). Использование redisplay также является подсказкой для бэкэнда, что x может быть отображено несколько раз, и бэкэнд может выбрать отложить отображение до (например) следующего интерактивного запроса.

Base.Multimedia.displayableФункция

displayable(mime) -> Bool
displayable(d::Display, mime) -> Bool

Возвращает булево значение, указывающее, является ли данный тип mime (строка) отображаемым любым из отображений в текущей стеке отображений, или конкретно отображением d во втором варианте.

Base.showМетод

show(stream, mime, x)

Функции display в конечном счёте вызывают show для записи объекта x в качестве заданного типа mime в заданный ввод/вывод stream (обычно буфер памяти), если это возможно. Для обеспечения богатого мультимедийного представления пользовательского типа T необходимо лишь определить новый метод show для T, посредством: show(stream, ::MIME"mime", x::T) = ..., где mime — это строка типа MIME, а тело функции вызывает write (или подобное) для записи этого представления x в stream. (Обратите внимание, что обозначение MIME"" поддерживает только литеральные строки; для построения типов MIME более гибким способом используйте MIME{Symbol("")}.)

Например, если вы определили тип MyImage и знаете, как записать его в файл PNG, вы можете определить функцию show(stream, ::MIME"image/png", x::MyImage) = ... для отображения ваших изображений в любом поддерживающем PNG бэкэнде Display (например, IJulia). Как обычно, убедитесь, что вы import Base.show для добавления новых методов к встроенной функции Julia show.

Тип MIME по умолчанию — MIME"text/plain". Существует резервный метод для вывода text/plain, который вызывает show с 2 аргументами. Следовательно, этот случай необходимо обработать, определив метод show(stream::IO, x::MyType) с 2 аргументами.

Технически, макрос MIME"mime" определяет тип-синглтон для заданной строки mime, что позволяет использовать механизмы диспетчеризации Julia для определения способа отображения объектов любого заданного типа.

Первый аргумент к show может быть IOContext, указывающим свойства формата вывода. Подробности см. в IOContext.

Base.Multimedia.mimewritableФункция

mimewritable(mime, x)

Возвращает булево значение, указывающее, может ли объект x быть записан в качестве заданного типа mime. (По умолчанию это определяется автоматически существованием соответствующего метода show для typeof(x).)

Base.Multimedia.reprmimeФункция

reprmime(mime, x)

Возвращает AbstractString или Vector{UInt8}, содержащие представление x в запрошенном типе mime, как записано в show (выбрасывая MethodError если нет подходящего show). Возвращается AbstractString для типов MIME с текстовыми представлениями (например, "text/html" или "application/postscript"), в то время как бинарные данные возвращаются как Vector{UInt8}. (Функция istextmime(mime) возвращает, рассматривает ли Julia данный тип mime как текст.)

В качестве специального случая, если x является AbstractString (для текстовых типов MIME) или Vector{UInt8} (для бинарных типов MIME), функция reprmime предполагает, что x уже в запрошенном формате mime и просто возвращает x. Этот специальный случай не применяется к типу MIME "text/plain". Это полезно, чтобы сырые данные можно было передать в display(m::MIME, x).

Base.Multimedia.stringmimeФункция

stringmime(mime, x)

Возвращает AbstractString, содержащие представление x в запрошенном типе mime. Это аналогично reprmime, за исключением того, что бинарные данные кодируются в base64 как строка ASCII.

Как упоминалось выше, можно также определять новые бэкэнды отображения. Например, модуль, который может отображать изображения PNG в окне, может зарегистрировать эту возможность в Julia, так что вызов display(x) на типах с представлениями PNG автоматически отобразит изображение с помощью окна модуля.

Для определения нового бэкэнда отображения необходимо сначала создать подтип D абстрактного класса Display. Затем для каждого типа MIME (строка mime), который может быть отображён в D, необходимо определить функцию display(d::D, ::MIME"mime", x) = ..., которая отображает x как этот тип MIME, обычно вызывая reprmime(mime, x). Необходимо бросить исключение MethodError, если x не может быть отображён как этот тип MIME; это происходит автоматически, если вызывается reprmime. Наконец, необходимо определить функцию display(d::D, x), которая запрашивает mimewritable(mime, x) для типов MIME mime, поддерживаемых D, и отображает «наиболее подходящий»; необходимо бросить исключение MethodError, если не найдено ни одного поддерживаемого типа MIME для x. Аналогичным образом, некоторые подтипы могут переопределить redisplay(d::D, ...). (Опять же, необходимо import Base.display для добавления новых методов к display.) Возвращаемые значения этих функций зависят от реализации (поскольку в некоторых случаях может быть полезно вернуть «дескриптор» отображения определённого типа).

Функции отображения для D могут вызываться непосредственно, но их также можно вызывать автоматически из display(x) путём простого добавления нового отображения в стек бэкэндов отображения с помощью:

Base.Multimedia.pushdisplayФункция

pushdisplay(d::Display)

Добавляет новое отображение d в начало глобального стека бэкэндов отображения. Вызов display(x) или display(mime, x) отобразит x на верхнем совместимом бэкэнде в стеке (то есть на верхнем бэкэнде, который не вызывает исключение MethodError).

Base.Multimedia.popdisplayФункция

popdisplay()
popdisplay(d::Display)

Удаляет верхний бэкэнд из стека бэкэндов отображения, или верхнюю копию d во втором варианте.

Base.Multimedia.TextDisplayТип

TextDisplay(io::IO)

Возвращает TextDisplay <: Display, который отображает любой объект как тип MIME text/plain (по умолчанию), записывая текстовое представление в указанный поток ввода/вывода. (Таким образом, объекты выводятся в Julia REPL.)

Base.Multimedia.istextmimeФункция

istextmime(m::MIME)

Определяет, является ли тип MIME текстовыми данными. Типы MIME предполагаются бинарными данными, за исключением набора типов, известных как текстовые данные (возможно, Unicode).

Картирование памяти ввода/вывода

Base.Mmap.AnonymousТип

Mmap.Anonymous(name, readonly, create)

Создаёт объект, похожий на IO, для создания нулевых отображений памяти, не связанных с файлом, для использования в Mmap.mmap. Используется SharedArray для создания массивов общей памяти.

Base.Mmap.mmapМетод

Mmap.mmap(io::Union{IOStream,AbstractString,Mmap.AnonymousMmap}[, type::Type{Array{T,N}}, dims, offset]; grow::Bool=true, shared::Bool=true)
       Mmap.mmap(type::Type{Array{T,N}}, dims)

Создаёт Array, значения которого связаны с файлом с помощью памяти. Это удобный способ работы с данными, слишком большими для размещения в оперативной памяти.

Тип является Array{T,N} с элементом типа битов T и размерностью N, которая определяет, как интерпретируются байты массива. Обратите внимание, что файл должен храниться в двоичном формате, и преобразования форматов невозможны (это ограничение операционных систем, а не Julia).

dims — это кортеж или одиночное целое число Integer, определяющее размер или длину массива.

Файл передаётся через аргумент потока, либо как открытый IOStream или строка имени файла. При инициализации потока используйте "r" для массива «только для чтения» и "w+" для создания нового массива, используемого для записи значений на диск.

Если не указан аргумент type, по умолчанию используется Vector{UInt8}.

Можно дополнительно указать смещение (в байтах), например, для пропуска заголовка в файле. Значение смещения по умолчанию — текущая позиция потока для IOStream.

Ключевой аргумент grow указывает, нужно ли увеличивать размер файла на диске для размещения запрошенного размера массива (если общий размер файла меньше запрошенного размера массива). Для увеличения файла требуются права на запись.

Ключевой аргумент shared указывает, будут ли изменения в результате Array и вносимые в него изменения видны другим процессам, отображающим тот же файл.

Например, следующий код

# Create a file for mmapping
# (you could alternatively use mmap to do this step, too)
A = rand(1:20, 5, 30)
s = open("/tmp/mmap.bin", "w+")
# We'll write the dimensions of the array as the first two Ints in the file
write(s, size(A,1))
write(s, size(A,2))
# Now write the data
write(s, A)
close(s)

# Test by reading it back in
s = open("/tmp/mmap.bin")   # default is read-only
m = read(s, Int)
n = read(s, Int)
A2 = Mmap.mmap(s, Matrix{Int}, (m,n))

создаёт m×n Matrix{Int}, связанный с файлом, связанным с потоком s.

Для более переносимого файла необходимо кодировать информацию о разрядности слова — 32 бита или 64 бита — и порядке байтов в заголовке. На практике рассмотрите кодирование двоичных данных с использованием стандартных форматов, таких как HDF5 (который можно использовать с отображением в памяти).

Base.Mmap.mmapМетод

Mmap.mmap(io, BitArray, [dims, offset])

Создаёт BitArray с значениями, связанными с файлом с помощью отображения в памяти; он выполняет ту же функцию, работает аналогичным образом и имеет те же аргументы, что и mmap, но с другим представлением байтов.

Пример: B = Mmap.mmap(s, BitArray, (25,30000))

Это создаст 25×30000 BitArray, связанный с файлом, связанным с потоком s.

Base.Mmap.sync!Функция

Mmap.sync!(array)

Принудительно синхронизирует версию в памяти отображаемого в памяти Array или BitArray с версией на диске.

Ввод/вывод по сети

Base.connectМетод

connect([host], port::Integer) -> TCPSocket

Подключение к хосту host на порту port.

Base.connectМетод

connect(path::AbstractString) -> PipeEndpoint

Подключение к именованной пайпе/UNIX-доменному сокету по адресу path.

Base.listenМетод

listen([addr, ]port::Integer; backlog::Integer=BACKLOG_DEFAULT) -> TCPServer

Прослушивание порта по адресу, указанному в addr. По умолчанию прослушивание только на localhost. Для прослушивания на всех интерфейсах передайте IPv4(0) или IPv6(0), как это подходит. backlog определяет, сколько подключений могут ожидать (не вызвав accept) прежде чем сервер начнёт их отклонять. Значение по умолчанию для backlog составляет 511.

Base.listenМетод

listen(path::AbstractString) -> PipeServer

Создание и прослушивание именованной пайпы/UNIX-доменного сокета.

Base.getaddrinfoФункция

getaddrinfo(host::AbstractString) -> IPAddr

Получение IP-адреса host (возможно, потребуется выполнить DNS-запрос).

Base.getsocknameФункция

getsockname(sock::Union{TCPServer, TCPSocket}) -> (IPAddr, UInt16)

Получение IP-адреса и порта, к которому подключён данный TCPSocket (или к которому он привязан в случае TCPServer).

Base.IPv4Тип

IPv4(host::Integer) -> IPv4

Возвращает объект IPv4 из IP-адреса host, отформатированного как Integer.

julia> IPv4(3223256218)
ip"192.30.252.154"

Base.IPv6Тип

IPv6(host::Integer) -> IPv6

Возвращает объект IPv6 из IP-адреса host, отформатированного как Integer.

julia> IPv6(3223256218)
ip"::c01e:fc9a"

Base.nb_availableФункция

nb_available(stream)

Возвращает количество байтов, доступных для чтения, прежде чем чтение из этого потока или буфера заблокируется.

Base.acceptФункция

accept(server[,client])

Принимает подключение на заданном сервере и возвращает подключение к клиенту. Может быть предоставлен неинициализированный поток клиента, в этом случае он будет использован вместо создания нового потока.

Base.listenanyФункция

listenany([host::IPAddr,] port_hint) -> (UInt16, TCPServer)

Создаёт TCPServer на любом порту, используя подсказку в качестве отправной точки. Возвращает кортеж из фактического порта, на котором был создан сервер, и самого сервера.

Base.Filesystem.poll_fdФункция

poll_fd(fd, timeout_s::Real=-1; readable=false, writable=false)

Отслеживает дескриптор файла fd на изменения доступности чтения или записи с таймаутом, заданным в timeout_s секундах.

Ключевые аргументы определяют, какой из статусов чтения и/или записи должен контролироваться; по крайней мере один из них должен быть установлен в true.

Возвращаемое значение — объект с булевыми полями readable, writable, и timedout, содержащими результат опроса.

Base.Filesystem.poll_fileФункция

poll_file(path::AbstractString, interval_s::Real=5.007, timeout_s::Real=-1) -> (previous::StatStruct, current::StatStruct)

Отслеживает файл на изменения, опрашивая каждые interval_s секунды до тех пор, пока не произойдёт изменение или не пройдёт timeout_s секунд. interval_s должен быть большим значением; по умолчанию 5.007 секунд.

Возвращает пару StatStruct объектов (previous, current) при обнаружении изменения.

Для определения момента изменения файла сравните mtime(prev) != mtime(current) для обнаружения уведомлений об изменениях. Однако использование watch_file для этой операции предпочтительнее, так как оно более надёжное и эффективное, хотя в некоторых ситуациях может быть недоступно.

Base.Filesystem.watch_fileФункция

watch_file(path::AbstractString, timeout_s::Real=-1)

Наблюдает за файлом или каталогом path за изменениями до тех пор, пока не произойдёт изменение или не пройдёт timeout_s секунд.

Возвращаемое значение — объект с булевыми полями changed, renamed, и timedout, содержащими результат наблюдения за файлом.

Это поведение этой функции немного отличается на различных платформах. Для более подробной информации см. https://nodejs.org/api/fs.html#fs_caveats.

Base.bindФункция

bind(socket::Union{UDPSocket, TCPSocket}, host::IPAddr, port::Integer; ipv6only=false, reuseaddr=false, kws...)

Связывает socket с заданным host:port. Обратите внимание, что 0.0.0.0 будет прослушивать все устройства.

• Параметр ipv6only отключает режим двойного стека. Если ipv6only=true, создаётся только стек IPv6.

• Если reuseaddr=true, несколько потоков или процессов могут связываться с одним и тем же адресом без ошибки, если все они установят reuseaddr=true, но только последний, установивший соединение, получит трафик.

bind(chnl::Channel, task::Task)

Связывает срок службы chnl с задачей. Канал chnl автоматически закрывается при завершении задачи. Любые необработанные исключения в задаче передаются всем ожидающим на chnl.

Объект chnl можно явно закрыть независимо от завершения задачи. Завершение задач не влияет на уже закрытые объекты канала.

Когда канал связан с несколькими задачами, первая завершившаяся задача закроет канал. Когда несколько каналов связаны с одной и той же задачей, завершение задачи закроет все связанные каналы.

julia> c = Channel(0);

julia> task = @schedule foreach(i->put!(c, i), 1:4);

julia> bind(c,task);

julia> for i in c
           @show i
       end;
i = 1
i = 2
i = 3
i = 4

julia> isopen(c)
false

julia> c = Channel(0);

julia> task = @schedule (put!(c,1);error("foo"));

julia> bind(c,task);

julia> take!(c)
1

julia> put!(c,1);
ERROR: foo
Stacktrace:
 [1] check_channel_state(::Channel{Any}) at ./channels.jl:131
 [2] put!(::Channel{Any}, ::Int64) at ./channels.jl:261

Base.sendФункция

send(socket::UDPSocket, host, port::Integer, msg)

Отправляет msg по socket в host:port.

Base.recvФункция

recv(socket::UDPSocket)

Считывает пакет UDP из указанного сокета и возвращает полученные байты. Этот вызов блокируется.

Base.recvfromФункция

recvfrom(socket::UDPSocket) -> (address, data)

Считывает пакет UDP из указанного сокета, возвращая кортеж (address, data), где address будет либо IPv4, либо IPv6, как соответствующим образом.

Base.setoptФункция

setopt(sock::UDPSocket; multicast_loop = nothing, multicast_ttl=nothing, enable_broadcast=nothing, ttl=nothing)

Устанавливает параметры сокета UDP.

• multicast_loop: петля обратной связи для мультивещательных пакетов (по умолчанию: true).

• multicast_ttl: TTL для мультивещательных пакетов (по умолчанию: nothing).

• enable_broadcast: флаг должен быть установлен в true, если сокет будет использоваться для широковещательных сообщений, в противном случае UDP-система вернёт ошибку доступа (по умолчанию: false).

• ttl: Время жизни пакетов, отправляемых по сокету (по умолчанию: nothing).

Base.ntohФункция

ntoh(x)

Преобразует порядок байтов значения из сетевого порядка байтов (big-endian) в порядок байтов хоста.

Base.htonФункция

hton(x)

Преобразует порядок байтов значения из порядка байтов хоста в сетевой порядок байтов (big-endian).

Base.ltohФункция

ltoh(x)

Преобразует порядок байтов значения из little-endian в порядок байтов хоста.

Base.htolФункция

htol(x)

Преобразует порядок байтов значения из порядка байтов хоста в little-endian.

Base.ENDIAN_BOMКонстанта

ENDIAN_BOM

32-битный маркер порядка байтов указывает порядок байтов на целевой машине. Машины little-endian будут содержать значение 0x04030201. Машины big-endian будут содержать значение 0x01020304.