写一个函数，接受一个字符串，返回这个字符串的翻转

例如：

s = ‘hello’

return ‘olleh’

使用Python

1
2
3
4
5
6
7

class Solution(object):
    def reverseString(self, s):
        """
        :type s: str
        :rtype: str
        """
        return s[::-1] # [:]代表切片遍历全部,[::-1],-1代表从最后一个元素开始

使用JavaScript

1
2
3
4
5
6
7

/**
 * @param {string} s
 * @return {string}
 */
var reverseString = function(s) {
    return s.split('').reverse().join('')
};

JavaScript中reverse()函数用于反转数组项的顺序。如下：

1
2
3

var values = [1, 2, 3, 4, 5];
values.reverse();
alert(values);   //5,4,3,2,1

在上述两种方法中，python的速度明显快于javascript，而且javascript存在bug，具体查看Esrever,但大多数的情况下还是够用了，就勉强先用着吧（笑）

有一个如下的文件file.txt

1
2
3
4
5
6
7
8
9
10

Line 1
Line 2
Line 3
Line 4
Line 5
Line 6
Line 7
Line 8
Line 9
Line 10

使用脚本输出第10行

Line 10

方法1:

1

sed -n '10p' file.txt

方法2:

1

sed '10!d' file.txt

方法3:

1
2

sed '10q;d'
# 此方法在处理大型文件时更有效率

方法4:

1
2
3
4
5

head -n 10 file.txt | tail -n +10
# 此方法最快
# head -n -lines 指定显示的行数
# tail -n +10 从第10行开始显示
# 此方法只能在Linux上使用

方法5:

1

awk 'NR==10' file.txt

找局部最优解和全局最优解时发现的有趣的概念。

柏拉图有一天问老师苏格拉底什么是爱情？苏格拉底叫他到麦田走一次，摘一颗最大的麦穗回来，不许回头，只可摘一次。柏拉图空着手出来了，他的理由是，看见不错的，却不知道是不是最好的，一次次侥幸，走到尽头时，才发现还不如前面的，于是放弃。苏格拉底告诉他：“这就是爱情。”这故事让我们明白了一个道理，因为生命的一些不确定性，所以全局最优解是很难寻找到的，或者说根本就不存在，我们应该设置一些限定条件，然后在这个范围内寻找最优解，也就是局部最优解——有所斩获总比空手而归强，哪怕这种斩获只是一次有趣的经历。

柏拉图有一天又问什么是婚姻？苏格拉底叫他到彬树林走一次,选一棵最好的树做圣诞树，也是不许回头，只许选一次。这次他一身疲惫地拖了一棵看起来直挺、翠绿，却有点稀疏的杉树回来，他的理由是，有了上回的教训，好不容易看见一棵看似不错的，又发现时间、体力已经快不够用了，也不管是不是最好的，就拿回来了。苏格拉底告诉他：“这就是婚姻。

ps(Process Status)用于列出系统当前运行的那些进程。ps命令列出的是当前那些进程的快照，如果要动态显示进程信息，就使用top命令。

Linux上的进程有5种状态：

• 运行 R runnable (正在运行或运行队列中等待)

• 中断 S sleeping (休眠中，受阻，在等待某个条件的形成或接受到信号)

• 不可中断 D uninterruptible sleep (收到信号不唤醒和不可运行，进程必须等待直到有中断发生)

• 僵死 a defunctt(“zombie”) process (进程已终止，但进程描述符存在，直到父进程调用wait()系统调用后释放)

• 停止 Z traced or stopped (进程收到SIGSTOP, SIGSTP, SIGTIN, SIGTOU信号后停止运行运行)

ps命令格式

ps[参数]

ps常用命令

ps -A

显示所有进程信息

ps -u root

显示指定用户信息

ps -ef

显示所有进程信息，连同命令行

ps -ef | grep

查找特定进程

ps -l

将目前属于自己这次登入的PID与相关信息列示出来

ps aux

列出目前所有的正在内存中的程序

ps -axjf

列出类似程序树的程序显示

sed学习

在Mac OS上使用sed是BSD sed 会产生很多的不便，因此可以替换一下

1
2

brew install gnu-sed
alias sed=gsed

sed(stream editor)流编辑器，用程序的方式来编辑文本。基本上使用正则模式匹配。

sed的官方手册

s替换命令

首先写一下可能会用到的正则的东西

