読者です 読者をやめる 読者になる 読者になる

りんごがでている

何か役に立つことを書きます

PythonistaのためのJulia100問100答

Julia

この記事はJulia Advent Calendar 2014の12日目の記事だったはずのものです(遅れてすいません...)。 Pythonユーザーとしての自分に対して100問100答形式で気になるだろうことを列挙したものになっています。

全体は以下の様なセクションに分かれています。

  • Julia
  • 環境
  • データ
  • 技術計算
  • 言語機能
  • 文字列 / 正規表現
  • ファイル / IO
  • システム
  • プロファイリング / ベンチマーク / テスト
  • ライブラリ

Juliaのバージョンはv0.3系を基本としていますが、開発中のv0.4の内容も必要に応じてコメントしています。

Julia

Juliaってどういう言語なの?

Juliaは高レベルでハイパフォーマンスな技術計算のための動的言語だよ。 構文はPythonユーザーならすぐに理解できるよ。

公式ウェブページはここ: http://julialang.org/


誰が作ってるの?

主にMITの人達が中心になって作ってる言語だよ。 特にJeff Bezansonという人が創始者のひとりで、一番コミットしてる人だよ。


ライセンスはどうなってるの?

Juliaの処理系自体はMIT Licenseだよ。 外部のライブラリや一部のソースコードに一部他のライセンスが適用されているよ。 詳しくはLICENSE.mdを見てね。


Juliaって速いの?

とっても速いよ!

ここで他の言語との比較ベンチマークが見られるからのぞいてみてごらん。 CやFortranのような言語と比べても決して遜色ないし、きっと動的型付け言語としては最速クラスだと思うよ!


何で速いの?

LLVMベースのJITコンパイラを搭載してるからだよ。 C言語みたいにビルドとか要らないし、インタープリタをつかうPythonと同じ感覚で簡単に動かせるよ。


PythonにもCythonとかあるけど?

「いやCythonとか面倒やろ、ていうかね、なんで別の言語使わないとあかんねんと。一つの言語でパフォーマンスが要求されるコアの部分からインターフェースまで書く、そういう考え方もできると思うんですよ。だって考えてみてくださいよ、ブラジルの選手Cython書かないでしょ。」


PyPyもあるけど?

最適化の仕方が多分かなり違うから、コードによってはJuliaのほうがずっと速かったりするよ。


Numbaもあるよね?

そうだね!


速度比較できるコード例はある?

大分極端な差が出るパフォーマンス比較だと、Nクイーン問題を解いた以下の例があるよ。

N Julia v0.4.0dev CPython 2.7.8 PyPy 2.4.0
11 0.0285 2.34 0.99
12 0.164 13.9 4.80
13 1.02 - 29.47

(単位は秒, 2.6GHz Intel Core i5, Mac OS X 10.9.5)

なお、測定にはJuliaは@timeマクロ、CPythonはIPythonのtimeit、PyPyはtimeitが正しく動かないのでrun -tスクリプトを実行してWall timeを計測したよ。 PyPyには少し不利な測定方法だけど、それでもJuliaがすごく速いね!

function solve(n::Int)
    places = zeros(Int, n)
    search(places, 1, n)
end

function search(places, i, n)
    if i == n + 1
        return 1
    end

    s = 0
    @inbounds for j in 1:n
        if isok(places, i, j)
            places[i] = j
            s += search(places, i + 1, n)
        end
    end
    s
end

function isok(places, i, j)
    qi = 1
    @inbounds for qj in places
        if qi == i
            break
        elseif qj == j || abs(qi - i) == abs(qj - j)
            return false
        end
        qi += 1
    end
    true
end
def solve(n):
    places = [-1] * n
    return search(places, 0, n)


def search(places, i, n):
    if i == n:
        return 1

    s = 0
    for j in range(n):
        if isok(places, i, j):
            places[i] = j
            s += search(places, i + 1, n)
    return s


def isok(places, i, j):
    for qi, qj in enumerate(places):
        if qi == i:
            break
        elif qj == j or abs(qi - i) == abs(qj - j):
            return False
    return True

環境

Juliaのレポジトリはどこ?

GitHubホスティングされてるよ: https://github.com/JuliaLang/julia

インストールはJulia環境構築 2014 ver. #julialangを参考にしてね。


IPythonみたいなのはあるの?

コンソールではJuliaのREPLはわりと強力だよ。 juliaコマンドでREPLを立ち上げて、?と入力すると関数のドキュメントも参照できるし、;と入力するとシェルコマンドも実行できるすぐれものだよ! タブ補完もあるし、Bashのような履歴機能もあるし、色も着くし、さらに全てJulia自身で実装されているんだよ! あとIPython Notebookを使えるIJuliaというのもあるよ。 それにJupyterプロジェクトのJuはJuliaのJuだよ。


EmacsとかVimのサポートはあるの?

Emacsjulia-mode.elが本体で開発されているよ。 Vimjulia-vimというプラグインがあるよ。

あとはLightTable用のJunoとか、Sublime Textのためのパッケージもあるよ。


PyPIみたいなパッケージのレポジトリはあるの?

パッケージの管理はJuliaの機能にそもそも組み込まれているよ。 パッケージはhttp://pkg.julialang.org/で探せるよ。 このパッケージ管理はMETADATA.jlというメタパッケージを通して行われてるんだ。

Packages


どうやってパッケージをインストールするの?

JuliaのREPLを立ち上げてPkg.add("PackageName")などとするとMETADATA.jlに登録されているパッケージはインストールできるよ。

他にはシェルから直接

julia -e 'Pkg.add("PackageName")'

としてもOKだよ。

METADATA.jlにはないけどGitHubなどにホスティングされているGitレポジトリなら、Pkg.addの代わりにPkg.cloneにGitレポジトリのURLを渡すとインストールできるよ。

PEP8みたいなスタイルの規範はあるの?

