Julia之初体验（二）变量

 

无论使用预编译的二进制文件还是从源代码进行编译，Julia的安装都非常简单。 按照https://julialang.org/downloads/上的说明下载并安装Julia。

学习和使用Julia的最简单方法是通过双击Julia可执行文件或从命令行运行julia来启动交互式会话（也称为read-eval-print循环或“ REPL”）：

要退出交互式会话，请键入CTRL-D（同时按Ctrl / ^键和d键），或键入exit（）。 在交互模式下运行时，julia将显示横幅，并提示用户输入。 用户输入完整的表达式（例如1 + 2）并按回车后，交互式会话将评估该表达式并显示其值。 如果表达式以尾部分号输入到交互式会话中，则不会显示其值。 无论是否显示，变量ans都绑定到最后一个求值表达式的值。 ans变量仅在交互式会话中绑定，而在以其他方式运行Julia代码时则不绑定。

要评估写在源文件file.jl中的表达式，就输入include（“ file.jl”）。

要以非交互方式在文件中运行代码，可以将其作为julia命令的第一个参数：

$ julia script.jl arg1 arg2...

 

一、变量

在Julia中，变量是与值关联（或绑定）的名称。 当您想存储一个值（例如，在一些数学运算之后获得的值）供以后使用时，此功能很有用。 例如：

# Assign the value 10 to the variable x
julia> x = 10
10

# Doing math with x's value
julia> x + 1
11

# Reassign x's value
julia> x = 1 + 1
2

# You can assign values of other types, like strings of text
julia> x = "Hello World!"
"Hello World!"

Julia提供了一个非常灵活的变量命名系统。 变量名区分大小写，没有语义（也就是说，语言不会根据变量名区别对待变量，中文也可以作为变量名！点赞！！）。

julia> x = 1.0
1.0

julia> y = -3
-3

julia> Z = "My string"
"My string"

julia> customary_phrase = "Hello world!"
"Hello world!"

julia> UniversalDeclarationOfHumanRightsStart = "人人生而自由，在尊严和权利上一律平等。"
"人人生而自由，在尊严和权利上一律平等。"

允许使用Unicode名称（采用UTF-8编码）：输入：\delta 按tab键

julia> δ = 0.00001
1.0e-5
julia> 我说 = "Hello"
"Hello"

在Julia REPL和其他几个Julia编辑环境中，您可以通过键入反斜杠LaTeX符号名称和制表符来键入许多Unicode数学符号。 例如，可以通过键入\ delta-tab输入变量名δ，或者通过\ alpha-tab- \ hat-tab-\ _ 2-tab甚至输入α̂2来输入。 （如果您在某个地方（例如在他人的代码中）发现不知道如何键入的符号，则REPL帮助将告诉您：只需键入？，然后粘贴该符号即可。）

如有需要，Julia甚至可以让您重新定义内置的常量和函数（尽管不建议这样做以避免潜在的混乱）：还是别这么做吧，我们还是初学者。

julia> pi = 3
3

julia> pi
3

julia> sqrt = 4
4

但是，如果尝试重新定义已使用的内置常量或函数，Julia会给您一个错误：

julia> pi
π = 3.1415926535897...

julia> pi = 3
ERROR: cannot assign a value to variable MathConstants.pi from module Main

julia> sqrt(100)
10.0

julia> sqrt = 4
ERROR: cannot assign a value to variable Base.sqrt from module Main

 

二、整数和浮点数

整数和浮点值是算术和计算的基本构建块。这种值的内置表示形式称为数字原语，而整数和浮点数的表示形式作为代码中的立即值称为数字文字。例如，1是整数文字，而1.0是浮点文字；它们作为对象的二进制内存表示形式是数字基元。

Julia提供了多种原始数字类型，并且在它们之上定义了算术和按位运算符以及标准数学函数的完整补充。这些直接映射到现代计算机本身支持的数字类型和运算上，从而使Julia可以充分利用计算资源。此外，Julia提供了对任意精度算术的软件支持，该算法可以处理无法在本机硬件表示中有效表示的数值上的运算，但会以相对较慢的性能为代价。

以下是Julia的原始数字类型：

整数型

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^127	2^127 - 1
UInt128		128	0	2^128 - 1
Bool	N/A	8	false (0)	true (1)

注意：Bool布尔型是整数型

 

浮点型：

Type	Precision	Number of bits
Float16	half	16
Float32	single	32
Float64	double	64

 

julia> 1
1

julia> 1234
1234

整数文字的默认类型取决于目标系统是32位体系结构还是64位体系结构：

# 32-bit system:
julia> typeof(1)
Int32

# 64-bit system:
julia> typeof(1)
Int64

查类型用 typeof()，这相当于python的type()

# 32-bit system:
julia> Int
Int32
julia> UInt
UInt32

# 64-bit system:
julia> Int
Int64
julia> UInt
UInt64

# 32-bit or 64-bit system:
julia> typeof(3000000000)
Int64

