编者注：此文是 CamMi Pham 的文章，原文发表在 Medium上。作者通过自身经历和一些科学证据说明，有时候努力工作未必是通往成功的正确路径。成功的关键不是努力而是巧干。因为时间是稀缺商品，有时候少干反而收效更佳。

忙未必就说明你有生产力。要想有生产力，更多的是要管理好你的精力而不是时间。要经营好你的生活。我们需要学会花费最小的精力得到最大的收益。不干以下 7 件事，我把每周的工作时间从 80 小时缩短到了 40 小时，但是完成的工作却多了很多。

1、不加班效率高

每周 5 天，每天 8 小时的工作制是福特在 1926 年的发现。实验表明，把每天工作时间从 10 小时降至 8 小时，每周工作时间从 6 天降至 5 天后，生产力反而提升了。

1980 年由商业圆桌会议发布的《建筑项目的加班效应》指出，无论从短期还是长期来看，工作越多，效率和生产力都会下降：

若每周工作时间超过 60 小时的情况持续超过两个月，生产力下降的累积效应将导致完工日期推迟，而同样的人数每周只工作 40 小时甚至还会更早完工。

美国军方研究表明，“每天少睡 1 小时持续一周会导致相当于 0.1 血醇水平的认知退化”。

《睡眠的秘密世界》指出：

熬夜之后无论白天你干得有多好，情绪不会太高。更重要的是前瞻性思考和行动的意愿、对冲动的抑制、乐观程度、同理心、情商等也会下降。

所以保证充足的睡眠对于维持高水平的生产力十分重要。

很多名人的经验是白天多小睡。达芬奇、拿破仑、爱迪生、罗斯福夫人、吉恩•奥特里、肯尼迪、洛克菲勒、丘吉尔、林顿•约翰逊、里根等都有小睡的习惯。

2、不要老说“好的”

根据 20/80 原理（帕累托原理），20% 的努力创造出 80% 的结果；但反过来 20% 的结果消耗了 80% 的努力。因此我们应该把精力集中在能产出 80% 结果的事情上，然后放弃其他的事情。如此就能把更多的时间集中在最重要的任务上。我们应该对低产出甚至无结果的任务停止说“yes”。

成功人士和非常成功人士的区别在于后者几乎对所有事情说“不”

——巴菲特

这就引出一个问题：我们该对哪些事情说“yes”，对哪些事情说“no”呢？如果想不出哪些事情值得花时间，不妨来个简单的分离测试。跟踪自己所做的一切事情然后尽可能优化。

我们中的大多数往往都说了太多的“yes”，因为这比拒绝要容易得多。没人想当坏人。

2012 年的消费者杂志发表了一项研究，研究人员把 120 人分成了 2 组。一组人训练成说“我不能（I can’t）”，另一组则说“我不（I don’t）”。结果很有趣：

告诉自己“我不能吃 X”的学生在 61% 的时间内选择了吃巧克力糖，而告诉自己“我不吃 X”的只在 36% 的时间里抵挡不住诱惑。在说法上作这么简单的一个变化就能显著改善健康食品的选择。

所以，下次需要避免说 yes 的时候，直接说“我不”。

另一个避免不必要活动的技巧是 20 秒规则：对于不应该做的事情多给自己 20 秒的时间考虑。

3、不要事必躬亲

我曾经管理过一个非常大的社区，试图一个人做完所有事情，最后发现我干不了。我筋疲力尽，最后社区接管了自我管理的工作。令人惊奇的是大家做得比我还好。我因而领悟到了社区的力量。

我们必须意识到，在需要的时候可以去寻求帮助，这一点很重要。让做得更好的人接管你的一些工作对你来说更好。这可以让你花更多的时间在自己最重要的任务上。不要把时间浪费在自己解决问题上，让专家帮助你。

很多时候，哪怕朋友不能帮你，他们的陪伴也能让你更有生产力。

4、不要完美主义

达尔豪斯大学的心理学教授 Simon Sherry 的完美主义与生产力研究发现，完美主义是生产力的绊脚石：

完美主义者完成任务需要花费更多的时间

完美主义者因此等待完美时刻而耽搁。就商业而言，如果你等到了完美时刻时间已经太迟。

完美主义往往因为一叶障目而不见泰山，因为过于关注小事情而错失了大场面。

最好的完美时刻就是现在。

5、不要做重复工

根据 Tethys Solution 的一项研究，一支 5 人团队，如果把 3%、20%、25%、30% 和 70% 时间花在重复性工作上，经过 2 个月的生产力强化（引入自动化软件）后，时间相应降至 3%、10%、15%、15% 和 10%。

现在只要我需要重复做一件事情 5 次以上，我就会要求自己找个程序来替我做。不会编程没关系，如果不懂开发，那就去买程序。

人们往往不记得时间就是金钱。他们手工做的原因通常是因为这么做比较容易，不需要研究。处理 30 张图片似乎没有问题，但是如果是 30000 张呢？你只能靠软件去处理了。记住，你需要花钱去挣钱，而时间是你最有价值的商品。

6、决策不靠猜测

如果网站可以 SEO，那么生活也能。不要靠胡乱猜测做决定，要用数据支持你的决策。

不同领域有许多研究可供参考。比方说，你是否知道下午 4 点的时候人最容易分心？这是宾州大学助理教授 Robert Matchock 领导的一项研究。哪怕你找不到需要的数据，进行分离测试也不需要话太多的时间。

要不断问问自己，你打算如何去衡量和优化自己所做的一切事情 ？

7、不要老是工作

大多数人没有意识到，如果我们过于专注在某件事情上，就会画地为牢，跳不出框框。时不时从工作中脱身出来独处一下非常重要。按照《孤独的力量》的说法，独处的时间对于大脑和精神很有益处：

哈佛研究表明，如果某人相信自己正在独自体验某件事情时，其记忆会更持久更精确。另一项研究表明，一定时间的独处可令人更具同理心。尽管没人会质疑早期过多的孤僻生活是不健康的，但一定时间的独处可令青少年改善情绪提高成绩。

给反省留点时间很重要。当我们不去寻找解决方案时，后者却往往不期而至。

当然，我们不能一夜之间就能变得更有生产力。跟生活中的每一件事情一样，这也需要努力。守株待兔是等不到变化的。我们都需要多了解自己的身体，找到精力分配的最佳方式，这样才能拥有更成功更幸福的生活。

虽然并非你编写的每个 Python 程序都要求一个严格的性能分析，但是让人放心的是，当问题发生的时候，Python 生态圈有各种各样的工具可以处理这类问题。

分析程序的性能可以归结为回答四个基本问题：

1. 正运行的多快
2. 速度瓶颈在哪里
3. 内存使用率是多少
4. 内存泄露在哪里

下面，我们将用一些神奇的工具深入到这些问题的答案中去。

用  time 粗粒度的计算时间

让我们开始通过使用一个快速和粗暴的方法计算我们的代码:传统的 unix  time 工具。

 $ time python yourprogram.py
real    0m1.028s
user    0m0.001s
sys     0m0.003s

