Getting Started with Julia

文章目录

• Getting Started with Julia
• Introduction
• Manual手册
• • Install安装
  • Getting start
  • Varables变量
  • Integers整数 & Floating-Point Numbers浮点数
  • • Integer types:
    • Floating-point types:
    • Overflow behavior溢出行为
    • Divison errors除法错误
    • Append of Num
    • • 浮点中的零
      • Underscores in Float
      • Special float-point values
      • `BigInt`&`BigFloat`
  • Mathematical Oprations and Elementary Functions
  • • 算数运算符
    • Bitwise Operators位运算符[^2]
    • Updating Operators复合赋值操作
    • ==Vectorized "dot" operators向量乘法运算==
    • Numeric Comparisons数值比较
    • ==Elementary Functions初等函数==
    • 运算优先级
    • Numerical Conversions数字转换
    • Rounding functions舍入函数
    • Division functuons除法函数
    • Sign and absolute value functions符号和绝对值
    • Power, logs and roots幂、对数和根号
    • Trigonometric and hyperbolic functions==三角函数==和双曲函数
    • 特殊函数
  • Complex and Rational Numbers复数和有理数
  • • Complex Numbers复数
    • Real numbers有理数
  • Strings字符串
  • • 字符
    • String Basics字符串基础
    • Unicode & UTF-8
    • Concatenation拼接
    • Interpolation插入
    • Triple-Queoted String Literals三引号字符串
    • Common Operations常用操作
    • • Index索引
      • Special Index特殊的索引
      • Tricks小操作
    • Non-Standard String Literals非标准字符串
    • • Regular Expressions正则表达式
      • Byte Array Literals
      • Version Number Literals
      • Raw String Literals原始字符串
  • Function函数
  • Multi Dimensional Arrays多维数组

Introduction

本文为SesameMan笔记，详细信息请参照中文手册、英文教学材料等。

优势为：

• 免费开源；

• 用户定义的类同内建变量一样快；

• 非向量化的语言就很快；

• 为并行计算与分布式计算设计；

• 能使用协程¹；

• 低调且强大的类型系统；

• 对于其中的类，有可扩展的类型转换和提升；

• 支持UTF-8；

• 直接支持C；

• 像shell一样强的管理其他进程的能力；

• 像Lisp一样的宏和其他元编程工具。

Manual手册

Install安装

点击此处下载

Getting start

在交互式界面上(REPL)学习是上手Julia的最佳方式。

For Mac user, add this code in your file ~/.zprofile:

export PATH="/Applications/Julia-1.6.app/Contents/Resources/julia/bin:$PATH"

这样就能在命令行直接输入julia打开Julia交互式界面。

• Press Ctrl+d or input exit() to exit the interactive session;
• To evaluate expression writen in a source file myproject.jl , write include("file,jl") ;
• Just like other languages , you can print juila myfile.jl to compile.

Here are some useful args for Julia to provide:

option	功能
-t {N}	开启N线程
-h	显示命令行帮助，就是显示这些参数
–project[={ |@.}]	设置项目工作目录
-q	安静的启动，不显示横幅和警告
==-o, --optimize={0,1,2,3}==疑似不能用	设置编译器优化级别
-g, -g	Debug信息等级，默认为1，开2试试
–code-coverage={none|user|all}	对原文件中每行代码执行次数计数
-e <代码>	执行这一条代码
-E <代码>	执行这一条并输出结果

Varables变量

变量同其他程序一样，通过赋值给予：

julia> x=10
10

julia> x+=41
51

julia> x+8
59

julia> x="try this"
"try this"

julia> 中文也行=21
21

julia> 中文也行
21

除此之外还有一些注意事项：

• 不能使用内建变量(build_in Keywords)；
• 变量用小写；
• 不鼓励使用下划线；
• 类型(Type)与库(Module)的名字使用大写开头，使用驼峰式；
• 函数(Function)和宏(Macro)的名字使用小写；
• 会对输入参数更改的函数使用!结尾，因为它们在被调用后，不仅仅会返回一些值 还会更改输入参数的内容。

