使用复读机之前首先需要明确的不是软件使用方法，而是英语学习套路。

这个套路中跟读部分取自李笑来，听写部分取自张晓楠，最后我自己进行综合整理而成。

我使用的资料是老托福听力Part C，下载地址如下：

http://www.lixiaolai.com/index.php/downloads

因为其时间控制内容不是lrc的，自己写了个python脚本把里面的txt转换成了lrc文件，这样在复读机里面就可以使用了。

对待每一篇的动作是这样的：

首先是听写，具体要求如下。首先总听两三遍，把握全篇大意;然后每次听一句话，根据听到的信息可以用自己的话来重写这个句子，也可以直接用听到的词来写，遇到听不懂的就用声音标记来记录这个词，每句话大概听6,7遍就到极限了。遇到不认识的单词就记下来，一篇文章听写3,4遍基本上就全熟了。
个人说法比较简略，没看懂的见听力方法原文如下：

http://blog.sina.com.cn/s/blog_4fe4f4760100adg9.html

使用复读机进行听写，在设置中关掉连续播放，然后按一下上面的放大镜图标隐藏掉里面的英语原文就可以开始听写了。软件升级之后进行单句播放非常的方便，只要从第一句开始听，如果还需要再听就点下面的“重复上一句”按钮，如果这一句听的足够了就点“播放”按钮来播放下一句，这样就完全可以很方便的使用上述方法进行听写了。

听写进行完之后是跟读模仿。
和听写类似的方法，开始是跟读，即听一句，跟着读一句。读熟练之后可以听一句跟着背一句，彻底熟练之后就可以整篇背诵了。
跟读的细节见跟读方法原文：

http://www.lixiaolai.com/index.php/archives/4054.html

http://www.lixiaolai.com/index.php/archives/4055.html

这个过程中复读机软件的使用方法和听写的时候一样，以句子为单位的重复阅读。

整个过程可以练习听力（因为有精听，而且是整句理解能力），口语（跟读和背诵会让你习惯说英语），部分写作能力（听写的时候会去熟悉句子，如果你用自己的话来重复的话还有复述能力），阅读（也可以这么说把，因为这个过程中你会接触到很多的新单词，新句子，只不过不会去阅读太过复杂的句子）。整体来说是个全部能力综合提升的过程。

动态数组：
动态数组只写了三遍，发现一些问题总结如下。

设计的动态数组和之前的双向链表一样，也是浅拷贝的数据结构。

• 第一遍用malloc,free,memmove等函数来完成的(注：memcpy和memmove的区别是memcpy没有考虑内存重叠的情况)。
• 第二遍发现memmove的操作并不怎么直观，所移动的size每次都要写的比较长(sizeof(void *) * n)，于是实现了一个elem_move的函数，使用index进行移动。同时替换malloc和free所进行的内存扩展为realloc，在使用realloc的过程中没有仔细阅读realloc的函数原型，第一次使用时居然认为肯定原地扩展了，虽然运行起来没发现错误，还好被valgrind查出来了。在此严重推荐一下valgrind，检查内存泄漏的一个很不错的工具，帮我查出很多次错误了；
• 写第三遍是因为发现了浅拷贝的一个问题。如果get了其中一个elem然后set到不同的index下，那么原来在此index下的elem会发生内存泄漏，而被set过来的elem则会在销毁的时候被free两遍。为了改善这个这个问题，在数组内引入了reference count的概念。我在数组初始化的时候引入了ref_ch和ref_eq函数，调用者自己完成这些函数，并且在自己的数据结构里面加上reference count，根据自己的elem结构对reference count进行操作，并且在insert和set_by_index的时候进行reference count加一，elem_destroy的时候先减一，判断为0了再free。

最终结构是这样的：
数据部分：

struct _DArray{
	void **data;//用来存放动态数组的首指针
	size_t length;//数组当前长度
	size_t size;//数组目前的可用大小

	void *ctx;//进行free的上下文
	DArrayFreeFunc free;//自己的free函数
	DArrayVisitFunc ref_ch;//修改reference count的函数
	DArrayCmpFunc ref_eq;//判断reference count是否等于一个数的函数
};

内部方法：

//销毁一个元素，data为所要销毁的elem的指针。具体操作为调用
//ref_ch((void *)-1, data)减少其ref count，然后检查是否为0，
//是则free掉，否则只是减一
static void darray_elem_destroy(DArray *thiz, void *data)
static size_t darray_get_size(DArray *thiz)
static Ret darray_set_size(DArray *thiz, size_t size)
static Ret darray_set_length(DArray *thiz, size_t length)
//扩展当前数组，函数判断若inc+length>size了就扩展
static Ret darray_expand(DArray *thiz, int inc)
//收缩，若数组长度已减少到一半又少了rand()，则缩减数组尺寸为一半
static Ret darray_shrink(DArray *thiz)
//元素移动，用于中间的插入和删除。n为需要移动的元素个数。
static Ret darray_elem_move(DArray *thiz, size_t des_index, size_t src_index, size_t n)

外部方法：

//创建动态数组实例，返回此实例的指针，参数为该数组用的元素free函数，
DArray *darray_create(DArrayFreeFunc free,
		DArrayVisitFunc ref_ch,
		DArrayCmpFunc ref_eq,
		void *ctx);
//把data插入对应index，具体操作为调用expand(thiz, 1),elem_move, 设置值,
//ref_count++, set_length
Ret darray_insert(DArray *thiz, size_t index, void *data);
Ret darray_append(DArray *thiz, void *data);
Ret darray_prepend(DArray *thiz, void *data);
//删除某个元素，具体操作为elem_destroy, elem_move, set_length, shrink
Ret darray_delete(DArray *thiz, size_t index);
//把某个元素的内容设置为data
Ret darray_set_by_index(DArray *thiz, size_t index, void *data);
//获取某个index对应的元素，将其指针赋到data上
Ret darray_get_by_index(DArray *thiz, size_t index, void **data);

size_t darray_length(DArray *thiz);
Ret darray_foreach(DArray *thiz, DArrayVisitFunc visit, void *ctx);

//顺序调用elem_destroy， free掉所有元素，并把指针全部置为NULL
void darray_destroy(DArray *thiz);

在这个过程中同时折腾了好多的东西，感觉也很有意思。

• 关于malloc来的内存没有初始化，原因是这样的：我原来认为malloc和free是c用来提供内存和释放内存的函数，其实更准确的说它们是管理内存的函数，它所做的事就是管理内存。malloc是找到一块没有其他人使用的内存，free是把这块内存标记为没有使用，至于内存中的内容？抱歉，这两个函数是不管里面的内容的，free掉的内存中甚至还可能有内存控制块的信息。这样的话所谓的“未初始化”的内存含义就是可能有人用过，可能没有人用过，至于里面的内容，谁知道是什么，可能刚刚有人拿它来存整数，也可能存指针了，也可能真就是空的。（此处提一嘴，强烈推荐K&R的C程序设计语言，这本书中居然还有malloc和free的实现！）
• 关于struct，猜测内存对齐的原因及结构体访问的方式。新建一个struct实例的操作很简单，malloc一块空间，地址赋给struct类型的指针。就这么简单，这是怎么回事呢？从刚才的说法可以了解malloc来的内存其实是未初始化的，里面什么东西都有可能，那么我们调用其成员的时候系统是如何知道什么是它的成员呢？猜测：其实系统不知道，系统做的只是访问某块内存，对其读取或者写入，系统所了解到的“成员”只不过是这个“成员”相对于结构体指针地址的偏移量，为了方便管理和计算偏移，在编译的时候把它们的偏移量都统一确定了。（暂时不好查阅资料，内存对齐的话题看来要留到以后学习了）。

排序算法
这章中重新写了三个排序算法，冒泡，快速，归并。事实证明，我对这三个算法的熟悉程度并没有到“技能”的程度，平均一个算法写了一个半小时。这里将三个排序算法的关键点记录一下。

• 冒泡排序：我采取了改进的冒泡法，即每次冒泡都进行到上次交换过的最后一个。此方法主要有三个变量，一个遍历用的变量，一个记录单轮冒泡过程中做交换的元素的位置，一个用来记录已经有序有序的元素的位置（它等于上一轮最后那做交换的元素的位置）。
• 快速排序：主要思想是每轮都把一个元素放到最终位置上，并且保证比它大的和比它小的元素分开两边。这个算法有两个特殊情况需要处理，选取的标准元素是这一堆中的最小值，或者是其中的最大值，写条件的时候主意这两种情况外加不要越过左右边界，快速排序就不会有什么问题了。
• 归并排序：它主要是两个动作，首先是递归，然后是合并有序数据。递归出口是函数参数包含的数据段合并完成，初始递归出口是数据段内只有一个元素。每个数据段都是闭区间，所以不要把某个元素包含到两个数据段中去。用来遍历的变量i超过边界是没有问题的，只要超过之后不会再次被使用。

专业程序员最需要的是什么？是专业态度。

专业态度一：风格态度。良好的代码风格是严谨的一种表现，“傻瓜都能写出机器能读懂的代码，但只有专业程序员才能写出人能读懂的代码。”

