更改第二章所有变量名、函数、类等文本为代码

K-Guan · K-Guan · commit b31085ea49c5 · 2015-09-18T00:42:55.000+08:00
diff --git a/source/c02/p01_split_string_on_multiple_delimiters.rst b/source/c02/p01_split_string_on_multiple_delimiters.rst
@@ -12,7 +12,7 @@
 ----------
 解决方案
 ----------
-string对象的 ``split()`` 方法只适应于非常简单的字符串分割情形，
+``string`` 对象的 ``split()`` 方法只适应于非常简单的字符串分割情形，
 它并不允许有多个分隔符或者是分隔符周围不确定的空格。
 当你需要更加灵活的切割字符串的时候，最好使用 ``re.split()`` 方法：
 
@@ -29,7 +29,7 @@ string对象的 ``split()`` 方法只适应于非常简单的字符串分割情
 讨论
 ----------
 函数 ``re.split()`` 是非常实用的，因为它允许你为分隔符指定多个正则模式。
-比如，在上面的例子中，分隔符可以是逗号(,)，分号(;)或者是空格，并且后面紧跟着任意个的空格。
+比如，在上面的例子中，分隔符可以是逗号，分号或者是空格，并且后面紧跟着任意个的空格。
 只要这个模式被找到，那么匹配的分隔符两边的实体都会被当成是结果中的元素返回。
 返回结果为一个字段列表，这个跟 ``str.split()`` 返回值类型是一样的。
 
@@ -60,7 +60,7 @@ string对象的 ``split()`` 方法只适应于非常简单的字符串分割情
     >>>
 
 如果你不想保留分割字符串到结果列表中去，但仍然需要使用到括号来分组正则表达式的话，
-确保你的分组是非捕获分组，形如(?:...)。比如：
+确保你的分组是非捕获分组，形如 ``(?:...)`` 。比如：
 
 .. code-block:: python
 
diff --git a/source/c02/p03_match_strings_with_shell_wildcard.rst b/source/c02/p03_match_strings_with_shell_wildcard.rst
@@ -5,14 +5,14 @@
 ----------
 问题
 ----------
-你想使用Unix Shell中常用的通配符(比如*.py, Dat[0-9]*.csv等)去匹配文本字符串
+你想使用 **Unix Shell** 中常用的通配符(比如 ``*.py`` , ``Dat[0-9]*.csv`` 等)去匹配文本字符串
 
 |
 
 ----------
 解决方案
 ----------
-fnmatch模块提供了两个函数—— ``fnmatch()`` 和 ``fnmatchcase()`` ，可以用来实现这样的匹配。用法如下：
+``fnmatch`` 模块提供了两个函数—— ``fnmatch()`` 和 ``fnmatchcase()`` ，可以用来实现这样的匹配。用法如下：
 
 .. code-block:: python
 
@@ -42,7 +42,7 @@ fnmatch模块提供了两个函数—— ``fnmatch()`` 和 ``fnmatchcase()`` ，
 
 如果你对这个区别很在意，可以使用 ``fnmatchcase()`` 来代替。它完全使用你的模式大小写匹配。比如：
 
-..  code-block:: python
+.. code-block:: python
 
     >>> fnmatchcase('foo.txt', '*.TXT')
     False
@@ -80,5 +80,5 @@ fnmatch模块提供了两个函数—— ``fnmatch()`` 和 ``fnmatchcase()`` ，
 ``fnmatch()`` 函数匹配能力介于简单的字符串方法和强大的正则表达式之间。
 如果在数据处理操作中只需要简单的通配符就能完成的时候，这通常是一个比较合理的方案。
 
-如果你的代码需要做文件名的匹配，最好使用glob模块。参考5.13小节。
+如果你的代码需要做文件名的匹配，最好使用 ``glob`` 模块。参考5.13小节。
 
diff --git a/source/c02/p04_match_and_search_text.rst b/source/c02/p04_match_and_search_text.rst
@@ -31,8 +31,8 @@
     10
     >>>
 
-对于复杂的匹配需要使用正则表达式和re模块。
-为了解释正则表达式的基本原理，假设你想匹配数字格式的日期字符串比如"11/27/2012"，你可以这样做：
+对于复杂的匹配需要使用正则表达式和 ``re`` 模块。
+为了解释正则表达式的基本原理，假设你想匹配数字格式的日期字符串比如 ``11/27/2012`` ，你可以这样做：
 
 .. code-block:: python
 