三个输出测量值之间的详细意义在这里  stackoverflow article，但简介在这：

• real — 指的是实际耗时
• user — 指的是内核之外的 CPU 耗时
• sys — 指的是花费在内核特定函数的 CPU 耗时

你会有你的应用程序用完了多少 CPU 周期的即视感，不管系统上其他运行的程序添加的系统和用户时间。

如果 sys 和 user 时间之和小于 real 时间，然后你可以猜测到大多数程序的性能问题最有可能与  IO wait 相关。

用  timing context 管理器细粒度的计算时间

我们下一步的技术包括直接嵌入代码来获取细粒度的计时信息。下面是我进行时间测量的代码的一个小片段

timer.py

import time

class Timer(object):
    def __init__(self, verbose=False):
        self.verbose = verbose

    def __enter__(self):
        self.start = time.time()
        return self

    def __exit__(self, *args):
        self.end = time.time()
        self.secs = self.end - self.start
        self.msecs = self.secs * 1000  # millisecs
        if self.verbose:
            print 'elapsed time: %f ms' % self.msecs

为了使用它，使用 Python 的  with 关键字和  Timer 上下文管理器来包装你想计算的代码。当您的代码块开始执行，它将照顾启动计时器,当你的代码块结束的时候，它将停止计时器。

这个代码片段示例：

from timer import Timer
from redis import Redis
rdb = Redis()

with Timer() as t:
    rdb.lpush("foo", "bar")
print "=> elasped lpush: %s s" % t.secs

with Timer() as t:
    rdb.lpop("foo")
print "=> elasped lpop: %s s" % t.secs

为了看看我的程序的性能随着时间的演化的趋势，我常常记录这些定时器的输出到一个文件中。

使用  profiler 逐行计时和分析执行的频率

罗伯特·克恩有一个不错的项目称为  line_profiler , 我经常使用它来分析我的脚本有多快，以及每行代码执行的频率：

为了使用它，你可以通过使用  pip 来安装它：

pip install line_profiler

安装完成后，你将获得一个新模块称为  line_profiler 和  kernprof.py 可执行脚本。

为了使用这个工具，首先在你想测量的函数上设置  @profile 修饰符。不用担心，为了这个修饰符，你不需要引入任何东西。 kernprof.py 脚本会在运行时自动注入你的脚本。

primes.py

@profile
def primes(n): 
    if n==2:
        return [2]
    elif n<2:
        return []
    s=range(3,n+1,2)
    mroot = n ** 0.5
    half=(n+1)/2-1
    i=0
    m=3
    while m <= mroot:
        if s[i]:
            j=(m*m-3)/2
            s[j]=0
            while j<half:
                s[j]=0
                j+=m
        i=i+1
        m=2*i+3
    return [2]+[x for x in s if x]
primes(100)

一旦你得到了你的设置了修饰符  @profile 的代码，使用  kernprof.py 运行这个脚本。

kernprof.py -l -v fib.py

-l 选项告诉  kernprof 把修饰符  @profile 注入你的脚本， -v 选项告诉  kernprof 一旦你的脚本完成后，展示计时信息。这是一个以上脚本的类似输出：

Wrote profile results to primes.py.lprof
Timer unit: 1e-06 s

File: primes.py
Function: primes at line 2
Total time: 0.00019 s

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     2                                           @profile
     3                                           def primes(n): 
     4         1            2      2.0      1.1      if n==2:
     5                                                   return [2]
     6         1            1      1.0      0.5      elif n<2:
     7                                                   return []
     8         1            4      4.0      2.1      s=range(3,n+1,2)
     9         1           10     10.0      5.3      mroot = n ** 0.5
    10         1            2      2.0      1.1      half=(n+1)/2-1
    11         1            1      1.0      0.5      i=0
    12         1            1      1.0      0.5      m=3
    13         5            7      1.4      3.7      while m <= mroot:
    14         4            4      1.0      2.1          if s[i]:
    15         3            4      1.3      2.1              j=(m*m-3)/2
    16         3            4      1.3      2.1              s[j]=0
    17        31           31      1.0     16.3              while j<half:
    18        28           28      1.0     14.7                  s[j]=0
    19        28           29      1.0     15.3                  j+=m
    20         4            4      1.0      2.1          i=i+1
    21         4            4      1.0      2.1          m=2*i+3
    22        50           54      1.1     28.4      return [2]+[x for x

寻找  hits 值比较高的行或是一个高时间间隔。这些地方有最大的优化改进空间。

它使用了多少内存？

现在我们掌握了很好我们代码的计时信息，让我们继续找出我们的程序使用了多少内存。我们真是非常幸运， Fabian Pedregosa 仿照 Robert Kern 的  line_profiler 实现了一个很好的内存分析器  [memory profiler][5]。

首先通过 pip 安装它：

$ pip install -U memory_profiler
$ pip install psutil

在这里建议安装  psutil 是因为该包能提升  memory_profiler 的性能。

想  line_profiler 一样，  memory_profiler 要求在你设置  @profile 来修饰你的函数：

@profile
def primes(n): 
    ...
    ...

运行如下命令来显示你的函数使用了多少内存：

$ python -m memory_profiler primes.py

一旦你的程序退出，你应该可以看到这样的输出：

Filename: primes.py

Line #    Mem usage  Increment   Line Contents
==============================================
     2                           @profile
     3    7.9219 MB  0.0000 MB   def primes(n): 
     4    7.9219 MB  0.0000 MB       if n==2:
     5                                   return [2]
     6    7.9219 MB  0.0000 MB       elif n<2:
     7                                   return []
     8    7.9219 MB  0.0000 MB       s=range(3,n+1,2)
     9    7.9258 MB  0.0039 MB       mroot = n ** 0.5
    10    7.9258 MB  0.0000 MB       half=(n+1)/2-1
    11    7.9258 MB  0.0000 MB       i=0
    12    7.9258 MB  0.0000 MB       m=3
    13    7.9297 MB  0.0039 MB       while m <= mroot:
    14    7.9297 MB  0.0000 MB           if s[i]:
    15    7.9297 MB  0.0000 MB               j=(m*m-3)/2
    16    7.9258 MB -0.0039 MB               s[j]=0
    17    7.9297 MB  0.0039 MB               while j<half:
    18    7.9297 MB  0.0000 MB                   s[j]=0
    19    7.9297 MB  0.0000 MB                   j+=m
    20    7.9297 MB  0.0000 MB           i=i+1
    21    7.9297 MB  0.0000 MB           m=2*i+3
    22    7.9297 MB  0.0000 MB       return [2]+[x for x in s if x]

line_profiler 和  memory_profiler 的 IPython 快捷命令

line_profiler 和  memory_profiler 一个鲜为人知的特性就是在 IPython 上都有快捷命令。你所能做的就是在 IPython 上键入以下命令：

%load_ext memory_profiler
%load_ext line_profiler

这样做了以后，你就可以使用魔法命令  %lprun 和  %mprun 了，它们表现的像它们命令行的副本，最主要的不同就是你不需要给你需要分析的函数设置  @profile 修饰符。直接在你的 IPython 会话上继续分析吧。

In [1]: from primes import primes
In [2]: %mprun -f primes primes(1000)
In [3]: %lprun -f primes primes(1000)

这可以节省你大量的时间和精力,因为使用这些分析命令，你不需要修改你的源代码。

哪里内存溢出了？

cPython的解释器使用引用计数来作为它跟踪内存的主要方法。这意味着每个对象持有一个计数器，当增加某个对象的引用存储的时候，计数器就会增加，当一个引用被删除的时候，计数器就是减少。当计数器达到0， cPython 解释器就知道该对象不再使用，因此解释器将删除这个对象，并且释放该对象持有的内存。

内存泄漏往往发生在即使该对象不再使用的时候，你的程序还持有对该对象的引用。

最快速发现内存泄漏的方式就是使用一个由 Marius Gedminas 编写的非常好的称为  [objgraph][6] 的工具。
这个工具可以让你看到在内存中对象的数量,也定位在代码中所有不同的地方,对这些对象的引用。

开始，我们首先安装  objgraph

pip install objgraph

一旦你安装了这个工具，在你的代码中插入一个调用调试器的声明。

import pdb; pdb.set_trace()

哪个对象最常见

在运行时,你可以检查在运行在你的程序中的前20名最普遍的对象

pdb) import objgraph
(pdb) objgraph.show_most_common_types()

