Python 的开发环境

OpenResty - a fast web app server by extending nginx

pickle和cPickle：Python对象的序列化（上）

pickle和cPickle：Python对象的序列化（下）

JianZhen

pickle

serializing

cPickle

导入

try:
import cPickle as pickle
except:
import pickle

编码和解码

pickle.dumps()

try:
import cPickle as pickle
except:
import pickleimport pprint

data = [ { 'a':'A', 'b':2, 'c':3.0 } ]
print 'DATA:',
pprint.pprint(data)

data_string = pickle.dumps(data)
print 'PICKLE:', data_string

$ python pickle_string.py

DATA:[{'a': 'A', 'b': 2, 'c': 3.0}]
PICKLE: (lp1
(dp2
S'a'
S'A'
sS'c'
F3
sS'b'
I2
sa.

try:
import cPickle as pickle
except:
import pickleimport pprint

data1 = [ { 'a':'A', 'b':2, 'c':3.0 } ]
print 'BEFORE:',
pprint.pprint(data1)

data1_string = pickle.dumps(data1)

data2 = pickle.loads(data1_string)
print 'AFTER:',
pprint.pprint(data2)

print 'SAME?:', (data1 is data2)
print 'EQUAL?:', (data1 == data2)

$ python pickle_unpickle.py

BEFORE:[{'a': 'A', 'b': 2, 'c': 3.0}]
AFTER:[{'a': 'A', 'b': 2, 'c': 3.0}]
SAME?: False
EQUAL?: True

与流一起工作

dumps()

loads()

try:
import cPickle as pickle
except:
import pickleimport pprint
from StringIO import StringIO

class SimpleObject(object):

def __init__(self, name):
self.name = name
l = list(name)
l.reverse()
self.name_backwards = ''.join(l)
return

data = []
data.append(SimpleObject('pickle'))
data.append(SimpleObject('cPickle'))
data.append(SimpleObject('last'))

# 使用StringIO模拟一个文件
out_s = StringIO()

# 写入该流
for o in data:
print 'WRITING: %s (%s)' % (o.name, o.name_backwards)
pickle.dump(o, out_s)
out_s.flush()

# 建立一个可读流
in_s = StringIO(out_s.getvalue())

# 读数据
while True:
try:
o = pickle.load(in_s)
except EOFError:
break
else:
print 'READ: %s (%s)' % (o.name, o.name_backwards)

shelve

$ python pickle_stream.py

WRITING: pickle (elkcip)
WRITING: cPickle (elkciPc)
WRITING: last (tsal)
READ: pickle (elkcip)
READ: cPickle (elkciPc)
READ: last (tsal)

os.fork()

os.pipe()

multiprocessing

pickle和cPickle：Python对象的序列化（下）

JianZhen

重构对象的问题

try:
import cPickle as pickle
except:
import pickleimport sys

class SimpleObject(object):

def __init__(self, name):
self.name = name
l = list(name)
l.reverse()
self.name_backwards = ''.join(l)
return

if __name__ == '__main__':
data = []
data.append(SimpleObject('pickle'))
data.append(SimpleObject('cPickle'))
data.append(SimpleObject('last'))

try:
filename = sys.argv[1]
except IndexError:
raise RuntimeError('Please specify a filename as an argument to %s' % sys.argv[0])

out_s = open(filename, 'wb')
try:
# 写入流中
for o in data:
print 'WRITING: %s (%s)' % (o.name, o.name_backwards)
pickle.dump(o, out_s)
finally:
out_s.close()

$ python pickle_dump_to_file_1.py test.dat

WRITING: pickle (elkcip)
WRITING: cPickle (elkciPc)
WRITING: last (tsal)

try:
import cPickle as pickle
except:
import pickleimport pprint
from StringIO import StringIO
import sys

try:
filename = sys.argv[1]
except IndexError:
raise RuntimeError('Please specify a filename as an argument to %s' % sys.argv[0])

in_s = open(filename, 'rb')
try:
# 读取数据
while True:
try:
o = pickle.load(in_s)
except EOFError:
break
else:
print 'READ: %s (%s)' % (o.name, o.name_backwards)
finally:
in_s.close()

$ python pickle_load_from_file_1.py test.dat

Traceback (most recent call last):
File "pickle_load_from_file_1.py", line 52, in <module>
o = pickle.load(in_s)
AttributeError: 'module' object has no attribute 'SimpleObject'

from pickle_dump_to_file_1 import SimpleObject

$ python pickle_load_from_file_2.py test.dat

READ: pickle (elkcip)
READ: cPickle (elkciPc)
READ: last (tsal)

__getstate__()

__setstate__()

__getnewargs__()

C.__new__()

环形引用（Circular References）

import pickle

class Node(object):
"""
一个所有结点都可知它所连通的其它结点的简单有向图。
"""
def __init__(self, name):
self.name = name
self.connections = []
return

def add_edge(self, node):
"创建两个结点之间的一条边。"
self.connections.append(node)
return

def __iter__(self):
return iter(self.connections)

def preorder_traversal(root, seen=None, parent=None):
"""产生器（Generator ）函数通过一个先根遍历（preorder traversal）生成（yield）边。"""
if seen is None:
seen = set()
yield (parent, root)
if root in seen:
return
seen.add(root)
for node in root:
for (parent, subnode) in preorder_traversal(node, seen, root):
yield (parent, subnode)
return

def show_edges(root):
"打印图中的所有边。"
for parent, child in preorder_traversal(root):
if not parent:
continue
print '%5s -> %2s (%s)' % (parent.name, child.name, id(child))

# 创建结点。
root = Node('root')
a = Node('a')
b = Node('b')
c = Node('c')

# 添加边。
root.add_edge(a)
root.add_edge(b)
a.add_edge(b)
b.add_edge(a)
b.add_edge(c)
a.add_edge(a)

print 'ORIGINAL GRAPH:'
show_edges(root)

# 腌渍和反腌渍该图来创建
# 一个结点集合。
dumped = pickle.dumps(root)
reloaded = pickle.loads(dumped)

print
print 'RELOADED GRAPH:'
show_edges(reloaded)

id()

$ python pickle_cycle.py

ORIGINAL GRAPH:
root ->  a (4299721744)
a ->  b (4299721808)
b ->  a (4299721744)
b ->  c (4299721872)
a ->  a (4299721744)
root ->  b (4299721808)

RELOADED GRAPH:
root ->  a (4299722000)
a ->  b (4299722064)
b ->  a (4299722000)
b ->  c (4299722128)
a ->  a (4299722000)
root ->  b (4299722064)