• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    迪恩网络公众号

lua工具库penlight--06数据(一)

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

这篇太长了,分了两部分。(这个是机器翻译之后我又校对了一下,以后的都这样,人工翻译太累了。)

读数据文件

首先考虑清楚,你的确需要一个自定义的文件读入器吗?如果是,你能确定有能力写好吗?

正确,稳健,快速,当如先得把第一项处理好。

Unix世界里常见的数据文件夹是配置文件。在Java世界里也被叫做属性文件。

 # Read timeout in seconds

read.timeout=10

 

# Write timeout in seconds

write.timeout=10

 

下面是简单的Lua的实现:

-- property file parsing with Lua string patterns

props = []

for line in io.lines() do

     if line:find('#',1,true) ~= 1 and not line:find('^%s*$') then

         local var,value = line:match('([^=]+)=(.*)')

         props[var] = value

     end

end

 

非常简洁,不过用了字符串匹配技巧,对于读者来说不易读懂。

下面是利用Penlight的实现:

require 'pl'

stringx.import()

props = []

for line in io.lines() do

     if not line:startswith('#') and not line:isspace() then

         local var,value = line:splitv('=')

         props[var] = value

     end

end

 

显然上面的代码可以自为文档,而不需要到处写注释。它的速度稍微有点慢

,但是事实上脚本的速度有I/O决定,因此一下优化是必须的。

 

读无结够的文本数据

文本经常是无结构的。pl.input提供了许多简化操作的函数。例如统计文本

中的单词数量:

 -- countwords.lua

require 'pl'

local k = 1

for w in input.words(io.stdin) do

     k = k + 1

end

print('count',k)

 

或者计算平均数:

 -- average.lua

require 'pl'

local k = 1

local sum = 0

for n in input.numbers(io.stdin) do

     sum = sum + n

     k = k + 1

end

print('average',sum/k)

这些脚本可以通过进一步排除循环提高效率。下面这个例子,使用seq.sum函数

计算数字序列的和。

-- average2.lua

require 'pl'

local total,n = seq.sum(input.numbers())

print('average',total/n)

 

一个更简单的例子是,从输入中提取参数,如下:

-- countwords2.lua

require 'pl'

print('count',seq.count(input.words()))

 

一个有用的序列生成器要能直接读取字符串。下面这个例子计算文件中每行的数字和:

-- sums.lua

