Julia语言程序基础

Julia-lang

新兴的Julia语言，Julia 一开始就是为高性能而设计的。 Julia 程序通过 LLVM 编译成高效的多平台机器码。
Julia中文社区: https://cn.julialang.org/
Julia的诞生: 一群拥有各种语言丰富编程经验的Matlab高级用户，对现有的科学计算编程工具感到不满——这些软件对自己专长的领域表现得非常棒，但在其它领域却非常糟糕。他们想要的是一个开源的软件，它要像C语言一般快速而又拥有如同Ruby的动态性；要具有Lisp般真正的同像性而又有Matlab般熟悉的数学记号；要像Python般通用、像R般在统计分析上得心应手、像Perl般自然地处理字符串、像Matlab般具有强大的线性代数运算能力、像shell般胶水语言的能力，易于学习而又不让真正的黑客感到无聊；它应该是交互式的，同时又是编译型的JIT(Just-In-Time)。

• julia与传统动态语言最重要的区别是：

  • 核心语言很小：标准库是使用Julia下的，包括整数运算这样的基础运算
  • 丰富的基础类型：既可用于定义和描述对象，也可用于做可选的数据标注
  • 通过多重派发，可根据类型的不同，来调用同名函数的不同实现
  • 为了不同的参数类型，自动生成高效、专用的代码
  • 接近C语言的性能

Julia 变量

Julia语言中，变量是与某个值关联的名字。你可以用它来保存一个值

x = 10 
x + 1
x = "hello world"

Julia提供了非常灵活的变量命名的策略。变量名是大小写敏感的，且不包含语义，意思就是说，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 = " 人人生而自由，在尊严和权利上一律平等。"

• 变量的命名

变量名字必须以英文字母开头。

命名规范：变量名字采用小写

用下划线分割命名中的单词，不鼓励使用

Type Module类型的名字使用大写字符开头，并且大写字母而不是用下划线分割单词

函数function 和 宏macro的名字使用小写，不使用下划线

会对输入参数进行更改的函数要使用叹号！结尾

• 数值转换

Julia支持三种数值转换

​ - T(x) 和convert(T, x) 会把x转换成T类型

​ - 如果T是浮点类型，转换的结果就是最近的可表示值，可能会是正无穷大。

​ - 如果T为整数类型，当x不能由 T 类型表示时，会抛出异常InexactError

字符

char类型的值代表单个字符：他只是带有特殊文本表示法和适当算术行为的32位原始类型，不能转换为代表Unicode代码的数值，

• 字符拼接

text = string("Hello", "World")
println(text)

>>> HelloWorld
# 在Julia中字符串拼接的+号变成了*号
println("test" * "123")

• 计算长度

# 计算字符串的长度
println(length.(text))
>>> 10

• 引用变量进行字符拼接

# 引用变量
println("$text" * "123")
>>> HelloWorld123

• 三引号字符串字面量

str = """
    又来到某个港口
    我不是一定要你回来

"""
println("xix :$str")

• 常见的操作

# findfirst 获取字符串中是否有相应的字符 如果有返回第一个匹配到的字符下标
flag = findfirst(isequal('0'), "OOOOOOOOOO0OOOOOOO0oo")
println(flag)

# findfirst 获取字符串中是否有相应的字符 如果有返回最后一个匹配到的字符下标
flag = findlast(isequal('0'), "OOOOOOOOOO0OOOOOOO0oo")
println(flag)


# findnext 字符串偏移 之后进行匹配 偏移到从第15个开始
flag = findnext(isequal('0'), "OOOOOOOOOO0OOOOOOO0oo", 15)
println(flag)


# 判断字符是否存在在字符串中 返回bool值
flag = occursin("123", "1233123133")
println(flag)

# 切片拆分 以, 间隔 
join(["apples", "bananas", "pineapples"], ", ", " and ") "apples, bananas and pineapples"

函数