稳定的代码风格：
文件名：单词小写，多个单词用下划线分隔。如：dlist.c
函数名：单词小写，多个单词用下划线分隔。如：node_find。一个函数只完成单一功能。一个函数最好在80*24的范围内完成，函数内的临时变量不要超过10个（此句来自linux kernel coding style）。
结构/枚举/联合名：下划线开头，首字母大写，多个单词连写。如：struct _DListNode;
宏名：单词大写，多个单词下划线分隔。如：#define MAX_PATH 260
变量名：单词小写，多个单词下划线分隔。如：DList *node = NULL(此处习惯*与node相连沿用于K&R C，表明*node是DList，这种写法有利于同时定义多个变量。)

面向对象的命名方式：
1.以对象为中心，采用主谓形式（对象+动作）来命名，取代传统的动宾形式，如：dlist_append
2.第一个参数为对象，并用thiz命名，如：dlist_append(DList *thiz, void *value)
3.对象有自己的声明周期，所以有对应的创建和销毁函数。

排版：
使用空行：1.函数体之间。2.结构/联合/枚举声明。3.不同功能的代码块之间。4.功能类似的代码放在一起，和其他部分用可能空行分隔。5.用一行就够了。
使用空格：1.等号两边。2.运算符两边。3.参数之间（for,函数等）
使用括号：
1.分隔子表达式，让人更容易看明白。如：((a && b) || (c && d))。
2.条件判断和循环，即使是一句也要加括号。如：

1
2
3
4
5

if (a > b) {
return c;
} else if (a == b) {
...
}

缩进：使用tab。缩进超过三层的话说明设计有问题

保护隐私：封装。可以隔离变化，降低复杂度。
隐藏数据结构：若为内部数据结构，则直接放在C文件中，不要放在头文件里。若为外部也要使用，则对外暴露名字而封装实现细节。做法为：
在头文件中声明该数据结构。
在C文件中定义该数据结构。
提供操作改数据结构的函数，避免直接访问其成员。
提供创建和销毁函数。
不过是否封装还是要看具体情况。
隐藏内部函数：在头文件中只放最少的接口函数声明，在C文件中所有内部函数都加上static关键字（将函数private化）。
禁用全局变量。

通用化
通用链表的实现方式有两种：
深拷贝，存值，以void *来保存数据首地址，size_t length来保存数据长度。进行深拷贝的时候使用memcpy。C语言没有构造函数，实现深拷贝比较复杂，且复制数据带来性能开销，不符合C语言的风格，较少见。
浅拷贝，存指针，只用void *保存对象的指针。存放整数时，可以把void *强制转换成整数使用。
（注：是否要进行深拷贝要根据实际情况来决定，在需要的时候，比如防火墙处理数据包，还是需要做深拷贝的。另外，据说公司前辈说自己实现的拷贝函数性能比memcpy好。）
让C++可以调用：在头文件中防止编译器对函数名重新编码，加入如下内容：

1
2
3
4
5
6
7

#ifdef __cplusplus
extern "C" {
#endif
/* add your code here */
#ifdef __cplusplus
}
#endif

通用链表面向特定数据的操作
面向特定数据的操作会很多，但是若将其一一实现的话会产生大量重复的代码。将遍历和对数据的操作分离开，使用函数指针将对数据的操作传入就是一个良好的实现框架，称为回调函数法。使用回调函数来进行数据操作的时候会产生一些中间数据，对此引入一个上下文context(缩写为ctx)的概念，用它来做参数负责传入传出数据和保存中间变量。框架如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

 //定义函数指针别名
typedef STAT (*DListVisitFunc)(void *ctx, void *data);
//实现遍历
STAT dlist_foreach(DList *thiz, DListVisitFunc visit, void *ctx)
{
/* some code */
stat = visit(ctx, some_data);
/* some code */
}
//实际回调函数
static STAT sum_cb(void *ctx, void *data)
{
/* some code */
}
//调用方法
long long sum = 0;
stat = dlist_foreach(pdlist, sum_cb, &sum);

面向特定数据的操作不应该杂糅到通用链表中，否则会造成不必要的耦合度和复杂度。

自己拿主意，反正只有一周，景点还是一个玩够了吧。九寨沟，青城，峨眉，还是九寨沟吧~虽然挺费时间的，毕业旅行，还是找个比较好玩的地方。

自助？跟团？熟人帮我联系了一个团，然后某人极力推荐我自助。反正没有自助过，好歹疯狂一下，联系一下自助吧~跟着攻略一路查找，结束之后发现也不难么。开始喜欢这种自助游了，玩的实在太high了~

首先预处理工作，同学推荐了天堂青年旅社（http://www.ttjzg.com/），这个青年旅社是九寨沟脚下满有名的一个。打电话询问过床位情况之后去成都的新南门客运站买票，买完车票后再给旅社打电话确认床位预定。

第一天，大早晨的跑去新南门客运站坐车，路太绕了，建议不停车的时候不要吃东西，太容易勾引出来想吐的感觉了。晚上7点左右到九寨沟，找到旅社入住，然后在旅社办理入住手续，沟内住宿手续，车票代购手续。下车的地方在九通宾馆，从绵阳过去的车好像并不路过天堂青年旅社，下车之后往上走吧，大约两公里，具体走法在他们网站上都有。懒得走的话打车也行，估计8块左右。值得一提的是下车的时候外面围了一圈各种各样的青年旅社来拉人入住的，挺住啊~

第二天，进沟。旅社跟我说8点多正好是旅行团大批进入的时候，既然我要在里面玩两天，就9点前进去就行。结果我8点半出发，打车5元到了景区门口，正好是旅行团高峰期。在服务中心拿了个宣传资料，然后拿学生证去买了学生票。进门的时候跟着大队旅行团进去的，结果连学生证都没查验（检票系统语音提示要检查学生证了）。由于根本没来过，路也不熟，反正有两天时间呢，先跟着旅行团溜达一下吧。于是进门之后跟着旅行团大队坐车到了树正。（从门口往上走的车有两种，一种是到树正，一种是到山顶，车前面写着到树正的是前一种，没写的是后一种。）在车上路过芦苇海，玉带河，双龙海，卧龙海。坐在车上看玉带河还是很有意思的，矮矮的芦苇之中一条宝蓝色的河道从中穿过，很是漂亮。到了树正之后下车，树正寨就在旁边，晚上就住这里了，进来之前还怕找不到地方。往左走是树正群海，下了石阶就是水磨坊。到了这里我才知道九寨沟原来是藏族的村寨。水磨坊全是人，往上走树正瀑布也全是人，继续走。老虎海和犀牛海还是不错的，毕竟人只能分布在一条线上，哈哈。在沿岸拍点风景，继续走到犀牛海坐车。这次坐车直接送到了顶部的长海，路上的上季节海和下季节海现在都处于干旱期，基本没有水。从长海往下走看过五彩池后坐车到中间的诺日朗服务中心，开始进食。值得一提的是这个服务中心有餐厅，里面的餐食价格基本都在50以上，门口还有卖方便面的，￥15一桶送一根香肠而且给泡好。我在吃东西的时候闻到各种各样的方便面味道，真是太诱惑人了。吃过东西之后继续坐车，这次直接到了另外一条沟的最高处原始森林。原始森林还是看过比较多的，这边的也没有太大特点，从原始森林的栈道上走一圈，然后下来走到芳草海和天鹅海。再往下走需要走的距离比较远，于是坐车到箭竹海，一路步行下来到五花海。走在栈道上突然下雨了，于是打着伞在栈道上继续向前，栈道有点湿滑，走的小心翼翼的。走到五花海的时候很幸运，由于下雨那里都没什么人，连租服装照相的都收摊了，于是看到了很漂亮的雨后初晴的五花海，哈哈~~看完之后觉得下雨走的很不爽，于是从五花海出去坐车，然后直达珍珠滩。下车后遇到两个导游，听说我一路走下来的，觉得我很厉害，哈哈哈哈。珍珠滩是西游记的外景地之一，是个斜坡式的瀑布，白色的水花确实很像珍珠。从珍珠滩一路走到镜海停车场，顺便看到了雨后的镜海。（后来我倒是觉得雨后的镜海是一点都不比早晨的镜海差。）继续坐车到诺日朗瀑布拍照后上车回树正休息。

一年前刚去过贵州，风景秀美，水也是清澈怡人。不过和九寨沟相比的话那里的水一般只是蓝和绿，而九寨沟的水看起来则是色彩斑斓，辅以水中生长的植物，非常的赏心悦目。车上的导游说九寨风景是晴看水，雾看山，半晴半雨看云烟，而来到九寨沟第一反应一般都是这里的水如何如何，这样就很容易忽略了山和云。绿树和青山未必独立成景，然而辅以云烟或者配上海子确是秀美绝伦。