MyBigFatObject             20000
tuple                      16938
function                   4310
dict                       2790
wrapper_descriptor         1181
builtin_function_or_method 934
weakref                    764
list                       634
method_descriptor          507
getset_descriptor          451
type                       439

哪个对象被增加或是删除了？

我们能在两个时间点之间看到哪些对象被增加或是删除了。

(pdb) import objgraph
(pdb) objgraph.show_growth()
.
.
.
(pdb) objgraph.show_growth()   # this only shows objects that has been added or deleted since last show_growth() call

traceback                4        +2
KeyboardInterrupt        1        +1
frame                   24        +1
list                   667        +1
tuple                16969        +1

这个泄漏对象的引用是什么？

继续下去，我们还可以看到任何给定对象的引用在什么地方。让我们以下面这个简单的程序举个例子。

x = [1]
y = [x, [x], {"a":x}]
import pdb; pdb.set_trace()

为了看到持有变量 X 的引用是什么，运行  objgraph.show_backref() 函数：

(pdb) import objgraph
(pdb) objgraph.show_backref([x], filename="/tmp/backrefs.png")

该命令的输出是一个 PNG 图片，被存储在  /tmp/backrefs.png，它应该看起来像这样：

盒子底部有红色字体就是我们感兴趣的对象，我们可以看到它被符号 x 引用了一次，被列表 y 引用了三次。如果 x 这个对象引起了内存泄漏，我们可以使用这种方法来追踪它的所有引用，以便看到为什么它没有被自动被收回。

回顾一遍，objgraph 允许我们：

• 显示占用 Python 程序内存的前 N 个对象
• 显示在一段时期内哪些对象被增加了，哪些对象被删除了
• 显示我们脚本中获得的所有引用

Effort vs precision

在这篇文章中,我展示了如何使用一些工具来分析一个python程序的性能。通过这些工具和技术的武装，你应该可以获取所有要求追踪大多数内存泄漏以及在Python程序快速识别瓶颈的信息。

和许多其他主题一样,运行性能分析意味着要在付出和精度之间的平衡做取舍。当有疑问是，用最简单的方案，满足你当前的需求。

Python 性能分析入门指南，首发于 博客 - 伯乐在线。

根据美国退休研究中心发布的最新全国退休风险指数显示，目前有一半多的美国人没有存够足够的退休金。这已经不是什么新生现象，只不过从经济衰退以来，更为严重罢了。为什么美国人的退休金持续短缺？原因其实不难看出。

报告称，35岁的美国人如果想要晚年过得舒适，需要将15%的年薪作为养老金投入。低收入人群的养老金比例要低一些，但是无论如何，为了退休生活有保障，养老金是一定要交的。现在大多数的美国人养成了储蓄的习惯，他们有的是为了预防突发事件、教育、首付款、房屋改造等等原因。根据2010消费者金融调查的数据显示，只有53%的美国人完全不存任何钱，更别提15%的退休金储蓄了。

但是，15%的推荐储蓄率的基础是在65岁时退休。如果你觉得这个数字太高不能承受，没关系，只要工作到70岁，你每年只需要存年收入的6%。

延迟退休年龄的好处是双向的，一方面延长了储蓄养老金的年限，另一方面，减少了养老金的使用年限，一切看上去都很公平。其实65岁退休和70岁退休的区别，更在于养老保险。我们假设一个35岁的美国人，他一年能挣4.9万美元，这个数字在他这个年龄段属于中等水平。如果他65岁退休，每年能从养老保险中得到18200美元；70岁退休，一年就有26500美元，增幅达到45%。

把钱放在养老保险里，回报比储蓄和投资更高。如果放在401(k)基金和个人养老账户(IRA)里，钱会随着市场行情的涨跌而涨跌，所以不建议美国人这样做。国家养老保险只看工资水平，不看市场行情。——专家建议说。

美国专家也表示，推迟退休年龄也有风险。70岁之前你能不能保证正常的工作能力还不一定，不但失业的风险提高，在工作中患病或残疾的风险也大大提高。特别是对身体要求较高的工作岗位和新入职工资较低的岗位。

但是美国专家还是建议大家推迟退休，因为好处要比坏处多——存钱压力小，能花的钱也多了。蛤蛤蛤

[ 王大发财 via Businessweek]

尽管个性化阅读软件“ 今日头条”此前面临来自《新京报》、搜狐等合作媒体以及国家版权局的压力，但作为一家新闻资讯推荐公司，北京旭宁信息技术有限公司CEO徐屾屾认为，“从其产品来说，今日头条推荐的新闻还是很准确。”

徐屾屾的团队一起合作了很多年，这是一个有多年开发经验的老团队。2009年初，他们做的第一款手机应用Daily Finance iPhone App就成为美国最受欢迎的金融应用，之后又连续做了4款游戏。这些产品都在全球下载榜上长期保持不错的成绩。之后，这个团队开始做开发外包，开发了不少知名的产品，业务一直做得顺风顺水。2012年初，他们停止了外包业务，开始专注于产品研发。

“ 品读”是徐屾屾的团队开发的一款全新理念的个性化阅读类产品，这款产品的iPad，iPhone及网站版已经上线，并且推出了相应的浏览器插件。

尽管都主推个性化阅读，但品读的推荐机制并非完全基于类似今日头条所用的“大数据”。在徐屾屾看来，机器推荐可以算出用户的兴趣，但很难算出内容本身的品质。

品读更像是一个基于内容的Zaker跟Pocket的合体。品读的内容主要来自用户收集，部分来自合作媒体。

品读的文章被聚合在一个个代表不同主题的本子里，它们由用户创建，由用户整理。用户在品读里可以按照兴趣阅读这些本子，同时可以使用品读在移动端、PC端将喜欢的文章收集到本子里，创建新的本子，而品读会将这其中的精品按照大家的阅读兴趣推荐给用户。