きっちりこれに従わなければ村八分というのはないけど、ゆるい慣習としてドキュメントに記載されているのは、

  • 変数名は小文字
  • 単語の境界はアンダースコア(_)。でもなるべく使用は避ける。
  • 型名は大文字で始まり、CamelCase
  • 関数名やマクロ名は小文字でアンダースコアなし。
  • 引数を破壊的に変更する関数は!をつける(sort!など)。

だよ。

他に標準ライブラリを読むと、

  • スペース4つでインデント
  • オペレータの左右にはスペース(✖: x+y, ✔: x + y)
  • ただし配列のインデックスではスペースを空けない(1:n-3など)

といったルールに従ってるっぽいかな。

Stylistic Conventions


う〜んPythonを呼び出したいなぁ...

実はPyCall.jlなんていうPythonを呼び出せるライブラリもあるよ。 かなりちゃんと動くよ!


今度はC++を...

まだ若いけどCxx.jlがかなり期待できそうだよ。 他にはC++をCでラップして呼び出す方法もあるよ。


データ

TrueFalseは?

小文字化したtruefalseがあるよ。


数値は?

基本Pythonと同じように42と書くと整数、42.0とかくと浮動小数点数になるよ。


Noneは?

nothingがそれに当たるよ。


演算子はどんな感じ?

+, -, *Pythonと同じ感じ。でも/はPython2でなくPython3と同じように整数 / 整数浮動小数点数になるので気をつけてね。

julia> 10 / 2
5.0

julia> 3 / 2
1.5

Python2の/に当たるのはJuliaではdiv関数だよ。

julia> div(10, 2)
5

julia> div(3, 2)
1

andorは?

JuliaではC言語と同様に&&||を使うよ。


Pythonlistdictにあたるのは何?

PythonlistはJuliaのVector{T}型に、dictDict{K,V}型が対応してるよ。


そのVector{T}TとかDict{K,V}KとかVとかは何?

型パラメータ(type parameter)だよ。Vector{T}ならそのベクターT型の要素を持っていて、Dict{K,V}K型が辞書のキーでVが値の型だよ。 例えばVector{Int64}なら(符号付き)64bitの整数が要素のベクターだし、Dict{ASCIIString,Bool}ならASCII文字列がキーでブール値が値の辞書だよ。


type関数みたいにある値の型の確認するのはどうするの?

typeof関数を使おう。

julia> typeof(1)
Int64

julia> typeof(1.0)
Float64

julia> typeof([1,2,3])
Array{Int64,1}

julia> typeof("foobar")
ASCIIString (constructor with 2 methods)

julia> typeof("漢字とか")
UTF8String (constructor with 2 methods)

Vectorのインデックス0の要素にアクセスしようとしたらエラーがでたんだけど!?

そうそう、Juliaではインデックスは1始まりだよ。


xrangeはあるの?

範囲型ももちろんあるよ!例えばPythonxrange(0, 10)はJuliaだと0:9と書くよ。 Pythonと違って範囲の右端が含まれることに注意してね!


dictは?

Dict{K,V}という型があるよ。Kがキーの型でVが値の型だよ。

julia> d = Dict{ASCIIString,Int}()
Dict{ASCIIString,Int64} with 0 entries

julia> d["foo"] = 100
100

julia> d["bar"] = 200
200

julia> d["bar"]
200

julia> haskey(d, "foo")
true

julia> haskey(d, "baz")
false

tupleは?

あるよあるよ!Pythonと同じようにコンマ(,)をつかって作れるよ!

julia> 1, 1.0, "one"
(1,1.0,"one")

julia> (1, 1.0, "one")
(1,1.0,"one")

Pythonのタプルとの違いはタプルはその要素によって型が別々なところかな。

julia> typeof((1, 1.0, "one"))
(Int64,Float64,ASCIIString)

julia> typeof((1, "壱"))
(Int64,UTF8String)

関数も引数として渡したりできるの?

もちろん! Juliaでは関数もFunctionという型のオブジェクトだよ。


lambda式みたいな無名関数は?

->という矢印を使うと作れるよ。

julia> x -> x * 10
(anonymous function)

julia> map(x -> x * 10, [1,2,3])
3-element Array{Int64,1}:
 10
 20
 30

julia> typeof(x -> x * 10)
Function

日付・時刻を表すdatetimeみたいなのは?

v0.4からDateTime型が入るよ!

http://julia.readthedocs.org/en/latest/stdlib/dates/


もっとPythonの型との対応関係を教えて!

はいよ!

ちなみにPython2系を基準にしてるよ。

Python Julia 備考
NoneType Nothing v0.4からはVoid
bool Bool
int Int IntがInt32かInt64かは環境依存
float Float64
str ASCIIString
unicode UnicodeString
dict Dict{K,V}
list Vector{T}
bytearray Vector{Uint8} v0.4からは Vector{UInt8}
tuple (T1,), (T1,T2), (T1,T2,T3), ...
set Set{T} / IntSet
xrange UnitRange{T} / StepRange{T,S} 浮動小数点数などの範囲型もある
datetime DateTime v0.4から
module Module
type DataType
Exception Exception 抽象型

技術計算

NumPyとかSciPyみたいなのが使いたいんだけど?

Juliaは技術計算のための言語を目的としてるから、標準ライブラリとして多くが組み込まれているよ。


NumPyのndarrayはどれ?

Array{T,N}という多次元配列があるよ。 実はさっきのVector{T}Array{T,1}という1次元配列のエイリアスだよ。


NumPyみたいなベクトル化の計算もできるの?

もちろん! +Arrayに対しても定義されてるからね。 要素ごとの加算であることを明確にするため.+という演算子もあるよ。

julia> x = [1,2,3]
3-element Array{Int64,1}:
 1
 2
 3

julia> y = [4,5,6]
3-element Array{Int64,1}:
 4
 5
 6

