Julia的编程概念(learning julia 未完待续)

在上一章中，我们讨论了Julia如何适用于原型设计和执行几乎和C.朱莉娅同样适应经验丰富的程序员和新手。朱莉娅是设计的方式是刚开始编程的人能够在REPL或Jupyter Notebook的帮助下，在一天内完成并运行。它提供了很多对数据科学家，统计学家和在该领域工作的人有用的功能科学计算

了解其他语言会使阅读愉快，但不是必需的。该读者会发现Julia非常类似于MATLAB，Python和R.

Julia的1.0版本计划在几个月内发布。虽然可能会有一些变化到那时，大多数概念和代码应该对该版本有效。

在本章中，读者将学习语法，以及在Julia中编程的众多方法之一。本章将介绍以下主题：

重温编程范式
从Julia REPL开始
变量
整数，位，字节和bools
Julia的浮点数
逻辑和算术运算
数组和矩阵
DataFrames和数据数组
字典
## 重温编程范式
在解决问题之前，我们应该始终尝试了解它的来源，然后将问题分解为我们将要执行的步骤来解决问题。我们应该确保我们考虑所有场景和将要解决问题。

编程范式是指将编程活动分解为思想结构。这是解决问题和子任务方向的方法。尽管可以使用不同的范例来解决问题，但是一种范式可能比另一种范式更适合解决它。

有很多编程范例，所以我们在这里只讨论其中的几个：

Imperative
Logical
Functional
Object-oriented

建议理解编程范例，因为一种编程语言可能更适合于一种特定范例。例如，C适用于命令式编程，Haskell适用于函数式编程，Smalltalk适用于面向对象的编程。让我们更详细地理解这些不同的范例。

以下略

从Julia REPL开始

我们已经学会了如何启动Julia REPL并评估其中的基本语句。

Julia提供了各种选项来运行程序。我们可以直接运行语句，甚至不用打开REPL：

$ julia -e 'println("Hello World")'
Hello World

我们甚至可以在不启动REPL的情况下运行循环：

$ julia -e 'for i=1:5; println("Hello World"); end'
Hello World
Hello World

也可以传递参数：

$ julia -e 'for i in ARGS; println(i); end' k2so r2d2 c3po r4 bb8
k2so
r2d2
c3po
r4
bb8

ARGS用于获取脚本的命令行参数。

我们可以使用–help选项找到Julia支持的不同选项：
# 一级标题

二级标题

在文字写书写不同数量的#可以完成不同的标题，如下：

$ julia --help
julia [switches] -- [programfile] [args...]
-v, --version Display version information
-h, --help Print this message
-H, --home <dir> Set location of `julia` executable
-e, --eval <expr> Evaluate <expr>
-E, --print <expr> Evaluate and show <expr>
-L, --load <file> Load <file> immediately on all processors
-p, --procs {N|auto} Integer value N launches N additional local
worker processes
"auto" launches as many workers as the number of
local cores
--machinefile <file> Run processes on hosts listed in <file>
-i Interactive mode; REPL runs and isinteractive()
is true

（在前面的输出中，我们只显示了最常用的选项。还有更多
可以使用julia访问的选项–help。）

Julia的变量

就像在其他编程语言中一样，我们使用变量来存储从计算或外部源获得的值。

在终端中键入julia启动REPL：

$ julia
# assign 100 to a variable x
julia> x = 100
100
# multiple the value in the variable by 5
julia> x*5
500

我们可以更改存储在变量中的值或改变状态：

# assign a different value to x
# this will replace the existing value in x
julia> x = 24
24
# create another variable y
julia> y = 10
10

简单的操作，例如交换，很容易：

# swap values of x and y
julia> x,y = y,x
(10,24)
julia> x
10
julia> y
24

变量的名称可以以字符或“_”（下划线）开头。 Julia还允许使用Unicode名称（UTF-8），但并非所有Unicode名称都在变量名称中被接受：

julia> _ab = 40
40
julia> @ab = 10
ERROR: syntax: unexpected "="
julia> 1000
1000

请注意 ”！” （感叹号）不应在变量名中使用，因为以感叹号结尾的函数用于修改其参数。

我们可以使用UTF-8中任何大于00A0的符号集（尽管不接受许多符号）：

# assigning value to a Hindi word.
julia> अंशुल= 101
10

Julia提供了一些内置的常量和函数，我们可以为它们赋值，虽然不建议这样做，因为它可能会造成混淆：

julia> pi
π = 3.1415926535897…
julia> pi = 300
300

有一些保留关键字，不允许用作变量名称：

julia> for = 100
ERROR: syntax: unexpected "="
julia> if = 1000
ERROR: syntax: unexpected "="

命名约定

尽管Julia对命名没有太多限制，但大多数组合都是允许的，但遵循一些约定作为良好实践是很好的：

通常，变量名称以小写形式编写。
下划线用于分隔a中的不同单词
变量名，但不建议使用需要下划线的名称。
函数和宏名称为小写。不使用下划线。
类型和模块的第一个字符是大写。名称中的词之间的分隔是使用上骆驼案例完成的。
修改或写入任何参数的函数以“！”结尾符号。

