Lua: 用 table 统一实现数组和字典

42_Lua table表 Lua 中的 table 是一种核心且功能强大的数据结构。它可充当数组与字典,能构建复杂数据形式。数组基于 table,索引从 1 起,一维数组动态可变,多维数组(以二维为例)用嵌套表实现,创建、访问、遍历及元素操作都有对应方法。字典通过 table 构建,键有取值限制,创建与操作便捷,遍历用 pairs() 函数。同时,Lua 提供了多个 table 内置函数。 阅读详情

概述

  • Lua 没有独立的数组或字典类型,而是通过其强大的 table 数据结构来统一实现
  • table 是 Lua 的核心,可以看作是关联数组(associative array),键(key)可以是任意类型(除了 nil),值(value)也可以是任意类型
  • 当键为数字时,table 表现为数组;当键为字符串或其他类型时,table 表现为字典

背景

  • Lua 是一种轻量级脚本语言,最初由巴西里约热内卢天主教大学的研究小组于 1993 年开发
  • 其设计目标是嵌入应用程序,提供灵活的扩展和定制功能
  • table 作为 Lua 中唯一的数据结构,集数组、字典、集合、对象等多种功能于一身,是其灵活性的关键
  • Lua 数组实现
    • Lua 中的数组本质上是使用数字作为键的 table
    • 数组索引通常从 1 开始(虽然也可以使用 0 或负数)

数组与字典的详细实现与实践案例


1 ) 实践案例 1:一维数组

--- 定义一个数组(使用数字键)
local fruits = {"apple", "banana", "orange"}
--- 访问元素(索引从1开始)
print(fruits[1])  -- 输出: apple
print(fruits[2])  -- 输出: banana
--- 遍历数组(使用 ipairs,保证顺序)
for i, fruit in ipairs(fruits) do 
    print(i, fruit)
end 
--- 输出:
--- 1   apple
--- 2   banana
--- 3   orange 

--- 添加元素 
table.insert(fruits, "grape")
print(fruits[4]) -- 输出: grape 
--- 删除元素 
table.remove(fruits, 2) -- 删除索引为2的元素
for i, fruit in ipairs(fruits) do 
    print(i, fruit)
end 
--- 输出:
--- 1   apple
--- 2   orange 
--- 3   grape

特点:索引为数字,通常从1开始;#fruits 或 table.getn(fruits) 可获取数组长度(但对稀疏数组可能不准确);ipairs 遍历时会按数字索引顺序迭代,遇到 nil 值会停止

2 ) 实践案例 2:多维数组

--- 定义一个 3x3 的二维数组(即 table 的 table)
local matrix = {}
for i = 1, 3 do
    matrix[i] = {} -- 每一行是一个新的 table
    for j = 1, 3 do
        matrix[i][j] = i * j -- 填充元素 
    end
end
--- 访问二维数组元素
print(matrix[2][3]) -- 输出: 6

--- 遍历二维数组
for i = 1, 3 do
    for j = 1, 3 do
        print("matrix[" .. i .. "][" .. j .. "] = " .. matrix[i][j])
    end
end

特点:通过嵌套 table 实现;matrix[i][j] 等价于 ((matrix[i])[j])

Lua 字典实现


Lua 中的字典同样使用 table,但键通常是字符串或其他非数字类型

1 ) 实践案例 1:基础字典操作

--- 定义一个字典(使用字符串键)
local person = {
    name = "Alice", -- 等价于 ["name"] = "Alice"
    age = 30,
    city = "New York"
}
--- 访问元素 
print(person.name)  -- 输出: Alice
print(person["age"]) -- 输出: 30
--- 修改值
person.age = 31
print(person.age) -- 输出: 31
--- 添加键值对 
person.job = "Engineer"
person["salary"] = 50000
--- 删除键值对(通过赋值为 nil)
person.city = nil 
--- 遍历字典(使用 pairs,顺序不定)
for key, value in pairs(person) do
    print(key, value)
end
--- 可能的输出:
--- name    Alice
--- job     Engineer
--- salary  50000
--- age     31

