
2024 年 9 月 30 日起，本站网址
- 从 `https://mountaye.github.io/blog/` 
- 变更为 `https://blog.mountaye.com`.

因为网站仍然架设在 GitHub Pages 上，所以旧网址可以自动跳转到新网址。

但是下一步计划把网站迁移到 Cloudflare Pages 上，因为 Next.js 项目不同构建之间文件差异过多，不适合作为 git 仓库的内容进行托管。

所以无法保证将来旧网址依然可以自动跳转。请使用浏览器收藏功能的读者更新收藏夹，使用 RSS 订阅功能的读者更新 RSS 源。

根据初步计划，过渡期将持续到 2024 年 12 月 31 日。


通知：本站网址変更

.zh | 反派影评·波米：开局的终局

转载 | 《叙述》

·转载 | 吉汉：边缘化的六四论述：八九春夏，其实发生的是“两场运动” | 端传媒

.en | 外交政策杂志《中国在衰落，而这才是问题》及一篇反驳



> 2011 年 7 月 30 日，桥水基金的达里奥最近对滴滴中止赴美上市和中国整治课外辅导两件事发表了看法。大陆的很多财经自媒体对这篇文章进行了转述，但是并没有引用原文。周末读了一下，至少我对原文的理解，和财经自媒体所称达里奥的观点不同。所以翻译一下，供参考。
>
> 在找原文的过程中，还发现了一篇刊登于 2021 年 7 月 11 日日经亚洲板块的观点性文章，对达里奥的文章更早的一篇《不要对变化世界中的中国崛起视而不见》进行了反驳，遂将达里奥此文与反驳一并翻译，附于后。

## 0

> 2011 年 7 月 30 日，原文 [发表于 LinkedIn](https://www.linkedin.com/pulse/understanding-chinas-recent-moves-its-capital-markets-ray-dalio/)


最近中国与—— 1）滴滴的上市和对其数据使用的控制以及 2）中国教育公司正被转为非营利组织——有关的政策举措，让人对中国的资本主义和资本市场产生了很多怀疑，所以我想帮助澄清一下那里发生了什么事。 

我知道这让不了解正在发生的事情的人感到困惑。自从我36年前开始去中国以来，我发现大多数与政策制定者没有直接接触、没有详细了解变化趋势的西方观察家们，往往不相信中国共产党真的是在用资本市场促进发展。他们将最近这两个举措解释为共产党领导人显示了他们真正的反资本主义的，尽管过去 40 年来的趋势已经明显地朝向用资本市场发展市场经济，并在这个过程中让企业家和资本家变得富有。结果，他们误解了中国正在发生的事情，并且可能会继续误解。这一回，政策制定者向滴滴表示，进行上市可能不是最好的选择，政府很容易让人理解地希望处理数据隐私问题。就教育辅导公司而言，政府希望减少教育不平等，和那些急于让孩子获得这些服务但又负担不起的人的经济负担，通过广泛提供这些服务。他们认为，这些东西对国家更好，即使股东不喜欢。

我记得有许多类似的误解。例如，我记得中国散户投资者泡沫破灭导致政府购买股票，然后政府试图操纵市场一段时间。我还记得中国央行在 2015-16 年间因扩大 [汇率区间](https://www.investopedia.com/terms/c/currency-band.asp) 而导致人民币暴跌，以及这如何导致许多投资者将这些发展作为政策制定者正在远离发展中的资本市场的证据。一些持怀疑态度的投资者认为这些举措是不恰当的反自由市场的干预，尽管这些举措在许多资本主义市场已经多次发生，尽管美国和其他发达市场的财政和货币政策干预使中国政府对其市场的干预相形见绌. 通过它，所有中国决策者都成功地应对了影响并实现了他们的目标；即，他们的行动方向从未改变。这个方向就是支持稳定快速发展资本市场、企业家精神、对外国投资者的开放程度。所以我鼓励你看看趋势，不要误解和过度关注摆动。

要了解正在发生的事情，您需要了解中国是一个国家资本主义体制，这意味着国家运行资本主义，为了为大多数人的利益服务，政策制定者不会让资本市场的敏感性和富裕资本家，挡住他们认为最适合该国大多数人的道路。相反，资本市场中的人和资本家必须了解他们在体制中的从属地位，否则他们将承担自己错误的后果。例如，他们需要纠正认为自己的财富有权决定事情发展方向的错误。 

您还需要了解，在这个快速发展的资本市场环境中，中国监管机构正在探索适当的法规，因此，当法规变化迅速且不明确时，会导致此类混乱，这可能会被误解为反资本主义举措. 

此外，您需要了解全球地缘政治环境的变化会导致一些变化。你可以看到这反映在美国政府的政策转变上，例如 a) 改变对中国公司在美国上市的政策和 b) 威胁禁止美国养老基金在中国投资。 

假设这样的事情将来会发生，并以此为依据进行投资。但不要将这些波动误解为趋势的变化，也不要指望这种中国国有资本主义与西方资本主义完全一样。 

话虽如此，我确实认为不幸的是，中国的决策者没有更清楚地公开表达他们行动背后的原因。 

至于投资，在我看来，美国和中国的体制和市场都有机会和风险，很可能相互竞争，相互多元化。因此，它们都应该被视为一个人的投资组合的重要组成部分。我敦促您不要将此类举动误解为对过去几十年存在的趋势的逆转，并让它吓跑您。


## 1