有一段如下的文字pet.txt：

1
2
3
4
5
6
7
8

This is my cat
  my cat's name is betty
This is my dog
  my dog's name is frank
This is my fish
  my fish's name is george
This is my goat
  my goat's name is adam

要把其中的my替换为Dlala's，就使用

1

sed "s/my/Dlala's/g" pet.txt

这里使用""是为了能转义，其中，s代表替换命令，/my/代表匹配my，’/Dlala’s/‘代表把匹配替换成Dlala’s，/g和正则中一样，为全局模式，表示一行上替换所有的匹配。

上述的sed并没有对文件的内容进行修改，只是把处理后的内容输出出来，如果要修改原文件，就使用重定向，如下

1

sed "s/my/Dlala's/g" pet.txt > Dlala_pet.txt

或者也可以使用-i参数直接修改文件的内容:

1

sed -i "s/my/Dlala's/g" pet.txt

这里如果使用OS X的话要这样写

1

sed -i '' "s/my/Dlala's/g" pet.txt

这是因为Ubuntu ships with GNU sed, where the suffix for the -i option is optional. OS X ships with BSD sed, where the suffix is mandatory. Try sed -i ‘’

来写个实例，获取html标签内的内容

index.html如下

1
2
3

<p>
	<b>This</b> is what <span style="text-decoration: underline;">I</span> meant. Understand?
</p>

使用sed命令如下:

1

sed "s/<[^>]*>//g" index.html

输出如下:

1

This is what I meant. Understand?

在每一行的前面加东西：

1

sed "s/^/#/g" pet.txt

在每一行的后面加东西：

1

sed "s/$/ --- /g" pet.txt

替换第三行的制定内容

1

sed "3s/my/your/g" pet.txt

替换3到6行的指定内容

1

sed "3,6s/my/your/g" pet.txt

修改一个txt如下：

1
2
3
4

This is my cat, my cat's name is betty
This is my dog, my dog's name is frank
This is my fish, my fish's name is george
This is my goat, my goat's name is adam

只替换每一行的第一个s：

1

sed "s/s/S/1" pet.txt

只替换每一行的第二个s：

1

sed "s/s/S/2" pet.txt

只替换每一行的第三个以后的s：

1

sed "s/s/S/3g" pet.txt

此命令只能在Linux下执行，原因还是sed的版本问题。

使用&来当做被匹配的变量，然后在其左右加内容

1

sed 's/my/[&]/g' pet.txt

多个匹配

如果需要一次替换多个模式，可以使用多个匹配，每个模式之间使用；分割，下面写两个例子:

第一个例子是这样的，替换一到三行的my，并且第三行到最后一行的This

1

sed '1,3s/my/your/g; 3,$s/This/That/g' pet.txt

这里的''不能用""代替！

上述的命令等价于：

1

sed -e'1,3s/my/your/g' -e '3,$s/This/That/g' pet.txt

（这里就使用了sed的-e命令行参数）这里也不要使用""因为会造成$不起作用的情况。

圆括号匹配

圆括号括起来的正则表达式所匹配的字符串可以当成变量来使用，sed中使用的是\1,\2…

1

sed 's/This is my \([^,]*\),.*is \(.*\)/\1:\2/g' pet.txt

输出结果：

1
2
3
4

cat:betty
dog:frank
fish:george
goat:adam

sed的命令

N命令

N命令–把下一行的内容纳入当成缓冲区做匹配。

例如，当使用N来处理以下pet.txt文件时

1
2
3
4
5
6
7
8

This is your cat
  my cat's name is betty
This is your dog
  my dog's name is frank
This is your fish
  my fish's name is george
This is your goat
  my goat's name is adam

会把原文本中的偶数行纳入奇数行进行匹配，就成了以下效果：

1
2
3
4

This is my cat\n  my cat's name is betty
This is my dog\n  my dog's name is frank
This is my fish\n  my fish's name is george
This is my goat\n  my goat's name is adam

那么使用命令

1

sed 'N;s/\n/,/' pet.txt

就会出现以下效果：

1
2
3
4

This is my cat,  my cat's name is betty
This is my dog,  my dog's name is frank
This is my fish,  my fish's name is george
This is my goat,  my goat's name is adam

a命令和i命令

a : append

i : insert

这两条命令是用来添加行的。分别举个例子：

1

sed "1 i This is Lyh"

