p3

Author: qiwsir

229.md

@@ -4,36 +4,34 @@
 
 在[《文件(1)》](./126.md)和[《文件(2)》](./127.md)中，已经学习了如何读写文件。
 
-如果在程序中，有数据要保存到磁盘中，放到某个文件中是一种不错的方法。但是，如果像以前那样存，未免有点凌乱，并且没有什么良好的存储格式，导致数据以后被读出来的时候遇到麻烦，特别是不能让另外的使用者很好地理解。不要忘记了，编程是一个合作的活。还有，存储的数据不一定都是类似字符串、整数那种基础类型的。
+程序执行结果，就是产生一些数据，一般情况下，这些数据数据要保存到磁盘中，最简单的方法就是写入到某个文件。但是，如果仅仅是简单地把数据写入文件，不是最佳的存储机构。为此，就有了诸多不同的数据存储方式，这些方式不仅能够保证数据被存储，还能够让数据便于读取，此外，还有很多其它方面的优势。
 
-总而言之，需要将要存储的对象格式化（或者叫做序列化），才好存好取。这就有点类似集装箱的作用。
-
-所以，要用到本讲中提供的方式。
+简而言之，就是要将存储的对象格式化（或者叫做序列化），才好存好取。这就有点类似集装箱的作用。
 
 ##pickle
 
-pickle是标准库中的一个模块，还有跟它完全一样的叫做cpickle，两者的区别就是后者更快。所以，下面操作中，不管是用`import pickle`，还是用`import cpickle as pickle`，在功能上都是一样的。
+pickle是标准库中的一个模块，在Python 2中还有一个cpickle，两者的区别就是后者更快。所以，下面操作中，不管是用`import pickle`，还是用`import cpickle as pickle`，在功能上都是一样的。
+
+而在Python 3中，你只需要`import pickle`即可，因为它已经在Python 3中具备了Python 2中的cpickle同样的性能。
 
     >>> import pickle
     >>> integers = [1, 2, 3, 4, 5]
     >>> f = open("22901.dat", "wb")
     >>> pickle.dump(integers, f)
     >>> f.close()
 
-用`pickle.dump(integers, f)`将数据integers保存到了文件22901.dat中。如果你要打开这个文件，看里面的内容，可能有点失望，但是，它对计算机是友好的。这个步骤，可以称之为将对象序列化。用到的方法是：
+用`pickle.dump(integers, f)`将数据integers保存到了文件22901.dat中。如果你要打开这个文件，看里面的内容，可能有点失望，但是，它对计算机是友好的。这个步骤可以称之为将对象序列化。用到的方法是：`pickle.dump(obj,file[,protocol])`
 
-`pickle.dump(obj,file[,protocol])`
-
-- obj：序列化对象，上面的例子中是一个列表，它是基本类型，也可以序列化自己定义的类型。
-- file：一般情况下是要写入的文件。更广泛地可以理解为为拥有write()方法的对象，并且能接受字符串为为参数，所以，它还可以是一个StringIO对象，或者其它自定义满足条件的对象。
+- obj：序列化对象，在上面的例子中是一个列表，它是基本类型，也可以序列化自己定义的对象。
+- file：要写入的文件。可以更广泛地可以理解为为拥有`write()`方法的对象，并且能接受字符串为为参数，所以，它还可以是一个`StringIO`对象，或者其它自定义满足条件的对象。
 - protocol：可选项。默认为False（或者说0），是以ASCII格式保存对象；如果设置为1或者True，则以压缩的二进制格式保存对象。
 
-下面换一种数据格式，并且做对比：
+换一种数据格式，并且做对比：
 
     >>> import pickle
     >>> d = {}
     >>> integers = range(9999)
-    >>> d["i"] = integers        #下面将这个dict格式的对象存入文件
+    >>> d["i"] = integers        #下面将这个字典类型的对象存入文件
 
     >>> f = open("22902.dat", "wb")
     >>> pickle.dump(d, f)           #文件中以ascii格式保存数据
@@ -47,37 +45,37 @@ pickle是标准库中的一个模块，还有跟它完全一样的叫做cpickle
     >>> s1 = os.stat("22902.dat").st_size    #得到两个文件的大小
     >>> s2 = os.stat("22903.dat").st_size
 
-    >>> print "%d, %d, %.2f%%" % (s1, s2, (s2+0.0)/s1*100)
+    >>> print "%d, %d, %.2f%%" % (s1, s2, (s2+0.0)/s1*100)    #Python 3: print("{0:d}, {1:d}, {2:.2f}".format (s1, s2, (s2+0.0)/s1*100))
     68903, 29774, 43.21%
 
 比较结果发现，以二进制方式保存的文件比以ascii格式保存的文件小很多，前者约是后者的43%。
 
-所以，在序列化的时候，特别是面对较大对象时，建议将dump()的参数True设置上，虽然现在存储设备的价格便宜，但是能省还是省点比较好。
+所以，在序列化的时候，特别是面对较大对象时，建议将`dump()`的参数True设置上，虽然现在存储设备的价格便宜，但是能省还是省点比较好。
 
