mzh/blog – 第 7 页

Linux下Redis内存优化

2014-06-09

最近使用Redis，由于它属于内存数据库，所以调优都集中到了内存上。
根据Redis官方说法：

需要将vm.overcommit设置为1
```
sysctl vm.overcommit_memory=1
```
确保设置了一定量的swap，最好和内存一样大，否则内核的OOM（out-of-memory）killer会干掉Redis进程
若Redis是大量写入的应用，持久化的RDB或者AOF会按比例使用，或很有可能使用redis使用量的一样多的内存.

使用和Redis一样多的内存做持久化，那我岂不是都得让一半的内存出来给它？还有那个overcommit是几个意思也不解释一样？搞砸了其他进程肿么办？
好吧，得研究一下内存是如何管理的：
内核会将物理内存分割成动态虚拟的内存页（page），然后在malloc时按overcommit_memory和overcommit_ratio的设置来确定是否允许分配虚拟内存页。
翻看Linux Kernel的文档/资料才发现，有三种值：

overcommit_memory=0，默认，智能超发，每次要求分配内存时，kernel都会比较请求的空间和空余的空间是否足以分配
overcommit_memory=1，请求分配内存时，永远假装还有足够的内存
overcommit_memory=2，不允许超发内存，即允许分配的大小小于

overcommit_ratio*物理内存+swap大小

好吧，Redis要大家假装还有空余内存…也就是说会有很大的几率触发Swap造成性能急剧下降，不过，性能下降总比不能用好。
说到swap，大家肯定给Redis服务器设定过swappiness=0，然后祈祷奇迹的发生，但是还是触发了swap。为什么呢？
首先，Linux十分注重读写性能，尽量避免磁盘IO，你从磁盘上读取的文件会被放入内存，就算程序结束了，还是存在的，这部分内存被称为file
buffer（或者file page），是swap重点照顾的回收对象。其次，Linux上的用户态进程所有页（也就是redis运行时占用的）也是可以回收的。
其实，swap的触发机制是这样的：根据swap倾向（swap_tendency）决定回收用户态页还是file
buffer，最后把LRU队列中用得最少的放入swap空间中。摘自LWN
以下是内核计算其 “swap倾向"的公式：

swap_tendency = mapped_ratio/2 + distress + vm_swappiness

其中：

distress 值是内核在释放内存时遇到的问题数。当内核第一次决定收回内存页面时, distress将为0；尝试次数越多，这个值也越大。
mapped_ratio值是mapped page与总page比例，即
```
mapped ratio = (nr mapped * 100) / total memory
```

nr_mapped可以从下面的命令行获得

 grep nr_mapped /proc/vmstat

vm_swappiness 就是大家设定的swappniness值

当swap_tendency超过100时，swap就开始收集最近较少用的页。而且swappiness设置为0，PRFA就不会回收用户态页，
设置为100时，总是回收用户态页，当然这不是我们想看到的。最后回到之前的问题，怎么避免触发swap？
其实调整好swapiness之后，只需要监测/proc/zoneinfo中的pages free/high
之间的差值即可，high是当前zone中计算出来的高水位值，当pages free低于pages high才会触发swap回收页，就是这么简单啦~
实在担心的话可以用

redis-server --test-memory 需要测试的内存（MB）

测试一下，系统就会在给定的内存下跑测试。

SSDP协议笔记

2014-05-30

近来在研究SSDP，Simple Service Discovery Protocol (简单服务发现协议)。
这是用来实现无配置，自发现局域网内部服务的协议。由IPv4下有固定的239.255.255.250:1900这一固定的地址来负责多播数据。
不过，从我的学习经历来说，要啃这种东西，最好的方法还是用例子搞懂名词，并实践一次。其实SSDP协议的请求就三种： byebye, alive,
discovery

byebye请求

NOTIFY * HTTP/1.1
Host: 239.255.255.250:1900
NT: someunique:idscheme3
NTS: ssdp:byebye
USN: someunique:idscheme3

NOTIFY 通知所有广播域的机器
HOST 值是固定的（IPv4），算是协议的一部分
NT （Notification Type）这个是GENA的定义，即通知类型,值一般是当前设备的类型
NTS (Notification Sub-Type)通知子类型，如果要遵守SSDP，这个值就代表了请求的类型，但是为什么NTS和NT搞混了呢……协议中写得非常明白

