“全新” 编程语言 Julia开箱体验

编程语言 Julia更新了1.0正式版,上手体验了一下,集Python、C、R、Ruby之所长,效率大增,说不定未来就火了!

Julia Lang


本文共 851字,阅读大约需要 3分钟 !


概 述

Julia 是一个 “全新”的高性能动态编程语言,前两天迎来了其 1.0 正式版的重大更新。Julia集 Python、C、R、Ruby 之所长,感觉就像一种脚本语言,并且对交互式使用有很好的支持。而且其天生的高性能、通用性与专业性使得其非常适用于科学数值计算、机器学习项目等前沿场景。我看完这个消息以后也迫不及待想尝试一下。

注: 本文原载于 My Personal Blog:CodeSheep · 程序羊

本文内容脑图如下:

本文内容脑图


Julia的特性

  • 高性能:Julia 通过 LLVM 为多个平台编译高效本地代码,性能很高
  • 动态性:编程范式灵活,代码信噪比极高
  • 通用性:易于表达OOP和函数式编程范式,并且其标准库提供异步I / O,进程控制,日志记录,概要分析,包管理器等。
  • 专业性:擅长数值计算,支持许多数值数据类型,并且提供开箱即用的并行性。
  • 可组合性:Julia 的包之间可以很好地协同工作。

正是由于这些特性,才使其应用场景宽泛,而且都是当下前沿热门应用场景:

Julia 应用场景


编程环境支持

Julia通过提供了一系列插件支持,从而可以在大多数常见的编辑器中进行编程,具体包括

  • Atom
  • VS Code
  • Jupyter
  • Vim
  • Emacs
  • SublimeText

Julia安装和部署

Julia 提供了各种平台和环境的安装包,具体可以去其官网进行下载:

安装平台

安装非常简单,像 Windows平台,基本上只需要点按下一步即可安装到位,而 MacOS平台使用 brew包管理器也仅需 一行命令 即可完成安装。

下面我以 Linux CentOS 7.4 平台为例,介绍一些其安装过程:

CentOS7 上 Julia 安装也无需复杂的过程,只需要下载对应的可执行版本,并置于系统的命令路径中即可愉快的使用:

1
2
3
4
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控制台,顺便来向世界问一下好吧:

Hello Julia !

下面做一些上手实验,大致来感受一下该语言精炼、灵活的风格。即使不使用任何文字说明,也能很容易地理解各个命令的含义,这也说明该语言很好上手。


Julia上手体验

  • 变量操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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("#")
  • 类型转换和提升
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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)
  • 函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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
  • 控制流
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
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
  • 对象构造

外部构造方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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)

内部构造方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
  • 迭代与索引

迭代操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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

索引操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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,获取更多 务实、能看懂、可复现的 原创文 ↓↓↓

CodeSheep · 程序羊



最后附上个人联系方式,欢迎大家交流学习:
个人博客:www.codesheep.cn
个人网站:http://113.209.119.170/ (捂脸的表情,很慢,1G1C1M,你懂的)
简 书:https://www.jianshu.com/u/d19536b0189b



支付宝打赏 微信打赏

如果文章对您有帮助,您可以鼓励一下作者

评论