第三天，继续。大早晨起来跑出去看静海。从树正出来沿着第一天的路过去，磨房，树正瀑布，老虎海犀牛海全部都没有人，而且早晨景色超好，太爽了，哈哈。不过路实在好远啊，大早晨的没吃饭实在懒得走，找到巡逻的补了个车票，然后坐车到了镜海。镜海确实应该是没有风的时候看才会比较好，一旦有风起了水波，倒影就完全混乱了。早晨镜海的倒影不错，但是因为没有阳光不如昨天看到的雨后镜海那么透亮。不过有一点晨雾还是挺有感觉的。坐车回树正吃早餐，吃完之后有了力气，打算用和昨天不一样的方式来玩九寨沟。于是。。。我选择了走，哈哈，反正路也熟悉了。于是坐车到珍珠滩，开始一路往上走了。从珍珠滩一路步行到箭竹海，开始的时候人还很少，偶尔碰到几个人也还是外国人比较多，走到后面是越走人越多，估计旅行团是上来了。这段基本以看为主，反正照片昨天都拍过了~有一点心得就是，往上走比往下走累好多啊。本来想坐车到天鹅海然后继续步行上去，但是发现车到那里并不停，于是只好在车上多看两眼了。坐车到了原始森林，毕竟昨天都看过了，这一段也不怎么出彩，于是到休息站进餐，所以我就在九寨沟最高点吃了一顿饭，哈哈。吃完东西之后想到这条沟我两遍都是走的，坐车的观景点都没看，反正下去也要坐车，顺便再看一遍吧。继续坐车把这条沟的下车点的观景点看了一遍。值得一提的是可以俯瞰五花海全貌的老虎嘴观景点由于修缮工作不能停车，于是错失了拍照的大好地点，只好在下车点的公路上拍了两张五花海的半景。到了珍珠滩之后觉得镜海到诺日朗那段栈道没有走过，于是从珍珠滩走到了诺日朗的停车点，中间栈道上又看到不少老外。坐车坐到犀牛海，这次改往下走，路上的芦苇海很漂亮，但是好像没有看到玉带河。走到一大半的时候觉得好累啊，但是怎么都走不到头。上车点明明就在公路另一边，就是没有可以横穿的栈道。走到盆景滩的时候终于可以过去坐车了，这时我是实在不想再走了。于是在盆景滩坐车到景区门口，结束了两天的沟内旅游。回到旅店，吃点东西跑去上网，遇到一个沈阳过来开会的美女，一边上网一边聊天，最后回去住的时候发现居然住同一个房间。。。当然同寝室还有4个新加坡人（一个男生三个女生）。

第四天，一大早起来打车到九通宾馆，坐车走人~路上的山很漂亮，山顶的云看着很壮观！不过比较煞风景的就是水坝了，路边的河好多干枯的地方，一到有水多的地方基本上就是有水坝在拦水了。

游记写的和流水账似的，将就看吧~

总结：现在的九寨沟其实地方不是很大，就算想用走的也能一天玩的不错。一个人旅游就是拍照麻烦。可以借鉴的关键事项：去之前头一天打电话订好旅店，去新南门客运站买好车票，找好怎么到旅社的路。到了旅社之后就要计划好主要事项了，玩几天，怎么住，怎么返程之类的。九通车站是头一天放票，旅社的人可以给代买票，收￥10手续费。我在里面玩两天，肯定不能出来买票，让他们代买还是很方便的。关于在里面玩，其实一天足够了，不过对我来说多一天是多一份安心，第一天怎么都不怕玩漏了，第二天路都熟了，就是放心的四处乱跑了。一天的行程可以大早7，8点钟买票进去，坐到山顶的车，然后镜海下车，看早晨的镜海，如果你有体力的话建议你从镜海步行上去，到箭竹海后坐车上行到顶端的原始森林，然后走下来到天鹅海，接着坐车看这条沟的停车观景点。这条沟是重点，不玩就白来了。然后如果有时间可以坐车去长海和五彩池，然后坐车下来到犀牛海往下走到盆景滩结束旅程。不过这样这条沟的停车观景点又会忽略掉，如果知道怎么停车的话就先用与停车反向的方式走栈道，然后坐车停观景点就完美了。虽然坐车的时候看到了，不过我还是觉得忽略了火花海，卧龙海这块地方的停车观景点，唯一的缺憾吧。

对于摄影最大的收获就是我会用光圈优先了，哈哈~~上次去集安学会的用曝光补偿，继续慢慢学习摄影知识中。

1.用glade3生成xml文件，然后在python中载入。运行之后没有窗口出现，按ctrl-c结束，停在gtk.main()那里。这是个什么问题呢？百思不得其解。。。直到我看到了这篇文章：http://tristram.squarespace.com/home/2008/5/26/glade-3-pygtk-and-beginning-python.html
原来是mainwindow的公共（common）选项卡下的可见（Visible）属性默认居然是否！！！这个问题真是太白痴了。。。

2.由于有个算法要一直运行，需要多线程，使用后发现一个问题。我点运行了，它不动，我点退出了，算法开始运行了。我晕死。期间使用了无数的测试方法，均没有发现问题所在。吴锡同学到最后说了一句，大概这个也是个初级问题。然后我google一下，发现了这篇文章：http://hi.baidu.com/jzinfo/blog/item/3f7dcc1b149088fbae51337e.html
原来需要在gtk.main()之前调用gtk.gdk.threads_init()这个函数否则gtk独占python解释器！！！果然还是个白痴问题。。。

在做这两个东西的时候对python有了一些初步的理解，python用起来真的很舒服。数据结构，函数方法等都能够让你写出简短易读的代码。做天气预报的时候出现的问题比较简单，因为信息处理都是自己做的，只有发送的时候使用飞信库，所有抓取的信息甚至都不用解码，在程序里处理后直接发送出去就行，需要注意的就只有程序里写的字符要使用unicode，发送前进行编码就行了。做RSS生成的时候使用了PyRSS2Gen库，最后写入文件是使用此类库的函数进行的，在认知上出了点偏差，发生了不少的错误，饱受折磨好几天。

简而言之，把握住以下几点，在python中进行信息处理的时候应该不会再遇到这么多的信息编码问题。
1.在取得信息的时候（从文件，网络中）尽快进行解码，在程序中使用被解码的信息进行处理，在信息被写出去的时候（写到文件，网络等）再进行编码。
2.关于编码和解码，概念一度被我理解的比较混乱。首先是这个：

>>> “a”.decode(‘ascii’)
u’a’
>>> u’a’.encode(‘ascii’)
‘a’

这个到底怎么理解呢？我一直认为unicode和ascii是一个类别的，类似raw data的那一种，现在发现不对。因为unicode只是规定了字符集，但是没有规定存储方式，所以只有unicode是类似于raw数据的，它离开存储方式无法生存，而ascii则字符集和存储方式都有，所以说unicode可以作为一种内部数据处理方式，但是不能用来存储。所以，u’a'是unicode字符串，它被ascii进行编码之后出现ascii编码下的a，而’a'也可以被解码为unicode的字符串u’a'。于是在处理数据的时候，其实ascii是应该和utf-8，gb2312这种编码处于一个类别里。由于历史原因，ascii不管在什么地方都会获得良好的支持，所以ascii的信息不经过任何编码解码处理都不会有什么问题，而网络上编码千变万化，比如在中文互联网中gb2312和utf-8就经常相互打架。总结一下，编码和解码的过程应该这样处理，如果是ascii编码，完全不用理会编码解码的问题，而如果是utf-8或者gb2312这种，在取到的时候应当对其进行解码，这样数据就变成了unicode字符串，它适合在程序内部进行处理，在需要对其进行输出的时候，把它进行编码，需要utf-8的就编码为utf-8，需要gb2312的就编码为gb2312。

在rss生成的时候遇到的UnicodeDecodeError的问题，最后确认是因为对某些数据提前进行了encode操作，而写操作的时候依然需要进行encode操作。在python中，已编码的字符串也有encode方法，其操作是按照默认的ascii编码进行解码操作，然后再进行encode[2]。已编码为utf-8的字符是无法被ascii编码进行解码操作的，于是这个过程中就是把编码过的数据当作未编码的数据，试图对其进行解码导致了错误。参考如下，取自第二篇：

Why do Python byte strings have an encode() method?

The sharp-eyed amongst you will have noticed that byte strings have an encode() method as well as a decode() method. What does this do? Quite simply, it does a decode-then-encode. The byte string is decoded to Unicode using the default (ascii) encoding, and is then encoded to the target encoding specified in the call to encode() using the appropriate encoding. As you’d expect, fun and games ensue if the original byte string isn’t actually encoded in ASCII at all.

最终总结：对于python2.5而言,字符类型就两种，str和unicode[3]，下图中左边是str，右边是unicode。
ascii—————–decode(‘ascii’)——-┐
utf-8—————–decode(‘utf-8′)——–┼—unicode
gb2312————decode(‘gb2312′)—┘

反之为encode操作。

参考：
1.python核心编程第二版
2.Python, Unicode and UnicodeDecodeError，地址在这里（英文，讲的很好）
3.Re: u’吴’和’吴’有什么区别？ ，地址在这里

