标准库部分：为文中出现的代码、变量、命令等添加代码（code）格式。

Author: pastgift

content/STL01.md

@@ -16,23 +16,23 @@
 
 (官方documentation)
 
-在Python中使用正则表达式需要标准库中的一个包re。
+在Python中使用正则表达式需要标准库中的一个包`re`。
 ```python
 import re
 m = re.search('[0-9]','abcd4ef')
 print(m.group(0))
 ```
-re.search()接收两个参数，第一个'[0-9]'就是我们所说的正则表达式，它告诉Python的是，“听着，我从字符串想要找的是从0到9的一个数字字符”。
+`re.search()`接收两个参数，第一个`'[0-9]'`就是我们所说的正则表达式，它告诉Python的是，“听着，我从字符串想要找的是从`0`到`9`的一个数字字符”。
 
-re.search()如果从第二个参数找到符合要求的子字符串，就返回一个对象m，你可以通过m.group()的方法查看搜索到的结果。如果没有找到符合要求的字符，re.search()会返回None。
+`re.search()`如果从第二个参数找到符合要求的子字符串，就返回一个对象`m`，你可以通过`m.group()`的方法查看搜索到的结果。如果没有找到符合要求的字符，`re.search()`会返回`None`。
 
 
 
 如果你熟悉Linux或者Perl, 你应该已经熟悉正则表达式。当我们打开Linux shell的时候，可以用正则表达式去查找或着删除我们想要的文件，比如说：
 ```bash
 $rm book[0-9][0-9].txt
 ```
-这就是要删除类似于book02.txt的文件。book[0-9][0-9].txt所包含的信息是，以book开头，后面跟两个数字字符，之后跟有".txt"的文件名。如果不符合条件的文件名，比如说:
+这就是要删除类似于`book02.txt`的文件。`book[0-9][0-9].txt`所包含的信息是，以`book`开头，后面跟两个数字字符，之后跟有`.txt`的文件名。如果不符合条件的文件名，比如说:
 
 bo12.txt
 
