叙然茶樓-小昭&小君的生活筆記

eval用法 eval SAENameAx=\${SAENameA$(($i+1))[j]}

2019-11-05T07:40:00.000+08:00

eval：

語法

[test @test test]# eval variable
例題：
[test @test test]# days=365
[test @test test]# year=days
[test @test test]# echo \$$year
$days <==第一個 $ 被 \ 改變成為一般字元，而 \$ 後面接的 $year 就成為 days 啦！
[test @test test]# eval echo \$$year
365
加上 eval 之後， \$$year 變成的 $days 的『變數內容』會顯現出來喔！

上述資料來自 http://linux.vbird.org/linux_basic/0320bash/0320bash.php

1. ~$ name=yawu
~$ echo $name
~$ yawu

2. ~$ yawu=vmd
~$ echo $name
~$ yawu

~$ eval echo \$$name
~$ vmd

3. ~$ eval echo "$""$name"
~$ vmd

or

~$ eval echo '${'"$name"'}'
~$ vmd

链接：https://www.jianshu.com/p/284ae3a0244e

-------------------------------------------------------------------------------------------------------------------------

for ((i=0; i < 2; i++)); do
for ((j=0; j < 3; j++)); do
# ii=$(($i+1))
# eval SAENameAx=\${SAENameA${ii}[j]}
eval SAENameAx=\${SAENameA$(($i+1))[j]}
echo "SAENameAx="$SAENameAx
PathFileName=$(echo $Path/${SAESide[i]}/${SAEDir[j]}/${SAENameAx}"-"$SearchDATE"-task.txt")
echo "PathFileName= "$PathFileName
The_number_of_lines_in_a_file=$(cat $PathFileName |grep -n 'HKT 2019'| wc -l)
echo "The number of lines in a file="$The_number_of_lines_in_a_file
cat ${PathFileName} |grep -n 'HKT 2019' > $Path/tempA_${i}_${j}.txt
for ((k=1; k < $The_number_of_lines_in_a_file; k++)); do
Paragraph_begin=$(cat $Path/tempA_${i}_${j}.txt | sed -n "${k}p" | awk 'BEGIN {FS=":"}; END{print $1}')
Paragraph_begin=$(($Paragraph_begin+5))

k=$(($k+1))
Paragraph_end=$(cat $Path/tempA_${i}_${j}.txt | sed -n "${k}p" | awk 'BEGIN {FS=":"}; END{print $1}')
Paragraph_end=$(($Paragraph_end-2))

cat ${PathFileName} |sed -n "${Paragraph_begin},${Paragraph_end}p" > $Path/tempB_${i}_${j}.txt
done
done

done

Linux 的 scp 指令用法教學與範例：遠端加密複製檔案與目錄

2019-11-01T08:38:00.002+08:00

文章來自 https://blog.gtwang.org/linux/linux-scp-command-tutorial-examples/

Linux 的 scp 指令用法教學與範例：遠端加密複製檔案與目錄

這裡介紹如何在 Linux 系統上以 scp 指令複製檔案與目錄，並提供一些參考範例。

若要在不同的 Linux 主機之間複製檔案，最常用的方法就是使用 scp 指令，它可以透過 SSH 安全加密傳輸的方式，將本地端的檔案或目錄複製到遠端，或是將遠端的資料複製到本地端，而這個指令在 Mac OS X 中也同樣可以使用。

在不同 Linux 主機之間使用 scp 指令複製檔案時，遠端的 Linux 主機必須要開啟 SSH 遠端登入服務，否則無法使用 scp 指令複製檔案。

複製檔案與目錄

scp 指令的語法跟一般的 cp 類似，只不過 scp 可以在不同的 Linux 主機之間複製檔案，其語法為：

scp [帳號@來源主機]:來源檔案 [帳號@目的主機]:目的檔案

這裡的帳號就是登入主機上的帳號（類似 ssh 指令的用法），如果省略帳號與主機，只寫一般的檔案路徑的話，就是代表本機的檔案。

例如將本地端的 /path/file1 複製到 192.168.0.1 這台主機上的 /path/file2，而登入 192.168.0.1 這台主機時，是以 myuser 這個帳號登入：

# 從本地端複製到遠端
scp /path/file1 myuser@192.168.0.1:/path/file2

也可以把遠端的檔案複製到本地端：

# 從遠端複製到本地端
scp myuser@192.168.0.1:/path/file2 /path/file1

這樣就會用 myuser 這個帳號登入 192.168.0.1，將遠端主機上的 /path/file2 複製到 /path/file1。

如果本地端的使用者帳號名稱剛好跟遠端的使用者帳號一樣，也可以將使用者帳號省略，例如：

# 從本地端複製到遠端
scp /path/file1 192.168.0.1:/path/file2

反過來也是類似：

# 從遠端複製到本地端
scp 192.168.0.1:/path/file2 /path/file1

複製目錄

若要複製整個目錄以及其下的所有檔案，則加上 -r 參數：

# 複製目錄
scp -r /path/folder1 myuser@192.168.0.1:/path/folder2

保留檔案時間與權限

若要讓檔案在複製之後，還可保留原本的修改時間、存取時間與權限，可以加上 -p 參數：

# 保留檔案時間與權限
scp -p /path/file1 myuser@192.168.0.1:/path/file2

資料壓縮

若要將資料壓縮之後再傳送，減少網路頻寬的使用量，可以加上 -C 參數：

# 資料壓縮
scp -C /path/file1 myuser@192.168.0.1:/path/file2

限制傳輸速度

若要限制網路的使用頻寬，可以用 -l 指定可用的網路頻寬上限值（單位為 Kbit/s）：

# 限制傳輸速度為 400 Kbit/s
scp -l 400 /path/file1 myuser@192.168.0.1:/path/file2

這樣就會限制 scp 只能使用 400 Kbit/s，也就是 400 / 8 = 50 KB/s。

自訂連接埠

一般 SSH 伺服器的連接埠號為 22，如果遇到使用非標準埠號的伺服器，可以用 -P 來指定埠號。若遠端的 SSH 伺服器使用 2222 這個連接埠，我們就可以這樣複製檔案：

# 使用 2222 連接埠
scp -P 2222 /path/file1 myuser@192.168.0.1:/path/file2

IPv4 與 IPv6

-4 與 -6 兩個參數分別可以讓 scp 使用 IPv4 與 IPv6 來傳輸資料：

# 使用 IPv4
scp -4 /path/file1 myuser@192.168.0.1:/path/file2

# 使用 IPv6
scp -6 /path/file1 myuser@192.168.0.1:/path/file2

參考資料：Tecmint、UX Techno、Linux and Ubuntu、Jscape、O’Relly、nixCraft

[Ubuntu] 自動掛載 NAS 網路磁碟機 (samba)

2019-10-30T16:02:00.002+08:00

轉自
https://blog.ladsai.com/ubuntu-%E8%87%AA%E5%8B%95%E6%8E%9B%E8%BC%89-nas-%E7%B6%B2%E8%B7%AF%E7%A3%81%E7%A2%9F%E6%A9%9F-samba.html

Ubuntu 18.04

首先建立一個要空資料

2019-10-29T14:15:00.001+08:00

https://www.runoob.com/python3/python3-reg-expressions.html

Python3 正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能。

compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

本章节主要介绍 Python 中常用的正则表达式处理函数，如果你对正则表达式不了解，可以查看我们的正则表达式 - 教程。

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

函数语法：

re.match(pattern, string, flags=0)

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

匹配成功re.match方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到所含的小组号。

实例

#!/usr/bin/python  import reprint(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配

以上实例运行输出结果为：

(0, 3)
None

实例

