IO とネットワーク

一般的な IO

Base.stdout ── 定数

stdout

標準出力ストリームを指すグローバル変数です。

Base.stderr ── 定数

stderr

標準エラーストリームを指すグローバル変数です。

Base.stdin ── 定数

stdin

標準入力ストリームを指すグローバル変数です。

Base.open ── 関数

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

関数 fopen(args...; kwargs...) が返すファイル記述子に適用し、完了したらそのファイル記述子を閉じます。

julia> open("myfile.txt", "w") do io
           write(io, "Hello world!")
       end;

julia> open(f->read(f, String), "myfile.txt")
"Hello world!"

julia> rm("myfile.txt")
open(filename::AbstractString; lock = true, keywords...) -> IOStream

五つのキーワード引数で指定されるモードでファイルを開きます:

キーワード引数 説明 デフォルト値
read 読み込みのために開く !write
write 書き込みのために開く truncate | append
create ファイルが存在しなければ作成する !read & write | truncate | append
truncate サイズをゼロに切り捨てる !read & write
append 末尾にシークする false

キーワード引数が一つも指定されないときのデフォルトは読み込み専用でファイルを開く処理です。開かれたファイルにアクセスするためのストリームを返します。

キーワード引数 lock は安全なマルチスレッドアクセスのためにファイル操作をロックするかどうかを制御します。

Julia 1.5

キーワード引数 lock は Julia 1.5 以降でサポートされます。

open(filename::AbstractString, [mode::AbstractString]; lock = true) -> IOStream

五つの真偽値ではなく文字列でオプションを指定するバージョンの open です。mode には fopen(3) や Perl の open で使われるのと同じ値を指定でき、次のように真偽値グループと対応します:

モード 説明 キーワード引数
r 読み込み 無し
w 書き込み・作成・上書き write = true
a 書き込み・作成・追記 append = true
r+ 読み込み・書き込み read = true, write = true
w+ 読み込み・書き込み・作成・上書き truncate = true, read = true
a+ 読み込み・書き込み・作成・追記 append = true, read = true

キーワード引数 lock は安全なマルチスレッドアクセスのためにファイル操作をロックするかどうかを制御します。

julia> io = open("myfile.txt", "w");

julia> write(io, "Hello world!");

julia> close(io);

julia> io = open("myfile.txt", "r");

julia> read(io, String)
"Hello world!"

julia> write(io, "This file is read only")
ERROR: ArgumentError: write failed, IOStream is not writeable
[...]

julia> close(io)

julia> io = open("myfile.txt", "a");

julia> write(io, "This stream is not read only")
28

julia> close(io)

julia> rm("myfile.txt")
Julia 1.5

キーワード引数 lock は Julia 1.5 以降でサポートされます。

open(fd::OS_HANDLE) -> IO

生のファイル記述子を受け取り、それを Julia が認識できる IO 型にラップしたものを返します。そのときハンドル fd の所有権は Julia に移ります。元のハンドルの所有権を手放したくない場合には open(Libc.dup(fd)) を使ってください。

警告

システムの他の部分が所有しているハンドルに対してこのメソッドを呼び出してはいけません。

open(command, mode::AbstractString, stdio=devnull)

command を非同期的に実行します。open(command, stdio; read, write) と同様ですが、読み込みと書き込みのフラグをキーワード引数ではなくモード文字列で表す点が異なります。指定できるモード文字列とその意味は次の通りです:

モード 説明 キーワード引数
r 読み込み 無し
w 書き込み write = true
r+ 読み込み・書き込み read = true, write = true
w+ 読み込み・書き込み read = true, write = true
open(command, stdio=devnull; write::Bool = false, read::Bool = !write)

command の実行を非同期に開始し、process::IO オブジェクトを返します。readtrue なら新しいプロセスの標準出力に書き込まれたデータを process オブジェクトから読み込めるようになり、省略可能引数 stdio は新しいプロセスの標準入力ストリームとなります。writetrue なら process オブジェクトを通して新しいプロセスの標準入力に書き込めるようになり、省略可能引数 stdio は新しいプロセスの標準出力ストリームとなります。プロセスの標準エラーストリームは現在のグローバル変数 stderr に接続されます。

open(f::Function, command, args...; kwargs...)

open(command, args...; kwargs...) と同じ処理を行い、返り値のストリームに対して f を適用し、関数が返ったら入力ストリームを閉じてプロセスの完了を待ちます。f が返す値を返します。

Base.IOStream ── 型

IOStream

OS のファイル記述子をラップするバッファされた IO ストリームです。主に open が返すファイルの表現として使われます。

Base.IOBuffer ── 型

IOBuffer([data::AbstractVector{UInt8}]; keywords...) -> IOBuffer

インメモリの IO ストリームを作成します。既存の配列を使うこともできます。

省略可能なキーワード引数は次の通りです:

  • read, write, append: バッファに対して行える操作を制限します。詳細は open を参照してください。
  • truncate: バッファを長さゼロに切り捨ててから使います。
  • maxsize: バッファの最大サイズを指定します。バッファはこのサイズより大きくなることができません。
  • sizehint: バッファの容量を提案します (datasizehint!(data, size) を実装している必要があります)。

data が与えられないと、バッファはデフォルトで読み込み可能かつ書き込み可能となります。

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