表示在第一行前插入一行(insert)

1

sed "1 a This is Lyh"

表示在第一行后插入一行(append)

还可以使用匹配来添加文本:

1

sed "/fish/a This is Lyh" pet.txt

d命令

删除匹配行,举三个例子

1
2
3
4
5
6
7
8

sed '/fish/d' pet.txt
#删除fish这一行

sed '2d' pet.txt
#删除第二行

sed '2,$d' pet.txt
#删除第二到最后一行

p命令

p命令可以理解为是grep式的命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 匹配fish并输出，可以看到fish的那一行被打了两遍，
# 这是因为sed处理时会把处理的信息输出
$ sed '/fish/p' pet.txt
This is my cat, my cat's name is betty
This is my dog, my dog's name is frank
This is my fish, my fish's name is george
This is my fish, my fish's name is george
This is my goat, my goat's name is adam
 
# 使用n参数就能只输出一行
$ sed -n '/fish/p' pet.txt
This is my fish, my fish's name is george
 
# 从一个模式到另一个模式
$ sed -n '/dog/,/fish/p' pet.txt
This is my dog, my dog's name is frank
This is my fish, my fish's name is george
 
#从第一行打印到匹配fish成功的那一行
$ sed -n '1,/fish/p' pet.txt
This is my cat, my cat's name is betty
This is my dog, my dog's name is frank
This is my fish, my fish's name is george

基本知识

• Pattern Space: 关于参数-n，表示取消默认输出，相当于–quiet，–silent。在sed处理文件的时候，每一行都被保存在一个叫模式空间的临时缓冲区中，除非行被删除或者输出被取消，否则所有被处理的行都将打印在屏幕上。接着模式空间被清空，并存入新的一行等待处理。

• Address：[address[,address]][!]{cmd}，其中的!表示匹配成功后是否执行命令，address可以是一个数字，也可以是一个模式，可以通过逗号分隔两个address表示两个address的区间。

• 命令打包：cmd可以是多个，它们可以用分号分开，可以用大括号括起来作为嵌套命令

举个例子：

1
2

sed '3,6 {/This/{/fish/d}}' pet.txt
#对3行到第6行，匹配/This/成功后，再匹配/fish/，成功后执行d命令

1
2

sed '1,${/This/d ; s/^ *//g}' pets.txt
#从第一行到最后一行，如果匹配到This，则删除之；如果前面有空格，则去除空格

• HoldSpace: 保持空间

1
2
3
4
5

g：将hold space中的内容拷贝到pattern space中，原来pattern space里的内容清除
G：将hold space中的内容append到pattern space\n后
h：将pattern space中的内容拷贝到hold space中，原来的hold space里的内容被清除
H：将pattern space中的内容append到hold space\n后
x：交换pattern space和hold space的内容

举个例子：

1

sed -e '/test/h' -e '$G‘  example

在这个例子里，匹配test的行被找到后，将存入模式空间，h命令将其复制并存入一个称为保持缓存区的特殊缓冲区内。第二条语句的意思是，当到达最后一行后，G命令取出保持缓冲区的行，然后把它放回模式空间中，且追加到现在已经存在于模式空间中的行的末尾。在这个例子中就是追加到最后一行。简单来说，任何包含test的行都被复制并追加到该文件的末尾。

1

sed -e '/test/h' -e '/check/x' example

互换模式空间和保持缓冲区的内容。也就是把包含test与check的行互换。

• 执行sed脚本：sed -f test.sed

Sed对于脚本中输入的命令非常挑剔，在命令的末尾不能有任何空白或文本，如果在一行中有多个命令，要用分号分隔。以#开头的行为注释行，且不能跨行。

ps: 去除空白行：sed ‘/^ *$/d’ file

定义

正则表达式就是记录文本规则的代码。

正则表达式测试

JavaScript正则表达式在线测试工具

Python正则表达式在线测试工具

元字符

常用元字符:

重复

例如：
Windows\d+
匹配Windows后面接一次到无限次的数字

字符转义

如果查找元字符本身就，使用 \ 来进行转义，例如 dwk715.github 使用dwk715\.github来匹配.

字符类

[]可以用于匹配字符集
例如：
当要匹配元音字母时，使用[aeiou] 进行匹配
匹配电话号码

1

\(?0\d{2}[)-]?\d{8}

