From 27d73bbc9aeaecdcd494b1ab668b7461353c595e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com>
Date: Sat, 10 Nov 2018 17:41:55 +0800
Subject: [PATCH] EX.Strings can be tricky sometimes

---
 README.md | 38 +++++++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 17 deletions(-)

diff --git a/README.md b/README.md
index dae55fb..3e035d1 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,7 @@ So, here we go...
 - [Usage](#usage)
 - [👀 Examples](#👀-examples)
     - [Section: Strain your brain!](#section-strain-your-brain)
-        - [> Strings can be tricky sometimes *](#-strings-can-be-tricky-sometimes-)
+        - [> 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-)
@@ -155,14 +155,14 @@ Now, just run `wtfpython` at the command line which will open this collection in
 
 ## 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,8 +179,8 @@ True
 False
 
 >>> a, b = "wtf!", "wtf!"
->>> a is b
-True
+>>> a is b 
+True # 3.7 版本返回结果为 False.
 ```
 
 3\.
@@ -188,21 +188,25 @@ True
 >>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
 True
 >>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
-False
+False # 3.7 版本返回结果为 True
 ```
 
-Makes sense, right?
+很好理解, 对吧?
 
-#### 💡 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)
-  <img src="/images/string-intern/string_intern.png" alt="">
-+ 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.
+#### 💡 说明:
+- 这些行为是由于 Cpython 在编译优化时, 某些情况下会尝试使用已经存在的不可变对象而不是每次都创建一个新对象. (这种行为被称作字符串的驻留[string interning])
+- 发生驻留之后, 许多变量可能指向内存中的相同字符串对象. (从而节省内存)
+- 在上面的代码中, 字符串是隐式驻留的. 何时发生隐式驻留则取决于具体的实现. 这里有一些方法可以用来猜测字符串是否会被驻留:
+  - 所有长度为 0 和长度为 1 的字符串都被驻留.
+  - 字符串在编译时被实现 (`'wtf'` 将被驻留, 但是 `''.join(['w', 't', 'f'])` 将不会被驻留)
+  - 字符串中只包含字母，数字或下划线时将会驻留. 所以 `'wtf!'` 由于包含 `!` 而未被驻留. 可以在[这里](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)找到 CPython 对此规则的实现.
+
+    <img src="/images/string-intern/string_intern.png" alt="">
+
+- 当在同一行将 `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).
+- 如果你是使用 3.7 版本中运行上述示例代码, 会发现部分代码的运行结果与注释说明相同. 这是因为在 3.7 版本中, 常量折叠已经从窥孔优化器迁移至新的 AST 优化器, 后者可以以更高的一致性来执行优化. (由 Eugene Toder 和 INADA Naoki 在 [bpo-29469](https://bugs.python.org/issue29469) 和 [bpo-11549](https://bugs.python.org/issue11549) 中贡献.) 
+- (译: 但是在最新的 3.8 版本中, 结果又变回去了. 虽然 3.8 版本和 3.7 版本一样, 都是使用 AST 优化器. 目前不确定官方对 3.8 版本的 AST 做了什么调整.)
 
 
 ---