julia> io = IOBuffer(b"JuliaLang is a GitHub organization.")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=35, maxsize=Inf, ptr=1, mark=-1)

julia> read(io, String)
"JuliaLang is a GitHub organization."

julia> write(io, "This isn't writable.")
ERROR: ArgumentError: ensureroom failed, IOBuffer is not writeable

julia> io = IOBuffer(UInt8[], read=true, write=true, maxsize=34)
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=34, ptr=1, mark=-1)

julia> write(io, "JuliaLang is a GitHub organization.")
34

julia> String(take!(io))
"JuliaLang is a GitHub organization"

julia> length(read(IOBuffer(b"data", read=true, truncate=false)))
4

julia> length(read(IOBuffer(b"data", read=true, truncate=true)))
0
IOBuffer(string::String)

指定された文字列 string から読み込み専用の IOBuffer を作成します。

julia> io = IOBuffer("Haho");

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

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

Base.take! ── メソッド

take!(b::IOBuffer)

IOBuffer の内容を配列として取得します。コピーは起きません。この関数を実行した IOBuffer は初期状態にリセットされます。

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

Base.fdio ── 関数

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

整数のファイル記述子から IOStream オブジェクトを作成します。owntrue なら、返り値のオブジェクトを閉じたときに内部のファイル記述子も閉じられます。デフォルトで IOStream はガベージコレクトされるときに閉じられます。name を使うとファイル記述子 fd に名前の付いたファイルを関連付けることができます。

Base.flush ── 関数

flush(stream)

与えられたストリームが現在バッファしている書き込みを全てコミットさせます。

Base.close ── 関数

close(stream)

IO ストリームを閉じます。閉じる前に flush が行われます。

Base.write ── 関数

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

値の正準バイナリ表現を指定された IO ストリームもしくはファイルに書き込みます。ストリームに書き込まれたデータのバイト数を返します。テキスト表現を書き込む場合は print を使ってください (print では書き込まれる形式が io によって変わります)。

書き込まれる値のエンディアンはホストシステムのエンディアンによって決まります。プラットフォーム間で一貫した結果を保証するには、書き込み/読み込み時に (htolltoh などで) 固定されたエンディアンへの変換を行ってください。

一度の write の呼び出しで複数の値を書き込むことができます。つまり次の二つは等価です:

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

一貫したシリアライズの例を示します:

julia> fname = tempname(); # ランダムな一時ファイルの名前を取得する。

julia> open(fname,"w") do f
           # 64 ビットの整数をリトルエンディアンのバイトオーダーで書き込む。
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # ホストのバイトオーダーで読み込み、ホストの整数型に変換する。
           Int(ltoh(read(f,Int64)))
       end
42

一度の呼び出しで複数の値を書き込む例を示します:

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

julia> write(io, "Sometimes those members") + write(io, " write documentation.")
44

julia> String(take!(io))
"Sometimes those members write documentation."

ユーザー定義のプレーンデータは、write メソッドを持たなくても Ref で包めば書き込めます:

julia> struct MyStruct; x::Float64; end

julia> io = IOBuffer()
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=Inf, ptr=1, mark=-1)

julia> write(io, Ref(MyStruct(42.0)))
8

julia> seekstart(io); read!(io, Ref(MyStruct(NaN)))
Base.RefValue{MyStruct}(MyStruct(42.0))

Base.read ── 関数

read(io::IO, T)

T の値を io から一つ読みます。値は正準バイナリ表現として読み込まれます。

Julia はエンディアンの変換を行わないことに注意してください。エンディアンの変換には ntoh または ltoh が利用できます。

read(io::IO, String)

io からデータを全て読み、String として返します。

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> read(io, Char)
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> read(io, String)
"JuliaLang is a GitHub organization"
read(filename::AbstractString, args...)

ファイルを開き、その内容を読みます。argsread に渡されます。この関数は open(io->read(io, args...), filename) と等価です。

read(filename::AbstractString, String)

ファイルのデータを全て読み、文字列として返します。

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

s から最大で nb バイトを読み、結果を読んだバイト数と等しい長さの Vector{UInt8} として返します。

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

s から最大で nb バイトを読み、結果を読んだバイト数と等しい長さの Vector{UInt8} として返します。

alltrue (デフォルト値) だと、この関数は要求されたバイト数を読むまで (もしくはエラーまたは EOF が発生するまで) 何度も読み込みを行い、その間ブロックします。allfalse なら read は一度だけ呼ばれ、返るデータの量はデバイス依存となります。なお全てのストリーム型が all オプションをサポートするわけではありません。

read(command::Cmd)

command を実行し、出力をバイト列として返します。

read(command::Cmd, String)

command を実行し、出力を String として返します。

Base.read! ── 関数

read!(stream::IO, array::AbstractArray)
read!(filename::AbstractString, array::AbstractArray)

IO ストリームあるいはファイルからバイナリデータを読み、array に保存します。

Base.readbytes! ── 関数

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

stream から最大 nb バイトを b に読み込み、読み込んだバイト数を返します。b のサイズは必要なら (つまり nblength(b) より大きいとき) 大きくなりますが、小さくなることはありません。

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

stream から最大 nb バイトを b に読み込み、読み込んだバイト数を返します。b のサイズは必要なら (つまり nblength(b) より大きいとき) 大きくなりますが、小さくなることはありません。

