朱莉娅 - 快速指南

---

朱莉娅 - 概述

什么是 Julia 编程语言？

关于科学编程的事实之一是它需要高性能、灵活的动态编程语言。不幸的是，在很大程度上，领域专家已经转向速度较慢的动态编程语言。使用这种动态编程语言可能有很多充分的理由，事实上，它们的使用也不能减少。另一方面，我们可以从现代语言设计和编译器技术中期待什么？一些期望如下 -

• 它应该消除性能权衡。

• 它应该为领域专家提供一个足以进行原型设计的单一环境。

• 它应该为领域专家提供一个足够高效的单一环境来部署性能密集型应用程序。

Julia编程语言满足了这些期望。它是一种通用高性能灵活的编程语言，可用于编写任何应用程序。它非常适合科学和数值计算。

朱莉娅的历史

让我们从以下几点来了解 Julia 编程语言的历史 -

• Jeff Bezanson、Stefan Karpinski、Viral B. Shah 和 Alan Edelman 于 2009 年开始研究 Julia。

• 上述四人的开发团队于 2012 年 2 月 14 日推出了一个网站。该网站有一篇博客文章，主要解释 Julia 编程语言的使命。

• 2012 年 4 月晚些时候，Stefan Karpinski 在接受 InfoWorld 杂志采访时将他们的编程语言命名为“Julia”。

• 2014年，名为“The JuliaCon”的Julia年度学术会议；用户和开发者已经启动，此后每年定期举行。

• 2014年8月，Julia Version 0.3发布使用。

• 2015年10月，Julia Version 0.4发布使用。

• 2016年10月，Julia Version 0.5发布使用。

• 2017 年 6 月，Julia 版本 0.6 发布使用。

• Julia 版本 0.7 和版本 1.0 均于 2018 年 8 月 8 日同一天发布。其中 Julia 版本 0.7 对于测试包以及想要升级到版本 1.0 的用户特别有用。

• Julia 版本 1.0.x 是仍受支持的最旧版本。

• 2019年1月，Julia 1.1版本发布使用。

• 2019年8月，Julia 1.2版本发布使用。

• 2019年11月，Julia 1.3版本发布使用。

• 2020年3月，Julia 1.4版本发布使用。

• 2020年8月，Julia 1.5版本发布使用。

朱莉娅的特点

以下是 Julia 提供的一些特性和功能 -

• Julia 为我们提供了一个低调但强大且动态的类型系统。

• 借助多重分派，用户可以跨多种参数组合定义函数Behave。

• 它具有强大的 shell，使 Julia 能够轻松管理其他进程。

• 用户无需任何包装器或任何特殊 API 即可调用 C 函数。

• Julia 为 Unicode 提供了有效的支持。

• 它还为用户提供类似 Lisp 的宏以及其他元编程过程。

• 它提供了轻量级的绿色线程，即协程。

• 它非常适合并行性和分布式计算。

• 在 Julia 中完成的编码速度很快，因为不需要为了性能而对代码进行矢量化。

• 它可以有效地与其他编程语言（例如 Python、R 和 Java）交互。例如，它可以使用 PyCall 与 Python 交互，使用 RCall 与 R 交互，以及使用 JavaCall 与 Java 交互。

朱莉娅的范围

Julia 的核心设计师和开发人员 Jeff Bezanson、Stefan Karpinski、Viral B. Shah 和 Alan Edelman 明确表示，Julia 的明确设计目的是为了弥补技术计算学科中现有软件工具集中的以下差距：

原型设计- 原型设计是技术计算学科中的一个此类问题，需要一种高级且灵活的编程语言，以便开发人员不必担心计算和编程语言本身的低级细节。

性能- 实际计算需要最大性能。编程语言的生产版本通常应该用“ Fortran ”或“ C ”编程语言编写。

速度- 技术领域的另一个重要问题是速度。在 Julia 之前，程序员需要掌握高级编程（用 Matlab、R 或 Python 编写代码进行原型设计）和低级编程（编写程序中对性能敏感的部分，以加快实际计算速度） ，采用统计编译语言，如 C 或 Fortran）。

Julia 编程语言为实践者提供了编写高性能程序的可能性，这些程序像 C 或 Fortran 一样有效地使用 CPU 和内存等计算机资源。从这个意义上说，Julia 减少了对低级编程语言的需求。Julia、LLVM JIT（低级虚拟机即时）编译器技术的最新进展证明，在具有表达能力和纯粹速度的环境中工作是可能的。

与其他语言的比较

数据科学家的目标之一是实现表达能力和纯粹的速度，从而避免使用“C”编程语言。Julia 为程序员提供了一个技术计算的新时代，他们可以用高级编程语言开发库。

以下是 Julia 与最常用的编程语言（Matlab、R 和 Python）的详细比较：

MATLAB - Julia 的语法与 MATLAB 类似，但与 MATLAB 相比，它是一种更加通用的语言。尽管 Julia 中的大多数函数名称类似于 OCTAVE（MATLAB 的开源版本），但计算却截然不同。在线性代数领域，Julia 拥有与 MATLAB 同样强大的功能，但不会给用户带来同样的许可费用问题。与 OCTAVE 相比，Julia 也快得多。MATLAB.Jl是 Julia 提供 MATLAB 接口的软件包。

Python - Julia 将类似 Python 的代码编译为机器代码，为程序员提供与 C 编程语言相同的性能。如果我们比较 Julia 和 Python 的性能，Julia 领先 10 到 30 倍。借助 PyCall 包，我们可以在 Julia 中调用 Python 函数。

R - 众所周知，在统计领域，R 是最好的开发语言之一，但随着性能提高 10 到 1,000 倍，Julia 在统计领域与 R 一样可用。MATLAB 不适合做统计，R 也不适合做线性代数，但 Julia 非常适合做统计和线性代数。另一方面，如果我们将 Julia 的类型系统与 R 进行比较，前者的类型系统要丰富得多。