特点:键为字符串(或其它类型),通过 key 访问 value;pairs 遍历时顺序不确定

2 ) 实践案例 2:混合使用(数组和字典部分)

local mixed_table = {
    "first",      -- 索引1 
    "second",     -- 索引2
    name = "Bob", -- 字典部分
    age = 25      -- 字典部分 
}
--- 访问数组部分 
print(mixed_table[1]) -- 输出: first 
print(mixed_table[2]) -- 输出: second 
--- 访问字典部分
print(mixed_table.name) -- 输出: Bob
print(mixed_table["age"]) -- 输出: 25 
--- 遍历混合 table(需要注意 pairs 和 ipairs 的行为)
print("Using pairs (all key-value pairs):")
for k, v in pairs(mixed_table) do 
    print(k, v)
end 
 
print("Using ipairs (array part only, stops at first nil):")
for i, v in ipairs(mixed_table) do 
    print(i, v)
end 

特点:一个 table 可以同时包含数字索引和字符串索引(或其它类型索引)的元素

数组与字典实现对比表


特性Lua 数组 (Table with Numeric Keys)Lua 字典 (Table with String/Other Keys)
键类型通常是数字 (通常从1开始)通常是字符串或其他类型
访问方式arr[index] 或通过 ipairs 遍历dict.key 或 dict[“key”] 或 pairs 遍历
遍历顺序ipairs 保证顺序 (从1开始连续)pairs 不保证顺序
长度获取#arr (对连续数组有效)无内置函数,需手动计算或使用 pairs 计数
主要用途存储有序、同类型元素存储无序、键值对映射关系
底层实现与字典相同,都是 table与数组相同,都是 table

下面是数组与字典实现逻辑的核心对比:

维度数组实现字典实现
索引规则仅使用连续整数(默认从1开始)支持任意非nil类型(字符串/数字等)
遍历方式优先ipairs、for i=1,#t遍历必须使用pairs遍历
内置方法适配兼容table.insert/sort等数组方法不支持table标准数组方法
典型使用场景有序存储同类型数据键值对映射存储异构关联数据

数组实现扩展案例


1 ) 基础声明与访问:使用大括号直接声明,默认索引从1开始,可手动指定非连续负索引

--- 声明一维数组 
local arr = {"Lua", "Table", "Array"} 
print(arr[1]) --> Lua 
--- 声明负索引数组 
local neg_arr = {} 
neg_arr[-1] = "negative index" 

2 )动态扩容与修改:直接新增索引指向值即可扩容,使用table.insert/table.remove完成指定位置操作

table.insert(arr, 2, "Demo") 
--> arr变为 {"Lua","Demo","Table","Array"} 

3 )多维数组实现:通过表嵌套表来构建,结合嵌套循环初始化与访问

local matrix = {} 
for i=1,3 do 
    matrix[i] = {} 
    for j=1,3 do matrix[i][j] = i*j end 

完整示例参考

local matrix = {}
for i = 1, 3 do 
    matrix[i] = {}  -- 初始化行 
    for j = 1, 3 do
        matrix[i][j] = i * j 
    end 
end  -- 外层循环闭合 
 
-- 输出矩阵的字符串表示 
local function matrixToString(m)
    local rows = {}
    for i = 1, #m do 
        local row = {}
        for j = 1, #m[i] do 
            table.insert(row, tostring(m[i][j]))
        end
        table.insert(rows, "{" .. table.concat(row, ", ") .. "}")
    end 
    return "{\n  " .. table.concat(rows, ",\n  ") .. "\n}"
end
 
print(matrixToString(matrix))

--[==[
{
  {1, 2, 3},
  {2, 4, 6},
  {3, 6, 9}
}
]==]

字典实现实践案例


1 ) 基础声明与访问:支持括号索引与点语法两种写法,点语法仅适用于字符串键且键名不含特殊字符

--- 声明键值对字典 
local user = {name="Alice", age=24, [true]="valid"} 
print(user.name) --> Alice (点语法) 
print(user[true]) --> valid (括号索引) 