alltrue (デフォルト値) だと、この関数は要求されたバイト数を読むまで (もしくはエラーまたは EOF が発生するまで) 何度も読み込みを行い、その間ブロックします。allfalse なら read は一度だけ呼ばれ、返るデータの量はデバイス依存となります。なお全てのストリーム型が all オプションをサポートするわけではありません。

Base.unsafe_read ── 関数

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

ストリームオブジェクト IO から ref (をポインタに変換した場所) へ nbytes バイトのデータをコピーします。

部分型 T <: IO では unsafe_read(s::T, p::Ptr{UInt8}, n::UInt) というシグネチャを持つメソッドをオーバーライドして高速な実装を提供することが推奨されます。

Base.unsafe_write ── 関数

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

ref (をポインタに変換した場所) からストリームオブジェクト IOnbytes バイトのデータをコピーします。

部分型 T <: IO では unsafe_write(s::T, p::Ptr{UInt8}, n::UInt) というシグネチャを持つメソッドをオーバーライドして高速な実装を提供することが推奨されます。

Base.peek ── 関数

peek(stream[, T=UInt8])

ストリームから T 型の値を一つ読んで返します。ただしそのときストリームの現在位置を動かしません。

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)
Julia 1.5

peek の引数 T は Julia 1.5 以降でサポートされます。

Base.position ── 関数

position(s)

ストリームの現在位置を取得します。

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> position(io)
5

julia> skip(io, 10);

julia> position(io)
15

julia> seekend(io);

julia> position(io)
35

Base.seek ── 関数

seek(s, pos)

与えられた位置にストリームをシークします。

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (category Lu: Letter, uppercase)

Base.seekstart ── 関数

seekstart(s)

ストリームを先頭にシークします。

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (category Lu: Letter, uppercase)

julia> seekstart(io);

julia> read(io, Char)
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

Base.seekend ── 関数

seekend(s)

ストリームを末尾にシークします。

Base.skip ── 関数

skip(s, offset)

ストリームを現在位置からの相対位置にシークします。

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> skip(io, 10);

julia> read(io, Char)
'G': ASCII/Unicode U+0047 (category Lu: Letter, uppercase)

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)

ストリーム s に印が付いているなら true を返します。

mark, unmark, reset も参照してください。

Base.eof ── 関数

eof(stream) -> Bool

IO ストリームがファイル終端 (EOF) を指すかどうかを判定します。ストリームを使い切っていないなら、データが利用可能になるのを必要なら待った上で false を返します。そのため、eoffalse 返したときはストリームから一バイトを安全に読み込むことができます。stream の内部バッファにデータが残っている限り、たとえその時点で接続のリモート終端が閉じられていたとしても、eoffalse を返します。

Base.isreadonly ── 関数

isreadonly(io) -> Bool

ストリームが読み込み専用かどうかを判定します。

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

Base.iswritable ── 関数

iswritable(io) -> Bool

IO オブジェクトが書き込み可能 (であることが判定できる) なら true を返します。

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           iswritable(io)
       end
true

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")

Base.isreadable ── 関数

isreadable(io) -> Bool

IO オブジェクトが読み込み可能 (であることが判定できる) なら true を返します。

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           isreadable(io)
       end
false

julia> open("myfile.txt", "r") do io
           isreadable(io)
       end
true

julia> rm("myfile.txt")

Base.isopen ── 関数

isopen(object) -> Bool

ストリームやタイマーのようなオブジェクトが閉じられていないかどうかを判定します。一度閉じられたオブジェクトは二度と新しいイベントを生成しません。ただし閉じられたストリームのバッファに読み込めるデータが残っている可能性があるので、データが読み込めるかどうかの判定には eof を使うべきです。ストリームが書き込みあるいは読み込み可能になった (可能性がある) ときに通知を受け取るには FileWatching パッケージを使ってください。

julia> io = open("my_file.txt", "w+");

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

Base.fd ── 関数

fd(stream)

ストリームあるいはファイルのファイル記述子を返します。この関数は同期的な File および IOStream にだけ適用でき、非同期的なストリームには適用できないことに注意してください。

Base.redirect_stdout ── 関数

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

パイプを作成し、C および Julia レベルで行われる stdout への出力が全てそこにリダイレクトされるようにします。返り値はパイプの両端を示すタプル (rd, wr) です。stdout へ書き込んだデータは rd から読み込めるようになります。wr は古い stdout オブジェクトが別の場所でキャッシュされていて更新が必要な場合に利用します。

省略可能引数 stream を渡して呼び出すと、stream を返します。

情報

streamTTYPipe・ソケットのいずれかである必要があります。

Base.redirect_stdout ── メソッド

redirect_stdout(f::Function, stream)

stdoutstream にリダイレクトした状態で関数 f を実行します。実行が完了すると stdout は元の設定に復元されます。

情報

streamTTYPipe・ソケットのいずれかである必要があります。

Base.redirect_stderr ── 関数

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

redirect_stdout と同様の処理を stderr に対して行います。

情報

streamTTYPipe・ソケットのいずれかである必要があります。

Base.redirect_stderr ── メソッド

redirect_stderr(f::Function, stream)

stderrstream にリダイレクトした状態で関数 f を実行します。実行が完了すると stdout は元の設定に復元されます。

情報

