easy_install scipy
$ easy_install matplotlib
pybrain把数据处理算法叫做Module，一个network本身也是一个Module，自由参数free parameters是通过Trainder来调整的，

pybrain
structure
FeedForwardNetwork
LinearLayer
SigmoidLayer
datasets
SupervisedDataSet：监督数据集
ClassificationDataSet：分类数据集
tools.shortcuts
buildNetwork：快速构建神经网络
pybrain.supervised.trainers：训练器
BackpropTrainer
神经网络的构建

这里是快速使用网络

from pybrain.tools.shortcuts import buildNetwork
net = buildNetwork(2, 3, 1) # 表示二维输入，3个隐藏层，1维输出

Feed Forward Network 自己构建一个网络

from pybrain.structure import FeedForwardNetwork
n = FeedForwareNetwork()

接着构建那三层

from pybrain.structure import LinearLayer, SigmoidLayer
inLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outLayer = LinearLayer(1)

必须将几个层加入到网络中，为了网络能够前向传输输入和后向传输错误，必须指明哪一个是输入哪一个是输出

n.addInputModule(inLayer)
n.addModule(hiddenLayer)
n.addOutputModule(outLayer)

必须明确他们该怎样连接，其中一个连接方式是FullConnection

from pybrain.structure import FullConnection
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)

还得将模块与网络连接

n.addConnection(in_to_hidden)
n.addConnection(hidden_to_out)

最后为了让我们的MLP能使用，得

n.sortModules()

print n 查看该神经网络的结构

初始化一个神经网络

n.activate([1, 2] # 初始化的时候给一组数据进去就行了

查看初始化后的一些参数

in_to_hidden.params
hidden_to_out.params
n.params

给自己的神经网络命名

LinearLayer(2, name=”foo”)

第二个例子构建Recurrent Networks递归神经网络

不同的隐藏层：TanhLayer, SoftmaxLayer,

数据集
ds = SupervisedDataSet(2, 1) # 表示二维输入，一维输出
ds.addSample( (0, 0), (0) ) # 添加样本，第一个参数是输入，第二个参数是输出

对数据集的操作，inputs表示输入，targets表示目标(输出)

len(ds) # 数据集的样本数
for inpt, target in ds: # 对数据集进行遍历
ds[‘input’], ds[‘target’] # 获取所有的输入样本和相应的输出样本
ds.clear() # 清空数据集

SupervisedDataSet，监督训练的数据集，使用的appendLinked

sequential dataset, 监督序列回归训练数据集

classification：分类训练数据集

importance：加权监督数据集

训练器
from pybrain.supervised.trainers import BackpropTrainer
net = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, ds)
trainer.train() # 这就是在训练了，会输出错误的比例
trainer.trainUnitilConvergence() # 输出每个数据的收敛情况

分类
使用前馈神经网络进行分类
http://pybrain.org/docs/tutorial/fnn.html 使用了pylab的

alldata = ClassificationDataSet(2, 1, nb_classes=3) # 这种方式新建分类数据集
alldata.addSample(输入，类别) # 这种方式添加数据
test, train = alldata.splitWithProportion(0.25) # 使测试数据占0.25， 训练数据占75%
train._convertToOneOfMany() # 建议一个类别一个类，这句话啥子意思哟
test._convertToOneOfMany() # 这两个操作会将原始目标重复并且将他们存储在’class’字段

查看我们的数据

len(train) # 输出训练数据的长度
train.indim, train.outdim # 输出数据的inupt纬度和输出纬度
train[‘input’][0], train[‘target’][0], train[‘class’][0], # 输出第一个样本的输入数据，输出数据和分类

构造神经网络

fnn = buildNetwork(train.indim, 5, train.outdim, outclass=SoftMaxLayer)
trainer = BackpropTrainer(fnn, dataset=train, momentum=0.1, verbose=True, weightdecay=0.01)# 设置一个训练器
trainer.trainEpochs(1) # 训练一次的结果，可以多次训练
trnresult= percentError( trainer.testOnClassData(), trandata[‘class’])
tstresult = percentError( trainer.testOnClassData(dataset=tstdata), tstdata’class’]

黑盒优化

强化学习

今年情人节，和女朋友相约去最近的一个县城玩儿，但其中发生了各种不愉快，不过还好女朋友现在越来越像我了，遇到事情不会抱怨太久。又要离开家乡了，仔细想想这个寒假的种种经历，我想，可能，我再也回不来家乡了。

这里的回不来，不是指不回来，而是，我已经完全不适合在家乡生存了。我从大学一进城就发现，家乡的生存成本比城里高出了不知道多少倍，父母却总是不信。在家乡人眼里，城市依然是一个吃顿饭就会不小心花上几百上千的地方。然而，他们所不知道的是，农村因为信息的阻塞和大家生活水平的相对提高，物价可能比城市更高，至少在我眼里是这样的。城里有团购软件，你可以选择离你最近的地方，然后点你最想吃的餐，这些你都可以通过一个手机APP找到，并且全都明码标价，绝对不会作出宰客这种事情。如果你对商家提供的服务有一点点的不满意，你随时可以给一个差评或者直接向APP投诉，不出24小时基本上你的诉求都能得到回应。