@@ -170,7 +170,7 @@
     <_sre.SRE_Match object at 0x1005d2750>
     >>>
 
-最后，如果你仅仅是做一次简单的文本匹配/搜索操作的话，可以略过编译部分，直接使用re模块级别的函数。比如：
+最后，如果你仅仅是做一次简单的文本匹配/搜索操作的话，可以略过编译部分，直接使用 ``re`` 模块级别的函数。比如：
 
 .. code-block:: python
 
diff --git a/source/c02/p05_search_and_replace_text.rst b/source/c02/p05_search_and_replace_text.rst
@@ -21,8 +21,8 @@
     'yep, but no, but yep, but no, but yep'
     >>>
 
-对于复杂的模式，请使用re模块中的 ``sub()`` 函数。
-为了说明这个，假设你想将形式为"11/27/201"的日期字符串改成"2012-11-27"。示例如下：
+对于复杂的模式，请使用 ``re`` 模块中的 ``sub()`` 函数。
+为了说明这个，假设你想将形式为 ``11/27/201`` 的日期字符串改成 ``2012-11-27`` 。示例如下：
 
 .. code-block:: python
 
@@ -32,7 +32,7 @@
     'Today is 2012-11-27. PyCon starts 2013-3-13.'
     >>>
 
-``sub()`` 函数中的第一个参数是被匹配的模式，第二个参数是替换模式。反斜杠数字比如\3指向前面模式的捕获组号。
+``sub()`` 函数中的第一个参数是被匹配的模式，第二个参数是替换模式。反斜杠数字比如 ``\3`` 指向前面模式的捕获组号。
 
 如果你打算用相同的模式做多次替换，考虑先编译它来提升性能。比如：
 
diff --git a/source/c02/p06_search_replace_case_insensitive.rst b/source/c02/p06_search_replace_case_insensitive.rst
@@ -12,7 +12,7 @@
 ----------
 解决方案
 ----------
-为了在文本操作时忽略大小写，你需要在使用re模块的时候给这些操作提供 ``re.IGNORECASE`` 标志参数。比如：
+为了在文本操作时忽略大小写，你需要在使用 ``re`` 模块的时候给这些操作提供 ``re.IGNORECASE`` 标志参数。比如：
 
 .. code-block:: python
 
diff --git a/source/c02/p07_specify_regexp_for_shortest_match.rst b/source/c02/p07_specify_regexp_for_shortest_match.rst
@@ -51,5 +51,5 @@
 在一个模式字符串中，点(.)匹配除了换行外的任何字符。
 然而，如果你将点(.)号放在开始与结束符(比如引号)之间的时候，那么匹配操作会查找符合模式的最长可能匹配。
 这样通常会导致很多中间的被开始与结束符包含的文本被忽略掉，并最终被包含在匹配结果字符串中返回。
-通过在*或者+这样的操作符后面添加一个?可以强制匹配算法改成寻找最短的可能匹配。
+通过在 ``*`` 或者 ``+`` 这样的操作符后面添加一个 ``?`` 可以强制匹配算法改成寻找最短的可能匹配。
 
diff --git a/source/c02/p08_regexp_for_multiline_partterns.rst b/source/c02/p08_regexp_for_multiline_partterns.rst
@@ -38,7 +38,7 @@
     [' this is a\n multiline comment ']
     >>>
 
-在这个模式中，``(?:.|\n)`` 指定了一个非捕获组
+在这个模式中， ``(?:.|\n)`` 指定了一个非捕获组
 (也就是它定义了一个仅仅用来做匹配，而不能通过单独捕获或者编号的组)。
 
 |
@@ -47,7 +47,7 @@
 讨论
 ----------
 ``re.compile()`` 函数接受一个标志参数叫 ``re.DOTALL`` ，在这里非常有用。
-它可以让正则表达式中的.匹配包括换行符在内的任意字符。比如：
+它可以让正则表达式中的点(.)匹配包括换行符在内的任意字符。比如：
 
 .. code-block:: python
 