julia> x + y
3-element Array{Int64,1}:
 5
 7
 9

julia> x .+ y
3-element Array{Int64,1}:
 5
 7
 9

空の配列をつくるときは?

Array型のコンストラクタを呼ぶと目的の型の配列を作ってくれるよ。 呼び出し方はArray(<型名>, <サイズのタプル>)だよ。 初期化されてないこともあるから注意してね。

julia> Array(Int, (2, 3))
2x3 Array{Int64,2}:
 140339717649152  140339717659744  140339700672608
 140339719760256  140339700672608                0

julia> Array(Int, (2, 3, 4))
2x3x4 Array{Int64,3}:
[:, :, 1] =
 0  0  0
 0  0  0

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

[:, :, 3] =
 0  0  0
 0  0  0

[:, :, 4] =
 0  0  0
 0  0  0

julia> Array(Float64, (10, 10))
10x10 Array{Float64,2}:
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0

配列の初期化をしたいんだけど?

fill!を使ってね。 !がついてる関数は破壊的なので元の配列に直接書き込むよ。

julia> x = Array(Float64, (3, 3))
3x3 Array{Float64,2}:
 6.95286e-310  6.95285e-310  0.0
 6.95285e-310  0.0           0.0
 6.95286e-310  0.0           0.0

julia> fill!(x, 0.5)
3x3 Array{Float64,2}:
 0.5  0.5  0.5
 0.5  0.5  0.5
 0.5  0.5  0.5

julia> x
3x3 Array{Float64,2}:
 0.5  0.5  0.5
 0.5  0.5  0.5
 0.5  0.5  0.5

非破壊版のfillもあるよ。


0や1で埋められた配列はどうつくるの?

zerosonesや関数があるよ。

julia> zeros(3, 3)
3x3 Array{Float64,2}:
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0

julia> zeros((3, 3))
3x3 Array{Float64,2}:
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0

julia> zeros(Int, 3, 3)
3x3 Array{Int64,2}:
 0  0  0
 0  0  0
 0  0  0

julia> ones(3, 3)
3x3 Array{Float64,2}:
 1.0  1.0  1.0
 1.0  1.0  1.0
 1.0  1.0  1.0

scipy.sparseみたいな疎行列が欲しいなぁ?

SparseMatrixCSCがあるよ! spzerosでゼロ初期化された疎行列を作れるよ。 試しに10,000 x 10,000行列を作ってみよう。

julia> x = spzeros(10000, 10000)
10000x10000 sparse matrix with 0 Float64 entries:

julia> x[rand(1:10000, 3), rand(1:10000, 3)] = randn(9)
9-element Array{Float64,1}:
  0.273565
  0.982527
  0.469546
 -0.132561
  0.49318
 -0.59534
 -0.403649
 -0.748683
  0.819549

julia> x
10000x10000 sparse matrix with 9 Float64 entries:
        [1564 ,   858]  =  0.819549
        [4492 ,   858]  =  -0.748683
        [7057 ,   858]  =  -0.403649
        [1564 ,  4839]  =  -0.59534
        [4492 ,  4839]  =  0.49318
        [7057 ,  4839]  =  -0.132561
        [1564 ,  9154]  =  0.469546
        [4492 ,  9154]  =  0.982527
        [7057 ,  9154]  =  0.273565

scipy.statsでやるみたいに確率分布からサンプリングしたいんだけど?

Distributions.jlがあるよ。


線形方程式系が解きたいんだけど?

\\という演算子があるよ。 例えば、Ax = yという方程式を解くなら以下の様な感じだよ。

julia> A = [1.0 2.0; 2.0 3.0]
2x2 Array{Float64,2}:
 1.0  2.0
 2.0  3.0

julia> y = [5.0, 8.0]
2-element Array{Float64,1}:
 5.0
 8.0

julia> A \ y
2-element Array{Float64,1}:
 1.0
 2.0

LU分解とかQR分解とかSVDとか固有値とか行列式とか...

ここを見て! http://julia.readthedocs.org/en/latest/stdlib/linalg/


言語機能

defみたいな関数定義の方法は?

function ... endで関数が定義できるよ。

例えばn番目のフィボナッチ数の計算をするfib(n)なら、

function fib(n)
    if n < 2
        return 1
    else
        return fib(n - 1) + fib(n - 2)
    end
end

という感じ。ちなみにreturnは省略可能なので省略されることも多いよ。

もう一つの記法として、

fib(n) = n < 2 ? 1 : fib(n - 1) + fib(n - 2)

というように一行で定義することもできるよ。

引数の型を制限するために、

function fib(n::Integer)
    # ...
end

というように::<型>を引数につけられるよ。

Functions


可変長引数は?

args...というように仮引数に...をつけると使えるよ。

function foo(x, y, zs...)
    println("x: $x")
    println("y: $y")
    println("zs: $zs")
end

これを使ってみると、

julia> foo(1, 2)
x: 1
y: 2
zs: ()

julia> foo(1, 2, 3)
x: 1
y: 2
zs: (3,)

julia> foo(1, 2, 3, 4)
x: 1
y: 2
zs: (3,4)

julia> foo(1, 2, 3, 4, 5)
x: 1
y: 2
zs: (3,4,5)

と言ったかんじ。

可変長引数の展開も同じように...をつけるんだよ。

julia> zs = [3, 4, 5]
3-element Array{Int64,1}:
 3
 4
 5

julia> foo(1, 2, zs...)
x: 1
y: 2
zs: (3,4,5)

Varargs Functions


オプション引数やキーワード引数は?

もちろん使えるよ!

オプション引数:

function foo(x, y=1, z=2)
    println("x: $x")
    println("y: $y")
    println("z: $z")
end

使用例:

julia> foo(0)
x: 0
y: 1
z: 2

julia> foo(0, 100)
x: 0
y: 100
z: 2