Julia 编程 - 环境设置

要安装 Julia，我们需要下载可执行形式的二进制 Julia 平台，您可以从链接https://julialang.org/downloads/下载。在网页上，您将找到适用于所有三个主要平台（即 Linux、Windows 和 Macintosh (OS X)）的 32 位和 64 位格式的 Julia。我们要使用的当前稳定版本是 v1.5.1。

安装朱莉娅

让我们看看如何在各种平台上安装 Julia -

Linux 和 FreeBSD 安装

下面给出的命令集可用于将最新版本的 Julia 编程语言下载到目录中，假设是 Julia-1.5.1 -

wget https://julialang-s3.julialang.org/bin/linux/x64/1.5/julia-1.5.1-linux-x86_64.tar.gz
tar zxvf julia-1.5.1-linux-x86_64.tar.gz

安装后，我们可以执行以下任意操作来运行 Julia -

• 使用 Julia 的完整路径<Julia 目录>/bin/Julia来调用 Julia 可执行文件。这里<Julia目录>指的是您计算机上安装Julia的目录。

• 您还可以创建到 Julia 编程语言的符号链接。该链接应该位于系统PATH上的文件夹内。

• 您可以通过编辑~/.bashrc或~/.bash_profile文件将 Julia 的 bin 文件夹及其完整路径添加到系统 PATH 环境变量。可以通过在任何编辑器中打开文件并添加下面给出的行来完成：

export PATH="$PATH:/path/to/<Julia directory>/bin"

Windows安装

根据 Windows 规范下载安装程序后，运行安装程序。建议记下安装目录，如下所示：C:\Users\Ga\AppData\Local\Programs\Julia1.5.1。

要通过在 cmd 中输入Julia来调用 Julia 编程语言，我们必须将 Julia 可执行目录添加到系统 PATH 中。您需要根据您的 Windows 规格执行以下步骤 -

在 Windows 10 上

• 首先使用快捷键 Windows 键 + R打开“运行” 。

• 现在，输入rundll32 sysdm.cpl、EditEnvironmentVariables并按 Enter 键。

• 现在，我们将在“用户变量”或“系统变量”下找到带有“路径”的行。

• 现在单击编辑按钮以获取“编辑环境变量”UI。

• 现在，单击“新建”并粘贴我们在安装时记下的目录地址（C:\Users\Ga\AppData\Local\Programs\Julia1.5.1\bin）。

• 最后单击“确定”，Julia 就可以通过键入 Julia 从命令行运行。

在 Windows 7 或 8 上

• 首先使用快捷键 Windows 键 + R打开“运行”。

• 现在，输入rundll32 sysdm.cpl、EditEnvironmentVariables并按 Enter 键。

• 现在，我们将在“用户变量”或“系统变量”下找到带有“路径”的行。

• 单击编辑按钮，我们将获得“编辑环境变量”UI。

• 现在将光标移动到该字段的末尾并检查末尾是否有分号。如果找不到，则添加分号。

• 添加后，我们需要粘贴我们在安装时记下的目录地址（C:\Users\Ga\AppData\Local\Programs\Julia1.5.1\bin）。

• 最后单击“确定”，Julia 就可以通过键入 Julia 从命令行运行。

macOS安装

在 macOS 上，将提供一个名为Julia-<version>.dmg的文件。该文件包含Julia-<version>.app，您需要将此文件拖到应用程序文件夹快捷方式。运行 Julia 的另一种方法是通过打开应用程序从磁盘映像中运行。

如果您想从终端运行 Julia，请输入以下给出的命令 -

ln -s /Applications/Julia-1.5.app/Contents/Resources/julia/bin/julia /usr/local/bin/julia

此命令将创建指向我们选择的 Julia 版本的符号链接。现在关闭 shell 配置文件页面并退出终端。现在再次打开终端并在其中输入 julia，您将使用您的Julia编程语言版本。

从源代码构建 Julia

要从源代码而不是二进制文件构建 Julia，我们需要遵循以下给出的步骤。在这里，我们将概述 Ubuntu 操作系统的过程。

• 从 GitHub 下载源代码：https://github.com/JuliaLang/julia。

• 编译它，你将得到最新版本。它不会给我们稳定版本。

• 如果您没有安装 git，请使用以下命令进行安装 -

sudo apt-get -f install git

使用以下命令克隆 Julia 源 -

git clone git://github.com/JuliaLang/julia.git

上面的命令会将源代码下载到当前文件夹中的 julia 目录中。

现在，通过使用下面给出的命令，安装 GNU 编译工具 g++、gfortran 和 m4 -

sudo apt-get install gfortran g++ m4

安装完成后，开始编译过程如下 -

cd Julia
make

之后，成功构建 Julia 编程语言将通过 ./julia 命令启动。

朱莉娅的工作环境

REPL（读取-评估-打印循环）是Julia的工作环境。借助这个 shell，我们可以与 Julia 的 JIT（Just in Time）编译器交互来测试和运行我们的代码。我们还可以将代码复制并粘贴到.jl扩展名中，例如first.jl。另一种选择是使用文本编辑器或 IDE。让我们看看下面的 REPL -

单击 Julia 徽标后，我们将收到Julia> 的提示，要求您编写我们的代码或程序。使用exit()或CTRL + D结束会话。如果要计算表达式，请在输入后按 Enter。

套餐

Julia 中的几乎所有标准库都是用 Julia 本身编写的，但 Julia 代码生态系统的其余部分可以在包（即Git存储库）中找到。下面给出了有关 Julia 包的一些要点 -