> 达里奥 2020 年 10 月 23 日在 [《Financial Times》上的一个专栏](https://www.ft.com/content/8749b742-d3c9-41b4-910e-80e8693c36e6)，原文标题为 "Don’t be blind to China’s rise in a changing world".
>
> 原文有付费墙，译文基于 [这个连接](https://thefinanceinfo.com/2020/10/23/dont-be-blind-to-chinas-rise-in-a-changing-world/)

作者为桥水联合创始人、联席董事长兼联席首席投资官

从我记事起，人们就说中国不可能成功。共产主义行不通。威权主义行不通。中国人没有创造力。他们在坏账和房地产投机方面有很大的问题。然而，我们每天都看到中国以非凡的方式取得成功。

它实现了一些世界上最低的 Covid-19 病例率。在过去的一年里，其经济增长了近 5%，没有将债务货币化，而所有主要经济体都在收缩。中国的生产多于消费，国际收支顺差，与美国和许多西方国家不同。今年，全球近一半的首次公开募股将在中国进行，其中包括蚂蚁金服 300 亿美元的上市，这是全球有史以来规模最大的一次。甚至特斯拉最畅销的 Model 3 汽车也可能很快就会完全在中国制造。

世界秩序正在发生变化，但由于持续存在的反华偏见，许多人忽略了这一点。中国的非凡表现并不新鲜。事实上，除了1839-1949年的“百年屈辱”外，它在历史上一直是世界上最强大的国家和文化之一。就在过去的四年里，它的经济变化是显着的。无论你对中国的“国家资本主义”有什么批评，你都不能说它没有用，即使你强烈反对北京的做法。

36年前我第一次访问中国时，我会给高级官员10美元的袖珍计算器。他们认为它们是奇迹装置。现在中国在先进技术上与美国匹敌，并且可能会在五年内领先。自 1984 年以来，人均收入增长了 30 多倍，预期寿命增加了十年，贫困率几乎降至零。 1990年，中国第一个股票市场由我认识的七位爱国青年设计。从那时起，它已成为世界第二大。

所有这些都是在说，中国的崛起具有巨大的政治、经济和投资影响。在政治上，中国已成为美国两党面临的主要问题，美国担心中国崛起，扩大全球影响力，并且拒绝其威权模式和对待新疆维吾尔族穆斯林等少数民族的方式。中方的反驳是，维护秩序需要强有力的手，在其境内发生的事情是自己的事，美国有自己的人权问题。它对台湾、香港等地区的主权也是争议很大的大问题。没有人知道这些紧张局势将如何发展，但它们会影响我们所有人。

与此同时，中国的经济规模与美国大致相当，而且扩张速度更快——所以时间站在中国一边。它拥有不断增长的受过良好教育的人口，约占世界科技大学专业的三分之一，是美国的三倍。它还产生和收集更多数据以使用人工智能进行处理。对于西方的许多人来说，这在国家监视方面有阴暗面。但对许多中国人来说，它强化了积极的社会规范，同时也带来了巨大的效率。看待中国相对实力的一种方式是，在人口是美国四倍的情况下，当其人均收入在大约 25 年内达到美国的一半时，其经济规模将是美国的两倍。

最后，还有投资影响。作为一名全球宏观投资者，关于我应该在何处投资多少，查看基本面以及其他人的仓位，我考虑得很多。中国基本面强劲，资产定价相对有吸引力，全球都在减持中国股票和债券。这些目前占外国投资组合持有量的 3% 或更少；中性权重将接近 15%。

这种差异至少部分是由于反华偏见。我认为它即将改变。中国市场正在向外国人开放，他们现在至少可以进入其中的 60%，而 2015 年为 1%。主要指数的基准权重正在上升。因此，我预计中国将享受有利的资本流入，这将支持已经处于两年高位的货币和金融市场。所有这些都促使我在投资组合中增持了中国。

当然，任何国家都可能出现问题。北京可能不会坚持目前的经济改革进程，尽管我怀疑这会发生。美国和中国也在贸易、技术、地缘政治、资本市场和军事力量方面展开激烈竞争——有人说是交战。没有人知道这些战争会有多严重，哪个国家会获胜，或者如何获胜。这就是为什么我将资金分散到这两个国家。

从长远来看，永恒和普遍的真理决定了国家成功或失败的原因。简而言之，当帝国生产力高、财务状况良好、收入多于支出、资产增长快于负债时，帝国就会崛起。这种情况往往发生于他们的人民受过良好教育，努力工作时，并举止文明之时。 正如我在一项正在进行的研究中记录的那样，客观地将中国与美国在这些措施上进行比较，基本面显然有利于中国。

偏见和偏见总是让人们看不到机会。 所以，如果你因为与中国发生的事情不符的原因而对中国持怀疑态度，我建议你理清思路。 美国的事件及其在不断变化的世界中的地位也是如此。 美国大选前夕是反思两者的好时机。


## -1

> 日经亚洲板块对上文的 [一个反驳](https://asia.nikkei.com/Opinion/Why-Ray-Dalio-is-wrong-about-China)，作者是 Andrew Hunt 和 Ben Ashby，发布于 2021 年 7 月 11 日

*Andrew Hunt 是 Hunt Economics 的首席执行官，也是 Dresdner Asset Management 在亚洲的前顾问。Ben Ashby 是摩根大通首席投资办公室的前董事总经理。*

高盛与中国工商银行（ICBC）的新财富管理合资企业，和对冲基金亿万富翁Ray Dalio有什么共同点？他们都是希望更多地接触中国金融市场的全球金融投资者的一部分，因为他们认为中国的崛起是不可避免的。我们认为他们错了。

我们认为，达利欧在2020 年 10 月 23 日发表在《金融时报》上的专栏《不要对中国在不断变化的世界中的崛起视而不见》中提出的许多论点今天都可能被证明是错误的，而其他观点可能随着时间的推移也会被证明是错误的。中国市场很可能对外国人“开放”，但是否保证他们有更多的资本是另一回事。

乍一看，更多中国储蓄进入金融市场的前景似乎证明了这种兴奋是合理的，中国证券将成为全球投资者投资组合的更大一部分。

我们计算出，按当前汇率计算，至少需要 6 万亿美元的海外资产来重新平衡国内储户的存款密集型投资组合，使其分布类似于中国邻国的分布。而且，正如达利欧在英国《金融时报》中指出的那样，“世界正在减持中国股票和债券”，它们占外国投资组合的 3% 或更少，而不是接近 15% 的“自然”权重。

到目前为止，如此真实。但许多国际金融机构希望，金融部门政策的“正常化”、投资组合的重新平衡和持续的债务推动的增长将创造一笔横财，他们现在应该为自己建仓。这就是我们不同的地方：我们预计在可预见的未来不会发生任何根本性的变化，由于中国经济的现实。

该国的大部分家庭财富仍存留在银行账户中，而且对外流动受到严格控制。因此，银行体系庞大：中国在全球存款中所占的份额大约是其在全球国内生产总值中所占份额的两倍。

不过，中资银行的主要职能是促进政府政策，促进符合中国共产党原则的经济发展。他们必须确保关键部门有现成的廉价信贷供应，支持实现经济的产出最大化，而非利润。

自 1980 年代后期经济改革开始以来，这种模式必然助长了更广泛的企业部门的赤字。我们估计，平均短缺每年相当于 GDP 的 16%。这必然会影响贷款、储蓄和监管。

为支撑经济，抑制融资成本；在过去四十年的大部分时间里，实际利率一直为负。自然，不愿向借款人收取高额费用对储户来说意义更小。但是已经实施了严格的监管，严格控制资本流动，以确保他们将大部分财富留在银行。

如果中国政府考虑将其做法正常化，将面临艰难的选择。当局可以允许市场将资金分配给寻求利润最大化的公司，或者他们可以继续将资本引导到许多破坏股东价值的公司。在后一种情况下，投资者将不得不接受中国的金融市场没有真正的经济目的，长期回报可能会受到限制。

正如著名投资者本·格雷厄姆所说，“股市在短期内可能是一台投票机，但随着时间的推移，它是一台称重机。”

如果没有利润最大化的潜在驱动力，中国股票就很难达到投资者预期的回报。这意味着该国的储蓄者可能会与任何遵循 Dalio 的 GDP 称重方法的长期被动投资者一起失败——这一策略在 1990 年代后期的亚洲金融危机期间失败了。但企业行为的任何巨变都不符合政策制定者的经济目标。

如果允许更多的国内资金离开该国，也会出现困难局面。对储蓄市场的任何放松管制都可能将中国宝贵的外汇储备消耗到一个危险的低水平。

尽管这些储备的名义价值很大，但它们是否足以满足中国这样规模的经济体的需求仍然是一个悬而未决的问题。此外，如果储户要根据区域标准进行再平衡，我们认为银行系统将面临至少 180% 的贷存比，从而阻碍其向企业提供廉价信贷的主要功能。公司的融资成本也将飙升，引发大量重组，进一步损害投资者回报。

在可预见的未来，中国的银行和企业根本无法承受国内储蓄的流失。即使这些储蓄被锁在家里，前景也越来越消极。由于债务负担已经很高，经济放缓，加上多年不景气的贷款后不良贷款比例不断增加，中资银行将越来越挣扎，其发放新贷款的能力将下降。这在一定程度上解释了中国吸引更多外国投资者的动机。有希望的正常化和确保新的资本来源有助于推迟艰难的决定。

这一切都在达利欧几乎没有提到的实际考虑之前，例如将资金投入到一个有资本管制的国家或满足国内监管机构和投资者的需求的影响，特别是当他们越来越关注环境、社会和治理原则时，如以及应对日益激烈和紧张的地缘政治竞争。没有人知道这一切的正确风险溢价是多少。

在任何像中国这样规模的市场中，投资者都将有较早获得轻松获利的机会。鉴于对冲基金倾向于短期投资，Dalio 可能会获利。但我们认为潜在的回报最终会消退。

更糟糕的是，如果中国无法改革国内经济，或者国际政治局势进一步恶化，甚至撤资都可能成为问题。如果发生这种情况，仓促进入的投资者和公司将有时间悠闲地忏悔。


.en | 达里奥关于滴滴及课外辅导的看法，及2篇相关文章

> 本文的作者保罗·格雷厄姆是一位程序员、画家兼投资人。他曾在哈佛大学获得计算机方向的博士学位，也在罗德岛设计学院和佛罗伦萨绘画艺术学院学习过绘画。作为两种身份的结合，他创作了《Hackers & Painters》一书。作为投资人，他最为出名的成就是参与创办了创业孵化公司 Y Combinator. 
>
> 保罗在互联网上最有名的文章，当属这篇《How to Disagree》，他的个人维基百科词条上专门用一个小节介绍了这篇文章。网络上也有根据这篇文章制作的“反驳金字塔”图片。虽说一图胜千言，但是从文字转化为示意图的过程中，很多信息被省略，一些常见的话术和对这些话术的反驳，以及本文文末，对反对的不同层次，其意义的讨论和澄清，都没有出现在图中。在争论中直接扔给对方一张反驳金字塔的图，看起来反而很接近于最低层次的扣帽子。
>
> 以下是全文翻译。原文链接：[http://paulgraham.com/disagree.html](http://paulgraham.com/disagree.html)

作于 2008 年 3 月

网络正把写作变成对话。二十年前，作者只用写而读者只能读。网络让读者可以回应，而且这些回应越来越多——评论区里、论坛里，和他们自己的博客文章里。

这些回应的人中有很多是反对原文的。这是可以预见的。同意不如反对激励人们（发表看法）。当你同意的时候可说的也更少。你也许可以就作者说过的东西进行拓展，但是他可能已经把最有趣的推论都说完了。当你反对的时候，你所踏足的领域是他可能还没涉及到的。

结果就是，反对的声音要多得多，尤其是以字数来衡量。这并不意味着人们的戾气愈发严重。我们交流方式的结构性改变就足以解释这一现象了。但是尽管驱动着反对声音增多的并非愤怒，人们因为反对增多而变得更加生气的危险却真实存在。尤其是在网上，在你不用和对方面对面的地方发言是容易的。

如果我们都在越来越多地进行反对，那我们就需要把这件事小心做好。什么叫好好反对？绝大多数读者可以区分单纯的**扣帽子**和通过细致推理进行的反驳，但我认为把中间状态也逐个列举一下是很有帮助的。所以下面就是对反对的不同层次进行列举的一个尝试：

## 第 0 层：扣帽子 (Name-calling)

这是反对的最低层次，可能也是最常见的形式。我们都见过这样的评论：

> 你个娘炮！！！！！！

但是重要的是意识到，更加高大上的**扣帽子**同样没什么效力。一个像这样的评论：

> 作者是个自以为是的外行。

不过就是一个高配版的“你个娘炮”。

## 第 1 层：诉诸身份 (Ad Hominem)

**诉诸身份**的攻击不像单纯的**扣帽子**那么无力。它其实可能有些威力。比如说，如果一个参议院写文章说参议员们的工资需要提高，有人可能会回应道：

> 他当然会这么说了，他是个参议员。

这并不会反驳作者的论证，但是这至少和主题有关。然而，这仍然是一种很无力的反对。如果这位参议院的论证里有什么错误，你应该说明错在哪里；如果没错，他是一个参议员又有什么区别？

说作者不具备写作某一话题文章的权威性是**诉诸身份**的一个变种，而且是特别没用的一种，因为好的想法经常来自于旁观者。问题是作者对还是不对。如果他缺乏的权威性导致他犯了错误，请把这些错误指出来。如果没有，那（缺乏权威性）就不是一个问题。

## 第 2 层：诉诸语气 (Responding to Tone)

接下来这个层次我们开始看到针对内容而非作者的回应。这些回应中最低级的一种形式就是反对作者的语气。例如：

> 无法相信作者竟然用如此傲慢的方式贬低智能设计。

尽管强于攻击作者，这仍是一种无力的反对。作者是对还是错，比他的语气重要得多。尤其是鉴于语气是多么难以评判。一个挂着某种观点的粉丝牌子的人可能被一些其他人觉得正常的语气所激怒。

所以如果你对于一篇文章所能说的最坏的事情就是**诉诸语气**，那你实在是没说出什么东西来。作者是不是轻佻但是正确？那总好过持重但是错误。如果作者有哪里错了，那就指出到底是哪儿。

## 第 3 层：声明异见 (Contradiction)

这一层次我们终于来到了对说过的内容进行的回应，而不是怎么说的和谁说的。对一个论证的最低层次的回应就是简单陈述相反的论点，没有或只提供很少的支持性证据。

这一方法经常和第2层结合起来使用，正如：

> 无法相信作者竟然用如此傲慢的方式贬低智能设计。智能设计是合理的科学理论。

**声明异见**有时可能有些威力，有时仅仅让人看见明确声明的反方命题就足以看到反方是正确的。但是通常来说，证据是有帮助的。

## 第 4 层：证明异见 (Counterargument)

到了第4层上，我们终于见到了第一种有说服力的反对形式：**证明异见**。之前的几种形式通常可以因为啥也没论证而被忽略。**证明异见**可能会证明某些观点。问题在于，很难说证明的究竟是啥。

**证明异见**就是在**声明异见**之外，再加上论证和/或论据。当其针对的是原论点时，这种方式是令人信服的。但是不幸的是，通常情况下**证明异见**针对的是和原论点稍微有些区别的东西。多数情况下，争论得热火朝天的俩人其实争论的是两件不同的事情。有时他们甚至互相同意对方，但是陷于斗嘴的程度如此之深，以至于没有意识到这一点。

反对和作者原文有轻微不同的论点也是可能有合理原因的：当你感觉他们没有把握问题的中心的时候就可以这么做。但是当你这么做的时候，应该明确说明你在论证不同的论点。

## 第 5 层：驳斥对方 (Refutation)

最有说服力的反对形式是**驳斥对方**。它同样是最罕见的，因为需要最多的工作量。其实，反对的不同层次构成了一种金字塔，层次越高，你能找到的实例就越少。

要**驳斥**一个人，你可能得引用他们说过的话。你可能必须找到一件“还热乎着的凶器 (smoking gun)”，一个在你反对的内容中你认为搞错了的东西，然后解释它为什么错了。如果你找不到可以用来反对的实际引用，那么你可能在犯 [“稻草人谬误”](https://zh.wikipedia.org/wiki/%E7%A8%BB%E8%8D%89%E4%BA%BA%E8%AB%96%E8%AD%89)。

尽管**驳斥对方**一般包含引用，引用并不必然意味着**驳斥对方**。有些作者引用部分他们反对的文章的内容，做出合理**驳斥对方**的样子，然后用第 3 层甚至第 0 层的形式进行回应。

## 第 6 层：驳斥对方中心论点

**驳斥**的力度取决于你驳斥对方的是什么。最强有力的反对形式就是**驳斥对方的中心论点**。

即便到了第5层，我们偶尔仍能看见故意的智力不诚实 (interlectual dishonesty)，比如有人挑出一个论证中不重要的点然后把它们**驳斥**一番。有时这么做的精神让这种反对更像是一种处心积虑的**诉诸身份**的攻击，而非真正的**驳斥对方**。比如，纠正某人的语法，或者揪住名字或数字中的小错不放。除非反对的论证实际上依赖于这些错误，否则纠正它们的唯一目的就是损害对手的名誉。

> **intellectual-dishoesty**
>
> 相对于 intellectual honesty, 故意在辩论和推理中使用谬误被称作 intellectual dishonesty, 译作“智力不诚实”。详见维基百科 inteleectual honesty 词条。

真正意义上的**驳斥对方**要求一个人反驳其中心论点，或者至少是其中之一。那意味着一个人必须明确地指出中心论点是什么。所以一个真正有效的**驳斥对方**看起来就像：

> 作者的主要论点似乎是 X。正如他说的：
> 
> > <引用的内容>
> 
> 但这是错的，原因如下……

你引用并指出错误的内容不一定是原作者主要论点的原样陈述，只要批判的是中心论点所依赖的东西就足够了。

## 这样做的意义

现在我们有了给不同形式的反对进行分类的方法。这有什么好处？这种反对的分级所**不能**带给我们的，就是判断输赢的方法。反对的不同层次描述的只是一个反对的形式，而不是反对是否正确。一个第 6 层的回应可能仍然是完全错误的。

但是尽管反对的不同层次没有给一个回复的可信度设定一个下限，但它的确设定了一个上限。一个第 6 层的回应不一定有说服力，但是一个第 2 层的回应一定没有说服力。

区分不同形式反对的最明显的好处就是帮助人们评估他们所阅读的东西。特别是，这将帮助他们看清的议论。一个雄辩的演讲者或者作家可以给人一种碾压对手的印象，仅仅通过使用强有力的词汇。实际上这可能是一个煽动者的决定性特质。通过辨别不同形式的反对，我们给了批判性阅读者一个图钉，让他们能戳破这种气球。

这种标签同样能帮助写作者。大多数的智力不诚实是无意的。有些人用**诉诸语气**的方法批评他反对的观点，可能真的觉得自己言之有物。放大并看清他当时在反对分级上的位置，有可能会启发他尝试进步到**证明异见**和**驳斥对方**的层次上去。

但是好好反对的最大好处并不只是让对话变得更好，而是让被反对的人开心一点。如果你研究对话，会发现第 1 层比第 6 层更加刻薄。当你真的言之有物的时候，大可不必刻薄。实际上，你也不会想这么做。当你真的有观点要表达时，刻薄只能起阻碍作用。

如果沿着反对的不同层次向上攀登可以让人们不那么刻薄，那将会让大多数人更快乐。多数人并不乐于刻薄，他们这么做只是因为控制不当。

感谢 Trevor Blackwell 和 Jessica Livingston 阅读这篇文章的草稿。

.en | 翻译：保罗·格雷厄姆谈如何反对


> 人类的本质就是复读机。

首先萌狼看[phoenixlzx](https://blog.phoenixlzx.com/2014/03/10/browser-from-a-to-z/)那有一篇这样的文章，貌似很好玩的样子。

咱看[约伊兹的萌狼乡手札](https://blog.yoitsu.moe/a2z.html)那有一篇这样的文章，貌似很好玩的样子。

咱也试试看？

- __A__ [amazon.com](https://www.amazon.com): 美帝的JD
- __B__ [bilibili.com](https://www.bilibili.com): 比利比利♂干杯
- __C__ [changhai.org](https://www.changhai.org): 卢昌海的个人主页，科普作家的自留地，互联网的名胜古迹
- __D__ [douban.com](https://www.douban.com): 人均大文豪
- __E__ [email.——.edu](): 学校邮箱
- __F__ [farseerfc.me](https://farseerfc.me): farseerfc 的博客，本人博客的留言区代码就是根据[他(她？)的教程](https://farseerfc.me/github-issues-as-comments.html)改写成的
- __G__ [github.com](https://github.com): 同性交友网站
- __H__ [hacker-tools.github.io](https://hacker-tools.github.io): 标题党，你以为我是黑客教程，其实我是 Linux 入门哒
- __I__ [idope.se](): 好像已经失效的p2p搜索网站
- __J__ 没有 :-(
- __K__ [kenengba.com](https://kenengba.com): 可能吧，Jason Ng 的博客，号称“互联网的‘新鲜事’”，更新周期以年为单位
- __L__ [localhost:4000/blog/](): 个人博客的本地调试端口
- __M__ [mountaye.github.io/blog/](https://mountaye.github.io/blog/): 个人博客，不要忘记反斜线
- __N__ 没有 :-(
- __O__ [ozdic.com](http://www.ozdic.com/): 一个搜索英语固定搭配的在线词典
- __P__ [program-think.blogspot.com](https://program-think.blogspot.com): 咱也不知道，咱也不敢问
- __Q__ [quantopian.com](https://www.quantopian.com/home): 一个提供量化金融数据接口的平台，数据与主流财经门户的数据有出入
- __R__ [ruanyifeng.com](https://www.ruanyifeng.com/home.html): 阮一峰的个人网站
- __S__ [stackoverflow.com](https://stackoverflow.com): 编程相关的问答网站 ~~（抄代码就完事了）~~
- __T__  ~~（谁能给个邀请码）~~ 没有 :-(
- __U__ 没有 :-(
- __V__ [linux.vbird.org](http://linux.vbird.org/): 鸟哥的 Linux 私房菜
- __W__ [wolfram.com](http://wolfram.com/): ~~世界上第二好的编程语言~~
- __X__ 没有 :-(
- __Y__ [yoitsu.moe](https://blog.yoitsu.moe): 约伊兹的萌狼乡手札
- __Z__ [zh.moegirl.org](https://zh.moegirl.org/Mainpage): 中文萌娘百科，90后中老年人了解00后的窗口


.html | 浏览器A到Z

.en | 翻译：为什么说物理不是一门学科

.html | 转载：青涩的爱人

当初博客开张的时候，原计划在编程语言方面聊聊 C++、Java 和 Python。谁曾想半年多过去了，尚未写过 Python 的帖子。实在是说不过去啊！所以今天赶紧写一篇来凑数。

其实俺接触 Python 的时间，也不算太早（大概是2003年那会儿）。当时看到 Eric Raymond 关于几大编程语言的评价（原文在“这里”，翻译在“这里”），之后又看了他写的《Why Python?》。感觉这位大牛蛮器重 Python 滴，于是俺也就跟风学习了一番。从此一发不可收拾——现在 Python 已然成为俺最常使用的脚本语言了。

接下来，俺就从几个不同的角度来鼓吹一下 Python。假如你从来没有听说过或者从来没用过此语言，听了俺的忽悠之后，或许会有所心动 :-) 假如你觉得俺只不过是 Python 阵营的枪手，发发广告帖，那你就不用再浪费宝贵的时间去看后续的帖子了。

按照俺先前的习惯，会把接下来的内容拆成几个帖子来写......

为了方便阅读，把本系列帖子的目录整理如下（需翻墙）：

1. [作为脚本语言的 Python](RP-why-choose-python-1-script)
2. [作为动态语言的 Python](RP-why-choose-python-2-dynamic)
3. [作为面向对象语言的 Python](RP-why-choose-python-3-oop)
4. [作为函数式编程语言的 Python](RP-why-choose-python-4-fp)
5. [作为瑞士军刀的 Python](RP-why-choose-python-5-tool)
6. （未完待续）


> **版权声明**
>
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
>
> <a href="https://program-think.blogspot.com/2009/08/why-choose-python-0-overview.html">https://program-think.blogspot.com/2009/08/why-choose-python-0-overview.html</a>

.py | 转载：为什么俺推荐 Python[0]·概述

### 文章目录

* [脚本语言好在哪？](#pros)
* [脚本语言有啥缺点？](#cons)
* [Python 和其它脚本语言的比较](#compare)
* [总结](#summary)

俺窃以为，Python 的所有特征中，作为脚本语言（“脚本语言”的定义参见“[这里](https://en.wikipedia.org/wiki/Scripting_language)”）是它的首要特征。因此，在本系列帖子中，俺首先来忽悠一下 Python 作为脚本语言，有些啥好处？

# 脚本语言好在哪？<a name="pros"></a>

要聊 Python 作为脚本语言的好处，首先得说说脚本语言自身有哪些优点。一般来说，当我们提及“脚本语言”，都是强调其解释执行的特性（虽然有些脚本语言也支持编译）。所以，后面陈述的这些优点，大都是拿编译型语言来进行对比。

## 更高层次的抽象和封装

大部分脚本语言都提供了（内置了）比较高层次的抽象和封装。像很多脚本语言都内置了字符串处理能力以及正则表达式（典型代表就是 Perl）。还有很多脚本语言都内置了高级的数据结构。比如 Python 在语言层面支持了链表（Python 的术语叫 List）、映射（Python 的术语叫 Dict）、元组（Python 的术语叫 Tuple）。

有了这些高层次的封装，你写起代码来，就特别滴简单、特别滴爽。比如，在 Python 中要把一个 List 翻倍，只需这么写：

```python

[1,2,3] * 2

```

就得到

```python

[1,2,3,1,2,3]

```

## 更少的代码量

得益于高层次的封装，在完成相同功能的前提下，脚本语言的代码量会比编译型语言少很多。

比如说，要打印出某个文本文件的内容，如果用 Java 实现，正常的写法大概要七、八行代码（把所有代码硬挤到一行的，不予讨论）；用 Python 也就三、五行。

再比如说，抓取某个网址对应的 web 网页，用 Python 自带的标准库实现，大概3到5行代码；但如果用 C++ 实现，代码量会增加许多（具体要写多少代码，取决于你用了哪个 http 的库）。

代码量少了之后，至少你看代码的时候（无论是看自个儿滴还是看别人滴），能少敲很多次翻页键，大大延长了键盘的寿命，顺便降低了手指头的劳损。

## 更好的可读性

当然啦，延长键盘寿命还不是关键，关键在于——代码量少了之后，（通常情况下）会有助于提高可读性。而可读性恰恰是 Python 的强项之一。

比方说：Python 在【语法层面】强制约定了作用域缩进（这是俺很喜欢 Python 的地方之一）。如此一来，即便是新手程序猿写出的 Python 代码，缩进风格也很统一。反观 C/C++/Java 的新手，写出的代码就没有这么整齐了。

## 更平缓的学习曲线

通常，脚本语言的语法都比较简单、傻瓜化。因此，入门也就容易很多。稍微有一些编程基础的人，就能够在短时间内上手。

比如俺手下的 C++、Java 程序员，以及某些测试人员，都可以在一周内（程序员用不着一周，一般就1、2天）掌握 Python 的语法并用来写一些辅助的小工具。大大节约了俺培训的口水。

## 支持“交互式”

很多脚本语言的 IDE 支持【交互式写代码】。也就是说，你每写完一行代码，解释器就执行一把。这样能很快发现输入错误，而且还可以立即看到执行结果。

# 脚本语言有啥缺点？<a name="cons"></a>

前面说了那么多优点，那脚本语言有啥缺点捏？

主要的缺点就是【性能差】。这是他们为上述优点所付出的沉重代价。所幸当今的计算机硬件突飞猛进，性能差的缺点已经越来越不明显了。

# Python 和其它脚本语言的比较<a name="compare"></a>

有同学可能要问了，脚本语言有很多，为啥俺独独青睐 Python 捏？

为了回答这个问题，下面俺拿 Python 和一些常见的脚本语言作一些【肤浅的】比较。

鉴于后面的内容极易引发语言的口水战，俺特此声明：虽然接下来会提及某些语言相对于 python 的缺点，但俺绝无贬低这些语言的企图，也无意证明 python 比这些语言优秀！俺只是陈述一下：当年是如何在几种脚本语言中进行取舍的？

除了 Python 之外，常见的脚本语言还有很多，比如：PHP、JavaScript（以下简称 JS）、Perl、VBScript（以下简称 VBS）、Ruby、Bash、Lua、Tcl（可别误以为是某家电厂商）......Python 是如何从这些脚本语言中脱颖而出的捏？俺挑选的时候，主要考虑了如下几点：

## 通用性（跨领域）

因为俺懒得学太多编程语言。所以，俺希望熟悉一门脚本语言之后，能够尽量多帮俺搞定不同领域的事儿。从这点来看，俺就不会选择 PHP（太偏重于 Web 服务端）、JS（太偏重于 Web 客户端）、诸如 Bash 之类的 Shell 脚本（太偏重于系统管理）。

而 Python 则属于通用的脚本语言，覆盖范围很广。比如 Web 开发、桌面 GUI 应用、系统管理、网络应用、科学计算等许多领域，Python 都可以轻易搞定。

## 人气够旺

关于“人气”的重要性，俺在《如何选择开源项目》一文中，有介绍过。人气越高、越流行，就意味着更多的资源（包括文档、相关软件），当你碰到问题需要解决，也有更多的人可以咨询。

关于编程语言的流行程度，可以大致参考 TIOBE 的排名（虽然 TIOBE 不能全面反映流行程度，但至少可作为某种参考）。

像 Tcl、PowerShell、Groovy、JavaFX 等都排在３０名之外（截至写本文的2009年8月），感觉用的人太少了，俺暂时不予考虑。而 Python 最近几年的排名则一路上升（请看“这里”），截止到2009年8月，已经高踞排行榜第６位。Perl 虽然也身居高位，但是最近几年的排名一路下滑（请看“[这里](http://www.tiobe.com/content/paperinfo/tpci/Perl.html)”）。俺个人认为，其人气不容乐观。

## 功能够强、库够丰富

另一个俺很看重的地方是功能是否够强大。在这点上，Python 和 Perl 都算是比较强悍的。关于 Python 如何强悍，俺会在本系列的第5篇帖子《作为瑞士军刀的 Python》中加以介绍。

反观 JS、Ruby、Tcl 等语言，则稍显不足（当然，也有可能俺孤陋寡闻）。

## 跨平台

由于俺平时会使用不同的操作系统，再加上俺负责的产品也是跨平台的。所以，俺对脚本语言有跨平台的要求。说到跨平台，诸如VBS、Bash之流就不予考虑了。

其实，很多脚本语言都支持跨平台。而 Python 在这方面，更为出众。不光支持主流的操作系统，还支持一些冷门的（比如古老的 DOS），还支持手持设备（比如智能手机和平板）。

## 和其它语言的整合、交互

最后这一点，估计大多数同学不会太关心。俺因为要在公司的产品中引入脚本技术，所以俺还得考虑该脚本语言和其它语言的整合能力。整合能力强的脚本语言，可以作为复杂系统中的胶水，用来把不同模块粘合在一起（关于 Glue Language，可以参见“[这里](https://en.wikipedia.org/wiki/Glue_language)”）。

在这方面，Python 和 Ruby 的表现都不错：

它们和 Java 的整合有Jython、JRuby；

和 dotNet 平台的整合有IronPython、IronRuby。

至于俺常用的 C++，Python 整合得比 Ruby 好。比如 C++ 社区大名鼎鼎的 Boost 库里面，就内置了一个 Boost.Python 的子库（参见“这里”）。

关于 Python 如何用作胶水，俺会在后续的帖子“作为胶合语言的 Python”中会详细介绍。

# 总结<a name="summary"></a>

基于上述几个方面的考虑，俺最终选择了 Python 作为日常使用的脚本工具，并把它引入到公司的产品中，作为模块之间的胶合剂。

啰嗦完Python作为脚本语言的方方面面，下一个帖子，咱来聊一下它作为动态语言的那些事儿。


[回到本系列的目录](RP-why-choose-python-0-overview)

> *版权声明* 
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
> <a href="https://program-think.blogspot.com/2009/08/why-choose-python-1-script.html">https://program-think.blogspot.com/2009/08/why-choose-python-1-script.html</a>

.py | 转载：为什么俺推荐 Python[1]·作为脚本语言的 Python

### 文章目录

* [动态语言扫盲](#overview)
* [为啥要学习动态语言？](#whyDynamic)
* [为什么是 Python？](#whyPython)
* [总结](#summary)

上一篇帖子介绍了脚本语言的优缺点，然后又拿 Python 和其它脚本语言PK了一下。今天主要是忽悠一下动态语言，捎带忽悠一下 Python。如果你看完本贴，觉得动态语言不错，那俺建议你从 Python 开始入手。

# 动态语言扫盲<a name="overview"></a>

考虑到还有很多同学对动态语言了解不深入，有必要先来普及一下它的基本常识。已经了解的同学，请略过本节。

通俗地说：能够在运行时修改自身程序结构的语言，就属于动态语言。那怎样才算是“运行时修改自身程序结构”捏？比如下面这几个例子都 算：在【运行时】给某个类增加成员函数及成员变量；在【运行时】改变某个类的父类；在【运行时】创建出某个函数......

从这些例子，你应该对动态语言有一个初步的感觉了吧？毕竟传统的静态语言（比如C、C++、Java），是很难达到这些效果滴。

另外，有个误区需要澄清一下。很多同学以为脚本语言也就是动态语言。其实两者是不等价滴——虽然两者有很大的交集。比如 C# 在4.0之后，就可以算是动态语言了，但它不能算是脚本语言；另外，有很多 Shell 脚本语言（比如 DOS & Windows 下的 bat），不能算是动态语言。

关于动态语言更深入的介绍，大伙儿可以看“这里”。

# 为啥要学习动态语言？<a name="whyDynamic"></a>

扫盲之后，就该来说一下，学习动态语言的动机了。搞明白动机，学起来才有干劲嘛 :-)

## 顺应大趋势

假如你经常关注 TIOBE 的排名，那你应该能察觉出来，动态语言近两年的发展势头比较迅猛（在 Top10 里面，至少占了半壁江山）。这能从某个侧面反映出动态语言的影响力在扩大。

假使你不相信 TIOBE 的排名，俺再举一个例子。两大开发阵营（Java 和 dotNet）最近几年也加大了对动态语言的支持力度。比如，dotNet 的 CLR 加入了对IronPython 和 IronRuby 的支持；Sun 当然也不甘示弱，JVM 也开始支持 Groovy，JRuby 等语言。

俺费了这许多口水，列位看官应该明白动态语言是大势所趋吧。在这动态语言大行其道的日子里，你如果连一门动态语言都没搞懂，那出门都不好意思跟人打招呼。

不过，话又说回来，静态语言也是不会消亡滴。毕竟，静态语言有自己的优势（比如严谨、性能）。长期来说，必定是动态语言和静态语言并存。各自弥补对方的缺点。

## 了解新思维、新理念

学习一门动态语言还有一个好处：有很多时候，多学习一门语言，并不一定是为了在工作中用它，而是为了学习新的思维方式、体会新的理念。比如俺就曾经花时间去看 Prolog，但是俺在工作中，从来不需要用到它。（以后有空的话，俺会介绍一下这玩意儿）

由于动态语言可以在运行时修改自身结构，因此就会产生很多静态语言所没有编程范式和手法（比如 eval、Mixin）。如果你以前只使用静态语言，那你在学习了动态语言之后，多半会从它身上领略到很多新的思想和理念。

（关于 eval 的招数，俺后来写了一篇《再举几个动态语言 eval 手法的例子》）

## 能够化繁为简

可能有些同学觉得，前面说的都有些务虚，那咱再来说点具体实在的。大牛 Edsger Dijkstra（图灵奖得主）曾经说过：编程的艺术就是处理复杂性的艺术。咱们来看看，动态语言是如何处理复杂问题滴。

假设要你实现一个函数，用来完成两个数的“某种运算”，具体的运算类型作为函数的参数传入，然后该函数返回运算结果。比如：

```python

Foo("+", 2, 4) # 返回 6
Foo("*", 3, 5) # 返回 15

```

对于上述需求，你会如何实现捏？

请先暗自盘算一柱香的功夫，然后再往下看。

．．．．．．

Ｔｈｉｎｋｉｎｇ

．．．．．．

如果你用静态语言（比如 C、C++、Java）来实现，你可能会在函数内使用一个 switch，根据不同的运算符，进行计算，然后返回计算结果。

对于某些比较 ＯＯ 的语言（例如 C++、Java），你或许还会抽象出一个运算的接口类（纯虚类），然后分别派生出若干个不同的计算类（比如加法类、乘法类），看起来似乎比 switch 要优雅一些。

当然，用静态语言还有其它一些玩法，但是代码量都不会少。具体详情可以看很早以前的一个老故事：《4个程序员的一天》。（其实俺这个例子的灵感就是从那个老故事剽窃滴）

现在，咱们来看看 Python 是如何【优雅地】实现该需求滴。用 Python 只需要【两行代码】即可。请看：

```python

def Foo(op, n1, n2) :
 return eval( "%d %s %d" % (n1, op, n2) )

```

不懂 Python 的同学可能要问了，这两行代码是啥子意思呀？

其实，第一行代码只不过是定义了一个函数头，第2行代码才是精华。这里面利用了动态语言常见的 eval 手法（具体参见“这里”）。在 python 里面，内置的 eval 函数可以把某个字符串当成一个表达式，并对其求值。而语句 "%d %s %d" % (n1, op, n2) 只不过格式化出一个表达式的字符串。

顺便再插一句，Python 还有一个 exec 的内置函数，可以把一段 Python 源代码作为字符串参数传递给它，让该函数去执行。两个函数结合起来，就能玩出很多花样。具体的花样可以参见“这篇博文”。

# 为什么是 Python？<a name="whyPython"></a>

说了动态语言的种种好话，有同学会问了，动态语言有很多种，为啥非要学习 Python 捏？

首先，俺在本系列的第1篇帖子，已经对比过 Python 和另外几种脚本语言。那几种“脚本语言”碰巧也是知名的“动态语言”。Python 相对于他们的优势，此处就不再重复啰嗦了。

其次，单就语法本身而言，Python 的语法对动态性的支持是很优雅、很简洁滴。通过刚才那个 eval 小例子，大伙应该已经看出来了。为了更形象一点，咱拿前面提到的 Mixin 来 Show 一下 Python 的语法是如何的简洁。

通俗地说，Mixin 手法需要在【运行时】给某个类增加基类（也就是父类）。对于 Python 而言，每一个类都有一个内置属性 __bases__，里面包含这个类【当前】的所有基类。假如要在【运行时】增加基类，只需操作 __bases__ 这个属性即可。

比如有一个类 A 和类 B。如果要在运行时把 B 加为 A 的父类，可以用如下语句：
A.__bases__ += (B,)

是不是也很简洁，而且可读性也不差？相比而言，有些动态语言（比如 JavaScript），要实现类似的效果，代码就相对复杂了。

由于 Mixin 不是今天的重点，就不再深入展开了。


# 总结<a name="summary"></a>


最后，来个总结发言：如果你之前没有接触过动态语言，建议去学习一下；如果你已经打定主意要学，Python 是比较好的候选者。

好了，今天就聊到这里。下一个帖子，咱们来讲讲 Python 作为一个纯粹的面向对象语言，有些啥特色。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明** 
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
> [ https://program-think.blogspot.com/2009/08/why-choose-python-2-dynamic.html ](https://program-think.blogspot.com/2009/08/why-choose-python-2-dynamic.html)

.py | 转载：为什么俺推荐 Python[2]·作为动态语言的 Python

### 文章目录

* [抽象（Abstraction）](#abstract)
* [封装（Encapsulation）](#encap)
* [继承（Inheritance）](#inherit)
* [多态（Polymorphism）](#poly)
* [结尾](#summary)

本系列已经中断了很长时间 :( 直到最近一个读者来信问俺，为啥不继续写，俺才突然想起这个被遗忘的系列，实在是抱歉！前一个帖子介绍了作为动态语言的 Python，今天来聊一聊 Python 在面向对象编程（OOP）方面的特色。

本文主要针对那些熟悉 OOP，但还不熟悉 Python 的同学。为了让大伙儿有一个直观的认识，俺会拿 C++/Java 来进行语法上的对比。（这俩语言的名气够大，且号称支持 OO，也算有些可比性）

强调一下：本文虽然拿了某些语言来作对比，但丝毫没有贬低这些语言的意思，请这些语言的粉丝们，不要对号入座 :)

# 抽象（Abstraction）<a name="abstract"></a>

但凡介绍 OOP，自然会提到抽象。因为抽象，是 OO 的第一要素，也是其它要素的基础。而提到抽象，又不免提到对象（Object）。所以，俺首先来聊一下，Python 语言是如何体现“对象”这个思想的。

## Python的对象

如果要问俺，什么是 Python 中的对象，还真不好下一个严密又通俗易懂的定义。为了敷衍大伙儿，俺只好用一句话来概括，那就是 Python 语言中，【一切皆对象】。这句话该如何理解捏？简单来说，就是你在 Python 语言中涉及到的各种东东，都是“对象”。比如，函数是对象、各种数值（比如整数值、浮点数值、布尔值）是对象、模块（类似于 Java 的 package）是对象、None（类似于 Java 的空引用 null、C++ 的空指针 NULL）也是对象、甚至连类（class）也是对象......

对比一下 C++ 和 Java 的语法：只有【类的实例】才能算得上是对象。这2个语言的基本类型（比如“int、char、float”等）不是对象，至于函数，就更算不上了。

既然是一切皆对象，俺有必要稍微总结一下，Python 对象的共性，否则初学 Python 的同学还是会一头雾水。

## 对象的属性

首先，所有的 Python 的对象，都具有若干个属性。你可以通过内置的 dir() 函数进行反射，从而了解到某个对象分别都包含哪些属性。熟悉 Java 的同学，应该明白啥是“反射”。光懂 C/C++ 的同学，如果理解上有困难，可以先参考“维基百科的解释”。

另外，Python 还提供了若干内置的函数，用于在【运行时】操作指定对象的属性。具体如下：

```python

hasattr(obj, name) #判断obj对象是否具有名为name的属性
setattr(obj, name, value) #设置obj对象的名为name的属性值为value
getattr(obj, name) #获取obj对象的名为name的属性值
delattr(obj, name) #删除obj对象的名为name的属性

```

## 对象的类型

所有的 Python 对象，都可以通过内置的 type() 函数获取该对象的类型。这实际上就是 Python 的 RTTI 机制的体现。懂 C++ 的同学，可以回忆一下 C++ 的 typeid 关键字；懂 Java 的同学，可以想一想 Java 的 instanceof 关键字。

## 对象的标示

所有的 Python 对象，都可以通过内置的 id() 函数获取该对象的【唯一】标示。而且当一个对象创建之后，这个唯一标示就会始终保持不变。对于学过 C/C++ 的同学，不妨把这个“唯一标示”想象成该对象在内存的地址。这或许有助于你的理解 :)

Python 对象还有其它一些共性，考虑到本文的扫盲性质，就不再费口水了。有兴趣的同学，可以自己找些入门书研读一番。

## 【一切皆对象】的好处？

可能有同学会问，“一切皆对象”有啥好处捏？俺窃以为：当一切皆为对象，就可以把很多概念、操作、惯用手法统一起来，在语法层面体现出美感。

下面俺举几个例子，并拿 Java 来对比一下。

在 Java 里面，由于基本类型不是继承自 Object 类，引出不少麻烦。当初 Java 它爹刚开始设计容器类（比如 Vector、ArrayList ...）的时候，颇费了一番功夫。因为容器里面放置的东东必须是 Object，为了让容器能适应基本类型，只好给每一种基本类型分别对应一个派生自 Object 的包装类（Integer 类对应 int、Float 类对应 float ...）；后来又平添了自动装箱/拆箱的概念；搞来稿去，产生了 N 多复杂性。

而 Python 就没有这方面的困扰。

再拿刚才提及的“反射”来说事儿。虽然 Java 语言支持对象的反射，但是 Java 的 package 不是 Object，所以也就无法对 package 进行反射。反观 Python，任何一个 module（相当于 Java 的 package）import 之后，都可以直接通过前面提到的 dir() 函数进行反射，得知该 module 包含了哪些东东。仅仅需要2行代码：

```python

import xxx
dir(xxx)

```

# 封装（Encapsulation）<a name="encap"></a>

为了避免歧义，首先要明确一下：什么是“封装”？为了叙述方便，俺把【OOP 的封装】，分为“狭义”和“广义”两种。（关于“封装”的深入讨论，可以参见“另一篇博文”）

## 广义封装

OOP 很强调以数据为中心。所以 OOP 的广义封装，就是把数据和操作数据的行为，打包到一起。比如 C++/Java 里的 class，可以同时包含数据成员和函数成员，就算是满足“广义的封装”了。对于 Python 而言，其 class 关键字类似于 C++ 和 Java，也已经具有“广义的封装性”了。

## 狭义封装

而 OOP 的狭义封装，则更进一步，增加了信息隐藏（Information Hiding）。比如 C++ 和 Java 的“public、protected、private”等关键字，就是通过访问控制来达到信息隐藏的效果。Python 虽然没有针对访问控制的关键字来修饰类成员，但是 Python 采用了另外一套机制——根据命名来约定。在 Python 的对象中，如果某个属性以双下划线开头来命名（比如 __name），就能起到类似于 C++/Java 的 private 关键字的效果。

## 对访问控制的偏见

俺曾经在某技术论坛看到有人质疑 Python 的访问控制机制，说 Python 的私有属性，可以通过反射机制绕过，因此形同虚设。在此，俺想举 C++ 和 Java 来进行反驳。

在 Java 中，同样可以通过反射机制，来访问类的私有成员。至于 C++，得益于指针的强大，只要能访问某个对象（的 this 指针），通过计算该对象成员变量在内存中的偏移，一样可轻易对私有成员变量进行读写。虽然这么干挺变态滴，但技术上是可行滴。

# 继承（Inheritance）<a name="inherit"></a>

紧接着，咱再来说一下继承的话题。

## Python 的继承

Python 没有像 Java 那样，区分出“类继承”（OO 的术语中也叫“实现继承”）和“接口继承”；也没有像 C++ 那样，区分出“公有继承、私有继承、保护继承”这么花哨的玩意儿。Python 就只有一种继承方式。

## 继承的语法

Python 的继承语法，相比 C++/Java 而言，更加简洁。比如子类 Child 需要继承父类 Parent，代码只需如下：

```python

class Child(Parent) :
 # xxxx

```

如果是多继承，代码大同小异：

```python

class Child(Parent1, Parent2, Parent3) :
 # xxxx

```

假如你想知道某个类有哪些父类（基类），只需要通过 Child.__bases__ 便可知晓。

## 继承的动态性

其实上一个帖子已经介绍了动态改变继承关系的例子。但是考虑到上一个帖子年代久远（距本文将近1年），想必很多同学没看过或者看过又忘了。俺不妨再啰嗦一下：作为一种动态语言，Python 可以在【运行时】修改类的继承关系。这个特性比较酷，是 C++/Java 所望尘莫及滴。请看下面的例子：

```python

class Parent1 :
 def dump(self) :
 print("parent1")

class Parent2 :
 def dump(self) :
 print("parent2")

class Child :
 def dump(self) :
 print("child")

print(Child.__bases__)
Child.__bases__ += (Parent1, Parent2) # 动态追加了2个父类
print(Child.__bases__) # 此处打印出的父类信息中，已经包含 Parent1、Parent2

```

# 多态（Polymorphism）<a name="poly"></a>

至于 Python 的多态，和传统的 OO 语言差不多，似乎没有太多值得说道的地方。俺简单举个代码作例子。为了省打字，直接复用上述的3个类，并增加一个 test() 函数如下：

```python

def test(obj) :
 obj.dump()

```

然后对 test() 函数分别传入不同的类型的对象，输出结果俺就无需多说了吧？

```python

c = Child()
test(c) # 打印出 child
p1 = Parent1()
test(p1) # 打印出 parent1

```

# 结尾<a name="summary"></a>

今天的话题，主要是让不熟悉 Python 的网友，对 Python 在面向对象方面的特性，有一个粗浅、感性的认识。聊完了 OOP，下一个帖子会聊一下关于 FP（函数式编程）的话题。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明** 
> 本博客（编程随想的博客）所有的原创文章，原作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址: 
> [https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html](https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html)

.py | 转载：为什么俺推荐 Python[3]·作为面向对象语言的 Python

### 文章目录

* 什么是函数式编程
* FP 的特点
* FP 的优点
* Python 的函数语法
* 和 FP 相关的内置函数
* 消除控制流
* List Comprehension
* 闭包
* 结尾

春节前看到热心读者留言，提醒俺：Python 系列好久没更新了（不知不觉又过了一年多）。俺当时回复说：春节假期补上后一篇。昨天听到鞭炮声才发觉元宵已经到了，赶忙写出本文。

前一个帖子介绍了 Python 作为“面向对象编程”（以下简称 OOP）语言的特点，今天来聊一聊 Python 作为“函数式编程”（以下简称 FP）语言的特点。考虑到本系列面向的是 Python 的门外汉或刚入门的新手，故本文仅介绍若干浅显的 FP 特性。

# 什么是函数式编程

说实话，“函数式编程语言”是一个很大的话题。由于篇幅有限，本文不可能对这个话题做全面介绍。俺干脆偷一下懒，只简单说说。

从字面上看，所谓的函数式编程，就是以“函数”为中心的“编程范式”。估计有同学又会问了，啥是“编程范式”捏？哎呦，这又是一个很大的话题。通俗来讲，“编程范式”就是指编程的套路。比方说大家很熟悉的 OOP，就是一种“编程范式”。FP 跟 OOP 一样，都是一种编程的套路。做个简单类比：OOP 以“对象/类”作为程序设计的核心，而 FP 以“函数”作为程序设计的核心。

# FP的特点

既然说到 FP，自然要稍微说一下 FP 的特色。

## 函数很牛X

刚才说了，FP 是以函数为中心。既然如此，在支持 FP 的语言中，函数的功能自然十分牛X。通俗地说，OOP 语言中，类/对象能干的事情，FP 语言中的函数也能干。下面做一些对比，以加深大伙儿的印象。

OOP 中，对象可以互相赋值；FP 中，函数可以互相赋值。

OOP 中，对象可以作为函数的参数/返回值，FP 中，函数可以作为函数的参数/返回值。

某些 OOP 中，类可以嵌套定义；FP 中，函数可以嵌套定义。

某些 OOP 中，可以有匿名类；FP 中，可以有匿名函数。

## 避免副作用

在 FP 中，特别强调函数不要有“副作用”（洋文叫“side effect”）。没有副作用的函数，又称之为纯函数（pure function）。其输出完全依赖于输入。换句话说，只要输入一样，输出就一样。

要成为纯函数，函数内部不能读写函数外部变量、不能有设备 I/O（比如读写文件）......

无副作用是 FP 的重要特性。FP的很多优点来自于此特性。

## 避免控制流

在 FP 中，尽量避免用控制流语句（循环语句、判断语句）。对于控制流语句，FP 有另外的替代方式。比如：常用递归或高阶函数来替代循环。如此一来，FP 的代码会显得更简洁，更可读。

## 多态

大部分支持 FP 的语言，也都支持多态。函数参数支持多态化，便可实现非常灵活的功能。

说了这么多，不知道大伙儿明白了没？还是没整明白的同学，请看维基百科的英文词条（中文词条太简单，看不明白滴）。

洋文实在看不下去吗？那不妨看看 IT 大牛 Joel 写的《你的编程语言能这样做吗？》（中文版在“这里”）。此文以 JavaScript 来阐述 FP 的妙处。

# FP 的优点

再稍微说一下 FP 的好处，以强化大伙儿学习的动力。

## 模块化

在 FP 的思想中，函数最好是“纯”的，而且最好只完成“单一”的任务。在这种指导思想下，函数的模块化程度自然就高。

## 可复用性

模块化程度高，直接的好处就是可复用性好。

## 可读性

刚才说了，FP 的思想强调函数又纯又小。这样的函数，代码的可读性自然好，修改起来也方便。

## 易于调试

前面提到了纯函数。如果你的程序中大部分函数都是纯函数，则调试 Bug 会容易很多。像 OOP 中，类的多个成员函数都可以修改类的成员变量，有时候会导致调试极其困难。而纯函数没有此问题。

另外，多线程是调试的一大噩梦。当年俺还专门写过帖子，介绍 C++ 多线程的注意事项（在“这里”）。而纯函数由于没有副作用，不必担心各种“互斥”、“死锁”等问题。

## 易于测试

除了易于调试，纯函数的输出仅仅依赖于输入，这一特点注定了它很容易进行单元测试。

## 适合并行

在 FP 中，由于纯函数无副作用，很适合编写并行处理的代码。最典型并且在工业界获得巨大成功的例子就是 Erlang。

## 其它

当然啦，FP 的好处远不止上述这些（比如还有：利于形式化证明）。限于篇幅，俺就不展开了。

# Python 的函数语法

Python 中，常见的函数定义和函数调用，想必各位都晓得了。下面说几种不太常见的，且跟 FP 有关的语法。

## 函数赋值

Python 可以把函数直接赋值给一个变量。举例如下：

```python

def square(n) : # 这是一个计算平方的小函数，后面会反复用它举例
 return n ** 2

f = square # 此处赋值给变量 f
f(10) # 此处返回100。注意：对该变量使用小括号，等同于调用函数

```

## 匿名定义

Python 可以用 lambda 关键字定义【单行】的匿名函数。套用刚才的例子

```python

square = lambda x : x**2 # 定义一个单参数的匿名函数，并把该函数赋值给变量
square(10) # 此处返回 100

```

## 嵌套定义

Python 支持函数的嵌套定义（请看如下例子）。这种语法，在“闭包”中经常出现（后面会具体介绍“闭包”）。

```python

def outer() : # 外层函数
 s = "hello"
 def inner() : # 内层函数
 print(s) # 此处引用的是外层作用域的变量

 inner() # 输出 hello
 s = "world"
 inner() # 输出 world

```

# 和 FP 相关的内置函数

Python 内置了一大坨用于 FP 的函数，以方便程序猿写出简洁的代码。在接下去聊之前，俺有必要先介绍其中的2个。

## map(func, iter)

为了省事，俺只介绍2参数的 map（正宗的 map 支持 N 参数）。

参数 func 是个函数，参数 iter 是个迭代器（也可以理解为集合）

map() 会把 iter 的每个元素传给 func，并把每次调用的结果保存到一个 list 中，然后返回此 list。

举例：

挨个计算整数 list 的平方：

```python

map(square, [1, 2, 3]) # 返回 [1, 4, 9]

```

## filter(func, iter)

参数含义同 map

filter() 会把 iter 的每个元素传给 func，如果 func 返回结果为 True，就把元素保存在一个 list 中，最后返回此 list。

举例：

要过滤出所有奇数，代码如下：

```python

def odd(n) :
 return (n%2) == 1

filter(odd, [1, 2, 3]) # 返回[1, 3]

```

此处可以用上 lambda，把代码简化为一行：

```python
filter(lambda n: (n%2)==1, lst)
```

# 消除控制流

为了让大伙儿更深刻体会 FP 风格同传统风格的差别，俺把刚才两个例子组合一下——要求返回整数list 中所有奇数的平方。

传统的写法（有控制流）：

```python

def func1(old_lst) :
 new_lst = []
 for n in old_lst :
 if odd(n) :
 new_lst.append(square(n))
 return new_lst

```

FP 的写法（无控制流）：

```python

def func2(lst) :
 return map(square, filter(odd, lst))

```

怎么样？是不是更简洁？连 for / if 这两个关键字都不需要了。

# List Comprehension

这个洋文比较难翻译。有人叫做“列表推导”，也有人称为“列表展开”或“列表解析”。（俺比较喜欢头一个翻译——不禁让人联想到“推倒”:）

在 Python 中，这是一个很好吃的语法糖——可以让你写出很简洁、很优雅的代码。

举例1：

还拿刚才过滤奇数的例子。

```python

filter(lambda n: (n%2)==1, lst)

```

上述写法可以等价替换为列表推导：

```python

[n for n in lst if (n%2)==1]

```

举例2：
　　
再来一个稍微复杂的例子。假设有两个整数 list，分别存储矩形的宽度和高度。现在想把所有的宽度和高度进行两两组合，把大于 10 的面积打印出来。
　　
传统的写法（2层循环，4行代码）

```python

for w in width :
 for h in height :
 if w*h > 10 :
 print(w*h)

```

FP 的写法（无循环，1行代码，多精致啊）

```python

print( [w*h for w in width for h in height if w*h > 10] )

```

除了列表推导，Python 中还有字典推导、集合推导等等。为了省点口水，暂且打住。

# 闭包

闭包，洋文叫“closure”，解释在“这里”。它是 FP 的常见手法。那闭包到底有啥用捏？俺举一个微积分中，函数求导的例子。（不懂微积分或者对高数有心理阴影的同学，别担心，请把注意力集中在代码上）

```python

def d(f) :
 def calc(x) :
 dx = 0.000001 # 表示无穷小的Δx
 return (f(x+dx) - f(x)) / dx # 计算斜率。注意，此处引用了外层作用域的变量 f
 return calc # 此处用函数作为返回值（也就是函数 f 的导数）

```

现在，假设要计算二次函数 f(x) = x2 + x + 1 的导数，只需如下代码：

```python

f = lambda x : x**2 + x + 1 # 先把二次函数用代码表达出来
f1 = d(f) # 这个f1 就是 f 的一阶导数啦。注意，导数依然是个函数

```

有了一阶导数，就可以很容易地计算该函数在某点的斜率

比如要计算 x=3 的斜率，只需：

```python

f1(3)

```

如果要想得到二阶导数（导数的导数），只需依样画葫芦（瞧这代码写得多优雅）

```python

f2 = d(f1)

```

看到这里，大伙儿不妨设想一下：如果不用 FP，改用 OOP，上述需求该如何实现？俺觉得吧，用 OOP 来求导，这代码写起来多半是又丑又臭。

# 结尾

今天聊了不少 FP 的语法特性，可惜还是没聊完。由于俺比较懒，而且怕写得太长没人看，所以一些高级话题（比如：迭代器、生成器、等），今天就不介绍了。假如列位看官对那些玩意儿感兴趣，再抽空单独写一帖。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明** 
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
> <a href="https://program-think.blogspot.com/2012/02/why-choose-python-4-fp.html">https://program-think.blogspot.com/2012/02/why-choose-python-4-fp.html</a>

.py | 转载：为什么俺推荐 Python[4]·作为函数式编程语言的 Python

> **文章目录**
>
> * 短小精悍
> * 功能强大之1——跟非常多的语言整合
> * 功能强大之2——既可以跨平台，又可以跟操作系统深度整合
> * 功能强大之3——具有很丰富的第三方模块


本系列几乎变成年度系列了——上一篇帖子是去年元宵节发的。这几天正值春节假期，赶紧抽空补上本系列新的一篇，免得大伙儿以为本系列“烂尾”了。

“瑞士军刀”，大伙儿应该很熟悉，俺就不解释了。拿“瑞士军刀”来比喻 Python 就是想说明：Python 不但短小精悍，而且功能强大。今天就来介绍一下 Python 的这两个特点（尤其是后者）。

# 短小精悍

## 轻量级的的代码

要吹嘘 Python 的轻量级，首先要吹嘘的，自然是它简洁的代码。为了让大伙儿有个初步的印象，举几个例子。

举例1

要得到100-200之间所有奇数的3次方，只需如下一行

```python

[x**3 for x in range(100, 200) if (x%2)==1]

```

举例2

如果要把上述结果拼成一个逗号分隔的字符串，还是只要一行

```python

','.join([str(x**3) for x in range(100, 200) if (x%2)==1])

```

举例3

可能有人觉得上面2个例子是小儿科，再来举一个稍微复杂点的。只需一行代码，即可实现网络扫描（用的是第三方的 Scapy 工具）。

```python

# 传统的 ping 扫描，基于 ICMP 协议
ans,unans = sr(IP(dst="192.168.1.1-254")/ICMP())
# 局域网扫描，基于 ARP 协议
ans,unans = srp(Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst="192.168.1.0/24"), timeout=2)

```

## 轻量级的安装环境

比如 Python 的安装包只有十几兆，而 Java 的 JDK 安装包动辄接近100兆。

## 轻量级的运行环境

同样是运行一个“Hello World”，用 Python 写的进程，占用的内存会更小（相比大多数其它编程语言）。而且 Python 的运行环境（Python 虚拟机）可以很方便地嵌入到 C/C++ 程序中，只需额外带一个动态库即可。

# 功能强大之1——跟非常多的语言整合

很多程序员喜欢“在一棵树上吊死”——始终只用一种编程语言。俺非常反对这种倾向。要想成为一个优秀的程序员，有必要掌握【不同风格/不同范式】的编程语言。编程语言多样化的好处在于，你可以利用不同语言的特色，以取长补短。

而 Python 在跨语言整合方面，堪称佼佼者——你很难找到哪个语言，能像 Python 这样，跟如此多的语言进行整合。

下面简单举几个例子：

## 跟 C/C++ 整合

咱们常用的 Python 运行环境也称为 CPython，是用 C 语言写的。所以 Python 天生就具有跟 C/C++ 整合的能力。而且这种整合是双向的——也就是说，既可以在 Python 模块调用 C/C++ 模块，也可以在 C/C++ 模块调用 Python 模块。

Python 跟 C/C++ 整合，可以有如下三个优点：

1. 丰富的第三方资源

因为 C/C++ 具有非常丰富的第三方模块（包括开源和闭源），其丰富程度超过 Java。所以 Python 可以利用这种整合能力，直接调用各种 C/C++ 的模块，来丰富自己的功能。

举个例子

比如 cURL 是一个C语言编写的应用层网络工具，功能非常强。而 Python 可以通过整合 cURL 直接获得 cURL 的强大功能。

2. 性能的提升

除了第三方模块丰富，C/C++ 开发的模块还有一个优点——性能好。所以，Python 整合了 C/C++ 模块之后，还能趁机获得性能提升。

举个例子

比方说你要写一个 3D 游戏，其中的 3D 渲染引擎是性能瓶颈。那么你可以用 Python 整合一个 C/C++ 的 3D 渲染引擎。而 Python 只用来实现跟游戏高层应用逻辑相关的部分。这样可以一举两得：性能不差，代码不多。

顺便说一下：如今有不少游戏都走这个开发思路——底层引擎用【重型的】C 或 C++ 实现，以确保高性能；而高层的业务逻辑则用【轻型的】脚本语言来开发。

3. 跟操作系统整合

地球上的操作系统，只要是有点名气的，内核都是 C 语言写的；除了操作系统内核，大部分操作系统的运行库也都是 C/C++ 编写的。所以，Python 跟 C/C++ 整合，可以带来第三个好处——跟操作系统的整合。关于这点，待会儿俺还会专门聊。

## 跟 JVM（Java） 整合

通过 Jython 这个开源项目，Python 可以无缝整合到 JVM 环境中。如此一来，Python 能直接调用所有 JVM 标准库（比如 JDBC）和第三方库（比如 Lucene），还可以跟各种 JVM 语言（比如“Java、Scale、Groovy”等）进行互操作。

## 跟 dotNet 整合

通过 IronPython 这个开源项目，Python 可以无缝整合到 dotNet 环境中。如此一来，Python 能直接调用所有 dotNet 的标准库（比如 ADO.NET）和第三方库，还可以跟各种 dotNet 语言（比如“C#、F#”等）进行互操作。

顺便说一下：Jython 跟 IronPython 貌似同一个作者，牛人啊！

# 功能强大之2——既可以跨平台，又可以跟操作系统深度整合

## Python 语言如何体现“跨平台性”？

说到跨平台这个话题，俺给编程语言分一下类：

1. 可以跨平台，但无法跟操作系统深度耦合（比如 JavaScript、PHP）

2. 可以跟操作系统深度耦合，但无法跨平台（比如 VB、VBScript）

3. 既可以跨平台，又可以跟操作系统深度耦合（比如 C C++ Python）

为啥第三类语言能做到两者兼得？因为这类语言把选择权留给了程序猿——

一方面，如果程序猿遵循跨平台的开发规范，那么写出来的代码就是跨平台的；

另一方面，程序猿也可以写出跟系统耦合很紧密的代码——这样的代码虽然不能跨平台，但可以发挥特定平台的强项。

显然俺喜欢第三类编程语言，因为这类语言给了程序猿自由。

## Python 语言如何“与操作系统深度整合”？

Python 的跨平台特性，懂 Python 的同学估计都晓得了。所以俺单独说一下 Python 如何跟操作系统深度整合。为了照顾到大多数人，俺拿 Windows 来说事儿。

在 Python 社区有一个很有名气的库，叫做 PyWin32。通过这个库，可以让 Python 代码很容易地调用 Windows 的 API 以及 COM 组件。

比方说，可以用 Python 代码直接操作 Windows 注册表

比方说，可以用 Python 代码直接读写 Windows 的系统日志

比方说，可以用 Python 代码直接操作某个窗口句柄

比方说，可以利用 COM 组件，直接调用 Word 来处理 doc 格式的文档

......

# 功能强大之3——具有很丰富的第三方模块

最后一个方面，也是最重要的一个方面，就是 Python 社区具有非常非常丰富的资源（第三方库），而且几乎都是开源的。形形色色的编程领域几乎都可以看到 Python 的身影。

为了让众多程序员读者领略 Python 的丰富资源，俺特地整理了一个 wiki 页面（请用鼠标猛击“这里”），放上 Python 在各个编程领域的常用模块。为了显示出 Python 代码的简洁，某些模块还放上示例代码。

最后感叹一下：

写这篇博文只花了不到一小时，而整理这个 wiki 页面累计超过10个小时。不过这时间没白花——整理的时候顺便对某些领域有了更多的了解。这也就是写博客的好处，既可以帮助别人，又可以帮助自己。

大伙儿如果觉得俺整理的清单有遗漏，欢迎到本页面留言补充。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明**
>
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址： 
>
> <a href="https://program-think.blogspot.com/2013/02/why-choose-python-5-tools.html">https://program-think.blogspot.com/2013/02/why-choose-python-5-tools.html</a>

2019 年 8 月 16 日.html | 浏览器A到Zhtml

.html | 浏览器A到Z

.html转载和二次创作