2 ) 增删改操作:新增指定索引值完成添加操作,赋值nil即可移除字典元素

user.gender = "female" --新增键值对 
user.age = 25 --修改值 
user.age = nil --删除age键值对 

3 ) 有序遍历字典:将字典键转为数组后排序,基于有序数组遍历获取对应值

-- 初始化空键列表
local keys = {}
local user = {name = "Alice", age = 10}

-- 提取所有键
for k in pairs(user) do
    -- 可选:过滤仅字符串/数字键 (取消注释下一行)
    -- if type(k) == "string" or type(k) == "number" then
    table.insert(keys, k)
    -- end
end
 
-- 按键排序(假设键可比较)
table.sort(keys)
 
-- 打印排序后的键值对
for _, k in ipairs(keys) do 
    print(k, user[k])
end

混合存储实践


Lua允许在同一个表内同时存储数组与字典逻辑,数组索引与字典键互不干扰

local mix_data = {
    "first element", 
    "second element", 
    title = "Mixed Table Demo", 
    version = "5.4" 
}

print(mix_data[0]) -- nil
print(mix_data[1]) -- first element
print(mix_data[2]) -- second element
print(mix_data[3]) -- nil
print(mix_data['title']) -- Mixed Table Demo
print(mix_data[4]) -- nil
print(mix_data['version']) -- 5.4
print(mix_data[5]) -- nil

Lua 数组与字典的核心机制


Lua 仅用 table 一种数据结构实现了数组(顺序表)和字典(关联数组),其设计遵循灵活性优先原则:

  • 数组本质:以连续整数为键的 table。索引默认从 1 开始(符合数学传统),但支持任意起点(如 0 或负数)
  • 字典本质:键值对集合,键可为 string、number 甚至 table,值无类型限制[9]。
  • 混合存储:同一 table 可同时包含数组部分和哈希部分,例如:
     mixed = { "apple", "banana", color = "yellow", price = 2.5 } -- 前两项为数组,后两项为字典  
    

高级案例实践


1 ) 案例 1:游戏地图网格系统(二维数组)

需求:存储 3x3 地图格子类型(0=空地,1=障碍)并快速访问

local map = {}  

for i = 1, 3 do  
    map[i] = {}  -- 每行初始化新数组  
    for j = 1, 3 do  
        map[i][j] = (i == j) and 1 or 0  -- 对角线设为障碍  
    end  
end

print(map[2][2]) -- 输出: 1 (中心障碍)

2 ) 案例 2:角色属性配置(字典 + 元表)

需求:加载角色默认属性,支持自定义覆盖

local defaults = { hp = 100, mp = 50, speed = 10 }  
local hero = setmetatable({ hp = 120 }, { index = defaults })  
print(hero.hp)  -- 输出: 120
hero.speed = 15 -- 自定义覆盖
print(hero.speed) -- 15

3 ) 案例 3:物品合成系统(混合结构)

需求:验证玩家背包材料是否满足合成配方

-- 合成配方定义 
local recipe = {
    materials = {{ "wood", "iron", "iron" }},  -- 材料排列方式(未使用)
    quantities = { wood = 1, iron = 2 }        -- 实际材料需求字典(修正为直接字典)
}

-- 检测是否能合成 
function canCraft(playerInventory)
    for item, need in pairs(recipe.quantities) do 
        if (playerInventory[item] or 0) < need then 
            return false 
        end
    end 
    return true 
end 

-- 测试用例 
local testInventory = {
    { name = "充足材料",  wood = 3, iron = 5 },  -- 材料充足 
    { name = "缺少木材",  wood = 0, iron = 5 },  -- 木材不足 
    { name = "缺少金属",  wood = 1, iron = 1 },  -- 金属不足
    { name = "无材料",    wood = 0, iron = 0 }   -- 完全不足 
}

-- 执行测试 
print("合成配方需求: wood x1, iron x2\n")
print("测试结果:")
print("---------------------------------")