基于移动端的阅读需求很大。根据CNNIC发布的第34次《中国互联网络发展状况统计报告》，从2013年12月到2014 年 6 月，网络新闻用户规模超过5亿，使用率达到79.6%。时下最为热门的手机资讯软件 今日头条发布的数据显示，其日活跃用户有1300多万，月度活跃用户4000万，下载并启动过手机的累计激活数据是1.2亿。

品读的用户都是多大年纪的？

品读的用户年龄分布很广泛，从17、18岁到40多岁都有。用户创建的本子从情感类美文到中国文字字体研究应用尽有。有一个名为“蒸汽博客”的本子，主要是收集蒸汽朋克的内容，这位本子的主人是一位文身师。

今日头条已经做得很好了，你为什么还要做一个？

跟今日头条提供新闻不同，品读上提供的新闻很少。我们希望给用户提供能沉淀下来的内容。坚持看10年新闻可能也不会有太大收获。我们的产品相当于一个内容众包版的Flipboard。

你的内容主要来自用户收集，用户真的有收集的欲望吗？

这其实是还原了一种古老的需求。以前收集剪报，只是现在放到手机、电脑上且能分享。

除了从网上收集之外，PC版的品读还提供博客功能，供用户发布自己原创的内容。用户可以通过这些资讯结识自己最想认识的人。在没有社交功能的情况下，用户的收集不会产生价值。

你的盈利模式是怎样的？

品读的盈利模式跟今日头条、Flipboard一样，瞄准的是广告主。不过，品读提供的广告方式可能不只是目前普遍的横幅模式。我更希望能切入主题类广告，这类广告占据广告界利润的最大比例。

采访手记

品读从今年6月上线至今，已得到了大量用户的认可。徐屾屾介绍，“每个人的兴趣都有很多，因此一个用户可能就有几个不同兴趣点的本子。”

让用户订阅其他用户的本子，除了为用户提供精品内容以外，这也是激励用户收集本子的一个动力。一些用户在用过一段时间Pocket之后，便再也不会点开也很少分享。徐屾屾认为，这正是因为Pocket只利于收集，不利于分享传播，在没有社交功能的情况下，用户的收集不会产生价值。

徐屾屾自己就是一个典型的用户案例。他在品读上建立了一个关于科技新闻的本子，在演示如何使用本子收集资讯时，他突然说了一句：“不能随便收集，这体现我的品味。”

本文 品读：与今日头条反向而行来自 动点科技.

python 代码自动生成的方法 （代码生成器）

遇到的问题

工作中遇到这么一个事，需要写很多C++的底层数据库类，但这些类大同小异，无非是增删改查，如果人工来写代码，既费力又容易出错；而借用python的代码自动生成，可以轻松搞定；
（类比JAVA中的Hibernate自动生成的数据库底层操作代码）
下面介绍使用python字符串替换的方法；

Python字符串替换的几种方法

1. 字符串替换
将需要替换的内容使用格式化符替代，后续补上替换内容；

template = "hello %s , your website  is %s " % ("大CC","http://blog.me115.com")
print(template)

也可使用format函数完成：

template = "hello {0} , your website  is {1} ".format("大CC","http://blog.me115.com")
print(template)

注：该方法适用于变量少的单行字符串替换；

2. 字符串命名格式化符替换
使用命名格式化符，这样，对于多个相同变量的引用，在后续替换只用申明一次即可；

template = "hello %(name)s ，your name is %(name), your website  is %(message)s" %{"name":"大CC","message":"http://blog.me115.com"}
print(template)

使用format函数的语法方式：

template = "hello {name} , your name is {name}, your website  is {message} ".format(name="大CC",message="http://blog.me115.com")
print(template)

注：适用相同变量较多的单行字符串替换；

3.模版方法替换
使用string中的Template方法；

from string import Template
tempTemplate = string.Template("Hello $name ,your website is $message")
print(tempTemplate.substitute(name='大CC',message='http://blog.me115.com'))

有了模版方法后，就可以将模版保存到文件单独编辑，在生成的地方替换为需要的变量；

示例：代码生成

这个示例使用以上讲到的第三种方法；
建立一个模版文件，里面需要替换的内容使用${}变量替换;
dao_cpp.template

///
/// @class ${CLASSNAME}
/// @brief Redis底层接口类 操作${TABLE_NAME}表
/// TABLE ${TABLE_NAME_UPPER}
/// @author dao_cpp_generator.py
/// @generate date: ${GENE_DATE}
/// [注：本文件为自动生成，不需要人为编辑，若有修改，请通过配置py脚本来重新生成.]

#include "${CLASSNAME}.h"
#include "include/${TABLE_NAME}_t.h"
#include "RedisManager.h"
#include "common/LogMacros.h"
#include "common/StringUtility/OtherStringFunc.h"
#include "common/DateTime.h"

namespace redisdao{

#define PRIMARY_KEY "${PRIMER_KEY}"
const string ${CLASSNAME}::TABLE_NAME = "${TABLE_NAME}";
const string ${CLASSNAME}::TABLE_ID = "${TABLE_ID}"; //在数据库中的表的唯一性标识符
const string ${CLASSNAME}::KEY_SEPARETER = "${KEY_SEPARETER}";

${CLASSNAME}::${CLASSNAME}(void)
{
    if ( 0 == m_reHandler.EnsureConnect())
        m_bRedisConnected = true;
    else
        m_bRedisConnected = false;
}

${CLASSNAME}::~${CLASSNAME}(void)
{
}

int ${CLASSNAME}::InsertRecord(const string& strVal)
...

python代码生成程序：
cpp_generator.py

#! /usr/bin/env python
#coding=utf-8
#Redis底层操作类CPP文件生成程序（*RedisDao.cpp)
#author me115@126.com 2014-7-22
import os,sys,re,traceback
from datetime import datetime
from string import Template

class DaoCppGenerator:

    def generate(self):
        tableName = 'students'
        className = '%sRedisDao' %  tableName.capitalize()
        filePath = r'include/%s.cpp' % className
        class_file = open(filePath,'w')

        lines = []

        #模版文件
        template_file = open(r'dao_cpp.template','r')
        tmpl = Template(template_file.read())

        #模版替换
        lines.append(tmpl.substitute(
                    CLASSNAME = className,
                    TABLE_NAME = tableName,
                    TABLE_NAME_UPPER = tableName.upper(), 
                    GENE_DATE = datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                    TABLE_ID = '115',
                    EXPIRE_DATE = '06JUN14'))

        # 0.将生成的代码写入文件
        class_file.writelines(lines)
        class_file.close()

