2.Julia REPL 变量

2020-06-30 12:24:13 浏览数 (1)

开始使用Julia

注意 Julia 1.0版本跟之前的版本有较大不同，在学习的需注意

在Julia的REPL下，有多种模式：

  • help模式，按?进入help模式
  • shell模式，按;进入shell模式
  • package模式，按]进入package模式
  • 按backspace键返回正常Julia模式

也可以在REPL中运行一些简单的运算，或者定义函数等

在help模式下，可以查看各种帮助文档，就相当于执行@doc命令；

在package模式下，可以增加、删除各种库，相当于用Pkg这个模块来操作； package模式下的add GR相当于Pkg.add("GR") package模式下的rm GR相当于Pkg.rm("GR")

其他关于package的操作

代码语言：javascript复制
Pkg.installed()  #查看已安装的库和它们的版本
Pkg.update()     #升级安装的库

我们在julia的目录下新建一个helloworld.jl的文件，里面内容为：

代码语言：javascript复制
println("Hello World!")

在Windows中，shell模式下，执行julia helloworld.jl，即可运行该文件。

变量

可以参考知乎的文章《Python/Matlab/Julia基本语法比较》

像其他的动态语言一样，可以无需声明直接赋值

代码语言：javascript复制
x = 10
x = "Hello world!"
x = 1.1
x = "这是Julia教程

变量名还可以是中文，当然不推荐这么做

代码语言：javascript复制
测试 = 10
测试 1

还可以输入 符号名称的方式来输入更多的Unicode数学字符，如alpha后按tab键就会出现α的字符。 命名规范 跟其他编程语言的命名规范基本相同，如：

  • 变量名尽量小写
  • 类型和模块名首字母大写，单词间使用驼峰式分隔
  • 在几个单词不易区分时才以_分隔，一般不鼓励使用_
  • 函数名和宏名使用小写字母，不使用下划线
  • 修改参数的函数结尾使用!，这样的函数被称为mutating functions或in-place functions

整型和浮点

整数类型

Type

Signed

Number of bits

Smallest value

Largest value

Int8

√

8

-2^7

2^7-1

UInt8

8

0

2^8-1

Int16

√

16

-2^15

2^15-1

UInt16

16

0

2^16-1

Int32

√

32

-2^31

2^31-1

UInt32

32

0

2^32-1

Int64

√

64

-2^63

2^63-1

UInt64

64

0

2^64-1

Int128

√

128

-2^128

2^127-1

UInt128

128

0

2^128-1

Bool

N/A

8

false(0)

true(1)

代码语言：javascript复制
a = typoef(2)
>>Int64
typeof(a)
>>DataType
typeof(DataType)
>>DataType
b = supertype(a)
>>Signed
supertype(Signed)
>>Integer
supertype(Integer)
>>Real
supertype(Real)
>>Number
supertype(Number)
>>Any
supertype(Any)
>>Any
subtypes(Integer)
>>3-element Array{Any,1}:
 Bool    
 Signed  
 Unsigned
 sizeof(1)
 >>8
 sizeof(Int16(1))
 >>2

浮点数

Type

Precision

Number of bits

Float16

half

16

Float32

single

32

Float64

double

64

在32位系统中，整数默认是Int32类型，浮点数默认是Float32类型； 在64位系统中，整数默认是Int64类型，浮点数默认是Float64类型。

代码语言：javascript复制
x = 1
typeof(x)
>>Int64
a = tpyeof(1.1)
>>Float64
typeof(a)
>>DataType
typeof(DataType)
>>DataType
sizeof(Float64)
>>8
sizeof(Int128)
>>16
sizeof(Bool)
>>1
sizeof(Signed)
>>argument is an abstract type; size is indeterminate

    Stacktrace:
     [1] sizeof(::Type) at .essentials.jl:405
     [2] top-level scope at In[15]:1

可以使用Sys.WORD_SIZE命令查看系统是32位还是64位， 也可以直接输入Int或UInt看系统位数

JUlia中的很多语法和REPL的用法都跟matlab很像，比如上一次的结果用ans表示

代码语言：javascript复制
julia> x = 1
1
julia> ans   1
2

十六进制

由于Julia的整数中定义了Int和UInt两种大类型，其中Int用十进制表示，UInt类型用十六进制表示，当然我们也可以以0b开头表示二进制，以0o开头表示八进制

代码语言：javascript复制
x = 10
UInt8(x)
>>0x0a
x = 0b1010
Int64(x)
>>10

二进制和十六进制也支持有符号数，直接在前面加-即可

代码语言：javascript复制
-0xa
>>0xf6
bitstring(2)
>>"0000000000000000000000000000000000000000000000000000000000000010"
bitstring(-2)
>>"1111111111111111111111111111111111111111111111111111111111111110"

查看某种进制类型的最大最小值：

代码语言：javascript复制
(typemin(Int32), typemax(Int32))
>>(-2147483648, 2147483647)
typemax(Int64) 1
>>-9223372036854775808