Integers整数 & Floating-Point Numbers浮点数

Integer types:

注意，无符号整数会通过 0x 前缀以及十六进制数 0-9a-f 来输入和输出（输入也可以使用大写的 A-F）。无符号值的位数取决于十六进制数字使用的数量：

#16进制
julia> 0x10
0x10

julia> ans*10
160

#2进制
julia> 0b10
0x02

#最大最小
julia> for T in [Int8,Int16,Int32,Int64,Int128,UInt8,UInt16,UInt32,UInt64,UInt128]
                  println("$(lpad(T,7)): [$(typemin(T)),$(typemax(T))]")
              end
   Int8: [-128,127]
  Int16: [-32768,32767]
  Int32: [-2147483648,2147483647]
  Int64: [-9223372036854775808,9223372036854775807]
 Int128: [-170141183460469231731687303715884105728,170141183460469231731687303715884105727]
  UInt8: [0,255]
 UInt16: [0,65535]
 UInt32: [0,4294967295]
 UInt64: [0,18446744073709551615]
UInt128: [0,340282366920938463463374607431768211455]

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)

Floating-point types:

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

E-notation for Float64：

julia> 2.5e-8
2.5e-8

julia> 2.5e-3
0.0025

julia> 2.5e2
250.0

F-notation for Float32 , using f in place of e:

julia> 2.5f-2
0.025f0

julia> ans*1
0.025f0

julia> ans*1.0
0.02500000037252903

julia> typeof(ans)
Float64

这里我们可以看出变量类型的改变。

类型转换：

julia> 0.25
0.25

julia> Float32(ans)
0.25f0

julia> Float16(ans)
Float16(0.25)
#半精度的数字是用32位模拟的

Overflow behavior溢出行为

julia> x=typemax(Int32)
2147483647

julia> x+1
2147483648

julia> x=typemax(Int64)
9223372036854775807

julia> x+1
-9223372036854775808

julia> x+=1
-9223372036854775808

julia> x==typemin(Int64)
true

#解决溢出
julia> big(10)
10

julia> big(10)^19
10000000000000000000

在可能有溢出产生的程序中，对最值边界出现循环进行显式检查是必要的。否则，推荐使用 BigInt 类型作为替代。

Divison errors除法错误

两种错误情况：

• Divide by 0，疑似没什么事;

julia> a
25

julia> a/0
Inf

• dividing the lowest negative number (typemin) by -1;好像也没什么事;

julia> -1/typemin(Int64)1.0842021724855044e-19julia> ans*typemin(Int64)-1.0julia> -1/typemin(Int128)5.877471754111438e-39

据说会报错`Divide error`。

### Machine epsilon机器精度

`eps`给出`1.0`与下一个浮点数之间的差值：

