An interesting collection of surprising snippets and lesser-known Python features.
+一些有趣且鲜为人知的 Python 特性.
-[![WTFPL 2.0][license-image]][license-url] [![Commit id][commit-image]][commit-url] + +[![WTFPL 2.0][license-image]][license-url] [![Commit id][commit-image]][commit-url] [![996.icu][996.icu-image]][996.icu-url] -Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious to a regular user at first sight. -Here is a fun project to collect such tricky & counter-intuitive examples and lesser-known features in Python, attempting to discuss what exactly is happening under the hood! +Python, 是一个设计优美的解释型高级语言, 它提供了很多能让程序员感到舒适的功能特性. 但有的时候, Python 的一些输出结果对于初学者来说似乎并不是那么一目了然. -While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I think you'll find them interesting as well! +这个有趣的项目意在收集 Python 中那些难以理解和反人类直觉的例子以及鲜为人知的功能特性, 并尝试讨论这些现象背后真正的原理! -If you're an experienced Python programmer, you can take it as a challenge to get most of them right in first attempt. You may be already familiar with some of these examples, and I might be able to revive sweet old memories of yours being bitten by these gotchas :sweat_smile: +虽然下面的有些例子并不一定会让你觉得 WTFs, 但它们依然有可能会告诉你一些你所不知道的 Python 有趣特性. 我觉得这是一种学习编程语言内部原理的好办法, 而且我相信你也会从中获得乐趣! -PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/). +如果您是一位经验比较丰富的 Python 程序员, 你可以尝试挑战看是否能一次就找到例子的正确答案. 你可能对其中的一些例子已经比较熟悉了, 那这也许能唤起你当年踩这些坑时的甜蜜回忆 :sweat_smile: -So, here we go... +PS: 如果你不是第一次读了, 你可以在[这里](https://github.com/satwikkansal/wtfpython/releases/)获取变动内容. -# Table of Contents +那么, 让我们开始吧... + +# Table of Contents/目录 -- [Table of Contents](#table-of-contents) -- [Structure of the Examples](#structure-of-the-examples) -- [Usage](#usage) -- [👀 Examples](#👀-examples) - - [Section: Strain your brain!](#section-strain-your-brain) - - [> Strings can be tricky sometimes *](#-strings-can-be-tricky-sometimes-) - - [> Time for some hash brownies!](#-time-for-some-hash-brownies) - - [> Return return everywhere!](#-return-return-everywhere) - - [> Deep down, we're all the same. *](#-deep-down-were-all-the-same-) - - [> For what?](#-for-what) - - [> Evaluation time discrepancy](#-evaluation-time-discrepancy) - - [> `is` is not what it is!](#-is-is-not-what-it-is) - - [> A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) - - [> The sticky output function](#-the-sticky-output-function) - - [> `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) - - [> The surprising comma](#-the-surprising-comma) - - [> Backslashes at the end of string](#-backslashes-at-the-end-of-string) - - [> not knot!](#-not-knot) - - [> Half triple-quoted strings](#-half-triple-quoted-strings) - - [> Midnight time doesn't exist?](#-midnight-time-doesnt-exist) - - [> What's wrong with booleans?](#-whats-wrong-with-booleans) - - [> Class attributes and instance attributes](#-class-attributes-and-instance-attributes) - - [> yielding None](#-yielding-none) - - [> Mutating the immutable!](#-mutating-the-immutable) - - [> The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) - - [> When True is actually False](#-when-true-is-actually-false) - - [> From filled to None in one instruction...](#-from-filled-to-none-in-one-instruction) - - [> Subclass relationships *](#-subclass-relationships-) - - [> The mysterious key type conversion *](#-the-mysterious-key-type-conversion-) - - [> Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) - - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) - - [> Skipping lines?](#-skipping-lines) - - [> Teleportation *](#-teleportation-) - - [> Well, something is fishy...](#-well-something-is-fishy) - - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines) - - [> Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it) - - [> Stubborn `del` operator *](#-stubborn-del-operator-) - - [> Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) - - [> Loop variables leaking out!](#-loop-variables-leaking-out) - - [> Beware of default mutable arguments!](#-beware-of-default-mutable-arguments) - - [> Catching the Exceptions](#-catching-the-exceptions) - - [> Same operands, different story!](#-same-operands-different-story) - - [> The out of scope variable](#-the-out-of-scope-variable) - - [> Be careful with chained operations](#-be-careful-with-chained-operations) - - [> Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) - - [> Needle in a Haystack](#-needle-in-a-haystack) - - [Section: The Hidden treasures!](#section-the-hidden-treasures) - - [> Okay Python, Can you make me fly? *](#-okay-python-can-you-make-me-fly-) - - [> `goto`, but why? *](#-goto-but-why-) - - [> Brace yourself! *](#-brace-yourself-) - - [> Let's meet Friendly Language Uncle For Life *](#-lets-meet-friendly-language-uncle-for-life-) - - [> Even Python understands that love is complicated *](#-even-python-understands-that-love-is-complicated-) - - [> Yes, it exists!](#-yes-it-exists) - - [> Inpinity *](#-inpinity-) - - [> Mangling time! *](#-mangling-time-) - - [Section: Miscellaneous](#section-miscellaneous) - - [> `+=` is faster](#--is-faster) - - [> Let's make a giant string!](#-lets-make-a-giant-string) - - [> Explicit typecast of strings](#-explicit-typecast-of-strings) - - [> Minor Ones](#-minor-ones) -- [Contributing](#contributing) -- [Acknowledgements](#acknowledgements) -- [🎓 License](#🎓-license) - - [Help](#help) - - [Want to surprise your geeky pythonist friends?](#want-to-surprise-your-geeky-pythonist-friends) - - [Need a pdf version?](#need-a-pdf-version) - - [Follow Commit](#follow-commit) +- [Table of Contents/目录](#table-of-contents目录) +- [Structure of the Examples/示例结构](#structure-of-the-examples示例结构) +- [Usage/用法](#usage用法) +- [👀 Examples/示例](#-examples示例) + - [Section: Strain your brain!/大脑运动!](#section-strain-your-brain大脑运动) + - [> Strings can be tricky sometimes/微妙的字符串 *](#-strings-can-be-tricky-sometimes微妙的字符串-) + - [> Time for some hash brownies!/是时候来点蛋糕了!](#-time-for-some-hash-brownies是时候来点蛋糕了) + - [> Return return everywhere!/到处返回！](#-return-return-everywhere到处返回) + - [> Deep down, we're all the same./本质上,我们都一样. *](#-deep-down-were-all-the-same本质上我们都一样-) + - [> For what?/为什么?](#-for-what为什么) + - [> Evaluation time discrepancy/执行时机差异](#-evaluation-time-discrepancy执行时机差异) + - [> `is` is not what it is!/出人意料的`is`!](#-is-is-not-what-it-is出人意料的is) + - [> A tic-tac-toe where X wins in the first attempt!/一蹴即至!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt一蹴即至) + - [> The sticky output function/麻烦的输出](#-the-sticky-output-function麻烦的输出) + - [> `is not ...` is not `is (not ...)`/`is not ...` 不是 `is (not ...)`](#-is-not--is-not-is-not-is-not--不是-is-not-) + - [> The surprising comma/意外的逗号](#-the-surprising-comma意外的逗号) + - [> Backslashes at the end of string/字符串末尾的反斜杠](#-backslashes-at-the-end-of-string字符串末尾的反斜杠) + - [> not knot!/别纠结!](#-not-knot别纠结) + - [> Half triple-quoted strings/三个引号](#-half-triple-quoted-strings三个引号) + - [> Midnight time doesn't exist?/不存在的午夜?](#-midnight-time-doesnt-exist不存在的午夜) + - [> What's wrong with booleans?/布尔你咋了?](#-whats-wrong-with-booleans布尔你咋了) + - [> Class attributes and instance attributes/类属性和实例属性](#-class-attributes-and-instance-attributes类属性和实例属性) + - [> yielding None/生成 None](#-yielding-none生成-none) + - [> Mutating the immutable!/强人所难](#-mutating-the-immutable强人所难) + - [> The disappearing variable from outer scope/消失的外部变量](#-the-disappearing-variable-from-outer-scope消失的外部变量) + - [> When True is actually False/真亦假](#-when-true-is-actually-false真亦假) + - [> From filled to None in one instruction.../从有到无...](#-from-filled-to-none-in-one-instruction从有到无) + - [> Subclass relationships/子类关系 *](#-subclass-relationships子类关系-) + - [> The mysterious key type conversion/神秘的键型转换 *](#-the-mysterious-key-type-conversion神秘的键型转换-) + - [> Let's see if you can guess this?/看看你能否猜到这一点?](#-lets-see-if-you-can-guess-this看看你能否猜到这一点) + - [Section: Appearances are deceptive!/外表是靠不住的!](#section-appearances-are-deceptive外表是靠不住的) + - [> Skipping lines?/跳过一行?](#-skipping-lines跳过一行) + - [> Teleportation/空间移动 *](#-teleportation空间移动-) + - [> Well, something is fishy.../嗯, 有些可疑...](#-well-something-is-fishy嗯有些可疑) + - [Section: Watch out for the landmines!/小心地雷!](#section-watch-out-for-the-landmines小心地雷) + - [> Modifying a dictionary while iterating over it/迭代字典时的修改](#-modifying-a-dictionary-while-iterating-over-it迭代字典时的修改) + - [> Stubborn `del` operator/坚强的 `del` *](#-stubborn-del-operator坚强的-del-) + - [> Deleting a list item while iterating/迭代列表时删除元素](#-deleting-a-list-item-while-iterating迭代列表时删除元素) + - [> Loop variables leaking out!/循环变量泄漏!](#-loop-variables-leaking-out循环变量泄漏) + - [> Beware of default mutable arguments!/当心默认的可变参数!](#-beware-of-default-mutable-arguments当心默认的可变参数) + - [> Catching the Exceptions/捕获异常](#-catching-the-exceptions捕获异常) + - [> Same operands, different story!/同人不同命!](#-same-operands-different-story同人不同命) + - [> The out of scope variable/外部作用域变量](#-the-out-of-scope-variable外部作用域变量) + - [> Be careful with chained operations/小心链式操作](#-be-careful-with-chained-operations小心链式操作) + - [> Name resolution ignoring class scope/忽略类作用域的名称解析](#-name-resolution-ignoring-class-scope忽略类作用域的名称解析) + - [> Needle in a Haystack/大海捞针](#-needle-in-a-haystack大海捞针) + - [Section: The Hidden treasures!/隐藏的宝藏!](#section-the-hidden-treasures隐藏的宝藏) + - [> Okay Python, Can you make me fly?/Python, 可否带我飞? *](#-okay-python-can-you-make-me-flypython-可否带我飞-) + - [> `goto`, but why?/`goto`, 但为什么? *](#-goto-but-whygoto-但为什么-) + - [> Brace yourself!/做好思想准备 *](#-brace-yourself做好思想准备-) + - [> Let's meet Friendly Language Uncle For Life/让生活更友好 *](#-lets-meet-friendly-language-uncle-for-life让生活更友好-) + - [> Even Python understands that love is complicated/连Python也知道爱是难言的 *](#-even-python-understands-that-love-is-complicated连Python也知道爱是难言的-) + - [> Yes, it exists!/是的, 它存在!](#-yes-it-exists是的-它存在) + - [> Inpinity/无限 *](#-inpinity无限-) + - [> Mangling time!修饰时间! *](#-mangling-time修饰时间-) + - [Section: Miscellaneous/杂项](#section-miscellaneous杂项) + - [> `+=` is faster/更快的 `+=` ](#--is-faster更快的-) + - [> Let's make a giant string!/来做个巨大的字符串吧!](#-lets-make-a-giant-string来做个巨大的字符串吧) + - [> Explicit typecast of strings/字符串的显式类型转换](#-explicit-typecast-of-strings字符串的显式类型转换) + - [> Minor Ones/小知识点](#-minor-ones小知识点) +- [Contributing/贡献](#contributing贡献) +- [Acknowledgements/致谢](#acknowledgements致谢) +- [🎓 License/许可](#-license许可) + - [Help/帮助](#help帮助) + - [Surprise your geeky pythonist friends?/想给你的极客朋友一个惊喜?](#surprise-your-geeky-pythonist-friends想给你的极客朋友一个惊喜) + - [Need a pdf version?/需要来一份pdf版的?](#need-a-pdf-version需要来一份pdf版的) + - [Follow Commit/追踪Commit](#follow-commit追踪Commit) + - [996.icu](#996icu) -# Structure of the Examples +# Structure of the Examples/示例结构 -All the examples are structured like below: +所有示例的结构都如下所示: -> ### > Some fancy Title * -> The asterisk at the end of the title indicates the example was not present in the first release and has been recently added. +> ### > 一个精选的标题 * +> 标题末尾的星号表示该示例在第一版中不存在，是最近添加的. > > ```py -> # Setting up the code. -> # Preparation for the magic... +> # 准备代码. +> # 释放魔法... > ``` > > **Output (Python version):** > ```py -> >>> triggering_statement -> Probably unexpected output +> >>> 触发语句 +> 出乎意料的输出结果 > ``` -> (Optional): One line describing the unexpected output. +> (可选): 对意外输出结果的简短描述. > > -> #### 💡 Explanation: +> #### 💡 说明: > -> * Brief explanation of what's happening and why is it happening. +> * 简要说明发生了什么以及为什么会发生. > ```py -> Setting up examples for clarification (if necessary) +> 如有必要, 举例说明 > ``` > **Output:** > ```py -> >>> trigger # some example that makes it easy to unveil the magic -> # some justified output +> >>> 触发语句 # 一些让魔法变得容易理解的例子 +> # 一些正常的输入 > ``` -**Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified in the description. +**注意:** 所有的示例都在 Python 3.5.2 版本的交互解释器上测试过, 如果不特别说明应该适用于所有 Python 版本. -# Usage +# Usage/用法 -A nice way to get the most out of these examples, in my opinion, will be just to read the examples chronologically, and for every example: -- Carefully read the initial code for setting up the example. If you're an experienced Python programmer, most of the times you will successfully anticipate what's going to happen next. -- Read the output snippets and, - + Check if the outputs are the same as you'd expect. - + Make sure if you know the exact reason behind the output being the way it is. - - If no, take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfPython)). - - If yes, give a gentle pat on your back, and you may skip to the next example. +我个人建议, 最好依次阅读下面的示例, 并对每个示例: +- 仔细阅读设置例子最开始的代码. 如果您是一位经验丰富的 Python 程序员, 那么大多数时候您都能成功预期到后面的结果. +- 阅读输出结果, + + 确认结果是否如你所料. + + 确认你是否知道这背后的原理. + - 如果不知道, 深呼吸然后阅读说明 (如果你还是看不明白, 别沉默! 可以在[这](https://github.com/satwikkansal/wtfPython)提个 issue). + - 如果知道, 给自己点奖励, 然后去看下一个例子. -PS: You can also read WTFpython at the command line. There's a pypi package and an npm package (supports colored formatting) for the same. +PS: 你也可以在命令行阅读 WTFpython. 我们有 pypi 包 和 npm 包(支持代码高亮).(译: 这两个都是英文版的) -To install the npm package [`wtfpython`](https://www.npmjs.com/package/wtfpython) +安装 npm 包 [`wtfpython`](https://www.npmjs.com/package/wtfpython) ```sh $ npm install -g wtfpython ``` -Alternatively, to install the pypi package [`wtfpython`](https://pypi.python.org/pypi/wtfpython) +或者, 安装 pypi 包 [`wtfpython`](https://pypi.python.org/pypi/wtfpython) ```sh $ pip install wtfpython -U ``` -Now, just run `wtfpython` at the command line which will open this collection in your selected `$PAGER`. +现在, 在命令行中运行 `wtfpython`, 你就可以开始浏览了. --- -# 👀 Examples +# 👀 Examples/示例 -## Section: Strain your brain! +## Section: Strain your brain!/大脑运动! -### > Strings can be tricky sometimes * +### > Strings can be tricky sometimes/微妙的字符串 * 1\. ```py >>> a = "some_string" >>> id(a) 140420665652016 ->>> id("some" + "_" + "string") # Notice that both the ids are same. +>>> id("some" + "_" + "string") # 注意两个的id值是相同的. 140420665652016 ``` @@ -179,7 +185,7 @@ True False >>> a, b = "wtf!", "wtf!" ->>> a is b +>>> a is b # 仅适用于3.7版本以下, 3.7以后的返回结果为False. True ``` @@ -191,23 +197,26 @@ True False ``` -Makes sense, right? +很好理解, 对吧? + +#### 💡 说明: +- 这些行为是由于 Cpython 在编译优化时, 某些情况下会尝试使用已经存在的不可变对象而不是每次都创建一个新对象. (这种行为被称作字符串的驻留[string interning]) +- 发生驻留之后, 许多变量可能指向内存中的相同字符串对象. (从而节省内存) +- 在上面的代码中, 字符串是隐式驻留的. 何时发生隐式驻留则取决于具体的实现. 这里有一些方法可以用来猜测字符串是否会被驻留: + - 所有长度为 0 和长度为 1 的字符串都被驻留. + - 字符串在编译时被实现 (`'wtf'` 将被驻留, 但是 `''.join(['w', 't', 'f']` 将不会被驻留) + - 字符串中只包含字母，数字或下划线时将会驻留. 所以 `'wtf!'` 由于包含 `!` 而未被驻留. 可以在[这里](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)找到 CPython 对此规则的实现. -#### 💡 Explanation: -+ Such behavior is due to CPython optimization (called string interning) that tries to use existing immutable objects in some cases rather than creating a new object every time. -+ After being interned, many variables may point to the same string object in memory (thereby saving memory). -+ In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation dependent. There are some facts that can be used to guess if a string will be interned or not: - * All length 0 and length 1 strings are interned. - * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned) - * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`. Cpython implementation of this rule can be found [here](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) -
-+ When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `wtf!` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above). It's a compiler optimization and specifically applies to the interactive environment.
-+ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
+
+
+- 当在同一行将 `a` 和 `b` 的值设置为 `"wtf!"` 的时候, Python 解释器会创建一个新对象, 然后同时引用第二个变量(译: 仅适用于3.7以下, 详细情况请看[这里](https://github.com/leisurelicht/wtfpython-cn/issues/13)). 如果你在不同的行上进行赋值操作, 它就不会“知道”已经有一个 `wtf！` 对象 (因为 `"wtf!"` 不是按照上面提到的方式被隐式驻留的). 它是一种编译器优化, 特别适用于交互式环境.
+- 常量折叠(constant folding) 是 Python 中的一种 [窥孔优化(peephole optimization)](https://en.wikipedia.org/wiki/Peephole_optimization) 技术. 这意味着在编译时表达式 `'a'*20` 会被替换为 `'aaaaaaaaaaaaaaaaaaaa'` 以减少运行时的时钟周期. 只有长度小于 20 的字符串才会发生常量折叠. (为啥? 想象一下由于表达式 `'a'*10**10` 而生成的 `.pyc` 文件的大小). 相关的源码实现在[这里](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288).
---
-### > Time for some hash brownies!
+### > Time for some hash brownies!/是时候来点蛋糕了!
+* hash brownie指一种含有大麻成分的蛋糕, 所以这里是句双关
1\.
```py
@@ -227,25 +236,25 @@ some_dict[5] = "Python"
"Python"
```
-"Python" destroyed the existence of "JavaScript"?
+"Python" 消除了 "JavaScript" 的存在?
-#### 💡 Explanation
+#### 💡 说明:
-* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.
-* Immutable objects with same value always have the same hash in Python.
+* Python 字典通过检查键值是否相等和比较哈希值来确定两个键是否相同.
+* 具有相同值的不可变对象在Python中始终具有相同的哈希值.
```py
>>> 5 == 5.0
True
>>> hash(5) == hash(5.0)
True
```
- **Note:** Objects with different values may also have same hash (known as hash collision).
-* When the statement `some_dict[5] = "Python"` is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.
-* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains beautifully the rationale behind it.
+ **注意:** 具有不同值的对象也可能具有相同的哈希值（哈希冲突）.
+* 当执行 `some_dict[5] = "Python"` 语句时, 因为Python将 `5` 和 `5.0` 识别为 `some_dict` 的同一个键, 所以已有值 "JavaScript" 就被 "Python" 覆盖了.
+* 这个 StackOverflow的 [回答](https://stackoverflow.com/a/32211042/4354153) 漂亮的解释了这背后的基本原理.
---
-### > Return return everywhere!
+### > Return return everywhere!/到处返回！
```py
def some_func():
@@ -261,14 +270,14 @@ def some_func():
'from_finally'
```
-#### 💡 Explanation:
+#### 💡 说明:
-- When a `return`, `break` or `continue` statement is executed in the `try` suite of a "try…finally" statement, the `finally` clause is also executed ‘on the way out.
-- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed.
+- 当在 "try...finally" 语句的 `try` 中执行 `return`, `break` 或 `continue` 后, `finally` 子句依然会执行.
+- 函数的返回值由最后执行的 `return` 语句决定. 由于 `finally` 子句一定会执行, 所以 `finally` 子句中的 `return` 将始终是最后执行的语句.
---
-### > Deep down, we're all the same. *
+### > Deep down, we're all the same./本质上,我们都一样. *
```py
class WTF:
@@ -277,22 +286,22 @@ class WTF:
**Output:**
```py
->>> WTF() == WTF() # two different instances can't be equal
+>>> WTF() == WTF() # 两个不同的对象应该不相等
False
->>> WTF() is WTF() # identities are also different
+>>> WTF() is WTF() # 也不相同
False
->>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well
+>>> hash(WTF()) == hash(WTF()) # 哈希值也应该不同
True
>>> id(WTF()) == id(WTF())
True
```
-#### 💡 Explanation:
+#### 💡 说明:
-* When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed.
-* When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same.
-* So, object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.
-* But why did the `is` operator evaluated to `False`? Let's see with this snippet.
+* 当调用 `id` 函数时, Python 创建了一个 `WTF` 类的对象并传给 `id` 函数. 然后 `id` 函数获取其id值 (也就是内存地址), 然后丢弃该对象. 该对象就被销毁了.
+* 当我们连续两次进行这个操作时, Python会将相同的内存地址分配给第二个对象. 因为 (在CPython中) `id` 函数使用对象的内存地址作为对象的id值, 所以两个对象的id值是相同的.
+* 综上, 对象的id值仅仅在对象的生命周期内唯一. 在对象被销毁之后, 或被创建之前, 其他对象可以具有相同的id值.
+* 那为什么 `is` 操作的结果为 `False` 呢? 让我们看看这段代码.
```py
class WTF(object):
def __init__(self): print("I")
@@ -314,11 +323,11 @@ True
D
True
```
- As you may observe, the order in which the objects are destroyed is what made all the difference here.
+ 正如你所看到的, 对象销毁的顺序是造成所有不同之处的原因.
---
-### > For what?
+### > For what?/为什么?
```py
some_string = "wtf"
@@ -329,18 +338,19 @@ for i, some_dict[i] in enumerate(some_string):
**Output:**
```py
->>> some_dict # An indexed dict is created.
+>>> some_dict # 创建了索引字典.
{0: 'w', 1: 't', 2: 'f'}
```
-#### 💡 Explanation:
+#### 💡 说明:
-* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:
+* [Python 语法](https://docs.python.org/3/reference/grammar.html) 中对 `for` 的定义是:
```
for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
```
- Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.
- An interesting example that illustrates this:
+ 其中 `exprlist` 指分配目标. 这意味着对可迭代对象中的**每一项都会执行**类似 `{exprlist} = {next_value}` 的操作.
+
+ 一个有趣的例子说明了这一点:
```py
for i in range(4):
print(i)
@@ -355,13 +365,13 @@ for i, some_dict[i] in enumerate(some_string):
3
```
- Did you expect the loop to run just once?
+ 你可曾觉得这个循环只会运行一次?
- **💡 Explanation:**
+ **💡 说明:**
- - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case).
+ - 由于循环在Python中工作方式, 赋值语句 `i = 10` 并不会影响迭代循环, 在每次迭代开始之前, 迭代器(这里指 `range(4)`) 生成的下一个元素就被解包并赋值给目标列表的变量(这里指 `i`)了.
-* The `enumerate(some_string)` function yields a new value `i` (A counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:
+* 在每一次的迭代中, `enumerate(some_string)` 函数就生成一个新值 `i` (计数器增加) 并从 `some_string` 中获取一个字符. 然后将字典 `some_dict` 键 `i` (刚刚分配的) 的值设为该字符. 本例中循环的展开可以简化为:
```py
>>> i, some_dict[i] = (0, 'w')
>>> i, some_dict[i] = (1, 't')
@@ -371,7 +381,7 @@ for i, some_dict[i] in enumerate(some_string):
---
-### > Evaluation time discrepancy
+### > Evaluation time discrepancy/执行时机差异
1\.
```py
@@ -407,19 +417,19 @@ array_2[:] = [1,2,3,4,5]
[1,2,3,4,5]
```
-#### 💡 Explanation
+#### 💡 说明
-- In a [generator](https://wiki.python.org/moin/Generators) expression, the `in` clause is evaluated at declaration time, but the conditional clause is evaluated at runtime.
-- So before runtime, `array` is re-assigned to the list `[2, 8, 22]`, and since out of `1`, `8` and `15`, only the count of `8` is greater than `0`, the generator only yields `8`.
-- The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values.
-- In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).
-- In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).
+- 在[生成器](https://wiki.python.org/moin/Generators)表达式中, `in` 子句在声明时执行, 而条件子句则是在运行时执行.
+- 所以在运行前, `array` 已经被重新赋值为 `[2, 8, 22]`, 因此对于之前的 `1`, `8` 和 `15`, 只有 `count(8)` 的结果是大于 `0` 的, 所以生成器只会生成 `8`.
+- 第二部分中 `g1` 和 `g2` 的输出差异则是由于变量 `array_1` 和 `array_2` 被重新赋值的方式导致的.
+- 在第一种情况下, `array_1` 被绑定到新对象 `[1,2,3,4,5]`, 因为 `in` 子句是在声明时被执行的， 所以它仍然引用旧对象 `[1,2,3,4]`(并没有被销毁).
+- 在第二种情况下, 对 `array_2` 的切片赋值将相同的旧对象 `[1,2,3,4]` 原地更新为 `[1,2,3,4,5]`. 因此 `g2` 和 `array_2` 仍然引用同一个对象(这个对象现在已经更新为 `[1,2,3,4,5]`).
---
-### > `is` is not what it is!
+### > `is` is not what it is!/出人意料的`is`!
-The following is a very famous example present all over the internet.
+下面是一个在互联网上非常有名的例子.
```py
>>> a = 256
@@ -437,26 +447,26 @@ False
True
```
-#### 💡 Explanation:
+#### 💡 说明:
-**The difference between `is` and `==`**
+**`is` 和 `==` 的区别**
-* `is` operator checks if both the operands refer to the same object (i.e., it checks if the identity of the operands matches or not).
-* `==` operator compares the values of both the operands and checks if they are the same.
-* So `is` is for reference equality and `==` is for value equality. An example to clear things up,
+* `is` 运算符检查两个运算对象是否引用自同一对象 (即, 它检查两个预算对象是否相同).
+* `==` 运算符比较两个运算对象的值是否相等.
+* 因此 `is` 代表引用相同, `==` 代表值相等. 下面的例子可以很好的说明这点,
```py
>>> [] == []
True
- >>> [] is [] # These are two empty lists at two different memory locations.
+ >>> [] is [] # 这两个空列表位于不同的内存地址.
False
```
-**`256` is an existing object but `257` isn't**
+**`256` 是一个已经存在的对象, 而 `257` 不是**
-When you start up python the numbers from `-5` to `256` will be allocated. These numbers are used a lot, so it makes sense just to have them ready.
+当你启动Python 的时候, `-5` 到 `256` 的数值就已经被分配好了. 这些数字因为经常使用所以适合被提前准备好.
-Quoting from https://docs.python.org/3/c-api/long.html
-> The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you just get back a reference to the existing object. So it should be possible to change the value of 1. I suspect the behavior of Python, in this case, is undefined. :-)
+引用自 https://docs.python.org/3/c-api/long.html
+> 当前的实现为-5到256之间的所有整数保留一个整数对象数组, 当你创建了一个该范围内的整数时, 你只需要返回现有对象的引用. 所以改变1的值是有可能的. 我怀疑这种行为在Python中是未定义行为. :-)
```py
>>> id(256)
@@ -477,9 +487,9 @@ Quoting from https://docs.python.org/3/c-api/long.html
140084850247344
```
-Here the interpreter isn't smart enough while executing `y = 257` to recognize that we've already created an integer of the value `257,` and so it goes on to create another object in the memory.
+这里解释器并没有智能到能在执行 `y = 257` 时意识到我们已经创建了一个整数 `257`, 所以它在内存中又新建了另一个对象.
-**Both `a` and `b` refer to the same object when initialized with same value in the same line.**
+**当 `a` 和 `b` 在同一行中使用相同的值初始化时，会指向同一个对象.**
```py
>>> a, b = 257, 257
@@ -495,17 +505,17 @@ Here the interpreter isn't smart enough while executing `y = 257` to recognize t
140640774013488
```
-* When a and b are set to `257` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `257` as an object.
-* It's a compiler optimization and specifically applies to the interactive environment. When you enter two lines in a live interpreter, they're compiled separately, therefore optimized separately. If you were to try this example in a `.py` file, you would not see the same behavior, because the file is compiled all at once.
+* 当 a 和 b 在同一行中被设置为 `257` 时, Python 解释器会创建一个新对象, 然后同时引用第二个变量. 如果你在不同的行上进行, 它就不会 "知道" 已经存在一个 `257` 对象了.
+* 这是一种特别为交互式环境做的编译器优化. 当你在实时解释器中输入两行的时候, 他们会单独编译, 因此也会单独进行优化. 如果你在 `.py` 文件中尝试这个例子, 则不会看到相同的行为, 因为文件是一次性编译的.
---
-### > A tic-tac-toe where X wins in the first attempt!
+### > A tic-tac-toe where X wins in the first attempt!/一蹴即至!
```py
-# Let's initialize a row
+# 我们先初始化一个变量row
row = [""]*3 #row i['', '', '']
-# Let's make a board
+# 并创建一个变量board
board = [row]*3
```
@@ -522,19 +532,19 @@ board = [row]*3
[['X', '', ''], ['X', '', ''], ['X', '', '']]
```
-We didn't assign 3 "X"s or did we?
+我们有没有赋值过3个 "X" 呢？
-#### 💡 Explanation:
+#### 💡 说明:
-When we initialize `row` variable, this visualization explains what happens in the memory
+当我们初始化 `row` 变量时, 下面这张图展示了内存中的情况。
-And when the `board` is initialized by multiplying the `row`, this is what happens inside the memory (each of the elements `board[0]`, `board[1]` and `board[2]` is a reference to the same list referred by `row`)
+而当通过对 `row` 做乘法来初始化 `board` 时, 内存中的情况则如下图所示 (每个元素 `board[0]`, `board[1]` 和 `board[2]` 都和 `row` 一样引用了同一列表.)
-We can avoid this scenario here by not using `row` variable to generate `board`. (Asked in [this](https://github.com/satwikkansal/wtfpython/issues/68) issue).
+我们可以通过不使用变量 `row` 生成 `board` 来避免这种情况. ([这个](https://github.com/satwikkansal/wtfpython/issues/68)issue提出了这个需求.)
```py
>>> board = [['']*3 for _ in range(3)]
@@ -545,7 +555,7 @@ We can avoid this scenario here by not using `row` variable to generate `board`.
---
-### > The sticky output function
+### > The sticky output function/麻烦的输出
```py
funcs = []
@@ -554,7 +564,7 @@ for x in range(7):
def some_func():
return x
funcs.append(some_func)
- results.append(some_func()) # note the function call here
+ results.append(some_func()) # 注意这里函数被执行了
funcs_results = [func() for func in funcs]
```
@@ -566,9 +576,10 @@ funcs_results = [func() for func in funcs]
>>> funcs_results
[6, 6, 6, 6, 6, 6, 6]
```
-Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.
-//OR
+即使每次在迭代中将 `some_func` 加入 `funcs` 前的 `x` 值都不相同, 所有的函数还是都返回6.
+
+// 再换个例子
```py
>>> powers_of_x = [lambda x: x**i for i in range(10)]
@@ -576,11 +587,11 @@ Even when the values of `x` were different in every iteration prior to appending
[512, 512, 512, 512, 512, 512, 512, 512, 512, 512]
```
-#### 💡 Explanation
+#### 💡 说明:
-- When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation.
+- 当在循环内部定义一个函数时, 如果该函数在其主体中使用了循环变量, 则闭包函数将与循环变量绑定, 而不是它的值. 因此, 所有的函数都是使用最后分配给变量的值来进行计算的.
-- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.
+- 可以通过将循环变量作为命名变量传递给函数来获得预期的结果. **为什么这样可行?** 因为这会在函数内再次定义一个局部变量.
```py
funcs = []
@@ -599,7 +610,7 @@ Even when the values of `x` were different in every iteration prior to appending
---
-### > `is not ...` is not `is (not ...)`
+### > `is not ...` is not `is (not ...)`/`is not ...` 不是 `is (not ...)`
```py
>>> 'something' is not None
@@ -608,14 +619,14 @@ True
False
```
-#### 💡 Explanation
+#### 💡 说明:
-- `is not` is a single binary operator, and has behavior different than using `is` and `not` separated.
-- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise.
+- `is not` 是个单独的二元运算符, 与分别使用 `is` 和 `not` 不同.
+- 如果操作符两侧的变量指向同一个对象, 则 `is not` 的结果为 `False`, 否则结果为 `True`.
---
-### > The surprising comma
+### > The surprising comma/意外的逗号
**Output:**
```py
@@ -637,15 +648,14 @@ SyntaxError: invalid syntax
SyntaxError: invalid syntax
```
-#### 💡 Explanation:
-
-- Trailing comma is not always legal in formal parameters list of a Python function.
-- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it.
-- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python.
+#### 💡 说明:
+- 在Python函数的形式参数列表中, 尾随逗号并不一定是合法的.
+- 在Python中, 参数列表部分用前置逗号定义, 部分用尾随逗号定义. 这种冲突导致逗号被夹在中间, 没有规则定义它.(译:这一句看得我也很懵逼,只能强翻了.详细解释看下面的讨论帖会一目了然.)
+- **注意:** 尾随逗号的问题已经在Python 3.6中被[修复](https://bugs.python.org/issue9232)了. 而这篇[帖子](https://bugs.python.org/issue9232#msg248399)中则简要讨论了Python中尾随逗号的不同用法.
---
-### > Backslashes at the end of string
+### > Backslashes at the end of string/字符串末尾的反斜杠
**Output:**
```
@@ -661,18 +671,18 @@ SyntaxError: invalid syntax
SyntaxError: EOL while scanning string literal
```
-#### 💡 Explanation
+#### 💡 说明:
-- In a raw string literal, as indicated by the prefix `r`, the backslash doesn't have the special meaning.
+- 在以 `r` 开头的原始字符串中, 反斜杠并没有特殊含义.
```py
>>> print(repr(r"wt\"f"))
'wt\\"f'
```
-- What the interpreter actually does, though, is simply change the behavior of backslashes, so they pass themselves and the following character through. That's why backslashes don't work at the end of a raw string.
+- 解释器所做的只是简单的改变了反斜杠的行为, 因此会直接放行反斜杠及后一个的字符. 这就是反斜杠在原始字符串末尾不起作用的原因.
---
-### > not knot!
+### > not knot!/别纠结!
```py
x = True
@@ -690,16 +700,16 @@ True
SyntaxError: invalid syntax
```
-#### 💡 Explanation:
+#### 💡 说明:
-* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python.
-* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`.
-* But `x == not y` raises a `SyntaxError` because it can be thought of being equivalent to `(x == not) y` and not `x == (not y)` which you might have expected at first sight.
-* The parser expected the `not` token to be a part of the `not in` operator (because both `==` and `not in` operators have the same precedence), but after not being able to find an `in` token following the `not` token, it raises a `SyntaxError`.
+* 运算符的优先级会影响表达式的求值顺序, 而在 Python 中 `==` 运算符的优先级要高于 `not` 运算符.
+* 所以 `not x == y` 相当于 `not (x == y)`, 同时等价于 `not (True == False)`, 最后的运算结果就是 `True`.
+* 之所以 `x == not y` 会抛一个 `SyntaxError` 异常, 是因为它会被认为等价于 `(x == not) y`, 而不是你一开始期望的 `x == (not y)`.
+* 解释器期望 `not` 标记是 `not in` 操作符的一部分 (因为 `==` 和 `not in` 操作符具有相同的优先级), 但是它在 `not` 标记后面找不到 `in` 标记, 所以会抛出 `SyntaxError` 异常.
---
-### > Half triple-quoted strings
+### > Half triple-quoted strings/三个引号
**Output:**
```py
@@ -707,24 +717,24 @@ SyntaxError: invalid syntax
wtfpython
>>> print("wtfpython""")
wtfpython
->>> # The following statements raise `SyntaxError`
+>>> # 下面的语句会抛出 `SyntaxError` 异常
>>> # print('''wtfpython')
>>> # print("""wtfpython")
```
-#### 💡 Explanation:
-+ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example,
+#### 💡 说明:
++ Python 提供隐式的[字符串链接](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), 例如,
```
>>> print("wtf" "python")
wtfpython
>>> print("wtf" "") # or "wtf"""
wtf
```
-+ `'''` and `"""` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal.
++ `'''` 和 `"""` 在 Python中也是字符串定界符, Python 解释器在先遇到三个引号的的时候会尝试再寻找三个终止引号作为定界符, 如果不存在则会导致 `SyntaxError` 异常.
---
-### > Midnight time doesn't exist?
+### > Midnight time doesn't exist?/不存在的午夜?
```py
from datetime import datetime
@@ -746,20 +756,20 @@ if noon_time:
```sh
('Time at noon is', datetime.time(12, 0))
```
-The midnight time is not printed.
-#### 💡 Explanation:
+midnight_time 并没有被输出.
-Before Python 3.5, the boolean value for `datetime.time` object was considered to be `False` if it represented midnight in UTC. It is error-prone when using the `if obj:` syntax to check if the `obj` is null or some equivalent of "empty."
+#### 💡 说明:
+
+在Python 3.5之前, 如果 `datetime.time` 对象存储的UTC的午夜时间(译: 就是 `00:00`), 那么它的布尔值会被认为是 `False`. 当使用 `if obj:` 语句来检查 `obj` 是否为 `null` 或者某些“空”值的时候, 很容易出错.
---
-### > What's wrong with booleans?
+### > What's wrong with booleans?/布尔你咋了?
1\.
```py
-# A simple example to count the number of boolean and
-# integers in an iterable of mixed data types.
+# 一个简单的例子, 统计下面可迭代对象中的布尔型值的个数和整型值的个数
mixed_list = [False, 1.0, "some_string", 3, True, [], False]
integers_found_so_far = 0
booleans_found_so_far = 0
@@ -803,9 +813,9 @@ another_dict[1.0] = "Python"
''
```
-#### 💡 Explanation:
+#### 💡 说明:
-* Booleans are a subclass of `int`
+* 布尔值是 `int` 的子类
```py
>>> isinstance(True, int)
True
@@ -813,17 +823,17 @@ another_dict[1.0] = "Python"
True
```
-* The integer value of `True` is `1` and that of `False` is `0`.
+* 所以 `True` 的整数值是 `1`, 而 `False` 的整数值是 `0`.
```py
>>> True == 1 == 1.0 and False == 0 == 0.0
True
```
-* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.
+* 关于其背后的原理, 请看这个 StackOverflow 的[回答](https://stackoverflow.com/a/8169049/4354153).
---
-### > Class attributes and instance attributes
+### > Class attributes and instance attributes/类属性和实例属性
1\.
```py
@@ -886,14 +896,14 @@ True
True
```
-#### 💡 Explanation:
+#### 💡 说明:
-* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it.
-* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well.
+* 类变量和实例变量在内部是通过类对象的字典来处理(译: 就是 `__dict__` 属性). 如果在当前类的字典中找不到的话就去它的父类中寻找.
+* `+=` 运算符会在原地修改可变对象, 而不是创建新对象. 因此, 修改一个实例的属性会影响其他实例和类属性.
---
-### > yielding None
+### > yielding None/生成 None
```py
some_iterable = ('a', 'b')
@@ -916,13 +926,13 @@ def some_func(val):
['a', 'something', 'b', 'something']
```
-#### 💡 Explanation:
-- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
-- Related bug report: http://bugs.python.org/issue10544
+#### 💡 说明:
+- 来源和解释可以在这里找到: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
+- 相关错误报告: http://bugs.python.org/issue10544
---
-### > Mutating the immutable!
+### > Mutating the immutable!/强人所难
```py
some_tuple = ("A", "tuple", "with", "values")
@@ -933,7 +943,7 @@ another_tuple = ([1, 2], [3, 4], [5, 6])
```py
>>> some_tuple[2] = "change this"
TypeError: 'tuple' object does not support item assignment
->>> another_tuple[2].append(1000) #This throws no error
+>>> another_tuple[2].append(1000) # 这里不出现错误
>>> another_tuple
([1, 2], [3, 4], [5, 6, 1000])
>>> another_tuple[2] += [99, 999]
@@ -942,20 +952,22 @@ TypeError: 'tuple' object does not support item assignment
([1, 2], [3, 4], [5, 6, 1000, 99, 999])
```
-But I thought tuples were immutable...
+我还以为元组是不可变的呢...
+
+#### 💡 说明:
-#### 💡 Explanation:
+* 引用 https://docs.python.org/2/reference/datamodel.html
-* Quoting from https://docs.python.org/2/reference/datamodel.html
+ > 不可变序列
+ 不可变序列的对象一旦创建就不能再改变. (如果对象包含对其他对象的引用，则这些其他对象可能是可变的并且可能会被修改; 但是，由不可变对象直接引用的对象集合不能更改.)
- > Immutable sequences
- An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.)
+* `+=` 操作符在原地修改了列表. 元素赋值操作并不工作, 但是当异常抛出时, 元素已经在原地被修改了.
-* `+=` operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place.
+(译: 对于不可变对象, 这里指tuple, `+=` 并不是原子操作, 而是 `extend` 和 `=` 两个动作, 这里 `=` 操作虽然会抛出异常, 但 `extend` 操作已经修改成功了. 详细解释可以看[这里](https://segmentfault.com/a/1190000010767068))
---
-### > The disappearing variable from outer scope
+### > The disappearing variable from outer scope/消失的外部变量
```py
e = 7
@@ -977,18 +989,20 @@ except Exception as e:
NameError: name 'e' is not defined
```
-#### 💡 Explanation:
+#### 💡 说明:
-* Source: https://docs.python.org/3/reference/compound_stmts.html#except
+* 出处: https://docs.python.org/3/reference/compound_stmts.html#except
- When an exception has been assigned using `as` target, it is cleared at the end of the except clause. This is as if
+ 当使用 `as` 为目标分配异常的时候, 将在except子句的末尾清除该异常.
+
+ 这就好像
```py
except E as N:
foo
```
- was translated into
+ 会被翻译成
```py
except E as N:
@@ -998,9 +1012,9 @@ NameError: name 'e' is not defined
del N
```
- This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs.
+ 这意味着异常必须在被赋值给其他变量才能在 `except` 子句之后引用它. 而异常之所以会被清除, 则是由于上面附加的回溯信息(trackback)会和栈帧(stack frame)形成循环引用, 使得该栈帧中的所有本地变量在下一次垃圾回收发生之前都处于活动状态.(译: 也就是说不会被回收)
-* The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions which have their separate inner-scopes. The example below illustrates this:
+* 子句在 Python 中并没有独立的作用域. 示例中的所有内容都处于同一作用域内, 所以变量 `e` 会由于执行了 `except` 子句而被删除. 而对于有独立的内部作用域的函数来说情况就不一样了. 下面的例子说明了这一点:
```py
def f(x):
@@ -1023,19 +1037,19 @@ NameError: name 'e' is not defined
[5, 4, 3]
```
-* In Python 2.x the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing.
+* 在 Python 2.x 中, `Exception()` 实例被赋值给了变量 `e`, 所以当你尝试打印结果的时候, 它的输出为空.（译: 正常的Exception实例打印出来就是空）
**Output (Python 2.x):**
```py
>>> e
Exception()
>>> print e
- # Nothing is printed!
+ # 没有打印任何内容!
```
---
-### > When True is actually False
+### > When True is actually False/真亦假
```py
True = False
@@ -1048,14 +1062,14 @@ if True == False:
I've lost faith in truth!
```
-#### 💡 Explanation:
+#### 💡 说明:
-- Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true). Then they added `True`, `False`, and a `bool` type, but, for backward compatibility, they couldn't make `True` and `False` constants- they just were built-in variables.
-- Python 3 was backward-incompatible, so it was now finally possible to fix that, and so this example won't work with Python 3.x!
+- 最初, Python 并没有 `bool` 型 (人们用0表示假值, 用非零值比如1作为真值). 后来他们添加了 `True`, `False`, 和 `bool` 型, 但是, 为了向后兼容, 他们没法把 `True` 和 `False` 设置为常量, 只是设置成了内置变量.
+- Python 3 由于不再需要向后兼容, 终于可以修复这个问题了, 所以这个例子无法在 Python 3.x 中执行!
---
-### > From filled to None in one instruction...
+### > From filled to None in one instruction.../从有到无...
```py
some_list = [1, 2, 3]
@@ -1077,13 +1091,13 @@ None
None
```
-#### 💡 Explanation
+#### 💡 说明:
-Most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list))
+大多数修改序列/映射对象的方法, 比如 `list.append`, `dict.update`, `list.sort` 等等. 都是原地修改对象并返回 `None`. 这样做的理由是, 如果操作可以原地完成, 就可以避免创建对象的副本来提高性能. (参考[这里](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list))
---
-### > Subclass relationships *
+### > Subclass relationships/子类关系 *
**Output:**
```py
@@ -1096,18 +1110,18 @@ True
False
```
-The Subclass relationships were expected to be transitive, right? (i.e., if `A` is a subclass of `B`, and `B` is a subclass of `C`, the `A` _should_ a subclass of `C`)
+子类关系应该是可传递的, 对吧? (即, 如果 `A` 是 `B` 的子类, `B` 是 `C` 的子类, 那么 `A` _应该_ 是 `C` 的子类.)
-#### 💡 Explanation:
+#### 💡 说明:
-* Subclass relationships are not necessarily transitive in Python. Anyone is allowed to define their own, arbitrary `__subclasscheck__` in a metaclass.
-* When `issubclass(cls, Hashable)` is called, it simply looks for non-Falsey "`__hash__`" method in `cls` or anything it inherits from.
-* Since `object` is hashable, but `list` is non-hashable, it breaks the transitivity relation.
-* More detailed explanation can be found [here](https://www.naftaliharris.com/blog/python-subclass-intransitivity/).
+* Python 中的子类关系并不必须是传递的. 任何人都可以在元类中随意定义 `__subclasscheck__`.
+* 当 `issubclass(cls, Hashable)` 被调用时, 它只是在 `cls` 中寻找 "`__hash__`" 方法或继承自"`__hash__`"的方法.
+* 由于 `object` is 可散列的(hashable), 但是 `list` 是不可散列的, 所以它打破了这种传递关系.
+* 在[这里](https://www.naftaliharris.com/blog/python-subclass-intransitivity/)可以找到更详细的解释.
---
-### > The mysterious key type conversion *
+### > The mysterious key type conversion/神秘的键型转换 *
```py
class SomeClass(str):
@@ -1122,18 +1136,18 @@ some_dict = {'s':42}
str
>>> s = SomeClass('s')
>>> some_dict[s] = 40
->>> some_dict # expected: Two different keys-value pairs
+>>> some_dict # 预期: 两个不同的键值对
{'s': 40}
>>> type(list(some_dict.keys())[0])
str
```
-#### 💡 Explanation:
+#### 💡 说明:
-* Both the object `s` and the string `"s"` hash to the same value because `SomeClass` inherits the `__hash__` method of `str` class.
-* `SomeClass("s") == "s"` evaluates to `True` because `SomeClass` also inherits `__eq__` method from `str` class.
-* Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary.
-* For the desired behavior, we can redefine the `__eq__` method in `SomeClass`
+* 由于 `SomeClass` 会从 `str` 自动继承 `__hash__` 方法, 所以 `s` 对象和 `"s"` 字符串的哈希值是相同的.
+* 而 `SomeClass("s") == "s"` 为 `True` 是因为 `SomeClass` 也继承了 `str` 类 `__eq__` 方法.
+* 由于两者的哈希值相同且相等, 所以它们在字典中表示相同的键.
+* 如果想要实现期望的功能, 我们可以重定义 `SomeClass` 的 `__eq__` 方法.
```py
class SomeClass(str):
def __eq__(self, other):
@@ -1143,8 +1157,8 @@ str
and super().__eq__(other)
)
- # When we define a custom __eq__, Python stops automatically inheriting the
- # __hash__ method, so we need to define it as well
+ # 当我们自定义 __eq__ 方法时, Python 不会再自动继承 __hash__ 方法
+ # 所以我们也需要定义它
__hash__ = str.__hash__
some_dict = {'s':42}
@@ -1163,7 +1177,7 @@ str
---
-### > Let's see if you can guess this?
+### > Let's see if you can guess this?/看看你能否猜到这一点?
```py
a, b = a[b] = {}, 5
@@ -1175,24 +1189,24 @@ a, b = a[b] = {}, 5
{5: ({...}, 5)}
```
-#### 💡 Explanation:
+#### 💡 说明:
-* According to [Python language reference](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), assignment statements have the form
+* 根据 [Python 语言参考](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), 赋值语句的形式如下
```
(target_list "=")+ (expression_list | yield_expression)
```
- and
- > An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right.
-* The `+` in `(target_list "=")+` means there can be **one or more** target lists. In this case, target lists are `a, b` and `a[b]` (note the expression list is exactly one, which in our case is `{}, 5`).
+ > 赋值语句计算表达式列表(expression list)(牢记 这可以是单个表达式或以逗号分隔的列表, 后者返回元组)并将单个结果对象从左到右分配给目标列表中的每一项.
+
+* `(target_list "=")+` 中的 `+` 意味着可以有**一个或多个**目标列表. 在这个例子中, 目标列表是 `a, b` 和 `a[b]` (注意表达式列表只能有一个, 在我们的例子中是 `{}, 5`).
-* After the expression list is evaluated, it's value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`.
+* 表达式列表计算结束后, 将其值自动解包后**从左到右**分配给目标列表(target list). 因此, 在我们的例子中, 首先将 `{}, 5` 元组并赋值给 `a, b`, 然后我们就可以得到 `a = {}` 且 `b = 5`.
-* `a` is now assigned to `{}` which is a mutable object.
+* `a` 被赋值的 `{}` 是可变对象.
-* The second target list is `a[b]` (you may expect this to throw an error because both `a` and `b` have not been defined in the statements before. But remember, we just assigned `a` to `{}` and `b` to `5`).
+* 第二个目标列表是 `a[b]` (你可能觉得这里会报错, 因为在之前的语句中 `a` 和 `b` 都还没有被定义. 但是别忘了, 我们刚刚将 `a` 赋值 `{}` 且将 `b` 赋值为 `5`).
-* Now, we are setting the key `5` in the dictionary to the tuple `({}, 5)` creating a circular reference (the `{...}` in the output refers to the same object that `a` is already referencing). Another simpler example of circular reference could be
+* 现在, 我们将通过将字典中键 `5` 的值设置为元组 `({}, 5)` 来创建循环引用 (输出中的 `{...}` 指与 `a` 引用了相同的对象). 下面是一个更简单的循环引用的例子
```py
>>> some_list = some_list[0] = [0]
>>> some_list
@@ -1204,14 +1218,14 @@ a, b = a[b] = {}, 5
>>> some_list[0][0][0][0][0][0] == some_list
True
```
- Similar is the case in our example (`a[b][0]` is the same object as `a`)
+ 我们的例子就是这种情况 (`a[b][0]` 与 `a` 是相同的对象)
-* So to sum it up, you can break the example down to
+* 总结一下, 你也可以把例子拆成
```py
a, b = {}, 5
a[b] = a, b
```
- And the circular reference can be justified by the fact that `a[b][0]` is the same object as `a`
+ 并且可以通过 `a[b][0]` 与 `a` 是相同的对象来证明是循环引用
```py
>>> a[b][0] is a
True
@@ -1221,9 +1235,9 @@ a, b = a[b] = {}, 5
---
-## Section: Appearances are deceptive!
+## Section: Appearances are deceptive!/外表是靠不住的!
-### > Skipping lines?
+### > Skipping lines?/跳过一行?
**Output:**
```py
@@ -1233,43 +1247,43 @@ a, b = a[b] = {}, 5
11
```
-Wut?
+什么鬼?
-**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell.
+**注意:** 如果你想要重现的话最简单的方法是直接复制上面的代码片段到你的文件或命令行里.
-#### 💡 Explanation
+#### 💡 说明:
-Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter.
+一些非西方字符虽然看起来和英语字母相同, 但会被解释器识别为不同的字母.
```py
->>> ord('е') # cyrillic 'e' (Ye)
+>>> ord('е') # 西里尔语的 'e' (Ye)
1077
->>> ord('e') # latin 'e', as used in English and typed using standard keyboard
+>>> ord('e') # 拉丁语的 'e', 用于英文并使用标准键盘输入
101
>>> 'е' == 'e'
False
->>> value = 42 # latin e
->>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here
+>>> value = 42 # 拉丁语 e
+>>> valuе = 23 # 西里尔语 'e', Python 2.x 的解释器在这会抛出 `SyntaxError` 异常
>>> value
42
```
-The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example.
+内置的 `ord()` 函数可以返回一个字符的 Unicode [代码点](https://en.wikipedia.org/wiki/Code_point), 这里西里尔语 'e' 和拉丁语 'e' 的代码点不同证实了上述例子.
---
-### > Teleportation *
+### > Teleportation/空间移动 *
```py
import numpy as np
def energy_send(x):
- # Initializing a numpy array
+ # 初始化一个 numpy 数组
np.array([float(x)])
def energy_receive():
- # Return an empty numpy array
+ # 返回一个空的 numpy 数组
return np.empty((), dtype=np.float).tolist()
```
@@ -1280,21 +1294,21 @@ def energy_receive():
123.456
```
-Where's the Nobel Prize?
+谁来给我发个诺贝尔奖?
-#### 💡 Explanation:
+#### 💡 说明:
-* Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate.
-* `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always).
+* 注意在 `energy_send` 函数中创建的 numpy 数组并没有返回, 因此内存空间被释放并可以被重新分配.
+* `numpy.empty()` 直接返回下一段空闲内存，而不重新初始化. 而这个内存点恰好就是刚刚释放的那个(通常情况下, 并不绝对).
---
-### > Well, something is fishy...
+### > Well, something is fishy.../嗯，有些可疑...
```py
def square(x):
"""
- A simple function to calculate the square of a number by addition.
+ 一个通过加法计算平方的简单函数.
"""
sum_so_far = 0
for counter in range(x):
@@ -1309,17 +1323,17 @@ def square(x):
10
```
-Shouldn't that be 100?
+难道不应该是100吗?
-**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell.
+**注意:** 如果你无法重现, 可以尝试运行这个文件[mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py).
-#### 💡 Explanation
+#### 💡 说明:
-* **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example.
-* This is how Python handles tabs:
- > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...>
-* So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop.
-* Python 3 is kind enough to throw an error for such cases automatically.
+* **不要混用制表符(tab)和空格(space)!** 在上面的例子中, return 的前面是"1个制表符", 而其他部分的代码前面是 "4个空格".
+* Python是这么处理制表符的:
+ > 首先, 制表符会从左到右依次被替换成8个空格, 直到被替换后的字符总数是八的倍数 <...>
+* 因此, `square` 函数最后一行的制表符会被替换成8个空格, 导致return语句进入循环语句里面.
+* Python 3 很友好, 在这种情况下会自动抛出错误.
**Output (Python 3.x):**
```py
@@ -1330,10 +1344,10 @@ Shouldn't that be 100?
---
-## Section: Watch out for the landmines!
+## Section: Watch out for the landmines!/小心地雷!
-### > Modifying a dictionary while iterating over it
+### > Modifying a dictionary while iterating over it/迭代字典时的修改
```py
x = {0: None}
@@ -1357,18 +1371,18 @@ for i in x:
7
```
-Yes, it runs for exactly **eight** times and stops.
+是的, 它运行了**八次**然后才停下来.
-#### 💡 Explanation:
+#### 💡 说明:
-* Iteration over a dictionary that you edit at the same time is not supported.
-* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.
-* How deleted keys are handled and when the resize occurs might be different for different Python implementations.
-* For more information, you may refer to this StackOverflow [thread](https://stackoverflow.com/questions/44763802/bug-in-python-dict) explaining a similar example in detail.
+* Python不支持对字典进行迭代的同时修改它.
+* 它之所以运行8次, 是因为字典会自动扩容以容纳更多键值(我们有8次删除记录, 因此需要扩容). 这实际上是一个实现细节. (译: 应该是因为字典的初始最小值是8, 扩容会导致散列表地址发生变化而中断循环.)
+* 在不同的Python实现中删除键的处理方式以及调整大小的时间可能会有所不同.(译: 就是说什么时候扩容在不同版本中可能是不同的, 在3.6及3.7的版本中到[5](https://github.com/python/cpython/blob/v3.6.1/Objects/dictobject.c#L103-L110)就会自动扩容了. 以后也有可能再次发生变化. 顺带一提,后面两次扩容会扩展为32和256. 8->32->256)
+* 更多的信息, 你可以参考这个StackOverflow的[回答](https://stackoverflow.com/questions/44763802/bug-in-python-dict), 它详细的解释一个类似的例子.
---
-### > Stubborn `del` operator *
+### > Stubborn `del` operator/坚强的 `del` *
```py
class SomeClass:
@@ -1381,37 +1395,38 @@ class SomeClass:
```py
>>> x = SomeClass()
>>> y = x
->>> del x # this should print "Deleted!"
+>>> del x # 这里应该会输出 "Deleted!"
>>> del y
Deleted!
```
-Phew, deleted at last. You might have guessed what saved from `__del__` being called in our first attempt to delete `x`. Let's add more twist to the example.
+唷, 终于删除了. 你可能已经猜到了在我们第一次尝试删除 `x` 时是什么让 `__del__` 免于被调用的. 那让我们给这个例子增加点难度.
2\.
```py
>>> x = SomeClass()
>>> y = x
>>> del x
->>> y # check if y exists
+>>> y # 检查一下y是否存在
<__main__.SomeClass instance at 0x7f98a1a67fc8>
->>> del y # Like previously, this should print "Deleted!"
->>> globals() # oh, it didn't. Let's check all our global variables and confirm
+>>> del y # 像之前一样, 这里应该会输出 "Deleted!"
+>>> globals() # 好吧, 并没有. 让我们看一下所有的全局变量
Deleted!
{'__builtins__':