• 包提供可重用的功能，可供其他 Julia 项目轻松使用。

• Julia 有内置的包管理器，名为pkg.jl，用于包安装。

• 包管理器处理包的安装、删除和更新。

• 仅当包位于 REPL 中时，包管理器才起作用。

安装软件包

步骤 1 - 首先打开 Julia 命令行。

步骤 2 - 现在按 ] 打开 Julia 包管理环境。您将得到以下控制台 -

您可以检查https://juliaobserver.com/packages 以查看我们可以在 Julia 上安装哪些软件包。

添加包

要在 Julia 环境中添加包，我们需要使用带有包名称的add命令。例如，我们将添加名为Graphs的包，该包用于在 Julia 中处理图形。

删除包

要从 Julia 中删除包，我们需要使用rm命令和包的名称。例如，我们将删除名为Graphs 的包，如下所示 -

更新包

要更新 Julia 包，您可以使用 update 命令，这将更新所有 Julia 包，也可以使用 up 命令和包名称，这将更新特定包。

测试包

使用test命令来测试 Julia 包。例如，下面我们测试了 JSON 包 -

安装 IJulia

要安装 IJulia，请在 Julia 包环境中使用add IJulia命令。我们需要确保您已在计算机上预安装了 Anaconda。安装完成后，打开 Jupyter Notebook 并选择 Julia1.5.1，如下所示 -

现在您将能够使用 IJulia 编写 Julia 程序，如下所示 -

安装朱诺

Juno 是 Julia 编程语言的强大 IDE。它是免费的，安装步骤如下：

步骤 1 - 首先我们需要在我们的系统上安装 Julia。

步骤 2 - 现在您需要从 这里安装 Atom 。必须更新（版本 1.41+）。

步骤 3 - 在 Atom 中，转到设置，然后安装面板。它将为您安装 Juno。

步骤 4 - 通过使用 Juno > open REPL 命令打开 REPL 开始在 Juno 中工作。

Julia 编程 - 基本语法

最简单的第一个 Julia 程序（以及许多其他编程语言）是打印hello world。脚本如下 -

如果您已将 Julia 添加到路径中，则可以将相同的脚本保存在文件hello.jl中，并可以通过在命令提示符下键入 Julia hello.jl来运行。或者，也可以通过键入include(“hello.jl”)从 Julia REPL 运行相同的内容。该命令将计算所有有效表达式并返回最后的输出。

变量

计算机程序最简单的定义是什么？最简单的可能是计算机程序是对各种数据执行的一系列指令。

这里的数据可以是人名、地点、人的门牌号，甚至是你所做的事情的列表。在计算机编程中，当我们需要标记这些信息时，我们给它一个名称（比如A）并称之为变量。从这个意义上说，我们可以说变量是一个包含数据的盒子。

让我们看看如何将数据分配给变量。非常简单，只需输入即可。例如，

student_name = “Ram”
roll_no = 15
marks_math = 9.5

这里，第一个变量即student_name包含一个字符串，第二个变量即roll_no包含一个数字，第三个变量即marks_math包含一个浮点数。我们看到，与其他编程语言如C++、Python等不同，在Julia中我们不必指定变量的类型，因为它可以推断等号右侧对象的类型。

文体约定和允许的变量名称

以下是变量名称的一些约定 -

• Julia 中变量的名称区分大小写。因此，变量Student_name和Student_name不会相同。

• Julia 中的变量名称应始终以字母开头，之后我们可以使用数字、字母、下划线等任何内容。

• 在 Julia 中，通常使用小写字母，多个单词之间用下划线分隔。

• 我们应该为变量使用清晰、简短、切中要点的名称。

• 一些有效的 Julia 变量名称包括Student_name、roll_no、speed、current_time。

评论

在 Julia 中编写注释与 Python 非常相似。根据用法，注释有两种类型 -

单行评论

在 Julia 中，单行注释以 # （井号标签）符号开头，一直持续到该行的末尾。假设如果您的注释超过一行，那么您也应该在下一行添加 # 符号并可以继续注释。下面给出的是显示单行注释的代码片段 -

例子

julia> #This is an example to demonstrate the single lined comments.
julia> #Print the given name

多行注释

在 Julia 中，多行注释是一段文本，就像单行注释一样，但它在注释的开头用分隔符 #= 括起来，在注释的末尾用分隔符 =# 括起来。下面给出的是显示多行注释的代码片段 -

例子

julia> #= This is an example to demonstrate the multi-line comments that tells us about tutorialspoint.com. At this website you can browse the best resource for Online Education.=#
julia> print(www.tutorialspoint.com)

朱莉娅 - 数组

数组是一组有序的元素，通常用具有逗号分隔项的方括号指定。我们可以创建数组 -

• 满或空

• 保存不同类型的值

• 仅限于特定类型的值

在 Julia 中，数组实际上是可变类型集合，用于列表、向量、表和矩阵。这就是为什么 Julia 中的数组值可以使用某些预定义的关键字进行修改。借助推力！命令您可以在数组中添加新元素。同样，在 splice 的帮助下！函数可以在数组中的指定索引处添加元素。

创建简单的一维数组

以下示例展示了如何创建一个简单的一维数组 -

julia> arr = [1,2,3]
3-element Array{Int64,1}:
 1
 2
 3

上面的示例显示我们创建了一个包含 3 个元素的一维数组，每个元素都是 64 位整数。该一维数组绑定到变量arr。

未初始化的数组

我们还可以使用以下语法指定数组的类型和维度 -

Array{type}(dims)

以下是未初始化数组的示例 -

julia> array = Array{Int64}(undef, 3)
3-element Array{Int64,1}:
 0
 0
 0

julia> array = Array{Int64}(undef, 3, 3, 3)
3×3×3 Array{Int64,3}:
[:, :, 1] =
 8  372354944   328904752
 3  331059280   162819664
 32  339708912           1
  
