Julia 元组

元组（Tuple）是 Julia 中不可变的有序集合，可以包含不同类型的元素。元组创建后不能修改，适合用于函数返回多个值或存储固定的数据组合。

创建元组

基本创建

# 使用圆括号创建
t = (1, 2, 3)
println(t)  # (1, 2, 3)

# 混合类型
t = (1, "hello", 3.14, true)
println(t)  # (1, "hello", 3.14, true)

# 单元素元组需要逗号
single = (1,)     # 元组
not_tuple = (1)   # 只是数字1

# 空元组
empty = ()

省略括号

在某些情况下可以省略括号：

# 赋值时可以省略
t = 1, 2, 3
println(t)  # (1, 2, 3)

# 函数返回多个值
function minmax(a, b)
    return a < b ? (a, b) : (b, a)
end
result = minmax(5, 3)
println(result)  # (3, 5)

访问元素

索引访问

元组索引从 1 开始：

t = (10, 20, 30, 40, 50)

# 访问单个元素
println(t[1])    # 10
println(t[end])  # 50

# 范围访问
println(t[2:4])  # (20, 30, 40)

解构（解包）

t = (1, 2, 3)

# 解构到变量
a, b, c = t
println(a)  # 1
println(b)  # 2
println(c)  # 3

# 交换变量
x, y = 10, 20
x, y = y, x
println("x=$x, y=$y")  # x=20, y=10

# 忽略某些值
first, _, third = (1, 2, 3)
println(first)  # 1
println(third)  # 3

# 收集剩余元素
first, rest... = (1, 2, 3, 4, 5)
println(first)  # 1
println(rest)   # (2, 3, 4, 5)

元组属性

t = (1, "hello", 3.14)

# 长度
println(length(t))  # 3

# 类型
println(typeof(t))  # Tuple{Int64, String, Float64}

# 检查是否包含元素
println(1 in t)       # true
println("world" in t) # false

不可变性

元组创建后不能修改：

t = (1, 2, 3)

# 尝试修改会报错
# t[1] = 100  # ERROR: MethodError

# 但如果元组包含可变对象，该对象本身可以修改
t = ([1, 2], [3, 4])
t[1][1] = 100  # 这是允许的
println(t)     # ([100, 2], [3, 4])

命名元组

命名元组（NamedTuple）是带有字段名的元组，可以通过名称访问元素。

创建命名元组

# 使用 = 语法
person = (name="Alice", age=30, city="Beijing")
println(person)  # (name = "Alice", age = 30, city = "Beijing")

# 使用 NamedTuple 构造
nt = NamedTuple{(:x, :y)}((1, 2))
println(nt)  # (x = 1, y = 2)

# 从变量创建
name = "Bob"
age = 25
person = (; name, age)  # 使用变量名作为字段名
println(person)  # (name = "Bob", age = 25)

访问命名元组

person = (name="Alice", age=30, city="Beijing")

# 通过名称访问
println(person.name)  # Alice
println(person.age)   # 30

# 也可以通过索引访问
println(person[1])    # Alice

# 获取所有键
println(keys(person))    # (:name, :age, :city)

# 获取所有值
println(values(person))  # ("Alice", 30, "Beijing")

命名元组解构

person = (name="Alice", age=30)

# 按名称解构
(; name, age) = person
println(name)  # Alice
println(age)   # 30

# 重命名
(; name => n, age => a) = person
println(n)  # Alice

元组操作

合并元组

t1 = (1, 2, 3)
t2 = (4, 5, 6)

# 使用 ... 展开
combined = (t1..., t2...)
println(combined)  # (1, 2, 3, 4, 5, 6)

命名元组合并

nt1 = (a=1, b=2)
nt2 = (c=3, d=4)

# 合并
combined = (; nt1..., nt2...)
println(combined)  # (a = 1, b = 2, c = 3, d = 4)

# 覆盖字段
nt1 = (a=1, b=2)
nt2 = (b=10, c=3)
combined = (; nt1..., nt2...)
println(combined)  # (a = 1, b = 10, c = 3)

遍历元组

t = (1, 2, 3, 4, 5)

# for 循环
for x in t
    println(x)
end

# 带索引遍历
for (i, x) in enumerate(t)
    println("索引 $i: 值 $x")
end

# 遍历命名元组
person = (name="Alice", age=30)
for (key, value) in pairs(person)
    println("$key: $value")
end

转换操作

t = (1, 2, 3, 4, 5)

# 转为数组
arr = collect(t)
println(arr)  # [1, 2, 3, 4, 5]

# 数组转元组
arr = [1, 2, 3]
t = Tuple(arr)
println(t)  # (1, 2, 3)

# 命名元组转字典
person = (name="Alice", age=30)
d = Dict(pairs(person))
println(d)  # Dict(:name => "Alice", :age => 30)

函数与元组

返回多个值

function divrem_custom(a, b)
    return (a ÷ b, a % b)
end

quotient, remainder = divrem_custom(17, 5)
println("商: $quotient, 余: $remainder")  # 商: 3, 余: 2

元组作为参数

# 使用 splatting 展开元组作为参数
function add3(a, b, c)
    return a + b + c
end

args = (1, 2, 3)
result = add3(args...)
println(result)  # 6

可变参数

# 可变参数作为元组
function show_all(args...)
    println("收到 $(length(args)) 个参数")
    for arg in args
        println("  - $arg")
    end
end

show_all(1, 2, 3, "hello")

元组比较

t1 = (1, 2, 3)
t2 = (1, 2, 3)
t3 = (1, 2, 4)

# 相等比较
println(t1 == t2)  # true
println(t1 == t3)  # false

# 大小比较（字典序）
println(t1 < t3)   # true（因为 3 < 4）
println((1, 2) < (1, 2, 3))  # true（较短的更小）

常用场景

1. 函数返回多个值

function analyze(data)
    n = length(data)
    total = sum(data)
    avg = total / n
    return (count=n, sum=total, average=avg)
end

result = analyze([1, 2, 3, 4, 5])
println(result.average)  # 3.0

2. 字典键

# 元组可以作为字典键
locations = Dict{Tuple{Int,Int}, String}()
locations[(0, 0)] = "原点"
locations[(1, 2)] = "点A"

println(locations[(0, 0)])  # 原点

3. 多重赋值和交换

# 交换变量
a, b = 1, 2
a, b = b, a

# 同时赋值
x, y, z = 1, 2, 3

4. 配置参数

config = (
    host = "localhost",
    port = 8080,
    debug = true,
    timeout = 30
)

println("服务器: $(config.host):$(config.port)")

元组 vs 数组

特性	元组	数组
可变性	不可变	可变
类型	可以混合类型	通常同一类型
性能	类型已知，更快	稍慢
用途	固定结构数据	动态集合

# 元组：类型在编译时已知
t = (1, "hello", 3.14)
println(typeof(t))  # Tuple{Int64, String, Float64}

# 数组：元素类型统一
arr = [1, 2, 3]
println(typeof(arr))  # Vector{Int64}

下一步

学习完元组后，请继续学习：

• 数据类型 - 深入了解类型系统
• 字典和集合 - 其他数据结构
• 函数 - 函数定义和使用