第二十七章，因为相爱而分手。有没有搞错！女人的逻辑有时候就是这么的怪异而且看上去没有任何的问题。“恩， 我们俩一起经历了快乐的时光，享受了两个人相爱的幸福，到这里应该停止了，任何事情都一定逃脱不了现实的规律，我们的爱情达到了极限，如果我们继续相处接 下来就会有很多很多我们预想不到也逃避不了的不好的事情出现，然后慢慢地破坏我们之间的感情，我不想等到那一天的到来，也不想因为和你分开是因为我们不再 相爱。”因为相爱而分开？理解不了，即使它看上去多么的符合逻辑。“我 试过了，其实在选择来加拿大读书的时候，我就已经做好要和你分开的准备，原本我想借着遥远的距离，在我们的爱情最美丽的时候分开，可是我还是舍不得你，所 以我尝试着去继续我们的爱情，甚至试想着和你一起走入婚姻的殿堂，贪婪地去享受更多更多的幸福，可是越幸福我就越害怕，我害怕爱情没有的那一天，巨大的落 差我无法承受。”这个，难道是没有安全感？毫不犹豫地回答出“是”的时候，我就知道我又上了丫头的当，可是这次不是一个玩笑。我爱冉静，爱到可以为她做任何事情，所以我应该尊重她的决定，即使这个决定是如此的荒唐和难以承受。这 一次，他们两个都错了，冉静的因为相爱而离开其实是没有勇气面对未来的退缩行为。越幸福就越害怕？同样都是消逝的幸福，有比现在更不能接受的情况么？陆飞 也错了，其实两个人都深爱对方，而且深知对方一样深爱自己，陆飞在这种情况下选择了同意分手是因为爱而同意对方的决定，但是这个逻辑本身就是错误的。既然 知道互相之间的深爱，就应该明白这一个“是”不仅是难以接受，更重要的是这一个“是”直接辜负了两个人的心。你爱冉静么？如果爱的话是不是应该让她更幸福 而不是无论对错都同意她的决定？还是那句话，人能不能坚持一件事取决于背后支持他的逻辑，既然如此的深爱，为何找不到这个逻辑来支持你呢？小说看多了，就 会觉得这种分离是用到烂俗的桥段，经过这种经历的男女主角最终还是会和好并且修成正果，但是现实中完全不是这回事，破镜重圆？但是破镜永远不会重圆，因为 这种行为极大地损伤互相之间的感情和信任，它在心灵上留下的是一个巨大的伤疤。冉静错了，因为她的任性，陆飞也错了，他并没有努力的守护住他们的幸福。因 为这是小说，最后他们两个还能重归于好，如果在现实中，这绝对是将茂盛的爱情之树拦腰砍断的行为，两年后能重归于好的可能性微乎其微。你愿意为微乎其微的 可能性而做百分之百的努力么？

第三十七章～第四十五章，冉静归来到他们两个重归于好。看这段真是看的磨蹭死，中国传统的委婉就这样被发挥的淋漓尽致。两个人的各种暗示阿。。。说起来我 真的看不懂暗示，因为暗示可以让你想到这个，也可以想到那个，因为没有明确的表示，所以暗示的人有退路，但是被暗示的人很可能想不明白真正的意思到底是什 么。承认自己喜欢一个人会不会把自己的地位降低不在于承认这个动作，而在于这个动作所引发的心理反应。一般来说承认之后男生相当于身份暴露，心里想的全被 对方知道，被人握住把柄，而女生则可以“仗着”对方喜欢自己而有了底牌，从而处于优势地位。其实这个道理男女通用，所以有先承认的一方比较容易失败之类的 评论。但是如果跳出这个心理反应呢？我是喜欢你，但是我喜欢的是通情达理的你，如果你“仗着”我喜欢你，那么你就不是我所喜欢的那个人，我一样可以放弃 你，那么这种心态下的表白是不是可以无所畏惧呢？不过在故事中，男女主角并没有这种想法，他们互相“爱情角力”了好久，最后男主角受不了了，开门把话说明 白了，同时话里又暴露出了新的问题。“我 怎么知道你这两年都干什么了，一回来就看见你抱着个女孩，我气了好几天呢，我已经不怪你了，几天后还是回来了，可是你呢，问你有没有女朋友，你又说有，那 我怎么办啊，我已经很卑微地赖在这里了，你还欺负我。”“我欺负你，最后还不是我主动开口请求你留下来住的，你什么时候很卑微地赖在这里了，我有女朋友， 就凭你对我的了解，你听不出来是假的，你对我也太没信心了，反倒是你，两年期间交个男朋友，失恋了才想到回来。”这两个对话下的暴露问题 是，卑微，误会。人确实不可以爱别人超过爱自己太多，因为那样确实会导致自己爱的卑微，这样损伤了自己。也许有人会说我不在乎损伤自己，只在乎对方，那么 这样的爱同样会损伤对方。爱还是要平衡，这在第一部里男主角的理论为何完全没有起作用。。。卑微的爱有两种结果，一方卑微而另一方伤人，或者两人都卑微 （因为都不说出来而达到微妙的平衡）。先对自己好，才能对其他人好。如果一定认为太爱对方了，那么不妨借用Mindhacks上一篇博文，亲密关系中的冲突解决的结论，把两个人捆绑为利益共同体，这样就不会因为相爱而造成互相伤害。误会，毫无悬念，信任的大敌，爱情的杀手。关于应对措施，我只 想到了在真相不明时的信任+亲口确认，没有亲口确认就不要给事件定性，或者你认为自己能够承受如果那是误会所带来的所有恶果。

男人来自火星，女人来自金星。不得不说这个比喻很好，小说中穿插了一些以冉静的角度写的文字，虽然那些只是女人的千奇百怪的想法中的一种，但是明确的表达出了一些男人无法理解的思维。不要尝试着搞明白所有的想法，不那么重要的部分去包容就好。

篇 尾来自陆飞母亲的反对是非常合乎情理的。卑微和误解只是相处过程中的障碍，属于恋爱中问题，但是因为相爱而分手绝对是原则性错误。虽然我也很喜欢冉静这个 形象，但是人所做出的错误行为绝对是要自己承担后果的，任何人无法替代。错误越严重，要弥补的时候所需要付出的努力就越大。冉静在这个过程中的心态还是很 好的，不急不躁，对所有冷眼泰然处之。在这个过程中如果她表现出一丝的委屈，那么她获得陆飞母亲同意的可能性都会极大的降低。还有最后这段话，这才是我心中真正的爱，共同承担，而不是自己顶下所有的悲伤然后消失。

“你先听我说，我明白，我明白陆飞很爱你，正因为他爱你，所以他等了你两年的时间，在这两年的时间里，他表面上似乎一切都很好，但是我知道不是，他只是习惯将最难受的部分留给自己，不想去影响那些关心他的人。他没日没夜地工作，是为事业而努力，也是希望能将时间填补得更满，他依旧可以说说笑笑，是想让自己快乐，更是希望身边关心他的人快乐。他是我的儿子，作为母亲我可以感受到他的感受，你就当阿姨自私好了，我不希望我的儿子爱一个人远远超过爱他自己，我不认为那样他会幸福，尤其他爱的人不知道什么时候不知道什么理由就会离开他。”

“阿姨，我知道我之前的行为很不好，可是我现在明白了，我非常珍惜可以再一次和陆飞在一起的机会，我也希望你相信，我同样爱陆飞。”

“我没有资格说你不爱他，但是我不认为你可以像他爱你一样爱他。你们出车祸，他断了腿，伤了头，你却基本完好无损，他宁愿自己冒着生命危险，也要保住你安全，这让我更坚定了不允许你们俩在一起的诀心。起初我还担心我的反对会带来许多的麻烦，但是现在他失忆了，他不记得你了，所以我请求你体谅一个母亲的心情，离开他好吗？”陆飞妈妈说得没错，陆飞用所有的行动证明了他对我的爱，他无条件地支持我完成自己的理想。无条件地接受我分手的要求，无条件等候两年等待我的归来，甚至在车祸的一瞬间，他也将受撞击的那一面留给了他自己，而我没有能够以任何的行动证明我爱陆飞和陆飞爱我一样多。

“阿姨，我不能答应你这个要求。”可是我还是拒绝了陆飞妈妈的提议，因为我爱陆飞，所以我不会离开。

“你……”

“阿姨，我不是故意要惹你生气的，就像你说的一样，我已经离开过陆飞一次，绝不会有第二次，无论他变成什么样，即使他不记得我，我都会在他的身边，所以我不能答应你的要求。”

曾经我心中的爱情神话就这样出现了一个瑕疵，而且这个瑕疵是这么的显眼，罢了，也许神话只应该存在于目标中和心里。

首先，有很多人跟我说，你连女朋友都没有呢，想孩子的教育是不是太早了点阿。我觉得一点都不早，思考孩子的教育同时就是在总结自己的为人处事和反思自己的成长经历。

我是极其不放心把孩子扔给中国中小学教育的，这一点我几个好友基本达成共识了。总结一下的话，从传统上来说，教育是教书育人的过程，然而现在大部分的中国教 育只管教书，不管育人，学校里为了容易管理，老是想出来各种稀奇古怪而且磨灭孩子天性的方法。通俗一点说，就是学校和老师根本不管孩子的心灵成长。