我嫂子前几天去银行改手机号码，结果银行服务人员脾气太差，她直接被吓回来了，我就跟她说下次带我一起去，她一发脾气，我立马举报，如果举报不行，那就找12315投诉。同样，我另一个在城里待过几年的嫂子，想要将城里暂时用不到的宽带转移到家里来却被各种拖延，当时眼看对方要发脾气，立马说了一句，“你再不搞好我就投诉你”，对方立马焉了，我多么想看看服务员当时的面部表情。家乡的人由于信息闭塞与教育落后，真的受了太多的“欺负”，他们不知道还有这么多的合法渠道来维护自己的合理的权益，导致这里的不良商家像上帝一样对待顾客，不过这里，商家才是上帝。同样关于维权的，前几年，我家的电压一直不稳定，电力局一直说要解决，但是一直不见行动，当时的我十分气愤，给市长信箱写了邮件，第二天，一伙人赶来我家检查，最后还要我签字确认。不是我这人较真，我只是觉得，我付出了金钱，就应该享受这些服务，而且在我付钱的时候他们也都承诺过要给予这些服务的。包括12315这样的组织，我们虽然没有直接交钱，但是我们的税收里肯定包含了这些的，所以有问题不能解决，那我就找12315。

情人节去邻县看电影，整个县城两个电影院，我们去的中心那个，另一个在城边上，几乎没人会去那里。可是，居然有电影院不能网上团购选座，把我弄郁闷了。于是我们就自己走去购买，12点买到了下午2点的票，而且是最后几个位置，当然是第一排的边上了，2点去看电影的时候电影院简直人满为患，据说现在买到的都到晚上八点后的了。看电影的时候我惊奇地发现，屏幕咋那么小，而且屏幕边缘那些褶皱是什么鬼。总之，体验超级不好，还不能给差评。邻县的交通也是乱得无法形容，基本上是人和车都在抢道，没办法，人让了就过不了马路，车让了也过不了马路，政府也没办法，人流量大的地方正好车流量也大，设个红绿灯还不如不设呢。中午吃饭，这里居然有三顾冒菜，但是，价钱呢，怎么没标识，想着也没有团购吧。这里的出租车据说跑城内都很有可能不打表的，不过在这里我一般不坐出租车，毕竟公交车只要1元，虽然我不知道司机哪儿有那么多急刹车要踩。

这里的人际关系之复杂，与城里简直是天壤之别。简单地说，在大城市，有能力就可以，而在小地方，有关系，没能力你也可以。在这里无论做什么，你都得先想想，对方可能是你的某个亲戚或者某个亲戚的亲戚。比如去年，我一个大姨被一酒驾人员擦到了，由于年岁已高，当时就倒地不起，那人居然肇事逃逸了。之后家人居然叫我们不急打110。我是完全无法理解的。直到我大姨被送到医院，那人始终未出面，而那些大人们却一直在联系认识肇事人的亲戚过来。最后我们中有年轻人报了警，但是警察来的时候，那亲戚也来了，然后，就叫警察回去了，当时看得我是目瞪口呆的。最后，这件事也在一顿饭中不了了之了。对于肇事逃逸那个人，我只想说，幸亏你身在这儿，不然早就进监狱了。

再来说说家乡的酒桌文化和面子文化。为什么有人要把劝酒视为一种传统文化而世代相传呢，连七八岁的小孩都觉得，不喝酒怎么行，不喝酒怎么在社会上走。有些人劝起酒来，给我这种不喝酒的人的感受就是，不把你灌醉就是我照顾不周，而你不喝酒的话，那更严重，那就是不给我面子。面对这种人，我就有多远滚多远吧。我说我不能喝酒，我说我高血压，结果还非要我喝，你连我的命都不要，还奢求我给你什么面子，再说，我不想喝你偏要我喝，这到底是谁不给谁面子。当然，家乡的送礼文化我倒觉得没什么，一般也就送一些奶、火炮什么的，一般是你送给我多少，下次我就还给你多少，这个虽然也是有点麻烦，但是毕竟不会劳民伤财嘛。当然，请一定要记住，千万不要少给或者不给，不然的话，背地里一定会到处说的，你永远也不知道在家乡，一张嘴的传播速度与互联网的传播能力速度哪个更快。

我知道，家乡生我养我，我或许不该说得这么过分，但是现在，我真的越来越不懂家乡了。

买了kindle已经看了七八本书了，其他的书在博客改版后都陆陆续续写了书评了，但是我居然还没有给《三体》写读后感。这两天，世界突然被一个发现震动了：引力波被证实了。虽然不知道其中的具体含义，但是可能真的如人们所说，引力波的发现可能会像万有引力被发现一样给基础物理学带来飞速的发展。

简单地说，我最初是因为急着看《三体》才去淘宝买kindle的。对于一个长大了的科幻迷来说，《三体》绝对是不可多得的好书，并且它是国产的，这是我最惊讶的一个部分。不是我看不起国内小说，国内小说总体来说武侠传奇的比较多，描写未来的确实罕见，而能这样引人入胜的，更是凤毛麟角。当然也有可能是由于我读的小说比较少的缘故吧，这部小说在开篇就把我吸引进去了，废寝忘食地看了一个星期。