在Julia中，函数是将一个参数值元祖映射到返回值的对象。Julia的函数不是说纯粹的数学函数，在某种意义上，函数可以改变并受程序的全局状态的影响。在Julia中定义函数的基本语法是：

• 函数基本语法

function f(x, y)
    return x + y

    end
println(f(1,2))


# 函数还可以进行缩写 简洁语法
foo(x, y) = x * y
println(foo(2,3))

• 函数指定返回类型

function bar(x, y)::Int64
    return x * y
    end

println(
bar(3, 5))

• 元祖

Julia有一个和函数参数与返回值密切相关的内置数据结构叫元祖。一个元祖是一个固定的长度的容器，可以容纳任何值。但是不可以被修改

yuanzu = (1,2,2,3,3)
println(typeof(yuanzu))

>>> NTuple{5, Int64}

• 具名元祖

元祖的元素可以有名字。

x = (a=2, b=2^2)
println(x.a)
# 或者 x[1]
>>> 2

• 多返回值

Julia中一个函数可以返回多个值 ，使用元祖来表示

function foo(a, b)
    return a + b, a * b
end

println(foo(2,3))
>>>(5, 6)

• 变参函数

function bar(a, b, x...)
    return a, b, x

end

println(bar(1, 2, 3,3,4,4))

>>>(1, 2, (3, 3, 4, 4))

• 日期内置函数

# 导入日期库
using Dates
println(Date(2021, 1, 10))
# >>> 2021-01-10

println(Date(2021,2))
# >>> 2021-02-01

println(Date(2021))
# >>> 2021-01-01

• 关键字参数

# 关键字参数
function plot(a, b, c=2)
    println("$a, $b, $c")

end
 
plot(6, 8, 1)
>>> 6, 8, 1

plot(6, 8)
>>> 6, 8, 2

• 函数参数中的Do结构

map([1, 2, 3]) do x
    if x < 0&& iseven(x) # iseven功能是判断这个参数是否被2整除
        return 0
    elseif  x == 0
        return 1
    else
        return x
    end
end

# 程序会将map中的值遍历赋值为x

• Julia读写文件操作

open("test.txt", "w") do io
    write(io, "123")
    end

# convert("需要转换的类型", 数据data)  convert可以将数据转换成相关的数据
open("test.txt", "r") do io
    line = readline(io)
    println(line)
    end

# 循环读取字符串  一定要记得if for等语句需要使用end结束
open("test.txt", "r") do io
    line = readline(io)
    println(line)
    for i in line
        println(i)
        end
    end

• 向量化函数的点语法

# 函数向量化的.点语法 a => A  list => tsil  of => Of  strings => 7
test_list = ["a", "list", "of", "strings"] .|> [uppercase, reverse, titlecase, length]
println(test_list)

流程控制

Julia提供了大量的流程控制构件

• 复合表达式：begin 和 ;

z = begin
    x=2
    y=3
    x+y

end
println(z)

z = (x=1; y=2; x+y)
println(z)

• 条件表达式：if - elseif - else 和？:（三元运算符）

# if else 不做太多解释
if 条件
  println
elseif 条件
  println
else
  println
end

• 短路求值：&& || 和链式比较

# and 和 or 也不做太多解释
• 在表达式 a && b 中，子表达式 b 仅当 a 为 true 的时候才会被执行。
• 在表达式 a || b 中，子表达式 b 仅在 a 为 false 的时候才会被执行。

• 重复执行：循环 while for

# while 循环 从0 到100
i = 0
while i <= 100
     println(i)
     global i+=1
    end


# for 循环从1到100
for i = 1:100
    println(i)

end


# 循环列表
for i in [1,2,3]
    println(i)
end

• 异常处理 try-catch error 和 throw

当一个意外的报错发生时，会抛出Exception。下面列出的内置exception会中断程序的正常运行流程

Exception

ArgumentError

BoundsError

CompositeException

DimensionMismatch

DivideError

DomainError

EOFError

ErrorException

InexactError

InitError

InterruptException

InvalidStateException

KeyError

注: 上述为常见的异常

​ - throw函数