julia> foo(0, 100, 200)
x: 0
y: 100
z: 200

キーワード引数:

function foo(x; y=1, z=2)
    println("x: $x")
    println("y: $y")
    println("z: $z")
end

使用例:

julia> foo(0, y=1, z=2)
x: 0
y: 1
z: 2

julia> foo(0, z=1, y=2)
x: 0
y: 2
z: 1

Pythonの変数スコープと違いはある?

簡潔に列挙していくと

  • 関数定義がスコープをつくるのは同じ
  • 現在のスコープでで変数が定義されてないときに外側に探しに行き、最終的にグローバルスコープに行くのも同じ
  • ifがスコープを作らないのも同じ
  • でも、Juliaのforwhileといったループがスコープをつくるのが違う
  • Juliaではtryもスコープをつくる
  • 内包表記で使われる変数はPython2と違ってその内包表記内のみのスコープになる(これはPython3と同じ)

forを例に具体的動作の違いを見てみよう。

まずはPythonの動作の確認から。

In [1]: for i in xrange(10):
   ...:     x = i
   ...:

In [2]: x
Out[2]: 9

このようにfor文内で定義したxにはfor文を抜けた後もアクセスできるね。

これをJulia側で見てみると、

julia> for i in 0:9
           x = i
       end

julia> x
ERROR: x not defined

というように、変数xにはアクセスできなくなっているよ。


じゃぁJuliaで変数の値をループ内で設定したいときはどうするのさ

localを使おう!

次のようにlocal xと書くことでPythonと同様の動作を実現できるよ。

julia> function foo()
           local x
           for i in 0:9
               x = i
           end
           x
       end
foo (generic function with 1 method)

julia> foo()
9

クラスを定義したいんだけど?

新しいデータ型を定義するには、type...endimmutable...endの2つの定義の仕方があるよ。

例えば、

type Point
    x::Float64
    y::Float64
end

immutable IPoint
    x::Float64
    y::Float64
end

のように同じように定義できて、immutableの方はメンバーの変更ができないよ。


コンストラクタ(__init__)はどうやって定義するの?

デフォルトのコンストラクタがあるから自分で定義しなくてもオブジェクトは作れるよ。

p1 = Point(1.2, 3.4)
print(p1)

もちろん自分でも定義できるよ! 型名と同名の関数を以下のように定義して、内部でnewを呼べばOKだよ。

type Point
    x::Float64
    y::Float64

    function Point(x, y)
        if x >= y
            error("x should be less than y")
        end
        new(x, y)
    end
end

isinstance関数に当たるのは?

isaがあるよ。

julia> isa(1, Int)
true

julia> isa(1, Integer)
true

julia> isa(1, Float64)
false

julia> isa("string", ASCIIString)
true

julia> isa("string", String)  # v0.4からはAbstractString
true

クラスの継承は?

できないよ。


ほんとに?

う〜ん。近しいものとしてnominal subtypingといって抽象型(abstract type)の下に具体型(concrete type)を定義して型の階層関係を定義できるよ。 注意しなければいけないのは具体型のsubtypeとして具体型を定義することはできない点だよ。

例えばこんな感じ:

abstract Person

type Employer <: Person
    name::UTF8String
    age::Int
end

type Employee <: Person
    name::UTF8String
    age::Int
    salary::Int
end

ちなみに<:はある型が別の型のサブタイプかどうかを調べる演算子としても使えるよ。 次の例ではInt, Int8, Float64が具体型でIntegerFloatingPointが抽象型だよ。

julia> Int <: Integer
true

julia> Int8 <: Integer
true

julia> Float64 <: FloatingPoint
true

julia> Int <: FloatingPoint
false

それって将来変わるの?

構造を継承するような変更は入らないと思うよ。

マニュアルから引用すると:

While this might at first seem unduly restrictive, it has many beneficial consequences with surprisingly few drawbacks. It turns out that being able to inherit behavior is much more important than being able to inherit structure, and inheriting both causes significant difficulties in traditional object-oriented languages.

Types

さらにStefan Karpinski氏の言葉を引用すると:

There are never going to be classes in Julia in the C++/Java style. This is by design. Inheriting structure — i.e. tacking fields onto a composite object type — is rarely of much use and has huge downsides. There are two types of sharing that inheritance is suposed to be useful for: sharing structure and sharing behavior. If you want to share structure, delegation is a much better design than tacking extra fields onto a existing composite type. If you want to share behavior, then a better design is to write generic code to an abstract type (a.k.a. a trait in OO lingo) of which the concrete types are specific implementations. To those ends, we probably need some features to improve delegation support, as well as support for multiple inheritance from abstract types. Class-based OO, however, is definitely never going to happen.

https://groups.google.com/forum/#!msg/julia-dev/p9bV6rMSmvY/cExeSb-cMBYJ

つまり、型のメンバ(フィールド)を共有させるような機能よりは振る舞いを共有させるほうが重要だし、移譲を使えば別にフィールドを共有させる必要はないよねということだよ。

さっきの例なら:

type Person
    name::UTF8String
    age::Int
end

type Employer
    person::Person
end

type Employee
    person::Person
    salary::Int
end

としてもいいよね。


文字列の長さを取得したいんだけど、lenみたいなのはあるの?

length関数があるよ。

> length("foobar")
6

> length("日本語")
3

自分で定義した型にlenを使いたいんだけど、__len__みたいなメソッドはあるの?

自分で定義した型にlengthメソッドを定義してやるだけだよ。 やり方は簡単で、自分の定義した型Fooに対してはlength(foo::Foo)というメソッドを以下のように定義できるよ。

例えばA,C,G,Tの四文字だけを持つ文字列DNAStringを圧縮して効率的に保持することを考えると、以下のように定義できるよ。

type DNAString
    n::Int
    pack::Vector{Uint8}
    
    function DNAString(s::ASCIIString)
        ...
    end