如果不考虑行为的对错，人是不是能够坚定地执行某个行为取决于他自己是否认为自己的行为合理，而这一点很大程度上取决于他自己能不能找到一种自己认为合理的逻辑来支撑自己的行为。我家有一个我相当欣赏的小学生，他有 自己的思 维方式，能够自己独立思考，然后以相当高的分数考上了市里有名的重点初中。但是今年回去的时候，他也说，在他们中学里面，教育方式还是那一套。他们老师有 了孩子，才两岁，然后老师就拿管理自己孩子的方法来管理他们，对他们说课间时间不能越过楼梯，否则监视器里面我会看到，跟我小时候 相比除了多了个监视器以外没什么进步。在班里安插卧底这件事他的老师也在干。其实这件事要不是某一部电影我也不会反应这么强烈。上个学期看了闻香识女人，最后在礼堂上那段慷慨激昂的演讲让我一身冷 汗。我小时候虽然不是个标准的好学生，但是除了去打电动游戏以外没有什么出格的事，于是小时候我是个坚强的告密者，并且活在告密的“白色恐怖”中。当时的 思维很红很专，只要你做好自己的事，而且问心无愧，谁还去怕别人告密啊。但是看完这部电影，我才明白我错得有多么离谱，我们根本就是混淆了是非，然后用错误的逻辑来支撑错误的行为。坚守原则，不出卖同伴，这是非常难得的优良品质，看完后我为我小时候的行为感觉到深深的羞愧。

从这一点来反思中国的教育，我们 从小就是鼓励告密的。我没有告密告到现在，纯粹是因为上了初中之后我“学坏”了。也就是说，我小时候是用告密的逻辑来支撑自己的行为并且心安理得，但是我 直到研究生快毕业了才发现自己的逻辑是错的多么的离谱。另外这些纠正都是建立在我愿意思考人生的基础上的，不会思考的人很多，他们或许就会成为一辈子的告密者。小时候的是非其实记忆很深刻，如果我没有看到这部电影，并且我不愿意思考，不愿意去怀疑小时候的教育，那么我还是会告密下去。所以说如果一个人真的顺 从中国教育走到了最后，那么得到的很有可能是一个智商很高，但是情商很低的人，他不能独立思考，没有自己的人格。确实，这样的人很容易被政府管理，但是他 没有了人的灵魂，所有情况的处理都 是父母学校教的，离开了这些就不会思考，同时没有自己形成的原则。

这个例子只是管中窥豹，在中国的教育中这种为了方便管理而想出来的磨灭孩子未来可能性的方法还多的是。所以，关于这些原则家长必须早教育，因为你不教育，就会有别人或者别的事去教育。我的家长也不是这种观念，我的老师们也没有持这种观念 的，我为什么能形成这些呢？就是因为我看的东西。所以从家长的角度来说，他们掌控不了我的发展，同时由于没有足够的心灵上的沟通，他们也掌握不了我的心里 到底在想什么。同时，我看的东西也许是我决定的，也许是随机的，不过你能放心让孩子随机的发展么？显然没有一个家长会愿意，但是绝大多数的家长意识不到这样会 导致孩子的发展是随机的，例如用我妈的话说，这些东西你“慢慢就会知道了”。是的，还好我慢慢的随机的学到了这些，没有随机的跟着小时候的一些不好的习惯越走越远。

记得曾经有个电视节目里面出现过一个台湾的老师，她教育出来的孩 子在和别人对话的时候说了这么一句。别人说，咱们下午去玩吧，她的孩子说，不要，我和我爸爸有个约会，然后别人说，你真可怜，居然和你爸爸有个约会，她的孩子说，你才可怜呢，你和你爸爸没有约会。这段对话我非常的喜欢，它反映出不仅这个家庭沟通良好，而且孩子有自己的思考，他可以用一个极其温馨的逻辑来支 撑自己的行为。

国内不是没有好老师，但是完全靠运气，我有个同学就遇到了一个好老师，我十分的羡慕他。我认为一个老师能被评价为好老师，首先它要从心里去爱护 自己的学生，注重孩子心灵的成长，而不是纠缠于丢个钢笔的事儿去冤枉别人。从小就不公正，而是人云亦云，被小孩子看在眼里，所造成的后果最少会一直影响直 到有独立思维能力。然而什么时候会有独立思维能力呢？其实我看到很多成年人一样没有。。。
协助论证文章一篇：<中国孩子>http://www.dapenti.com/blog/more.asp?name=xilei&id=27864
这是个逆境成才的例子，如果让我选择的话我不愿意选择让孩子这样成才。其实是不是成才也没有关系，重要的是孩子要生活得幸福快乐。

尾注：对于无理取闹的，赠送一句话。你有孩子吗？如果你有孩子，或今后将要有孩子，我想你能够理解一个未来总会成为家长的人对因学校的错误教育而对孩子产生终生影响的担忧和关切。

python的变量名和以前接触过的c/c++等完全不一样。c/c++的变量名的思想应该是这样，分配之后变量名就永远的关联到了编译器分配到的内存，任何对此变量名进行的操作都最终落实在对这段内存的操作上。

python中的变量名更像lisp的感觉，内存和变量名的关系并不是永远“绑定”的，这个变量名更像是一个指针，它指向了那个“变量”。

拿最简单的a=1来做例子。在c/c++中，=的意义是赋值，它对应的操作是把1赋值到a所指向的内存中。1这个表示在c/c++中是一个int型整数，存到a对应内存的是int型的整数1。为什么不同类型的赋值会出错？因为那个变量所指向的是一段可存储被赋值类型的内存空间，无法保证这个不同的类型在那段内存不出现问题。（由此引出的类型转换暂不考虑）如果再用b=a，则是将a的内容复制到b中去。在python中，=的意义虽然也是赋值，但是它做的完全不是这样的操作。根据python的声明，一切都是对象（变量名是不是还没有体会到），那么这个1也是对象，a=1就是将a指向1这个对象，而再用b=a则是将b指向a所指向的内容。那既然a和b都指向同一个地方，为什么修改了a之后b不变呢？举例，执行a=2，再看b的话你会发现还是1。其实这个还是惯性思维的原因。a=2实际上执行的操作是将a指向2这个对象，而不是将a所指向的内存改为2，所以a指向了2，而b还是指向1。可以体现这一点的比较容易的方法是用字符串。如果你用下标改了字符串的内容，两个“变量”都会变。

所以在python中，变量名不如叫名字（name）更为贴切，而在这种机制下，名字空间就显得尤为重要。

注：此文没有经过c/c++编译器及python解释器的证明，如有错误请指出，多谢

1. 二分搜索：将线性搜索的O(n)时间降到O(log2n) ，要求单调
   1. 看这句话似乎很平凡无奇，但是这句话确实是二分搜索适用范围的精确表达，关键在于线性搜索四个字。你明确知道什么样的是线性搜索么？我不敢说我很明确，但是在这里我把它总结为在线性解空间里寻找解。曾经有人给我讲过二分枚举法，一个奇形怪状的容器，问水面多高的时候水是总容积的一半。这就是个线性有序的解空间，可以进行二分搜索。如果你可以求得高与体积的关系式，那么直接根据一半体积求高的做法就更像是hash查找。
   2. 二分搜索的核心问题：1.有序2.有个比较“大小”的方法来将解空间每次减半（定义一个范围，在该范围内表示元素的方式，确定哪一半范围存在缺失整数的方法）
   3. A问题，有一个连续的文件里面有40亿个32位整数，找出至少一个不在这个文件里的32位整数。朴素的二分思想，每次找出存在缺失整数的那一堆。