全书分为三个部分：《地球往事》、《黑暗森林》、《死神永生》，其中最精彩的部分莫过于黑暗森林了，把宗教、伦理、科幻、爱情等统统融合在一起，体现了其宇宙社会学的深层含义。看了很多的书评，负面评价的原因主要有二，一是叙事手法上，二是科幻知识上相对低级。前者我不好评价，毕竟我对这方面没有研究，我只知道在阅读的时候我被深深地吸入进去了，只知道这本书的想象力至少在国内是极少见到的。(不过说实话，最后一部的结尾，确实有点粗糙，感觉就像是《火影忍者》一样，匆匆结尾，看起来像是文思枯竭了一样)对于后者，我只能说，正式因为此书所用到的物理知识对于一个大学生的我来说，刚好能够理解，不会显得晦涩难懂，我想，这已经很成功了。

黑暗森林法则：宇宙就是一座黑暗森林，每个文明都是带枪的猎人，像幽灵般潜行于林间，轻轻拨开挡路的树枝，竭力不让脚步发出一点儿声音，连呼吸都必须小心翼翼：他必须小心，因为林中到处都有与他一样潜行的猎人，如果他发现了别的生命，能做的只有一件事：开枪消灭之。在这片森林中，他人就是地狱，就是永恒的威胁，任何暴露自己存在的生命都将很快被消灭，这就是宇宙文明的图景。佩服作者的想象力，以前的我真的从没想过这一个层面的东西，认为我们就应该一直寻找宇宙中的智慧生物，去寻找另一个文明，现在看来，一切都太艰难了，宇宙中处处存在着猜疑链，你永远不知道另一个文明是怎么看你的，不要像程圣母(程心)一样只用善良的思维去思考这个世界。

射手假说：有一名神枪手，在一个靶子上每隔十厘米打一个洞。设想这个靶子的平面上生活着一种二维智能生物，它们中的科学家在对自己的宇宙进行观察后，发现了一个伟大的定律： “宇宙每隔十厘米，必然会有一个洞。”它们把这个神枪手一时兴起的随意行为，看成了自己宇宙中的铁律。

农场主假说：一个农场里有一一群火鸡，农场主每天中午十一点来给它们喂食。火鸡中的一名科学家观察这个现象，一直观察了近一年都没有例外，于是它也发现了自己宇宙中的伟大定律：“每天上午十一点，就有食物降临。”它在感恩节早晨向火鸡们公布了这个定律，但这天上午十一点食物没有降临，农场主进来把它们都捉去杀了。

这两个假说，我也只能仰望了，看过那么多科幻小说和纪录片，我也没能跳出这个牢笼，从外面的世界思考，比如这里，如果调到比我们更高维度来思考，他们也会不会认为我们只是纸上的一些小人儿呢。

消灭人类暴政，世界属于三体

一切都会逝去，只有死神永生

推荐观看：
神剪辑！12分钟看完90万字科幻小说神作《三体》
我的三体(国内粉丝使用minecraft制作)

人生最后一个寒假，趁着还记得，回忆一下我这四年

大一

• 比规定时间提前来了几天，学校里居然这么少的人。6栋真小，12平米的房间住了四个人。那几天有领导来关怀新生，整栋楼就没几个人，正好他们敲了我的房间，还和领导握了手。后来才知道，她就是大名鼎鼎的是书记
• 听学长的话，认为大学就该多去争取兼职机会，于是答应帮别人卖被子提成。但是遇到一个人得时候不忍心把被子高价卖给别人，也由于自己脸皮比较薄，所以放弃了
• 听别人的话，大学得多加社团，报了几个社团，基本上，如果有技术面的都能过，面试都没过，然后就没有然后了。当时不知道还有学生社团这种东西(和学生会的黑社会性质不一样，这个完全是兴趣)，也错过了社团的招新。
• 下学期的时候参加了C语言考前培训，认识了软件协会会长和副会长，给了我几道题，做好了，然后就跟着他们联系ACM，然后顺利成长的当上了副会长(当时叫我当会长，被我拒绝了)
• 大学有一次进某个实验室的机会，但我也放弃了，那老师就一个做外挂的
• 虽然我高三就开始学习C语言，但其实大一那个寒假我才真正学完，才真正学号了她
• 大一结束那个暑假，学了Python、Delphi、PHP，虽然都只是学了其语法，但也算入门了
• 我们是大一结束才军训的，厌恶透了
• 从大一下开始追海贼，也是这个时候入微博
• 大一暑假，我们一行人准备骑行去西藏，结果，我半途而废，至今是我心里永远的伤疤
• 对了，就在大一结束就开始写个人博客了

大二