for line in io.lines() do

     print(seq.sum(input.numbers(line))

end

 

读分隔文件

读取分隔文件是常有的事,它们或以空格、或者逗号分隔,或许还有初始的列头。

如下例:

 EventID    Magnitude    LocationX    LocationY    LocationZ

 981124001    2.0    18988.4    10047.1    4149.7

 981125001    0.8    19104.0    9970.4    5088.7

 981127003    0.5    19012.5    9946.9    3831.2

...

 

input.fields可以提取列,并且可以设置分隔符(默认空格)。

下面是计算所有事件里x的平均位置:(即上表中的LocationX 

 -- avg-x.lua

require 'pl'

io.read() -- skip the header line

local sum,count = seq.sum(input.fields {3})

print(sum/count)

 

input.fields可以提取列,并且可以设置分隔符(默认空格)。

下面是计算所有事件里x的平均位置:(即上表中的LocationX 

 -- avg-x.lua

require 'pl'

io.read() -- skip the header line

local sum,count = seq.sum(input.fields {3})

print(sum/count)

 

input.fields可以使用字段数或列数,可以从1开始也可以从其它列开始。如果你传递一个字段计数,你会得到该计数的每个字段:

 for id,mag,locX,locY,locZ in input.fields (5) do

 ....

 end

 

input.fields 默认会尝试将每个字段转换为数字。它将跳过不匹配模式的字段,如果任何字段都不能转换为数字时会中止脚本。input.fields第二个参数是分隔符,默认是空格。如果传入’ ‘,会匹配 '任意数目的空格',即 '%s+',你可以使用 任意的Lua 字符串匹配模式。

第三个参数是数据源,默认为标准输入 (由input.create_getter定义)。它假定数据源有一个read的方法,可以产生下一行,即它是一个 '类文件对象。作为一种特殊情况,一个字符串,将分成多行:

 > for x,y in input.fields(2,' ','10 20\n30 40\n') do print(x,y) end

 10      20

 30      40

 

注意对于坏的字段,默认行为是显示出错的行号:

 > for x,y in input.fields(2,' ','10 20\n30 40x\n') do print(x,y) end

 10      20

 line 2: cannot convert '40x' to number

 

Input.fields的这种行为是适当的,第四个可选参数是一个选项表: {no_fail=true}意味着尝试转换后失败后,仅返回字符串,而不是向 AWK(译注:一个*nix下的文本匹配工具)继续运行。你有责任检查返回的字段的类型。{no_convert=true}是否将所有字段都作为字符串返回。

有时将整个数据放到内存中,会很有用,如提取的列的操作。Penlight专门为阅读此类型的数据,提供了一个灵活的data解析器。例如看起来像这样的文件:

 x,y

 10,20

 2,5

 40,50

 

data.read将创建如下的表,每一行创建一个子表:

 > t = data.read 'test.txt'

 > pretty.dump(t)

 {{10,20},{2,5},{40,50},fieldnames={'x','y'},delim=','}

 

现在,您可以使用提供的方法来分析返回的表。例如,方法column_by_name返回的列的所有表。

 -- testdata.lua

 require 'pl'

 d = data.read('fev.txt')

 for _,name in ipairs(d.fieldnames) do

     local col = d:column_by_name(name)

     if type(col[1]) == 'number' then

         local total,n = seq.sum(col)

         utils.printf("Average for %s is %f\n",name,total/n)

     end

 end

 

data.read有点小聪明,默认情况下它期望第一行是列名称,除非其中都是何数字。它会尝试推导第一行的列分隔符。有时它会猜错,当然可以显式指定分隔符。第二个可选参数是一个选项表: 可以重写delim 字符串匹配模式),fieldnames(列表或逗号分隔的字符串),是否转换no_convert (默认是要转换),numfields (列表中的列的索引) 和thousands_dot 千位在 Excel CSV 中的分隔符是 ‘. ')

一个非常强大的功能是在这种数据上执行类似于 SQL 的查询:

 -- queries on tabular data

 require 'pl'

 local d = data.read('xyz.txt')

 local q = d:select('x,y,z where x > 3 and z < 2 sort by y')

 for x,y,z in q do

     print(x,y,z)

 end

 

请注意查询的格式限于以下语法:

 FIELDLIST [ 'where' CONDITION ] [ 'sort by' FIELD [asc|desc]]

 

任何有效的 Lua 代码都可以出现在CONDITION中;请记住它并不是SQL,您必须使用== (此警告来自于经验)

若想这样,字段名称必须是 Lua 的标识符。所以read会改变字段名,这样,所有非字母数字字符替换为下划线。然而, original_fieldnames字段总是包含原始字段名。

read可以很好的处理标准 CSV 文件,但是它不会尝试成为一个全面的 CSV 分析器。加上csv=true选项,可以处理双引号字段,这些字段可以包含逗号,尾随逗号也是有意义的。

电子表格程并不总是处理这种数据最好的工具,这看起来可能对某些人很奇怪。下面是一个玩具 CSV 文件 ;要认识这个问题,想象类似下面的数千行和数十列:

 Department Name,Employee ID,Project,Hours Booked

 sales,1231,overhead,4

 sales,1255,overhead,3

 engineering,1501,development,5

 engineering,1501,maintenance,3

 engineering,1433,maintenance,10

 

任务是减少相关的行和列的数据、 或许做一些处理行的数据,并将结果写到一个新的 CSV 文件。write_row方法使用分隔符将行写入一个文件 ;Data.select_row类似Data.select,除了它会循环访问行,而不是字段;如果我们处理很多列,这是必要的 !

 names = {[1501]='don',[1433]='dilbert'}

 keepcols = {'Employee_ID','Hours_Booked'}

 t:write_row (outf,{'Employee','Hours_Booked'})

 q = t:select_row {

     fields=keepcols,

     where=function(row) return row[1]=='engineering' end

 }

 for row in q do

     row[1] = names[row[1]]

     t:write_row(outf,row)

 end

 

Data.select_rowData.select可以传递一个表,并指定查询 ;字段表,定义条件和可选参数的sort_by函数。它不是必须的,但如果我们有更复杂的行条件 (如属于指定的一组)。

如果不能存到hackery(不知如何翻译)如全局变量,将不能作为一般条件查询字符串。

在 1.0.3,您可以指定所选列的显式转换函数。例如,这是 Unix 日期戳一个日志文件:

 Time Message

 1266840760 +# EE7C0600006F0D00C00F06010302054000000308010A00002B00407B00

 1266840760 closure data 0.000000 1972 1972 0

 1266840760 ++ 1266840760 EE 1

 1266840760 +# EE7C0600006F0D00C00F06010302054000000408020A00002B00407B00

 1266840764 closure data 0.000000 1972 1972 0

 

我们想把第一列作为实际日期对象,这样convert可以从1显式转换字段。(请注意第一次我们必须显式转换字符串为数字)。

 Date = require 'pl.Date'

 

 function date_convert (ds)

     return Date(tonumber(ds))

 end

 

 d = data.read(f,{convert={[1]=date_convert},last_field_collect=true})

 

这给了我们一个两列数据集,其中的第一列包含日期对象,第二列包含该行的其余部分。查询可以很容易找出事件发生的一天:

 q = d:select "Time,Message where Time:weekday_name()=='Sun'"

 

数据没有来从文件,也不一定来自于实验室或会计部。在 Linux 上, ps aux为您提供在您的机器上运行的所有进程的完整列表。直接把ps aux的结果送入data.read,并对它执行有用的查询。请注意非标识符字符,如 %会转化为下划线:

 require 'pl'

 f = io.popen 'ps aux'

 s = data.read (f,{last_field_collect=true})

 f:close()

 print(s.fieldnames)

 print(s:column_by_name 'USER')

 qs = 'COMMAND,_MEM where _MEM > 5 and USER=="steve"'

 for name,mem in s:select(qs) do

     print(mem,name)

 end

 

我一直崇拜 AWK 编程语言 ;使用filter中,您可以让lua作为简单的AWK

 -- printxy.lua

 require 'pl'

 data.filter 'x,y where x > 3'

 

数据文件没有标题,没有字段名称,是常见现象。如果所有字段都是数字,data.read把此类文件为一个特殊的例外。由于在查询表达式中无法使用的列名称,您可以使用 类AWK的 索引,例如 ' $1、 $2$1 > 3'。我有一个小的可执行脚本,在我的系统称为lf这看起来像这样:

 #!/usr/bin/env lua

 require 'pl.data'.filter(arg[1])

 

它可用于一般的从数据中提取列的筛选器命令。(列规格可能是表达式或甚至常量)

 $ lf '$1,$5/10' < test.dat

 

(与 AWK类似,请注意在此命令使用单引号,这样可以防止shell解释列索引。如果您在 Windows 上,你必须用在双引号引起传递给您的批处理文件参数)

作为教程的资源,看看test-data.lua的使用,以及其他例子的评论。

 

从readData.copy_select查询返回的数据,基本上是只是数组的行: {{1,2},{3,4}}。所以您可以使用read处理任何类似数组的数据集,或者任何其它类似的函数处理。尤其是,在array2d函数中数据工作正常。事实上,这些函数可以作为方法 ;例如array2d.flatten ,可以直接给我们一维列表:

 v = data.read('dat.txt'):flatten()

 

LuaMatrix期望数据像矩阵一样正确的形状:

 > matrix = require 'matrix'

 > m = matrix(data.read 'mat.txt')

 > = m

 1       0.2     0.3

 0.2     1       0.1

 0.1     0.2     1

 > = m^2  -- same as m*m

 1.07    0.46    0.62

 0.41    1.06    0.26

 0.24    0.42    1.05

 

write将写入矩阵文件。

最后,可以使用全局变量_DEBUG打印出查询生成并动态编译的实际迭代器函数。通过使用代码生成,我们可以任优化查询的性能。

 > lua -lpl -e "_DEBUG=true" -e "data.filter 'x,y where x > 4 sort by x'" < test.txt

 return function (t)

         local i = 0

         local v

         local ls = {}

         for i,v in ipairs(t) do

             if v[1] > 4  then

                     ls[#ls+1] = v

             end

         end

         table.sort(ls,function(v1,v2)

             return v1[1] < v2[1]

         end)

         local n = #ls

         return function()

             i = i + 1

             v = ls[i]

             if i > n then return end

             return v[1],v[2]

         end

 end

 

 10,20

 40,50

 

 

读取配置文件

配置模块提供了把几种类型的配置文件转换为一个 Lua 表的简单方法。考虑的简单示例:

 # test.config

 # Read timeout in seconds

 read.timeout=10

 

 # Write timeout in seconds

 write.timeout=5

 

 #acceptable ports

 ports = 1002,1003,1004

 

可以使用config.read读,使用pretty.write显示结果 :

 -- readconfig.lua

 local config = require 'pl.config'

 local pretty= require 'pl.pretty'

 

 local t = config.read(arg[1])

 print(pretty.write(t))

 

lua readconfig.lua test.config的输出是:

 {

   ports = {

     1002,

     1003,

     1004

   },

   write_timeout = 5,

   read_timeout = 10

 }

 

config.read将产生所有键/值对,忽略 注释,并确保键名称是正确的 Lua 标识符,通过非标识符字符替换为 _。如果这些值是数字,他们将被转换。(所以t.write_timeout的值是数字 5)。此外,由逗号分隔的任何值将同样转换为数组。

可以一个反斜杠续行。考虑下面这行:

 names=one,two,three, \

 four,five,six,seven, \

 eight,nine,ten

 

此外支持 Windows 风格的 INI 文件。INI 文件的部分结构自然转换为嵌套表在 Lua 中:

 ; test.ini

 [timeouts]

 read=10 ; Read timeout in seconds

 write=5 ; Write timeout in seconds

 [portinfo]

 ports = 1002,1003,1004

 

输出为:

 {

   portinfo = {

     ports = {

       1002,

       1003,

       1004

     }

   },

   timeouts = {

     write = 5,

     read = 10

   }

 }

 

你现在可以这样用t.timeouts.write引用write timeout.

最后一个例子显示config.read 读取逗号分隔的文件的灵活性。

 one,two,three

 10,20,30

 40,50,60

 1,2,3

 

它将生成下表:

 {

   { "one", "two", "three" },

   { 10, 20, 30 },

   { 40, 50, 60  },

   { 1, 2, 3 }

 }

 

config.read不是设计为读取所有的 CSV 文件,但打算支持没有键-值对的结构,如 '/ etc/passwd' 等一些 Unix 配置文件   。

这个函数想成为读取配置的瑞士军刀,它无需做出假设,你也可能不喜欢他们(假设)。所以有一个可选的额外参数,来进行一些控制,可能有以下字段:

 {

    variablilize = true,

    convert_numbers = tonumber,

    trim_space = true,

    list_delim = ',',

    trim_quotes = true,

    ignore_assign = false,

    keysep = '=',

    smart = false,

 }

 

variablilize选项即第一个示例中将write.timeout转化write_timeout 。如果convert_numbers为 true,尝试转换开始像数的任何字符串。您可以指定您自己的函数 (如像 '5224 kb' 的字符串转换为数字)。

trim_space可确保有没有开始或结尾的空白值,list_delim分割字符 (如可能 Lua 字符串模式 '%s+'.)

例如,在 Unix 中的密码文件是冒号分隔:

 t = config.read('/etc/passwd',{list_delim=':'})

 

这将产生以下输出在我的系统 (只有最后两线所示):

 {

   ...

   {

     "user",

     "x",

     "1000",

     "1000",

     "user,,,",

     "/home/user",

     "/bin/bash"

   },

   {

     "sdonovan",

     "x",

     "1001",

     "1001",

     "steve donovan,28,,",

     "/home/sdonovan",

     "/bin/bash"

   }

 }

 

你可以进入这一个更明智的格式,加上判断哪些用户名是索引( tablex.pairmap函数必须返回valuekey!)

 t = tablex.pairmap(function(k,v) return v,v[1] end,t)

 

得到:

 { ...

   sdonovan = {

     "sdonovan",

     "x",

     "1001",

     "1001",

     "steve donovan,28,,",

     "/home/sdonovan",

     "/bin/bash"

   }

 ...

 }

 

许多常见的 Unix 配置文件可以通过调整这些参数读取。/etc/fstab,选项为{list_delim=‘%s+’,ignore_assign=true}将正确分隔列。在文件里查找’KEY VALUE’是常见的,如/etc/ssh/ssh_config; 选项{keysep=‘ ’}使config.read返回一个表,其中每个key具有一个值value。

在 Linux 中的文件procfs通常使用 ':’作为分隔符

 > t = config.read('/proc/meminfo',{keysep=':'})

 > = t.MemFree

 220140 kB

 

这一结果是一个字符串,因为tonumber不喜欢它,但把convert_numbers定义为function(s) return tonumber((s:gsub(' kB$',''))) end,可以返回实际数字。(额外的括号是必要因此tonumber仅从gsub中获取的第一个结果)。

tests/test-config.lua':

 testconfig([[

 MemTotal:        1024748 kB

 MemFree:          220292 kB

 ]],

 { MemTotal = 1024748, MemFree = 220292 },

 {

  keysep = ':',

  convert_numbers = function(s)

     s = s:gsub(' kB$','')

     return tonumber(s)

   end

  }

 )

 

smart选项可以让config.read替你一个合理的猜测,例子为tests/test-config.lua。基本上可以直接在智能模式下处理这些常见的文件格式 (那些遵循同一模式的文件): /etc/fstab ''/ proc/XXXX/status''ssh_config' 和 'pdatedb.conf'

请注意, config.read可以传入类文件对象的参数;如果它不是一个字符串,并支持read方法,才可以使用。例如,若要从字符串中读取一个配置,请使用stringio.open .


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
lua的匹配规则发布时间:2022-07-22
下一篇:
lua代码优化(转)发布时间:2022-07-22
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap