标签 awk 下的文章

Awk 是一个强大的工具,可以执行某些可能由其它常见实用程序(包括 sort)来完成的任务。

Awk 是个普遍存在的 Unix 命令,用于扫描和处理包含可预测模式的文本。但是,由于它具有函数功能,因此也可以合理地称之为编程语言。

令人困惑的是,有不止一个 awk。(或者,如果你认为只有一个,那么其它几个就是克隆。)有 awk(由Aho、Weinberger 和 Kernighan 编写的原始程序),然后有 nawkmawk 和 GNU 版本的 gawk。GNU 版本的 awk 是该实用程序的一个高度可移植的自由软件版本,具有几个独特的功能,因此本文是关于 GNU awk 的。

虽然它的正式名称是 gawk,但在 GNU+Linux 系统上,它的别名是 awk,并用作该命令的默认版本。 在其他没有带有 GNU awk 的系统上,你必须先安装它并将其称为 gawk,而不是 awk。本文互换使用术语 awkgawk

awk 既是命令语言又是编程语言,这使其成为一个强大的工具,可以处理原本留给 sortcutuniq 和其他常见实用程序的任务。幸运的是,开源中有很多冗余空间,因此,如果你面临是否使用 awk 的问题,答案可能是肯定的“随便”。

awk 的灵活之美在于,如果你已经确定使用 awk 来完成一项任务,那么无论接下来发生什么,你都可以继续使用 awk。这包括对数据排序而不是按交付给你的顺序的永恒需求。

样本数据集

在探索 awk 的排序方法之前,请生成要使用的样本数据集。保持简单,这样你就不会为极端情况和意想不到的复杂性所困扰。这是本文使用的样本集:

Aptenodytes;forsteri;Miller,JF;1778;Emperor
Pygoscelis;papua;Wagler;1832;Gentoo
Eudyptula;minor;Bonaparte;1867;Little Blue
Spheniscus;demersus;Brisson;1760;African
Megadyptes;antipodes;Milne-Edwards;1880;Yellow-eyed
Eudyptes;chrysocome;Viellot;1816;Sothern Rockhopper
Torvaldis;linux;Ewing,L;1996;Tux

这是一个很小的数据集,但它提供了多种数据类型:

  • 属名和种名,彼此相关但又是分开的
  • 姓,有时是以逗号开头的首字母缩写
  • 代表日期的整数
  • 任意术语
  • 所有字段均以分号分隔

根据你的教育背景,你可能会认为这是二维数组或表格,或者只是行分隔的数据集合。你如何看待它只是你的问题,而 awk 只认识文本。由你决定告诉 awk 你想如何解析它。

只想排序

如果你只想按特定的可定义字段(例如电子表格中的“单元格”)对文本数据集进行排序,则可以使用 sort 命令

字段和记录

无论输入的格式如何,都必须在其中找到模式才可以专注于对你重要的数据部分。在此示例中,数据由两个因素定界:行和字段。每行都代表一个新的记录,就如你在电子表格或数据库转储中看到的一样。在每一行中,都有用分号(;)分隔的不同的字段(将其视为电子表格中的单元格)。

awk 一次只处理一条记录,因此,当你在构造发给 awk 的这指令时,你可以只关注一行记录。写下你想对一行数据执行的操作,然后在下一行进行测试(无论是心理上还是用 awk 进行测试),然后再进行其它的一些测试。最后,你要对你的 awk 脚本要处理的数据做好假设,以便可以按你要的数据结构提供给你数据。

在这个例子中,很容易看到每个字段都用分号隔开。为简单起见,假设你要按每行的第一字段对列表进行排序。

在进行排序之前,你必须能够让 awk 只关注在每行的第一个字段上,因此这是第一步。终端中 awk 命令的语法为 awk,后跟相关选项,最后是要处理的数据文件。

$ awk --field-separator=";" '{print $1;}' penguins.list
Aptenodytes
Pygoscelis
Eudyptula
Spheniscus
Megadyptes
Eudyptes
Torvaldis

因为字段分隔符是对 Bash shell 具有特殊含义的字符,所以必须将分号括在引号中或在其前面加上反斜杠。此命令仅用于证明你可以专注于特定字段。你可以使用另一个字段的编号尝试相同的命令,以查看数据的另一个“列”的内容:

$ awk --field-separator=";" '{print $3;}' penguins.list
Miller,JF
Wagler
Bonaparte
Brisson
Milne-Edwards
Viellot
Ewing,L

我们尚未进行任何排序,但这是良好的基础。

脚本编程

awk 不仅仅是命令,它是一种具有索引、数组和函数的编程语言。这很重要,因为这意味着你可以获取要排序的字段列表,将列表存储在内存中,进行处理,然后打印结果数据。对于诸如此类的一系列复杂操作,在文本文件中进行操作会更容易,因此请创建一个名为 sort.awk 的新文件并输入以下文本:

#!/bin/gawk -f

BEGIN {
        FS=";";
}

这会将该文件建立为 awk 脚本,该脚本中包含执行的行。

BEGIN 语句是 awk 提供的特殊设置功能,用于只需要执行一次的任务。定义内置变量 FS,它代表 字段分隔符 field separator ,并且与你在 awk 命令中使用 --field-separator 设置的值相同,它只需执行一次,因此它包含在 BEGIN 语句中。

awk 中的数组

你已经知道如何通过使用 $ 符号和字段编号来收集特定字段的值,但是在这种情况下,你需要将其存储在数组中而不是将其打印到终端。这是通过 awk 数组完成的。awk 数组的重要之处在于它包含键和值。 想象一下有关本文的内容;它看起来像这样:author:"seth",title:"How to sort with awk",length:1200。诸如作者、标题和长度之类的元素是键,跟着的内容为值。

在排序的上下文中这样做的好处是,你可以将任何字段分配为键,将任何记录分配为值,然后使用内置的 awk 函数 asorti()(按索引排序)按键进行排序。现在,随便假设你想按第二个字段排序。

没有被特殊关键字 BEGINEND 引起来的 awk 语句是在每个记录都要执行的循环。这是脚本的一部分,该脚本扫描数据中的模式并进行相应的处理。每次 awk 将注意力转移到一条记录上时,都会执行 {} 中的语句(除非以 BEGINEND 开头)。

要将键和值添加到数组,请创建一个包含数组的变量(在本示例脚本中,我将其称为 ARRAY,虽然不是很原汁原味,但很清楚),然后在方括号中分配给它键,用等号(=)连接值。

{   # dump each field into an array
    ARRAY[$2] = $R;
}

在此语句中,第二个字段的内容($2)用作关键字,而当前记录($R)用作值。

asorti() 函数

除了数组之外,awk 还具有一些基本函数,你可以将它们用作常见任务的快速简便的解决方案。GNU awk中引入的函数之一 asorti() 提供了按键(索引)或值对数组进行排序的功能。

你只能在对数组进行填充后对其进行排序,这意味着此操作不能对每个新记录都触发,而只能在脚本的最后阶段进行。为此,awk 提供了特殊的 END 关键字。与 BEGIN 相反,END 语句仅在扫描了所有记录之后才触发一次。

将这些添加到你的脚本:

END {
    asorti(ARRAY,SARRAY);
    # get length
    j = length(SARRAY);
   
    for (i = 1; i <= j; i++) {
        printf("%s %s\n", SARRAY[i],ARRAY[SARRAY[i]])
    }
}

asorti() 函数获取 ARRAY 的内容,按索引对其进行排序,然后将结果放入名为 SARRAY 的新数组(我在本文中发明的任意名称,表示“排序的 ARRAY”)。

接下来,将变量 j(另一个任意名称)分配给 length() 函数的结果,该函数计算 SARRAY 中的项数。

最后,使用 for 循环使用 printf() 函数遍历 SARRAY 中的每一项,以打印每个键,然后在 ARRAY 中打印该键的相应值。

运行该脚本

要运行你的 awk 脚本,先使其可执行:

$ chmod +x sorter.awk

然后针对 penguin.list 示例数据运行它:

$ ./sorter.awk penguins.list
antipodes Megadyptes;antipodes;Milne-Edwards;1880;Yellow-eyed
chrysocome Eudyptes;chrysocome;Viellot;1816;Sothern Rockhopper
demersus Spheniscus;demersus;Brisson;1760;African
forsteri Aptenodytes;forsteri;Miller,JF;1778;Emperor
linux Torvaldis;linux;Ewing,L;1996;Tux
minor Eudyptula;minor;Bonaparte;1867;Little Blue
papua Pygoscelis;papua;Wagler;1832;Gentoo

如你所见,数据按第二个字段排序。

这有点限制。最好可以在运行时灵活选择要用作排序键的字段,以便可以在任何数据集上使用此脚本并获得有意义的结果。

添加命令选项

你可以通过在脚本中使用字面值 var 将命令变量添加到 awk 脚本中。更改脚本,以使迭代子句在创建数组时使用 var

{ # dump each field into an array
    ARRAY[$var] = $R;
}

尝试运行该脚本,以便在执行脚本时使用 -v var 选项将其按第三字段排序:

$ ./sorter.awk -v var=3 penguins.list
Bonaparte Eudyptula;minor;Bonaparte;1867;Little Blue
Brisson Spheniscus;demersus;Brisson;1760;African
Ewing,L Torvaldis;linux;Ewing,L;1996;Tux
Miller,JF Aptenodytes;forsteri;Miller,JF;1778;Emperor
Milne-Edwards Megadyptes;antipodes;Milne-Edwards;1880;Yellow-eyed
Viellot Eudyptes;chrysocome;Viellot;1816;Sothern Rockhopper
Wagler Pygoscelis;papua;Wagler;1832;Gentoo

修正

本文演示了如何在纯 GNU awk 中对数据进行排序。你可以对脚本进行改进,以便对你有用,花一些时间在gawk 的手册页上研究 awk 函数并自定义脚本以获得更好的输出。

这是到目前为止的完整脚本:

#!/usr/bin/awk -f
# GPLv3 appears here
# usage: ./sorter.awk -v var=NUM FILE

BEGIN { FS=";"; }

{ # dump each field into an array
    ARRAY[$var] = $R;
}

END {
    asorti(ARRAY,SARRAY);
    # get length
    j = length(SARRAY);
   
    for (i = 1; i <= j; i++) {
        printf("%s %s\n", SARRAY[i],ARRAY[SARRAY[i]])
    }
}

via: https://opensource.com/article/19/11/how-sort-awk

作者:Seth Kenlon 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

学习怎样使用 awk 的 !visited[$0]++ 在不重新排序或改变原排列顺序的前提下删掉重复的行。

假设你有一个文本文件,你需要删掉所有重复的行。

TL;DR

要保持原来的排列顺序删掉重复行,使用:

awk '!visited[$0]++' your_file > deduplicated_file

工作原理

这个脚本维护一个关联数组,索引(键)为文件中去重后的行,每个索引对应的值为该行出现的次数。对于文件的每一行,如果这行(之前)出现的次数为 0,则值加 1,并打印这行,否则值加 1,不打印这行。

我之前不熟悉 awk,我想弄清楚这么短小的一个脚本是怎么实现的。我调研了下,下面是调研心得:

  • 这个 awk “脚本” !visited[$0]++ 对输入文件的每一行都执行。
  • visited[] 是一个关联数组(又名映射)类型的变量。awk 会在第一次执行时初始化它,因此我们不需要初始化。
  • $0 变量的值是当前正在被处理的行的内容。
  • visited[$0] 通过与 $0(正在被处理的行)相等的键来访问该映射中的值,即出现次数(我们在下面设置的)。
  • ! 对表示出现次数的值取反:

    • awk 中,任意非零的数或任意非空的字符串的值是 true
    • 变量默认的初始值为空字符串,如果被转换为数字,则为 0。
    • 也就是说:

      • 如果 visited[$0] 的值是一个比 0 大的数,取反后被解析成 false
      • 如果 visited[$0] 的值为等于 0 的数字或空字符串,取反后被解析成 true
    • ++ 表示变量 visited[$0] 的值加 1。

      • 如果该值为空,awk 自动把它转换为 0(数字) 后加 1。
      • 注意:加 1 操作是在我们取到了变量的值之后执行的。

总的来说,整个表达式的意思是:

  • true:如果表示出现次数为 0 或空字符串
  • false:如果出现的次数大于 0

awk模式或表达式和一个与之关联的动作 组成:

<模式/表达式> { <动作> }

如果匹配到了模式,就会执行后面的动作。如果省略动作,awk 默认会打印(print)输入。

省略动作等价于 {print $0}

我们的脚本由一个 awk 表达式语句组成,省略了动作。因此这样写:

awk '!visited[$0]++' your_file > deduplicated_file

等于这样写:

awk '!visited[$0]++ { print $0 }' your_file > deduplicated_file

对于文件的每一行,如果表达式匹配到了,这行内容被打印到输出。否则,不执行动作,不打印任何东西。

为什么不用 uniq 命令?

uniq 命令仅能对相邻的行去重。这是一个示例:

$ cat test.txt
A
A
A
B
B
B
A
A
C
C
C
B
B
A
$ uniq < test.txt
A
B
A
C
B
A

其他方法

使用 sort 命令

我们也可以用下面的 sort 命令来去除重复的行,但是原来的行顺序没有被保留

sort -u your_file > sorted_deduplicated_file

使用 cat + sort + cut

上面的方法会产出一个去重的文件,各行是基于内容进行排序的。通过管道连接命令可以解决这个问题。

cat -n your_file | sort -uk2 | sort -nk1 | cut -f2-

工作原理

假设我们有下面一个文件:

abc
ghi
abc
def
xyz
def
ghi
klm

cat -n test.txt 在每行前面显示序号:

1       abc
2       ghi
3       abc
4       def
5       xyz
6       def
7       ghi
8       klm

sort -uk2 基于第二列(k2 选项)进行排序,对于第二列相同的值只保留一次(u 选项):

1       abc
4       def
2       ghi
8       klm
5       xyz

sort -nk1 基于第一列排序(k1 选项),把列的值作为数字来处理(-n 选项):

1       abc
2       ghi
4       def
5       xyz
8       klm

最后,cut -f2- 从第二列开始打印每一行,直到最后的内容(-f2- 选项:留意 - 后缀,它表示这行后面的内容都包含在内)。

abc
ghi
def
xyz
klm

参考

以上为全文。


via: https://opensource.com/article/19/10/remove-duplicate-lines-files-awk

作者:Lazarus Lazaridis 选题:lujun9972 译者:lxbwolf 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

awk 命令不仅提供了简单的输入字符串筛选功能,还包含提取数据列、打印简单文本、筛选内容——甚至做一些数学计算。

Thinkstock

如果你仅使用 awk 选取一行中的特定文本,那么你可能错过了它的很多功能。在这篇文章中,我们会来看看使用 awk 可以帮你做一些其他的什么事情,并提供一些例子。

提取数据列

awk 所提供的最简单与最常用的功能便是从文件或管道传输的数据中选取特定的内容。默认使用空格当做分隔符,这非常简单。

$ echo one two three four five | awk ‘{print $4}’
four
$ who | awk ‘{print $1}’
jdoe
fhenry

空格指的是一系列的 spacetab 字符。在下面所展示的命令里,awk 从提供的数据中筛选第一和第四项。

awk 命令也可以通过在其后增加文件名参数的方式从文本文件中获取数据。

$ awk '{print $1,$5,$NF}' HelenKellerQuote
The beautiful heart.

(LCTT 译注:“The best and most beautiful things in the world can not be seen or even touched , they must be felt with heart.” ——海伦凯勒)

在这个例子中,awk 挑选了一行中的第一个、第五个和最后一个字段。

命令中的 $NF 指定选取每行的最后一个字段。这是因为 NF 代表一行中的 字段数量 Number of Field ,也就是 23,而 $NF 就代表着那个字段的值,也就是heart。最后的句号也包含进去了,因为它是最后一个字符串的一部分。

字段能以任何有用的形式打印。在这个例子中,我们将字段以日期的格式进行打印输出。

$ date | awk '{print $4,$3,$2}'
2019 Nov 22

如果你省略了 awk 命令中字段指示符之间的逗号,输出将会挤成一个字符串。

$ date | awk '{print $4 $3 $2}'
2019Nov21

如果你将通常使用的逗号替换为连字符,awk 就会尝试将两个字段的值相减——或许这并不是你想要的。它不会将连字符插入到输出结果中。相反地,它对输出做了一些数学计算。

$ date | awk '{print $4-$3-$2}'
1997

在这个例子中,它将年 “2019” 和日期 “22” 相减,并忽略了中间的 “Nov”。

如果你想要空格之外的字符作为输出分隔符,你可以通过 OFS 输出分隔符 output field separator )指定分隔符,就像这样:

$ date | awk '{OFS="-"; print $4,$3,$2}'
2019-Nov-22

打印简单文本

你也可以使用 awk 简单地显示一些文本。当然了,比起 awk 你可能更想使用 echo 命令。但换句话说,作为 awk 脚本的一部分,打印某些相关性文本将会非常实用。这里有一个没什么用的例子:

$ awk 'BEGIN {print "Hello, World" }'
Hello, World

下面的例子更加合理,添加一行文本标签来更好的辨识数据。

$ who | awk 'BEGIN {print "Current logins:"} {print $1}'
Current logins:
shs
nemo

指定字段分隔符

不是所有的输入都以空格作为分隔符的。如果你的文本通过其它的字符作为分隔符(例如:逗号、冒号、分号),你可以通过 -F 选项(输入分隔符)告诉 awk

$ cat testfile
a:b:c,d:e
$ awk -F : '{print $2,$3}' testfile
b c,d

下面是一个更加有用的例子——从冒号分隔的 /etc/passwd 文件中获取数据:

$ awk -F: '{print $1}' /etc/passwd | head -11
root
daemon
bin
sys
sync
games
man
lp
mail
news
uucp

筛选内容

你也可以使用 awk 命令评估字段。例如你仅仅想列出 /etc/passwd 中的用户账号,就可以对第三个字段做一些筛选。下面的例子中我们只关注大于等于 1000 的 UID:

$ awk -F":" ' $3 >= 1000 ' /etc/passwd
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
shs:x:1000:1000:Sandra Henry-Stocker,,,:/home/shs:/bin/bash
nemo:x:1001:1001:Nemo,,,:/home/nemo:/usr/bin/zsh
dory:x:1002:1002:Dory,,,:/home/dory:/bin/bash
...

如果你想为输出增加标题,可以添加 BEGIN 从句:

$ awk -F":" 'BEGIN {print "user accounts:"} $3 >= 1000 ' /etc/passwd
user accounts:
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
shs:x:1000:1000:Sandra Henry-Stocker,,,:/home/shs:/bin/bash
nemo:x:1001:1001:Nemo,,,:/home/nemo:/usr/bin/zsh
dory:x:1002:1002:Dory,,,:/home/dory:/bin/bash

如果你想要不止一行的标题,你可以通过 "\n" 分隔输出:

$ awk -F":" 'BEGIN {print "user accounts\n============="} $3 >= 1000 ' /etc/passwd
user accounts
=============
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
shs:x:1000:1000:Sandra Henry-Stocker,,,:/home/shs:/bin/bash
nemo:x:1001:1001:Nemo,,,:/home/nemo:/usr/bin/zsh
dory:x:1002:1002:Dory,,,:/home/dory:/bin/bash

在 awk 中进行数学计算

awk 提供了惊人的数学计算能力,并且可以开平方,算 log,算 tan 等等。

这里有一对例子:

$ awk 'BEGIN {print sqrt(2019)}'
44.9333
$ awk 'BEGIN {print log(2019)}'
7.61036

想要详细了解 awk 的数学计算能力,可以看《使用 awk 进行数学计算》这篇文章。

awk 脚本

你也可以使用 awk 写一套单独的脚本。下面的例子模仿了之前写过的一个,不过还计算了系统里账户的数量。

#!/usr/bin/awk -f

# 这一行是注释

BEGIN {
    printf "%s\n","User accounts:"
    print "=============="
    FS=":"
    n=0
}

# 现在开始遍历数据
{
    if ($3 >= 1000) {
        print $1
        n ++
    }
}

END {
    print "=============="
    print n " accounts"
}

注意 BEGIN 那一节是如何提供标题、指定字段分隔符和初始化计数器的,它仅在脚本初始化时期执行。这个脚本也包含 END 节,它仅在中间所有命令处理完成之后运行,显示了所有中间小节所筛选数据的最终行数(第三个字段大于等于 1000)。

作为一个长存于 Unix 之上的命令,awk 依旧提供着非常有用的服务,这也是我几十年前爱上 Unix 的原因之一。


via: https://www.networkworld.com/article/3454979/the-many-faces-of-awk.html

作者:Sandra Henry-Stocker 选题:lujun9972 译者:LuuMing 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

将一个 awk 脚本移植到 Python 主要在于代码风格而不是转译。

脚本是解决问题的有效方法,而 awk 是编写脚本的出色语言。它特别擅长于简单的文本处理,它可以带你完成配置文件的某些复杂重写或目录中文件名的重新格式化。

何时从 awk 转向 Python

但是在某些方面,awk 的限制开始显现出来。它没有将文件分解为模块的真正概念,它缺乏质量错误报告,并且缺少了现在被认为是编程语言工作原理的其他内容。当编程语言的这些丰富功能有助于维护关键脚本时,移植将是一个不错的选择。

我最喜欢的完美移植 awk 的现代编程语言是 Python。

在将 awk 脚本移植到 Python 之前,通常值得考虑一下其原始使用场景。例如,由于 awk 的局限性,通常从 Bash 脚本调用 awk 代码,其中包括一些对 sedsort 之类的其它命令行常见工具的调用。 最好将所有内容转换为一个一致的 Python 程序。有时,脚本会做出过于宽泛的假设,例如,即使实际上只运行一个文件,该代码也可能允许任意数量的文件。

在仔细考虑了上下文并确定了要用 Python 替代的东西之后,该编写代码了。

标准 awk 到 Python 功能

以下 Python 功能是有用的,需要记住:

with open(some_file_name) as fpin:
    for line in fpin:
        pass # do something with line

此代码将逐行循环遍历文件并处理这些行。

如果要访问行号(相当于 awk 的 NR),则可以使用以下代码:

with open(some_file_name) as fpin:
    for nr, line in enumerate(fpin):
        pass # do something with line

在 Python 中实现多文件的 awk 式行为

如果你需要能够遍历任意数量的文件同时保持行数的持续计数(类似 awk 的 FNR),则此循环可以做到这一点:

def awk_like_lines(list_of_file_names):
    def _all_lines():
        for filename in list_of_file_names:
            with open(filename) as fpin:
                yield from fpin
    yield from enumerate(_all_lines())

此语法使用 Python 的生成器yield from 来构建迭代器,该迭代器将遍历所有行并保持一个持久计数。

如果你需要同时使用 FNRNR,这是一个更复杂的循环:

def awk_like_lines(list_of_file_names):
    def _all_lines():
        for filename in list_of_file_names:
            with open(filename) as fpin:
                yield from enumerate(fpin)
    for nr, (fnr, line) in _all_lines:
        yield nr, fnr, line

更复杂的 FNR、NR 和行数的 awk 行为

如果 FNRNR 和行数这三个你全都需要,仍然会有一些问题。如果确实如此,则使用三元组(其中两个项目是数字)会导致混淆。命名参数可使该代码更易于阅读,因此最好使用 dataclass

import dataclass

@dataclass.dataclass(frozen=True)
class AwkLikeLine:
    content: str
    fnr: int
    nr: int

def awk_like_lines(list_of_file_names):
    def _all_lines():
        for filename in list_of_file_names:
            with open(filename) as fpin:
                yield from enumerate(fpin)
    for nr, (fnr, line) in _all_lines:
        yield AwkLikeLine(nr=nr, fnr=fnr, line=line)

你可能想知道,为什么不一直用这种方法呢?使用其它方式的的原因是总用这种方法太复杂了。如果你的目标是把一个通用库更容易地从 awk 移植到 Python,请考虑这样做。但是编写一个可以使你确切地了解特定情况所需的循环的方法通常更容易实现,也更容易理解(因而易于维护)。

理解 awk 字段

一旦有了与一行相对应的字符串,如果要转换 awk 程序,则通常需要将其分解为字段。Python 有几种方法可以做到这一点。这将把行按任意数量的连续空格拆分,返回一个字符串列表:

line.split()

如果需要另一个字段分隔符,比如以 : 分隔行,则需要 rstrip 方法来删除最后一个换行符:

line.rstrip("\n").split(":")

完成以下操作后,列表 parts 将存有分解的字符串:

parts = line.rstrip("\n").split(":")

这种拆分非常适合用来处理参数,但是我们处于偏差一个的错误场景中。现在 parts[0] 将对应于 awk 的 $1parts[1] 将对应于 awk 的 $2,依此类推。之所以偏差一个,是因为 awk 计数“字段”从 1 开始,而 Python 从 0 开始计数。在 awk 中,$0 是整个行 —— 等同于 line.rstrip("\n"),而 awk 的 NF(字段数)更容易以 len(parts) 的形式得到。

移植 awk 字段到 Python

例如,让我们将这个单行代码“如何使用 awk 从文件中删除重复行”转换为 Python。

awk 中的原始代码是:

awk '!visited[$0]++' your_file > deduplicated_file

“真实的” Python 转换将是:

import collections
import sys

visited = collections.defaultdict(int)
for line in open("your_file"):
    did_visit = visited[line]
    visited[line] += 1
    if not did_visit:
        sys.stdout.write(line)

但是,Python 比 awk 具有更多的数据结构。与其计数访问次数(除了知道是否看到一行,我们不使用它),为什么不记录访问的行呢?

import sys

visited = set()
for line in open("your_file"):
    if line in visited:
        continue
    visited.add(line)
    sys.stdout.write(line)

编写 Python 化的 awk 代码

Python 社区提倡编写 Python 化的代码,这意味着它要遵循公认的代码风格。更加 Python 化的方法将区分唯一性和输入/输出的关注点。此更改将使对代码进行单元测试更加容易:

def unique_generator(things):
    visited = set()
    for thing in things:
        if thing in visited:
            continue
        visited.add(things)
        yield thing

import sys
   
for line in unique_generator(open("your_file")):
    sys.stdout.write(line)

将所有逻辑置于输入/输出代码之外,可以更好地分离问题,并提高代码的可用性和可测试性。

结论:Python 可能是一个不错的选择

将 awk 脚本移植到 Python 时,通常是在考虑适当的 Python 代码风格时重新实现核心需求,而不是按条件/操作进行笨拙的音译。考虑原始上下文并产生高质量的 Python 解决方案。虽然有时候使用 awk 的 Bash 单行代码可以完成这项工作,但 Python 编码是通往更易于维护的代码的途径。

另外,如果你正在编写 awk 脚本,我相信您也可以学习 Python!如果你有任何疑问,请告诉我。


via: https://opensource.com/article/19/11/awk-to-python

作者:Moshe Zadka 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

来学习一下多次执行同一条命令的不同类型的循环。

awk 脚本有三个主要部分:BEGINEND 函数(都可选),用户自己写的每次要执行的函数。某种程度上,awk 的主体部分就是一个循环,因为函数中的命令对每一条记录都会执行一次。然而,有时你希望对于一条记录执行多次命令,那么你就需要用到循环。

有多种类型的循环,分别适合不同的场景。

while 循环

一个 while 循环检测一个表达式,如果表达式为 true 就执行命令。当表达式变为 false 时,循环中断。

#!/bin/awk -f

BEGIN {
        # Loop through 1 to 10

    i=1;
    while (i <= 10) {
        print i, " to the second power is ", i*i;
        i = i+1;
    }
exit;
}

在这个简单实例中,awk 打印了放在变量 i 中的整数值的平方。while (i <= 10) 语句告诉 awk 仅在 i 的值小于或等于 10 时才执行循环。在循环最后一次执行时(i 的值是 10),循环终止。

do-while 循环

do-while 循环执行在关键字 do 之后的命令。在每次循环结束时检测一个测试表达式来决定是否终止循环。仅在测试表达式返回 true 时才会重复执行命令(即还没有到终止循环的条件)。如果测试表达式返回 false,因为到了终止循环的条件所以循环被终止。

#!/usr/bin/awk -f
BEGIN {

        i=2;
        do {
                print i, " to the second power is ", i*i;
                i = i + 1
        }
        while (i < 10)

exit;
}

for 循环