streamTTYPipe・ソケットのいずれかである必要があります。

Base.redirect_stdin ── 関数

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

redirect_stdout と同様の処理を stdin に対して行います。返り値の順序は (rd, wr) で変わらないことに注意してください。つまり stdin から読まれるべきデータを wr に書き込みます。

情報

streamTTYPipe・ソケットのいずれかである必要があります。

Base.redirect_stdin ── メソッド

redirect_stdin(f::Function, stream)

stdinstream にリダイレクトした状態で関数 f を実行します。実行が完了すると stdout は元の設定に復元されます。

情報

streamTTYPipe・ソケットのいずれかである必要があります。

Base.readchomp ── 関数

readchomp(x)

x が持つ全てのデータを文字列として読み、最後に改行があればそれを一つだけ削除して返します。chomp(read(x, String)) と等価です。

julia> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\nIt has many members.\n");
       end;

julia> readchomp("my_file.txt")
"JuliaLang is a GitHub organization.\nIt has many members."

julia> rm("my_file.txt");

Base.truncate ── 関数

truncate(file, n)

第一引数 file が示すファイルまたはバッファのサイズをちょうど n バイトに変更します。ファイルまたはバッファが大きくなる場合には、新しい空間を '\0' で埋めます。

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.")
35

julia> truncate(io, 15)
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=15, maxsize=Inf, ptr=16, mark=-1)

julia> String(take!(io))
"JuliaLang is a "

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.");

julia> truncate(io, 40);

julia> String(take!(io))
"JuliaLang is a GitHub organization.\0\0\0\0\0"

Base.skipchars ── 関数

skipchars(predicate, io::IO; linecomment=nothing)

次に読む文字が predicate に対して false を返す文字となるまでストリーム io を進めます。キーワード引数 linecomment を指定すると、その文字から次の改行までの全ての文字が無視されます。

julia> buf = IOBuffer("    text")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=1, mark=-1)

julia> skipchars(isspace, buf)
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=5, mark=-1)

julia> String(readavailable(buf))
"text"

Base.countlines ── 関数

countlines(io::IO; eol::AbstractChar = '\n')

ストリームまたはファイルの終端まで io を読み、行数を計算します。第一引数にファイル名を渡せばその名前のファイルを処理できます。'\n' 以外の改行マーカーを使う場合は第二引数に指定します。io の最後の空でない行は改行マーカーで終わらなくとも行としてカウントされます。このため countlines の返り値は eachlinereadlines の返り値の長さと一致します。

julia> io = IOBuffer("JuliaLang is a GitHub organization.\n");

julia> countlines(io)
1

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> countlines(io)
1

julia> countlines(io, eol = '.')
0

Base.PipeBuffer ── 関数

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

読み込みと書き込みが両方行える IOBuffer です。シークと切り捨てはサポートされません。利用可能なコンストラクタについては IOBuffer を参照してください。data が与えられるなら、そのデータベクトルを使う PipeBuffer が作成されます。そのとき内部の Array が成長できる最大のサイズを size で指定できます。

Base.readavailable ── 関数

readavailable(stream)

ストリームで利用可能なデータを全て読み込みます。利用可能なデータが存在しなければ、そのときに限ってブロックします。返り値は Vector{UInt8} です。

Base.IOContext ── 型

IOContext

IOContext は出力の構成に関する設定を show メソッドに渡す機構を提供します。

一言で言うと、IOContextIO の部分型である不変辞書です。getindex などの標準的な辞書操作をサポートし、IO ストリームとして使うこともできます。

Base.IOContext ── メソッド

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

与えられたストリームを包む IOContext を、与えられた key=>value の組をストリームのプロパティに追加した状態で作成します (io 自身が IOContext であっても構いません)。

  • 特定のプロパティの組が io に含まれるかどうかを判定するには (key => value) in io を使ってください。
  • 特定のキーに対する最も新しい値を取得するには get(io, key, default) を使ってください。

次のプロパティがよく使われます:

  • :compact: 値をコンパクトに (例えば数値は少ない桁数で) 出力すべきかどうかを指定する真偽値です。このプロパティは配列の要素を出力するときに設定されます。:compact な出力は改行を含まないものとされます。
  • :limit: コンテナを切り捨てる (例えば多数ある配列の要素を とする) べきかどうかを指定する真偽値です。
  • :displaysize: テキスト出力の表示範囲の行数と列数を与える Tuple{Int,Int} 型の値です。この値は別の関数を呼び出すときに表示範囲のサイズを上書きするためにも利用できます。スクリーンサイズは displaysize 関数で取得します。
  • :typeinfo: 既に出力された型情報を表す Type 型の値であり、現在処理中のオブジェクトの出力はこの情報を元に適切に短縮されます。このプロパティを使うと同じ型を持つオブジェクトのコレクション表示で冗長な型情報を避けられるので有用です。例えば [Float16(0)]"Float16[Float16(0.0)]" ではなく "Float16[0.0]" と表示できます: そうするには、配列の要素を表示している間 :typeinfo プロパティを Float16 に設定します。
  • :color: ANSI カラーコードおよびエスケープコードがサポートされる/期待されるかどうかを指定する真偽値です。デフォルトでは julia が起動されたときにコマンドライン引数 --color が付いていたかどうか、そして io が互換性のあるターミナルかどうかで判定されます。

julia> io = IOBuffer();

julia> printstyled(IOContext(io, :color => true), "string", color=:red)

julia> String(take!(io))
"\e[31mstring\e[39m"

julia> printstyled(io, "string", color=:red)

julia> String(take!(io))
"string"
julia> print(IOContext(stdout, :compact => false), 1.12341234)
1.12341234
julia> print(IOContext(stdout, :compact => true), 1.12341234)
1.12341
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)

context のプロパティを受け継いでストリームを io に入れ替えた IOContext を作成します。

テキスト IO

Base.show ── メソッド

show([io::IO = stdout], x)

x のテキスト表現を出力ストリーム io に書き込みます。新しい型 Tshow(io::IO, x::T) をオーバーロードするべきです。show が生成するテキスト表現は一般に Julia 特有のフォーマットと型情報を持ち、可能ならば Julia コードとしてパースできるべきとされます。

reprshow の結果を文字列として返します。

T 型のオブジェクトの人間が読むためのテキスト出力をカスタマイズするには、二引数の show(io::IO, x::T) ではなく三引数の show(io::IO, ::MIME"text/plain", ::T) を定義してください。::MIME"text/plain" を受け取るメソッドでは IOContextio が持つ :compact プロパティを確認することが推奨されます。コンテナ型が要素を出力するときは :compact => true としてこのメソッドを呼び出される可能性があるためです。

装飾されていない表現を書き込む print も参照してください。

julia> show("Hello World!")
"Hello World!"
julia> print("Hello World!")
Hello World!

Base.summary ── 関数

summary(io::IO, x)
str = summary(x)

x の簡単な説明をストリーム io に出力するか、文字列として返します。デフォルトでは "Int64" のように string(typeof(x)) で得られる文字列を返します。

配列に対しては 10-element Array{Int64,1} のようにサイズと型の情報からなる文字列を返します。

julia> summary(1)
"Int64"

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

Base.print ── 関数

print([io::IO], xs...)

正準な (装飾されていない) テキスト表現を io に (io が与えられなければ stdout に) 書き込みます。print が生成するテキスト表現はフォーマットを最小限にして、Julia 特有の詳細を追加するのを避けるべきです。

printshow にフォールバックします。そのため多くの型では show を定義すれば十分です。もし考えている型が “プレーンな” 表現を持つなら print を定義してください。例えば show はクオートした文字列を表示しますが、print はクオートせずに文字列を表示します。

stringprint の出力を文字列として返します。

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 に出力します。

julia> println("Hello, world")
Hello, world

julia> io = IOBuffer();

julia> println(io, "Hello, world")

julia> String(take!(io))
"Hello, world\n"

Base.printstyled ── 関数

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

シンボルまたは整数で指定される色を使って xs の各要素を出力します。出力は太字にもできます。

color に指定できるシンボルの値は :normal, :default, :bold, :black, :blink, :blue, :cyan, :green, :hidden, :light_black, :light_blue, :light_cyan, :light_green, :light_magenta, :light_red, :light_yellow, :magenta, :nothing, :red, :reverse, :underline, :white, :yellow で、整数の値は 0 から 255 (境界含む) です。256 色の全てをサポートしないターミナルもあるので注意してください。キーワード引数 boldtrue だと、出力は太字で表示されます。

Base.sprint ── 関数

sprint(f::Function, args...; context=nothing, sizehint=0)

関数 f を IO ストリームと args を引数として呼び出します。f に渡される IO へ書き込まれたデータを文字列として返します。省略可能なキーワード引数 context に指定できるのは

  • :key=>value
  • IO オブジェクト
  • IOContext オブジェクト

のいずれかであり、:key=>value という属性 (あるいは io に含まれる属性) が f に渡される IO ストリームで使われます。sizehint は文字列を書き込むときに使われるバッファの容量を提案します (単位はバイト)。

julia> sprint(show, 66.66666; context=:compact => true)
"66.6667"

julia> sprint(showerror, BoundsError([1], 100))
"BoundsError: attempt to access 1-element Array{Int64,1} at index [100]"

Base.showerror ── 関数

showerror(io, e)

例外オブジェクト e を説明する表現を表示します。このメソッドは throw が呼ばれた後に例外を表示するために使われます。

julia> struct MyException <: Exception
           msg::AbstractString
       end

julia> function Base.showerror(io::IO, err::MyException)
           print(io, "MyException: ")
           print(io, err.msg)
       end

julia> err = MyException("test exception")
MyException("test exception")

julia> sprint(showerror, err)
"MyException: test exception"

julia> throw(MyException("test exception"))
ERROR: MyException: test exception

Base.dump ── 関数

dump(x; maxdepth=8)

値の表現を省略せずに表示します。出力は深さ maxdepth で打ち切られます。

julia> struct MyStruct
           x
           y
       end

julia> x = MyStruct(1, (2,3));

julia> dump(x)
MyStruct
  x: Int64 1
  y: Tuple{Int64,Int64}
    1: Int64 2
    2: Int64 3

julia> dump(x; maxdepth = 1)
MyStruct
  x: Int64 1
  y: Tuple{Int64,Int64}

[email protected] ── マクロ

@dump expr

与えられた式に含まれる全てのパーツを表示します。dump(:(expr)) と等価です。

Base.readline ── 関数