diff --git a/source/c02/p10_work_with_unicode_in_regexp.rst b/source/c02/p10_work_with_unicode_in_regexp.rst
@@ -12,8 +12,8 @@
 ----------
 解决方案
 ----------
-默认情况下re模块已经对一些Unicode字符类有了基本的支持。
-比如，\\d已经匹配任意的unicode数字字符了：
+默认情况下 ``re`` 模块已经对一些Unicode字符类有了基本的支持。
+比如， ``\\d`` 已经匹配任意的unicode数字字符了：
 
 .. code-block:: python
 
@@ -27,7 +27,7 @@
     <_sre.SRE_Match object at 0x101234030>
     >>>
 
-如果你想在模式中包含指定的Unicode字符，你可以使用Unicode字符对应的转义序列(比如\uFFF或者\UFFFFFFF)。
+如果你想在模式中包含指定的Unicode字符，你可以使用Unicode字符对应的转义序列(比如 ``\uFFF`` 或者 ``\UFFFFFFF`` )。
 比如，下面是一个匹配几个不同阿拉伯编码页面中所有字符的正则表达式：
 
 .. code-block:: python
diff --git a/source/c02/p11_strip_unwanted_characters.rst b/source/c02/p11_strip_unwanted_characters.rst
@@ -12,7 +12,7 @@
 ----------
 解决方案
 ----------
-``strip()`` 方法能用于删除开始或结尾的字符。``lstrip()`` 和 ``rstrip()`` 分别从左和从右执行删除操作。
+``strip()`` 方法能用于删除开始或结尾的字符。 ``lstrip()`` 和 ``rstrip()`` 分别从左和从右执行删除操作。
 默认情况下，这些方法会去除空白字符，但是你也可以指定其他字符。比如：
 
 .. code-block:: python
@@ -63,7 +63,7 @@
     'hello world'
     >>>
 
-通常情况下你想将字符串strip操作和其他迭代操作相结合，比如从文件中读取多行数据。
+通常情况下你想将字符串 ``strip`` 操作和其他迭代操作相结合，比如从文件中读取多行数据。
 如果是这样的话，那么生成器表达式就可以大显身手了。比如：
 
 .. code-block:: python
diff --git a/source/c02/p12_sanitizing_clean_up_text.rst b/source/c02/p12_sanitizing_clean_up_text.rst
@@ -42,7 +42,7 @@
     'pýtĥöñ is awesome\n'
     >>>
 
-正如你看的那样，空白字符\t和\f已经被重新映射到一个空格。回车字符\r直接被删除。
+正如你看的那样，空白字符 ``\t`` 和 ``\f`` 已经被重新映射到一个空格。回车字符\r直接被删除。
 
 你可以以这个表格为基础进一步构建更大的表格。比如，让我们删除所有的和音符：
 
@@ -60,7 +60,7 @@
     'python is awesome\n'
     >>>
 
-上面例子中，通过使用 ``dict.fromkeys()`` 方法构造一个字典，每个Unicode和音符作为键，对于的值全部为None。
+上面例子中，通过使用 ``dict.fromkeys()`` 方法构造一个字典，每个Unicode和音符作为键，对于的值全部为 ``None`` 。
 
 然后使用 ``unicodedata.normalize()`` 将原始输入标准化为分解形式字符。
 然后再调用 ``translate`` 函数删除所有重音符。
@@ -103,7 +103,7 @@
 讨论
 ----------
 文本字符清理一个最主要的问题应该是运行的性能。一般来讲，代码越简单运行越快。
-对于简单的替换操作，``str.replace()`` 方法通常是最快的，甚至在你需要多次调用的时候。
+对于简单的替换操作， ``str.replace()`` 方法通常是最快的，甚至在你需要多次调用的时候。
 比如，为了清理空白字符，你可以这样做：
 
 .. code-block:: python
@@ -116,7 +116,7 @@
 
 如果你去测试的话，你就会发现这种方式会比使用 ``translate()`` 或者正则表达式要快很多。
 
-另一方面，如果你需要执行任何复杂字符对字符的重新映射或者删除操作的话，``tanslate()`` 方法会非常的快。
+另一方面，如果你需要执行任何复杂字符对字符的重新映射或者删除操作的话， ``tanslate()`` 方法会非常的快。
 
 从大的方面来讲，对于你的应用程序来说性能是你不得不去自己研究的东西。
 不幸的是，我们不可能给你建议一个特定的技术，使它能够适应所有的情况。