[:, :, 2] =
 331213072           3   331355760
         1   328841776   331355984
        -1   328841680           2
[:, :, 3] =
         1           0   339709232
 164231472   328841872   347296224
 328841968   339709152   16842753

在这里，我们将类型放在花括号中，将尺寸放在括号中。我们使用 undef 这意味着特定数组尚未初始化为任何已知值，这就是我们在输出中得到随机数的原因。

任何东西的数组

Julia 使我们可以自由地创建包含不同类型元素的数组。让我们看下面的示例，我们将在其中创建奇数混合数组 - 数字、字符串、函数、常量 -

julia> [1, "TutorialsPoint.com", 5.5, tan, pi]
5-element Array{Any,1}:
 1
  "TutorialsPoint.com"
 5.5
  tan (generic function with 12 methods)
 π = 3.1415926535897...

空数组

就像创建特定类型的数组一样，我们也可以在 Julia 中创建空数组。下面给出了示例 -

julia> A = Int64[]
Int64[]

julia> A = String[]
String[]

创建二维数组和矩阵

省略元素之间的逗号，您将在 Julia 中获得二维数组。下面是单行多列数组的示例 -

julia> [1 2 3 4 5 6 7 8 9 10]
1×10 Array{Int64,2}:
 1 2 3 4 5 6 7 8 9 10

这里，1×10是该数组的第一行。

要添加另一行，只需添加分号 (;)。让我们检查下面的例子 -

julia> [1 2 3 4 5 ; 6 7 8 9 10]
2×5 Array{Int64,2}:
 1  2   3    4   5
 6  7   8    9  10

这里就变成了2×5的数组。

使用范围对象创建数组

我们可以通过以下方式使用范围对象创建数组 -

收集（）函数

使用范围对象创建数组的第一个有用函数是collect()。在 colon(:) 和collect() 函数的帮助下，我们可以使用范围对象创建一个数组，如下所示 -

julia> collect(1:5)
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

我们还可以使用浮点范围对象创建数组 -

julia> collect(1.5:5.5)
5-element Array{Float64,1}:
 1.5
 2.5
 3.5
 4.5
 5.5

让我们看看范围对象的三部分版本，借助它您可以指定 1 以外的步长大小。

其语法如下 -

start:step:stop.

下面是一个构建数组的示例，其元素从 0 到 50，步长为 5 -

julia> collect(0:5:50)
11-element Array{Int64,1}:
 0
 5
 10
 15
 20
 25
 30
 35
 40
 45
 50 

省略号(…) 或 splat 运算符

我们还可以在最后一个元素后面使用 splat 运算符或省略号（…），而不是使用collect（）函数。以下是一个例子 -

julia> [0:10...]
11-element Array{Int64,1}:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

range() 函数

Range() 是另一个有用的函数，用于创建包含范围对象的数组。它通过采用特定的步长值从起始值到最终值。

例如，让我们看一个从 1 到 150 只需 15 个步骤的示例 -

julia> range(1, length=15, stop=150)
1.0:10.642857142857142:150.0

Or you can use range to take 10 steps from 1, stopping at or before 150:
julia> range(1, stop=150, step=10)
1:10:141

我们可以使用 range() 和collect() 来构建一个数组，如下所示 -

julia> collect(range(1, length=15, stop=150))
15-element Array{Float64,1}:
 1.0
 11.642857142857142
 22.285714285714285
 32.92857142857143
 43.57142857142857
 54.214285714285715
 64.85714285714286
 75.5
 86.14285714285714
 96.78571428571429
 107.42857142857143
 118.07142857142857
 128.71428571428572
 139.35714285714286
 150.0

使用推导式和生成器创建数组

创建数组的另一种有用方法是使用推导式。通过这种方式，我们可以创建数组，其中每个元素都可以使用少量计算来生成。例如，我们可以创建一个包含 10 个元素的数组，如下所示 -

julia> [n^2 for n in 1:10]
10-element Array{Int64,1}:
 1
 4
 9
 16
 25
 36
 49
 64
 81
 100

我们也可以轻松创建一个二维数组，如下所示 -

julia> [n*m for n in 1:10, m in 1:10]
10×10 Array{Int64,2}:
 1  2  3  4  5  6  7  8  9  10
 2  4  6  8  10 12 14 16 18 20
 3  6  9  12 15 18 21 24 27 30
 4  8  12 16 20 24 28 32 36 40
 5  10 15 20 25 30 35 40 45 50
 6  12 18 24 30 36 42 48 54 60
 7  14 21 28 35 42 49 56 63 70
 8  16 24 32 40 48 56 64 72 80
 9  18 27 36 45 54 63 72 81 90
 10 20 30 40 50 60 70 80 90 100

与理解类似，我们可以使用生成器表达式来创建数组 -

julia> collect(n^2 for n in 1:5)
5-element Array{Int64,1}:
 1
 4
 9
 16
 25

生成器表达式不会构建数组来首先保存值，而是在需要时生成值。因此它们比推导式更有用。

填充数组

以下是您可以使用特定内容创建和填充数组的帮助的函数 -

零点 (m, n)

该函数将创建具有 m 行和 n 列的零矩阵。下面给出了示例 -

julia> zeros(4,5)
4×5 Array{Float64,2}:
 0.0 0.0 0.0 0.0 0.0
 0.0 0.0 0.0 0.0 0.0
 0.0 0.0 0.0 0.0 0.0
 0.0 0.0 0.0 0.0 0.0

我们还可以指定零的类型，如下所示 -

julia> zeros(Int64,4,5)
4×5 Array{Int64,2}:
 0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0
 0 0 0 0

个（m，n）