end

function length(s::DNAString)
    s.n
end

え、それはlength以外でもできるの?

そう!それがJuliaの多重ディスパッチング(multiple dispatch)だよ!


「多重」ってのはどういうこと?

複数の引数があっても、その型の組み合わせで実際に呼び出されるメソッドが決まるということだよ。


それはどんなところで役に立つの?

例えばPythonmodel.predict(data)のように与えられたモデルでデータの予測をしようとしたときを考えてみよう。

ここで引数として与えられるdataの型はlistかもしれないし、NumPyのndarrayかもしれないとする。

Pythonだと

class SomeModel:
    ...
    def predict(self, data):
        if isinstance(data, list):
            self.predict_list(list)
        elif instance(data, np.ndarray):
            self.predict_array(data)

のようにSomeModel.predictメソッド内で自分で分岐をするコードを書くことになっちゃうけど、Juliaだと

predict(model::SomeModel, data::List)
    ...
end

predict(model::SomeModel, data::Array)
    ...
end

というようにメソッドの定義自体を分離して書けるんだ!


__getitem__メソッドは?

getindexがあるよ。


他の特殊メソッドの対応関係は?

こんな感じかな?

Python Julia 備考
__getitem__ getindex
__setitem__ setindex!
__delitem__ delete!
__lt__ isless / < islessは全順序、<は半順序
__eq__ ==/isequal 浮動小数点数ではisequalと振る舞いが異なる
__contains__ in
__hash__ hash
__call__ call v0.4から
__str__ show
__len__ length

空のコンテナにFalseを返すような__nonzero__(__bool__)を定義したいんだけど?

Juliaは割りと暗黙の意味みたいなのを嫌うのでそういうのはないよ。 bool関数はあるけど数値のみに定義されていてPythonみたいに文字列などには定義されてないよ。


じゃぁどうするの?

isemptyとか明示的な関数を使おう!

JuliaでBool値を返す関数はis___という名前を持っていて、 ほかにもisnan, isspace, isalpha, islower, isupperなどたくさんあるよ!


イテレータを定義したいな

Juliaのイテレータstart, done, nextの3つの関数からなるので、これを自分の定義した型にも定義してあげるといいよ。

  • start(iter) → stateで開始状態を設定し
  • done(iter,state) → Boolで状態を受けてイテレーションが終了したか否かを返し
  • next(iter,state) → item,stateで要素と次の状態を返すんだ。

イテレータIに対するfor文

for i in I
    # body
end

は以下のものと等価になるんだ。

state = start(I)
while !done(I, state)
    (i, state) = next(I, state)
    # body
end

試しにTODOリストの未完了のタスクに対するイテレータを定義してみたよ。

type ToDoList{T<:String}
    tasks::Vector{T}
    finished::BitVector

    function ToDoList(tasks::Vector{T})
        finished = BitVector(length(tasks))
        finished[1:end] = false
        new(tasks, finished)
    end
end

Base.start(list::ToDoList) = 1
Base.done(list::ToDoList, state) = findnext(!list.finished, state) == 0
function Base.next(list::ToDoList, state)
    n = findnext(!list.finished, state)
    list.tasks[n], n + 1
end

ちょっと待って、今のtype ToDoList{T<:String}って一体なに!?

型パラメータTに制約をつけてるんだよ。 ここではTStringという抽象型(v0.4ではAbstractString)のサブクラスであることを強制してるんだよ。

インスタンス化するときは、

julia> ToDoList{ASCIIString}(["foo"])
ToDoList{ASCIIString}(ASCIIString["foo"],Bool[false])

というように呼び出すんだよ。


@show xとか@assert sum(x) == 10みたいなのは何? デコレータ?

@で始まるのはデコレータじゃなくてJuliaのマクロ呼出しだよ。これは実行前にJuliaのプログラムを書き換えることができるんだ。 デコレータは「関数を取って関数を返す関数」と考えられるけど、マクロは「式(expression)を取って式を返す関数」と考えられるよ。


モジュールってあるの?

Juliaもモジュール機能があるよ。 Pythonと違うのはPythonではファイルが自動的にモジュールになるのに対し、Juliaではmodule ... endで挟んだところがモジュールになるよ。

例えば、

module Foo1
function foo()
    println("Foo1.foo")
end
end

module Foo2
function foo()
    println("Foo2.foo")
end
end

という風にFoo1Foo2の2つのモジュールを定義してfoos.jlファイルに保存して、

julia> include("foos.jl")

julia> Foo1.foo()
Foo1.foo

julia> Foo2.foo()
Foo2.foo

というようにしてそれぞれのfoo関数を使えるよ。 ちなみにPythonと同じようにimportがJuliaにもあるけど、暗黙的に名前を導入するusingの方がよく使われるよ。


そうそう例外は?

一番手軽なのはerrorという関数があるよ。

julia> error("!!!")
ERROR: !!!
 in error at error.jl:21

例外の種類としては、PythonValueError(不正な引数)に当たるDomainErrorIndexError(存在しないキーへのアクセス)に当たるBoundsErrorなど色いろあるよ。

特定の例外を投げるにはthrow関数(errorでもOK)を使ってね。

julia> throw(DomainError())
ERROR: DomainError

julia> error(DomainError())
ERROR: DomainError
 in error at error.jl:19

もちろん例外を捕まえるためにtry ... catch ... finally ... endというのもあるよ。

julia> try
           error("panic!")
       catch err
           println("something bad happened")
           println(err)
       finally
           println("and finally do something")
       end
something bad happened
ErrorException("panic!")
and finally do something

文字列 / 正規表現


文字列の型は?

ASCIIStringUTF8Stringの2つがあるよ。

Python2系のstrにあたるのがASCIIStringunicodeにあたるのがUTF8Stringだよ。 両方をまとめるString(v0.4ではAbstractString)というより上位の型もあるよ。


