def convert_object(cls, obj):
"""
convert all objects to dictionaries - otherwise preserve structure
"""
if hasattr(obj, "to_json"):
return obj.to_json()
if obj == None:
return obj
for a in cls.allowed:
if isinstance(obj, a):
return obj
if isinstance(obj, list):
return [cls.convert_object(x) for x in obj]
if isinstance(obj, dict):
return {x: cls.convert_object(y) for x, y in obj.iteritems()}
# all other objects
"""
if registered, store using a basic recursive dictionary approach (easier to edit)
"""
if obj.__class__.__name__ in cls.classes:
return obj.serial_dumps()
if isinstance(obj, types.FunctionType) == False:
return {"_type": obj.__class__.__name__,
"_pickle": pickle.dumps(obj)}
def send(self, input):
t = pickle.dumps(input)
self.socket.sendto(t, (self.host, self.port))
def pickle(self, obj):
return pickle.dumps(obj)
#encoding:utf-8
try:
import cpickle as pickle
except:
import pickle
import pprint
data=[{'a':'A','b':2.0,'c':2.5}]
print 'BEFORE Date:',
pprint.pprint(data)
#pickle只包含ASCII字符
data_string=pickle.dumps(data)
data2=pickle.loads(data_string)
print 'AFTER pickle: ',
pprint.pprint(data2)
print 'SAME?:',(data is data2)
print 'EQL?:',(data==data2)
def parse_rpcline_expression(rpcline):
try:
return pickle.dumps(
dict([item.split('|', 1) for item in rpcline.split(',')]))
except:
return rpcline
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# -----------------------------------------------------
# FileName : pickle_string.py
# Author : linuxme@
# Project : monitor_maintain
# Date : 2013-09-01 10:32
# Description :
# -----------------------------------------------------
try:
import cpickle as pickle
except:
import pickle
import 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)
def pickle(self, obj):
return pickle.dumps(obj)
from socket import *
import cpickle as pickle
import time
import numpy as np
# Set the socket parameters
host = '104.194.113.209'
port = 9999
buf = 10**4
addr = (host, port)
# Create socket
UDPSock = socket(AF_INET, SOCK_DGRAM)
def_msg = "===Enter message to send to server==="
print("\n", def_msg)
#a = array('i',[1,3,2])
# Send messages
while 1:
if (UDPSock.sendto(pickle.dumps(np.random.random(2**12)), addr)):
print("Sending message")
time.sleep(1)
# Close socket
UDPSock.close()
# coding=utf-8
d = dict(a=1, b=2, c=3)
try:
import cpickle as pickle
except ImportError:
import pickle
s = pickle.dumps(d)
f = open('dump.txt', 'wb')
pickle.dump(d, f)
f.close()
f = open('dump.txt', 'rb')
h = pickle.load(f)
f.close()
pickle.loads(pickle.dumps(d))
import json
w = json.dumps(d)
i = json.loads(w)
import json
class Student(object):
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
from socket import *
import cpickle as pickle
import time
import numpy as np
# Set the socket parameters
host = '104.194.113.209'
port = 9999
buf = 10**4
addr = (host,port)
# Create socket
UDPSock = socket(AF_INET,SOCK_DGRAM)
def_msg = "===Enter message to send to server===";
print ("\n",def_msg)
#a = array('i',[1,3,2])
# Send messages
while 1:
if(UDPSock.sendto(pickle.dumps(np.random.random(2**12)),addr)):
print ("Sending message")
time.sleep(1)
# Close socket
UDPSock.close()
两种存储模式 ；fixed和table 后者有点慢
store.put('obj2',frame,format='table')
store.select('obj2',where=['index>=10 and index <= 15'])
逆操作
store['obj2']
5.9 pickle python对象序列化======
序列化是指把对象的层级几个转换成字节流的过程
5.9.1 用 cPickle实现python对象序列化
import cpickle as pickle
dumps()函数
pickled_data = pickle.dumps(data)
数据序列化后，再写入文件或用套接字，管道等发送就很简单
反序列化 loads()函数
nframe = pickle.loads(pickled_data)
----5.9.2 用pandas实现对象序列化----- ‘’‘重点====
无需导入cpickle模块，所有的操作都是隐士进行的
frame.to_pickle('frame.pkl')
读取数据
pd.read_pickle('trame.pkl')
def ExecuteMultilevelMonteCarloAnalisys_Task(
current_MLMC_level, pickled_coarse_model, pickled_coarse_parameters,
size_meshes, pickled_settings_metric_refinement,
pickled_settings_remesh_refinement, sample, current_level,
mlmc_results_class):
'''unpickle model and build Kratos Model object'''
serialized_model = pickle.loads(pickled_coarse_model)
current_model = KratosMultiphysics.Model()
serialized_model.Load("ModelSerialization", current_model)
del (serialized_model)
'''unpickle parameters and build Kratos Parameters object'''
serialized_parameters = pickle.loads(pickled_coarse_parameters)
current_parameters = KratosMultiphysics.Parameters()
serialized_parameters.Load("ParametersSerialization", current_parameters)
del (serialized_parameters)
'''start time'''
start_MLMC_time = time.time()
'''refine if current current_level > 0, adaptive refinement based on the solution of previous level'''
if (current_level > 0):
'''unpickle metric and remesh refinement parameters and build Kratos Parameters objects'''
settings_metric_refinement_serializer = pickle.loads(
pickled_settings_metric_refinement)
settings_remesh_refinement_serializer = pickle.loads(
pickled_settings_remesh_refinement)
current_settings_metric_refinement = KratosMultiphysics.Parameters()
current_settings_remesh_refinement = KratosMultiphysics.Parameters()
settings_metric_refinement_serializer.Load(
"MetricRefinementParametersSerialization",
current_settings_metric_refinement)
settings_remesh_refinement_serializer.Load(
"RemeshRefinementParametersSerialization",
current_settings_remesh_refinement)
del (settings_metric_refinement_serializer,
settings_remesh_refinement_serializer)
'''refine the model Kratos object'''
refined_model, refined_parameters = refinement.compute_refinement_hessian_metric(
current_model, current_parameters, size_meshes[current_level],
size_meshes[current_level - 1], current_settings_metric_refinement,
current_settings_remesh_refinement)
'''initialize the model Kratos object'''
simulation = MultilevelMonteCarloAnalysis(refined_model,
refined_parameters, sample)
simulation.Initialize()
'''update model Kratos object'''
current_model = simulation.model
current_parameters = simulation.project_parameters
del (simulation)
simulation = MultilevelMonteCarloAnalysis(current_model,
current_parameters, sample)
simulation.Run()
QoI = EvaluateQuantityOfInterest(simulation)
'''save model and parameters as StreamSerializer Kratos objects'''
serialized_finer_model = KratosMultiphysics.StreamSerializer()
serialized_finer_model.Save("ModelSerialization", simulation.model)
serialized_finer_parameters = KratosMultiphysics.StreamSerializer()
serialized_finer_parameters.Save("ParametersSerialization",
simulation.project_parameters)
'''pickle model and parameters'''
pickled_finer_model = pickle.dumps(
serialized_finer_model, 2
) # second argument is the protocol and is NECESSARY (according to pybind11 docs)
pickled_finer_parameters = pickle.dumps(
serialized_finer_parameters, 2
) # second argument is the protocol and is NECESSARY (according to pybind11 docs)
del (simulation)
end_MLMC_time = time.time()
'''register results of the current level in the MultilevelMonteCarloResults class'''
mlmc_results_class.time_ML[current_level].append(
end_MLMC_time - start_MLMC_time
) # saving each result in the corresponding list in order to ensure the correctness of the results order and the levels
mlmc_results_class.QoI[current_level].append(
QoI
) # saving each result in the corresponding list in order to ensure the correctness of the results order and the levels
return mlmc_results_class, pickled_finer_model, pickled_finer_parameters
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# -----------------------------------------------------
# FileName : pickle_string.py
# Author : linuxme@
# Project : monitor_maintain
# Date : 2013-09-01 10:32
# Description :
# -----------------------------------------------------
try:
import cpickle as pickle
except:
import pickle
import 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)
#encoding:utf-8
try:
import cpickle as pickle
except:
import pickle
import pprint
data = [{'a': 'A', 'b': 2.0, 'c': 2.5}]
print 'BEFORE Date:',
pprint.pprint(data)
#pickle只包含ASCII字符
data_string = pickle.dumps(data)
data2 = pickle.loads(data_string)
print 'AFTER pickle: ',
pprint.pprint(data2)
print 'SAME?:', (data is data2)
print 'EQL?:', (data == data2)
def dump_self(self):
return cpickle.dumps(self)
def dump_self(self):
return cpickle.dumps(self)