readline(io::IO=stdin; keep::Bool=false)
readline(filename::AbstractString; keep::Bool=false)

指定された IO ストリームあるいはファイルから一行のテキストを読みます。ファイルまたはストリームが指定されないときのデフォルト値は stdin です。ファイルから読み込まれるテキストは UTF-8 でエンコードされると仮定されます。入力に含まれる '\n', "\r\n", EOF が行の終わりを表します。keepfalse (デフォルト値) だと、行末の改行を削除して返します。keeptrue だと、改行も行の一部として返ります。

julia> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\nIt has many members.\n");
       end
57

julia> readline("my_file.txt")
"JuliaLang is a GitHub organization."

julia> readline("my_file.txt", keep=true)
"JuliaLang is a GitHub organization.\n"

julia> rm("my_file.txt")

Base.readuntil ── 関数

readuntil(stream::IO, delim; keep::Bool = false)
readuntil(filename::AbstractString, delim; keep::Bool = false)

IO ストリームまたはファイルから指定された区切り文字まで文字列を読みます。区切り文字に指定できるのは UInt8/AbstractChar/文字列/ベクトルです。キーワード引数 keep は区切り文字を返り値に含めるかどうかを制御します。テキストは UTF-8 でエンコードされると仮定されます。

julia> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\nIt has many members.\n");
       end
57

julia> readuntil("my_file.txt", 'L')
"Julia"

julia> readuntil("my_file.txt", '.', keep = true)
"JuliaLang is a GitHub organization."

julia> rm("my_file.txt")

Base.readlines ── 関数

readlines(io::IO=stdin; keep::Bool=false)
readlines(filename::AbstractString; keep::Bool=false)

IO ストリームあるいはファイルの全ての行からなる文字列のベクトルを返します。これは readline を同じ引数で何度も呼び出し、結果を文字列のベクトルに格納し、結果を返すのと等価です。

julia> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\nIt has many members.\n");
       end
57

julia> readlines("my_file.txt")
2-element Array{String,1}:
 "JuliaLang is a GitHub organization."
 "It has many members."

julia> readlines("my_file.txt", keep=true)
2-element Array{String,1}:
 "JuliaLang is a GitHub organization.\n"
 "It has many members.\n"

julia> rm("my_file.txt")

Base.eachline ── 関数

eachline(io::IO=stdin; keep::Bool=false)
eachline(filename::AbstractString; keep::Bool=false)

IO ストリームあるいはファイルを読んで各行を生成する EachLine 型の反復可能オブジェクトを作成します。反復すると readline が同じストリームに対して呼び出され、そのとき行末を保持するかどうかを示す keep 引数も渡されます。ファイル名を指定して eachline を呼び出すと、ファイルは反復の最初で開かれ、最後の反復で閉じられます。反復が中断されると、ファイルは EachLine オブジェクトがガベージコレクトされるときに閉じられます。

julia> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\n It has many members.\n");
       end;

julia> for line in eachline("my_file.txt")
           print(line)
       end
JuliaLang is a GitHub organization. It has many members.

julia> rm("my_file.txt");

Base.displaysize ── 関数

displaysize([io::IO]) -> (lines, columns)

IO オブジェクトに出力するときに使うべきスクリーンサイズを返します。入力が与えられないと、環境変数 LINESCOLUMNS を返します。 もしこの二つの環境変数が定義されていないと、デフォルトのサイズ (24, 80) が返ります。

julia> withenv("LINES" => 30, "COLUMNS" => 100) do
           displaysize()
       end
(30, 100)

TTY のサイズを取得するには次のようにしてください:

julia> displaysize(stdout)
(34, 147)

マルチメディア IO

テキスト形式の出力を行うのは print であり、ユーザー定義型のテキスト表現は show をオーバーロードすることで指定します。これと同様に、Julia はリッチなマルチメディア出力 (例えば画像や整形されたテキストから、音声や動画まで) を行うための標準化されたメカニズムを持ちます。このメカニズムは次の三つの部分からなります:

基礎的な Julia ランタイムはプレーンテキストのディスプレイだけを提供しますが、外部モジュールを読み込んだりグラフィカルな Julia 環境 (IPython ベースの IJulia ノートブックなど) を使ったりすればリッチなディスプレイを有効にできます。

Base.Multimedia.AbstractDisplay ── 型

AbstractDisplay

リッチディスプレイの出力デバイスを表す抽象上位型です。部分型に TextDisplay などを持ちます。

Base.Multimedia.display ── 関数

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

ディスプレイスタックを上から順に調べ、最初に見つかった x に適用可能なディスプレイを使って x を表示します。通常は x をサポートする最もリッチなマルチメディアディスプレイが使われ、プレーンテキストを stdout に出力するディスプレイがフォールバックとなります。display(d, x) の形式は指定されたディスプレイ d だけを使って x の表示を試み、dx の型を表示できなければ MethodError を送出します。

print(x)show(x) と異なり、一般に display の出力が stdout に向かうことを仮定してはいけません。例えば display(x) が異なるウィンドウで画像を開くこともあります。display(x) は「現在の出力デバイスで可能な最も優れた方法で x を表示せよ」を意味します。REPL と同じような stdout に向かうテキスト出力を期待するなら、show(stdout, "text/plain", x) を使ってください。