for _, inv in ipairs(testInventory) do
    local result = canCraft(inv)
    local status = result and "✓ 可合成" or "✗ 不可合成"
    print(string.format("%-12s | 木材: %d | 金属: %d | %s",
          inv.name, inv.wood or 0, inv.iron or 0, status))
end

--[==[
合成配方需求: wood x1, iron x2

测试结果:
---------------------------------
充足材料 | 木材: 3 | 金属: 5 | ✓ 可合成
缺少木材 | 木材: 0 | 金属: 5 | ✗ 不可合成
缺少金属 | 木材: 1 | 金属: 1 | ✗ 不可合成
无材料    | 木材: 0 | 金属: 0 | ✗ 不可合成

]==]

性能优化技巧


1 ) 数组预分配:避免动态扩容开销,提前初始化大小

local data = {}
for i = 1, 1000 do data[i] = 0 end  -- 一次性分配

2 ) 避免哈希冲突:对高频字典使用 string 而非 number 键,减少哈希计算开销

-- 原始方案:数字键 → 冲突风险高 
local userDataByNumber = {}
for i = 1, 10000 do 
    userDataByNumber[i] = { name = "User" .. i } -- 数字键
end
 
-- 高频访问测试(易引发冲突)
for i = 1, 1000000 do
    local key = math.random(1, 10000)  -- 随机键 
    local data = userDataByNumber[key] -- 触发哈希计算
end
 
-- ✅ 优化方案:字符串键 → 减少冲突 
local userDataByString = {}
for i = 1, 10000 do 
    userDataByString[tostring(i)] = { name = "User" .. i } -- 显式转为字符串键
end
 
-- 高频访问测试(哈希计算开销更低)
for i = 1, 1000000 do 
    local key = tostring(math.random(1, 10000)) -- 字符串键
    local data = userDataByString[key]          -- 优先命中缓存哈希值 
end

3 ) 复用 Table:缓存频繁创建的 table,减少 GC 压力

-- 表缓存池实现 
local cache = {{}}  -- 初始缓存池包含一个空表 
 
function getTempTable()
    if #cache > 0 then 
        return table.remove(cache)  -- 从池中取出表
    end 
    return {}  -- 创建新表(注意:原代码返回{{}}会导致嵌套表)
end
 
function releaseTempTable(t)
    -- 清空表内容(保留表结构)
    for k in pairs(t) do 
        t[k] = nil 
    end 
    -- 放回缓存池 
    table.insert(cache, t)
end 

------------------
-- 使用示例 --
------------------
-- 1. 获取临时表
local playerData = getTempTable()
playerData.name = "Alice"
playerData.score = 95
print("Player data:", playerData.name, playerData.score)  -- 输出:Alice 95

-- 2. 归还临时表
releaseTempTable(playerData)
print("\nAfter release:", playerData.name)  -- 输出:nil(已被清空)
 
-- 3. 复用缓存表
local config = getTempTable()
config.resolution = "1920x1080"
config.volume = 80
print("\nConfig:", config.resolution)  -- 输出:1920x1080

-- 4. 检查缓存池状态
print("\nCache size:", #cache)  -- 输出:1(已归还1个表)

--[==[
Player data:	Alice	95

After release:	nil

Config:	1920x1080

Cache size:	0
]==]

高级技巧与陷阱规避


1 ) 稀疏数组处理:用 ipairs 遍历连续部分,pairs 遍历非连续部分

-- 创建稀疏数组:连续部分 + 非连续键值对 
local sparseArray = {
    "apple",        -- [1] 连续部分 
    "banana",       -- [2] 连续部分
    "cherry",       -- [3] 连续部分
    [5] = "elderberry",  -- 非连续数字键
    [8] = "fig",         -- 非连续数字键 
    color = "red",       -- 非数字键
    [true] = "boolean_key" -- 布尔类型键
}
 
-- 1. 用 ipairs 遍历连续部分 (索引 1 开始的连续整数键)
print("===== 连续部分遍历 (ipairs) =====")
for idx, value in ipairs(sparseArray) do 
    print(string.format("索引 %d: %s", idx, value))