2. 向量旋转：问题B：用几十个字节的额外空间将一个n元向量x在正比于n的时间内左旋i个位置。对应于实际问题中交换相邻的不同大小的内存块。
   可用方法：
   1. “杂技”算法。以“元素”为单位（元素不仅可以为数组元素，还可以为一切旋转单位），循环移动该向量中的元素，若元素个数为n，移动距离为d，那么需要移动n与d的最大公约数趟。
   2. 等大小内存块移动法。目的：ab->ba，假设b比a长，那么取b后面的与a等长的一段br，与a交换。于是效果就是ablbr->brbla，a已经到了最终位置，剩下的目标就是交换bl和br。递归操作。
   3. 求逆法。(a’b')’＝ba
      reverse(0, i-1);     //abcdefgh->cbadefgh
      reverse(i-1, n);     //cbadefgh->cbahgfed
      reverse(0, n);       //cbahgfed->defghabc

   直观上比较，杂技算法对每个元素仅存取一次，而求逆要两次，那么杂技算法算法的速度要两倍于求逆。实际上当n比较大而旋转距离变长的时候，由于杂技算法的高速缓存性能比较差，而求逆大部分操作为顺序读取，由于缓存局部性的影响，杂技算法的实际表现并不如求逆算法。

3. 标识：当使用等价关系来定义类别时，定义一种标识，使得类中每一项都具有相同的标识，而该类以外的其他项没有，这样就可以将一个感觉无从下手的问题变成一个用已知数据结构和算法解决的问题。（ps：后续还可以根据标识进行排序，二分等等操作）
   问题C，挑选出一个词典中所有的变位词，就是如deposit和topside这样关系的词。如果要考虑单词字母的所有排列，那是注定要失败的方法。因为算法复杂度实在太大了。注意描述，deposit和topside是一类，他们是变位词，也就是说他们存在着某种等价关系。只要给所有变位词定义上同样的标识，然后将其按照标识排序，这个问题就变成了一个很容易下手的问题。

后记：本章主题是寻找合适的算法，绝对不要有了想法就急不可耐的去实现，就是要找到自己的灵机一动，用巧妙的方法来实现，要“建设性的懒惰”。

c语言宏处理器（出自C程序设计语言）

“这段代码很典型，可以在宏处理器或编译器的符号表管理例程中找到。”

例如考虑define语句。

#define IN 1

需要把名字IN和替换文本1存入到某个表中，此后当名字IN出现在某些语句中时，就必须用1来替换IN。

以下两个函数用来处理名字和替换文本。install(s, t)函数将名字s和替换文本t记录到某个表中，其中s和他仅仅是字符串。lookup(s)函数在表中查找s，若找到，则返回指向该处的指针；若没找到，返回NULL。

该算法采用的是散列查找方法，将输入的名字转换为一个小的非负整数，该整数随后将作为一个指针数组的下标。数组的每个元素指向某个链表的表头，链表中的各个块用于描述具有该散列值的名字。如果没有名字散列到该值，则数组元素值为NULL。

链表块结构：

struct nlist {                /*链表项*/

struct nlist *next;    /*链表中下一表项*/

char *name;            /*定义的名字*/

char *defn;            /*替换文本*/

}

指针数组：

#define HASHSIZE 101

static struct nlist *hashtab[HASHSIZE];    /*指针表*/

散列函数hash，通过for循环将上次计算的结果值变换（乘以31）得到的值加上当前字符值（*s + 31 * hashval），然后对数组长度取模。这并不是最好的散列函数，但比较简短有效。

unsigned hash(char *s)

{

unsigned hashval;

for (hashval = 0; *s  != ”; s++)

hashval = *s + 31 * hashval;

return hashval % HASHSIZE;

}

strdup函数将通过参数传入的字符串复制到某个安全的位置

char *strdup(char *s)

{

char *p;

p = (char *) malloc(strlen(s) + 1);

if (p != NULL)

strcpy(p, s);

return p;

}

lookup函数发现表项存在，则返回指向该表项的指针，否则返回NULL。散列过程生成了在数组hashtab中执行查找的起始下标，若该字符串可以找到，则它一定位于该起始下标指向的链表的某个块中。

struct nlist *lookup(char *s)

{

struct nlist *np;

for (np = hashtab[hash(s)]; np != NULL; np = np-> next)

if (strcmp(s, np->name == 0))

return np;    /*found*/

return NULL;        /*not found*/

}

install函数借助lookup判断待加入的名字是否已经存在。若存在则用新的定义取而代之；否则创建新表项。若无足够空间创建新表项，则install函数返回NULL

struct nlist *lookup(char *);

char *strdup(char *);

struct nlist *install(char *name, char *defn)

{

struct nlist *np;

unsigned hashval;

if ((np = lookup(name)) == NULL){    /*not found*/

np = (struct nlist *) malloc(sizeof(*np));

if (np == NULL || (np->name = strdup(name)) == NULL)

return NULL;

hashval = hash（name）;

np->next = hashtab[hashval];

hashtab[hashval] = np;

} else                                 /*already exist*/

free((void *) np->defn);    /*free previous defn*/

if ((np->defn = strdup(defn)) == NULL)

return NULL;

return np;

}

三点疑问：

1.hash函数如何选的？

2.hashsize如何选定？

3.作为宏处理器，又用了宏定义？

Python字典类（代码之美 第18章）

为小哈希表而做的特别优化

模块化原则：模块间通过应用程序编程接口（API）──一组严密，定义良好的程序调用和数据结构来通信。

API标准：若试着用纯人类语言来描述设计（不摘录源代码），能否将事情说清楚？在编码前为API编写一段非正式书面描述是个好习惯。一些最有能力的开发者，一开始总是在定义接口，然后编写简要注释，对其进行描述，最后才编写代码──因为编写注释的过程就阐明了代码必须达到的目的，这种描述能够帮助组织思路，本身就是十分有用的模块说明。P85（编写简要注释这个习惯半年了还没有养成）

Hatton的经验数据表明，最佳模块长度为200~400逻辑行，大概400~800物理行。P87

紧凑性：若有经验的用户不需要操作手册，那么着个设计满足紧凑性。评测API的经验：若编程者要记忆的条目大于七，则不大可能算是严格紧凑的。合理对待紧凑性，设计中尽量考虑，绝不随意抛弃。（七，人类短期记忆的极限）

正交性：每一个动作（无论是API调用，宏调用，还是语言运算）只改变一件事，不会影响其它。无论控制什么系统，改变一个属性的方法有且只有一个。

重构：改变代码的结构和组织，而不改变其外在行为，目的在于提高正交性。

SPOT：真理的单点性（Single Point of Truth）。不要重复自身。任何一个知识点在系统内部都应有一个唯一，明确，权威的表述。数据结构中也存在类似原则，“无垃圾，无混淆”。无垃圾是指数据结构（模型）应该最小化，无混淆是指在真实世界中绝对明确清晰的状态在模型中也应该同样明确清晰。（不要重复自身这条基本在每本编程方法的书里都有）

自顶向下和自底向上：考量差异的方法。问一下设计是围绕主事件循环（常常具备与其非常接近的高级应用逻辑）组织，还是围绕主循环可能调用的所有操作的服务库组织代码。P95

模块化编码需要考虑的问题：

• 有多少全局变量？全局变量是模块化的毒药，很容易使各模块轻率、混乱地互相泄露信息。
• 模块大小是否在最佳范围？多了会产生长期的维护问题。若不知自己的最佳范围，则最好保守，坚持下限。
• 模块内的单个函数是否太大？内部不要太复杂。
• 代码是否有内部API？即可作为单元向其它人描述的函数调用集和数据结构集。且每个单元都封装了某一个层次的函数，不受其它代码影响。
• API的入口点是否超过七个？哪个类有七个以上的方法？数据结构成员是否超过七个？
• 每个模块的入口点数量如何分布？是否不均？有很多入口点的模块真的需要那么多入口点么？模块的复杂性往往和入口点数量的平房成正比。

By Doug Mcllorg：

1. 让每个程序就做好一件事，有新任务就重新开始，不要往原程序中加入新功能而搞的复杂。
2. 假定每个程序的输出都会成为另一个程序的输入，哪怕那个程序还是未知的，输出中不要有无关信息干扰。避免使用严格的分栏格式和二进制格式输入。不要坚持使用交互式输入。
3. 尽可能早的将设计和编译的软件投入试用，哪怕是操作系统。理想状况应该是几个星期内。对拙劣的代码别犹豫，扔掉重写。
4. 优先使用工具而不是拙劣的帮助来减轻编程任务的负担。

重点：一个程序只做一件事，并做好，程序要能协作，程序要能处理文本流。

By Rob Pike：

1. 程序耗费运行时间的地方无法判定，瓶颈经常出现在想不到的地方。证实瓶颈之前切勿急于找地方改代码。
2. 估量：没有估量代码，尤其未找到最耗时的部分前不要去优化速度。
3. 花哨算法在n很小的时候通常很慢，而n通常很小。花哨算法的常数复杂度很大，除非n一直很大，否则不要用。（拿不准就穷举）
4. 花哨算法比简单算法更容易出现bug，难以实现。尽量简单算法配合简单数据结构。
5. 数据压倒一切。编程的核心是数据结构，而不是算法。

Unix系统的十七个原则

1. 模块原则：使用简单的结构拼合简单的部件。
2. 清晰原则：清晰胜于机巧。优雅清晰的代码不仅不容易崩溃，而且更易于让后来的修改者立刻理解。
3. 组合原则：设计时考虑拼接组合，互相通信。
4. 分离原则：策略同机制分离，接口同引擎分离。如：前端策略，后端机制，设计分层。
5. 简洁原则：设计要简洁，复杂度能低则低。
6. 吝啬原则：除非确无他法，不要编写庞大的程序。（体积大复杂度高）
7. 透明性原则：设计要可见，以便审查和调试。
8. 健壮原则：健壮源于透明与简洁。（避免在代码中出现特例）
9. 表示原则：把知识叠入数据以求逻辑质朴而健壮。（在设计中应主动将代码的复杂度转移到数据中去）
10. 通俗原则：接口设计避免标新立异。
11. 缄默原则：如果一个程序没什么好说的，就保持沉默。
12. 补救原则：出现异常时马上退出并给出足量错误信息。宁为玉碎，不为瓦全。
13. 经济原则：宁花程序一分，不花程序员一秒。（人少花时间，交给机器）
14. 生成原则：避免手工hack，尽量编写程序去生成程序。如makefile生成器。
15. 优化原则：雕琢前先得有原型，跑之前先学会走。（先制作原型系统，再精雕细琢，优化前先确保能用。 | 先求运行，再求正确，最后求快。）
16. 多样原则：绝不相信所谓“不二法门”的断言。
17. 扩展原则：设计着眼未来，未来总比预想快。

应用实例：

• 只要可行，一切都应该作成与来源和目的无关的过滤器。
• 数据应尽可能文本化。
• 数据库部署和应用协议应尽可能文本化。
• 复杂的前端（用户界面）和后端应该泾渭分明。
• 如果有可能，用c语言编写前先用解释性语言搭建原型。
• 当且仅当只用一门语言编程会提高程序复杂度时，混合语言编程比单一语言编程来的好。
• 宽收严发。
• 过滤时，不需要丢弃的信息决不丢。
• 小就是美，在确保完成任务的基础上，程序的功能尽可能少。

在好友那里看到了一段视频(点击这里)，说的是如何用意念来改变自己的生活。说的很神道，像宗教似的，但是其中的道理却是存在的。

这段视频里将这个秘密叫做吸引力定律，说只要你不停的想，你想的东西就会被吸引到现实中来。这个定律作用范围很广，而且不会区分否定词，如果你一直想不要什么，那么你不想要的这个东西也会被吸引到现实中来。同学将其称为主观唯心主义。

其实这些都可以得到科学的解释。这个“不停的想”所发生作用的途径并不是在视频里所出现的什么宇宙，特殊频率，而是你自己。

首先是自信和催眠，就是这个“不停的想”。自信是一个很强大的心理武器，用好它的话可以由内而外的狠狠地改变你的气质和精神面貌，但是自信有足和不足的量化水准。自我催眠是一个可控的增强自信的方法。所谓“不停的想”就是以自我催眠的方式来增加自信。虽然说自我催眠的效果也会受个体状态而受到影响，但是铺天盖地的自我催眠能起到作用的概率还是很大的。在自我催眠的过程中，自信会影响自己的做事态度，方式及完成程度，而这些又会反过来增强自信，顺利的话它们会形成正向循环反馈，从而形成强大的自信。当然这些也不是凭空就能出来。自信需要一个强大的支撑点，你需要很明白你为了什么而自信，有了坚实的地基才会有稳定的上层建筑。其次，这个过程远没有说的这么简单容易，它需要有足够的精力和毅力来支撑整个过程，成功之后还要有巩固过程来使它不容易退回去。自信有那种“自愈”的特点，短期的改变会被“自愈”到原来的水平。所以如果半途而废的话，效果就会差很多，就像盖了一半的楼崩掉一大截一样。

精力和个人有关，增强恐怕要积累，但是毅力的作用和可控程度似乎比精力容易。所谓毅力和坚信有关，视频中告诉你，如果失败了也不要放弃，不要灰心，还是要继续相信这个方法。这个方法有着比较浓的宗教色彩。其实坚信也是一个很强的心理武器，关键在于你能不能拿的动。如果每对夫妻都互相坚信对方是爱自己的，那么除了故意出轨的和性格不合以外，其余绝大部分都可以幸福的生活下去。坚信的关键在于没有猜疑，没有杂念，满心只有相信你所相信的东西，其余的一点都容不进来。它的作用是可以使在于成功和失败之间的事的成功率大大增加。说的通俗一点也不难懂，在同等能力情况下，坚信自己能成功的比抱着试试看心情的成功率肯定高。

心情影响生活。那个半杯水的例子很明显，但是不深入。乐观主义说我还有半杯水，他的注意力放在半杯水上，他会围绕半杯水而努力。悲观主义说我没了半杯水，他的注意力放在空杯子上，他更可能去叹息失去的东西和伤心难过。这个就是视频中所谓的“不区分否定词”起作用的原因。情绪短期来看不会影响自信，但是会影响坚信。情绪低落会很影响你做事的态度，从而极大的影响完成程度。如果长期存在情绪低落的话会通过事情的完成程度反过来影响自信。

感恩的心。不是说肯定能成功，而是大概率成功，小概率事件一样会出现。要怀有感恩的心，感谢该感谢的人，事。就算是在成功的事件中也不会完全是自己的努力，怀有感激会让你下次再成功的概率增加。就算是失败了，也要感谢下为你作出努力的人。人生活在世界上本来不需要很多，能得到就很不错了，降低心里预期，对得到的心存感恩，过段时间你可能会发现无论主观上还是客观上你得到的都会比以前多。

行动！！！以上所有东西都是辅助性的，他们都要通过行动才能最终对生活进行影响。如果你开始迷信上面那些东西而把行动忽略了，我只能说你捡了芝麻丢了西瓜。就和那个健康和财富的关系一样，行动是1，其他是0，有了1，0越多越好，没有1，0什么都不是。
注：以上道理大多知易行难，也许这就是那段视频选择宗教的方式来做这个节目的原因。宗教可以鼓动人们以极大的热情投入它所宣扬的东西中，但是对知情的人却没什么作用。

注2：本人非心理学专业，所知心理学内容也多为普及性知识，如有错误请指出，万分感谢。若要转载请注明出处。

0.妙探寻凶是一个好玩的桌面游戏，由于目前玩的次数较少，还处在初级的推理及运气阶段。说是推理其实就是排除法。如何有效利用场上信息来进行排除就成了一个很重要的问题。

1.首先，是如何利用场上言论进行排除。分以下情况：
1.1.自己提出假设，下家给自己看一张牌，那么此张牌被否定，这个过程中有什么信息呢？首先，此张牌不可能是凶案牌，然后给下家被确定一张牌，未知牌减一，最后其他人未知牌减一。
1.2.有人提出假设，过了一个人，什么都没有，这个过程中的信息就是这个人没有这三张牌。
1.3.有人提出假设，另外一个人给他看了。这表明出牌的人有三张之一，如果你确定了其他的牌，那么你就可以确定出牌的人有什么牌了。
基本情况就这三种，剩下的就是如何记录和如何提问了。

2.笔记。
首先打格子，竖排是凶器，嫌疑人和地点，横排是玩家。拿到牌之后，首先在自己的列钩上自己有的牌，然后在其他牌的格子里画叉，自己手牌的行画叉和划去均可(update:这样做笔记的话其实自己那一列没必要，还能节省格子，减少冗余信息)

然后游戏开始，在表格下面再进行发言及看牌记录，可按行记录，一行是一个人的发言，未能走到的情况下空下。记录内容为发言三要素及给他看牌的人，可简记。
如：
A：绿温钳C  蓝饭烛B
B：红图刀A
C：白台枪B  绿书铅A
这样发言顺序和发言内容及看牌记录全部都有，目前没发现这样记会有遗漏信息的情况。如果一条信息里左右可以用的信息都已经反应到了表里，那么这条信息可以划掉，以方便后续处理那些不确定的信息。如：绿温钳C

3.接着是这些信息的处理。
3.1遇到情况1，在相应的格子里画钩，此行其余格子全部划掉。然后此条记录也可以划掉，因为没有更多可用信息了。
3.2遇到情况2，在对应的格子里划叉，表示这个人没有这三样东西。
3.3遇到情况3是最复杂的
3.3.1如果已经确定了这三张牌都不确定，那么这条记录只能先放着；
3.3.2如果确定了这三张牌中的一张不在出牌者手里，我习惯把这条记录划掉，然后在表中剩余两张牌的位置做上记号，如写两个1，再出现这种情况写两个2，它们之间不能混淆。一定注意的是如果两个这种情况有了相交部分的话只要在未推断出的牌数允许的范围内什么可能都会出现的，不要贸然猜测；
3.3.3如果确定这三张牌中的两张不在出牌者手里，那么很好，剩下那张就是这个人的手牌，可以给这张牌画钩，然后这张牌横向划掉，这条记录也可以划掉。注意在游戏进行中可以随时回去处理那些先放着的记录，这才是记录发言的最大价值所在。
ps：如果一个人的牌已经全部推断出来，那表中他其他位置未知的牌全部可以画叉了。

最后，我们要找的是那些全是叉的牌，不要看到一行有n-1个叉（人数为n）就在剩下那个地方画勾。

注：完全原创方法，可能有漏洞，欢迎讨论~

替换：
命令格式：地址范围s/匹配模式/替换字符/选项
/为分界符，可以用别的字符。s后的第一个字符会被识别为分隔符，要求不能是空格或制表符，且能将三段内容分开。
地址范围：数字或模式，如 1 1,4 /A/ /A/,/E/
匹配模式：可用基本元字符，另外可以用( )
替换字符：可写正常文字，也可有特殊字符：
&：代表匹配模式中正则表达式配的字符串。例：s/ab/&cd/
\n：与模式中第n（数字）个\( \)制定的字符串匹配。有点类似子式
\：转义替换特殊字符，如&，\，替换命令的分界符
选项：n：指定第n次出现时替换。（1~512）
g：所有目标均替换。
p：输出模式空间的内容。
w：写模式空间的内容。

删除： 地址范围d 整行删除
附加： 定位地址a\
文本 在定位到的行下面加一行，内容为命令中的文本
插入： 定位地址i\
文本 在定位到的行上面加一行，内容为命令中的文本
变换： 定位地址c\
文本 把定位到的行整行替换掉
*插入和附加不可与地址范围同用，交换可以

sed控制步骤：
1.预处理步骤。将下一行读入模式空间。
2.处理步骤。在模式空间中直接处理所有命令。
3.后处理步骤。输出模式空间并返回第一步骤。
*.删除命令出现后立刻停止处理步骤，并且跳过后处理步骤。
**.插入，附加，变换均为后处理步骤操作。变换先删除模式空间，然后返回后处理模式。

列表： l 前面也可加地址范围，一般用法是用-n参数禁止缺省输出再用 它来处理想要输出的部分。另外它会将不可打印字符输出。
输出： p 同列表命令相似，区别大概是不输出不可打印字符。
= 输出行号，不过在对应行的上一行（？）
转换： 行地址y/abc/ABC/ 将每一个a变为A，b变为B…对应位替换。
下一命令： 行地址n 向模式空间读入下一行，直接转入后处理步骤。
读入文件： 行地址r 文件
写文件： 行地址w 文件

多行下一行： N 将输入文件的下一行附加到模式空间的当前行之后，两端内容
间用换行符\n分开，可配合s将换行替换为空格。
多行删除： D 删除内容只第一个换行符（然后直接转到后处理步骤）
多行打印： P 输出模式空间至第一个换行符

驻留空间：除模式空间外的另一块临时空间。
驻留： 行地址h 将匹配的行覆盖驻留空间内的内容
H 附加到驻留空间，并加入换行符
获取： 行地址g 用驻留空间内容覆盖模式空间的内容
G 将驻留空间的内容附加到模式空间后面，并用换行符分隔
交换： 行地址x 交换驻留空间与模式空间的内容

附：ibm的sed教程（比我的详细很多）
http://www.ibm.com/developerworks/cn/linux/shell/sed/sed-2/index.html

对知识的渴求造就了我第二段的学习热情高涨。现在我几乎每天都会去学习，但是平心而论，却会比第一段学习热情高涨（出生～小学毕业）的效率低不少。潜力还有很多，但是不知道怎么去挖掘，这让我对自己非常的不满。虽然我知道这样会影响自信，但是却没有办法停下来。也许因为《编程之道》，也许因为《Unix编程艺术》，现在看专业有了一个完全不同的眼界。这学期开始的时候还在看c++ primer，但是一段时间之后放弃了。高级语言各得其道，不可能一种语言通吃天下。看到这个之后，就此跳出了语言的束缚，开始往更深的地方望去。关于语言现在选择了两个极端，c和Python，然后以此开始了在计算机世界的求道之旅。自己总结了一下，现在有三条出路可以走，这条录是最想走的，而且是最困难的。现在的感叹就是时间太少了，效率又不够高，自己买的书都来不及看。什么时候才能有梦寐以求的如宝剑一般犀利的思维呢。。。

这半年，我意识到了自信的力量，意识到了人皆可以有自己的自信，然后以此迸发出奇妙的魅力。那么我的“隐”法处世也要做一些修正了。这半年，感情依然没有进展，依然不会与女生相处，依然会把相处的还不错的女生丢了。若是以前，这条根本不会写进来。但是已经理智到这种程度的我，第一次有了找女友的冲动。最好的朋友之二订婚了，似乎前不久还在和他们一块打闹玩耍。他们订婚的刺激程度比听说100个同龄人订婚都强烈。不过话说回来，这个不是计划可以控制的。。。先消化一下这种冲动吧。

[user]
13*********
[pass]
passwd
[city]
54161               长春
[to]
FetionId_1        自己
FetionId_2        nick
…..

[city]
59493           深圳
[to]
FetionId_1        nick

这个数据结构看起来很清晰，但是写起代码来判断比较多，最终awk脚本大概50多行代码。扫了一下unix编程艺术之后，参考.netrc做了如下改进：

第二版文本格式：

user    13*********
pass    passwd
city    54161           长春
to      FetionId_1        nick
to      FetionId_2        nick
…..
send    Yes

city    59493           深圳
to      FetionId_1        nick
…..
send    Yes

使用这个格式进行编码，awk脚本用了30行多点，代码如下

#!/usr/bin/awk -f
BEGIN{
SmsPath = “/home/conan/bin/weather/”
}
#支持注释
{
if (substr($1,1,1) == “#”)
next
}
#跳过空行
NF < 2{ next }
#设置用户名密码等信息
$1 != “to”{
Data[$1] = $2
}
#格式化群发列表
$1 == “to”{
if (Data["to"] == 0 )
Data["to"] = $2
else
Data["to"] = Data["to"] “,” $2
}
#获取天气并发送
Data["send"] == “Yes”{
Data["send"] = “No”
system(“wget -qnv -O ” Data["city"] ” http://wap.weather.com.cn/wap/” Data["city"] “/h24/”)
system(“sed -i -n ’15,31p’ ” Data["city"])
system(“sed -i ‘s/<[^<]*>//g’ ” Data["city"])
system(“sed -i /^$/d ” Data["city"])
#下面一行可以加上你要的内容
system(“sed -i ’1 i\**气象台为你预报’ ” Data["city"])
system(“sed -i ‘:a;N;s/\\n/ /g;ta’ ” Data["city"])
print (SmsPath “sendsms -vl -f ” Data["user"] ” -p ” Data["pass"] ” -t ” Data["to"] ” \”`cat ” Data["city"] “`\”")
system (“sleep 1″)
system (SmsPath “sendsms -vl -f ” Data["user"] ” -p ” Data["pass"] ” -t ” Data["to"] ” \”`cat ” Data["city"] “`\”")
print “——————–”
delete Data["to"]
delete Data["city"]
}

实验方式：
1.进行连续的看书行为
2.可以写代码
3.拒绝娱乐活动，可以进行体育运动

先试一周看看效果如何

update:很郁闷的没有做到

具体参考gentoo手册x86版
http://www.gentoo-cn.org/doc/zh_cn/handbook/handbook-x86.xml?style=printable&full=1

下为抽象出来的思路：

1. 关于如何安装Gentoo Linux
   本章介绍了本手册所讲解的安装方式。
   （一些常识）
2. 选择合适的安装方式
   你可以用许多方法安装Gentoo。本章讲解怎样用最小安装光盘安装Gentoo，尽管使用安装程序LiveCD也是可以的。
   （还是一些常识（有些不大懂 – -）。获取安装镜像，验证镜像有效性，用最小安装光盘来组成最小系统，然后从这个系统上进行安装）
3. 配置网络
   要下载最新的源代码，你要先设置好网络。
   （使最小系统能够连接网络，好下载安装包。）
4. 准备磁盘
   为了能够安装Gentoo，你必须创建所需的分区。本章讲解如何给磁盘分区以备后用。
   （准备好要安装gentoo的磁盘分区）
5. 安装Gentoo安装文件
   我们使用一个stage3文件来安装Gentoo。在这一章里我们将教你如何解压缩stage3文件和配置Portage。
   （安装包有两个，stage3和portage，stage3可以理解为最小的gentoo系统，里面是一个普通linux系统的根目录下的所有东西；portage为gentoo的软件包管理工具，记录了所有的软件包依赖关系，并含有emerge工具用来安装各种软件，地位相当于debian系中的apt-get）
6. 安装Gentoo基本系统
   安装并配置完stage3以后，你就会有一个可用的Gentoo基本系统了。这一章将教你如何达到这一状态。
   （组织分区，用chroot命令将当前shell的根目录更改为gentoo的分区，当前session下所有操作均调用gentoo分区的命令，相当于已经进入这个“半成品”的系统）
7. 配置内核
   Linux内核是每个发行版的核心。本章节将解释如何配置您自己的内核。
   （手工配置未遂，启动不能，于是genkernel搞定，没办法，经验太少，人也笨。。。 – -）
8. 配置系统
   你需要编辑一些重要的配置文件。在这一章中将对这些重要的配置文件作概述，并且介绍如何配置它们。
   （给系统做基础配置，包括硬盘挂载方式（重要），系统的网络设定，root密码）
9. 安装必要的系统工具
   在这一章中我们将帮助你选择并安装一些重要的工具。
   （一些系统服务）
10. 配置引导程序
    x86架构存在几种引导程序。它们中的每一种都有自己的配置方法。我们会一步步来告诉你怎样根据你的需求配置一个引导程序。
    （简单且片面的说，就是grub的安装和写菜单咯~全面的自己去理解吧：P）
11. 结束Gentoo的安装
    您几乎已经完成了。接下来我们只需要为您的系统创建一个（或更多）用户就可以了。
12. 下一步该做什么？
    现在你已经拥有了你自己的Gentoo操作系统了，但是下一步该做什么呢？
    （没啥了，自己看吧~）

总结：

第一步，建立起一个基本系统，配置好它，准备安装。
第二步，准备好要安装的分区。
第三步，下载stage和portage包，一个是基本系统，一个是软件包安装工具。
第四步，配置分区和portage包，并且切换根目录过去，进入“新系统”。
第五步，配置并编译内核。
第六步，配置新系统，善后。

ps：简单的说，这个安装过程虽说比其他系统那么方便的安装要麻烦很多，但是很有助于理解系统。经过这个过程你可以大概了解到一个正常的linux系统安装都会做些什么。