匹配电话号码,如(010)88886666，或022-22334455，或02912345678等。
但这个表达式存在问题，会匹配到010）12345678或者（10112345678这样错误的号码

分枝条件

分枝条件就是为了解决这个而引入的
正则表达式里的分枝条件指有几种规则，如果满足其中的一条规则就完成匹配，具体方法用|把不同的规则分割开。
例如：解决上面说到的问题，应该使用正则表达式如下：

1

0\d{2}[-]?\d{8}｜\(＋0\d{2}\)＋[-]?\d{8}

匹配不带()的或者带()的，但要注意匹配的顺序，如匹配🇺🇸的邮政编码，应该使用一下正则：

1

\d{5}-\d{4}|\d{5}

如果写成

1

\d{5}|\d{5}-\d{4}

则只会匹配5位邮政编码以及9位邮政的前5位，原因就是匹配分枝条件时，将会从左到右测试每个条件，如果满足某个分枝的话，就不会再去尝试其他的条件了。

分组

分组（又称子表达式）用于匹配多个重复字符。
举个例子，匹配合规的IP地址（这个很复杂）应该有如下考虑：

• 由四个不大于255的数字组成
• 数字应该为24（0～9）或者25（0～5）或者01后跟一个数字或者
• 可以存在前导0，如01.02.03.04这样的IP地址
  具体实现如下：

1

(2[0-4]\d)

后向引用

后向引用用于重复搜索前面某个分组匹配的文本。使用小括号指定一个子表达式后，匹配这个子表达式的文本（也就是此分组捕获的内容）可以在表达式或其他程序中作进一步的处理。
例如\1代表分组1匹配的文本。
例子：

1

\b(?<Word>\w+)\b\s+\k<Word>\b

可以匹配重复的单词，如go go，或者fuck fuck。也可以省略k，写成

1

\b(?<Word>\w+)\b\s+\<Word>\b

常用的分组语法

零宽断言

零宽断言用于匹配某些内容（但不包括这些内容）之前或者之后的东西。

举个例子：

要匹配一个句子中以ing结尾前的部分

1

\b\w+(?=ing\b)

这被称为零宽度正预测先行断言，它断言自身出现的位置后面能匹配表达式exp的。

再举个例子：

1

(?<=\bre)\w+\b

这个例子会断言自身出现的位置前面能匹配表达式exp的。就说在reading a book中会匹配到ading(JS不支持，垃圾！)

负向零宽断言

有时候会遇到这样的问题，例如，要匹配一个带q的但q后面不能跟着u的单词，就可以用反义来写：

1

\b\w*q[^u]\w*\b

但这个正则会除问题，例如在匹配Iraq fighting时，就会匹配到整个字符串，这是因为[^u]总会要匹配一个字符，所以如果q是单词结束的最后一个字符的话，[^u]就会匹配到空格，要解决这个问题，就用到了零宽度负预测先行断言(?!exp)，断言此位置的后面不能匹配表达式exp。例如：

1

\b((?!abc)\w)+\b

匹配不包含连续字符串abc的单词

同理，使用零宽度负回顾后发断言来断言此位置的前面不能匹配表达式exp：

1

(?<![a-z])\d{3}

前面不是小写字母的3位数字

一个复杂的不正确的例子：匹配不包含属性的简单html标签内的内容，

这个例子中需要有一个<…>和一个</…>并且…的内容相同，那么就可以写成下面这种形式

1

(?<=<(\w+)>).*(?=<\/\1>)

在这个正则中，首先匹配一个带<…>的部分，此部分中间有一个w+的字符串，然后跟着任意的字符串.*，接下来匹配一个</…>的部分，...需要和前面的…相同，这样就匹配了一个不包含属性的简单html标签。(js不支持lookbehind)。

贪婪与懒惰

贪婪就是匹配尽可能多的字符

懒惰则是匹配尽可能少的字符

下面的表格为懒惰限定符

举个例子：

a.*b在匹配aabab时会匹配到aabab

而a.*?b在匹配aabab时会匹配到aab和ab

这就说明*?会在整个正则匹配成功的前提下使用最少的重复！

（在正则表达式中有一条规则，最先开始的匹配拥有最高的优先权

The match that begins earliest wins

）

总结

正则的简单学习花了很多时间，不知道值不值得，但还是有许多疏漏的地方，在学习python和javascript的时候再根据语言本身看看。