awk 中有两种 for 循环。

一种 for 循环初始化一个变量,检测一个测试表达式,执行变量递增,当表达式的结果为 true 时循环就会一直执行。

#!/bin/awk -f

BEGIN {
    for (i=1; i <= 10; i++) {
        print i, " to the second power is ", i*i;
    }
exit;
}

另一种 for 循环设置一个有连续索引的数组变量,对每一个索引执行一个命令集。换句话说,它用一个数组“收集”每一条命令执行后的结果。

本例实现了一个简易版的 Unix 命令 uniq。通过把一系列字符串作为键加到数组 a 中,当相同的键再次出现时就增加键值,可以得到某个字符串出现的次数(就像 uniq--count 选项)。如果你打印该数组的所有键,将会得到出现过的所有字符串。

用演示文件 colours.txt(前一篇文章中的文件)来举例:

name       color  amount
apple      red    4
banana     yellow 6
raspberry  red    99
strawberry red    3
grape      purple 10
apple      green  8
plum       purple 2
kiwi       brown  4
potato     brown  9
pineapple  yellow 5

这是 awk 版的简易 uniq -c

#! /usr/bin/awk -f

NR != 1 {
    a[$2]++
}
END {
    for (key in a) {
                print a[key] " " key
    }
}

示例数据文件的第三列是第一列列出的条目的计数。你可以用一个数组和 for 循环来按颜色统计第三列的条目。

#! /usr/bin/awk -f

BEGIN {
    FS=" ";
    OFS="\t";
    print("color\tsum");
}
NR != 1 {
    a[$2]+=$3;
}
END {
    for (b in a) {
        print b, a[b]
    }
}

你可以看到,在处理文件之前也需要在 BEFORE 函数(仅仅执行一次)中打印一列表头。

循环

在任何编程语言中循环都是很重要的一部分,awk 也不例外。使用循环你可以控制 awk 脚本怎样去运行,它可以统计什么信息,还有它怎么去处理你的数据。我们下一篇文章会讨论 switchcontinuenext 语句。


via: https://opensource.com/article/19/11/loops-awk

作者:Seth Kenlon 选题:lujun9972 译者:lxbwolf 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

这个系列的第二篇,我们会学习字段,记录和一些非常有用的 Awk 变量。

Awk 有好几个变种:最早的 awk,是 1977 年 AT&T 贝尔实验室所创。它还有一些重构版本,例如 mawknawk。在大多数 Linux 发行版中能见到的,是 GNU awk,也叫 gawk。在大多数 Linux 发行版中,awkgawk 都是指向 GNU awk 的软链接。输入 awk,调用的是同一个命令。GNU awk 用户手册中,能看到 awkgawk 的全部历史。

这一系列的第一篇文章 介绍了 awk 命令的基本格式:

$ awk [选项] '模式 {动作}' 输入文件

awk 是一个命令,后面要接选项 (比如用 -F 来定义字段分隔符)。想让 awk 执行的部分需要写在两个单引号之间,至少在终端中需要这么做。在 awk 命令中,为了进一步强调你想要执行的部分,可以用 -e 选项来突出显示(但这不是必须的):

$ awk -F, -e '{print $2;}' colours.txt
yellow
blue
green
[...]

记录和字段

awk 将输入数据视为一系列记录,通常是按行分割的。换句话说,awk 将文本中的每一行视作一个记录。每一记录包含多个字段。一个字段由字段分隔符分隔开来,字段是记录的一部分。

默认情况下,awk 将各种空白符,如空格、制表符、换行符等视为分隔符。值得注意的是,在 awk 中,多个空格将被视为一个分隔符。所以下面这行文本有两个字段:

raspberry red

这行也是:

tuxedo                  black

其他分隔符,在程序中不是这么处理的。假设字段分隔符是逗号,如下所示的记录,就有三个字段。其中一个字段可能会是 0 个字节(假设这一字段中不包含隐藏字符)

a,,b

awk 程序

awk 命令的程序部分是由一系列规则组成的。通常来说,程序中每个规则占一行(尽管这不是必须的)。每个规则由一个模式,或一个或多个动作组成:

模式 { 动作 }

在一个规则中,你可以通过定义模式,来确定动作是否会在记录中执行。模式可以是简单的比较条件、正则表达式,甚至两者结合等等。

这个例子中,程序只会显示包含单词 “raspberry” 的记录:

$ awk '/raspberry/ { print $0 }' colours.txt
raspberry red 99

如果没有文本符合模式,该动作将会应用到所有记录上。

并且,在一条规则只包含模式时,相当于对整个记录执行 { print },全部打印出来。

Awk 程序本质上是数据驱动的,命令执行结果取决于数据。所以,与其他编程语言中的程序相比,它还是有些区别的。

NF 变量

每个字段都有指定变量,但针对字段和记录,也存在一些特殊变量。NF 变量,能存储 awk 在当前记录中找到的字段数量。其内容可在屏幕上显示,也可用于测试。下面例子中的数据,来自上篇文章文本