#!/usr/bin/python3import re  line = "Cats are smarter than dogs"# .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)  if matchObj:    print ("matchObj.group() : ", matchObj.group())   print ("matchObj.group(1) : ", matchObj.group(1))   print ("matchObj.group(2) : ", matchObj.group(2))else:    print ("No match!!")

以上实例执行结果如下：

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

函数语法：

re.search(pattern, string, flags=0)

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

匹配成功re.search方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到所含的小组号。

实例

#!/usr/bin/python3  import re  print(re.search('www', 'www.runoob.com').span())  # 在起始位置匹配print(re.search('com', 'www.runoob.com').span())         # 不在起始位置匹配

以上实例运行输出结果为：

(0, 3)
(11, 14)

实例

#!/usr/bin/python3  import re  line = "Cats are smarter than dogs";   searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)  if searchObj:    print ("searchObj.group() : ", searchObj.group())   print ("searchObj.group(1) : ", searchObj.group(1))   print ("searchObj.group(2) : ", searchObj.group(2))else:    print ("Nothing found!!")

以上实例执行结果如下：

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

实例

#!/usr/bin/python3  import re  line = "Cats are smarter than dogs";   matchObj = re.match( r'dogs', line, re.M|re.I)if matchObj:    print ("match --> matchObj.group() : ", matchObj.group())else:    print ("No match!!")  matchObj = re.search( r'dogs', line, re.M|re.I)if matchObj:    print ("search --> matchObj.group() : ", matchObj.group())else:    print ("No match!!")

以上实例运行结果如下：

No match!!
search --> matchObj.group() :  dogs

检索和替换

Python 的re模块提供了re.sub用于替换字符串中的匹配项。

语法：

re.sub(pattern, repl, string, count=0, flags=0)

参数：

pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
flags : 编译时用的匹配模式，数字形式。

前三个为必选参数，后两个为可选参数。

实例

#!/usr/bin/python3import re  phone = "2004-959-559 # 这是一个电话号码"  # 删除注释num = re.sub(r'#.*$', "", phone)print ("电话号码 : ", num)  # 移除非数字的内容num = re.sub(r'\D', "", phone)print ("电话号码 : ", num)

以上实例执行结果如下：

电话号码 :  2004-959-559 
电话号码 :  2004959559

repl 参数是一个函数

以下实例中将字符串中的匹配的数字乘于 2：

实例

#!/usr/bin/python  import re  # 将匹配的数字乘于 2def double(matched):     value = int(matched.group('value'))    return str(value * 2)  s = 'A23G4HFD567'print(re.sub('(?P<value>\d+)', double, s))

执行输出结果为：

A46G8HFD1134

compile 函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

语法格式为：

re.compile(pattern[, flags])

参数：

pattern : 一个字符串形式的正则表达式
flags 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
- re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
- re.M 多行模式
- re.S 即为' . '并且包括换行符在内的任意字符（' . '不包括换行符）
- re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
- re.X 为了增加可读性，忽略空格和' # '后面的注释

实例

>>>import re>>> pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字>>> m = pattern.match('one12twothree34four')        # 查找头部，没有匹配>>> print mNone>>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配>>> print mNone>>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配>>> print m                                         # 返回一个 Match 对象<_sre.SRE_Match object at 0x10a42aac0> >>> m.group(0)   # 可省略 0'12'>>> m.start(0)   # 可省略 03>>> m.end(0)     # 可省略 05>>> m.span(0)    # 可省略 0(3, 5)

在上面，当匹配成功时返回一个 Match 对象，其中：

group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
span([group]) 方法返回 (start(group), end(group))。

再看看一个例子：

实例

>>>import re>>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)   # re.I 表示忽略大小写>>> m = pattern.match('Hello World Wide Web')>>> print m                               # 匹配成功，返回一个 Match 对象<_sre.SRE_Match object at 0x10bea83e8> >>> m.group(0)                            # 返回匹配成功的整个子串'Hello World'>>> m.span(0)                             # 返回匹配成功的整个子串的索引(0, 11)>>> m.group(1)                            # 返回第一个分组匹配成功的子串'Hello'>>> m.span(1)                             # 返回第一个分组匹配成功的子串的索引(0, 5)>>> m.group(2)                            # 返回第二个分组匹配成功的子串'World'>>> m.span(2)                             # 返回第二个分组匹配成功的子串索引(6, 11)>>> m.groups()                            # 等价于 (m.group(1), m.group(2), ...)('Hello', 'World')>>> m.group(3)                            # 不存在第三个分组Traceback (most recent call last):   File "<stdin>", line 1, in <module> IndexError: no such group

findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次 findall 匹配所有。

语法格式为：

re.findall(string[, pos[, endpos]])

参数：

string 待匹配的字符串。
pos 可选参数，指定字符串的起始位置，默认为 0。
endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。

查找字符串中的所有数字：

实例

import re  pattern = re.compile(r'\d+')   # 查找数字result1 = pattern.findall('runoob 123 google 456')result2 = pattern.findall('run88oob123google456', 0, 10)  print(result1)print(result2)

输出结果：

['123', '456']
['88', '12']

re.finditer

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

re.finditer(pattern, string, flags=0)

参数：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

实例

import re  it = re.finditer(r"\d+","12a32bc43jf3")  for match in it:      print (match.group() )

输出结果：

re.split

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

re.split(pattern, string[, maxsplit=0, flags=0])

参数：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
maxsplit	分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

实例

>>>import re>>> re.split('\W+', 'runoob, runoob, runoob.')['runoob', 'runoob', 'runoob', '']>>> re.split('(\W+)', ' runoob, runoob, runoob.')  ['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', '']>>> re.split('\W+', ' runoob, runoob, runoob.', 1)  ['', 'runoob, runoob, runoob.']  >>> re.split('a*', 'hello world')   # 对于一个找不到匹配的字符串而言，split 不会对其作出分割['hello world']

正则表达式对象

re.RegexObject

re.compile() 返回 RegexObject 对象。

re.MatchObject

group() 返回被 RE 匹配的字符串。

start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'\t'，等价于 \\t )匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	匹配n个前面表达式。例如，"o{2}"不能匹配"Bob"中的"o"，但是能匹配"food"中的两个o。
re{ n,}	精确匹配n个前面表达式。例如，"o{2,}"不能匹配"Bob"中的"o"，但能匹配"foooood"中的所有o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a\| b	匹配a或b
(re)	匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (...), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。
(?> re)	匹配的独立模式，省去回溯。
\w	匹配数字字母下划线
\W	匹配非数字字母下划线
\s	匹配任意空白字符，等价于 [\t\n\r\f]。
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9]。
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等。	匹配一个换行符。匹配一个制表符, 等
\1...\9	匹配第n个分组的内容。
\10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

正则表达式实例

字符匹配

实例	描述
python	匹配 "python".

字符类

实例	描述
[Pp]ython	匹配 "Python" 或 "python"
rub[ye]	匹配 "ruby" 或 "rube"
[aeiou]	匹配中括号内的任意一个字母
[0-9]	匹配任何数字。类似于 [0123456789]
[a-z]	匹配任何小写字母
[A-Z]	匹配任何大写字母
[a-zA-Z0-9]	匹配任何字母及数字
[^aeiou]	除了aeiou字母以外的所有字符
[^0-9]	匹配除了数字外的字符

特殊字符类

实例	描述
.	匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w	匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W	匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。

python之正则sub函数split函数

2019-10-29T13:57:00.001+08:00

文章轉自 https://blog.csdn.net/GrofChen/article/details/93598605

python之正则sub函数split函数

2019-06-25 14:03:43 GrofChen 阅读数 200更多

分类专栏： Python高级

本文链接：https://blog.csdn.net/GrofChen/article/details/93598605