浮点数表示方法

代码语言：javascript复制
1e-3
>>0.001
typeof(ans)
>>Float64
1f-3
>>0.001f0
typeof(ans)
>>Float32

浮点的0.0和-0.0在表示方式中也是有点分别的

代码语言：javascript复制
0.0 = -0.0
>>true
bitstring(0.0)
>>"0000000000000000000000000000000000000000000000000000000000000000"
bitstring(-0.0)
>>"1000000000000000000000000000000000000000000000000000000000000000"

精度

代码语言：javascript复制
eps(Float32)
>>1.1920929f-7
eps(Float64)
>>2.220446049250313e-16

数值越大，精度也就越低,也就是说，浮点数在0附近最稠密，随着数值越来越大，数值越来越稀疏，数值间的距离呈指数增长。

代码语言：javascript复制
eps(1.0)
2.220446049250313e-16
eps(1000.)
1.1368683772161603e-13

舍入模型

代码语言：javascript复制
1.1 0.1
>>1.2000000000000002

任意精度的运算

代码语言：javascript复制
BigInt(typemax(Int64))   1
>>9223372036854775808
x=BigFloat(1.1 0.1)
>>1.20000000000000017763568394002504646778106689453125

BigFloat也是有默认的长度的，不过我们可以调节，但每次调节只能do模块里面的精度

代码语言：javascript复制
setrounding(BigFloat, RoundUp) do
           BigFloat(1)   parse(BigFloat, "0.1")
       end
>>1.100000000000000000000000000000000000000000000000000000000000000000000000000003
setrounding(BigFloat, RoundDown) do
1.            BigFloat(1)   parse(BigFloat, "0.1")
       end
>>1.099999999999999999999999999999999999999999999999999999999999999999999999999986
setprecision(40) do
           BigFloat(1)   parse(BigFloat, "0.1")
       end
>>1.1000000000004

一个简单的递归函数，函数的具体用法将在后面讲到

代码语言：javascript复制
function showTypeTree(T, level = 0)
    println("t" ^ level, T)
    for t in subtypes(T)
        if t!= Any
            showTypeTree(t, level   1)
        end
    end
end
>>showTypeTree (generic function with 2 methods)
showTypeTree(Real)
>>Real
    AbstractFloat
        BigFloat
        Float16
        Float32
        Float64
    AbstractIrrational
        Irrational
    Integer
        Bool
        Signed
            BigInt
            Int128
            Int16
            Int32
            Int64
            Int8
        Unsigned
            UInt128
            UInt16
            UInt32
            UInt64
            UInt8
    Rational

复数和分数

复数

代码语言：javascript复制
x = 1   2im
(1   2im)*(2 - 3im)
>>8   1im
(1   2im)^2
>>-3   4im
2(1 - 1im)
>>2 - 2im

运算优先级

代码语言：javascript复制
2/5im  #表示2/(5*im)
2/5im==-2/5*im

复数的其他运算

代码语言：javascript复制
sqrt(2   3im)
cos(1   2im)
exp(1   2im)
abs(1   2im)
sqrt(-1)  #error
sqrt(-1   0im)
x = 1
y = 2
z1 = x   y*im
z2 = complex(x,y)
real(z1)
angle(1 2im)

分数