        print 'generate %s over. ~ ~' % filePath

有了这个程序，再配合一堆XML配置文件，就可以轻松生成各种C++程序代码了；

Posted by: 大CC | 25JUL,2014
博客： blog.me115.com [ 订阅]
微博： 新浪微博

网友的问题：

1.MySQL对于int类型索引使用问题，如：tb中有主键id，普通索引tid，在执行SQL：select * from tb where id = 2 order by id 时，
extra为空，这里的id值没带引号，如果带上引号extra也为空。

2.当 select * from tb where tid = 2 order by tid，tid为普通索引，这时tid的值带引号和不带引号就会有区别，带引号时extra会提示额外的排序，不带引号时extra为空，这是怎么一回事？

mysqlops的回答：

1.当字段类型为：INT；

2. 传入的值为：字符串类型；

3.WHERE条件中的整型字段的传入值用单引号或双引号；

上述描述的前提条件下，会对把传入的 值类型 转换为 字段定义的数据类型，故WHERE 条件是可以使用到索引的，但从数据

库表读出到内存块后的值会被 转换为 传入值的数据类型，从而导致ORDER BY无法使用到索引解释为何ORDER BY ID没有外

部排序 或extra的内容为空，那是因为WHERE ID=’2′ 按主键查询只能查到唯一的一条记录，故不需要排序；

ORDER BY tid 时，WHERE tid=’2′ 按普通索引去查找的话，能查找到的数据条数会大于1条，加上数据类型隐形转换了，为

此需要再额外进行排序和extra部分有内容显示；

总结：

数据库中要尽量避免发生数据隐形转换的危险，极端情况下可能会发生偶尔的WHERE条件都无法使用到索引，故开发规范

非常重要。

成功后出现：打印出来，你所要打印的字符。

package com.clq.hdfs;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.util.Progressable;

public class FileCopyWithProgress {
//********************************
//把本地的一个文件拷贝到hdfs上
//********************************
	public static void main(String[] args) throws IOException {
		String localSrc = args[0];
		String dst = args[1];
		InputStream in = new BufferedInputStream(new FileInputStream(localSrc));
		Configuration conf = new Configuration();
		FileSystem fs = FileSystem.get(URI.create(dst), conf);
		FSDataOutputStream out = fs.create(new Path(dst), new Progressable() {
			@Override
			public void progress() {
				System.out.print(".");
			}
		});
		IOUtils.copyBytes(in, out, conf, true);
	}

}

• —软件人才免语言低担保 赴美带薪读研！—

• —软件人才免语言低担保 赴美带薪读研！—

CAP理论被很多人拿来作为分布式系统设计的金律，然而感觉大家对CAP这三个属性的认识却存在不少误区。从CAP的证明中可以看出来，这个理论的成立是需要很明确的对C、A、P三个概念进行界定的前提下的。在本文中笔者希望可以对论文和一些参考资料进行总结并附带一些思考。

一、什么是CAP理论

CAP原本是一个猜想，2000年PODC大会的时候大牛Brewer提出的，他认为在设计一个大规模可扩放的网络服务时候会遇到三个特性：一致性（consistency）、可用性（Availability）、分区容错（partition-tolerance）都需要的情景，然而这是不可能都实现的。之后在2003年的时候，Mit的Gilbert和Lynch就正式的证明了这三个特征确实是不可以兼得的。

二、CAP的概念

Consistency、Availability、Partition-tolerance的提法是由Brewer提出的，而Gilbert和Lynch在证明的过程中改变了Consistency的概念，将其转化为Atomic。Gilbert认为这里所说的Consistency其实就是数据库系统中提到的ACID的另一种表述：一个用户请求要么成功、要么失败，不能处于中间状态（Atomic）；一旦一个事务完成，将来的所有事务都必须基于这个完成后的状态（Consistent）；未完成的事务不会互相影响（Isolated）；一旦一个事务完成，就是持久的（Durable）。

对于Availability，其概念没有变化，指的是对于一个系统而言，所有的请求都应该‘成功’并且收到‘返回’。

对于Partition-tolerance，所指就是分布式系统的容错性。节点crash或者网络分片都不应该导致一个分布式系统停止服务。

三、基本CAP的证明思路

CAP的证明基于异步网络，异步网络也是反映了真实网络中情况的模型。真实的网络系统中，节点之间不可能保持同步，即便是时钟也不可能保持同步，所有的节点依靠获得的消息来进行本地计算和通讯。这个概念其实是相当强的，意味着任何超时判断也是不可能的，因为没有共同的时间标准。之后我们会扩展CAP的证明到弱一点的异步网络中，这个网络中时钟不完全一致，但是时钟运行的步调是一致的，这种系统是允许节点做超时判断的。

CAP的证明很简单，假设两个节点集{G1, G2}，由于网络分片导致G1和G2之间所有的通讯都断开了，如果在G1中写，在G2中读刚写的数据， G2中返回的值不可能G1中的写值。由于A的要求，G2一定要返回这次读请求，由于P的存在，导致C一定是不可满足的。

四、CAP的扩展

CAP的证明使用了一些很强的假设，比如纯粹的异步网络，强的C、A、P要求。事实上，我们可以放松某些条件，从而达到妥协。

首先 —— 弱异步网络模型

弱异步网络模型中所有的节点都有一个时钟，并且这些时钟走的步调是一致的，虽然其绝对时间不一定相同，但是彼此的相对时间是固定的，这样系统中的节点可以不仅仅根据收到的消息来决定自己的状态，还可以使用时间来判断状态，比如超时什么的。

在这种场景下，CAP假设依旧是成立的，证明跟上面很相似。

不可能的尝试 —— 放松Availability或者Partition-tolerance

放弃Partition-tolerance意味着把所有的机器搬到一台机器内部，或者放到一个要死大家一起死的机架上（当然机架也可能出现部分失效），这明显违背了我们希望的scalability。

放弃Availability意味着，一旦系统中出现partition这样的错误，系统直接停止服务，这是不能容忍的。

最后的选择 —— 放松一致性

我们可以看出，证明CAP的关键在于对于一致性的强要求。在降低一致性的前提下，可以达到CAP的和谐共处，这也是现在大部分的分布式存储系统所采用的方式：Cassandra、Dynamo等。“Scalability is a bussness concern”是我们降低一致性而不是A和P的关键原因。

Brewer后来提出了BASE ( Basically Available, Soft-state, Eventually consistent)，作为ACID的替代和补充。

五、战胜CAP

1，2008年9月CTO of atomikos写了一篇文章“ A CAP Solution (Proving Brewer Wrong)”，试图达到CAP都得的效果。

这篇文章的核心内容就是放松Gilbert和Lynch证明中的限制：“系统必须同时达到CAP三个属性”，放松到“系统可以不同时达到CAP，而是分时达到”。

Rules Beat CAP:

1) 尽量从数据库中读取数据，如果数据库不能访问，读取缓存中的数据

2) 所有读都必须有版本号

3) 来自客户端的更新操作排队等候执行，update必须包括导致这次更新的读操作的版本信息

4) 分区数量足够低的时候排队等待的update操作开始执行，附带的版本信息用来验证update是否应该执行

5) 不管是确认还是取消更新，所有的结构都异步的发送给请求方

证明：

1) 系统保证了consistency，因为所有的读操作都是基于snapshot的，而不正确的update操作将被拒绝，不会导致错误执行

2) 系统保证了availability，因为所有的读一定会返回，而写也一样，虽然可能会因为排队而返回的比较慢

3) 系统允许节点失效

缺点：