该函数将创建 m 行和 n 列的矩阵。下面给出了示例 -

julia> ones(4,5)
4×5 Array{Float64,2}:
 1.0 1.0 1.0 1.0 1.0
 1.0 1.0 1.0 1.0 1.0
 1.0 1.0 1.0 1.0 1.0
 1.0 1.0 1.0 1.0 1.0

兰特 (m, n)

顾名思义，该函数将创建m 行和 n 列的随机数矩阵。下面给出了示例 -

julia> rand(4,5)
4×5 Array{Float64,2}:
 0.514061 0.888862 0.197132 0.721092    0.899983
 0.503034 0.81519  0.061025 0.279143    0.204272
 0.687983 0.883176 0.653474 0.659005    0.970319
 0.20116  0.349378 0.470409 0.000273225 0.83694

随机数 (m, n)

顾名思义，该函数将创建 m*n正态分布随机数矩阵，平均值 = 0，标准差 (SD) = 1。

julia> randn(4,5)
4×5 Array{Float64,2}:
 -0.190909 -1.18673    2.17422   0.811674  1.32414
  0.837096 -0.0326669 -2.03179   0.100863  0.409234
 -1.24511  -0.917098  -0.995239  0.820814  1.60817
 -1.00931  -0.804208   0.343079  0.0771786 0.361685

充满（）

该函数用于用特定值填充数组。更具体地说，它将创建一个重复重复值的数组。

julia> fill(100,5)
5-element Array{Int64,1}:
 100
 100
 100
 100
 100
 
julia> fill("tutorialspoint.com",3,3)
3×3 Array{String,2}:
"tutorialspoint.com" "tutorialspoint.com" "tutorialspoint.com"
"tutorialspoint.com" "tutorialspoint.com" "tutorialspoint.com"
"tutorialspoint.com" "tutorialspoint.com" "tutorialspoint.com"

充满！（）

它与 fill() 函数类似，但感叹号 (!) 表示或警告现有数组的内容将被更改。示例如下：

julia> ABC = ones(5)
5-element Array{Float64,1}:
 1.0
 1.0
 1.0
 1.0
 1.0
 
julia> fill!(ABC,100)
5-element Array{Float64,1}:
 100.0
 100.0
 100.0
 100.0
 100.0
 
julia> ABC
5-element Array{Float64,1}:
 100.0
 100.0
 100.0
 100.0
 100.0

数组构造函数

我们之前研究过的函数Array()可以构建特定类型的数组，如下所示 -

julia> Array{Int64}(undef, 5)
5-element Array{Int64,1}:
 294967297
 8589934593
 8589934594
 8589934594
          0

从输出中我们可以看到该数组尚未初始化。这些奇怪的数字是记忆中的旧内容。

数组的数组

以下示例演示了创建数组的数组 -

julia> ABC = Array[[3,4],[5,6]]
2-element Array{Array,1}:
 [3, 4]
 [5, 6]

它也可以在数组构造函数的帮助下创建，如下所示 -

julia> Array[1:5,6:10]
2-element Array{Array,1}:
 [1, 2, 3, 4, 5]
 [6, 7, 8, 9, 10]

复制数组

假设您有一个数组并想要创建另一个具有相似维度的数组，那么您可以使用similar()函数，如下所示 -

julia> A = collect(1:5);
Here we have hide the values with the help of semicolon(;)

julia> B = similar(A)
5-element Array{Int64,1}:
 164998448
 234899984
 383606096
 164557488
 396984416

这里复制了数组 A 的维度，但没有复制值。

矩阵运算

我们知道，二维 (2D) 数组可以用作矩阵，因此所有可用于数组的函数也可以用作矩阵。条件是尺寸和内容允许。如果要输入矩阵，请使用空格来构成行并使用分号 (;) 来分隔行，如下所示 -

julia> [2 3 ; 4 5]
2×2 Array{Int64,2}:
 2 3
 4 5

以下是通过将两个数组彼此相邻放置来创建数组的数组（如我们之前所做的）的示例 -

julia> Array[[3,4],[5,6]]
2-element Array{Array,1}:
 [3, 4]
 [5, 6]

下面我们可以看到当我们省略逗号并将列彼此相邻放置时会发生什么 -

julia> [[3,4] [5,6]]
2×2 Array{Int64,2}:
 3 5
 4 6

访问数组的内容

在 Julia 中，要访问数组的内容/特定元素，您需要在方括号中写下数组的名称和元素编号。

下面是一维数组的示例 -

julia> arr = [5,10,15,20,25,30,35,40,45,50]
10-element Array{Int64,1}:
 5
 10
 15
 20
 25
 30
 35
 40
 45
 50
julia> arr[4]
20

在某些编程语言中，数组的最后一个元素称为 -1。然而，在 Julia 中，它被称为end。您可以按如下方式找到数组的最后一个元素 -

julia> arr[end]
50

倒数第二个元素如下 -

julia> arr[end-1]
45

为了一次访问多个元素，我们还可以提供一堆索引号，如下所示 -

julia> arr[[2,5,6]]
3-element Array{Int64,1}:
 10
 25
 30

我们甚至可以通过提供 true 和 false 来访问数组元素 -

julia> arr[[true, false, true, true,true, false, false, true, true, false]]
6-element Array{Int64,1}:
 5
 15
 20
 25
 40
 45

现在让我们访问二维元素。

julia> arr2 = [10 11 12; 13 14 15; 16 17 18]
3×3 Array{Int64,2}:
 10 11 12
 13 14 15
 16 17 18
julia> arr2[1]
10

下面的命令将给出 13，而不是我们预期的 11。

julia> arr2[2]
13

要访问 row1、column2 元素，我们需要使用以下命令 -

julia> arr2[1,2]
11