• 当了一年的副会长，认识了很多人，技术也学到了一些，与服务器的第一次亲密接触，从此知道linuxinux server这种神奇的东西，从此会搭建个人网站了，从此走上了运维这条不归路。其实在软协这两年，我一直是想通过一些特殊的培训来帮助大家，提高大家的，不过没想到的是大二大三事情太多了
• 与软件协会另两位组队参加了重庆市的ACM比赛，不过没获奖，也没什么，至少我还是参加过一次比赛的(PS:别问我获奖队伍那么多为什么我们都没获奖，谁叫他规定每个学校最多三支队伍获奖的)
• 英语四六级考试都一次过，不过，说真的，每次考完我都觉得差着几百分呢，ps：四级是优
• 大概是从这一年开始接触微博的，从此完全成了微博控，花费了我大量的时间，不过带给我的启发却是不可估量的，通过微博，我才看到了世界。至少，不用再沉浸在C和C++的海洋里，原来外面的世界还有python，还有node，还有openstack，还有nosql，原来，我们永远也学不完，原来学校教的在外面真的很少能用到
• 这一年，也是我上自习上得最多的，导致我连续两年拿了奖学金，还拿奖学金买了一把国产机械键盘，那叫一个爽，那叫一个帅
• 大二下学期，进入了实验室，好吧，我那么晚才进实验室的，可是实验室的老师是一个刚从国外留学回来的，感觉他不怎么了解国内市场和国内的职场。不过，搞研究的老师应该都这样吧。模式识别，几十篇的全英文论文，看得心烦。也因为这次经历，导致我放弃了考研的想法。
• 放弃考研的那几天，我把以前的书都卖了，还美其名曰破釜沉舟。同时，也没怎么关心学习的事情了，一心钻研自己的技术。
• 这个学期分专业填志愿，我和以前毅然决然的选择了信安专业，虽然当时我已经不想学信安了，但是毕竟自己以前一直期待这个专业嘛，而且当时的我对选择什么专业已经不以为然了，无论哪个专业我都只会走我自己的路。
• 20岁生日这天，买了两瓶白酒和几瓶啤酒，在寝室喝，由于没有什么氛围，室友们并不想喝，于是我一个人喝了…反正我是不知道那晚吐了多少次，据说我吐了无数次，翻下了床无数次，多亏了我的室友啊，不过，你们看到我这样都不送我去医院吗…
  醉了才知道自己有多么无力，20岁，我写过一篇文章，很伤心，很落寞，觉得自己太失败了，那晚我也仅仅是喝醉了而已，并没有把一切都看开，真正让我看开的，是我现在的女朋友，所以，忘掉一段感情最好的方式就是认真开始一段全新的感情
• 暑假的时候把qq相册所有的好友的图片抓下来了，这篇博客访问量上万了，而且因为这个，腾讯一个团队老大找过我，不过当时我实在不想去做前端…现在想想，还好没答应，不然怎么找得到女朋友呢
• 大二刚开始就买了台红米手机，从此入坑，直至现在都还在用着红米系列
• 大二暑假，我家终于买车了，突然想学车了，然而现在的我已经没时间去学习了

大三

• 既然不考研那就得找事儿了，找了一个工作室去练习，其实一直很佩服领导人眼光的(是一位在职百度贴吧大神创业)，但是他是在不懂得如何管理团队，导致大家最后都没什么激情了。而且由于没有项目管理人员，导致项目到最后居然和之前的需求不一致，最后就没让我们做了。在这个项目里面我主要做的是服务器、数据库的搭建与维护，还包括后台PHP程序的开发。虽然最终失败，不过经历过这个项目，我突然对运维感兴趣了，所以现在自然进入了运维开发这个行当。
• 大三下学期一直在找实习机会，也顺利在期末进入了一个传媒公司实习。实习到过年，同样，也是做的Python后台程序开发以及服务器的维护，也算是有大半年的Python工作经验了。我能说，我来这里一两个月了，团队里的人才知道我是实习生吗，原来人事和技术这么分离呀，原来我真的能胜任工作的。除了工资相对低以外，这个公司绝对是我见过的福利最好的公司，各种假期，中秋国庆连着放了13天，过年同事们都说毕业这么多年，第一次感觉到放寒假了，从2月3号放到23号。年会没人都抢了几百的红包，一人一块猪肉…对了当天我们还一人提一带猪肉去ktv的总统套房…
• 也正是因为实习，终于我过上了梦寐以求的租房的生活，想吃什么吃什么
• 也正是因为进了公司，开始大量使用微信了，原来这里又是另外一片天地
• 大三上学期，我居然挂科了，而且挂这个科的人基本上大学都是只挂了这一科，我只想说这个老师是个奇葩
• 在大三下学期刚开始就找到了女朋友，从此，每个周末都没有空了…很累但很幸福，对了，她可是我小学同学，隔壁村的哟
• 大三寒假，140斤，去医院检查，说肝上油太多，快发展成脂肪肝了，从此不敢海吃肥肉了，大三下每天运动，减了十几斤的肉，but，暑假的时候，老婆的菜确实太好吃了…
• 3月份，我的微博数量超过了1000
• 8月份，我终于申请到了人生的第一张信用卡，额度6000，写这篇文章的时候，这个月账单8000多

大四