@@ -51,10 +51,10 @@ Perl中内建有正则表达式的功能，据说是所有正则表达式系统
 m = re.search(pattern, string)  # 搜索整个字符串，直到发现符合的子字符串。
 m = re.match(pattern, string)   # 从头开始检查字符串是否符合正则表达式。必须从字符串的第一个字符开始就相符。
 ```
-可以从这两个函数中选择一个进行搜索。上面的例子中，我们如果使用re.match()的话，则会得到None，因为字符串的起始为‘a’， 不符合'[0-9]'的要求。
+可以从这两个函数中选择一个进行搜索。上面的例子中，我们如果使用`re.match()`的话，则会得到`None`，因为字符串的起始为`'a'`， 不符合`'[0-9]'`的要求。
 
 
-对于返回的m, 我们使用m.group()来调用结果。（我们会在后面更详细解释m.group()）
+对于返回的`m`, 我们使用`m.group()`来调用结果。（我们会在后面更详细解释`m.group()`）
 
 
 
@@ -71,7 +71,7 @@ re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字
 
 
 
-(在熟悉了上面的函数后，可以看一下re.compile()，以便于提高搜索效率。)
+(在熟悉了上面的函数后，可以看一下`re.compile()`，以便于提高搜索效率。)
 
 
 
@@ -81,113 +81,113 @@ re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字
 
 1）单个字符:
 
-.          任意的一个字符
+`.`          任意的一个字符
 
-a|b        字符a或字符b
+`a|b`        字符a或字符b
 
-[afg]      a或者f或者g的一个字符        
+`[afg]`      a或者f或者g的一个字符        
 
-[0-4]      0-4范围内的一个字符
+`[0-4]`      0-4范围内的一个字符
 
-[a-f]      a-f范围内的一个字符
+`[a-f]`      a-f范围内的一个字符
 
-[^m]       不是m的一个字符
+`[^m]`       不是m的一个字符
 
-\s         一个空格
+`\s`         一个空格
 
-\S         一个非空格
+`\S`         一个非空格
 
-\d         [0-9]
+`\d`         即`[0-9]`
 
-\D         [^0-9]
+`\D`         即`[^0-9]`
 
-\w         [0-9a-zA-Z]
+`\w`         即`[0-9a-zA-Z]`
 
-\W         [^0-9a-zA-Z]
+`\W`         即`[^0-9a-zA-Z]`
 
 
 
 2）重复
 
 紧跟在单个字符之后，表示多个这样类似的字符
 
-*         重复 >=0 次
+`*`         重复 >=0 次
 
-+         重复 >=1 次
+`+`         重复 >=1 次
 
-?         重复 0或者1 次
+`?`         重复 0或者1 次
 
-{m}       重复m次。比如说 a{4}相当于aaaa，再比如说[1-3]{2}相当于[1-3][1-3]
+`{m}`       重复m次。比如说 a{4}相当于aaaa，再比如说`[1-3]{2}`相当于`[1-3][1-3]`
 
-{m, n}    重复m到n次。比如说a{2, 5}表示a重复2到5次。小于m次的重复，或者大于n次的重复都不符合条件。
+`{m, n}`    重复m到n次。比如说`a{2, 5}`表示a重复2到5次。小于m次的重复，或者大于n次的重复都不符合条件。
 
 
 
 正则表达          相符的字符串举例
 
-[0-9]{3,5}       9678
+`[0-9]{3,5}`       9678
 
-a?b              b
+`a?b`              b
 
-a+b              aaaaab
+`a+b`              aaaaab
 
 
 
 3) 位置
 
-^         字符串的起始位置
+`^`         字符串的起始位置
 
-$         字符串的结尾位置
+`$`         字符串的结尾位置
 
 
 
 正则表达          相符的字符串举例        不相符字符串
 
-^ab.*c$          abeec               cabeec (如果用re.search(), 将无法找到。)
+`^ab.*c$`          abeec               cabeec (如果用`re.search()`, 将无法找到。)
 
 
 4）返回控制
 
 我们有可能对搜索的结果进行进一步精简信息。比如下面一个正则表达式：
 
-output_(\d{4})
+`output_(\d{4})`
 
-该正则表达式用括号()包围了一个小的正则表达式，\d{4}。 这个小的正则表达式被用于从结果中筛选想要的信息（在这里是四位数字）。这样被括号圈起来的正则表达式的一部分，称为群(group)。
-我们可以m.group(number)的方法来查询群。group(0)是整个正则表达的搜索结果，group(1)是第一个群……
+该正则表达式用括号`()`包围了一个小的正则表达式，`\d{4}`。 这个小的正则表达式被用于从结果中筛选想要的信息（在这里是四位数字）。这样被括号圈起来的正则表达式的一部分，称为群(group)。
+我们可以`m.group(number)`的方法来查询群。`group(0)`是整个正则表达的搜索结果，`group(1)`是第一个群……
 ```python
 import re
 m = re.search("output_(\d{4})", "output_1986.txt")
 print(m.group(1))
 ``` 
 
-我们还可以将群命名，以便更好地使用m.group查询:
+我们还可以将群命名，以便更好地使用`m.group`查询:
 ```python
 import re
 m = re.search("output_(?P<year>\d{4})", "output_1986.txt")   #(?P<name>...) 为group命名
 print(m.group("year"))
 ``` 
 
-对比re.search和re.match
-本节开头我们用re.search实现数字子串的提取；
+对比`re.search`和`re.match`
+本节开头我们用`re.search`实现数字子串的提取；
 m = re.search('[0-9]','abcd4ef')
-使用re.match同样实现上述功能（提取数字子串)，我们需要用到小括号'()':
+使用`re.match`同样实现上述功能（提取数字子串)，我们需要用到小括号`'()'`:
 ```python
 m = re.match('.*([0-9]+).*','abcd4ef')
 # 注意,我们通过m.group(1)来获取数字字串，下标0处是匹配的整个字符串
 print m.group(0), m.group(1) 
 abcd4ef 4
 ```
-很明显，这里使用match方法要繁琐一些；体会两个方法的差异，搜索整个字符串中的子串使用re.search，而从头开始检查字符串是否符合正则表达式选用re.match;
+很明显，这里使用`match`方法要繁琐一些；体会两个方法的差异，搜索整个字符串中的子串使用`re.search`，而从头开始检查字符串是否符合正则表达式选用`re.match`;
 
 练习
-有一个文件，文件名为output_1981.10.21.txt 。下面使用Python： 读取文件名中的日期时间信息，并找出这一天是周几。将文件改名为output_YYYY-MM-DD-W.txt (YYYY:四位的年，MM：两位的月份，DD：两位的日，W：一位的周几，并假设周一为一周第一天)
+有一个文件，文件名为`output_1981.10.21.txt`。下面使用Python： 读取文件名中的日期时间信息，并找出这一天是周几。将文件改名为`output_YYYY-MM-DD-W.txt`(`YYYY`:四位的年，`MM`：两位的月份，`DD`：两位的日，`W`：一位的周几，并假设周一为一周第一天)
 
 
 
 
 
 ##总结
 
-re.search() re.match() re.sub() re.findall()
+`re.search()` `re.match()` `re.sub()` `re.findall()`
 
 正则表达式构成方法

content/STL02.md

@@ -8,14 +8,14 @@ Python具有良好的时间和日期管理功能。实际上，计算机只会
 
 ##time包
 
-time包基于C语言的库函数(library functions)。Python的解释器通常是用C编写的，Python的一些函数也会直接调用C语言的库函数。
+`time`包基于C语言的库函数(library functions)。Python的解释器通常是用C编写的，Python的一些函数也会直接调用C语言的库函数。
 ```python
 import time
 print(time.time())   # wall clock time, unit: second
 print(time.clock())  # processor clock time, unit: second
 ``` 
 
-time.sleep()可以将程序置于休眠状态，直到某时间间隔之后再唤醒程序，让程序继续运行。
+`time.sleep()`可以将程序置于休眠状态，直到某时间间隔之后再唤醒程序，让程序继续运行。
 ```python
 import time
 print('start')