同样，对于 row1 和 column3 元素，我们必须使用以下命令 -

julia> arr2[1,3]
12

我们还可以使用getindex()函数从二维数组中获取元素 -

julia> getindex(arr2,1,2)
11

julia> getindex(arr2,2,3)
15

添加元素

我们可以分别使用push!()、pushfirst!() 和 splice!()函数将元素添加到 Julia 数组的末尾、前面和给定索引处。

在最后

我们可以使用push!()函数在数组末尾添加一个元素。例如，

julia> push!(arr,55)
11-element Array{Int64,1}:
 5
 10
 15
 20
 25
 30
 35
 40
 45
 50
 55

请记住，数组 arr 中有 10 个元素。现在，push!()函数将元素 55 添加到该数组的末尾。

感叹号（！）表示该函数将更改数组。

在前面

我们可以使用pushfirst!()函数在数组的前面添加一个元素。例如，

julia> pushfirst!(arr,0)
12-element Array{Int64,1}:
 0
 5
 10
 15
 20
 25
 30
 35
 40
 45
 50
 55

在给定索引处

我们可以使用splice!()函数将元素添加到数组中给定索引处。例如，

julia> splice!(arr,2:5,2:6)
4-element Array{Int64,1}:
 5
 10
 15
 20

julia> arr
13-element Array{Int64,1}:
 0
 2
 3
 4
 5
 6
 25
 30
 35
 40
 45
 50
 55

删除元素

我们可以分别使用pop!()、popfirst!() 和 splice!()函数从 Julia 中的数组中删除最后一个位置、第一个位置和给定索引处的元素。

删除最后一个元素

我们可以使用pop!()函数删除数组的最后一个元素。例如，

julia> pop!(arr)
55

julia> arr
12-element Array{Int64,1}:
 0
 2
 3
 4
 5
 6
 25
 30
 35
 40
 45
 50

删除第一个元素

我们可以使用popfirst!()函数删除数组的第一个元素。例如，

julia> popfirst!(arr)
0

julia> arr
11-element Array{Int64,1}:
 2
 3
 4
 5
 6
 25
 30
 35
 40
 45
 50

删除给定位置的元素

我们可以使用splice!()函数从数组的给定位置删除元素。例如，

julia> splice!(arr,5)
6

julia> arr
10-element Array{Int64,1}:
 2
 3
 4
 5
 25
 30
 35
 40
 45
 50

朱莉娅 - 元组

与数组类似，元组也是元素的有序集合。元组的工作方式与数组几乎相同，但它们之间有以下重要区别 -

• 数组由方括号表示，而元组由括号和逗号表示。

• 元组是不可变的。

创建元组

我们可以将元组创建为数组，并且大多数数组的函数也可以用于元组。下面给出了一些示例 -

julia> tupl=(5,10,15,20,25,30)
(5, 10, 15, 20, 25, 30)

julia> tupl
(5, 10, 15, 20, 25, 30)

julia> tupl[3:end]
(15, 20, 25, 30)

julia> tupl = ((1,2),(3,4))

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

julia> tupl[1]
(1, 2)

julia> tupl[1][2]
2

We cannot change a tuple:
julia> tupl[2]=0
ERROR: MethodError: no method matching setindex!(::Tuple{Tuple{Int64,Int64},Tuple{Int64,Int64}}, ::Int64, ::Int64)
Stacktrace:
 [1] top-level scope at REPL[7]:1

命名元组

命名元组只是元组和字典的组合，因为 -

• 命名元组像元组一样是有序且不可变的

• 就像命名元组中的字典一样，每个元素都有一个可用于访问它的唯一键。

在下一节中，让我们看看如何创建命名元组 -

创建命名元组

您可以通过以下方式在 Julia 中创建命名元组：

• 在单独的元组中提供键和值

• 在单个元组中提供键和值

• 组合两个现有的命名元组

单独元组中的键和值

创建命名元组的一种方法是在单独的元组中提供键和值。

例子

julia> names_shape = (:corner1, :corner2)
(:corner1, :corner2)

julia> values_shape = ((100, 100), (200, 200))
((100, 100), (200, 200))

julia> shape_item2 = NamedTuple{names_shape}(values_shape)
(corner1 = (100, 100), corner2 = (200, 200))

我们可以使用点(.)语法访问元素 -

julia> shape_item2.corner1
(100, 100)

julia> shape_item2.corner2
(200, 200)

单个元组中的键和值

我们还可以通过在单个元组中提供键和值来创建命名元组。

例子

julia> shape_item = (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))
(corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))

我们可以使用点(.)语法访问元素 -

julia> shape_item.corner1
(1, 1)

julia> shape_item.corner2
(-1, -1)

julia> shape_item.center
(0, 0)

julia> (shape_item.center,shape_item.corner2)
((0, 0), (-1, -1))

我们还可以像普通元组一样访问所有值，如下所示 -

julia> c1, c2, center = shape_item
(corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))

julia> c1
(1, 1)

组合两个命名元组

Julia 为我们提供了一种通过将两个命名元组组合在一起来创建新命名元组的方法，如下所示 -

例子

julia> colors_shape = (top = "red", bottom = "green")
(top = "red", bottom = "green")

julia> shape_item = (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))
(corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0))

julia> merge(shape_item, colors_shape)
(corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0), top = "red", bottom = "green")

命名元组作为关键字参数

如果您想将一组关键字参数传递给函数，在 Julia 中命名元组是一种便捷的方法。以下是接受三个关键字参数的函数示例 -

julia> function ABC(x, y, z; a=10, b=20, c=30)
         println("x = $x, y = $y, z = $z; a = $a, b = $b, c = $c")
      end
ABC (generic function with 1 method)

还可以定义一个命名元组，其中包含一个或多个关键字的名称和值，如下所示 -