​ throw函数就是Python中的raise 、Go中的panic 主动抛出异常

​ - try/catch语句

​ 通过try/catch 语句可以测试Exception并优雅的处理可能会破坏程序运行的代码。

try
  	# 可能会出现异常的代码包含在这里
    throw(InitError)

catch
    println("success")
end

# finally版本
try
    throw(InitError)

catch
    println("success")

finally
    println("finally success")
    throw(InitError)
end

• task协程 ： yieldto

详情查看https://www.geek-book.com/src/docs/julia/julia/docs.julialang.org/en/v1/base/parallel/index-2.html

变量作用域

变量的作用于是代码的一个区域，在这个区域中的这个变量是可见的。给变量划分作用于有助于解决变量命名重复冲突。这个概念是符合直觉的

Julia的变量作用域

作用于结构

结构	作用于类型	Allowed within
module ， baremodule	全局	全局
struct 结构体	local（soft）	全局
for， while ，try	local（soft）	全局或局部
macro	local（hard）	全局
let ，functions， comprehensions， generators	local（hard）	全局或局部
注：begin块和if块不会引入新的作用域块

Julia使用词法作用域，也就是说一个函数的作用域不会从其调用者的作用域继承，而从函数定义处的作用于继承。example

module Bar
    x = 1
    foo() = x
end


import .Bar
x = -1
println(Bar.foo())
>>> 1 

• 全局作用域

  每个模块会引进新的全局作用域，与其他所有模块的全局作用域分开；无所不包的全局作用域不存在。

  模块可以把其他模块的变量引入到自己的作用域中，通过using或者import语句或者通过.点符号有这种通路，也就是每个模块都是所谓的命名空间。

• let块

  不像局部变量的赋值行为，let语句每次运行都会新建一个变量进行绑定。赋值改变的是已存在值的位置，let会新建新的位置。这个区别通常都不重要，只会在通过闭包跳出作用于的变量的情况下能探测到。let语法接受由逗号隔开的一系列的赋值和变量名：

  let x = 1
      let
          local x=2
          println(x)
      end
      println(x)
  end
  

  通过for循环或者推倒式的迭代变量始终是一个新的变量：

  function  f()
      i = 0
      for outer i = 1:3
  
      end
      println(i)
  end
  
  f()
  

• 变量

  变量的经常的一个使用方式是给一个特定的不变的值一个名字，这样的变量只会被赋值一次且不能修改，关键字为const。const说明只应该在全局作用域中对全局 变量使用。

  const c, d = 1, 2
  println("a:$c, b:$d")
  

数据类型

​ Julia语言系统是动态的，但通过允许指出某些变量具体的数据类型，获得了静态类型系统的一些优点。这对于生成高效的代码非常有帮助，但更重要的是，它允许针对函数参数类型的方法派发与语言深度集成。方法派发将在方法中详细探讨，但他根植于此系统的类型系统。

​ 在类型被省略时，Julia默认行为是允许变量可以为任何类型。因此可以像Python一样无需明确的声明变量的数据类型.

类型声明

:: 运算符可以用来在程序中声明类型也就是 类型注释 可以提升性能 , 在某些场景下

println(1+2 :: Int)

function foo()::Int8

#     a :: String = "211"
    return 122
end

println(typeof(foo()))
>>> Int8

抽象类型

抽象类型不能实例化，只能作为类型图中的节点使用，从而描述由相关具体类型组成的集合：那些作为其后代的具体类型。

Julia的变量作用域

作用于结构

结构	作用于类型	Allowed within
module ， baremodule	全局	全局
struct 结构体	local（soft）	全局
for， while ，try	local（soft）	全局或局部
macro	local（hard）	全局
let ，functions， comprehensions， generators	local（hard）	全局或局部

Julia与Python的区别

• 切片 Julia 索引从1开始 Python从0开始
• Python切片左开右闭 julia 左右全闭
• Julia不支持负数索引
• Julia的条件语句 使用end结束 Python是以缩进结束

持续更新ing...