end 
-- 输出:
-- 索引 1: apple
-- 索引 2: banana
-- 索引 3: cherry
 
-- 2. 用 pairs 遍历非连续部分 (跳过连续整数键)
print("\n===== 非连续部分遍历 (pairs) =====")
local maxIndex = #sparseArray  -- 获取连续部分最大索引 (3)
for key, value in pairs(sparseArray) do
    -- 过滤连续部分:跳过 1~maxIndex 的整数键 
    if type(key) ~= "number" 
       or key < 1 
       or key > maxIndex 
       or math.floor(key) ~= key then 
        local keyType = type(key)
        print(string.format("键[%s](%s): %s", 
              tostring(key), keyType, value))
    end
end


--[==[
===== 连续部分遍历 (ipairs) =====
索引 1: apple
索引 2: banana
索引 3: cherry

===== 非连续部分遍历 (pairs) =====
键[8](number): fig
键[true](boolean): boolean_key
键[5](number): elderberry
键[color](string): red
]==]

2 ) 安全空表判断:

function isEmpty(t)  
    return next(t) == nil  -- 高效检测空表 [9]  
end  

较全示例

-- 高效检测空表函数(官方推荐方案)[1]()[5]()
function isEmpty(t)
    return next(t) == nil  -- next(t) 返回 nil 表示无任何键值对 
end 
 
-- 示例 1: 基础用法 
local emptyTable = {}
print(isEmpty(emptyTable))  -- true 
 
local nonEmptyTable = {name = "Lua", version = 5.4}
print(isEmpty(nonEmptyTable))  -- false 
 
-- 示例 2: 数组与哈希混合表 
local mixedTable = {1, "a", key = "value"}
print(isEmpty(mixedTable))  -- false 
 
-- 示例 3: 含 nil 的表(特殊场景)
local nilTable = {nil, nil}
print(isEmpty(nilTable))    -- true,因 next() 跳过 nil 键 
print(#nilTable)            -- 0,数组长度也为 0 
 
-- 示例 4: 循环检测表是否清空 
local data = {x=10, y=20}
while not isEmpty(data) do 
    local k = next(data)   -- 获取首个键 
    data[k] = nil          -- 移除该键值对 
    print("Removed:", k)
end 
-- 输出: 
-- Removed: x 
-- Removed: y 


--[==[
true
false
false
true
0
Removed:	x
Removed:	y
]==]

3 ) 自定义迭代顺序:通过元表重写 pairs,实现按键名排序输出

-- 自定义迭代器函数:按键名排序遍历表 
local function sorted_pairs(t, order)
    local keys = {}
    for k in pairs(t) do
        table.insert(keys, k)
    end
    
    -- 使用自定义排序规则(默认字母升序)
    table.sort(keys, order)
    
    local i = 0
    return function()
        i = i + 1
        local key = keys[i]
        if key then
            return key, t[key]
        end 
    end
end
 
-- 创建示例表
local data = {
    beta = 2,
    alpha = 1,
    gamma = 3,
    delta = 4
}
 
-- 设置元表重写 __pairs 方法
setmetatable(data, {
    __pairs = function(self)
        return sorted_pairs(self, function(a, b)
            return a < b  -- 自定义排序规则:字母升序
        end)
    end 
})
 
-- 测试:按键名字母顺序输出
print("按键名字母升序输出:")
for k, v in pairs(data) do
    print(k, v)
end
 
-- 可选:使用自定义排序规则(如按键名字母长度)
print("\n按键名长度升序输出:")
for k, v in sorted_pairs(data, function(a, b)
    return #a < #b  -- 按字符串长度排序
end) do
    print(k, v)
end

设计哲学启示


Lua 的 table 设计体现了 “简单即强大” 的理念:

  • 单一结构覆盖数组、字典、类、模块等多重角色
  • 经济性优先:拒绝为小众场景增加语法糖(如内置 OOP),鼓励用基础结构组合实现复杂需求