1) 读数据可能会不一致，因为之前的写还在排队

2) partition必须在有限的时间内解决

3) update操作必须在所有的节点上保持同样的顺序

2， 2011年11月Twitter的首席工程师Nathan Marz写了一篇文章，描述了他是如何试图打败CAP定理的： How to beat the CAP theorem

本文中，作者还是非常尊重CAP定律，并表示不是要“击败”CAP，而是尝试对数据存储系统进行重新设计，以可控的复杂度来实现CAP。

Marz认为一个分布式系统面临CAP难题的两大问题就是：在数据库中如何使用不断变化的数据，如何使用算法来更新数据库中的数据。Marz提出了几个由于云计算的兴起而改变的传统概念：

1) 数据不存在update，只存在append操作。这样就把对数据的处理由CRUD变为CR

2) 所有的数据的操作就只剩下Create和Read。把Read作为一个Query来处理，而一个Query就是一个对整个数据集执行一个函数操作。

在这样的模型下，我们使用最终一致性的模型来处理数据，可以保证在P的情况下保证A。而所有的不一致性都可以通过重复进行Query去除掉。Martz认为就是因为要不断的更新数据库中的数据，再加上CAP，才导致那些即便使用最终一致性的系统也会变得无比复杂，需要用到向量时钟、读修复这种技术，而如果系统中不存在会改变的数据，所有的更新都作为创建新数据的方式存在，读数据转化为一次请求，这样就可以避免最终一致性的复杂性，转而拥抱CAP。

具体的做法这里略过。

总结：

其实对于大规模分布式系统来说，CAP是非常稳固的，可以扩展的地方也不多。

它很大程度上限制了大规模计算的能力，通过一些设计方式来绕过CAP管辖的区域或许是下一步大规模系统设计的关键。

————— 参考文献 ———————–

[1] Seth Gilbert and Nancy Lynch. 2002. Brewer’s conjecture and the feasibility of consistent, available, partition-tolerant web services. SIGACT News 33, 2 (June 2002), 51-59. DOI=10.1145/564585.564601 http://doi.acm.org/10.1145/564585.564601

[2] Guy Pardon, 2008, A CAP Solution (Proving Brewer Wrong), http://blog.atomikos.com/2008/09/a-cap-solution-proving-brewer-wrong/

[3] Werner Vogels, 2007, Availability & Consistency, http://www.infoq.com/presentations/availability-consistency

[4] Nathan Marz, 2011, How to beat the CAP theorem, http://nathanmarz.com/blog/how-to-beat-the-cap-theorem.html

　　据路透社 报道，苹果近日首次承认可以通过未公开的技术，提取用户个人深层数据，包括短信、联系人列表和图片等。技术人员可以将设备连接到“受信任”的电脑，从而绕开备份加密，在用户不知情的前提下，轻松进入联网的iPhone手机。专家表示，窃取用户信息的行为严重侵犯人权，危害全球网络安全。

　　安全专家Jonathan Zdziarski近日在纽约举办的黑客大会上，展示了如何利用存在于iOS系统的“后门”，从苹果iPhone中提取大量数据。Jonathan Zdziarski说，提取数据过程中，iPhone用户并不知情，而且无法禁用。这一发现，引发业界关于苹果是否与美国国家安全局合作的猜测。

　　苹果否认为情报机构创建了任何“后门”。

　　苹果回应称，公司设计这一功能，是向企业IT部门、开发者和苹果维修人员提供所需信息；但在获取受限数据前，需要用户解锁设备，同时需要在iPhone上点击“信任”某一台电脑，以获得电脑的授权，经过授权后的电脑也只能访问有限的诊断数据，苹果并没有为任何情报部门创建“后门技术”。

　　Jonathan Zdziarski表示，他不相信苹果的这项服务是用于间谍用途，但是他表示，苹果提取的信息比公开披露的要多很多。

　　安全分析师Rich Mogull表示，Zdziarski的说法其实言过其实，但从技术上看是准确的。他表示，苹果收集超出许可的这些信息应该是为了安全性的妥协。

　　Mogull也认同Zdziarski的一些观点，如果苹果的后门工具存在，那么执法者将这个工具用于那些针对个人被没收的台式电脑，从里面拿到一些数据，这也许会为他们创造法律上的优势。

　　苹果公司对于是否存在这种提供给执法者使用的工具，并没有立即回应。

　　此前苹果手机被广泛地认为比其竞争对手谷歌的Android系统更为安全，因为苹果能够经常发布BUG修复补丁，而谷歌并没有权限直接发送软件补丁到指定的设备。

评论《苹果被曝提取iPhone个人数据》的内容...

相关文章:

• 移动应用被苹果官方推荐的秘密
• 用户投诉苹果预装软件不能删除
• 苹果回应央视质疑苹果搜集用户隐私
• 从HealthKit看iOS发展趋势
• 越狱对iOS 7份额影响很小

《富足》作者为人类的未来描绘了一幅激动人心的美好愿景，之前我们谈到人与科技的关系、实现富足的4大力量，那么对未来发展影响力最大的核心领域都有什么？这是各行各业最关注的话题。

一、工业互联网的建立

大量的人工智能和大量的传感器的运用，使得我们对工厂的控制，工厂和工厂之间的协作，以及工厂的柔性制造都达到前所未有的水平。我们在跟美国一些机构沟通一个设想，希望通过工业互联网的控制，让世界上每一个创新者都拥有中国的工厂，任何一个不管多么疯狂的主意，都可以用设计软件传到车间上生产，产量要多少有多少，让任何一个小公司都可以瞬间变成大公司，因为在未来的开放式创新进程中，小公司才是真正的主导者。这也许会成为我们中国成为人类富足贡献者的大机遇。

二、纳米科技

国内发展纳米技术的方式，一向是从国外挖优秀的人才。但是往往人才回到国内，受科研环境等因素的影响，科研成果会减少很多。将人才放在国外更适合他们做学术研究的土壤中培养，然后能将成果输出到国内就好。对于纳米技术，我们目前的程度距繁荣还早得很，因此还是需要嫁接在全球科研的生态体系上。

三、生物技术和生物信息

基因工程、基因组测序是最典型的例子，人类2003年才完成对一个人的完整基因组测序，我们人类所有的基因组在03年才知道，到今天十年的时间就做到了什么地位了？《富足》这本书就是讲的这个故事。对一个人的基因组完成测序大概需要1到2周的时间，5000美金，有人预测在五年之内这个数可能就降到500美金了，就意味着我们每个人对自己的了解有空前的增加，小孩一生出来就知道他可能在50岁的时会得心脏病，有了预防措施，人类的寿命会得到大幅度延长，长命百岁就不再只是美好的愿望。

四、神经科学的突破