@@ -26,7 +26,7 @@ print('wake up')
 
 
 
-time包还定义了struct_time对象。该对象实际上是将挂钟时间转换为年、月、日、时、分、秒……等日期信息，存储在该对象的各个属性中(tm_year, tm_mon, tm_mday...)。下面方法可以将挂钟时间转换为struct_time对象:
+`time`包还定义了`struct_time`对象。该对象实际上是将挂钟时间转换为年、月、日、时、分、秒……等日期信息，存储在该对象的各个属性中(`tm_year`, `tm_mon`, `tm_mday`...)。下面方法可以将挂钟时间转换为`struct_time`对象:
 ```python
 st = time.gmtime()      # 返回struct_time格式的UTC时间
 st = time.localtime()   # 返回struct_time格式的当地时间, 当地时区根据系统环境决定。
@@ -38,27 +38,27 @@ s  = time.mktime(st)    # 将struct_time格式转换成wall clock time
 
 1) 简介
 
-datetime包是基于time包的一个高级包， 为我们提供了多一层的便利。
+`datetime`包是基于`time`包的一个高级包， 为我们提供了多一层的便利。
 
-datetime可以理解为date和time两个组成部分。date是指年月日构成的日期(相当于日历)，time是指时分秒微秒构成的一天24小时中的具体时间(相当于手表)。你可以将这两个分开管理(datetime.date类，datetime.time类)，也可以将两者合在一起(datetime.datetime类)。由于其构造大同小异，我们将只介绍datetime.datetime类。
+`datetime`可以理解为date和time两个组成部分。date是指年月日构成的日期(相当于日历)，time是指时分秒微秒构成的一天24小时中的具体时间(相当于手表)。你可以将这两个分开管理(`datetime.date`类，`datetime.time`类)，也可以将两者合在一起(`datetime.datetime`类)。由于其构造大同小异，我们将只介绍`datetime.datetime`类。
 
 比如说我现在看到的时间，是2012年9月3日21时30分，我们可以用如下方式表达：
 ```python
 import datetime
 t = datetime.datetime(2012,9,3,21,30)
 print(t)
 ```
-所返回的t有如下属性:
+所返回的`t`有如下属性:
 
-hour, minute, second, microsecond
+`hour`, `minute`, `second`, `microsecond`
 
-year, month, day, weekday   # weekday表示周几
+`year`, `month`, `day`, `weekday`   # weekday表示周几
 
 
 
 2) 运算
 
-datetime包还定义了时间间隔对象(timedelta)。一个时间点(datetime)加上一个时间间隔(timedelta)可以得到一个新的时间点(datetime)。比如今天的上午3点加上5个小时得到今天的上午8点。同理，两个时间点相减会得到一个时间间隔。
+`datetime`包还定义了时间间隔对象(`timedelta`)。一个时间点(`datetime`)加上一个时间间隔(`timedelta`)可以得到一个新的时间点(`datetime`)。比如今天的上午3点加上5个小时得到今天的上午8点。同理，两个时间点相减会得到一个时间间隔。
 
 ```python
 import datetime
@@ -70,45 +70,46 @@ print(t + delta1)
 print(t + delta2)
 print(t_next - t)
 ```
-在给datetime.timedelta传递参数（如上的seconds和weeks）的时候，还可以是days, hours, milliseconds, microseconds。
+在给`datetime.timedelta`传递参数（如上的`seconds`和`weeks`）的时候，还可以是`days`, `hours`, `milliseconds`, `microseconds`。
 
 
 
-两个datetime对象还可以进行比较。比如使用上面的t和t_next:
+两个`datetime`对象还可以进行比较。比如使用上面的`t`和`t_next`:
 ```python
 print(t > t_next)
 ``` 
 
 3) datetime对象与字符串转换
 
-假如我们有一个的字符串，我们如何将它转换成为datetime对象呢？
+假如我们有一个的字符串，我们如何将它转换成为`datetime`对象呢？
 
 一个方法是用上一讲的正则表达式来搜索字符串。但时间信息实际上有很明显的特征，我们可以用格式化读取的方式读取时间信息。
 ```python
 from datetime import datetime
 format = "output-%Y-%m-%d-%H%M%S.txt" 
 str    = "output-1997-12-23-030000.txt" 
 t      = datetime.strptime(str, format)