```julia
julia> eps(Float64)2.220446049250313e-16

eps给出一个和 x 类型相同的值使得 x + eps(x) 是比 x 更大的下一个可表示的浮点值：

julia> eps(1.0)2.220446049250313e-16julia> 1e-271.0e-27julia> eps(ans)1.793662034335766e-43

Julia 也提供了 nextfloat 和 prevfloat 两个函数分别返回基于参数的下一个更大或更小的可表示的浮点数：

julia> x = 1.25f01.25f0julia> nextfloat(x)1.2500001f0julia> prevfloat(x)1.2499999f0julia> bitstring(prevfloat(x))"00111111100111111111111111111111"julia> bitstring(x)"00111111101000000000000000000000"julia> bitstring(nextfloat(x))"00111111101000000000000000000001"

Append of Num

浮点中的零

Useing the function of bitstring:

julia> (bitstring(0.0),bitstring(-0.0))("0000000000000000000000000000000000000000000000000000000000000000", "1000000000000000000000000000000000000000000000000000000000000000")

Underscores in Float

julia> 10_000, 0.000_000_005, 0xdead_beef, 0b1011_0010(10000, 5.0e-9, 0xdeadbeef, 0xb2)

Special float-point values

Float16	Float32	Float64	名称	描述
Inf16	Inf32	Inf	正无穷	一个大于所有有限浮点数的数
-Inf16	-Inf32	-Inf	负无穷	一个小于所有有限浮点数的数
NaN16	NaN32	NaN	不是数（Not a Number）	一个不和任何浮点值（包括自己）相等（==）的值

BigInt&BigFloat

必须声明变量：

julia> x=typemax(Int64)9223372036854775807julia> x+=1-9223372036854775808julia> x=big(typemax(Int64))9223372036854775807julia> x+=19223372036854775808

Mathematical Oprations and Elementary Functions

算数运算符

表达式	名称	描述
+x	一元加法运算符	全等操作
-x	一元减法运算符	将值变为其相反数
x + y	二元加法运算符	执行加法
x - y	二元减法运算符	执行减法
x * y	乘法运算符	执行乘法
x / y	除法运算符	执行除法
x ÷ y	整除	取 x / y 的整数部分
x \ y	反向除法	等价于 y / x
x ^ y	幂操作符	x 的 y 次幂
x % y	取余	等价于 rem(x,y)

以及对 Bool 类型的否定：

表达式	名称	描述
!x	否定	将 true 和 false 互换

有趣的现象：

julia> 0*InfNaNjulia> false*Inf0.0

Bitwise Operators位运算符²

操作	实例	怎么写
按位取反Not	0111$\to$1000	~x
按位或Or		x | y
按位异或XOR		x ⊻ \veebar ⊻ y
按位与AND		x & y
Arithmetic shift right		x >> y
logical shift right		x >>> y
logical shift left		x << y

Updating Operators复合赋值操作

+= -= *= /= \= $\div$= &= |= $\veebar$= >>>= >>= <<=

Vectorized “dot” operators向量乘法运算

Julia 中，每个二元运算符都有一个 dot 运算符与之对应，例如 ^ 就有对应的 .^ 存在。这个对应的 .^ 被 Julia 自动地定义为逐元素地执行 ^ 运算。比如 [1,2,3] ^ 3 是非法的，因为数学上没有给（长宽不一样的）数组的立方下过定义。但是 [1,2,3] .^ 3 在 Julia 里是合法的，它会逐元素地执行 ^ 运算（或称向量化运算），得到 [1^3, 2^3, 3^3]。类似地，! 或 √ 这样的一元运算符，也都有一个对应的 .√ 用于执行逐元素运算。

julia> [1,2,3] .^ 33-element Array{Int64,1}:  1  8 27

具体来说，a .^ b 被解析为 dot 调用 (^).(a,b)，这会执行 broadcast操作：该操作能结合数组和标量、相同大小的数组（元素之间的运算）、甚至不同形状的数组（例如行、列向量结合生成矩阵）。更进一步，就像所有向量化的 dot 调用一样，这些 dot 运算符是融合的（fused）。例如，在计算表达式 2 .* A.^2 .+ sin.(A) 时，Julia 只对 A 进行做一次循环，遍历 A 中的每个元素 a 并计算 2a^2 + sin(a)。上述表达式也可以用@.宏简写为 @. 2A^2 + sin(A)。特别的，类似 f.(g.(x)) 的嵌套 dot 调用也是融合的，并且“相邻的”二元运算符表达式 x .+ 3 .* x.^2 可以等价转换为嵌套 dot 调用：(+).(x, (*).(3, (^).(x, 2)))。

除了 dot 运算符，我们还有 dot 复合赋值运算符，类似 a .+= b（或者 @. a += b）会被解析成 a .= a .+ b，这里的 .= 是一个融合的 in-place 运算。

这个点语法，也能用在用户自定义的运算符上。例如，通过定义 ⊗(A,B) = kron(A,B) 可以为 Kronecker 积（kron）提供一个方便的中缀语法 A ⊗ B，那么配合点语法 [A,B] .⊗ [C,D] 就等价于 [A⊗C, B⊗D]。

将点运算符用于数值字面量可能会导致歧义。例如，1.+x 到底是表示 1. + x 还是 1 .+ x？这会令人疑惑。因此不允许使用这种语法，遇到这种情况时，必须明确地用空格消除歧义。

Numeric Comparisons数值比较

Standard comparison operations are defined for all the primitive numeric types:

Operator	Name
==	equality
!=, ≠	inequality
<	less than
<=, ≤	less than or equal to
>	greater than
>=, ≥	greater than or equal to

为此，Julia 给这些特别的数提供了下面几个额外的测试函数。这些函数在某些情况下很有用处，比如在做 hash 比较时。

函数	测试是否满足如下性质
isequal(x, y)	x 与 y 是完全相同的
isfinite(x)	x 是有限大的数字
isinf(x)	x 是（正/负）无穷大
isnan(x)	x 是 NaN

支持链式比较。

Elementary Functions初等函数

可向量化，例如：函数也能通过 点语法 f.(A) 以“向量化”的方式作用于数组和其它集合上。 比如，sin.(A) 会计算 A 中每个元素的 sin 值。

运算优先级

Numerical Conversions数字转换

Julia支持三种数值转换，他们在处理不精确转换上有所不同。

• T(x) and convert(T,x) will converts x to a value of type T.

• x % T converts an integer x to a value of integer type T congruent to x modulo 2^n, where n is the number of bits in T. In other words, the binary representation is truncated to fit.(注：相当于，分别取转化为二进制取模)

• The Rounding functions take a type T as an optional argument. For example, round(Int,x) is a shorthand for Int(round(x)).

Rounding functions舍入函数

函数	描述	返回类型
round(x)	x 舍到最接近的整数	typeof(x)
round(T, x)	x 舍到最接近的整数	T
floor(x)	x 向 -Inf 方向舍入	typeof(x)
floor(T, x)	x 向 -Inf 方向舍入	T
ceil(x)	x 向 +Inf 方向取整	typeof(x)
ceil(T, x)	x 向 +Inf 方向取整	T
trunc(x)	x 向 0 取整	typeof(x)
trunc(T, x)	x 向 0 取整	T

Division functuons除法函数

函数	描述
div(x,y), x÷y	截断除法；商向零近似
fld(x,y)	向下取整除法；商向 -Inf 近似
cld(x,y)	向上取整除法；商向 +Inf 近似
rem(x,y)	取余；满足 x == div(x,y)*y + rem(x,y)；符号与 x 一致
mod(x,y)	取模；满足 x == fld(x,y)*y + mod(x,y)；符号与 y 一致
mod1(x,y)	偏移 1 的 mod；若 y>0，则返回 r∈(0,y]，若 y<0，则 r∈[y,0) 且满足 mod(r, y) == mod(x, y)
mod2pi(x)	以 2pi 为基取模；0 <= mod2pi(x) < 2pi
divrem(x,y)	返回 (div(x,y),rem(x,y))
fldmod(x,y)	返回 (fld(x,y),mod(x,y))
gcd(x,y...)	x, y,… 的最大公约数
lcm(x,y...)	x, y,… 的最小公倍数

Sign and absolute value functions符号和绝对值

函数	描述
abs(x)	x 的模
abs2(x)	x 的模的平方
sign(x)	表示 x 的符号，返回 -1，0， +1
signbit(x)	表示符号位是 true 或 false
copysign(x,y)	返回一个数，其值等于 x 的模，符号与 y 一致
flipsign(x,y)	返回一个数，其值等于 x 的模，符号与 x*y 一致

Power, logs and roots幂、对数和根号

函数	描述
sqrt(x), √x	x 的平方根
cbrt(x), ∛x	x 的立方根
hypot(x,y)3	当直角边的长度为 x 和 y时，直角三角形斜边的长度
exp(x)	自然指数函数在 x 处的值
expm1(x)4	当 x 接近 0 时的 exp(x)-1 的精确值
ldexp(x,n)	x*2^n 的高效算法，n 为整数
log(x)	x 的自然对数
log(b,x)	以 b 为底 x 的对数
log2(x)	以 2 为底 x 的对数
log10(x)	以 10 为底 x 的对数
log1p(x)4	当 x接近 0 时的 log(1+x) 的精确值
exponent(x)	x 的二进制指数
significand(x)	浮点数 x 的二进制有效数（也就是尾数）

Trigonometric and hyperbolic functions三角函数和双曲函数

所有标准的三角函数和双曲函数也都已经定义了：

sin    cos    tan    cot    sec    cscsinh   cosh   tanh   coth   sech   cschasin   acos   atan   acot   asec   acscasinh  acosh  atanh  acoth  asech  acschsinc   cosc

所有这些函数都是单参数函数，不过 atan 也可以接收两个参数 来表示传统的 atan2 函数。

另外，sinpi(x) 和 cospi(x) 分别用来对 sin(pi*x) 和 cos(pi*x) 进行更精确的计算。

要计算角度而非弧度的三角函数，以 d 做后缀。 比如，sind(x) 计算 x 的 sine 值，其中 x 是一个角度值。 下面是角度变量的三角函数完整列表：

sind   cosd   tand   cotd   secd   cscdasind  acosd  atand  acotd  asecd  acscd

特殊函数

SpecialFunctions.jl see in github.

Complex and Rational Numbers复数和有理数

支持上一节中的所有函数。

Complex Numbers复数

全局变量im表示复数i。

标准函数名称	写法
取实部	real( )
取虚部	Imag( )
取复共轭	Conj()
取绝对值	Abs( )
取绝对值后平方	Abs2()
相角(弧度单位制)	Angle( )

构建一个复数：

julia> a=1010julia> b=2020julia> complex(a,b)10 + 20im

Real numbers有理数

• Julia支持一种使用//的分数表示法，eg：2//3；

整数比值的这种标准化形式是唯一的，所以分数值的相等性可由校验分子与分母都相等来测试。分数值的标准化分子和分母可以使用 numerator 和 denominator 函数得到：

julia> numerator(2//3)2julia> denominator(2//3)3

• 支持无穷分数构建：

julia> 99//01//0julia> -1//0-1//0

Strings字符串

高级特性：

• 补充知识，ASCII文本。
• 剩下的都不懂。

字符

看不懂

Char 类型的值代表单个字符：它只是带有特殊文本表示法和适当算术行为的 32 位原始类型，不能转化为代表 Unicode 代码 的数值。（Julia 的包可能会定义别的 AbstractChar 子类型，比如当为了优化对其它 字符编码 的操作时）Char 类型的值以这样的方式输入和显示：

julia> 'x''x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)julia> typeof(ans)Char

你可以轻松地将 Char 转换为其对应的整数值，即 Unicode 代码：

julia> Int('x')120julia> typeof(ans)Int64

在 32 位架构中，typeof(ans) 将显示为 Int32。你可以轻松地将一个整数值转回 Char。

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

并非所有的整数值都是有效的 Unicode 代码，但是为了性能，Char 的转化不会检查每个值是否有效。如果你想检查每个转换的值是否为有效值，请使用 isvalid 函数：

julia> Char(0x110000)'\U110000': Unicode U+110000 (category In: Invalid, too high)julia> isvalid(Char, 0x110000)false

目前，有效的 Unicode 码点为，从 U+0000 至 U+D7FF，以及从 U+E000 至 U+10FFFF。 它们还未全部被赋予明确的含义，也还没必要能被程序识别；然而，所有的这些值都被认为是有效的 Unicode 字符。

你可以在单引号中输入任何 Unicode 字符，通过使用 \u 加上至多 ４ 个十六进制数字或者 \U 加上至多 ８ 个十六进制数（最长的有效值也只需要 6 个）：

julia> '\u0''\0': ASCII/Unicode U+0000 (category Cc: Other, control)julia> '\u78''x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)julia> '\u2200''∀': Unicode U+2200 (category Sm: Symbol, math)julia> '\U10ffff''\U10ffff': Unicode U+10FFFF (category Cn: Other, not assigned)

Julia 使用系统默认的区域和语言设置来确定，哪些字符可以被正确显示，哪些需要用 \u 或 \U 的转义来显示。除 Unicode 转义格式之外，还可以使用所有的传统 C 语言转义输入形式：

julia> Int('\0')0julia> Int('\t')9julia> Int('\n')10julia> Int('\e')27julia> Int('\x7f')127julia> Int('\177')127

你可以对 Char 的值进行比较和有限的算术运算：

julia> 'A' < 'a'truejulia> 'A' <= 'a' <= 'Z'falsejulia> 'A' <= 'X' <= 'Z'truejulia> 'x' - 'a'23julia> 'A' + 1'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)

String Basics字符串基础

字符串的文字部分由双引号或3*双引号(包括双引号的字符串)分割；

在字符串中索引文字：

julia> mystr="康嘉胤好帅啊,his qq is 891124092""康嘉胤好帅啊,his qq is 891124092"julia> mystr[4]'嘉': Unicode U+5609 (category Lo: Letter, other)julia> mystr[21]'i': ASCII/Unicode U+0069 (category Ll: Letter, lowercase)julia> mystr[begin]'康': Unicode U+5EB7 (category Lo: Letter, other)julia> mystr[end]'2': ASCII/Unicode U+0032 (category Nd: Number, decimal digit)

范围索引：

julia> mystr[4:25]"嘉胤好帅啊,his qq"

注意到 str[k] 和 str[k:k] 输出的结果不一样：

julia> (mystr[1],mystr[1:1])('康', "康")

前者是 Char 类型的单个字符值，后者是碰巧只有单个字符的字符串值。在 Julia 里面两者大不相同。

范围索引复制了原字符串的选定部分。此外，也可以用 SubString 类型创建字符串的 view，例如：

julia> str = "long string""long string"julia> substr = SubString(str, 1, 4)"long"julia> typeof(substr)SubString{String}

几个标准函数，像 chop, chomp 或者 strip 都会返回一个 SubString。

Unicode & UTF-8

Concatenation拼接

如代码所示：

julia> who="sesame man ""sesame man "julia> what="handsome.""handsome."julia> hhh=string(who,"is ",what)"sesame man is handsome."

使*串联级：

julia> who*"is "*what"sesame man is handsome."

尽管对于提供 + 函数用于字符串拼接的语言使用者而言，* 似乎是一个令人惊讶的选择，但 * 的这种用法在数学中早有先例，尤其是在抽象代数中。

在数学上，+ 通常表示可交换运算（commutative operation）——运算对象的顺序不重要。一个例子是矩阵加法：对于任何形状相同的矩阵 A 和 B，都有 A + B == B + A。与之相反，* 通常表示不可交换运算——运算对象的顺序很重要。例如，对于矩阵乘法，一般 A * B != B * A。同矩阵乘法类似，字符串拼接是不可交换的：greet * whom != whom * greet。在这一点上，对于插入字符串的拼接操作，* 是一个自然而然的选择，与它在数学中的用法一致。

更确切地说，有限长度字符串集合 S 和字符串拼接操作 * 构成了一个*幺半群 (S, *)。该集合的单位元是空字符串，""。当一个*幺半群不是交换的时，它的运算通常表示为 \cdot，*，或者类似的符号，而非暗示交换性的 +。

Interpolation插入

有点像shell全局变量，前边加$即可插入字符串：

julia> "$who can win the game.""sesame man  can win the game."

可插入表达式：

julia> "$who can win the game $(2*50*1) times.""sesame man  can win the game 100 times."

对于一些抽象字符串而言，可返回字符表达形式:

julia> kang=["169 cm","23","imu","nku"]4-element Vector{String}: "169 cm" "23" "imu" "nku"julia> "kang:$kang""kang:[\"169 cm\", \"23\", \"imu\", \"nku\"]

Triple-Queoted String Literals三引号字符串

• 不仅仅能在句子中添加引号，更有层次关系；
• 会有强力的缩进；
• 反缩进dedentation；
• 无论是用单引号还是三引号，在文本字符串中换行符都会生成一个换行 (LF) 字符 \n，即使你的编辑器使用回车组合符 \r (CR) 或 CRLF 来结束行。为了在字符串中包含 CR，总是应该使用显式转义符 \r；比如，可以输入文本字符串 "a CRLF line ending\r\n"。

julia> ying="""       kang       jiayin        good       """"kang\njiayin \ngood\n"

Common Operations常用操作

Index索引

名称	作用
findfirst(char, string)	找到第一个char
findlast(char, string)	找到最后一个char
findnext(char, string ,num)	从num算起，找下一个char
findprev(char, string ,num)	从num算起，找上一个char
occurs(string1, string2)	找string1是否在string2中，返回布尔值

Special Index特殊的索引

firstindex(string)	给出第一个字节byte的索引，通常为1
lasrindex(string)	给出最大字节byte的索引，
length(string)	字符的个数
length(string,i,j)	从i到j有效字符的个数
ncodeunits(string)	Number unit码元的个数
codeunit(string,i)	给出在字符串 str 中索引为 i 的代码单元值。
thisind(string,i)	给出给定i处字符的索引值
nextind(string,i,n=1)	给出给定i后字符的索引值
prevint(string,i,n=1)	给出给定i前字符的索引值

定义：

julia> kang="康嘉胤""康嘉胤"julia> jia="kangjiayin""kangjiayin"

实验：

julia> ncodeunits(kang)9julia> thisind(kang,2)1julia> thisind(kang,3)1julia> thisind(kang,4)4julia> length(kang)3julia> prevind(kang,4)1

Tricks小操作

另外还有两个方便的字符串函数 repeat 和 join：

julia> repeat(".:Z:.", 10)".:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:."julia> join(["apples", "bananas", "pineapples"], ", ", " and ")"apples, bananas and pineapples"

Non-Standard String Literals非标准字符串

Regular Expressions正则表达式

• Julia采用和perl⁵兼容正则表达式(regexes);

• r" "开头;

• 检查是否匹配用occursin(regexes,string);

• 获取匹配信息用match(regexes,string,n=1);

• 从match对象提取信息：

  • 匹配的整个子字符串：m.match
  • 作为字符串数组捕获的子字符串：m.captures
  • 整个匹配开始处的偏移：m.offset
  • 作为向量的捕获子字符串的偏移：m.offsets

PCRE⁶正则表达式

字符	描述
\	将下一个字符标记为一个特殊字符，或一个原义字符，或一个向后引用，或一个八进制转义符。例如，”\n”匹配一个换行符。
^	匹配输入字符串的开始位置。
$	匹配输入字符串的结束位置。
*	匹配前面的子表达式零次或多次，等价于{0,}
+	匹配前面的子表达式一次或多次，等价于{1,}
?	匹配前面的子表达式零次或一次，等价于{0,1}
?	当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时，匹配模式是非贪婪的。非贪婪模式尽可能少地匹配所搜索的字符串，而默认的贪婪模式则尽可能多地匹配所搜索的字符串。例如，对于字符串”oooo”,”o+?”将匹配单个”o”,而”o+”将匹配所有的”o”。
{n}	N是一个非负整数，匹配确定的n次。
{n,}	N是一个非负整数，至少匹配n次。
{n,m}	M和n均为非负整数，其中n<=m，最少匹配n次且最多匹配m次。
.	匹配除”\n”之外的任何单个字符。要匹配包括”\n”在内的任何字符，请使用像”[.\n]”的模式
(pattern)	匹配pattern并获取这一匹配。
(?:pattern)	匹配pattern但不获取匹配结果。这在使用“或”字符(|)来组合一个模式的各个部分是很有用的。例如:’industry|industries’就可以用’industr(?:y|ies)’代替
(?=pattern)	正向预查，在任何匹配pattern的字符串开始处匹配查找字符串。例如：”Windows(?=95|98|NT|2000)”能匹配”Windows2000”中的”Windows”，但不能匹配”Windows3.1”中的”Windows”。
(?!pattern)	负向预查，在任何不匹配pattern的字符串开始处匹配查找字符串。例如：”Windows(?!95|98|NT|2000)”能匹配”Windows3.1”中的”Windows”，但不能匹配”Windows2000”中的”Windows”。
x|y	匹配x或y。
[xyz]	字符集合，匹配所包含的任何一个字符。
[^xyz]	负值字符集合，匹配未包含的任意字符。
[a-z]	字符范围，匹配指定范围内的任意字符。
[^a-z]	负值字符范围，匹配任何不在指定范围内的任意字符。
\b	匹配一个单词边界，也就是单词和空格间的位置。
\B	匹配非单词边界。
\cx	匹配由x指明的控制字符。X的值必须为A-Z或a-z之间
\d	匹配一个数字字符。等价于[0-9]
\D	匹配一个非数字字符。等价于[^0-9]
\f	匹配一个换页符。等价于\x0c和\cL
\n	匹配一个换行符。等价于\x0a和\cJ
\r	匹配一个回车符。等价于\x0d和\cM
\s	匹配任何空白字符，包括空格、制表符、换页符等。
\S	匹配任何非空白符。
\t	匹配一个制表符
\w	匹配包括下划线的任何单词字符。等价于[a-zA-Z0-9_]
\W	匹配任何非单词字符。
\xn	匹配n，其中n为十六进制转义值。例如”\x41”匹配”A”。
\num	匹配num，其中num是一个正整数。对所获取的匹配的引用。例如：”(.)\1”

Byte Array Literals

Version Number Literals

Raw String Literals原始字符串

引号仍必须转义，例如 raw"\"" 等效于 "\""。为了能够表达所有字符串，反斜杠也必须转义，不过只是当它刚好出现在引号前面时。

julia> println(raw"\\ \\\"")\\ \"

Function函数

Julia中，定义函数的语法为：

julia> function get(x,y)           x+y       endget (generic function with 1 method)julia> get(1,3)4

另一种定义语法为自然语言直接定义。

Multi Dimensional Arrays多维数组

---

1. https://zh.wikipedia.org/wiki/%E5%8D%8F%E7%A8%8B 协程（英语：coroutine）是计算机程序的一类组件，推广了协作式多任务的子程序，允许执行被挂起与被恢复。相对子例程而言，协程更为一般和灵活，但在实践中使用没有子例程那样广泛。协程更适合于用来实现彼此熟悉的程序组件，如协作式多任务、异常处理、事件循环、迭代器、无限列表和管道。 ↩︎

2. https://zh.wikipedia.org/wiki/%E4%BD%8D%E6%93%8D%E4%BD%9C位操作是程序设计中对位模式或二进制数的一元和二元操作。在许多古老的微处理器上，位运算比加减运算略快，通常位运算比乘除法运算要快很多。在现代架构中，情况并非如此：位运算的运算速度通常与加法运算相同（仍然快于乘法运算）。 ↩︎

3. https://www.johndcook.com/blog/2010/06/02/whats-so-hard-about-finding-a-hypotenuse/ ↩︎

4. https://www.johndcook.com/blog/2010/06/07/math-library-functions-that-seem-unnecessary/ ↩︎ ↩︎

5. https://zh.wikipedia.org/wiki/Perl Perl是高端、通用、解释型、动态的编程语言家族。 ↩︎

6. https://perldoc.perl.org/perlre#Modifiers ↩︎