julia> options = (b = 200, c = 300)
(b = 200, c = 300)

为了将命名元组传递给我们需要使用的函数；调用函数时 -

julia> ABC(1, 2, 3; options...)
x = 1, y = 2, z = 3; a = 10, b = 200, c = 300

值和关键字也可以被后面的函数覆盖，如下所示 -

julia> ABC(1, 2, 3; b = 1000_000, options...)
x = 1, y = 2, z = 3; a = 10, b = 200, c = 300

julia> ABC(1, 2, 3; options..., b= 1000_000)
x = 1, y = 2, z = 3; a = 10, b = 1000000, c = 300

整数和浮点数

在任何编程语言中，都有算术和计算两个基本构建块。它们是整数和浮点值。整数和浮点值的内置表示称为数字基元。另一方面，它们在代码中表示为立即值，称为数字文字。

以下是整数和浮点文字的示例 -

• 100 是一个整数文字

• 100.50 是浮点文字

• 它们作为对象的内置内存表示是数字基元。

整数

Integer 是 Julia 中的原始数字类型之一。它表示如下 -

julia> 100
100

julia> 123456789
123456789

我们可以检查整数文字的默认类型，这取决于我们的系统是32位还是64位体系结构。

julia> Sys.WORD_SIZE
64

julia> typeof(100)
Int64

整数类型

下表显示了 Julia 中的整数类型 -

溢出Behave

在 Julia 中，如果超过给定类型的最大可表示值，则会导致环绕Behave。例如 -

julia> A = typemax(Int64)
9223372036854775807

julia> A + 1
-9223372036854775808

julia> A + 1 == typemin(Int64)
true

建议显式检查溢出产生的环绕，特别是在可能发生溢出的情况下。否则在任意精度算术中使用BigInt类型。

下面是溢出Behave的示例以及我们如何解决它 -

julia> 10^19
-8446744073709551616

julia> big(10)^19
10000000000000000000

除法错误

在以下两种特殊情况下，整数除法会抛出DivideError -

• 除以零

• 除最小的负数

rem（余数）和 mod（模数）函数只要第二个参数为零，就会抛出DivideError 。示例如下 -

julia> mod(1, 0)
ERROR: DivideError: integer division error
Stacktrace:
 [1] div at .\int.jl:260 [inlined]
 [2] div at .\div.jl:217 [inlined]
 [3] div at .\div.jl:262 [inlined]
 [4] fld at .\div.jl:228 [inlined]
 [5] mod(::Int64, ::Int64) at .\int.jl:252
 [6] top-level scope at REPL[52]:1
 
 
julia> rem(1, 0)
ERROR: DivideError: integer division error
Stacktrace:
 [1] rem(::Int64, ::Int64) at .\int.jl:261
 [2] top-level scope at REPL[54]:1

浮点数字

Julia 中的另一种原始数字类型是浮点数。它表示（需要时使用 E 表示法）如下 -

julia> 1.0
1.0

julia> 0.5
0.5

julia> -1.256
-1.256

julia> 2e11
2.0e11

julia> 3.6e-5
3.6e-5

以上结果均为Float64。如果我们想输入 Float32 文字，可以通过在e的位置写入f来编写它们，如下所示 -

julia> 0.5f-5
5.0f-6

julia> typeof(ans)
Float32

julia> 1.5f0
1.5f0

julia> typeof(ans)
Float32

浮点类型

下表显示了 Julia 中的浮点类型 -

浮点零

浮点零有两种，一种是正零，另一种是负零。它们是相同的，但它们的二进制表示不同。从下面的例子可以看出 -

julia> 0.0 == -0.0
true

julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"

julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"

特殊浮点值

下表表示三个指定的标准浮点值。这些浮点值不对应于实数轴上的任何点。

我们还可以应用 typemin 和 typemax 函数，如下所示 -

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

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

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

机器ε

机器 epsilon 是两个相邻的可表示浮点数之间的距离。了解机器 epsilon 很重要，因为大多数实数无法用浮点数精确表示。

在 Julia 中，我们有eps()函数，它可以给出 1.0 和下一个更大的可表示浮点值之间的距离。下面给出了示例 -

julia> eps(Float32)
1.1920929f-7

julia> eps(Float64)
2.220446049250313e-16

舍入模式

我们知道，如果数字没有精确的浮点表示，则应将其四舍五入为适当的可表示值。Julia 使用名为 RoundNearest 的默认模式。它四舍五入到最接近的整数，并四舍五入到最接近的偶数。例如，

julia> BigFloat("1.510564889",2,RoundNearest)
1.5

有理数和复数

在本章中，我们将讨论有理数和复数。

有理数

Julia 借助有理数类型表示整数的精确比率。让我们在接下来的章节中了解 Julia 中的有理数 -

构造有理数

在 Julia REPL 中，有理数是使用运算符 // 构造的。下面给出的是相同的示例 -

julia> 4//5
4//5

您还可以提取标准化分子和分母，如下所示 -