• 大四上学期只回去上过一次课，都是找人代的，而且还没挂科，后来想想，要是大一大二就能做到这样该多好呀，但我们学校逼的，我只能呵呵
• 7月份校招就已经开始，但是我现在完全不像去外地了，只想找一个离家近的工作，好不容易得来的爱情，我不像就这样异地恋，别tm跟我说异地恋是一场考验，不像分开就是不像分开，交往一年，我现在觉得百多公里的距离就是银河那么远了。其实不离开家乡还有一个重要的原因是因为这里朋友多，我好想毕业了能像爱情公寓里面一样，所有的好朋友都能在一起。选择了重庆，自然就选择了猪八戒，好吧，其实我貌似只投过猪八戒。以我当时的能力，我想，在重庆，无论哪个公司应该都能投简历就能上吧，毕竟，我曾经那么努力，就是为了自己以后在选择的时候多一些自由。其实去不去外地，都是自己的选择，有很多人都不理解我，我也不奢求所有人都能理解，反正，你在那里奋斗，我再这里奋斗，大家一起努力嘛，都是自己选择的人生，站着跪着都要走完。
• 整个上学期都是在之前那个公司实习的…
• 大四上，我终于用上了苹果电脑，应了一句话，所有linux爱好者在有钱后都会转向mac的，不仅买了rmbp，还买了kindle，终于又开始大量看书的时代了
• 寒假，报名了学车了，以前我想学的时候他们不然我学，后来他们想让我学的时候我也不想学，现在终于抓紧最后时间学一下吧
• 大四寒假，二十几年来重庆看到的第一场大雪
• 这个寒假，爸爸50岁生日，终于能用自己的钱给爸爸买礼物了，一个机械表，信用卡刷爆…

总之，我的大学并没有白过，四年大学生涯，学校没教会我什么，但是我是在这个学校学到了我想学的，也领悟到了我以前我不懂得。比以前更了解自己，这才是大学的意义嘛。

之前在微博上看到有关敏感话题的讨论中看到该书名，然后出于愤世嫉俗的原因，我自然会去买来看。看了一点点后我就像说，在天朝，这本书没有被禁，简直是奇迹。

太像了，一切都太像了，为了自由，聪明的猪带领大家起义，最终赶走了农场主。但是随着猪的权利越来越大，得到的利益越来越多，野心越来越膨胀，最终，大家奋斗来的自由都被统治者剥削完了，生活甚至比以前更加艰难了，但是他们的洗脑工作却让下面的以为这样的日子比以前好多了，然而实则已经变成一个充满剥削的社会了。

据说，这部小说背景是俄国的十月革命到苏联1940年代，但我只想说，和某国太像了，既得利益者为了巩固和加强自己的权力，不顾一切地去掠夺，甚至有时候闹出一切滑稽的笑话，就像“所有动物生来平等，但有些动物比其他动物更平等。”这让我想起了某国的特供用品。对于对自己不利的一切消息，对内部一律封锁，甚至建立一堵堵厚厚的墙，声称这样是为了保护大家，实则是将好的东西都挡在了外面，最后的结局可想而知。

在我眼里，动物们升旗就是最大的讽刺，明显是为洗脑而生的行为。我能说某些国家即使到了大学还要经常升旗吗，升旗还要念文章，我去。自己生活十分艰苦，还一天嚷嚷着要去解放别人，别人的生活不知道比你好到哪里去了。他们还喜欢邀请别人来庄园，炫耀他们这里多么的繁华。还有被取消的“同志”这个词，看着真是搞笑。

至于这本书为什么没被禁，我是想不通了，或许他们根本不屑于审查这部“童话”，或许他们根本看不懂…反正我是推荐生在不平等国家的人都去看看。

初看麦田里的守望者，我只看到一个满口脏话，觉得全世界都是傻逼，只有我是最纯洁的一个人。在看之前我并不了解这本书的历史背景，一直觉得这本书可能是90年代后的，不过看了几天后脑海中却始终浮现出一幅很老的画面，就像电视里美国刚开始有摄像机的无声电影一样，所有的人都穿着”老土”的服装，那是一个灯红酒绿、社会混乱，所有人都在寻找出路的时代，事实证明我是对的，此书出版于1951年，正是二战后美国的真实写照吧。

“一个不成熟的人的标志是他愿意为了某个理由而轰轰烈烈地死去，而一个成熟的人的标志是他愿意为了某个理由而谦恭地活下去。”这或许是此书最出名的一句话。不敢自谦，不过，正如我一直坚持的价值观一样：人，是可以平凡的。比如爱情，现在的社会本没有历史上那么轰轰烈烈，也不会有什么海枯石烂，最多相隔万里，那也能通过网络时时通讯。说的太多，感觉这段和此书的主题并无多大联系。

第一次接触意识流的小说，觉得有些晦涩，有些不解，但霍尔顿的世界可能每个人都经历过。比如我们的成长，每个人的成长或许都伴随着成年人的不理解，有的人在这过程中练就了挑战世界的本领，而有的人则在反抗的过程中渐渐成长为自己曾经讨厌的人。成长过程中，无论坚持了以我，还是改变了自我，都没有错，最终他们都会走向自己一样的人生，哪怕不是曾经希望的，但一个成年人可能更懂得珍惜现在。不是认命，而是认清了自己。