我们之前提到Julia是一种强类型语言。因此，有必要
要定义的变量类型。如果未明确定义，则Julia将尝试从分配给变量的值推断出它。

我们可以使用Julia提供的typeof（）函数来查找变量的类型。

让我们对上一节中定义的变量执行此操作：

julia> typeof(_ab)
Int64
julia> langname = "Julia"
"Julia"
julia> typeof(langname)
String

前面示例中的Int64和String是类型。 Int64中的64是变量的位长。 Int有不同的大小，默认值通常与操作系统的字长有关。

还应该注意的是，在Julia中，我们可以使用下划线分隔数字：

julia> 1_0_0
100

这在许多情况下都很有用：

julia> 100_000_000
100000000

整数，位，字节和bools
算术运算中使用整数，位，字节，bool和浮点数。它们的内置表示称为数字基元，数字文字表示为代码中的值。

让我们了解Julia的原始数字类型。以下是Integer类型表，包括位，字节和bool：

Type	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	8	false(0)	true(1)

UInt类型引用无符号整数。这些是值从0开始的整数。
此表显示特定类型的整数可以容纳的最小值和最大值。

我们还可以使用typemin（）和typemax（）函数找到整数类型的最小值和最大值：

julia> typemax(Int32)
2147483647
julia> typemin(Int32)
-2147483648

这也来自上表：最小值-2 ^ 31和最大值2 ^ 31 -1。

在REPL中使用整数

我们可以使用REPL更好地理解整数。

$ julia
julia> 24
24
julia> typeof(24)
Int64

这是Int64，因为我们使用的是64位系统。如果我们在32位系统上，那么默认的整数类型将是Int32。

我们可以检查我们正在处理的系统的默认字大小（体系结构）是什么：

julia> Sys.WORD_SIZE
64

当我们启动REPL时，Julia横幅上也会提到体系结构的类型。
最后一行提到了这个架构：
x86_64-linux-gnu
这意味着我们正在使用Linux并且位于x86_64（64位）平台上。如果您使用的是32位平台，则可能会获得i386。
在我们处理无法用32位整数（Int32）表示的大数字的情况下，Julia本身创建64位整数（64位），而不是Int32，即使我们在32- 位的机器：

julia> large_integer = 99999999999
julia> typeof(large_integer)
Int64

了解溢出行为

在Julia中，我们没有适用于全局范围的类型声明。但我们绝对可以在函数的本地范围内使用它们。

在下面的示例中，我们将定义一个具有Int16类型的x变量的函数。我们将它赋值为10000（我们将在后面的章节中详细了解函数和类型）

julia> x = Int16(10000)
10000
julia> x*x
-7936

这个功能非常简单。它将值10000分配给Int16类型的x并打印x * x。
为什么我们得到x * x，10000 * 10000为-7936？

这是因为我们超出了变量类型可以处理的值。这导致了一种环绕行为。环绕行为是模运算的一部分，其中数字在达到某个值时会回绕，也称为模数。

理解这个概念的另一个例子是溢出a的最大可能值

# largest possible value of 16-bit Int: 32767
julia> x = typemax(Int16)
32767
# Julia will maintain variable types even if the max value # is exceeding
julia> x + Int16(1)
-32768

了解布尔数据类型

Bool是一种广泛使用的逻辑数据类型。它被分配，可以是真或假：

julia> 1 > 2
false
julia> typeof(ans)
Bool

与其他语言不同，Julia中不会将0，NULL或空字符串视为false。
例如：

julia> if 0
println("hello")
end

上面的命令将抛出一个错误：

TypeError: non-boolean (Int64) used in boolean context
Stacktrace:
[1] include_string(::String, ::String) at ./loading.jl:515

Julia的浮点数

在Julia中很容易表示浮点数。它们以与其他语言类似的方式表示：

# Add a decimal point
julia> 100.0
100.0
julia> 24.
24.0
# It is not required to precede a number from the decimal point
julia> .10
0.1
julia> typeof(ans)
Float64

Julia有一个正零和负零的概念。它们是相同的但具有不同的二进制表示：

# equating two zeroes
julia> 0.0 == -0.0
true
julia> bits(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"
# different first bit for negative zero
julia> bits(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"

在各种情况下，指数表示法非常有用和方便。它可以在使用e的Julia中使用：

julia> 2.99e8
2.99e8
julia> 2.99e8>999999
true

我们在前面的例子中一直使用Float64。如果需要，我们也可以在64位计算机上使用Float32：

# Replace e by f to generate Float32
julia> 2.99f8
2.99f8
# Check the type of the preceding variable if it is Float32
julia> typeof(ans)
Float32
# Compare it with the same value
julia> 2.99f8==2.99e8
true

将值从Float64转换为Float32很容易：

julia> Float32(2.99e8)
2.99f8

在某些用例中，使用十六进制浮点文字。在Julia中，它们仅作为Float64值有效：

julia> 0x4.1p1
8.125
julia> typeof(ans)
Float64

以下是浮点类型表：

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