julia> numerator(8//9)
8

julia> denominator(8//9)
9

转换为浮点数

将有理数转换为浮点数非常容易。查看以下示例 -

julia> float(2//3)
0.6666666666666666
Converting rational to floating-point numbers does not loose the following identity for any integral values of A and B. For example:

julia> A = 20; B = 30;

julia> isequal(float(A//B), A/B)
true

复数

我们知道，全局常数im表示 -1 的主平方根，它与复数相关。Julia 中的这种绑定足以为复数提供方便的语法，因为 Julia 允许数字文字与作为系数的标识符进行对比。

julia> 2+3im
2 + 3im

执行标准算术运算

我们可以对复数执行所有标准算术运算。示例如下 -

julia> (2 + 3im)*(1 - 2im)
8 - 1im

julia> (2 + 3im)/(1 - 2im)
-0.8 + 1.4im

julia> (2 + 3im)+(1 - 2im)
3 + 1im

julia> (2 + 3im)-(1 - 2im)
1 + 5im

julia> (2 + 3im)^2
-5 + 12im

julia> (2 + 3im)^2.6
-23.375430842463754 + 15.527174176755075im

julia> 2(2 + 3im)
4 + 6im

julia> 2(2 + 3im)^-2.0
-0.059171597633136105 - 0.14201183431952663im

组合不同的操作数

Julia 中的提升机制确保组合不同类型的运算符可以在复数上正常工作。让我们借助以下示例来理解它 -

julia> 2(2 + 3im)
4 + 6im

julia> (2 + 3im)-1
1 + 3im

julia> (2 + 3im)+0.7
2.7 + 3.0im

julia> (2 + 3im)-0.7im
2.0 + 2.3im

julia> 0.89(2 + 3im)
1.78 + 2.67im

julia> (2 + 3im)/2
1.0 + 1.5im

julia> (2 + 3im)/(1-3im)
-0.7000000000000001 + 0.8999999999999999im

julia> 3im^3
0 - 3im

julia> 1+2/5im
1.0 - 0.4im

操纵复数值的函数

在 Julia 中，我们还可以借助标准函数来操作复数的值。下面给出了一些相同的例子 -

julia> real(4+7im) #real part of complex number
4

julia> imag(4+7im) #imaginary part of complex number
7

julia> conj(4+7im) # conjugate of complex number
4 - 7im

julia> abs(4+7im) # absolute value of complex number
8.06225774829855

julia> abs2(4+7im) #squared absolute value
65

julia> angle(4+7im) #phase angle in radians
1.0516502125483738

让我们在下面的例子中看看复数的初等函数的使用 -

julia> sqrt(7im) #square root of imaginary part
1.8708286933869707 + 1.8708286933869707im

julia> sqrt(4+7im) #square root of complex number
2.455835677350843 + 1.4251767869809258im

julia> cos(4+7im) #cosine of complex number
-358.40393224005317 + 414.96701031076253im

julia> exp(4+7im) #exponential of complex number
41.16166839296141 + 35.87025288661357im

julia> sinh(4+7im) #Hyperbolic sine value of complex number
20.573930095756726 + 17.941143007955223im

Julia - 基本运算符

在本章中，我们将讨论 Julia 中不同类型的运算符。

算术运算符

在 Julia 中，我们获得了所有数字基元类型的所有基本算术运算符。它还为我们提供了按位运算符以及标准数学函数综合集合的高效实现。

下表显示了 Julia 的原始数字类型支持的基本算术运算符 -

Julia 的提升系统使这些算术运算在参数类型的混合上自然而自动地工作。

例子

以下示例显示了算术运算符的使用 -

julia> 2+20-5
17

julia> 3-8
-5

julia> 50*2/10
10.0

julia> 23%2
1

julia> 2^4
16

按位运算符

下表显示了 Julia 的原始数字类型支持的按位运算符 -

例子

以下示例显示了按位运算符的使用 -

julia> ∼1009
-1010

julia> 12&23
4

julia> 12 & 23
4

julia> 12 | 23
31

julia> 12 ⊻ 23
27

julia> xor(12, 23)
27

julia> ∼UInt32(12)
0xfffffff3

julia> ∼UInt8(12)
0xf3

更新运算符

每个算术和按位运算符都有一个更新版本，可以通过在运算符后面立即放置等号 (=) 来形成。该更新运算符将运算结果分配回其左操作数。这意味着a +=1 等于a = a+1。

以下是所有二进制算术和位运算符的更新版本列表 -

• +=

• -=

• *=

• /=

• \=

• ÷=

• %=

• ^=

• &=

• |=

• ⊻=

• >>>=

• >>=

• <<=

例子

以下示例显示了更新运算符的使用 -

julia> A = 100
100

julia> A +=100
200

julia> A
200

矢量化“点”运算符

对于像 ^ 这样的每个二元运算，都有一个相应的“点”(.) 运算，该运算在整个数组上一一使用。例如，如果您尝试执行 [1, 2, 3] ^ 2，则它未定义，并且无法对数组进行平方。另一方面，[1, 2, 3] .^ 2 被定义为计算向量化结果。同样的意义，这个向量化的“点”运算符也可以与其他二元运算符一起使用。

例子

以下示例显示了“点”运算符的使用 -

julia> [1, 2, 3].^2
3-element Array{Int64,1}:
 1
 4
 9

数值比较运算符

下表显示了 Julia 的原始数字类型支持的数字比较运算符 -

例子

以下示例显示了数字比较运算符的使用 -

julia> 100 == 100
true

julia> 100 == 101
false

julia> 100 != 101
true

julia> 100 == 100.0
true

julia> 100 < 500
true

julia> 100 > 500
false

julia> 100 >= 100.0
true

julia> -100 <= 100
true

julia> -100 <= -100
true

julia> -100 <= -500
false

julia> 100 < -10.0
false

链接比较

在 Julia 中，比较可以任意链接。对于数字代码，链接比较非常方便。用于标量比较的&&运算符和用于元素比较的&运算符允许链式比较在数组上正常工作。

例子

以下示例显示了链式比较的使用 -

julia> 100 < 200 <= 200 < 300 == 300 > 200 >= 100 == 100 < 300 != 500
true

在下面的示例中，让我们检查一下链式比较的评估Behave -

julia> M(a) = (println(a); a)
M (generic function with 1 method)
julia> M(1) < M(2) <= M(3)
 2
 1
 3
true
julia> M(1) > M(2) <= M(3)
 2
 1
false

运算符优先级和优先级