「全新」程式語言 Julia開箱體驗

本文共 1540字，閱讀大約需要 5分鐘，文末有計時器可自行對時

Julia 是一個 「全新」的高性能動態程式語言，前兩天迎來了其 1.0 正式版的重大更新。Julia集 Python、C、R、Ruby 之所長，感覺就像一種腳本語言，並且對交互式使用有很好的支持。而且其天生的高性能、通用性與專業性使得其非常適用於科學數值計算、機器學習項目等前沿場景。我看完這個消息以後也迫不及待想嘗試一下。

註： 本文首發於 My 公眾號 CodeSheep ，可 長按 或 掃描 下面的 小心心 來訂閱 ↓ ↓ ↓

本文內容腦圖如下：

高性能：Julia 通過 LLVM 為多個平臺編譯高效本地代碼，性能很高

動態性：編程範式靈活，代碼信噪比極高

通用性：易於表達OOP和函數式編程範式，並且其標準庫提供異步I / O，進程控制，日誌記錄，概要分析，包管理器等。

專業性：擅長數值計算，支持許多數值數據類型，並且提供開箱即用的並行性。

可組合性：Julia 的包之間可以很好地協同工作。

正是由於這些特性，才使其應用場景寬泛，而且都是當下前沿熱門應用場景：

Julia通過提供了一系列插件支持，從而可以在大多數常見的編輯器中進行編程，具體包括

Atom

VS Code

Jupyter

Vim

Emacs

SublimeText

Julia 提供了各種平臺和環境的安裝包，具體可以去其官網進行下載：

安裝非常簡單，像 Windows平臺，基本上只需要點按下一步即可安裝到位，而 MacOS平臺使用 brew包管理器也僅需 一行命令 即可完成安裝。

下面我以 Linux CentOS 7.4 平臺為例，介紹一些其安裝過程：

CentOS7 上 Julia 安裝也無需複雜的過程，只需要下載對應的可執行版本，並置於系統的命令路徑中即可愉快的使用：

wget https://julialang-s3.julialang.org/bin/linux/x64/1.0/julia-1.0.0-linux-x86_64.tar.gz

tar zxvf julia-1.0.0-linux-x86_64.tar.gz

cd /usr/bin

ln -s /root/julia-1.0.0/bin/julia

此時執行 julia 命令即可啟動 Julia控制臺，順便來向世界問一下好吧：

下面做一些上手實驗，大致來感受一下該語言精煉、靈活的風格。即使不使用任何文字說明，也能很容易地理解各個命令的含義，這也說明該語言很好上手。

julia> x=10

10

julia> x+1

11

julia> x^2

100

julia> pi

π = 3.1415926535897...

julia> sqrt(100)

10.0

julia> ~123

-124

julia> 123 & 234

106

julia> ~UInt32(123)

0xffffff84

julia> [1,2,3] .^ 3

3-element Array{Int64,1}:

 1

 8

27

julia> 1 == 1

true

julia> NaN == NaN

false

julia> NaN != NaN

true

julia>

julia> 'x'

'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)

julia> Int('x')

120

julia> str = "Hello, world.\n"

"Hello, world.\n"

julia> str[1]

'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase)

julia> str[end]

'\n': ASCII/Unicode U+000a (category Cc: Other, control)

julia> str[4:9]

"lo, wo"

julia> greet = "Hello"

"Hello"

julia> whom = "world"

"world"

julia> "$greet, $whom.\n"

"Hello, world.\n"

julia> findfirst(isequal('x'), "xylophone")

1

julia> findnext(isequal('o'), "xylophone", 1)

4

julia> findnext(isequal('o'), "xylophone", 5)

7

julia> findnext(isequal('o'), "xylophone", 8)

julia> occursin("world", "Hello, world.")

true

julia> repeat(".:Z:.", 10)

".:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:."

julia> occursin(r"^\s*(?:#|$)", "not a comment")

false

julia> occursin(r"^\s*(?:#|$)", "# a comment")

true

julia> match(r"^\s*(?:#|$)", "# a comment")

RegexMatch("#")

julia> x = 12

12

julia> typeof(x)

Int64

julia> convert(UInt8, x)

0x0c

julia> convert(AbstractFloat, x)

12.0

julia> a = Any[1 2 3; 4 5 6]

2×3 Array{Any,2}:

1  2  3

4  5  6

julia> convert(Array{Float64}, a)

2×3 Array{Float64,2}:

1.0  2.0  3.0