$ awk '{ print $0 " (" NF ")" }' colours.txt
name       color  amount (3)
apple      red    4 (3)
banana     yellow 6 (3)
[...]

awkprint 函数会接受一系列参数(可以是变量或者字符串),并将它们拼接起来。这就是为什么在这个例子里,每行结尾处,awk 会以一个被括号括起来的整数表示字段数量。

NR 变量

另外,除了统计每个记录中的字段数,awk 也统计输入记录数。记录数被存储在变量 NR 中,它的使用方法和其他变量没有任何区别。例如,为了在每一行开头显示行号:

$ awk '{ print NR ": " $0 }' colours.txt
1: name       color  amount
2: apple      red    4
3: banana     yellow 6
4: raspberry  red    3
5: grape      purple 10
[...]

注意,写这个命令时可以不在 print 后的多个参数间添加空格,尽管这样会降低可读性:

$ awk '{print NR": "$0}' colours.txt

printf() 函数

为了让输出结果时格式更灵活,你可以使用 awkprintf() 函数。 它与 C、Lua、Bash 和其他语言中的 printf 相类似。它也接受以逗号分隔的格式参数。参数列表需要写在括号里。

$ printf 格式, 项目1, 项目2, ...

格式这一参数(也叫格式符)定义了其他参数如何显示。这一功能是用格式修饰符实现的。%s 输出字符,%d 输出十进制数字。下面的 printf 语句,会在括号内显示字段数量:

$ awk 'printf "%s (%d)\n",$0,NF}' colours.txt
name       color  amount (3)
raspberry  red    4 (3)
banana     yellow 6 (3)
[...]

在这个例子里,%s (%d) 确定了每一行的输出格式,$0,NF 定义了插入 %s%d 位置的数据。注意,和 print 函数不同,在没有明确指令时,输出不会转到下一行。出现转义字符 \n 时才会换行。

Awk 脚本编程

这篇文章中出现的所有 awk 代码,都在 Bash 终端中执行过。面对更复杂的程序,将命令放在文件(脚本)中会更容易。-f FILE 选项(不要和 -F 弄混了,那个选项用于字段分隔符),可用于指明包含可执行程序的文件。

举个例子,下面是一个简单的 awk 脚本。创建一个名为 example1.awk 的文件,包含以下内容:

/^a/ {print "A: " $0}
/^b/ {print "B: " $0}

如果一个文件包含 awk 程序,那么在给文件命名时,最好写上 .awk 的扩展名。 这样命名不是强制的,但这么做,会给文件管理器、编辑器(和你)一个关于文件内容的很有用的提示。

执行这一脚本:

$ awk -f example1.awk colours.txt
A: raspberry  red    4
B: banana     yellow 6
A: apple      green  8

一个包含 awk 命令的文件,在最开头一行加上释伴 #!,就能变成可执行脚本。创建一个名为 example2.awk 的文件,包含以下内容:

#!/usr/bin/awk -f
#
# 除了第一行,在其他行前显示行号
#

NR > 1 {
    printf "%d: %s\n",NR,$0
}

可以说,脚本中只有一行,大多数情况下没什么用。但在某些情况下,执行一个脚本,比记住,然后打一条命令要容易的多。一个脚本文件,也提供了一个记录命令具体作用的好机会。以 # 号开头的行是注释,awk 会忽略它们。

给文件可执行权限:

$ chmod u+x example2.awk

执行脚本:

$ ./example2.awk colours.txt
2: apple      red    4
2: banana     yellow 6
4: raspberry red    3
5: grape      purple 10
[...]

awk 命令放在脚本文件中,有一个好处就是,修改和格式化输出会更容易。在终端中,如果能用一行执行多条 awk 命令,那么输入多行,才能达到同样效果,就显得有些多余了。

试一试

你现在已经足够了解,awk 是如何执行指令的了。现在你应该能编写复杂的 awk 程序了。试着编写一个 awk 脚本,它需要: 至少包括一个条件模式,以及多个规则。如果你想使用除 printprintf 以外的函数,可以参考在线 gawk 手册

下面这个例子是个很好的切入点:

#!/usr/bin/awk -f
#
#  显示所有记录 除了出现以下情况
#  如果第一个记录 包含 “raspberry”
#  将 “red” 替换成 “pi”

$1 == "raspberry" {
        gsub(/red/,"pi")
}

{ print }

试着执行这个脚本,看看输出是什么。接下来就看你自己的了。

这一系列的下一篇文章,将会介绍更多,能在更复杂(更有用!) 脚本中使用的函数。

这篇文章改编自 Hacker Public Radio 系列,一个技术社区博客。


via: https://opensource.com/article/19/11/fields-records-variables-awk

作者:Seth Kenlon 选题:lujun9972 译者:wenwensnow 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出