re.sub函数用于将原字符串匹配的字符替换，替换的可以是字符串，也可以是函数
格式：re.sub(表达式，字符串，原字符串【,次数,标志位】)

import re
a = "1234567abcdefg"           # \D表示非数字字符
s = re.sub('\D.*', "890", a)   # \D.*即非数字字符开头的字符串
print(s)

1

2

3

4

def one(matched):            # 参数为匹配对象
    s =matched.group('num')  # 匹配的分组结果
    return s.zfill(3)        # 对结果进行填充
 
a ='a1b2c3d4e5f6'
print(re.sub('(?P<num>\d)', one, a,3)) # \d为数字字符

1

2

3

4

5

6

re.split函数用于将符串中匹配的字符分割为列表
格式：re.split(表达式，字符串【,次数,标志位】)

import re
a='i love chian'
print(re.split('\s', a))    # \s为空字符
print(re.split('(\s)',a))   # 空字符也分为一组
print(re.split('\s', a, 1)) # 分割次数为1
print(re.split('\d', a))    # 匹配不到时不分割



1

2

3

4

5

6

2019-10-29T13:55:00.001+08:00

>>> import re
>>> inputStr = "hello 123 world 456"
>>> re.sub("\d+", "222", inputStr)
'hello 222 world 222'

-----------------------------------------------------------------------

>>> import re
>>> inputStr = "hello a123 world 456"
>>> re.sub("\d+", "222", inputStr)

'hello a222 world 222'

-----------------------------------------------------------------------

出現錯誤訊息: sed: -e expression #1, char 1: unknown command: `,'

2019-10-25T17:59:00.003+08:00

原程式語法如下:

sed_function=''
sed_function=${sed_function}"sed 's/Messages reached $[0-9][0-9][0-9]$ which/Messages reached xxx which/g'"

出現下列錯誤:
sed: -e expression #1, char 1: unknown command: `''

解決方法修正如下: 將 " " 改為 ${ }
sed_function=''
sed_function=${sed_function}${ sed 's/Messages reached $[0-9][0-9][0-9]$ which/Messages reached xxx which/g' }

-------------------------------------------------------------------------------------------------------------------------
解決方法來自下列文章

文章轉自 https://stackoverflow.com/questions/41355635/sed-e-expression-1-char-1-unknown-command

`sed: -e expression #1, char 1: unknown command: `,'`

問問題

1個

這個問題已經在這裡有了答案：

何時將引號括在shell變量周圍？ 5個答案

從CYGWIN中的shell腳本運行上述命令時，出現以下錯誤。

錯誤：