文字列は不変?

基本的にそうだよ。でも以下のように文字列だってJuliaで定義されていて、内部にさわろうと思えば触れちゃうけどいじっちゃダメだよ!

immutable ASCIIString <: DirectIndexString
    data::Array{UInt8,1}
end

immutable UTF8String <: AbstractString
    data::Array{UInt8,1}
end

base/boot.jl


文字列の結合は?

*をつかうよ。

julia> "foo" * "bar"
"foobar"

文字列の配列を結合するにはjoinを使うよ。

julia> join(["foo", "bar", "baz"], ',')
"foo,bar,baz"

他にも色々比較や検索の関数があるよ!


.formatみたいな文字列のフォーマットは?

2つの方法があるよ。

  1. 変数の埋め込み
  2. @sprintfマクロ
  3. Formatting.jlPythonの記法を使う。

変数の埋め込みはPythonで言うところの"... {} ...".format(x)に対応していて、文字幅などは指定せず単純に 変数を文字列に埋め込めるよ。 @sprintfマクロはC言語のようなフォーマットの指定が可能だよ。 さらに、Formatting.jlのformatPythonの記法が使えるよ。

julia> n = 150;

julia> "n is $n"
"n is 150"

julia> @sprintf "n is %05d" n
"n is 00150"

julia> format("n is {}", n)
"n is 150"

julia> format("n is {:05d}", n)
"n is 00150"

複数行の文字列はどう書くの?

Pythonみたいに""" ... """が使えるよ!

julia> x = """
foo
bar
"""

julia> print(x)
foo
bar

Pythonと違うのはJuliaの""" ... """では最初の改行文字が取り除かれるのに対し、Pythonでは除かれない点だよ。

つまり、

Julia:

"""
foo
bar
"""

と、

Python:

"""foo
bar
"""

が同じ意味だよ。


正規表現はどう書くの?

例えば"090-1234-5678"みたいなのにマッチさせる正規表現ならr"\d{3}-\d{4}-\d{4}"と書けるよ。 ちなみに使える正規表現Perl Compatible Regular Expression (PCRE)だよ。


正規表現の文字列の前のrは何? raw文字列?

実はこれもマクロだよ。 他にもv"1.2.3"みたいなバージョン文字列のマクロやb"DATA\xff\u2200"みたいなバイナリ列のマクロもあるよ。


マッチングはどうやるの?

ismatchを使ってね:

julia> ismatch(r"\d{3}", "123")
true

julia> ismatch(r"\d{3}", "12")
false

マッチした部分の抽出は?

()によるグルーピングが使えるよ。

m = match(r"(\d{3})-(\d{4})-(\d{4})", "090-1234-5678")
m.captures[1]
m.captures[2]
m.captures[3]

ファイル / IO

標準出力(sys.stdout)と標準エラー(sys.stderr)は?

STDOUTSTDERRという変数が予め定義されているよ。 print(io, string)で改行なし、println(io, string)で改行付きで出力だよ。


標準入力から一行づつ読み込みたいんだけど?

readlineを使おう!

n = 1
for line in eachline(STDIN)
    print("$n: $line")
    n += 1
end

テキストファイルを一行づつ読み込みたいんだけど?

次のイディオムが使えるよ:

open("some.txt") do f
    for line in eachline(f)
        # do something
    end
end

改行文字を取り除くには?

chomp関数を使おう!

julia> chomp("foobar\n")
"foobar"

書き込みは?

こんな感じだよ:

open("some.txt", "w") do f
    println(f, "the first line")
    println(f, "and more")
end

socketみたいなのは?

TCPソケットを通じてのデータのやり取りはlisten, accept, connectがあるよ。


システム

os.systemみたいに外部コマンドを実行したいんだけど。