过去30年神经科学有一个最大的突破，它叫做神经可塑性，我们以前认为，人一过了青春期，大脑的所有结构都固定了，如果某一部分坏死了也没有办法将它替换掉。如今这不是不可能的事，神经可塑性的一位创始人有个特别传奇的故事，他的父亲是美国很著名的诗人，突然有一天中风瘫痪了。家人为了帮他重新站起来，把老人接回家，让他像一个婴儿一样学习爬行。最开始他们甚至遭到邻居投诉，认为他们虐待老人。然而三年时间过去，老人从爬到坐，从走到跑，都恢复了正常。儿子看到爸爸的病情很受触动，就去学了医。父亲去世后，他请一个朋友给爸爸做了解剖，结果非常惊人——老人的的脑干97%坏死，按理说应该终身瘫痪，但是为什么恢复了？肯定是大脑的其他部分替代了他的功能，后来他就成为了神经可塑性最早的发现人之一。

除此之外他还提出，是否可以利用大脑可塑性，让身体其他器官代替受损伤的大脑功能？答案是，盲人真的能通过舌头看到世界了。我们的眼睛把外部的光信号输送进大脑视神经后，再转换成电信号，然后由我们大脑的电去解读。盲人看不见了是因为光电转换的部门失灵了，而大脑依然能解读，那么只要在体外完成光电转换就可以了。所以他用一个摄像头来采集光线，然后用计算机进行光电转换，这个时候，人的舌头代替了眼睛，将有电信号的电片含在舌头上。由于大脑的神经可塑性，当视觉区是空白的时候，舌头传进来的信号就能到视觉区做处理，这样盲人就能看到外部世界了。我们可以在网上查到一个产品叫做BrainPort，那个演示一定让你震惊——一个全盲的人戴着眼镜可以在屋里走，可以绕开桌椅障碍物，可以识别标志，可以跟小孩玩猜拳。我们特别有幸跟这个产品签了投资协议，会成为他在中国的投资人。

五、社交网络

如今我们能通过网络的算法做大数据预测，美国人靠大数据成功的预测了股票的大趋，他们通过监测推特上一些关键词提及的数量涨跌的数据，就能够预测大趋。哪个词是最标志性的呢？是calm，它高频出现意味着整个社会相对比较平静，这个时候股市就涨，这个词出现得少了，人心就相对浮躁一些，股市就会下跌。它能够预测一周的股市行情，准确率达80%。

六、电力新能源

英剧《黑镜》中关于无线充电的预言

我想用一个例子说明，叫做远程通电。我们都知道特斯拉还需要拿插销去充电，可是如果忘了拿插销就开出去，或者回家忘了充电第二天开不走，怎么办？最好的方式是车开在路上，就能自动充电。现在已经有了充电盘，只要把手机放在上面就能开始充电，还有超距离的远程充电，在屋里架一个设备，在一定范围内，所有用电设备都能不用电线进行对充。

现在很多交通监测用无人直升机，但它的飞行时间是有限的，但如果我是远距离的点对点供电，无人直升机就能永远飞着。因此未来的电力能源是革命性的，而且有巨大的市场。

未来我们的投资、教育等等的发展都应该密切关注这六个核心领域。《富足》一书所体现的正是今日美国的主流思想，绘出了一幅通向未来的地图。我们要实现富足就得走出去，去看看那些机会是不是真的存在，并且还要努力把机会拿回来，真正参与到富足的进程中去。

来源：湛卢文化

猜您喜欢：
观点 | 未来是“人人合作，人机协作”的时代——王煜全系列演讲（一）	观点 | 未来人类实现“富足”的四大力量——王煜全系列演讲（二）	观点 | 发挥创造力，带着机器往前走——王煜全系列演讲（三）	旅游业二级市场商机，Roomer帮用户拿回取消酒店房间的预付款	杀价王，抓住消费心理的拍卖网站
无觅

本文版权属于- 商业不靠谱 Bukop.com -转载请务必保留版权信息。
商业不靠谱（bukop.com）致力于汇聚全球新兴的商业模式与创新趋势，在全球范围内整合优秀商业创意和案例，并将这些好点子提供给具有企业家头脑的创业者，以及对创新和挖掘新商机有兴趣的朋友。

• —软件人才免语言低担保 赴美带薪读研！—

整洁的代码

*参考自: http://techbus.safaribooksonline.com/book/software-engineering-and-development/agile-development/9780136083238

安全

*参考自: http://www.oracle.com/technetwork/java/seccodeguide-139067.html

性能

*参考自: http://techbus.safaribooksonline.com/book/programming/java/9780137150021

综合(译者注：原文中的作者把checklist和category对应的列搞错了，译文中已修正)

*参考自: http://techbus.safaribooksonline.com/book/programming/java/9780137150021

静态代码分析

可能感兴趣的文章

• Java异常有多慢？
• Eclipse 教程系列
• Log4j 2 介绍
• JVM函数式编程资源
• JMS 2的新特性
• JDBC性能小贴
• 避免Java应用中NullPointerException的技巧和最佳实践
• 讲故事，学（Java）设计模式—观察者模式
• Java垃圾回收精粹 — Part4
• Servlet 3特性：异步Servlet

• —软件人才免语言低担保 赴美带薪读研！—

自从答应简二毛博士将自己的机器学习历程和心得分享给大家至今，转眼间半年已经过去了，感谢简博士分享和开源精神的鼓舞，这也正是本系列关于机器学习介绍博客的动力来源。

之前有些网友，师弟们问我，学习机器学习怎么入手，从看什么书开始。这里说一下个人见解：

如果你只愿意看一本书，那么推荐Bishop的PRML，全名Pattern Recognition and Machine Learning. 这本书是机器学习的圣经之作，尤其对于贝叶斯方法，介绍非常完善。该书也是众多高校机器学习研究生课程的教科书，如Deep Learning的开山鼻祖Hilton在多伦多大学教授机器学习课程（CSC2515）时也选择了这本书。该书电子版在Bishop个人网页提供直接下载。不过提前说明一下，这本书如果看了半年，看完三遍才能理解透，也属于正常。第一遍看不懂很正常，所以需要持之以恒。

http://research.microsoft.com/en-us/um/people/cmbishop/prml/

第二本书就是ESL(The Elements of Statistical Learning)。中文翻译叫统计学习基础，其实这个翻译不够准确，Statistical Learning并非statistics，叫机器学习基础更加准确。该书数学推导，理论系统很完备，结合后面的exercise用R语言自己联系一下，对于理解机器学习的基本方法很有帮助，如：Logistic，Ridge regression等。这本书同样可以在作者网站上直接下载到电子版。

http://statweb.stanford.edu/~tibs/ElemStatLearn/

有了理论基础，再结合一些教授的课程进行学习，效果更好。目前很流行的斯坦福大学机器学习公开课，在网易公开课中甚至都有中文版字幕出来，是非常不错的入门教程。不过个人更喜欢Hilton的机器学习课程。因为你看了上述两本书之后，基础知识基本都OK了，再看Stanford公开课还是基础。而Hilton的课程更加贴近目前的学术研究热点，比如对于Neural network，Deep Belief Nets的介绍，他的课程中包括了最早期的RBM的实现 http://www.cs.toronto.edu/~hinton/MatlabForSciencePaper.html 。值得一看。他老人家的课程地址： http://www.cs.toronto.edu/~hinton/csc2515/lectures.html 特别推荐做一做其中的assignments： http://www.cs.toronto.edu/~hinton/csc2515/assignments.html