故事最后的结局也让人们争论不已，我想，霍尔顿现在已经长大了吧，理想被一个一个击破，到底是继续反抗世界还是改变自己，现在他已经知道答案了。

今年过年回家，我仿佛变成了故事里的男主角，愤世嫉俗，以前觉得没什么的事情今年却突然感觉十分愤怒。

为什么我今年回到家成天就感觉这里活着真累呀，错综复杂的亲戚关系，成天都担心着别人眼中自己的形象，遇到各种不公平待遇却又忍气吞声，明明讨厌的事情却又有各种原因不去拒绝。。。

这是我2月7日发表的一篇微博，怎么说呢，以前可能觉得这些离自己太远，所以没去在意。但是即将毕业的我，又碰巧在这个节骨眼到了谈婚论嫁的时刻，实在无法适应，只能边骂边去接受自己能接受的。只希望，明天的我，依然是我曾经喜欢的模样。

参考地址：http://dev.mysql.com/doc/refman/5.6/en/linux-installation-debian.html
不知道为什么很多地方的官网都把一个完整的包打散了，然后完整包和分开的包放在同一级目录里，我也是醉了，最终我还是找到了正确的安装方法。

1. MySQL社区版官网下载地址：http://dev.mysql.com/downloads/mysql/
   需要注意的是，一定要下载结尾为.deb-bundle.tar的包，因为它包含了其它分开的包的所有数据

2. 一步一步执行下列步骤就可以了：

    sudo apt-get install libaio1   // 安装基本的依赖
tar -xvf mysql-server_MVER-DVER_CPU.deb-bundle.tar   //解压
sudo dpkg -i mysql-common_MVER-DVER_CPU.deb   // 安装common文件
dpkg-preconfigure mysql-community-server_MVER-DVER_CPU.deb // 预配置，进行mysql的配置，这时候会要求输入root密码等
sudo dpkg -i mysql-community-server_MVER-DVER_CPU.deb    // 安装mysql-server
sudo dpkg -i mysql-community-client_MVER-DVER_CPU.deb    // 安装mysql-client
sudo dpkg -i libmysqlclient18_MVER-DVER_CPU.deb   // 安装公共库

3. 收尾

    # 运行兼容检查工具，自动解决不兼容的问题
命令行执行mysql_upgrade -uroot -pmysql




不然可能会出现这些错误：
MySQL unknown column 'password_last_changed'

4. So Easy

参考地址：http://369369.blog.51cto.com/319630/790921

原来想要简单地实现MySQL的主从复制其实也是很简单的(这里当然不包括服务监控和容错处理啦)

1.要检查主从服务器的MySQL版本，最好版本一致，不然会出现各种问题，特别是，5.5和5.6是不会兼容的

2.修改两个服务器的mysql配置vim /etc/my.cnf

1
2
3

[mysqld]
log-bin=mysql-bin    // 打开二进制日志
server-id=41         // 服务器的唯一ID，为0表示拒绝所有从服务器的连接

分别修改两个服务器配置然后分别重启

3.主服务器建立账户：这个账户与普通账户不一样，它只能用于主从复制中：

1

mysql> GRANT REPLICATION SLAVE ON *.* to 'master'@'%' identified by 'mysql';

4.查看服务器状态

1
2
3
4
5
6
7

mysql> show master status;
+------------------+----------+--------------+------------------+-------------------+  
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |  
+------------------+----------+--------------+------------------+-------------------+  
| mysql-bin.000004 |   615261 |              |                  |                   |  
+------------------+----------+--------------+------------------+-------------------+  
1 row in set (0.00 sec)

需要注意的是，这两个值都得记下来哟

5.将主服务器数据库dump然后导入到从服务器，记下了Position就不用担心dump后新增数据的情况，会自动同步的

6.配置从服务器

1

mysql> change master to master_host='192.168.1.41', master_user='xiaohao', master_password='mysql', master_log_file='mysql-bin.000004', master_log_pos=615261;  # 这里就是刚才的Position

7.启动从服务器

1

mysql> start slave;   # 同理，停止用stop slave

8.查看复制状态

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

mysql> show slave status\G  
**_*_****_*_****_*_****_*_* 1. row ****_*_****_*_****_*_******  
Slave_IO_State: Waiting for master to send event  
Master_Host: 192.168.1.41  
Master_User: xiaohao  
Master_Port: 3306  
Connect_Retry: 60  
Master_Log_File: mysql-bin.000004  
Read_Master_Log_Pos: 652289  
Relay_Log_File: ubuntu-relay-bin.000002  
Relay_Log_Pos: 37345  
Relay_Master_Log_File: mysql-bin.000004  
Slave_IO_Running: Yes  
Slave_SQL_Running: Yes  
Replicate_Do_DB:

必须保证Slave_IO_Running和Slave_SQL_Running都为Yes的时候才正确的

TroubleShooting：

• 出现错误：Slave SQL for channel ‘’: Slave failed to initialize relay log info structure from the repository, Error_code: 1872是因为relay-log有问题，这时候修改从服务器mysql配置，在[mysqld]中加入relay-log-recovery=1，这样表示，服务器启动之后，删除所有已有的relay日志，重新接收主库的relay日志