バッククォート(\``)でコマンドを囲むとCmdオブジェクトができて、それをrun`関数で実行できるよ。

julia> `ls -la`
`ls -la`

julia> run(`ls -la`)
total 1144
drwxr-xr-x+ 19 kenta  staff     646 12 21 22:30 .
drwxr-xr-x+ 30 kenta  staff    1020 12  9 15:33 ..
-rw-r-----@  1 kenta  staff  281892 12  5 01:02 6167c823c760479357b781d04c03b4a4.gif
-rw-r--r--+  1 kenta  staff     412 12 21 22:03 bug.jl
-rw-r--r--@  1 kenta  staff  176316  9 27 02:30 build_tree.png
...

subprocess.callみたいにコマンドの出力を受け取りたいなぁ。

ファイルを開くのと同じopen関数が実は使えるんだよ(ココ多重ディスパッチのいいところ!)。 コマンドの出力を一行づつ処理すのに便利だよ。

open(`command args`) do p
    for line in eachline(p)
        # do something
    end
end

ファイルを開く時とそっくりだね!(再掲)

open("some.txt") do f
    for line in eachline(f)
        # do something
    end
end

現在のディレクトリの取得は?

pwd関数を使おう!

ディレクトリの移動は?

cd関数を使おう!

次のようにdo ... endを使って一時的にディレクトリの移動も出来るよ!

julia> println(pwd())
/Users/kenta/snippets/JuliaAdvent

julia> cd("/tmp") do
           println(pwd())
       end
/private/tmp

julia> println(pwd())
/Users/kenta/snippets/JuliaAdvent

プロファイリング / ベンチマーク / テスト

timeitみたいに手軽に関数の実行時間を知りたいんだけど

@timeマクロは与えられた式を実行して、実行時間と割り当てられたメモリの量を教えてくれるよ。

julia> @time sum([1:1000000])
elapsed time: 0.005030125 seconds (8000168 bytes allocated)
500000500000

コードの何処に時間がかかってるか知りたいんだけど?

@profileマクロを使おう。

たとえばこんな関数とすると:

function func(n)
    m = 2^n
    s = BigInt(0)
    for i in 1:m
        s += sum(1:i)
    end
    s
end

結果を見るには以下のようにするよ:

julia> Profile.clear()

julia> @profile func(20)
192154133857304576

julia> Profile.print()
1   ./base.jl; finalizer; line: 147
1   ./bool.jl; !; line: 17
1   gmp.jl; +; line: 267
476 task.jl; anonymous; line: 96
 476 REPL.jl; eval_user_input; line: 54
  476 profile.jl; anonymous; line: 14
   476 none; func; line: 5
    389 gmp.jl; +; line: 267
     300 ...lib/julia/sys.dylib; finalizer; (unknown line)
      2   ./base.jl; finalizer; line: 0
      91  ./base.jl; finalizer; line: 144
      205 ./base.jl; finalizer; line: 147
    72  gmp.jl; +; line: 268
    4   gmp.jl; +; line: 269
    3   range.jl; sum; line: 542

Juliaのプロファイラは実行途中にスタックのスナップショットを取って、何処に時間がかかってるかを割り出せるようになってるよ。左の数字が大きいところがコストのかかっている処理だよ。 gmp.jlのfinalizerでたくさんの時間がかかってる事がわかるね!


なんか数値計算で思ったよりパフォーマンスが上がらないんだけど...

数値計算などでC言語などに大きく水をあけられるケースの原因はいろいろ考えられるけど、よくあるのが変数の型が安定してないケースだよ。

次の配列xsの数値の総和を計算するケースを考えてみよう。

function mysum(xs)
    s = 0
    for x in xs
        s += x
    end
    s
end

一見問題なさそうに思えるけど、実はxsの要素の型によってパフォーマンスがかなり変わってしまう問題があるコードだ。 数字の1を10,000,000個持った配列の和を求める下のベンチマークを見ると要素がIntの時に比べてFloat64のときにおよそ40倍も時間がかかっていることが分かるね。

mysum, Int
elapsed time: 0.010568369 seconds (16 bytes allocated)
mysum, Float64
elapsed time: 0.425763243 seconds (320000000 bytes allocated)

これの原因は変数sにあって、与えられた配列xsの要素がInt型の時はsの型は常にIntだけども、xsの要素がFloat64の時には 最初はsの型が= 0Intに設定されるのに後でs += xとしたときにInt + Float64 → Float64に変わってしまうのが問題なんだ。

これをチェックすのにはcode_typed(f,types)関数(もしくはマクロ版の@code_typedマクロ)を使ってみよう。

例えばxsVector{Int}のとき、s::Int64で型付けされているけど、

julia> code_typed(mysum, (Vector{Int},))
1-element Array{Any,1}:
 :($(Expr(:lambda, {:xs}, {{:s,symbol("#s119"),symbol("#s118"),:x,:_var1,:_var2,:_var0,:_var3},{{:xs,Array{Int64,1},0},{:s,Int64,2},{symbol("#s119"),Int64,2},{symbol("#s118"),(Int64,Int64),18},{:x,Int64,18},{:_var1,Int64,18},{:_var2,Int64,18},{:_var0,Int64,18},{:_var3,Int64,18}},{}}, :(begin  # none, line 2:
        s = 0 # line 3:
        #s119 = 1
        _var1 = (top(arraylen))(xs::Array{Int64,1})::Int64
        unless (top(box))(Bool,(top(not_int))((top(slt_int))(_var1::Int64,#s119::Int64)::Bool))::Bool goto 1
        2:
        _var0 = (top(arrayref))(xs::Array{Int64,1},#s119::Int64)::Int64
        _var3 = (top(box))(Int64,(top(add_int))(#s119::Int64,1))::Int64
        x = _var0::Int64
        #s119 = _var3::Int64 # line 4:
        s = (top(box))(Int64,(top(add_int))(s::Int64,x::Int64))::Int64
        3:
        _var2 = (top(arraylen))(xs::Array{Int64,1})::Int64
        unless (top(box))(Bool,(top(not_int))((top(box))(Bool,(top(not_int))((top(slt_int))(_var2::Int64,#s119::Int64)::Bool))::Bool))::Bool goto 2
        1:
        0:  # line 6:
        return s::Int64
    end::Int64))))

xsVector{Float64}のとき、s::Union(Int64,Float64)で型付けされていて型が安定していないことが分かるね。

julia> code_typed(mysum, (Vector{Float64},))
1-element Array{Any,1}:
 :($(Expr(:lambda, {:xs}, {{:s,symbol("#s119"),symbol("#s118"),:x,:_var1,:_var2,:_var0,:_var3},{{:xs,Array{Float64,1},0},{:s,Any,2},{symbol("#s119"),Int64,2},{symbol("#s118"),(Float64,Int64),18},{:x,Float64,18},{:_var1,Int64,18},{:_var2,Int64,18},{:_var0,Float64,18},{:_var3,Int64,18}},{}}, :(begin  # none, line 2:
        s = 0 # line 3:
        #s119 = 1
        _var1 = (top(arraylen))(xs::Array{Float64,1})::Int64
        unless (top(box))(Bool,(top(not_int))((top(slt_int))(_var1::Int64,#s119::Int64)::Bool))::Bool goto 1
        2:
        _var0 = (top(arrayref))(xs::Array{Float64,1},#s119::Int64)::Float64
        _var3 = (top(box))(Int64,(top(add_int))(#s119::Int64,1))::Int64
        x = _var0::Float64
        #s119 = _var3::Int64 # line 4:
        s = s::Union(Int64,Float64) + x::Float64::Float64
        3:
        _var2 = (top(arraylen))(xs::Array{Float64,1})::Int64
        unless (top(box))(Bool,(top(not_int))((top(box))(Bool,(top(not_int))((top(slt_int))(_var2::Int64,#s119::Int64)::Bool))::Bool))::Bool goto 2
        1:
        0:  # line 6:
        return s::Union(Int64,Float64)
    end::Union(Int64,Float64)))))

これを防ぐにはsの型をxsの要素から直接得ればいいんだ。

function mysum_ok(xs)
    s = zero(eltype(xs))
    for x in xs
        s += x
    end
    s
end

code_typedで確認してみると、Float64のときはs::Float64で安定的に型付けされているのが分かるね。

julia> code_typed(mysum_ok, (Vector{Float64},))
1-element Array{Any,1}:
 :($(Expr(:lambda, {:xs}, {{:s,symbol("#s119"),symbol("#s118"),:x,:_var1,:_var2,:_var0,:_var3},{{:xs,Array{Float64,1},0},{:s,Float64,2},{symbol("#s119"),Int64,2},{symbol("#s118"),(Float64,Int64),18},{:x,Float64,18},{:_var1,Int64,18},{:_var2,Int64,18},{:_var0,Float64,18},{:_var3,Int64,18}},{}}, :(begin  # none, line 2:
        s = (top(box))(Float64,(top(sitofp))(Float64,0))::Float64 # line 3:
        #s119 = 1
        _var1 = (top(arraylen))(xs::Array{Float64,1})::Int64
        unless (top(box))(Bool,(top(not_int))((top(slt_int))(_var1::Int64,#s119::Int64)::Bool))::Bool goto 1
        2:
        _var0 = (top(arrayref))(xs::Array{Float64,1},#s119::Int64)::Float64
        _var3 = (top(box))(Int64,(top(add_int))(#s119::Int64,1))::Int64
        x = _var0::Float64
        #s119 = _var3::Int64 # line 4:
        s = (top(box))(Float64,(top(add_float))(s::Float64,x::Float64))::Float64
        3:
        _var2 = (top(arraylen))(xs::Array{Float64,1})::Int64
        unless (top(box))(Bool,(top(not_int))((top(box))(Bool,(top(not_int))((top(slt_int))(_var2::Int64,#s119::Int64)::Bool))::Bool))::Bool goto 2
        1:
        0:  # line 6:
        return s::Float64
    end::Float64))))

これでFloat64の時のパフォーマンスはぐっと良くなるよ。

mysum_ok, Int
elapsed time: 0.00833662 seconds (16 bytes allocated)
mysum_ok, Float64
elapsed time: 0.01434145 seconds (16 bytes allocated)

もちろん本当は色々工夫されている標準のsumを使ったほうがいいよ。

ベンチマークのコード全体は以下のとおりだよ。

function mysum(xs)
    s = 0
    for x in xs
        s += x
    end
    s
end

function mysum_ok(xs)
    s = zero(eltype(xs))
    for x in xs
        s += x
    end
    s
end

function bench(func::Function, eltype::DataType)
    # pre-compile
    func([one(eltype)])
    xs = ones(eltype, 10_000_000)
    gc_disable()
    @time func(xs)
    gc_enable()
    gc()
end

let
    println("mysum, Int")
    bench(mysum, Int)
    println("mysum, Float64")
    bench(mysum, Float64)

    println("mysum_ok, Int")
    bench(mysum_ok, Int)
    println("mysum_ok, Float64")
    bench(mysum_ok, Float64)

    println("Base.sum, Int")
    bench(Base.sum, Int)
    println("Base.sum, Float64")
    bench(Base.sum, Float64)
end

結果はこんなかんじ。

mysum, Int
elapsed time: 0.010568369 seconds (16 bytes allocated)
mysum, Float64
elapsed time: 0.425763243 seconds (320000000 bytes allocated)
mysum_ok, Int
elapsed time: 0.00833662 seconds (16 bytes allocated)
mysum_ok, Float64
elapsed time: 0.01434145 seconds (16 bytes allocated)
Base.sum, Int
elapsed time: 0.006605981 seconds (16 bytes allocated)
Base.sum, Float64
elapsed time: 0.006086415 seconds (16 bytes allocated)

そうそう単体テストは?

標準ライブラリにあるBase.Testを使うよ。 @testマクロがtrueになるような式を渡してね。

julia> using Base.Test

julia> @test 1 == 1

julia> @test 1 == 2
ERROR: test failed: 1 == 2
 in error at error.jl:21
 in default_handler at test.jl:19
 in do_test at test.jl:39

他に例外を投げることを確認する@test_throwsと、浮動小数点数がほぼ同じ値であることを確認する@test_approx_eqもあるよ。


ライブラリ


requestsみたいなのは?

Requests.jlが近いかな!


YAMLJSONXMLは?


pandasみたいなデータフレームは?

DataFrames.jlがあるよ!


プロットしたいんだけど?

一番使われてるのはGadfly.jlかな。 チョット動作が遅いけど簡単によくあるプロットができるよ。

Pythonistaの人にはMatplotlibをJuliaでラップしたPyPlot.jlがあるよ。

他にWinson.jlPlotlyもあるよ。


IPython Notebookは?

IJulia.jlがあるよ!

最近はJupyterも注目だね! もちろんJupyterのJuはJuliaのJuだよ!


コマンドライン引数のパースするには?

オススメはPythonのdocoptから移植されたDocOpt.jlだよ!。 詳しくはPythonのコマンドライン引数処理の決定版 docopt (あとJuliaに移植したよ)を見てね。 他にもArgParse.jlというのもあるよ。


Flake8みたいな静的なコードのチェッカーが欲しいんだけどなぁ

JuliaにはPEP8に相当するものは今のところないからスタイルに関してはかなり自由だけど、 List.jlでよくある間違いを事前に発見できるよ。


統計とか機械学習とかのライブラリが知りたい!

思いつく限り!

他にもJuliaStatsに色いろあるよ!


もっと資料や読み物を教えて!

言語をよく知りたいならJuliaの公式マニュアルを読もう!質も量も素晴らしいマニュアルだよ!

他にも、Worth Readingな記事を挙げていくよ!