sed：-e表達式＃1，字符1：未知命令：`，'

如果我在cmd中運行了命令：

$ sed -n "8937,8946 p" "/cygdrive/c/TEMP/temp_oracle/alert_cert1_copy.log" | egrep -e "ORA-|Shutting down"

它可以正常工作-結果：

ORA-1623 signalled during: ALTER DATABASE DROP LOGFILE GROUP 1...
Shutting down database

注意：8937＆8946是文本文件中的行號-需要在其中檢查模式。搜索必須在這些行之間。

如果我從shell腳本中運行命令-出現上述錯誤。

Shell腳本：

    export alert_file="/cygdrive/c/TEMP/temp_oracle/alert_cert1_copy.log"
    export alert_output="/cygdrive/c/cygwin64/home/alert_out.log"

        function searchAlertByFilterLN() {
            #err1=$(sed -n "${lastLineNum},${totLines} p" $alert_file | egrep -e "ORA-")
            err1=$(sed -n "8937,8946 p" $alert_file | egrep -e "ORA-|Shutting down")
                if [ -n "$err1" ]; then  
                echo -e "Errors found:" > $alert_output
                echo ------------       >> $alert_output
                sed -n "8937,8946 p" $alert_file | egrep -e "ORA-|Shutting down" >> $alert_output
                echo "" >> $alert_output
                echo "" >> $alert_output
                echo -e "Check the details of the errors below. (Details means the surroundig lines of the error message only)" >> $alert_output
                echo  "-------------------------------------" >> $alert_output
                sed -n "8937,8946 p" $alert_file | /usr/bin/egrep -A 5 -B 2 "ORA-|Shutting down" >> $alert_output
                fi
        }

searchAlertByFilterLN --
echo "function was executed"

帶著敬意！

16年12月28日於5:40編輯

問16年12月28日在5:03

布拉特·馬赫穆托夫

113枚青銅徽章

被三方標記為重複 bash 9月30日在5:31

這個問題已經問過了，已經有了答案。如果這些答案不能完全解決您的問題，請提出一個新問題。

複製粘貼腳本的內容，以及如何運行腳本？ – 年16年 12月28日 Inian 5:09
不要讓我們猜測，向您展示失敗的實際腳本代碼。我敢打賭，您正在使用sed -n "$startLineNo,$endLineNo p" file或類似方法，或者var拼寫錯誤，或者由於其他原因一個或兩個都沒有值。您是否了解Shell調試模式，並帶有set -vx（和set +vx關閉）。作為執行這將顯示你的線與它們的值代替變量。祝好運。 – shellter 16年 12月28日在5:17
另外，請閱讀 stackoverflow.com/help/how-to-ask，stackoverflow.com/help/dont-ask， stackoverflow.com/help/mcve 並採取旅遊張貼在這裡更多Qs的面前。祝好運。 – 剝殼機機'16 Dec 28'在5:20
庇護所，我已經閱讀了很多與網站政策不符的問題，所以請。 – 布拉特·馬赫穆托夫 16年12月28日在5:43
@bulatmakhmutov：可以將這行更改sed -n "8937,8946 p" $alert_file為sed -n "8937,8946 p" "$alert_file"帶有適當的雙引號引起的聲音$alert_file嗎？您可以圍繞腳本中的所有實例執行此操作，然後嘗試嗎？ – 伊尼安 16年 12月28日5:55

再顯示2條評論

1個回答

活躍的最古老的選票

1個

在腳本中的變量周圍使用正確的雙引號，以避免shell誤解您的正斜杠（/），換行符和單詞拆分。您的腳本中使用的所有變量都丟失了它。

您的腳本的更正版本應類似於

 #!/bin/bash

export alert_file="/cygdrive/c/TEMP/temp_oracle/alert_cert1_copy.log"
export alert_output="/cygdrive/c/cygwin64/home/alert_out.log"

function searchAlertByFilterLN() {
    #err1=$(sed -n "${lastLineNum},${totLines} p" $alert_file | egrep -e "ORA-")
    err1=$(sed -n "8937,8946 p" "$alert_file" | egrep -e "ORA-|Shutting down" )
     if [ -n "$err1" ]; then  
         echo -e "Errors found:" > "$alert_output"
         echo ------------       >> "$alert_output"
         sed -n "8937,8946 p" "$alert_file" | egrep -e "ORA-|Shutting down" >> $alert_output
         echo "" >> "$alert_output"
         echo "" >> "$alert_output"
         echo -e "Check the details of the errors below. (Details means the surroundig lines of the error message only)" >> "$alert_output"
         echo  "-------------------------------------" >> "$alert_output"
         sed -n "8937,8946 p" "$alert_file" | /usr/bin/egrep -A 5 -B 2 "ORA-|Shutting down" >> "$alert_output"
     fi
}

searchAlertByFilterLN --

uniq - remove duplicate lines from a sorted file (從排序的文件中刪除重複的行)

2019-10-25T09:15:00.002+08:00

uniq

From Wikipedia, the free encyclopedia

Jump to navigation Jump to search

uniq
Original author(s)	Ken Thompson
Developer(s)	AT&T Bell Laboratories
Initial release	February 1973; 46 years ago
Operating system	Unix and Unix-like, MSX-DOS
Type	Command
License	GNU GPL v3
Website	http://man7.org/linux/man-pages/man1/uniq.1.html

uniq - remove duplicate lines from a sorted file

從排序的文件中刪除重複的行

uniq is a Unix utility which, when fed a text file or STDIN, outputs the text with adjacent identical lines collapsed to one, unique line of text.

uniq是Unix實用程序，當輸入文本文件或STDIN時，它以折疊的相鄰相同行輸出為一行唯一的文本來輸出文本。

Overview[edit]

The command is a kind of filter program. Typically it is used after sort. 該命令是一種過濾程序。通常在之後使用sort。

It can also output only the duplicate lines (with the -d option), 它還可以僅輸出重複的行（帶-d選項）

or add the number of occurrences of each line (with the -c option). 或增加每行的出現次數（帶-c選項）。

An example: To see the list of lines in a file, sorted by the number of times each occurs:

一個示例：要查看文件中的行列表，按行出現的次數排序：

sort file | uniq -c | sort -n

Using uniq like this is common when building pipelines in shell scripts.

在shell腳本中構建管道時，通常會像這樣使用uniq 。

sed（意為流編輯器，源自英語「stream editor」的縮寫）

2019-10-25T08:25:00.000+08:00

轉自 https://zh.wikipedia.org/wiki/Sed

sed（意為流編輯器，源自英語「stream editor」的縮寫）是一個使用簡單緊湊的程式語言來解析和轉換文字Unix實用程式。

sed由貝爾實驗室的Lee E. McMahon於1973年至1974年開發， ^[1] 並且現在大多數作業系統都可以使用。 ^[2] sed基於互動式編輯器ed（「editor」，1971）和早期qed（「quick editor」，1965-66）的指令碼功能。sed是最早支援正規表示式的工具之一，至今仍然用於文字處理，特別是用於替換命令。用於純文字字串操作和「流編輯」的常用工具還有AWK和Perl 。

2019-10-23T11:21:00.000+08:00

Shell特殊變數：Shell $0, $#, $*, $@, $?, $$和命令列參數

前面已經講到，變數名只能包含數位、字母和底線，因為某些包含其他字元的變數有特殊含義，這樣的變數被稱為特殊變數。

例如，$ 表示當前Shell進程的ID，即pid，看下面的代碼：

1. $echo $$

運行結果

29949

特殊變數清單
變數	含義
$0	當前腳本的檔案名
$n	傳遞給腳本或函數的參數。n 是一個數字，表示第幾個參數。例如，第一個參數是$1，第二個參數是$2。
$#	傳遞給腳本或函數的參數個數。
$*	傳遞給腳本或函數的所有參數。
$@	傳遞給腳本或函數的所有參數。被雙引號(" ")包含時，與 $* 稍有不同，下面將會講到。
$?	上個命令的退出狀態，或函數的返回值。
$$	當前Shell進程ID。對於 Shell 腳本，就是這些腳本所在的進程ID。

命令列參數

運行腳本時傳遞給腳本的參數稱為命令列參數。命令列參數用 $n 表示，例如，$1 表示第一個參數，$2 表示第二個參數，依次類推。

請看下麵的腳本：

1. #!/bin/bash

3. echo "File Name: $0"

4. echo "First Parameter : $1"

5. echo "First Parameter : $2"

6. echo "Quoted Values: $@"

7. echo "Quoted Values: $*"

8. echo "Total Number of Parameters : $#"

運行結果：

$./test.sh Zara Ali

File Name : ./test.sh

First Parameter : Zara

Second Parameter : Ali

Quoted Values: Zara Ali

Total Number of Parameters : 2

$* 和 $@ 的區別

$* 和 $@ 都表示傳遞給函數或腳本的所有參數，不被雙引號(" ")包含時，都以"$1" "$2" … "$n" 的形式輸出所有參數。

但是當它們被雙引號(" ")包含時，"$*" 會將所有的參數作為一個整體，以"$1 $2 … $n"的形式輸出所有參數；"$@" 會將各個參數分開，以"$1" "$2" … "$n" 的形式輸出所有參數。

下面的例子可以清楚的看到 $* 和 $@ 的區別：

1. #!/bin/bash

2. echo "\$*=" $*

3. echo "\"\$*\"=" "$*"

5. echo "\$@=" $@

6. echo "\"\$@\"=" "$@"

8. echo "print each param from \$*"

9. for var in $*

10.do

11. echo "$var"

12.done

13.

14.echo "print each param from \$@"

15.for var in $@

16.do

17. echo "$var"

18.done

19.

20.echo "print each param from \"\$*\""

21.for var in "$*"

22.do

23. echo "$var"

24.done

25.

26.echo "print each param from \"\$@\""

27.for var in "$@"

28.do

29. echo "$var"

30.done

執行 ./test.sh "a" "b" "c" "d"，看到下面的結果：

$*= a b c d

"$*"= a b c d

$@= a b c d

"$@"= a b c d

print each param from $*

print each param from $@

print each param from "$*"

a b c d

print each param from "$@"

退出狀態

$? 可以獲取上一個命令的退出狀態。所謂退出狀態，就是上一個命令執行後的返回結果。

退出狀態是一個數位，一般情況下，大部分命令執行成功會返回 0，失敗返回 1。

不過，也有一些命令返回其他值，表示不同類型的錯誤。

下面例子中，命令成功執行：

$./test.sh Zara Ali

File Name : ./test.sh

First Parameter : Zara

Second Parameter : Ali

Quoted Values: Zara Ali

Total Number of Parameters : 2

$echo $?

$? 也可以表示函數的返回值，後續將會講解。

2019-10-22T10:58:00.000+08:00

文章轉自 https://www.opencli.com/linux/sort-command-sort-data

Sam Tang 10 April 2017 Linux No Comments

sort 指令是在 Linux 下的排序指令, 可以將資料以不同欄位以數值及字母排序。sort 預設會用以下條件排序:

— 數字會排在字母前面;
— 小寫字母會排在大寫字母前面;

以一個簡單的例子說明使用方法, 例如用 “ls -l” 列出檔案清單, ls 預設是用檔案名稱排序, 想要用檔案大小排序, 可以這樣:

$ ls -l | sort -n -k 5

上面的 “5” 代表是第 5 個欄位的意思, 因為 “ls -l” 指令的輸出, 第 5 欄是檔案大小。

上面的例子會將資料由小至大排序, 如果想從大至小排序, 可以加入 “-r” 參數:

$ ls -l | sort -n -r -k 5

另一個例子是用在 df 上, 將檔案系統按使用量排序:

$ df | sort -n -k 5

參數說明:

-n 按數值大小排序.
-r 倒轉排序, 即從大至小排序.
-t 指定欄位分隔的字符, 預設是 Tab.
-k 要排序的欄位.

機房建設 » 5G之於資料中心，到底意味著什麼？

2019-10-16T07:48:00.000+08:00

文章轉自: http://www.upsapp.com/articledetail.asp?ID=6536

機房建設 » 5G之於資料中心，到底意味著什麼？
2019-3-8 7:22:09

· 5G無線技術即將到來，當它到來時，將帶來更快、更密集的資料流程，這一趨勢將推動對於資料中心容量的更多需求。那麼，這個資料流程將會是什麼樣的？什麼時候到來？·

即將到來的5G轉型有望促進移動流量的發展。
　　
　　5G無線技術即將到來，當它到來時，將帶來更快、更密集的資料流程，這一趨勢將推動對於資料中心容量的更多需求。那麼，這個資料流程將會是什麼樣的？什麼時候到來？
　　
　　最近幾周來，5G轉型在資料中心行業領域佔據了中心位置，主要表現在行業會議的主題演講、 Equinix公司和 Digital Realty公司的項目，以及思科公司的最新報告中。而行業分析師們在5G採用的時間和廣度上存在不同的觀點，並且他們的預測受到宣佈炒作和市場行銷的影響而變得難以確定。
　　
　　隨著網路服務提供商和超大規模運營商開始部署下一代網路設備，為2020年及以後的5G服務做好準備，隨著2022年的到來，資料的細流逐漸彙聚成數位海嘯，5G很可能在2019年底開始為資料中心帶來引人注目的業務。
　　
　　瑞士信貸（Credit Suisse）公司證券分析師Sami Badri表示，“我認為5G將成為資料中心行業發展的主要驅動力。互聯網企業將從5G中獲益，5G將成為Equinix、Digital Realty和CoreSite等資料中心運營商新業務的主要推動因素。”　　
　　Badri在1月31日于維吉尼亞州阿什本市舉行的Capre2019資料中心預測大會上表示，“我們正處於這一轉載時期的第一階段。Arista Networks是 400Gbps交換機的領頭羊，這將極大提升網路容量，推動網路設備供應商的進步，這是5G應用的一個有用的領先指標。而其進展預示著需求。”　　

　　為什麼5G無線技術很重要
　　
　　5G無線技術是下一代移動協議，預計將啟用新的資料密集型服務，如自動駕駛汽車，這在當前的無線連接中是無法實現的。如果5G的部署獲得成功，在不同位置之間移動資料將更容易，這一趨勢一直對資料中心業務十分有利。5G技術預計具有三個關鍵屬性：
　　
　　•100Mbps或更高的高頻寬移動寬頻。
　　
　　•支援大規模的機器對機器（M2M）通信，其密度高達每平方公里100,000個連接。
　　
　　•超低延遲通信，為任務關鍵型應用程式提供低於10毫秒的延遲。
　　
　　5G將在數年內部署，隨著新設備的最終確定而廣泛應用。它將需要新的傳輸基礎設施，其中包括數千個蜂窩塔臺和數萬個天線（或稱之為小型蜂窩和分散式天線系統），這些設施將部署在電線杆和其他城市基礎設施上。它還需要部署大量的光纖。
　　　　
　　Equinix公司首席全球解決方案架構師Kelvin Cheung表示，5G轉型將帶來許多好處和許多挑戰。
　　
　　他在互聯網博客上指出，“更快、更低延遲的5G網路基礎設施將極大地促進物聯網、人工智慧、線上遊戲、虛擬/增強現實和智慧城市的發展。但是，在這一切都明朗化之前，目前存在的許多監管、頻譜許可、安全和基礎設施改造問題必須逐個解決。”　　
　　資料中心的5G應用
　　
　　瑞士信貸分析師Badri表示，5G帶來的資料浪潮將為IT基礎設施行業帶來廣泛的業務收益。但並非所有的資料中心都能從中受益。5G資料增長的主要受益者將是專注于互連的資料中心，這就是Equinix、Digital Realty和Core Site等資料中心運營商獲得巨大收益的原因。
　　
　　Badri說，沒有互連元件的批發資料中心提供商的收益將更為有限。Megaport和Packet Fabric等軟體定義網路（SDN）廠商可以幫助資料中心批發商參與市場。
　　
　　Badri說，5G的轉型正在推動向軟體定義的基礎設施的重大轉變，移動提供商正在升級其基礎設施，以支援“雲原生”計算模式。
　　
　　這就是電信公司採用開放計算項目（OCP）來部署低成本“白盒”伺服器和運行複雜SDN軟體的交換機的原因。分析人士認為，開放計算專案（OCP）硬體有機會支援UCPE（通用客戶場所設備），這是主要運營商將雲技術引入電信生態系統的一項舉措，其中包括軟體定義網路（SDN）和網路功能虛擬化（NFV）。
　　
　　“隨著時間的推移，電信公司看起來就像雲計算。”Badri預測。“網路功能虛擬化（NFV）本質上是應用於所有事物的雲計算模式。”　　
　　這就是Equinix公司認為到2020年，網路功能虛擬化（NFV）和虛擬網路應用可以為硬體、軟體和服務開啟價值150億美元的市場的原因。該公司尚未推出公開的網路功能虛擬化（NFV）產品，但正在與早期採用的客戶合作。這標誌著Equinix公司的下一步目標，即逐步向公司的整個全球平臺注入SDN功能，為客戶提供連接世界的服務。
　　
　　5G和邊緣計算
　　
　　5G無線基礎設施將成為邊緣計算基礎設施的利器。因此，5G網路的地理位置和相關的業務收入將指導大部分的早期投資。模組化資料中心運營商的生態系統已經出現，以尋求邊緣基礎設施的擴建，其中包括VaporIO、EdgeConneX、EdgeMicro、DartPoints、DataBank、Baselayer和Switch等公司。
　　
　　而資料中心行業規模最大的兩家運營商Equinix公司和Digital Realty公司也看到了5G驅動邊緣計算部署的機會。
　　
　　Equinix公司的Cheung說，“要克服的一個關鍵障礙是5G技術固有的距離限制，這將需要更大數量的5G網路節點之間的近距離放置和互連。服務提供者和企業將需要查看將5G置於數位邊緣的分散式IT和網路基礎設施——靠近商業、人口中心和網路和雲計算服務提供者的數位生態系統。在區域性都市中，接近各種5G網路服務提供商使中小型服務提供者和企業能夠租賃5G網路作為服務。這為那些可能沒有資源通過本地高速、低延遲連接向5G轉型的公司提供了訪問規模更大5G網路服務提供商的許可權。”
　　
　　Digital Realty公司的Tuhafa寫道：“我們開始看到更多的重點放在當地語系化、分散式運算能力上，以支持具有較低延遲和較高彈性的關鍵任務應用程式。但是，任何IT環境始終需要一個集中的核心。畢竟，即使是最先進的微型資料中心也不能完全處理邊緣計算承載的所有任務。”

命令群組 - () 與 {} 差在哪？

2019-10-15T12:25:00.000+08:00

轉自 http://wiki.jikexueyuan.com/project/13-questions-of-shell/brackets-and-braces.html

() 與 {} 差在哪？

嗯，這次輕鬆一下，不講太多... ^_^

先說一下，為何要用 () 或者{} 好了。

許多時候，我們在 shell 操作上，需要在一定的條件下執行多個命令，也就是說，要麼不執行，要麼就全執行，而不是每次依序的判斷是否要執行下一個命令。

或者，要從一些命令執行的先後次序中得到結果，如算數運算的 2*(3+4) 那樣...

這時候，我們就可以引入 "命令群組"(command group) 的概念：將許多命令集中處理。

在 shell command line中，一般人或許不太計較( )與 { }這兩對符號的差異，雖然兩者都可以將多個命令當作群組處理，但若從技術細節上，卻是很不一樣的：

· ( ) 將 command group 置於sub-shell(子shell) 中去執行，也稱 nested sub-shell。

· { } 則是在同一個 shell 內完成，也稱non-named command group。

若你對上一章的 fork 與source 的概念還記得的話，那就不難理解兩者的差異了。

要是在 command group中扯上變數及其他環境的修改，我們可以根據不同的需求來使用()或{}。通常而言, 若所作的修改是臨時的，且不想影響原有或以後的設定，那我們就使用nested sub-shell, 即(); 反之，則用non-named command group, 即{}。

是的，光從command line來看，()與 {}差別就講完了，夠輕鬆吧~~~, ^_^

然而，這兩個meta用在其他command meta或領域中 (如 Regular Expression)，還是有很多差別的。只是，我不打算再去說明了，留給讀者慢慢發掘好了...

我這裡只想補充一個概念，就是function。所謂function，就是用一個名字去命名一個command group, 然後再調用這個名字去執行command group。

從non-named command group來推斷，大概你也可以推測到我要說的是{}了吧？(yes! 你真聰明 ^_^)

在 bash 中，function 的定義方式有兩種：

· 方式一：

function function_name {

command1

command2

command3

.....

}

· 方式二：

function_name () {

command1

command2

command3

......

}

用哪一種方式無所謂，只是碰到所定義的名稱與現有的命令或者別名衝突的話，方式二或許會失敗。但方式二起碼可以少打個function這一串英文字元，對懶人來說 (如我)，有何樂而不為呢？...^_^

function 在一定程度上來說，也可以稱為 "函數"，但請不要與傳統程式設計所使用的 "函數"(library) 搞混了，畢竟兩者差異很大。唯一相同的是，我們都可以隨時用 "已定義的名稱" 來調用它們...

若我們在 shell 操作中，需要不斷地重複某些命令，我們首先想到的，或許是將命令寫成 shell 腳本 (shell script)。不過，我們也可以寫成 function, 然後在 command line 中打上 function_name 就可當一般的 shell script 使用了。

若只是你在 shell 中定義的function, 除了用unset function_name 取消外，一旦你退出 shell， function 也跟著消失。然而，在 script 中使用 function 卻有許多好處，除了提高整體 script 的執行性能外 (因為已經載入)，還可以節省許多重複的代碼......

簡單而言，若你會將多個命令寫成 script 以供調用的話，那你可以將 function 看成 script 中 script。... ^_^

而且通過上一章節介紹的source命令，我們可以自行定義許許多多好用的 function，在集中寫在特定文件中，然後，在其他的 script 中用source將它們載入，並反復執行。

若你是RedHat Linux的使用者，或許，已經猜出 /etc/rc.d/init.d/functions這個檔時啥作用了~~~ ^_^

okay，說要輕鬆點的嘛，那這次就暫時寫到這吧。祝大家學習愉快，^_^

命令替換 - (())與()還有${}差在哪？

2019-10-15T12:20:00.002+08:00

轉自 : http://wiki.jikexueyuan.com/project/13-questions-of-shell/eight.html

(( ))與( )還有${ }差在哪？

我們上一章介紹了( )與{ }的不同，這次讓我們擴展一下，看看更多的變化：( )與{ }又是啥玩意兒呢？

在bash shell中, $( ) 與 ` ` (反引號)都是用來做 命令替換(command substitution)的。

所謂的命令替換與我們第五章學過的變數替換差不多，都是用來重組命令列：完成 ` ` 或者$( )裡面的命令，將其結果替換出來，再重組命令列。

例如：

$ echo the last sunday is $(date -d "last sunday" +%Y-%m-%d)

如此便可方便得到上一個星期天的日期了...^_^

在操作上，用( )或‘‘都無所謂，只是我個人比較喜歡用( )，理由是：

1. ``(反引號)很容易與''(單引號)搞混亂，尤其對初學者來說。有時在一些奇怪的字形顯示中，兩種符號是一模一樣的(只取兩點)。當然了有經驗的朋友還是一眼就能分辨兩者。只是，若能更好的避免混亂，又何樂而不為呢？ ^_^

2. 在多次的複合替換中， ``需要額外的轉義(escape, )處理，而$()則比較直觀。例如，一個錯誤的使用的例子：

command1 `command2 `command3` `

原來的本意是要在command2 `command3` , 先將command3替換出來給command2處理，然後再將command2的處理結果，給command1來處理。然而真正的結果在命令列中卻是分成了`command2`與 ``。

正確的輸入應該如下：

command1 `command2 \`command3\` `

