Julia 教程 / 基本类型与数值计算
基本类型与数值计算
1. 类型体系概览
Julia 的类型系统是动态类型（运行时检查）与强类型（不允许隐式类型转换）的结合。所有类型形成一棵以 Any 为根的树。
Any
├── Number
│ ├── Real
│ │ ├── AbstractFloat
│ │ │ ├── Float16
│ │ │ ├── Float32
│ │ │ ├── Float64
│ │ │ └── BigFloat
│ │ ├── Integer
│ │ │ ├── Bool
│ │ │ ├── Signed
│ │ │ │ ├── Int8, Int16, Int32, Int64, Int128
│ │ │ │ └── BigInt
│ │ │ └── Unsigned
│ │ │ └── UInt8, UInt16, UInt32, UInt64, UInt128
│ │ └── Rational
│ │ └── Rational{T}
│ └── Complex
│ └── Complex{T}
├── AbstractString
│ └── String
├── Char
├── Bool (also under Integer)
└── ...（函数、容器、自定义类型等）
2. 整数类型
有符号整数
| 类型 | 位数 | 最小值 | 最大值 |
|---|---|---|---|
Int8 | 8 | -128 | 127 |
Int16 | 16 | -32768 | 32767 |
Int32 | 32 | -2147483648 | 2147483647 |
Int64 | 64 | -9.2×10¹⁸ | 9.2×10¹⁸ |
Int128 | 128 | -1.7×10³⁸ | 1.7×10³⁸ |
无符号整数
| 类型 | 位数 | 最大值 |
|---|---|---|
UInt8 | 8 | 255 |
UInt16 | 16 | 65535 |
UInt32 | 32 | 4294967295 |
UInt64 | 64 | 1.8×10¹⁹ |
UInt128 | 128 | 3.4×10³⁸ |
机器默认类型
julia> typeof(42)
Int64 # 64 位系统默认 Int64
julia> Sys.WORD_SIZE
64
julia> typeof(42.0)
Float64 # 默认浮点类型
💡 提示: 在大多数场景下，直接使用
Int64和Float64即可，无需显式指定类型。Julia 的 JIT 编译器会自动选择最优的机器指令。
3. 浮点类型
| 类型 | 位数 | 精度（十进制位） | 说明 |
|---|---|---|---|
Float16 | 16 | ~3.3 | 半精度，GPU 计算常用 |
Float32 | 32 | ~7.2 | 单精度，深度学习常用 |
Float64 | 64 | ~15.9 | 双精度，科学计算默认 |
BigFloat | 任意 | 可配置 | 任意精度浮点数 |
# 浮点字面量
x = 3.14 # Float64
y = 3.14f0 # Float32
z = Float16(3.14) # Float16
# 科学计数法
c = 3.0e8 # 3.0 × 10⁸
avogadro = 6.022e23
# 特殊浮点值
Inf # 正无穷
-Inf # 负无穷
NaN # 非数字
Inf32 # Float32 正无穷
浮点精度陷阱
julia> 0.1 + 0.2
0.30000000000000004
julia> 0.1 + 0.2 == 0.3
false
# 正确的比较方式
julia> isapprox(0.1 + 0.2, 0.3)
true
julia> abs(0.1 + 0.2 - 0.3) < 1e-15
true
⚠️ 注意: 浮点数比较永远不要用
==，使用isapprox()或设置容差比较。这是所有编程语言的通用陷阱。
4. 布尔类型与字符类型
Bool
julia> true
true
julia> typeof(true)
Bool
julia> Bool(1)
true
julia> Bool(0)
false
julia> Bool(42) # 非零为 true
true
# 布尔运算
julia> true && false # 逻辑与
false
julia> true || false # 逻辑或
true
julia> !true # 逻辑非
false
# 布尔可参与算术
julia> true + true + false
2
Char
julia> c = 'A'
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
julia> typeof(c)
Char
julia> Int(c)
65
julia> Char(65)
'A'
# Unicode 字符
julia> '中'
'中': Unicode U+4E2D (category Lo: Letter, other)
julia> Int('中')
20013
julia> '\u03b1' # α
'α': Unicode U+03B1 (category Ll: Letter, lowercase)
# 字符操作
julia> 'a' < 'b'
true
julia> isletter('x')
true
julia> isdigit('7')
true
julia> uppercase('a')
'A'
5. 字符串（简介）
字符串在下一章详细讲解，此处介绍基本用法：
# 字符串字面量用双引号
s = "Hello, Julia!"
# 字符串是不可变的 UTF-8 序列
julia> sizeof(s)
14
julia> length(s) # 字符数（不是字节数）
14
# 字符串插值
julia> name = "Julia"
julia> "Hello, $name!"
"Hello, Julia!"
# 字符串拼接
julia> "Hello" * ", " * "Julia!"
"Hello, Julia!"
6. BigInt 与 BigFloat 任意精度
当标准类型精度不够时，使用任意精度类型：
# BigInt — 任意精度整数
julia> big(2)^100
1267650600228229401496703205376
julia> factorial(big(100)) # 100!
93326215443944152681699238856266700490715968264381621468592963895217599993229915\
608941463976156518286253697920827223758251185210916864000000000000000000000000
# BigFloat — 任意精度浮点数
julia> big(π)
3.141592653589793238462643383279502884197169399375105820974944592307816406286198
# 设置精度（二进制位数）
julia> setprecision(256) do
big(1) / big(3)
end
3.333333333333333333333333333333333333333333333333333333333333333333333333333319e-01
# 高精度圆周率
julia> setprecision(1000) do
BigFloat(π)
end
3.141592653589793238462643383279502884197169399375105820974944592307816406286208\
99862803482534211706798214808651328230664709384460955058223172535940812848111745028410270...
精度对比表
| 计算 | Float64 | BigFloat (256 位) |
|---|---|---|
| 1/3 | 0.3333333333333333 | 0.333333333333333333…3319 |
| π | 3.141592653589793 | 3.14159265358979323… |
| √2 | 1.4142135623730951 | 1.41421356237309504… |
💡 提示:
BigInt和BigFloat运算比原生类型慢 100-1000 倍，仅在确实需要高精度时使用。
7. 算术运算与数学函数
基本算术
julia> 2 + 3 # 加法
5
julia> 10 - 4 # 减法
6
julia> 3 * 7 # 乘法
21
julia> 15 / 4 # 除法（总是返回浮点数）
3.75
julia> 15 ÷ 4 # 整除（\div + Tab）
3
julia> 15 % 4 # 取余
3
julia> 15 mod 4 # 取模
3
julia> 2^10 # 幂运算
1024
julia> √2 # 平方根（\sqrt + Tab）
1.4142135623730951
julia> 2.0^0.5
1.4142135623730951
数学函数
# 三角函数（弧度制）
sin(π/2) # 1.0
cos(0) # 1.0
tan(π/4) # 1.0
asin(1) # π/2
atan(1) # π/4
# 对数与指数
log(ℯ) # 1.0（自然对数）
log2(8) # 3.0
log10(1000) # 3.0
exp(1) # ℯ
exp2(10) # 1024.0
# 取整函数
round(3.7) # 4.0
floor(3.7) # 3.0
ceil(3.2) # 4.0
trunc(3.7) # 3.0（截断小数部分）
# 绝对值与符号
abs(-5) # 5
abs2(-3) # 9（平方）
sign(-7) # -1
sign(0) # 0
# 最大最小值
max(3, 7) # 7
min(3, 7) # 3
clamp(15, 0, 10) # 10（钳位到范围）
# 统计
sum(1:100) # 5050
prod(1:5) # 120
8. 溢出行为
Julia 的固定精度整数溢出时会环绕（wrap around），不会报错：
julia> typemax(Int64)
9223372036854775807
julia> typemax(Int64) + 1
-9223372036854775808 # 溢出为最小值！
julia> typemin(Int64)
-9223372036854775808
julia> UInt8(255) + UInt8(1)
0x00 # 无符号溢出到 0
防溢出策略
# 方案 1：使用 BigInt（不溢出）
julia> big(typemax(Int64)) + 1
9223372036854775808
# 方案 2：使用 checked 算术（溢出时抛异常）
julia> using Base.Checked
julia> checked_add(typemax(Int64), 1)
# 抛出 OverflowError
# 方案 3：使用 saturating 算术（溢出时钳位）
julia> using Base.Checked
julia> Base.Checked.add_with_overflow(typemax(Int64), 1)
⚠️ 注意: Julia 整数溢出不报错是刻意的设计决策（与 C 一致），以保证性能。在涉及金融计算等场景时，务必使用
BigInt或checked_*系列函数。
9. 类型转换
convert — 类型转换
# 基本转换
julia> convert(Float64, 42)
42.0
julia> convert(Int64, 3.14) # 截断小数
3
julia> convert(Int64, 3.9) # 也是截断
3
julia> convert(Bool, 0)
false
julia> convert(Bool, 42)
true
# 失败的转换
julia> convert(Int64, 3.5)
# 方法错误：不能直接转换
parse — 字符串解析
julia> parse(Int64, "42")
42
julia> parse(Float64, "3.14")
3.14
julia> parse(Bool, "true")
true
julia> parse(Int64, "hello")
# 抛出 ArgumentError
# 带进制解析
julia> parse(Int, "ff", base=16)
255
julia> parse(Int, "1010", base=2)
10
强制类型转换 T(x)
julia> Float32(42)
42.0f0
julia> Int8(100)
100
julia> Int8(200) # 溢出！
-56
julia> UInt8(255)
0xff
10. 有理数类型
Julia 内置精确有理数支持：
julia> 1//3
1//3
julia> typeof(1//3)
Rational{Int64}
julia> 2//4 # 自动约分
1//2
julia> 1//3 + 1//6
1//2
julia> 1//3 * 3
1//1
julia> float(1//3) # 转为浮点数
0.3333333333333333
# 分子与分母
julia> numerator(3//7)
3
julia> denominator(3//7)
7
💡 提示:
Rational类型可以精确表示分数，避免浮点舍入误差。在需要精确比较分数大小时非常有用。
11. 单位量（Unitful.jl）简介
通过 Unitful.jl 可以给数值附加物理单位，实现类型安全的量纲计算：
using Pkg; Pkg.add("Unitful")
using Unitful
# 带单位的数值
julia> 1u"m" + 2u"cm"
1.02 m
julia> 1u"km" / 1u"hr"
1.0 km hr⁻¹
# 单位转换
julia> uconvert(u"mph", 100u"km/hr")
62.13711922373339 mph
# 温度
julia> uconvert(u"°F", 100u"°C")
212.0 °F
# 编译时检查量纲一致性
julia> 1u"m" + 1u"s"
# 错误：不能将长度和时间相加
12. 数值计算业务场景
金融复利计算
function compound_interest(principal, rate, years, n=12)
"""计算复利终值
principal: 本金
rate: 年利率（如 0.05 表示 5%）
years: 年数
n: 每年复利次数（默认月复利）
"""
return principal * (1 + rate / n)^(n * years)
end
# 10 万元年利率 5%，10 年
compound_interest(100_000, 0.05, 10)
# 164700.95
# 连续复利
continous_compound(principal, rate, t) = principal * exp(rate * t)
物理计算
# 抛物线运动
function projectile(v0, θ, t; g=9.81)
vx = v0 * cos(θ)
vy = v0 * sin(θ)
x = vx * t
y = vy * t - 0.5 * g * t^2
return (x=x, y=y)
end
# 以 30 m/s、45° 发射
pos = projectile(30, π/4, 2.0)
println("x = $(pos.x) m, y = $(pos.y) m")
扩展阅读
- Julia 官方文档 — Integers and Floating-Point Numbers
- Julia 官方文档 — Mathematical Operations
- Unitful.jl 文档
- IEEE 754 浮点标准
- Julia 数值精度最佳实践
📌 本章小结: Julia 提供完整的数值类型层次，从 8 位整数到任意精度浮点数。默认
Int64/Float64满足大多数场景。整数溢出会环绕（非报错），使用BigInt或checked_*避免。Rational提供精确分数运算，Unitful.jl提供类型安全的物理量纲计算。