5.3.5. Shouldn’t the NT and NTS values be switched? Yes, they should.
Commands such as ssdp:alive and ssdp:byebye should be NT values and the
service type, where necessary, should be the NTS. The current mix-up is a
consequence of a previous design where the NT header was used in a manner much
like we use the USN today. This really needs to change.

USN 这个设备的UUID，防止设备的IP或者网络环境改变后，连接至错误的设备。

alive（服务上线/广播存活/心跳包）

NOTIFY * HTTP/1.1
HOST: 239.255.255.250:1900
CACHE-CONTROL: max-age=100
LOCATION: http://10.5.4.81:49155/TxMediaRenderer_desc.xml
NT: upnp:rootdevice
NTS: ssdp:alive
USN: uuid:001e4fd3fa0e0000_MR::upnp:rootdevice

CACHE-CONTROL说明这个设备状态至少在100秒内不会过期，过期时，所有设备就必须要刷新这信息，如果得不到新的数据，则认为此设备不可用。如果不提供CACHE-CONTROL或者EXPIRES，此设备的信息将不允许缓存，超时机制由接受端决定
LOCATION此设备的控制点或描述文件所在地

discovery请求

M-SEARCH * HTTP/1.1
Host:239.255.255.250:1900
ST:urn:schemas-upnp-org:device:InternetGatewayDevice:1
Man:"ssdp:discover"
MX:3

M-SEARCH 说明这是强制的搜索方法(由Mandatory Extensions in HTTP中的Mandatory HTTP Requests确定)
ST （search term)搜索条件，指明需要搜索的设备，可以是类型，服务，甚至是UUID，至于怎么回应嘛……那是服务端的事了
Man M-SEARCH请求必须带的数据项，值必须为"ssdp:discover"
MX 优先级，数字越高，优先级越低

服务发现的现实流程

 +---------+ +---------+ +-----------+
| Client | | Server | | Multicast |
+---------+ +---------+ +-----------+
---------------\ | | |
| Initialized |-| | |
---------------- | | |
| | |
| discovery | |
|------------------------------------->|
| | |
| | Client wants ST |
| |< ------------------------|
| | -------------------\ |
| |-| In discovery ST? | |
| | -------------------- |
| | |
| | (In ST) alive |
| |------------------------->|
| | |
| | Here is Server |
|< ------------------------------------|
| | |

好了，这个协议就这么Simple~

跟着Django学设计模式[1]

2014-04-09

Django作为传说中的又大又重的开源项目，自然而然地使用了很多优秀的设计模式，就让我们看看Django吸收了哪些优秀的设计模式吧。如果没有特殊说明，本文的Django均指Django
1.6 创建模式中Django使用了：

工厂方法模式
惰性初始模式

工厂方法模式