使用0x前缀和十六进制（以16为基）数字0-9a-f输入和输出无符号整数（大写数字A-F也适用于输入）。 无符号值的大小取决于所使用的十六进制数字的数量：

julia> 0x1
0x01

julia> typeof(ans)
UInt8

julia> 0x123
0x0123

julia> typeof(ans)
UInt16

julia> 0x1234567
0x01234567

julia> typeof(ans)
UInt32

julia> 0x123456789abcdef
0x0123456789abcdef

julia> typeof(ans)
UInt64

julia> 0x11112222333344445555666677778888
0x11112222333344445555666677778888

julia> typeof(ans)
UInt128

此行为基于以下观察结果：当人们使用无符号十六进制文字作为整数值时，通常是使用它们来表示固定的数字字节序列，而不仅仅是整数。

注意：变量ans是指在交互式会话中评估的最后一个表达式的值。有点像Mathematica中的%。 当以其他方式运行Julia代码时，不会发生这种情况。

还支持二进制和八进制文字：

julia> 0b10
0x02

julia> typeof(ans)
UInt8

julia> 0o010
0x08

julia> typeof(ans)
UInt8

julia> 0x00000000000000001111222233334444
0x00000000000000001111222233334444

julia> typeof(ans)
UInt128

 

浮点数字

文字浮点数以标准格式表示，必要时使用E表示法：

julia> 1.0
1.0

julia> 1.
1.0

julia> 0.5
0.5

julia> .5
0.5

julia> -1.23
-1.23

julia> 1e10
1.0e10

julia> 2.5e-4
0.00025

julia> 0.5f0
0.5f0

julia> typeof(ans)
Float32

julia> 2.5f-4
0.00025f0

 

julia> Float32(-1.5)
-1.5f0

julia> typeof(ans)
Float32

julia> 0x1p0
1.0

julia> 0x1.8p3
12.0

julia> 0x.4p-1
0.125

julia> typeof(ans)
Float64

julia> 0.0 == -0.0
true

julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"

julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"

 

特殊浮点值

有三个指定的标准浮点值，它们与实数线上的任何点都不对应：

Float16	Float32	Float64	Name	Description
Inf16	Inf32	Inf	positive infinity无穷大	a value greater than all finite floating-point values大于所有有限浮点值的值
-Inf16	-Inf32	-Inf	negative infinity负无穷大	a value less than all finite floating-point values小于所有有限浮点值的值
NaN16	NaN32	NaN	not a number 非数	a value not == to any floating-point value (including itself)不等于任何浮点值（包括其自身）的值

julia> 1/Inf
0.0

julia> 1/0
Inf

julia> -5/0
-Inf

julia> 0.000001/0
Inf

julia> 0/0
NaN

julia> 500 + Inf
Inf

julia> 500 - Inf
-Inf

julia> Inf + Inf
Inf

julia> Inf - Inf
NaN

julia> Inf * Inf
Inf

julia> Inf / Inf
NaN

julia> 0 * Inf
NaN

julia> (typemin(Float16),typemax(Float16))
(-Inf16, Inf16)

julia> (typemin(Float32),typemax(Float32))
(-Inf32, Inf32)

julia> (typemin(Float64),typemax(Float64))
(-Inf, Inf)

机器精度

大多数实数不能用浮点数精确表示，因此，出于许多目的，重要的是要知道两个相邻的可表示浮点数之间的距离，这通常称为机器ε。

Julia提供了eps，它给出了1.0与下一个更大的可表示浮点值之间的距离：

julia> eps(Float32)
1.1920929f-7

julia> eps(Float64)
2.220446049250313e-16

julia> eps() # same as eps(Float64)
2.220446049250313e-16

任意精度算法

julia> BigInt(typemax(Int64)) + 1
9223372036854775808

julia> big"123456789012345678901234567890" + 1
123456789012345678901234567891

julia> parse(BigInt, "123456789012345678901234567890") + 1
123456789012345678901234567891

julia> big"1.23456789012345678901"
1.234567890123456789010000000000000000000000000000000000000000000000000000000004

julia> parse(BigFloat, "1.23456789012345678901")
1.234567890123456789010000000000000000000000000000000000000000000000000000000004

julia> BigFloat(2.0^66) / 3
2.459565876494606882133333333333333333333333333333333333333333333333333333333344e+19

julia> factorial(BigInt(40))
815915283247897734345611269596115894272000000000

julia> x = typemin(Int64)
-9223372036854775808

julia> x = x - 1
9223372036854775807

julia> typeof(x)
Int64

julia> y = BigInt(typemin(Int64))
-9223372036854775808

julia> y = y - 1
-9223372036854775809

julia> typeof(y)
BigInt

赋值运算

julia> x = 3
3

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

julia> 1.5x^2 - .5x + 1
13.0

julia> 2^2x
64

还有两个函数：与python相似。

Function	Description
zero(x)	Literal zero of type x or type of variable x
one(x)	Literal one of type x or type of variable x

 

 

2020.5.21