基本概念

• 进程: 资源分配的最小单位。
• 线程: CPU调度的最小单位。
• Python里面的多线程只能利用CPU的一个核(全局解释锁的历史原因)
• 多线程一般来说比多进程快，毕竟共享内存，但是多线程也更危险，以为一个线程崩溃可能导致整个程序崩溃。

多线程

线程安全与线程不安全: 多个线程同时访问一个方法，得到的结果一样就是线程安全的，不一样则是线程不安全的。gevent库是基于事件驱动模型，它的线程是否安全完全看多线程程序是怎么写的，如果仅仅只有gevent一个线程那么不存在线程安全问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 创建子线程
class Thread(threading.Thread):
    def __init__(self, 变量):
        threading.Thread.__init__(self)
        self.变量 = 变量
    def run(self):
        逻辑
thread = Thread(参数) # 定义一个线程
thread.start()      # 开启一个线程，此时子线程已经开始执行了，主线程不会被阻塞
thread.join()		# 这样可以让主线程阻塞，一直等到子线程退出位置才会继续往下执行

# 常用方法
threading.activeCount()	# 获取当前线程数量，可以用这个来控制线程最大的数量
threading.currentThread() # 获取当前线程对象
threading.currentThread().getName() # 获取当前线程的名称
exit()         # 终止当前线程，网上好多人问怎么没有API，后来发现exit就行了...并不会影响到其它线程和主线程

# 线程锁，如果要修改全局变量，可以给全局变量加锁。
lock = threading.Lock()
lock.acquire()
xxxxx
lock.release()
# 更方便的使用：
lock = threading.Lock()
with lock:
	xxxxxxx
    
# 局部变量。虽然局部变量简单的使用直接用就行，但是如果要在run里面进行各个函数之间的传递那就麻烦了，所以提供了ThreadLocal来将线程内部的局部变量变为一个字典，其它函数直接调用即可
LOCAL = threading.local() # 在全局定义，每个线程引用该值结果都仅仅会得到自己的私有变量
# 在Thread类里面的run函数赋值，不能在__init__里面定义，因为那时候线程还没启起来
LOCAL.变量名 = 值 # 就这样

多进程

os.fork()

直接fork一个进程

multiprocessing库

线程池/进程池

Pool

协程(asyncio)

位于标准库中，使用协程来编写单线程的并发，通过IO多路复用技术访问套接字。进程和线程都面临着内核态和用户态的切换问题而耗费许多切换时间，而协程则是用户自己控制切换时机，不需要进入内核态。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import asyncio

# 用装饰器来标记作为协程的函数
@asyncio.coroutine
def countdown(number, n):
    while n > 0:
        print('T-minus', n, '({})'.format(number))
        yield from asyncio.sleep(1)	# 这里会返回一个asyncio.Future对象并将其传递给时间循环，同时暂停这一协程的执行，时间循环监听这一对象，1秒钟后，时间循环会选择刚刚这个协程，将future对象的结果返回给它，然后协程继续执行。这一过程会持续到所有的协程程序全部完成。
        n -= 1

loop = asyncio.get_event_loop()
tasks = [
    asyncio.ensure_future(countdown("A", 2)),
    asyncio.ensure_future(countdown("B", 3))]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

# 在3.5里面，有了新的语法，添加了types.coroutine修饰器
async def slow_operation(n):		# 以这种方式定义协程，在协程里面不能有yield语句，只有return和await可以用于返回
    await asyncio.sleep(1)	# await接受的对象必须是awaitable对象，必须是定义了__await__()方法且这一方法必须返回一个不是协程的迭代器，协程本身也被认为是awaitable对象
    print('Slow operation {} complete'.format(n))

async def main():
    await asyncio.wait([
        slow_operation(1),
        slow_operation(2),
        slow_operation(3),
        ])

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
loop.close()

asyncio中使用requests

1
2
3
4
5
6
7
8
9
10
11

async def req(url):
  loop = asyncio.get_event_loop()
  await loop.run_in_executor(None, requests.get, url)
  
async def req2(url):
  await req(url)

tasks = [req2(url1), req2(url2)]  

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.await(tasks))

asyncio动态添加任务

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

async def produce_task():
  while True:
    url = redis.pop()
    asyncio.run_coroutine_threadsafe(req2(url), thread_loop)	# 这里的req2参考上面的定义，是一个异步任务函数thread_loop是我们单独的一个事件循环

def start_loop(loop):
  asyncio.set_event_loop(loop)
  loop.run_forever()
    
# 单独启动了一个线程来做消费者
thread_loop = asyncio.new_event_loop()
run_loop_thread = Thrad(target=start_loop, args=(thread_loop,))
run_loop_thread.start()

# 主线程则直接进行事件循环
loop = asyncio.get_event_loop()
loop.run_until_complete(produce_task())

并发框架

concurrent.futures

该库通过相同的API同时支持线程与协程，以POOL的方式进行并行任务的管理。其中Executors用于管理workers，而futures则用于表示一个异步计算的结果，当调用future时会被立即返回，但是不一定就是最终结果。