diff --git a/source/c02/p13_aligning_text_strings.rst b/source/c02/p13_aligning_text_strings.rst
@@ -35,7 +35,7 @@
     >>>
 
 函数 ``format()`` 同样可以用来很容易的对齐字符串。
-你要做的就是使用<,>或者^字符后面紧跟一个指定的宽度。比如：
+你要做的就是使用 ``<,>`` 或者 ``^`` 字符后面紧跟一个指定的宽度。比如：
 
 .. code-block:: python
 
@@ -82,7 +82,7 @@
 ----------
 讨论
 ----------
-在老的代码中，你经常会看到被用来格式化文本的%操作符。比如：
+在老的代码中，你经常会看到被用来格式化文本的 ``%`` 操作符。比如：
 
 .. code-block:: python
 
@@ -93,7 +93,7 @@
     >>>
 
 但是，在新版本代码中，你应该优先选择 ``format()`` 函数或者方法。
-``format()`` 要比%操作符的功能更为强大。
+``format()`` 要比 ``%`` 操作符的功能更为强大。
 并且 ``format()`` 也比使用 ``ljust()`` , ``rjust()`` 或 ``center()`` 方法更通用，
 因为它可以用来格式化任意对象，而不仅仅是字符串。
 
diff --git a/source/c02/p15_interpolating_variables_in_strings.rst b/source/c02/p15_interpolating_variables_in_strings.rst
@@ -124,13 +124,13 @@ Python并没有对在字符串中简单替换变量值提供直接的支持。
     'Guido has 37 messages.'
     >>>
 
-然而，``format()`` 和 ``format_map()`` 相比较上面这些方案而已更加先进，因此应该被优先选择。
+然而， ``format()`` 和 ``format_map()`` 相比较上面这些方案而已更加先进，因此应该被优先选择。
 使用 ``format()`` 方法还有一个好处就是你可以获得对字符串格式化的所有支持(对齐，填充，数字格式化等待)，
 而这些特性是使用像模板字符串之类的方案不可能获得的。
 
 本机还部分介绍了一些高级特性。映射或者字典类中鲜为人知的 ``__missing__()`` 方法可以让你定义如何处理缺失的值。
-在SafeSub类中，这个方法被定义为对缺失的值返回一个占位符。
-你可以发现缺失的值会出现在结果字符串中(在调试的时候可能很有用)，而不是产生一个KeyError异常。
+在 ``SafeSub`` 类中，这个方法被定义为对缺失的值返回一个占位符。
+你可以发现缺失的值会出现在结果字符串中(在调试的时候可能很有用)，而不是产生一个 ``KeyError`` 异常。
 
 ``sub()`` 函数使用 ``sys._getframe(1)`` 返回调用者的栈帧。可以从中访问属性 ``f_locals`` 来获得局部变量。
 毫无疑问绝大部分情况下在代码中去直接操作栈帧应该是不推荐的。
diff --git a/source/c02/p18_tokenizing_text.rst b/source/c02/p18_tokenizing_text.rst
@@ -40,7 +40,7 @@
 
     master_pat = re.compile('|'.join([NAME, NUM, PLUS, TIMES, EQ, WS]))
 
-在上面的模式中，``?P<TOKENNAME>`` 用于给一个模式命名，供后面使用。
+在上面的模式中， ``?P<TOKENNAME>`` 用于给一个模式命名，供后面使用。
 
 下一步，为了令牌化，使用模式对象很少被人知道的 ``scanner()`` 方法。
 这个方法会创建一个 ``scanner`` 对象，
@@ -113,7 +113,7 @@
 第一点就是你必须确认你使用正则表达式指定了所有输入中可能出现的文本序列。
 如果有任何不可匹配的文本出现了，扫描就会直接停止。这也是为什么上面例子中必须指定空白字符令牌的原因。
 
-令牌的顺序也是有影响的。re模块会按照指定好的顺序去做匹配。
+令牌的顺序也是有影响的。 ``re`` 模块会按照指定好的顺序去做匹配。
 因此，如果一个模式恰好是另一个更长模式的子字符串，那么你需要确定长模式写在前面。比如：
 
 .. code-block:: python