要不然換成$()就沒有問題了：

command1 $(commmand2 $(command3))

只要你喜歡，做多少層的替換都沒有問題~~~^_^

不過，( )並不是沒有弊端的...首先，‘‘ 基本上可用在所有的unixshell中使用，若寫成shellscript，其移植性比較高。而( )並不是每一種shell都能使用，我只能說，若你用bash2的話，肯定沒問題... ^_^

接下來，再讓我們看看吧...它其實就是用來做變數替換用的啦。一般情況下，var與var並沒有啥不一樣。但是用{ }會比較精准的界定變數名稱的範圍，比方說:

$ A=B

$ echo $AB

原本是打算先將A的結果替換出來，然後在其後補一個字母B；但命令列上，真正的結果卻是替換變數名稱為AB的值出來...若使用{ }就沒有問題了：

$ A=B

$ echo ${A}B

$ BB

不過，假如你只看到${}只能用來界定變數名稱的話，那你就實在太小看bash了。

為了完整起見，我這裡再用一些例子加以說明${}的一些特異功能：假設我們定義了一個變數file為：

file=/dir1/dir2/dir3/my.file.txt

我們可以用${}分別替換獲得不同的值：

shell 字串的非貪婪(最小匹配)左刪除

${file#*/} #其值為：dir1/dir2/dir3/my.file.txt

拿掉第一個/及其左邊的字串，其結果為： dir1/dir2/dir3/my.file.txt 。

${file#*.} #其值為：file.txt

拿掉第一個.及其左邊的字串，其結果為： file.txt 。

shell 字串的貪婪(最大匹配)左刪除

${file##*/} #其值為：my.file.txt

拿掉最後一個/及其左邊的字串，其結果為： my.file.txt

${file##*.} #其值為：txt

拿掉最後一個.及其左邊的字串，其結果為： txt

shell 字串的非貪婪(最小匹配)右刪除

${file%/*} #其值為：/dir1/dir2/dir3

拿掉最後一個/及其右邊的字串，其結果為： /dir1/dir2/dir3。

${file%.*} #其值為：/dir1/dir2/dir3/my.file

拿掉最後一個.及其右邊的字串，其結果為： /dir1/dir2/dir3/my.file。

shell 字串的貪婪(最大匹配)右刪除

${file%%/*} #其值為：其值為空。

拿掉第一個/及其右邊的字串，其結果為：空串。

${file%%.*} #其值為：/dir1/dir2/dir3/my。

拿掉第一個.及其右邊的字串，其結果為： /dir1/dir2/dir3/my。

Tips:

記憶方法：

#是去掉左邊(在鍵盤上#在$的左邊);

%是去掉右邊(在鍵盤上%在$的右邊);

單個符號是最小匹配;

兩個符號是最大匹配;

shell 字串取子串：

${file:0:5} #提取最左邊的5個字元：/dir1

${file:5:5} #提取第5個字元及其右邊的5個字元:/dir2

shell 字串取子串的格式：${s:pos:length}, 取字串 s 的子串：從 pos 位置開始的字元(包括該字元)的長度為 length 的的子串；其中pos為子串的首字元，在 s 中位置； length為子串的長度；

Note: 字串中字元的起始編號為0.

shell 字串變數值的替換

${file/dir/path} #將第一個dir替換為path：/path1/dir2/dir3/my.file.txt

${file//dir/path} #將全部的dir替換為path：/path1/path2/path3/my.file.txt

shell 字串變數值的替換格式：

· 首次替換： ${s/src_pattern/dst_pattern} 將字串s中的第一個src_pattern替換為dst_pattern。

· 全部替換： ${s//src_pattern/dst_pattern} 將字串s中的所有出現的src_pattern替換為dst_pattern.

${ }還可針對變數的不同狀態(沒設定、空值、非空值)進行賦值

· ${file-my.file.txt} #如果file沒有設定，則使用使用my.file.txt作為返回值, 否則返回${file};(空值及非空值時，不作處理。);

· ${file:-my.file.txt} #如果file沒有設定或者file為空值,均使用my.file.txt作為其返回值，否則，返回{file}.(${file} 為非空值時，不作處理);

· ${file+my.file.txt} #如果file已設定(為空值或非空值), 則使用my.file.txt作為其返回值，否則不作處理。(未設定時，不作處理);

· ${file:+my.file.txt} #如果${file}為非空值, 則使用my.file.txt作為其返回值，否則，(未設定或者為空值時)不作處理。

· ${file=my.file.txt} #如果file為設定，則將file賦值為my.file.txt，同時將file作為其返回值；否則，file已設定(為空值或非空值)，則返回{file}。

· ${file:=my.file.txt} #如果file未設定或者file為空值,則my.file.txt作為其返回值，同時，將{file}賦值為my.file.txt，否則，(非空值時)不作處理。

· ${file?my.file.txt} #如果file沒有設定，則將my.file.txt輸出至STDERR, 否側，已設定(空值與非空值時)，不作處理。

· ${file:?my.file.txt} #若果file未設定或者為空值，則將my.file.txt輸出至STDERR，否則，非空值時，不作任何處理。

Tips:

以上的理解在於，你一定要分清楚，unset與null以及non-null這三種狀態的賦值；一般而言，與null有關，若不帶:, null不受影響；若帶 :, 則連null值也受影響。

計算 shell 字串變數的長度：${#var}

${#file} #其值為27, 因為/dir1/dir2/dir3/my.file.txt剛好為27個字元。

bash 陣列(array)的處理方法

接下來，為大家介紹一下bash的陣列(array)的處理方法。一般而言, A="a b c def" 這樣的變數只是將$A替換為一個字串，但是改為 A=(a b c def), 則是將$A定義為陣列....

陣列替換方法可參考如下方法

${A[@]} #方法一

${A[*]} #方法二

以上兩種方法均可以得到：a b c def, 即陣列的全部元素。

訪問陣列的成員

${A[0]}

其中，${A[0]}可得到a, 即陣列A的第一個元素，而 ${A[1]}則為陣列A的第二元素，依次類推。

陣列的 length

${#A[@]} #方法一

${#A[*]} #方法二

以上兩種方法均可以得到陣列的長度: 4, 即陣列的所有元素的個數。

回憶一下，針對字串的長度計算，使用${#str_var}；我們同樣可以將該方法應用于陣列的成員:

${#A[0]}

其中，${#A[0]}可以得到：1，即陣列A的第一個元素(a)的長度；同理，${#A[3]}可以得到: 3, 即陣列A的第4個元素(def)的長度。

陣列元素的重新賦值

A[3]=xyz

將陣列A的第四個元素重新定義為xyz。

Tips:

諸如此類的...

能夠善用bash的()與{}可以大大提高及簡化shell在變數上的處理能力哦~~~^_^

$(())作用

好了，最後為大家介紹$(())的用途吧： $(())是用來作整數運算的。

在bash中， $(())的整數運算子號大致有這些：

· +- * / #分別為"加、減、乘、除"。

· % #餘數運算,(模數運算)

· & | ^ ! #分別為"AND、OR、XOR、NOT"運算。

例如：

$ a=5; b=7; c=2;

$ echo $(( a + b * c ))

$ echo $(( (a + b)/c ))

$ echo $(( (a * b) % c ))

在$(())中的變數名稱，可以在其前面加 $符號來替換，也可以不用，如： $(( $a + $b * $c )) 也可以得到19的結果。

此外，$(())還可作不同進制(如二進位、八進制、十六進位)的運算，只是輸出結果均為十進位的。

echo $(( 16#2a )) #輸出結果為：42，(16進制的2a)

以一個實用的例子來看看吧 : 假如當前的umask是022,那麼新建檔的許可權即為：

$ umask 022

$ echo "obase=8; $(( 8#666 & (8#777 ^ 8#$(umask)) ))" | bc

644

事實上，單純用(())也可以重定義變數值，或作 testing：

a=5; ((a++)) #可將$a 重定義為6

a=5; ((a--)) #可將$a 重定義為4

a=5; b=7; ((a< b)) #會得到0 (true)返回值。

常見的用於(())的測試符號有如下這些：

符號	符號名稱
<	小於號
>	大於號
<=	小於或等於
>=	大於或等於
==	等於
!=	不等於

Note:

使用(())作整數測試時，請不要跟[]的整數測試搞混亂了。

更多的測試，我們將于第10章為大家介紹。

怎樣？好玩吧... ^_^

okay，這次暫時說這麼多...

上面的介紹，並沒有詳列每一種可用的狀態，更多的，就請讀者參考手冊檔(man)吧...

延伸正規表示法 - 群組功能『 | 』管線意義為『或 or』

2019-10-15T09:08:00.003+08:00

轉自 http://linux.vbird.org/linux_basic/0330regularex.php

延伸正規表示法 - 群組功能『 | 』管線意義為『或 or』

事實上，一般讀者只要瞭解基礎型的正規表示法大概就已經相當足夠了，不過，某些時刻為了要簡化整個指令操作，瞭解一下使用範圍更廣的延伸型正規表示法的表示式會更方便呢！舉個簡單的例子好了，在上節的例題三的最後一個例子中，我們要去除空白行與行首為 # 的行列，使用的是

grep -v '^$' regular_express.txt | grep -v '^#'

需要使用到管線命令來搜尋兩次！那麼如果使用延伸型的正規表示法，我們可以簡化為：

egrep -v '^$|^#' regular_express.txt

延伸型正規表示法可以透過群組功能『 | 』來進行一次搜尋！那個在單引號內的管線意義為『或 or』啦！是否變的更簡單呢？此外，grep 預設僅支援基礎正規表示法，如果要使用延伸型正規表示法，你可以使用 grep -E ，不過更建議直接使用 egrep ！直接區分指令比較好記憶！
其實 egrep 與 grep -E 是類似命令別名的關係啦！

熟悉了正規表示法之後，到這個延伸型的正規表示法，你應該也會想到，不就是多幾個重要的特殊符號嗎？ ^_^y 是的～所以，我們就直接來說明一下，延伸型正規表示法有哪幾個特殊符號？由於底下的範例還是有使用到 regular_express.txt ，不巧的是剛剛我們可能將該檔案修改過了 @_@，所以，請重新下載該檔案來練習喔！

RE 字符	意義與範例
+	意義：重複『一個或一個以上』的前一個 RE 字符範例：搜尋 (god) (good) (goood)... 等等的字串。那個 o+ 代表『一個以上的 o 』所以，底下的執行成果會將第 1, 9, 13 行列出來。 egrep -n 'go+d' regular_express.txt
?	意義：『零個或一個』的前一個 RE 字符範例：搜尋 (gd) (god) 這兩個字串。那個 o? 代表『空的或 1 個 o 』所以，上面的執行成果會將第 13, 14 行列出來。有沒有發現到，這兩個案例( 'go+d' 與 'go?d' )的結果集合與 'go*d' 相同？想想看，這是為什麼喔！ ^_^ egrep -n 'go?d' regular_express.txt
\|	意義：用或( or )的方式找出數個字串範例：搜尋 gd 或 good 這兩個字串，注意，是『或』！所以，第 1,9,14 這三行都可以被列印出來喔！那如果還想要找出 dog 呢？ egrep -n 'gd\|good' regular_express.txt egrep -n 'gd\|good\|dog' regular_express.txt
()	意義：找出『群組』字串範例：搜尋 (glad) 或 (good) 這兩個字串，因為 g 與 d 是重複的，所以，我就可以將 la 與 oo 列於 ( ) 當中，並以 \| 來分隔開來，就可以啦！ egrep -n 'g(la\|oo)d' regular_express.txt
()+	意義：多個重複群組的判別範例：將『AxyzxyzxyzxyzC』用 echo 叫出，然後再使用如下的方法搜尋一下！ echo 'AxyzxyzxyzxyzC' \| egrep 'A(xyz)+C' 上面的例子意思是說，我要找開頭是 A 結尾是 C ，中間有一個以上的 "xyz" 字串的意思～

以上這些就是延伸型的正規表示法的特殊字元。另外，要特別強調的是，那個 ! 在正規表示法當中並不是特殊字元，所以，如果你想要查出來檔案中含有 ! 與 > 的字行時，可以這樣：

grep -n '[!>]' regular_express.txt

這樣可以瞭解了嗎？常常看到有陷阱的題目寫：『反向選擇這樣對否？ '[!a-z]'？』，呵呵！是錯的呦～要 '[^a-z] 才是對的！至於更多關於正規表示法的進階文章，請參考文末的參考資料(註2)

which

2013-01-18T18:51:00.003+08:00

http://www.nciku.com.tw/search/en/detail/which/84532

(A002).What is the difference between a CSU/DSU and a modem?

2012-05-30T18:42:00.003+08:00

(A002).What is the difference between a CSU/DSU and a modem?

A. A CSU/DSU converts analog signals from a router to a leased line; a modem converts analog signals

from a router to a leased line.

B. A CSU/DSU converts analog signals from a router to a phone line; a modem converts digital signals

from a router to a leased line.

C. A CSU/DSU converts digital signals from a router to a phone line; a modem converts analog signals

from a router to a phone line.

D. A CSU/DSU converts digital signals from a router to a leased line; a modem converts digital signals

from a router to a phone line.

Answer: D

(A002).What是一個CSU / DSU和調製解調器之間的區別嗎？

A. CSU/DSU的轉換成模擬信號，以租用線路的路由器，數據機轉換成模擬信號

從租用線路的路由器。

B. CSU/DSU的轉換成模擬信號，一個電話線路由器，數據機轉換成數字信號

從租用線路的路由器。

C. CSU/DSU的轉換成數字信號，一個電話線路由器，數據機轉換成模擬信號

從路由器到電話線。

D. CSU/DSU的轉換成數字信號，以租用線路的路由器，數據機轉換成數字信號

從路由器到電話線。

答案：D

Local Management Interface (LMI)

2012-05-30T18:23:00.000+08:00

Local Management Interface （LMI）

主要文章：本地管理接口國際電話和電報（CCITT）諮詢委員會在1984年提出了幀中繼的初步建議。缺乏互操作性和標準化，阻止任何重大的幀中繼部署，直到1990年，當思科公司，數字設備公司（DEC），北方電訊，StrataCom組成的聯合體，把重點放在其發展。他們製作了一個協議，提供額外的功能，複雜的跨網絡環境。這些被稱為幀中繼擴展為本地管理接口（LMI）。

數據鏈路連接標識符（的DLCI）是指通過幀中繼網絡路徑的數字。他們只能在本地顯著，這意味著，當設備A發送到設備-B的數據，將最有可能使用比設備-B會使用不同的DLCI答辯。多個虛擬電路可以是積極的，在相同的物理端點（通過使用子接口執行）。

LMI的全球尋址擴展提供幀中繼數據鏈路連接標識符（DLCI）全球重視，而不是局部意義。 DLCI值成為在幀中繼廣域網獨特的DTE地址。全球尋址擴展添加功能和幀中繼互聯網絡的可管理性。單獨的網絡接口和終端連接到他們的節點，例如，可以通過使用標準的地址解析和發現技術鑑定。此外，整個幀中繼網絡出現路由器在它的外圍是一個典型的局域網。

LMI虛電路狀態消息提供幀中繼DTE和DCE設備之間的通信和同步。這些消息用於PVC的狀態，從而防止數據被發送到黑洞（即不再存在以上的PVC）定期報告。

LMI的多播擴展允許組播組分配。組播節省帶寬，允許只發送給特定群體的路由器的路由更新和地址解析消息。該擴展還發送狀態更新消息的組播組的報告。

You can set one of three types of LMIs on Cisco devices: ANSI T1.617 Annex D, Cisco, and ITU-T Q.933 Annex A.

To do so, use the following commands beginning in interface configuration mode:

frame-relay lmi-type {ansi | cisco | q933a}

(A001) Which WAN protocol is being used?

2012-05-30T17:48:00.001+08:00

(A001).Refer to the exhibit. 根據下圖

Which WAN protocol is being used?

A. ATM
B. HDLC
C. Frame Relay
D. PPP

Answer: C

葫蘆由種子開始一週成長日記

2010-01-30T07:29:00.000+08:00

【附記】：此篇撰寫於 2008年6月27日原Blog

一、栽植前的採購：(2008年6月14日)

泥炭土

小花盆

葫蘆種子包

二、栽植前的準備：(2008年6月16日)

將泥炭土放入小花盆

取出葫蘆種子

將葫蘆種子放水中浸泡一夜(先使用六顆種子)

三、開始栽植：(2008年6月17日)

將浸泡一夜的六顆葫蘆種子放入小花盆並覆土約一公分深

四、等待發芽：一星期後(2008年6月23日)~

終於等到發芽，並冒出葉子：(2008年6月23日早)

到了傍晚，葉子長得更大：(2008年6月23日晚)

後記：此篇為本Blog開站首發，值得慶祝!!!!

附上葫蘆生長第二週的照片(2008年6月30日)。

向陽面看出葉子很茂密，但也發現到新長出的第三、四片葉子與最原始由種子裡的長出的那二片葉子有極大的不一樣

編號1,2 為從種子裡的長出的第一、二片葉子，編號3,4 為新長出的第三、四片葉子，由此張照片可以更清楚地看出葉子1,2與3,4不同的地方，編號2 黃色框框為種子殼內的薄膜，還粘在葉子上，代表早期葉子與種子的關係

這是側面，沒錯是四顆，後來又冒出二顆來了

這是背面(向陽背面)，可以更清楚看到四顆，撒了六顆種子，長出四顆耶!!!

RE 字符	意義與範例
+	意義：重複『一個或一個以上』的前一個 RE 字符範例：搜尋 (god) (good) (goood)... 等等的字串。那個 o+ 代表『一個以上的 o 』所以，底下的執行成果會將第 1, 9, 13 行列出來。 egrep -n 'go+d' regular_express.txt
?	意義：『零個或一個』的前一個 RE 字符範例：搜尋 (gd) (god) 這兩個字串。那個 o? 代表『空的或 1 個 o 』所以，上面的執行成果會將第 13, 14 行列出來。有沒有發現到，這兩個案例( 'go+d' 與 'go?d' )的結果集合與 'go*d' 相同？想想看，這是為什麼喔！ ^_^ egrep -n 'go?d' regular_express.txt
\|	意義：用或( or )的方式找出數個字串範例：搜尋 gd 或 good 這兩個字串，注意，是『或』！所以，第 1,9,14 這三行都可以被列印出來喔！那如果還想要找出 dog 呢？ egrep -n 'gd\|good' regular_express.txt egrep -n 'gd\|good\|dog' regular_express.txt
()	意義：找出『群組』字串範例：搜尋 (glad) 或 (good) 這兩個字串，因為 g 與 d 是重複的，所以，我就可以將 la 與 oo 列於 ( ) 當中，並以 \| 來分隔開來，就可以啦！ egrep -n 'g(la\|oo)d' regular_express.txt
()+	意義：多個重複群組的判別範例：將『AxyzxyzxyzxyzC』用 echo 叫出，然後再使用如下的方法搜尋一下！ echo 'AxyzxyzxyzxyzC' \| egrep 'A(xyz)+C' 上面的例子意思是說，我要找開頭是 A 結尾是 C ，中間有一個以上的 "xyz" 字串的意思～