下面说一下数据集，孔子云“学而时习之”，光说不练是学习的大忌，练习就需要数据集，配合上述课程的数据集是mnist data， http://yann.lecun.com/exdb/mnist/ 这个链接中也可以看到众多大牛在该数据集上的突破。

本系列机器学习之路的内容主要参考来源于：PRML，ESL和Hilton CSC2515。

关于软件，是使用Matlab还是R。很难说哪个软件好，哪个不好，只有适不适合自己。R更适合做学术研究，有众多的包和data可以使用，方便快速地实现自己的算法原型。不管是在内置函数的数量还是质量上，尤其处理大量数据时R的确要强于Matlab。同时R还有CRAN，里面基本可以找到绝大多数我们需要的算法，介绍，教程等。

而Matlab强项在于矩阵运算，Matlab也有很多工具箱，里面的算法相对很成熟，Matlab的图形绘图性能也强于R。

二者的区别其实在于商业软件和自由软件的区别。Matlab庞大，成熟，美观，官方文档齐全，当然还有价格不菲。R免费，论坛强大，算法包更新快，紧贴研究的最前沿等等。当然二者可以相互转换，我记得Matlab有执行R语言程序的工具箱，同样R也有运行Matlab程序的包。

总结就是工程人员，更适合Matlab，学术研究还是用R更自由。详细的对比

http://www.math.umaine.edu/~hiebeler/comp/matlabR.pdf

机器学习方法

谈到机器学习，一堆概念和方法很容易混淆，比如：VC dimension， least squares， maximum likelihood maximum conditional likelihood，maximum penalized (conditional) likelihood，back propagation，Recurrent networks，Newton and Quasi-Newton Methods，Conjugate Gradients，Constrained Optimization，Mixtures of Experts，Hierarchical mixtures of experts EM Algorithm，PCA, Factor Analysis , Independent Components Analysis，Deep Belief Nets，Restricted Boltzmann Machines，Markov Chain Monte Carlo，Gibbs Sampling，Kernel Methods，kernel density，Association Rules Apriori，Sparse Kernel Machines，Graphical Models

Approximate Inference 等等。

在分类这些方法之前，首先描述一下几个概念：

1. 回归和分类(Regression and Classification), 给定一组输入X和输出Y的数据集S，我们通过回归或者分类方法来拟合数据集S，得到拟合模型F, 当有新的数据输入Xi时,通过拟合模型F来预测输出Yi的值。
2. 求解方法：在上述拟合模型F的过程中，我们怎么知道什么样的模型是好的，什么样的模型是不好的呢，那么就需要评价函数，有了评价函数之后，我们就需要对该评价函数进行参数求解，使得我们的误差最小，注意，这里的误差最小是针对训练集的数据。
3. 校验方法：通过上述求解方法得到了我们的求解出的拟合模型F，那么在真实数据中，是否也能够实现误差最小化呢，这里的误差最小是针对真实的测试数据，这个时候我们就需要使用校验方法。
4. 有些数据集，我们预先知道，或者预先假设好它的分布模型，再进行模型拟合，这个过程叫做有监督的学习（或者针对给定的输入，我们又给定的输出与之相对应）。比如，中国男生身高分布，我们预先设定好其为高斯分布，再进行参数拟合，或者对不同收入阶层的人进行购买力的统计和预测，我们预先假设其满足线性可分，采用线性分类方法，这些都属于有监督的学习。无监督的学习是指给定一组输入，我们没有预先设定的输出和预先设定的模型分布。根据输入变量内在关系进行学习的方法。典型的就是聚类，统计出一组用户的购买物品参数，根据这些参数对用户进行聚类分析，得出其属于重度购买用户还是轻度用户等等。还有如关联规则学习中著名的啤酒与尿布apriori 算法都属于非监督学习算法。
5. 数据加工方法：如今一个炒作非常火爆的一个概念叫做大数据，凡是和统计学沾边的都自称做大数据的，一个很小的互联网网址做后来数据处理的，也自称做大数据的，如今的社会风气实在让人无语，忍不住吐槽一下。回到正题，当数据量很大，部分数据不够完整，数据维数很高的时候，我们就需要借助于强有力的数据加工方法，其中包括提取有效的主成分，提取相似度高的输入因子等等。
6. 数据采集方法Sampling：现代计算机的方法，使得产生随机数几乎不需要成本，这就导致了Sampling方法的重大突破。当我们一直模型分布的时候，进行数据采集很方便，预先设定好模型，进行计算机随机数采集跳转获得相应的分布数据即可。但是当模型很复杂，或者我们根本不知道是什么模型的时候，很难适应计算机预先设定好模型进行采集，那么，我们如何获得和真实数据项一致的分布数据进行学习计算呢，这个时候就需要我们的Sampling方法派上用场了。

有了上述基本概念之后，我们就对一堆机器学习的概念机械归纳和分类：

1. 回归和分类模型有：Liner  regression，Logistic regression, Ridge regression, Lasso, Linear Discriminant Analysis，Basis Expansions，Smoothing Splines, Kernel Methods, Additive Models, Trees，Nearest-Neighbors Methods, SVM 等等，这些只是大致的方法，里面还包括了各种细致的算法，如Trees中包括 Classification trees, Random Forest 等等
2. 求解方法：最常见的Least Square，在这上面依次有maximum likelihood，EM, Gradient Descent等。其中Gradient Descent又包括Classic Newton methods， Quasi-Newton Methods等等。
3. 校验方法最常见是交叉验证（Cross Validation），其中包括留一验证（LOOCV）,K-Fold CV, Boostrap 等等。
4. 无监督的学习方法主要有：关联规则，聚类，自组网，主成分分析，因子分析，独立成分分析，已经如今很热门的Page Rank, deep Learning都属于无监督学习的一种。大多是的分类和回归模型都是有监督的学习或者半监督的学习。
5. 数据加工的方法主要有： 如收缩法的Ridge regression , Lasso, 降维法的PCA，ICA特征提取的因子分析等
6. 数据采样方法有：Bagging，Boosting，MCMC（Markov Chain Monte Carlo）, Gibbs Sampling等
7. 神经网络，之所以把神经网络单独分类主要是因为神经网络包罗万象，既可以属于有监督学习，有可以属于无监督学习，既可以是分类，也可以是回归，很难将其分在哪一类，所以干脆以后单独介绍。

声明

本系列介绍系本人的学习体会，难免有不足和错误，还望广大网友指正。比如也有的地方将Boosting总结为基于树的分类模型，只是个人觉得Boosting的思想更像是Sampling，所以将其归纳在采样方法中。开篇介绍到此，之后有空本系列会陆续更新，力求简要介绍各种常见的学习方法和学习策略。也欢迎广大网友共同探讨。

本系列参考：

http://research.microsoft.com/en-us/um/people/cmbishop/prml/

http://statweb.stanford.edu/~tibs/ElemStatLearn/

http://www.cs.toronto.edu/~hinton/csc2515/lectures.html

本文转载自： https://software.intel.com/zh-cn/blogs/2014/07/28