"image/png" のような MIME タイプを表す文字列 mime を引数に受け取る後ろの二つの形式では、指定された MIME タイプを使った x の出力だけが試されます。指定した MIME タイプがディスプレイあるいは x によって定義されていなければ MethodError が送出されます。これらの形式を使うときは、指定した MIME タイプの “生の” データを指定することもできます。つまり text/htmlapplication/postscript のようなテキストベースの格納形式を持つ MIME タイプでは x::AbstractString を渡すことができ、バイナリの MIME タイプでは x::Vector{UInt8} として渡すことができます。

マニュアルの独自型の出力の整形の節で説明されている通り、型のインスタンスの表示をカスタマイズするときは、display ではなく show をオーバーロードするべきです。

Base.Multimedia.redisplay ── 関数

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

デフォルトでは、redisplaydisplay を呼ぶだけです。ただし、ディスプレイバックエンドは redisplay をオーバーライドして x に対する既存の表示方法を変更できます。また redisplay の利用は、x が複数回表示される可能性があることをバックエンドに伝えるヒントでもあります。この場合バックエンドは表示を (例えば次の対話プロンプトまで) 遅らせることができます。

Base.Multimedia.displayable ── 関数

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

文字列 mime が表す MIME タイプが表示可能かどうかを示す真偽値を返します。一つ目の形式ではディスプレイスタックにあるディスプレイのどれかで表示可能かどうかが、二つ目の形式ではディスプレイ d で表示可能かどうかが判定されます。

Base.show ── メソッド

show(io::IO, mime, x)

display 関数がオブジェクト x を MIME タイプ mime でストリーム io (たいていはメモリバッファ) に書き込むとき、表示が可能な場合に最終的に呼ばれるのが show 関数です。ユーザー定義型にリッチなマルチメディア表現を追加するときは、T 型に対する新しい show メソッドだけを追加すれば十分です: MIME タイプ mime に対して show(io, ::MIME"mime", x::T) = ... を定義して、xmime における表現を write といった関数で io に書き込んでください (MIME"..." を使った記法はリテラル文字列だけをサポートする点に注意が必要です。MIME 型の値を柔軟に構築するには MIME{Symbol("...")} を使ってください)。

例えば独自型 MyImage が定義されていて、それを PNG ファイルとして書き出す方法を知っているとします。このとき show(io, ::MIME"image/png", x::MyImage) = ... を定義すれば、その型が表す画像を PNG に対応した AbstractDisplay (例えば IJulia) で表示できるようになります。なお Julia 組み込みの他の関数と同じように、show に新しいメソッドを追加するときは import Base.show が必要です。

細かいことを言っておくと、MIME"mime" マクロは与えられた文字列 mime を表すシングルトン型を定義します。これと Julia ディスパッチ機構により、指定された型オブジェクトの表示方法の選択が可能になります。

デフォルトの MIME タイプは MIME"text/plain" です。text/plain に対しては二引数の show を呼び出すフォールバックが定義されているので、メソッドの追加が必ず必要というわけではありません。ただし、人間が読むための通常とは異なる出力を考えている型 T に追加できるなら、show(::IO, ::MIME"text/plain", ::T) を定義するべきです。例えば Day 型の値 Day(1) を MIME タイプ text/plain で出力すると 1 day となるのに対して、二引数の show で出力すると Day(1) となります。

一般にコンテナ型では三引数の show を定義し、その本体で :compact => true とした IOContext を第一引数に用いた show(io, MIME"text/plain"(), x) を各要素 x に対して呼び出すべきです。

Base.Multimedia.showable ── 関数

showable(mime, x)

オブジェクト x を指定された MIME タイプ mime で出力できるかどうかを示す真偽値を返します。

デフォルトでは、この関数の返り値は typeof(x) に対応する show メソッドが存在するかどうかで判定されます。独自の showable メソッドを提供する型もあります: 例えば利用可能な MIME フォーマットが xによって変わる型です。

julia> showable(MIME("text/plain"), rand(5))
true

julia> showable("img/png", rand(5))
false

Base.repr ── メソッド

repr(mime, x; context=nothing)

指定された MIME タイプにおける x の表現を含んだ AbstractString または Vector{UInt8} を返します。返り値は show(io, mime, x) を使って生成され、この形の show が利用できなければ MethodError が発生します。テキスト表現を持つ MIME タイプ (例えば "text/html""application/postscript") に対しては AbstractString が返り、そうでないバイナリ表現を持つ MIME タイプに対しては Vector{UInt8} が返ります。特定の MIME タイプを Julia がテキストとして扱うかどうかは istextmime(mime) で判定できます。

省略可能なキーワード引数 context に設定できるのは :key=>value という組あるいは IOContext オブジェクトです。:key=>value という属性 (あるいは io に含まれる属性) が show に渡される IO ストリームで使われます。

特別なケースとして、mime がテキスト形式の MIME タイプで xAbstractString のとき、および mime がバイナリ形式の MIME タイプで xVector{UInt8} のとき、repr 関数は x が最初から指定された MIME 形式を持つとみなし、x をそのまま返します。この特別扱いは MIME タイプが "text/plain" のときは起こりません。この振る舞いは生のデータが display(m::MIME, x) に渡されたときに利用されます。