最著名的就是[inlineformset_factory](https://docs.djangoproject.com/en/dev/topics/forms/modelforms
/#inline-formsets)这函数。
应用场景是这样的：假设有两个Model:Book和Author。Book有外键指向Author，这时，如果需要写个关于Author和Book的model表单组（model
formset）时，顿时头疼了有没有，要判断Author是否是新创建的，Book的外键是否符合限制条件等等问题……重新写一个form把它们组合起来？太费事了
BookFormSet = inlineformset_factory(Author, Book) 搞定收工。
这就是工厂方法，根据给定参数产出新的类。

惰性初始模式

用过Django的人都知道settings很重要，但是每次遇到 from django.conf import settings
时，有没有人好奇地看看这个对象到底是什么呢

In [1]: from django.conf import settings
In [2]: type(settings)
Out[2]: django.conf.LazySettings

怎么算个惰性对象呢？假设我们有个需要挺多时间才能得到结果的函数sleepy

def sleepy():
import time
time.sleep(3)
print "Slept 3 seconds"
return True

直接调用sleepy肯定是会等上3秒才有结果的，而当settings里面引入这个函数，

SLEEPY=sleepy()

在from django.conf import settings时并没有暂停3秒，而是调用settings.SLEEPY时才会暂停。
也就是说，你要是永远不用settings.SLEEPY的话，这个函数就永远不会执行，这就是懒–>惰性初始模式啦

小结

Django最常见的设计模式，

工厂方法模式
惰性初始模式

大家应该是经常用的了，只是没有注意到这是"设计模式"，充分证明了"大道至简"，Django简化到了大家都没注意到的地步，可真是成功啊！

Python标准库小窥[1]:weakref

2014-03-14

平时工作经常能碰到一部分标准库的代码，但是常常因为琐事没有细细地研究这些标准库，直到最近发觉Python不愧是battery
included的语言，因此决定从PyMOTW好好学学。那么就从最常见，但最容易忽略的weakref开始吧！
先让我们看看weakref想解决什么问题。 PyMOTW是这样说的：

Refer to an “expensive” object, but allow it to be garbage collected if
there are no other non-weak references.

引用一个"开销大"的对象，并在只剩下弱引用时允许垃圾回收机制回收这个对象。 PyMOTW中的例子
当obj被显式地删除后（模拟gc回收了），弱引用的proxy和ref的引用对象消失了，不能再取回了。达到了之前希望的只剩下弱引用时允许回收。
如果还有强引用，这些弱引用仍能正常获取值。问题就来了，这个蛋疼的东西到底有什么用？那就是当个智能Cache
比如你有一堆图片文件buffer，你希望通过字典类组成一个cache来存储它们，以获得可观的O(1)读取速度。但是，当这个cache中的图片越来越多时，由于Python自带的gc（垃圾回收机制）没办法收回字典内引用了的项，导致cache越来越大，内存消耗加大，可你又不想用其他方法暂存这些数据到硬盘（因为慢啊！），这时，如果有种方法让这些存储项能自动清除，并能该有多好！
这就是PyMOTW中的Cache例子
可以看到，使用dict的例子中，如果删除了所有引用(all_refs)，cache仍然保留着这些"开销大"的对象，而用WeakValueDictionary就完成了正常回收的过程，保证了cache不会过多地占用系统空间。
还有一种用途，就是保证循环引用可回收 比如有以下节点 A B C，他们相互有指向下个节点的引用（->）表示

A->B
B->C
C->A
即A->B->C->A

当这个引用形成了环形时，如果把其中两个节点（B、C）删除掉，这个环仍能正常工作，

A->B->C->A

但是当我们删掉最后的A节点后，gc就不明白该不该回收这些节点，因此，造成了内存泄漏(leaking) 这个情况正如PyMOTW所示：

After 2 references removed:

one->two->three->one

Collecting...

Unreachable objects: 0

Garbage:[]

Removing last reference:

Collecting...

gc: uncollectable

gc: uncollectable

gc: uncollectable

gc: uncollectable

gc: uncollectable

gc: uncollectable

Unreachable objects: 6

Garbage:[Graph(one),

 Graph(two),

 Graph(three),

 {'name': 'one', 'other': Graph(two)},

 {'name': 'two', 'other': Graph(three)},

 {'name': 'three', 'other': Graph(one)}]

如果使用弱引用的dict就没有这个问题啦～注意，由于WeakDict是构建于dict之上的，因此，不要遍历（iter）这个对象，因为里面的值随时发生变化

Python如何查找Follow关系

2014-03-14

Twitter中Follower和Followee，现需要找到互相关注的两个人（不关心顺序）例如：现有列表

 l = [(1, 2), (2, 3), (3, 2), (3, 4), (4, 1),
(4, 3), (4, 3)]

可以通过下列函数生成

def gen_pairs():
return (random.randint(0, 30), random.randint(0, 30))
l = [gen_pairs() for x in xrange(20)]

解法一：

import collections
[x for x, y in collections.Counter([tuple(sorted(x)) for x in l]).iteritems() if y > 1]

[tuple(sorted(x)) for x in l] 首先是将列表的内容按小到大重新排列
通过计数器collections.Counter，来统计重复的数量
if y > 1 将大于一个的放入结果集中

最后统计用时best of 3: 38.9 µs per loop ~~老湿，还能给力点吗？~~ 解法二：
[Stackover上的解答](http://stackoverflow.com/questions/22161370/algorithm-to-find-
follow-relationship-like-twitter/22161585#22161585 “Stackover上的解答” )

[x for x in set_l if x[::-1] in set(l)]

快了6倍……答主说到这个算法最快也就是O(n)了，因为必须遍历所有项有木有啊！

2013年终总结

2013-12-27

这几天手机上的待办事项里一直提醒着要做总结了，去年的年终总结迫于压力删除了，找都找不回来啊……所以以后的总结就隐去隐私部分吧：）不过，大概记得的3个都实现了，充分说明这玩意还是挺神的，冥冥之中会推动自己实现它们。
2013年，其实还算过得比较充实的，消化了不少技术类书籍：

Python编程实践
程序语言的奥妙 : 算法解读
SQL反模式 : SQL反模式
黑客与画家 : 硅谷创业之父Paul Graham文集
MySQL性能调优与架构设计
简约之美 : 软件设计之道
Python学习手册
深入浅出 Python
代码整洁之道
Python编程
CouchDB指南
MongoDB指南

也参加了不少的技术会议，但是总感觉国内的企业没几家是在耐心积攒和发展技术的，全都是一股脑地用最新技术忽悠一阵……好了，咱没有文学青年的细腻，只好继续用问答式的总结模板了。

今年你所完成的最重要的事情是什么？

* 成功从职场菜鸟转化成普通员工，顺便喂饱自己了，职业上发展还算顺利

今年你所学到的最有用的是什么？

* 各种Python技术点，NoSQL入门

满分10分，你在这一年对自己的满意度有几分？

* 总评：6分 及格

你明年想要实现什么，要不要来个前所未有最棒的一年？

* **把《Data Structures and Algorithms Using Python》翻译完**
* 能换到Douban, Mozilla, Opera，Redhat其中之一
* dumpjs能上线，赚回租费
* 微健身，不求肌肉只求少点感冒
* 至少旅游一次

如果现在是明年的12月31日，你最想在你的生活中见到什么？

* 手上有《**Data Structures and Algorithms Using Python》的译本**

《程序语言的奥妙》之Python实现–Part1

2013-07-14

程序就像食谱，严格跟着食谱做饭，味道绝对不会差到哪里去，但是可能就不太好吃。
算法对于程序员，就像棋谱对于棋手，可能一时半回没啥用，但最终认得棋谱多的棋手始终会获胜的
链表的实现就像出门买杂货，逛完肉店买肉，然后再到鱼店买鱼，店之间并没有联系，但使之串起来的是自己的购物单，这张单子就是链表

还有很多对于计算机概念的有趣解释，大家就自己看吧 🙂

进入正题

前面就介绍下这本书，接下来是里面各种经典算法的Python实现，问题和算法神马的大家看书就好了～我就不摘抄了。有错欢迎指正。

第47节：辗转相除法

或称欧几里得求最大公约数算法

#!/usr/bin/env python
# encoding: utf-8
def Euclid(x, y):
if x < y:
tmp = x
x = y
y = tmp
while y != 0:
rod = x % y
x = y
y = rod
return x
if __name__ == '__main__':
print Euclid(126, 90) # should be 18

第50节：桶排序

#!/usr/bin/env python
# encoding: utf-8
def bucket_sort(lis):
max_item = max(lis)
bucket = [-1 for x in xrange(max_item+1)]
for item in lis:
if item < 0:
raise ValueError("Can't handle %d" % item)
bucket[int(item)] = item
return filter(lambda x: x != -1, bucket)
if __name__ == '__main__':
print bucket_sort([8,2,1,5,9,7]) # should be [1,2,5,7,8,9]

第51节：基位排序—-桶排序的升级版

#!/usr/bin/env python
# encoding: utf-8
from copy import deepcopy
def bit_sort(lis):
bucket = [[] for x in xrange(len(lis))]
k = len(str(max(lis))) # sort time
array = [deepcopy(bucket) for x in xrange(k)]
for time in xrange(k):
if time == 0:
for l in lis:
array[0][int(str(l)[-1])].append(l)
else:
for b in array[time-1]:
for item in b:
try:
array[time][int(str(item)[-1-time])].append(item)
except IndexError:
array[time][0].append(item)
return array
if __name__ == '__main__':
for line in bit_sort([123, 602, 82, 777, 57, 510, 396, 196, 843, 138]):
print line
print "The Last line should be:[[57, 82], [123, 138, 196], [], [396], [], [510], [602], [777], [843], []]"

中国县及县以上地区数据结构【Python】

2013-07-13

郭嘉统计局虽然经常更新地区数据，但是其数据结构糟糕透顶，plain
HTML有没有！都不提供SQL或者是XML数据类型！都还得写个解析器来加载这个结构，用LXML解析的过程我就不写了
去除各种table之后的数据库

110000 北京市 110100 市辖区 110101 东城区 110102 西城区 110105 朝阳区 110106 丰台区 110107
石景山区 110108 海淀区

转换以后：

省:北京
   ├─ 市辖区
   │  ├─ 东城区
   │  ├─ 西城区
   │  ├─ 朝阳区
   │  ├─ 石景山区
   │  ├─ 海淀区
   │  ╰─ 平谷区
   ╰─ 县
      ├─ 密云县
      ╰─ 延庆县

规律就是邮政编码！用了groupby和defaultdict这些基本的Python东西下面是程序啦，用法是直接打省份的名称即可。
当然，函数已经是单独实现的，所以在其他地方用也行啦～


#!/usr/bin/env python
# encoding: utf-8
from itertools import groupby
from utils import ScaleTree
def make_city_tree(path):
"""
 make a tree of province, city, county of China

 :path: path to database
 :returns: tree

 """
def strip_zipcode(item):
"""
 Strip all zipcode from stats.gov.cn
 :returns: city_name
 """
return item[7:].decode('utf8').strip()
with file(path, 'r') as db:
tree = ScaleTree()
provinces = groupby(db, key=lambda x: x[:2])
for pid, province_data in provinces:
province_data = list(province_data)
province_name, cities = strip_zipcode(province_data[0]), province_data[1:]
for cid, city_data in groupby(cities, key=lambda x: x[:4]):
city_data = list(city_data)
city_name, counties = strip_zipcode(city_data[0]), city_data[1:]
tree[province_name][city_name] = map(strip_zipcode, counties)
return tree
if __name__ == '__main__':
tree = make_city_tree('db.txt')
pro = unicode(raw_input('省:'), 'utf8')
for x in tree.keys():
if pro in x:
cities = tree.get(x)
for t, city in enumerate(cities):
if t+1 != len(cities):
st = u"├"
else:
st = u'╰'
print u"\u2004\u2004\u2004%s─\u2004%s" % (st, city)
for d, county in enumerate(tree.get(x).get(city)):
if d+1 != len(tree.get(x).get(city)):
st = u"├"
else:
st = u'╰'
if t+1 != len(cities):
ct = u"│"
else:
ct = u"\u2004"
print u"\u2004\u2004\u2004%s\u2004\u2004%s─\u2004%s" % (ct, st, county)

最近一些面试题（Python）

2013-07-01

最近换工作，面了几家公司，超大，大，中，小都有，不过就不提名字了。唯一的感触就是自己实在是太浪费四年的时间在游戏上了，要是腾出时间搞算法那是极好啊。
不过我总觉得知识的欠缺是可以通过学习来弥补的，同时，记录也是学习的一部分，现在我就写写我还记得的几道面试题。

骑士巡游问题

一道简单的BFS（广度优先）算法题

在一个国际象棋棋盘上 (NN)，有一个棋子"马(Knight)"，处在任意位置(x, y)；
马的走法是日字型，即其可以在一个方向上前进或后退两格，在另一方向上前进或后退一格。请编程找出马如何从位置(x, y)走到棋盘右下角(N,
N)的位置的步骤。例如：假设棋盘大小为33，马处在（1，2）位置，马只需要走一步，即 (1,2)-> (3,3)即可到达目的地。

具体代码我已经push到github上了，链接在此
对于从来没有研究过算法的我来说，整个题目的难处在理解队列这个概念上。
广度优先的队列之奇妙的地方在于，每一层的尝试，都先放入队列中，紧接着，挨个判断队列中的元素是否达成了目标。对，就这么简单。

Fibonacci数列

好吧～两家公司都考这斐波那契……

用Python生成指定长度的斐波那契数列

考递归：

def fib_recursion(n):
if 0< = n < 2:
return 1
else:
return fib_recursion(n-1)+fib_recursion(n-2)
print fib_recursion(99) # 调用即可

不错吧～完美地使用了递归，当然，如果能用字典存储，这样更完美了对吧？错！其实考的是iterable的使用，Python CookBook
19.3里那极为精妙的解法才可以称得上答案：

def fib():
x, y = 0,1
while True:
yield x
x, y = y,x+y
if __name__ == '__main__':
import itertools
print list(itertools.islice(fib(), 10))

LRU缓存

现场编程题，1小时之内写出可用的LRU cache util

其实当场没有写出来，主要是因为还不清楚list的pop()中如果有数字的话，就是O(n)的复杂度，我当时的水平最多写得出[这个源里的程度](https://github.com/mengzhuo
/django-lru-cache)。用的是dict的popitem，而且是面试官说在生产系统中也使用这样的方法。后来，仔细看了Python
Cookbook（知道是好书了吧），发现collections的deque神器，不过正反向双list也是个不错的ADT选择，而且这些连面试官都不知道。
具体的应用以后写读书笔记时会和大家分享下的。

Django调试方法三枚

2012-12-16

如果各位同学在coding过程中，需要打印变量，捕捉异常，但只能用print变量的方法解决问题，而你觉得不优雅，不方便，急需一种调试的方法的话，那这篇文章很适合你。
我学这些是因为在Django调试中，平时使用默认的Error
Page已经是非常方便了，但是，有次在对外API测试中可能会出现无法查看那个错误页的情况，两眼瞎，四处pirnt，最后还不能解决问题……如此屈辱后，我等痛下决心，一定找到更好的解决方法，因此有了本文。技巧

ipdb断点法［排错／尝试］

在你想打断点的地方，加上这句—-需要安装ipdb

import ipdb;ipdb.set_trace()

[](blog/wp-
content/uploads/2012/11/2012-11-17-213312的屏幕截图.png)

当程序运行到这里时，在启动服务器的console中将会弹出上面的提示符。这时就可以在这里像使用console编程时一样地随心所欲了～
顺便推荐几个好用的快捷键

按键	含义
l	line:查看指定行，例如l 31
r	return:执行到当前函数返回
c	continue:继续执行代码，直到下个断点
whatis	查询某个变量是什么

有了这招，基本的疑难杂症都可以debug掉了～

logger大法［定位／记录］

这是今天的主角，相对上面的方法，这个的自动化程度不是一般的高，在不改变源代码的情况下就可以记录所有的django行为。
在Django的settings.py里面，可以看到下面这自动添加的LOGGING这个设置变量。默认情况下，Django只会在DEBUG=False时，当服务器遭到500错误，才会发邮件给admins。而我们现在要在代码中加入一个logger，这样，任何错误或者是希望打印出来的信息都不会逃走啦～而且还可以自定义等级记录哦～
在settings.py中

from logging.handlers import SysLogHandler
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
"syslogHandler":{
"class":"logging.handlers.SysLogHandler",
"formatter":"verbose",
'address': '/dev/log',
"facility":SysLogHandler.LOG_LOCAL6
},
},
'loggers': {
"project":{
"handlers":["syslogHandler"],
"level":"DEBUG", #整个project的logger等级为DEBUG
},
"project.app":{
"handlers":["syslogHandler"],
"level":"INFO", #而project下的app对应的是INFO等级
},
},
"formatters":{
'verbose': {
'format': '%(levelname)-8s[%(name)s][%(funcName)s:%(lineno)d] %(message)s',
},
}
}

在某些你想记录log的地方

import logging
logger = logging.getLogger(__name__)
logger.error('This is an error')

注意这个__name__，返回值是app+文件名，有利于我们定位bug和使用不同的handler，比如下面的传递路径示意：

[](blog/wp-
content/uploads/2012/11/2012-11-20-220942的屏幕截图.png)

如果一条log信息被project.app.views的handler抓住了，并且，propagate=False时，父级的handler，比如"project.app"，就不会收到此log。
至于logger语句放在哪里，我个人习惯跟着try except这段，用于捕捉异常，或者在方法开始时logger.info查看相关参数。
而logger默认等级有6种：NONE, DEBUG, INFO, WARNING, ERROR, CRITICAL(严重等级由低到高)
至于logger输出目的地，有很多种选择，可以输出到文件，邮件，http请求，也可以输出到syslog中。本文的例子就是输出到syslog中。
至于syslog的配置，网上也有不少好的文章，这里就不说了当然这些logger等级时会在%(levelname)这个变量中出现，而一般的tail -f
最多只是输出他们，并不能主观地区分他们。所以需要另一个工具进行等级的划分和关键词的渲染（syntax
highlighting）。这里就严重推荐grcat这个小工具，能正则匹配，关键字各种格式化。

![日常例子一枚](/2012/12/2012-12-16-145748的屏幕截图-
610×214.png)

grcat的配置也十分简单，也有很多样例，网上可以搜到的。这里也不多说啦～讲错的地方，欢迎拍砖

« 上一页
1
…
5
6
7
8
9
下一页 »