4.0  5.0  6.0

julia> promote(1, 2.5)

(1.0, 2.5)

julia> promote(2, 3//4)

(2//1, 3//4)

julia> promote(1.5, im)

(1.5 + 0.0im, 0.0 + 1.0im)

julia> promote(1 + 2im, 3//4)

(1//1 + 2//1*im, 3//4 + 0//1*im)

julia> f(x,y) = x + y

f (generic function with 1 method)

julia> f(2,3)

5

julia> g = f

f (generic function with 1 method)

julia> g(2,3)

5

julia> ∑(x,y) = x + y

∑ (generic function with 1 method)

julia> ∑(2, 3)

5

julia> +(1,2,3)

6

julia> x -> x^2 + 2x - 1

#3 (generic function with 1 method)

julia> map(x -> x^2 + 2x - 1, [1,3,-1])

3-element Array{Int64,1}:

 2

14

-2

julia> function foo(a,b)

               a+b, a*b

         end;

julia> foo(2,3)

(5, 6)

julia> x, y = foo(2,3);

julia> x

5

julia> y

6

julia> z = begin

        x = 1

        y = 2

        x + y

      end

3

julia> function test(x, y)

        if x < y

          println("x is less than y")

        elseif x > y

          println("x is greater than y")

        else

          println("x is equal to y")

        end

      end

test (generic function with 1 method)

julia> test(1, 2)

x is less than y

julia> test(2, 1)

x is greater than y

julia> test(1, 1)

x is equal to y

julia> println(x < y ? "less than" : "not less than")

less than

julia> while i <= 5

        println(i)

        i += 1

      end

1

2

3

4

5

julia> for i = 1:5

        println(i)

      end

1

2

3

4

5

外部構造方式：

julia> struct Foo

          bar

          baz

      end

julia>

julia> fun=Foo(1,2)

Foo(1, 2)

julia> fun.bar

1

julia> fun.baz

2

julia> Foo(x) = Foo(x,x)

Foo

julia> Foo(1)

Foo(1, 1)

julia> Foo() = Foo(0)

Foo

julia> Foo()

Foo(0, 0)

內部構造方式：

julia> struct OrderedPair

          x::Real

          y::Real

          OrderedPair(x,y) = x > y ? error("out of order") : new(x,y)

      end

julia>

julia> OrderedPair(1, 2)

OrderedPair(1, 2)

julia> OrderedPair(2,1)

ERROR: out of order

Stacktrace:

[1] error(::String) at ./error.jl:33

[2] OrderedPair(::Int64, ::Int64) at ./REPL[45]:4

[3] top-level scope at none:0

迭代操作：

julia>  struct Squares

              count::Int

      end

julia> Base.iterate(S::Squares, state=1) = state > S.count ? nothing : (state*state, state+1)

julia> for i in Squares(7)

                 println(i)

      end

1

4

9

16

25

36

49

julia> 25 in Squares(10)

true

julia> using Statistics

julia> mean(Squares(100))

3383.5

julia> std(Squares(100))

3024.355854282583

julia> Base.eltype(::Type{Squares}) = Int

julia> Base.length(S::Squares) = S.count

julia> collect(Squares(4))

4-element Array{Int64,1}:

 1

 4

 9

16

索引操作：

julia> function Base.getindex(S::Squares, i::Int)

              1 <= i <= S.count || throw(BoundsError(S, i))

              return i*i

      end

julia> Squares(100)[23]

529

julia> Base.firstindex(S::Squares) = 1

julia> Base.lastindex(S::Squares) = length(S)

julia> Squares(23)[end]

529

julia> Base.getindex(S::Squares, i::Number) = S[convert(Int, i)]

julia> Base.getindex(S::Squares, I) = [S[i] for i in I]

julia> Squares(10)[[3,4.,5]]

3-element Array{Int64,1}:

 9

16

25

基本的語言特性就體驗到這，剩餘的還有一些高級特性，包括：

不在此文一一贅述，詳細了解就去參考官方文檔吧。

由於能力有限，若有錯誤或者不當之處，還請大家批評指正，一起學習交流！

如果有興趣，也可以抽時間看看作者關於容器化、微服務化方面的文章：

作者更多 務實、能看懂、可復現的 原創文章盡在公眾號 CodeSheep，歡迎訂閱 ⬇️⬇️⬇️

你花了   ·  來閱讀

點個  再走吧~ 

↓去簡書讀原文↓             ↓幫點個讚唄↓