具体的な例を一つ挙げておくと、通常 repr("text/plain", x) は人間が読むことを意図した “綺麗に成形された” バージョンの x を返します。Julia コードで x の値を入力するときにタイプする文字列に近いものを取得するには、show(x) に対応する repr(x) を使ってください。

julia> A = [1 2; 3 4];

julia> repr("text/plain", A)
"2×2 Array{Int64,2}:\n 1  2\n 3  4"

Base.Multimedia.MIME ── 型

MIME

インターネットで使われる標準的なデータフォーマットを表す型です。“MIME” は “Multipurpose Internet Mail Extensions” の略です。“Mail” とあるのは、元々 MIME が電子メールのメッセージに付属するマルチメディアの形式を指定するのに使われていたためです。

MIME オブジェクトを show に渡すと、出力をそのフォーマットにするよう要請できます。

julia> show(stdout, MIME("text/plain"), "hi")
"hi"

[email protected]_str ── マクロ

@MIME_str

MIME 型を簡単に書くためのマクロです。通常は show にメソッドを追加するときに使われます。例えば show(io::IO, ::MIME"text/html", x::MyType) = ... とすれば MyType 型の値の HTML 表現を出力する方法を定義できます。

上述したように、新しいディスプレイバックエンドを定義することもできます。例えば PNG 画像をウィンドウに表示できるモジュールがあるなら、その機能を Julia に登録することで、PNG 表現を持った型の値に対する display(x) がそのモジュールのウィンドウを使って画像を表示するようにできます。

新しいディスプレイバックエンドを定義する方法を示します。

  1. まず AbstractDisplay 型の部分型 D を作成します。
  2. 次に D が表示できる MIME タイプそれぞれについて、MIME タイプ dx を表示するメソッド display(d::D, ::MIME"mime", x) = ... を定義します。おそらく show(io, mime, x)repr(io, mime, x) を使うことになるでしょう。指定された MIME タイプで x を表示できない場合は MethodError を送出するべきですが、この処理は showrepr を呼べば自動的に行われます。
  3. 最後にメソッド display(d::D, x) を定義します。このメソッドでは D がサポートする MIME タイプそれぞれに対して showable(mime, x) を問い合わせ、“最良の” ものを使って x を表示します。ここでも x に対して使える MIME タイプが存在しなければ MethodError を送出してください。

さらに一部の型では redisplay(d::D, ...) のオーバーライドが必要になります。なお、こういった関数の返り値は実装ごとに異なります (何らかの型の「ハンドル」を返せると便利な場合があるためです)。以上で D に対する display 関数が直接呼び出せるようになります。さらに次の関数で新しいディスプレイをディスプレイスタックにプッシュすれば、display(x) で新しいメソッドが自動的に呼ばれるようになります:

Base.Multimedia.pushdisplay ── 関数

pushdisplay(d::AbstractDisplay)

ディスプレイバックエンドを保持するグローバルなスタックに新しいディスプレイ d をプッシュします。display(x) あるいは display(mime, x) を呼び出すと、スタックに含まれる x を処理可能な (つまり MethodError を送出しない) バックエンドの中で一番上にあるものを使って x が表示されます。

Base.Multimedia.popdisplay ── 関数

popdisplay()
popdisplay(d::AbstractDisplay)

一つ目の形式では、ディスプレイバックエンドのスタックの一番上にあるディスプレイをポップします。二つ目の形式では一番上にある d のコピーが取り除かれます。

Base.Multimedia.TextDisplay ── 型

TextDisplay(io::IO)

TextDisplay <: AbstractDisplay 型の値を返します。この型のディスプレイに対する display は、任意のオブジェクトのテキスト表現を text/plain (デフォルト) の MIME タイプで IO ストリームに書き込みます。Julia REPL でオブジェクトはこの型のディスプレイを使って出力されます。

Base.Multimedia.istextmime ── 関数

istextmime(m::MIME)

MIME タイプがテキストデータかどうかを判定します。テキストデータ (Unicode 含む) と認識される既知の MIME タイプ以外は全てバイナリデータと扱われます。

julia> istextmime(MIME("text/plain"))
true

julia> istextmime(MIME("img/png"))
false

ネットワーク IO

Base.bytesavailable ── 関数

bytesavailable(io)

ストリームあるいはバッファからブロックせずに読めるデータのバイト数を返します。

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> bytesavailable(io)
34

Base.ntoh ── 関数

ntoh(x)

値のエンディアンをネットワークバイトオーダー (ビッグエンディアン) からホストで使われているエンディアンに変換します。

Base.hton ── 関数

hton(x)

値のエンディアンをホストで使われているエンディアンからネットワークバイトオーダー (ビッグエンディアン) に変換します。

Base.ltoh ── 関数

ltoh(x)

値のエンディアンをリトルエンディアンからホストで使われているエンディアンに変換します。

Base.htol ── 関数

htol(x)

値のエンディアンをホストで使われているエンディアンからリトルエンディアンに変換します。

Base.ENDIAN_BOM ── 定数

ENDIAN_BOM

ホストマシンのネイティブバイトオーダーを示す 32 ビットのバイトオーダーマークです。

日本語 Julia 書籍 (Amazon アソシエイト)
1 から始める Julia プログラミング
Julia プログラミングクックブック―言語仕様からデータ分析、機械学習、数値計算まで
スタンフォード ベクトル・行列からはじめる最適化数学