代码语言：javascript复制
2//3
2//4
>>1//2
numerator(2//3) #分子
denominator(2//3) #分母
float(1//2)
isequal(float(a//b),a/b)

字符串

代码语言：javascript复制
x = 'a' #用单引号表示字符
Int(x)
Char(ans)
## ASCII码对应
'u21' # !
Int('t')

str = "Hello World!"
str[1]  #Julia的下标从1开始
str[end-3:end]

又见蛋疼的编码

Julia 完整支持 Unicode 字符和字符串,Unicode码位可以使用u和U来转义，在Julia中，非ASCII字符使用UTF-8编码，但UTF-8编码是一种变长的编码方式，也就是说不同字符的编码长度可能不同，这就导致在使用一些非常见字符时可能会碰到蛋疼的问题。

代码语言：javascript复制
str = "u2200 x u2203 y"
>>"∀ x ∃ y"
str[1]
>>'∀': Unicode U 2200 (category Sm: Symbol, math)
str[2]
>>ERROR:...
str[3]
>>ERROR:...
str[4]
>>' ': ASCII/Unicode U 0020 (category Zs: Separator, space)

在UTF-8的编码中，'u2200'即'∀'使用了三个字符，因此str[2]和str[3]都是无效的。str[4]为空格。 但可以这么使用：

代码语言：javascript复制
str[1:4]

也可以使用firstindex()和lastindex()来索引

代码语言：javascript复制
for i = firstindex(str):lastindex(str)
    try
        println(s[i])
    catch

    end
end
>>∀

x

∃

y

当然，也可以像Python一样，直接将字符串当做遍历对象，而且不需要异常处理：

代码语言：javascript复制
for i in s
    println(i)
end

字符串的其他操作

代码语言：javascript复制
x = "Helllo"
y = "World"
string(x,",",y,"n")
>>Hello,Worldn
x * ',' * y
>>"Hello,World"
string("$x $y !")
>>"Hello World !"
n = 4
"nnnn has $n n"
>>"nnnn has 4 n"
"1/3 is about $(1/3)"
>>"1/3 is about 0.3333333333333333"
"$x,$yn"
>>"Helllo,Worldn"
"1   2 = $(1   2)"
>>"1   2 = 3"
v = [1,2,3]
"v: $v"
>>"v: [1, 2, 3]"
# 由于$是一个特殊字符，在当做文字使用时需转义
println("$100")
>>$100
"abc" ^ 3
>>"abcabcabc"
lowercase("HELLO")
uppercase("hello")
replace("I want to learn Python", "Python" =>  "Julia")
replace("ABCD", 'A'=>'E')
startswith("julia is interesting", "julia")
>>true
startswith("  julia is interesting", "julia")
>>false
startswith(strip("  julia is interesting"), "julia")
>>true
s = split("one two three")
>>3-element Array{SubString{String},1}:
 "one"  
 "two"  
 "three"
join(s)
>>"onetwothree"
join(s, " ")
>>"one two three"

跨多行的字符串

代码语言：javascript复制
"""
Hello,
world."""
>>"Hello,nworld."

字符串的数学运算

代码语言：javascript复制
“abcde" < "xyz"
>>true
"abcd" != "abcde"
>>true
"1   2 = 3" == "1   2 = $(1 2)"
>>true
findfirst(isequal('x'),"xilinx")
>>1
findnext(isequal('x'),"xilinx",1)
>>1
findnext(isequal('x'),"xilinx",2)
>>6
occursin("world", "Hello, world.")
>>true
repeat('a',10)
>>"aaaaaaaaaa"
x = "abcd..."
repeat(x,10)
>>"abcd...abcd...abcd...abcd...abcd...abcd...abcd...abcd...abcd...abcd..."
join(["abcd","efg","kmn","xyz"],","," and ")
>>"abcd,efg,kmn and xyz"
x = "abcdefgh"
firstindex(x)
>>1
lastindex(x)
>>8
length(x)
>>8
length(x,2,4)

有字符串的地方当然少不了正则表达式

代码语言：javascript复制
r"^s*(?:#|$)"
typeof(ans)
>>Regetx
occursin(r"^s*(?:#|$)", "not a comment")
>>false
occursin(r"^s*(?:#|$)", "# a comment")
>>true
m = match(r"abc","abcdefgh")
>>RegexMatch("abc")
m = match(r"[0-9]","aaaa1aaaa2aaaa3",1)
>>RegexMatch("1")
m = match(r"[0-9]","aaaa1aaaa2aaaa3",6)
>>RegexMatch("2")

Tuple

用()表示，内容不可更改

代码语言：javascript复制
x1 = (1,2,3,4)
x1[1] # 序号从1开始
length(x1)
x1[2:end]
x2 = (1, 2.4, 'a', "hello")
x3 = (a=1, b = 2)
x3.a
>>1

字典

Julia中也支持字典类型

代码语言：javascript复制
dic = Dict("aa" => 1, "bb" => 2, "cc" => 3)
typeof(dic)
>>Dict{String,Int64}
dic.count
dic.keys
dic.vals
dic["aa"]

也可以把Array转成字典

代码语言：javascript复制
ary = ["one" => 1, "two" => 2]
Dict(ary)

把Array中的Tuple转成字典

代码语言：javascript复制
tpl = [("one", 1), ("two", 2)]
Dict(tpl)

把两个Array组合成Dict

代码语言：javascript复制
vas = [1, 2, 3]
kes = ["one", "two", "three"]
Dict(zip(kes, vas))

新建一个空字典

代码语言：javascript复制
d = Dict()
d["one"] = 1

在新建空字典时指定类型

代码语言：javascript复制
d = Dict{String,Int64}()

字典遍历

代码语言：javascript复制
d = Dict("one" => 1, "two" => 2, "three" => 3)
for (k,v) in d
    println("value is $k for key $v")
end

for v in values(d)
    println(v)
end

字典的其他用法

代码语言：javascript复制
d = Dict("one" => 1, "two" => 2)
get(d, "three", -1)
get(d, "one", -1)
delete!(d, "one")

# 使用fieldnames查看该类型的fieldname
fieldnames(typeof(d))

Set

代码语言：javascript复制
S = Set([1, 2, 3, 2])
S = Set(1:3:10)
2 in S
4 in S
issubset([1,4], S)  # [1,4] ⊆ S

A = Set([1, 2, 3, 4])
B = Set([2, 4, 6, 7])
# A 交 B
intersect(A,B)

# A 或 B
union(A, B)

# 注：不是Set也可以进行交/或操作，但返回不是Set
interset([1,2,3,4], [2,4,6,7])
编程算法 unicode shell

0 人点赞