ThreadPoolExcutor改为ProcessPoolExecutor就是线程了，真方便。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# 来源: https://pymotw.com/3/concurrent.futures/
# 该例表示一个最大执行进程数为2个的执行器，同时处理5个任务
def task(n):
    print('{}: sleeping {}'.format(
        threading.current_thread().name,
        n)
    )
    time.sleep(n / 10)
    print('{}: done with {}'.format(
        threading.current_thread().name,
        n)
    )
    return n / 10

ex = futures.ThreadPoolExecutor(max_workers=2)
print('main: starting')
results = ex.map(task, range(5, 0, -1))
print('main: unprocessed results {}'.format(results))	# 这里返回的是一个迭代器
print('main: waiting for real results')
real_results = list(results)
print('main: results: {}'.format(real_results)) # 返回真实的结果

# map中函数如果需要多参数，可以这样做(只需要替换lambda中的函数名即可)
for result in ex.map(lambda p: task(*p), arguements_list):
	print(result)

# 用map只能处理相同的任务，可以通过submit来执行需要执行的任务
from concurrent import futures
import threading
import time

def task(n):
    print('{}: sleeping {}'.format(
        threading.current_thread().name,
        n)
    )
    time.sleep(n / 10)
    print('{}: done with {}'.format(
        threading.current_thread().name,
        n)
    )
    return n / 10

ex = futures.ThreadPoolExecutor(max_workers=2)
print('main: starting')
f = ex.submit(task, 5)
print('main: future: {}'.format(f))
print('main: waiting for results')
result = f.result()
print('main: result: {}'.format(result))
print('main: future after result: {}'.format(f))

# 不按照顺序来获取结果，只要有个任务完成，就执行输出结果，上面那几个方法必须等所有任务执行完了顺序输出，而这个则是只要完成一个就输出一个
wait_for = [
    ex.submit(task, i)
    for i in range(5, 0, -1)
]
for f in futures.as_completed(wait_for):
    print('main: result: {}'.format(f.result()))

回调

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

from concurrent import futures
import time

def task(n):
    print('{}: sleeping'.format(n))
    time.sleep(0.5)
    print('{}: done'.format(n))
    return n / 10

def done(fn):
    if fn.cancelled():
        print('{}: canceled'.format(fn.arg))
    elif fn.done():
        error = fn.exception()
        if error:
            print('{}: error returned: {}'.format(
                fn.arg, error))
        else:
            result = fn.result()
            print('{}: value returned: {}'.format(
                fn.arg, result))

if __name__ == '__main__':
    ex = futures.ThreadPoolExecutor(max_workers=2)
    print('main: starting')
    f = ex.submit(task, 5)
    f.arg = 5
    f.add_done_callback(done)
    result = f.result()

任务的取消

Future只要还未开始就能被取消，f.cancel()

任务的异常

通过f.exception()可以获取到任务抛出了什么样的异常

gevent

协程

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

# 最简单的使用
import gevent

def foo():
    print('Running in foo')
    gevent.sleep(0)
    print('Explicit context switch to foo again')

def bar(abc):
    print('Explicit context to bar')
    gevent.sleep(0)
    print('Implicit context switch back to bar')

gevent.joinall([		# 把gevent.spawn()放到joinall过后才会真正开始执行
    gevent.spawn(foo),
    gevent.spawn(bar, '参数'),
])

print('abc')	# 这行代码会等待所有协程执行完了过后才会执行

多进程/线程下的常见问题

主线程监听子线程状态

我的解决方法是利用共享队列将子线程的信息等传入queue，类似创建一个flag变量，然后在主线程进行监听，例如，代码来自https://stackoverflow.com/questions/2829329/catch-a-threads-exception-in-the-caller-thread-in-python/2830127#2830127

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class ExcThread(threading.Thread):
    def __init__(self, bucket):
        threading.Thread.__init__(self)
        self.bucket = bucket
    def run(self):
        try:
            raise Exception('An error occured here.')
        except Exception:
            self.bucket.put(sys.exc_info())
def main():
    bucket = Queue.Queue()
    thread_obj = ExcThread(bucket)
    thread_obj.start()
    while True:
        try:
            exc = bucket.get(block=False)
        except Queue.Empty:
            pass
        else:
            exc_type, exc_obj, exc_trace = exc
            # deal with the exception
            print exc_type, exc_obj
            print exc_trace
        thread_obj.join(0.1)
        if thread_obj.isAlive():
            continue
        else:
            break
if __name__ == '__main__':
    main()

Atom

TroubleShooting

• 使用Python3，直接在文件头添加#!/usr/local/bin/python3

• atom-script输出中文出现unicodeerror错误，可以这样输出：

  import io, sys
  sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding = 'utf-8')
  sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding = 'utf-8')
  print ('中文')
  

• 设置shadowsocks代理
  vim ~/.atom/.apmrc

  1 2	strict-ssl = false http-proxy = http://127.0.0.1:8090/proxy.pac

  apm config list查看是否设置成功

  1	http-proxy = "http://127.0.0.1:8090/proxy.pac"

• ---