完整代码示例及性能测试工具可参考:

最佳实践


  1. 根据使用场景选择遍历方式,数组优先使用ipairs保证遍历顺序,字典必须使用pairs
  2. 数组内部尽量保持索引连续以兼容#长度运算符与table系数组方法
  3. 避免在同一个表中大量混合使用数组与字典逻辑,维护时不利于代码可读性与性能优化
  4. 字典排序前务必将键转为独立数组,利用table.sort完成排序后再遍历取值

如果你想深入了解元表对数组与字典的自定义操作,我可以补充相关实践案例与代码示例

要点回顾


  • Lua 的 table 是实现 数组 和 字典 的唯一数据结构
  • 通过数字键访问时,table 表现为数组;通过字符串或其他类型键访问时,table 表现为字典
  • 选择合适的遍历函数:ipairs 用于连续数字索引的数组,pairs 用于所有键值对(包括字典和非连续数组)
  • 数组索引默认从 1 开始,这是 Lua 的约定
Lua-Dictionary:原型模式 Lua字典 原型模式 单元字典 单元格中的字典不同于Python。 它类似于C ++ Multimap对象。 在Lua中,它本身就是一个表表。 因为Lua是一种关联的内存编程语言,所以它放弃了类似的怪异要求。 我们可以完全在Lua中做到 对于Lua词典,它是一个表,而每个条目都是一个表。 a = {} a[ " key " ] = {} a[ " man " ]. slim = walker a[ " tom " ][ 1337 ] = slim 因为它是关联内存的关联数组。 将来,我们可以创建元理论。 那就是一个神经网络联想记忆单元。 它是由科学家编程的,我不知道它是如何工作的。 数学非常简单,但是超尺寸非常困难。 这是元理论,根本不是我们要做的事情。 但是,就像我们可以想象的科幻小说一样,然后我们创建代码逻辑来实现我们认为应该起作用的功能。 我们知道神经网络的工作原理 但是,他们不 立即下载

相关推荐

远程桌面连接失败?手把手教你解决CredSSP加密Oracle漏洞(Win10/Win11通用)

本文详细解析了Windows远程桌面连接因CredSSP加密Oracle漏洞安全更新导致的“身份验证错误”问题。文章从原理入手,提供了通过组策略编辑器(适用于专业版)和注册表编辑器(适用于家庭版)两种核心解决方案,指导用户将安全策略调整为推荐的“缓解”模式,以在保障安全的前提下恢复连接,并给出了高级脚本处理与安全最佳实践。

u6v7w8x的博客 730

Lua 字典