-strptime, p = parsing
 ```
+`strptime`中的“p”代表解析（parsing）。
 
-我们通过format来告知Python我们的str字符串中包含的日期的格式。在format中，%Y表示年所出现的位置, %m表示月份所出现的位置……。
 
-反过来，我们也可以调用datetime对象的strftime()方法，来将datetime对象转换为特定格式的字符串。比如上面所定义的t_next,
+我们通过`format`来告知Python我们的str字符串中包含的日期的格式。在`format`中，`%Y`表示年所出现的位置, `%m`表示月份所出现的位置……。
+
+反过来，我们也可以调用`datetime`对象的`strftime()`方法，来将`datetime`对象转换为特定格式的字符串。比如上面所定义的`t_next`,
 ```python
 print(t_next.strftime(format))
 ```
-strftime, f = formatting
+`strftime`中的“f”代表格式化（formatting）。
 
-具体的格式写法可参阅官方文档。 如果是Linux系统，也可查阅date命令的手册($man date)，两者相通。
+具体的格式写法可参阅官方文档。 如果是Linux系统，也可查阅`date`命令的手册(`$man date`)，两者相通。
 
 
 
 ##总结
 
 时间，休眠
 
-datetime, timedelta
+`datetime`, `timedelta`
 
 格式化时间
 

content/STL03.md

@@ -10,7 +10,7 @@
 
 ##os.path包
 
-os.path包主要是处理路径字符串，比如说'/home/vamei/doc/file.txt'，提取出有用信息。
+`os.path`包主要是处理路径字符串，比如说`'/home/vamei/doc/file.txt'`，提取出有用信息。
 
 ```python
 import os.path
@@ -31,7 +31,7 @@ os.path.normpath(path)   # 去除路径path中的冗余。比如'/home/vamei/../
 
 
 
-os.path还可以查询文件的相关信息(metadata)。文件的相关信息不存储在文件内部，而是由操作系统维护的，关于文件的一些信息(比如文件类型，大小，修改时间)。
+`os.path`还可以查询文件的相关信息(metadata)。文件的相关信息不存储在文件内部，而是由操作系统维护的，关于文件的一些信息(比如文件类型，大小，修改时间)。
 
 ```python
 import os.path 
@@ -46,15 +46,15 @@ print(os.path.getmtime(path))  # 查询文件上一次修改的时间
 print(os.path.isfile(path))    # 路径是否指向常规文件
 print(os.path.isdir(path))     # 路径是否指向目录文件
 ```
- (实际上，这一部份类似于Linux中的ls命令的某些功能)
+ (实际上，这一部份类似于Linux中的`ls`命令的某些功能)
 
 
 
 ##glob包
 
-glob包最常用的方法只有一个, glob.glob()。该方法的功能与Linux中的ls相似(参看Linux文件管理命令)，接受一个Linux式的文件名格式表达式(filename pattern expression)，列出所有符合该表达式的文件（与正则表达式类似），将所有文件名放在一个表中返回。所以glob.glob()是一个查询目录下文件的好方法。
+`glob`包最常用的方法只有一个, `glob.glob()`。该方法的功能与Linux中的`ls`相似(参看Linux文件管理命令)，接受一个Linux式的文件名格式表达式(filename pattern expression)，列出所有符合该表达式的文件（与正则表达式类似），将所有文件名放在一个表中返回。所以`glob.glob()`是一个查询目录下文件的好方法。
 
-该文件名表达式的语法与Python自身的正则表达式不同 (你可以同时看一下fnmatch包，它的功能是检测一个文件名是否符合Linux的文件名格式表达式)。 如下：
+该文件名表达式的语法与Python自身的正则表达式不同 (你可以同时看一下`fnmatch`包，它的功能是检测一个文件名是否符合Linux的文件名格式表达式)。 如下：
 
 Filename Pattern Expression      Python Regular Expression
 
@@ -70,7 +70,7 @@ Filename Pattern Expression      Python Regular Expression
 
 
 
-我们可以用该命令找出/home/vamei下的所有文件:
+我们可以用该命令找出`/home/vamei`下的所有文件:
 ```python
 import glob
 print(glob.glob('/home/vamei/*'))
@@ -80,6 +80,6 @@ print(glob.glob('/home/vamei/*'))
 
 文件系统
 
-os.path
+`os.path`
 
-glob.glob
+`glob.glob`