-存入文件，仅是一个目标，还有另外一个目标，就是要读出来，也称之为反序列化。
+将数据保存入文件，还有另外一个目标，就是要读出来，也称之为反序列化。
 
     >>> integers = pickle.load(open("22901.dat", "rb"))
-    >>> print integers
+    >>> print integers    #Python 3: print(integers)
     [1, 2, 3, 4, 5]
 
-就是前面存入的那个列表。再看看被以二进制存入的那个文件：
+再看看以二进制存入的那个文件：
 
     >>> f = open("22903.dat", "rb")
     >>> d = pickle.load(f)
     >>> print d
     {'i': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, ....   #省略后面的数字}
     >>> f.close()
 
-还是有自己定义数据类型的需要，这种类型是否可以用上述方式存入文件并读出来呢？看下面的例子：
+如果是自己定义的对象，是否可以用上述方式存入文件并读出来呢？看下面的例子：
 
-    >>> import cPickle as pickle        #cPickle更快
+    >>> import cPickle as pickle        #这是Python 2的引入方式，如果是Python 3，直接使用import pickle
     >>> import StringIO                 #标准库中的一个模块，跟file功能类似，只不过是在内存中操作“文件”
 
     >>> class Book(object):             #自定义一种类型
     ...     def __init__(self,name):
     ...         self.name = name
     ...     def my_book(self):
-    ...         print "my book is: ", self.name
+    ...         print "my book is: ", self.name        #Python 3: print("my book is: ", self.name)
     ... 
 
     >>> pybook = Book("<from beginner to master>")
@@ -130,9 +128,9 @@ pickle是标准库中的一个模块，还有跟它完全一样的叫做cpickle
 
 ##shelve
 
-pickle模块已经表现出它足够好的一面了。不过，由于数据的复杂性，pickle只能完成一部分工作，在另外更复杂的情况下，它就稍显麻烦了。于是，又有了shelve。
+`pickle`模块已经表现出它足够好的一面了。不过，由于数据的复杂性，`pickle`只能完成一部分工作，在另外更复杂的情况下，它就稍显麻烦了。于是，又有了`shelve`。
 
-shelve模块也是标准库中的。先看一下基本操作：写入和读取
+`shelve`模块也是标准库中的。先看一下基本写、读操作。
 
     >>> import shelve
     >>> s = shelve.open("22901.db")
@@ -142,17 +140,17 @@ shelve模块也是标准库中的。先看一下基本操作：写入和读取
     >>> s["contents"] = {"first":"base knowledge","second":"day day up"}
     >>> s.close()
 
-以上完成了数据写入的过程。其实，这更接近数据库的样式了。下面是读取。
+以上完成了数据写入的过程，其实，这很接近数据库的样式了。下面是读。
 
     >>> s = shelve.open("22901.db")
     >>> name = s["name"]
-    >>> print name
+    >>> print name        #Python 3: print(name)
     www.itdiffer.com
     >>> contents = s["contents"]
-    >>> print contents
+    >>> print contents        #Python 3: print(contents)
     {'second': 'day day up', 'first': 'base knowledge'}
 
-当然，也可以用for语句来读：
+看到输出的内容，你一定想到，肯定可以用`for`语句来读，想到了就用代码来测试，这就是Python交互模式的便利之处。
 
     >>> for k in s:
     ...     print k, s[k]
@@ -162,7 +160,7 @@ shelve模块也是标准库中的。先看一下基本操作：写入和读取
     pages 1000
     name www.itdiffer.com
 
-不管是写，还是读，都似乎要简化了。所建立的对象s，就如同字典一样，可称之为类字典对象。所以，可以如同操作字典那样来操作它。
+不管是写还是读，都似乎要简化了。所建立的对象被变量`s`所引用，就如同字典一样，可称之为类字典对象。所以，可以如同操作字典那样来操作它。
 
 但是，要小心坑：
 
@@ -174,29 +172,27 @@ shelve模块也是标准库中的。先看一下基本操作：写入和读取
     ['qiwsir']
     >>> f.close()
 
-当试图修改一个已有键的值时，没有报错，但是并没有修改成功。要填平这个坑，需要这样做：
+当试图修改一个已有键的值时没有报错，但是并没有修改成功。要填平这个坑，需要这样做：
 
     >>> f = shelve.open("22901.db", writeback=True)    #多一个参数True
     >>> f["author"].append("Hetz")
     >>> f["author"]                   #没有坑了
     ['qiwsir', 'Hetz']
     >>> f.close()
 
-还用for循环一下：
+还用`for`循环一下：
 
     >>> f = shelve.open("22901.db")
     >>> for k,v in f.items():
-    ...     print k,": ",v
+    ...     print k,": ",v        #Python 3: print(k,": ",v)
     ... 
     contents :  {'second': 'day day up', 'first': 'base knowledge'}
     lang :  python
     pages :  1000
     author :  ['qiwsir', 'Hetz']
     name :  www.itdiffer.com
 
-shelve更像数据库了。
-
-不过，它还不是真正的数据库。真正的数据库在后面。
+`shelve`更像数据库了。不过，它还不是真正的数据库。真正的数据库在后面。
 
 ------