Lua 字典 dir = {["zzs"] = 18,["wy"] = 15,["lzq"] = 12} print(dir["zzs"]) print(dir.wy) print(dir.lzq) print("----------") --添加新元素 dir["sex"] = 12 dir.pnb = 16 --删除旧元素 dir.sex = nil dir["pnb"] = nil --遍历方式 for i, v in pairs(dir) do print(i,v) end print("-

zzzsss123333的博客 1766

睿尔曼超轻量仿人机械臂--机械臂接口介绍

本文介绍了睿尔曼超轻量仿人机械臂的控制器接口及末端接口。

realman_Rop的博客 3440

Lua 实现字典

声明 a={[“name”]=“小红”,[“age”]=15,[“1”]=1} 访问 print(a[“name”]) print(a[“age”]) 访问2 key为数值类型的字符串时 不能访问 print(a.name) print(a.age) 修改 a.name=“小宝” print(a.name) 增加 添加新的键 a[“class”]=“12” print(a.class) 移除 a[“class”]=nil print(a.class) 遍历 for k,v in pairs(a) do p.

记录 3026

二维紧束缚模型求解程序

假如我们已经推导出了二维紧束缚模型的哈密顿量矩阵H(kx,ky)的解析形式,那么在整个布里渊区对角化矩阵就可以得到能带。从技术上说这里面有以下几个问题。 1. 缺少实空间和倒空间的坐标,使得能带难以和布里渊区高对称点对应。 2. 最容易处理的布里渊区是矩形,对于其他多边形,如果全布里渊区mesh画费米面有一定技术困难。 因此一个好的处理框架是首先给出实空间原子坐标,给出实空间哈密顿量,...

wwxy1995的博客 4085

CS224W图神经网络实战:如何用Motifs和Graphlets分析社交网络结构?

本文基于斯坦福CS224W课程,深入探讨了如何利用网络模体(Motifs)和图元(Graphlets)分析社交网络的微观结构。通过实战代码演示,文章介绍了如何识别具有统计显著性的关键连接模式,计算节点的图元度向量以刻画局部拓扑特征,并将这些结构洞见应用于社区发现、影响力分析及图神经网络的节点特征工程,从而提升模型在虚假账号检测等任务中的性能。

2w3e4r5t6y的博客 912

Lua学习------table实现字典

print("************复杂数据类型——表2************") print("************字典************") print("************字典的申明************") --字典是由键值对构成 a = {["name"] = "唐老鸭" ,["age"] = 14 , ["1"] = 5} --访问当个变量 用中括号填键 来访问 print(a["name"]) print(a["age"]) print(a["1"]) --还可以.类似成

木辛木又 2376

微调大模型如何准备数据集——常用数据集,Alpaca和ShareGPT

在大模型微调中,我们一般使用Alpaca 和 ShareGPT和两种格式的数据集。

Science prince的博客 1097

Lua表实现字典

-遍历 用pairs。

holens01的博客 338

基于Python的FTA协定内容爬虫实战:从数据抓取到智能分析

本文将详细介绍如何使用Python构建一个高效的FTA(自由贸易协定)内容爬虫,涵盖最新技术如Playwright、异步IO、智能解析等。通过本教程,您将学会如何从各类政府网站和国际组织平台抓取结构化FTA数据,并对其进行清洗、存储和分析。文章包含完整的代码实现和最佳实践指南,适合中高级Python开发者学习网络爬虫开发。

2201_76125261的博客 994

YOLOv12超参数智能优化:基于内置Ray Tune的自动化调优实战指南

购买即可解锁300+YOLO优化文章,并且还有海量深度学习复现项目,价格仅需两杯奶茶的钱,别人有的本专栏也有! 目标检测模型的性能瓶颈往往源于超参数配置不当。传统手动调优方式不仅耗时耗力,且难以找到全局最优解。YOLOv12集成的Ray Tune框架为解决这一难题提供了完整方案,通过分布式异步优化算法,可实现超参数搜索效率的指数级提升。实际测试表明,采用Ray Tune自动调优的YOLOv12模型,在COCO数据集上mAP指标平均提升3.8%,收敛速度加快2.1倍。在VisDrone无人机数据集上的跨域测试

LXY_LOVE36的博客 119

Lua语法 | 8、字典(表)

本文讲解了如何在Lua中创建字典、操作字典、遍历字典、使用字典模式、使用字典常用函数,并且举出了一些常见的注意事项。

独立游戏开发者 1251

《备考系统架构设计师》 - 专栏介绍和目录

本专栏包括所有历年真题及详解、章节知识核心总结、精选高分论文、补充知识、专题总结等。欢迎订阅专栏。

数据知道的博客 4万+

Lua中字典型table的增删操作

table table(表)是Lua中一种基础且使用频率极高的数据结构,他的本质是“关联数组”! 根据内部元素的不同,我们一般可以将table分为数组型table和字典型(键值对型)table: 数组型table:将元素的值顺序存储到table中,元素的索引为从1开始连续递增的整数。例如: arrayTbl={3,5,7} arrayTbl对应的key为:1,2,3 字典型...

fightsyj的博客 4222

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

lua之table的使用

本文对从数据结构,存储和使用三个角度对lua之table的使用进行小结。 数据结构: table是lua的一种数据结构,可以用来存放各种类型的元素,例如可以创建数组和字典,以及二者混合的数据结构, 例如: a={“hello”,“world”,“lua”} --数组 b={a=“hello”,b=“world”,c=“lua”} --字典 c={“hello”,b=“world”,“lua”} --数组元素和字典元素混合 存储: lua的table使用数组和哈希表结合的方式,使用string或者0

cindyxue_17的博客 4847

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Lua的table(表)

Lua中的表(table)是一种多功能数据结构,可以用作数组、字典、集合等。表是Lua中唯一的数据结构机制,其他数据结构如数组、列表、队列等都可以通过表来实现。

Meiko_ahri的博客 1320

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

Lua: 表机制深度解析之数组字典实现与迭代器应用

本文深入解析Lua表的核心机制与高级应用。Lua表采用双段存储结构(数组段+哈希段)实现高效访问,并通过元表扩展支持OOP特性。重点对比了pairs和ipairs迭代器的底层差异:pairs遍历所有键值对,而ipairs仅处理连续整数索引。文章还提供了表操作库的实战案例,包括数组操作、字符串连接和排序优化,并给出性能优化建议如避免稀疏数组、高效过滤空值等。通过自定义迭代器和LRU缓存等案例,展示了Lua表在复杂场景下的灵活应用。

Wang的专栏 1663

Lua中Table表与C#数组区别

table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型,如:数组、字典等。 table表中数组与C#数组区别:(table表并不完全等同于C#数组) 一、table表中数组索引值可以为任意类型(可以为负数),但不能为nil类型 C#数组类型只能为整数类型 二、table表数组元素可以连接,C#数组不可以 三、table表数组元素可以插入和删除,C#数组不可以 实...

TianWeiKai的博客 1307

Lua处理从C#获得的数组、字典、结构体等

Lua从C#获得到的数组、字典等都是userdata。 C#获得到的数组索引从0开始。 C#获得到的字典数据处理: local testData = CS.LuaCallCSUtils.GetTestData() --为一个字典 local iter = testData:GetEn...

chuangpeng7633的博客 1698

【Lua学习笔记】Lua进阶——Table,迭代器

上文我们讲到了Lua的一些入门知识点,本文将补充Lua的一些进阶知识。

milu_ELK的博客 1638

Lua之table

1.table 介绍 什么是 table? table 是 Lua 语言中的一种“数据/代码结构”,可以用来帮助我们创建不同的“数据类型”。 其实我们之前讲解的 Lua 语言版本的数组,这个数组是什么类型? Lua 语言中的数组其实就是 table 类型。 案例:创建一个 Lua 版本的数组,然后用 type 方法获取数组的数据类型. 我们之前讲解的 lua 当中的 string,number,boolean,这三个是 Lua 当中的基本数据类型;而 table 也是数据类型,只不过是稍微高级一点的数据类型

lcy的博客 3792

lua 数组与表的异同

lua 数组与表的异同 在lua中,table是唯一的数据结构,通过表我们可以实现大部分的重要的数据结构,比如树,字典,当然,lua是没有表的,但是可以用表实现数组。 表 table不是值或者变量,而是对象。 table是不固定大小的,你可以根据自己需要进行扩容。 -- 初始化表 mytable = {} -- 指定值 mytable[1]= "Lua" -- 移除引用 mytable = nil -- lua 垃圾回收会释放内存 当我们为 table a 设置元素,然后将 a 赋值给 b,则 a 与

lovemo的博客 3610

Lua table(表)

table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型,如:数组、字典等。Lua table 使用关联型数组,你可以用任意类型的值来作数组的索引,但这个值不能是 nil。Lua table 是不固定大小的,你可以根据自己需要进行扩容。Lua也是通过table来解决模块(module)、包(package)和对象(Object)的。 例如string.format表示使用"format"来索引table string。构造器是创建和初始化表的表达式。表是Lua特有的功能强大的东西。最简单的构造函

chenjiniu的博客 981

【lua】table基础操作

lua table

kinghzking的专栏 927
上一篇: Lua: 核心机制解析之函数的多维魔法与模块化封装艺术
下一篇: Lua: 表机制深度解析之数组字典实现与迭代器应用
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值