精华内容
下载资源
问答
  • Python 序列自定义的类

    千次阅读 2018-04-19 06:35:31
    Python 序列自定义的类 目前主要的序列化模块是pickle和json。 接下来,我们把之前的我们自定义的树节点TreeNode类进行序列化。 TreeNode类代码参见Python 数据结构 tree 树 Pickle模块 pickle 可能是使用...

    Python 序列化自定义的类

    目前主要的序列化模块是pickle和json。

    接下来,我们把之前的我们自定义的树节点TreeNode类进行序列化。

    TreeNode类代码参见Python 数据结构 tree 树

    Pickle模块

    pickle 可能是使用最多的序列化模块了。
    cPickle是它的 C 语言实现,相比具有较好的性能。(推荐优先使用 cPickle)

    pickle提供的接口

    • dump() 序列化对象到文件
    • dumps() 序列化对象,返回字符串
    • load() 从文件加载对象
    • loads() 从字符串加载对象

    由于pickle支持的数据类型广泛

    • 如数字、布尔值、字符串
    • 只包含可序列化对象的元组、字典、列表等,非嵌套的函数、类
    • 通过类的__dict__或者__getstate__()可以返回序列化对象的实例

    不能支持的数据类型

    • 如 sockets 、文件、数据库连接等 (可以通过__getstate__()__setstate__()进行手动操作)

    由于我们的TreeNode类内部的属性都是简单的对象,所以可以使用pickle直接进行序列化。

    # build a tree
    root = TreeNode('') # root name is ''
    a1 = root.add_child('a1')
    a1.add_child('b1')
    a1.add_child('b2')
    a2 = root.add_child('a2')
    b3 = a2.add_child('b3')
    b3.add_child('c1')
    root.dump()
    
    # serialize to a string
    s = pickle.dumps(root)
    print(s)
    
    # deserialize from the string
    new_root = pickle.loads(s)
    new_root.dump()

    可以看到new_root.dump()的结果和之前的root.dump()一样。

    但是序列化的结果并不是易于阅读和手工修改, 例如:

    (i__main__
    TreeNode
    p1
    (dp2
    S'name'
    p3
    V
    sS'parent'
    p4
    NsS'child'
    p5
    (dp6
    Va1
    p7
    (i__main__
    TreeNode
    ......

    如果包含不能序列化的对象:
    - 序列化的时候,需要用到__getstate__()手工剔除
    - 反序列化的时候,通过__setstate__()手工加载

    例如:假设我们的TreeNode有一个文件句柄属性fp

    class TreeNode():
        """The basic node of tree structure"""
    
        def __init__(self, name, parent=None):
            # super(TreeNode, self).__init__()
            self.name = name
            self.parent = parent
            self.child = {}
            self.fpath = None 
            self.fp = None  # attr can not be serialized
    
        def __getstate__(self):
            """return a dict for current status"""
            state = self.__dict__.copy()
            del state['fp']  # manually delete
            return state
    
        def __setstate__(self, state):
            """return a dict for current status"""
            self.__dict__.update(state)
            self.fp = open(self.fpath)  # manually update
            return state

    上面的__getstate__()__setstate__()会在pickle的dump()load()中被自动调用。

    Json

    JSON ( JavaScript Object Notation )是一种轻量级数据交换格式。

    由于其格式使用了其他许多流行编程的约定,如 C 、 C++ 、 C#、 Java 、 JS 、 Python 等,加之其简单灵活、可读性和互操作性较强、易于解析和使用等特点,逐渐变得流行起来。

    由于TreeNode类是我们自定义的类结构,这里需要我们自己提供用于编码的解码的类。

    try: import simplejson as json
    except ImportError: import json
    
    class TreeNodeEncoder(json.JSONEncoder):
    
        def default(self, obj):
            if isinstance(obj, TreeNode):
                return {
                    'treenode_name': obj.name,
                    'child': {key: val for key, val in obj.items() },        
                }
            return json.JSONEncoder.default(self, obj)
    
    
    def TreeNodeDecoder(obj):
        if isinstance(obj, dict) and 'treenode_name' in obj:
            newobj = TreeNode(obj['treenode_name'])
            for name, subobj in obj.get('child', {}).items():
                newobj.add_child(name, TreeNodeDecoder(subobj))
            return newobj
        return obj

    NOTE: 为什么在上面的代码里用treenode_name这种丑陋的名字,而不是用name
    因为在Decoder的时候,需要判断那个object是我们的TreeNode dict。好无奈#_#

    当我们需要序列化的时候,

    print('test json dumps()')
    s = json.dumps(root, cls=TreeNodeEncoder, indent=4, sort_keys=True)
    print(s)
    
    print('test json loads()')
    new_root = json.loads(s, object_hook=TreeNodeDecoder)
    new_root.dump()

    序列化时通过参数cls来指定自定义的编码类,反序列化的时候通过object_hook来指定object的处理函数。

    序列化时参数indentsort_keys可以使序列化后的字符串更易于阅读和查找,例如:

    {
        "child": {
            "a1": {
                "child": {
                    "b1": {
                        "child": {},
                        "treenode_name": "b1" },
                    "b2": {
                        "child": {},
                        "treenode_name": "b2" }
                },
                "treenode_name": "a1"
            },
            "a2": {
                "child": {
                    "b3": {
                        "child": { "c1": { "child": {}, "treenode_name": "c1" } },
                        "treenode_name": "b3" }
                },
                "treenode_name": "a2"
            }
        },
        "treenode_name": ""
    }

    总结

    1. pickle比json要强大,要快,使用简单
    2. json的序列化结果更易于阅读和手工修改
    展开全文
  • json模块提供了一个类似于pickle中用于转换内存中Python对象为一个序列表示形式(“JavaScript Object Notation”)的API接口. 但和pickle不同的是, JSON在其他很多语言中都有对应实现(特别是在JavaScript中), 使其...

    PyMOTW: json

    • 模块: json
    • 目的: JavaScript对象格式序列器
    • python版本: 2.6

    json模块提供了一个类似于pickle中用于转换内存中Python对象为一个序列表示形式(“JavaScript Object Notation”)的API接口. 但和pickle不同的是, JSON在其他很多语言中都有对应实现(特别是在JavaScript中), 使其更适用于内部应用间的通信. 在一个AJAX应用中, JSON可能对于web服务器和客户端间的通信, 使用最为广泛, 但它也不仅限于这类应用.

     

     

     

    简单数据类型的编码和解码

    编码器默认支持Python的本地类型(如int, float, list, tuple, dict).

     

     

    1. import json  
    2. data = [ { 'a':'A''b':(24), 'c':3.0 } ]  
    3. print 'DATA:', repr(data)  
    4. data_string = json.dumps(data)  
    5. print 'JSON:', data_string  
     

    编码器处理之后的值和Python的repr()的输出值很类似.

    1. $ python json_simple_types.py  
    2. DATA: [{'a''A''c'3.0'b': (24)}]  
    3. JSON: [{"a""A""c"3.0"b": [24]}]  
     

    编码之后的解码所获的的值可能和原先的对象不是完全一致.

    1. import json  
    2. data = [ { 'a':'A''b':(24), 'c':3.0 } ]  
    3. data_string = json.dumps(data)  
    4. print 'ENCODED:', data_string  
    5. decoded = json.loads(data_string)  
    6. print 'DECODED:', decoded  
    7. print 'ORIGINAL:', type(data[0]['b'])  
    8. print 'DECODED :', type(decoded[0]['b'])  
     

    比如说, 元组会被转换为JSON的列表.

    1. $ python json_simple_types_decode.py  
    2. ENCODED: [{"a""A""c"3.0"b": [24]}]  
    3. DECODED: [{u'a': u'A', u'c'3.0, u'b': [24]}]  
    4. ORIGINAL: <type 'tuple'>  
    5. DECODED : <type 'list'>  
     

     

    人性化使用 vs 紧凑型输出

    JSON优于pickle的另外一点是其结果具有可读性. dumps()函数接收多个参数用于更好的输出结构. 比如说. sort_keys参数告诉编码器按照顺序输出字典的键值, 而不是随机无序的.

    1. import json  
    2. data = [ { 'a':'A''b':(24), 'c':3.0 } ]  
    3. print 'DATA:', repr(data)  
    4. unsorted = json.dumps(data)  
    5. print 'JSON:', json.dumps(data)  
    6. print 'SORT:', json.dumps(data, sort_keys=True)  
    7. first = json.dumps(data, sort_keys=True)  
    8. second = json.dumps(data, sort_keys=True)  
    9. print 'UNSORTED MATCH:', unsorted == first  
    10. print 'SORTED MATCH :', first == second  
     

    排序之后更容易让人看出结果, 也使进行JSON的比较输出成为可能.

     

    1. $ python json_sort_keys.py  
    2. DATA: [{'a''A''c'3.0'b': (24)}]  
    3. JSON: [{"a""A""c"3.0"b": [24]}]  
    4. SORT: [{"a""A""b": [24], "c"3.0}]  
    5. UNSORTED MATCH: False  
    6. SORTED MATCH : True  
     

    对于高度嵌套的数据结构, 你会想在输出结果中增加缩进以更好的显示其格式.

    1. import json  
    2. data = [ { 'a':'A''b':(24), 'c':3.0 } ]  
    3. print 'DATA:', repr(data)  
    4. print 'NORMAL:', json.dumps(data, sort_keys=True)  
    5. print 'INDENT:', json.dumps(data, sort_keys=True, indent=2)  
     

    当indent参数是一非负整数时, 输出的结构和pprint更为接近, 在每个缩进层次上都有前导空格.

    1. $ python json_indent.py  
    2. DATA: [{'a''A''c'3.0'b': (24)}]  
    3. NORMAL: [{"a""A""b": [24], "c"3.0}]  
    4. INDENT: [  
    5.              {  
    6.              "a""A",  
    7.              "b": [  
    8.                       2,  
    9.                       4  
    10.                       ],  
    11.              "c"3.0  
    12.              }  
    13. ]  
     

    像这种类型输出的数据在传输过程中需占用更多的字节, 不过, 在实际生产环境中没有必要使用缩进格式. 实际上, 你可以设置数据的分隔符来让结果更为紧凑.

    1. import json  
    2. data = [ { 'a':'A''b':(24), 'c':3.0 } ]  
    3. print 'DATA:', repr(data)  
    4. print 'repr(data) :', len(repr(data))  
    5. print 'dumps(data) :', len(json.dumps(data))  
    6. print 'dumps(data, indent=2) :', len(json.dumps(data, indent=2))  
    7. print 'dumps(data, separators):', len(json.dumps(data, separators=(',',':')))  
     

    dumps()函数的separators参数是一个元组, 包含分隔列表各项和字典键值各项的字符串. 默认是(‘, ‘, ‘: ‘). 可以去掉后者中的空格, 我们可以得到较紧凑的输出.

    1. $ python json_compact_encoding.py  
    2. DATA: [{'a''A''c'3.0'b': (24)}]  
    3. repr(data) : 35  
    4. dumps(data) : 35  
    5. dumps(data, indent=2) : 76  
    6. dumps(data, separators): 29  
     

     

    编码字典

    JSON格式中, 字典的键被限制为字符串类型. 如果字典中的键是其他类型, 那么在编码这个对象时会产生一个TypeError异常. 一种解决这个限制的方法是, 在编码时, 使用skipkeys参数跳过所有非字符串类型的键.

    1. import json  
    2. data = [ { 'a':'A''b':(24), 'c':3.0, ('d',):'D tuple' } ]  
    3. print 'First attempt'  
    4. try:  
    5.     print json.dumps(data)  
    6. except TypeError, err:  
    7.     print 'ERROR:', err  
    8. print  
    9. print 'Second attempt'  
    10. print json.dumps(data, skipkeys=True)  
     

    非字符串类型的键被忽略, 而不抛出一个异常.

    1. $ python json_skipkeys.py  
    2. First attempt  
    3. ERROR: key ('d',) is not a string  
    4. Second attempt  
    5. [{"a""A""c"3.0"b": [24]}]  
     

     

    自定义类型的处理

    上面所有的例子都是用了Python的内置类型作为例子, 因为他们都被json本身支持. 当然, 自定义类型也常常需要正确编码. 这里有两种情况:

    第一, 对于一个类的编码:

    1. class MyObj(object):  
    2.     def __init__(self, s):  
    3.         self.s = s  
    4.     def __repr__(self):  
    5.         return '<MyObj(%s)>' % self.s  
     

    编码一个MyObj对象的最简单方式是定义个转换函数, 用于将位置类型转换出呢个已知类型. 你没有必要自己进行编码, 而仅需要将一个对象转换成另一个对象.

    1. import json  
    2. import json_myobj  
    3. obj = json_myobj.MyObj('instance value goes here')  
    4. print 'First attempt'  
    5. try:  
    6.     print json.dumps(obj)  
    7. except TypeError, err:  
    8.     print 'ERROR:', err  
    9. def convert_to_builtin_type(obj):  
    10.     print 'default(', repr(obj), ')'  
    11.     # Convert objects to a dictionary of their representation  
    12.     d = { '__class__':obj.__class__.__name__,  
    13.           '__module__':obj.__module__,  
    14.         }  
    15.     d.update(obj.__dict__)  
    16.     return d  
    17. print  
    18. print 'With default'  
    19. print json.dumps(obj, default=convert_to_builtin_type)  
     

    在convert_to_builtin_type()函数中, 不被json识别的类对象被转换成一个包含足够能重建这个对象的字典信息.

    1. $ python json_dump_default.py  
    2. First attempt  
    3. ERROR: <MyObj(instance value goes here)> is not JSON serializable  
    4. With default  
    5. default( <MyObj(instance value goes here)> )  
    6. {"s""instance value goes here""__module__""json_myobj""__class__""MyObj"}  
     

     

    为了能解码结果数据并创建一个MyObj实例, 我们需要配合解码器以便可以从模块中导入类并创建实例. 我们在loads()函数中使用object_hook参数.

    在输入数据流中, 对于解码获得的每个字典都会调用object_hook, 将这个字典转换成其他类型的对象. hook函数返回的是调用程序所需要的对象, 而不是字典.

    1. import json  
    2. def dict_to_object(d):  
    3.     if '__class__' in d:  
    4.         class_name = d.pop('__class__')  
    5.         module_name = d.pop('__module__')  
    6.         module = __import__(module_name)  
    7.         print 'MODULE:', module  
    8.         class_ = getattr(module, class_name)  
    9.         print 'CLASS:'class_  
    10.         args = dict( (key.encode('ascii'), value) for key, value in d.items())  
    11.         print 'INSTANCE ARGS:', args  
    12.         inst = class_(**args)  
    13.     else:  
    14.         inst = d  
    15.     return inst  
    16. encoded_object = '[{"s": "instance value goes here", "__module__": "json_myobj", "__class__": "MyObj"}]'  
    17. myobj_instance = json.loads(encoded_object, object_hook=dict_to_object)  
    18. print myobj_instance  
     

    由于json将字符串值转换成unicode对象, 所以我们需要将作为类构造器的参数重新编码为ASCII字符串.

    1. $ python json_load_object_hook.py  
    2. MODULE: <module 'json_myobj' from '/Users/dhellmann/Documents/PyMOTW/src/PyMOTW/json/json_myobj.pyc'>  
    3. CLASS: <class 'json_myobj.MyObj'>  
    4. INSTANCE ARGS: {'s': u'instance value goes here'}  
    5. [<MyObj(instance value goes here)>]  
     

     

    对于内置类型也都有类似的hooks, 如整型(parse_int), 浮点型(parse_float), 常量(parse_constant).

    编码和解码类

    除了上述的这些函数外, json模块还提供了编码和解码类. 直接使用这些类, 你可以访问到额外的API接口或者定制创建它的子类.

    JSONEncoder提供了一个产生编码数据”块”的的迭代接口, 这在写入一个文件或网络sockets时(不需要在内存中完整表示整个数据)是非常方便的,

    1. import json  
    2. encoder = json.JSONEncoder()  
    3. data = [ { 'a':'A''b':(24), 'c':3.0 } ]  
    4. for part in encoder.iterencode(data):  
    5.     print 'PART:', part  
     

    正如你看到的, 数据是以逻辑单位形式输出的, 而不是按照数据长度输出.

    1. $ python json_encoder_iterable.py  
    2.      PART: [  
    3.              PART: {  
    4.              PART: "a"  
    5.              PART: :  
    6.              PART: "A"  
    7.              PART: ,  
    8.              PART: "c"  
    9.              PART: :  
    10.              PART: 3.0  
    11.              PART: ,  
    12.              PART: "b"  
    13.              PART: :  
    14.              PART: [  
    15.              PART: 2  
    16.              PART: ,  
    17.              PART: 4  
    18.              PART: ]  
    19.              PART: }  
    20.              PART: ]  
     

     

    encode()方法基本上等价于’‘.join(encoder.iterencode()), 只是多了些附加错误检查.

    为了能够编码任何类型的对象, 我们可以编写一类似于上述的convert_to_builtin_type()函数去重载default()方法.

    1. import json  
    2. import json_myobj  
    3. class MyEncoder(json.JSONEncoder):  
    4.     def default(self, obj):  
    5.         print 'default(', repr(obj), ')'  
    6.         # Convert objects to a dictionary of their representation  
    7.         d = { '__class__':obj.__class__.__name__,  
    8.               '__module__':obj.__module__,  
    9.             }  
    10.         d.update(obj.__dict__)  
    11.         return d  
    12. obj = json_myobj.MyObj('internal data')  
    13. print obj  
    14. print MyEncoder().encode(obj)  
     

    这里输出的结果是和先前的实现一致的.

    1. $ python json_encoder_default.py  
    2. <MyObj(internal data)>  
    3. default( <MyObj(internal data)> )  
    4. {"s""internal data""__module__""json_myobj""__class__""MyObj"}  
     

    解码后将字典转换成一个对象, 在先前实现的基础上稍作修改即可.

    1. import json  
    2. class MyDecoder(json.JSONDecoder):  
    3.     def __init__(self):  
    4.         json.JSONDecoder.__init__(self, object_hook=self.dict_to_object)  
    5.     def dict_to_object(self, d):  
    6.         if '__class__' in d:  
    7.             class_name = d.pop('__class__')  
    8.             module_name = d.pop('__module__')  
    9.             module = __import__(module_name)  
    10.             print 'MODULE:', module  
    11.             class_ = getattr(module, class_name)  
    12.             print 'CLASS:'class_  
    13.             args = dict( (key.encode('ascii'), value) for key, value in d.items())  
    14.             print 'INSTANCE ARGS:', args  
    15.             inst = class_(**args)  
    16.         else:  
    17.             inst = d  
    18.         return inst  
    19. encoded_object = '[{"s": "instance value goes here", "__module__": "json_myobj", "__class__": "MyObj"}]'  
    20. myobj_instance = MyDecoder().decode(encoded_object)  
    21. print myobj_instance  
     

    输出结果也是和先前例子中输出的一样.

    1. $ python json_decoder_object_hook.py  
    2. MODULE: <module 'json_myobj' from '/Users/dhellmann/Documents/PyMOTW/src/PyMOTW/json/json_myobj.pyc'>  
    3. CLASS: <class 'json_myobj.MyObj'>  
    4. INSTANCE ARGS: {'s': u'instance value goes here'}  
    5. [<MyObj(instance value goes here)>]  
     

     

    流和文件的处理

    到目前为止的所有例子, 我们都假设待编码的数据都是一次性完整加载到内存中的. 但对于大型数据结构来说, 将编码数据直接写入一个类文件对象, 可能会更好. load()和dump()函数可以接收一个用于读或写的类文件对象的引用.

    1. import json  
    2. import tempfile  
    3. data = [ { 'a':'A''b':(24), 'c':3.0 } ]  
    4. f = tempfile.NamedTemporaryFile(mode='w+')  
    5. json.dump(data, f)  
    6. f.flush()  
    7. print open(f.name, 'r').read()  
     

    对于socket来说, 也和正常文件句柄类似.

    1. $ python json_dump_file.py  
    2. [{"a""A""c"3.0"b": [24]}]  
     

    虽然一次性读取部分数据不是很好, 但是load()函数仍然提供了从流数据输入中封装生成对象的功能.

    1. import json  
    2. import tempfile  
    3. f = tempfile.NamedTemporaryFile(mode='w+')  
    4. f.write('[{"a": "A", "c": 3.0, "b": [2, 4]}]')  
    5. f.flush()  
    6. f.seek(0)  
    7. print json.load(f)  
     
    1. $ python json_load_file.py  
    2. [{u'a': u'A', u'c'3.0, u'b': [24]}]  
     

     

    混合数据流

    JSONDecoder包含了raw_decode()方法, 用于解码在很多数据组成的数据结构, 例如包含多余文本的JSON数据. 返回的值是从输入数据中解码获得的对象, 数据中的index表示解码对象结束时所在的位置.

    1. import json  
    2. decoder = json.JSONDecoder()  
    3. def get_decoded_and_remainder(input_data):  
    4.     obj, end = decoder.raw_decode(input_data)  
    5.     remaining = input_data[end:]  
    6.     return (obj, end, remaining)  
    7. encoded_object = '[{"a": "A", "c": 3.0, "b": [2, 4]}]'  
    8. extra_text = 'This text is not JSON.'  
    9. print 'JSON first:'  
    10. obj, end, remaining = get_decoded_and_remainder(' '.join([encoded_object, extra_text]))  
    11. print 'Object :', obj  
    12. print 'End of parsed input :', end  
    13. print 'Remaining text :', repr(remaining)  
    14. print  
    15. print 'JSON embedded:'  
    16. try:  
    17.     obj, end, remaining = get_decoded_and_remainder(  
    18.                  ' '.join([extra_text, encoded_object, extra_text])  
    19.                  )  
    20. except ValueError, err:  
    21.     print 'ERROR:', err  
     

    不幸的是, 这仅仅在对象出现在输入流的开始处才有效.

    1. $ python json_mixed_data.py  
    2. JSON first:  
    3. Object : [{u'a': u'A', u'c'3.0, u'b': [24]}]  
    4. End of parsed input : 35  
    5. Remaining text : ' This text is not JSON.'  
    6. JSON embedded:  
    7. ERROR: No JSON object could be decoded  


    展开全文
  • # 字典推导式的用法 my_dict = {'derek1':11,'derek2':22,'derek3':33} reversed_dict = {value:key for key,value in my_dict.items()} print(reversed_dict) #{11: 'derek1', 22: 'derek2', 33: 'derek3'}
  • Python: 自定义类对象序列化为Json串

    千次阅读 2019-03-06 11:12:00
    之前已经实现了Python: Json串反序列化为自定义类对象,这次来实现了Json的序列化。 测试代码和结果如下: import Json.JsonTool class Score: math = 0 chinese = 0 class Book: name = '' ...

        之前已经实现了Python: Json串反序列化为自定义类对象,这次来实现了Json的序列化。

        测试代码和结果如下:

    import Json.JsonTool
    
    
    class Score:
        math = 0
        chinese = 0
    
    
    class Book:
        name = ''
        type = ''
    
    
    class Student:
        id = ''
        name = ''
        score = Score()
        books = [Book()]
    
    
    student = Student()
    
    json_data = '{"id":"123", "name":"kid", "score":{"math":100, "chinese":98}, ' \
                '"books":[{"name":"math", "type":"study"}, ' \
                '{"name":"The Little Prince", "type":"literature"}]} '
    Json.JsonTool.json_deserialize(json_data, student)
    
    print(student.name)
    print(student.score.math)
    print(student.books[1].name)
    
    student_str = Json.JsonTool.json_serialize(student)
    print(student_str)
    
    input("\n按回车键退出。")

    运行结果:

    kid
    100
    The Little Prince
    {"books": [{"name": "math", "type": "study"}, {"name": "The Little Prince", "type": "literature"}], "id": "123", "name": "kid", "score": {"chinese": 98, "math": 100}}
    
    按回车键退出。

     

        实现代码如下:

    def json_serialize(obj):
        obj_dic = class2dic(obj)
        return json.dumps(obj_dic)
    
    
    def class2dic(obj):
        obj_dic = obj.__dict__
        for key in obj_dic.keys():
            value = obj_dic[key]
            obj_dic[key] = value2py_data(value)
        return obj_dic
    
    
    def value2py_data(value):
        if str(type(value)).__contains__('.'):
            # value 为自定义类
            value = class2dic(value)
        elif str(type(value)) == "<class 'list'>":
            # value 为列表
            for index in range(0, value.__len__()):
                value[index] = value2py_data(value[index])
        return value

     

    转载于:https://www.cnblogs.com/magic8sky/p/10482073.html

    展开全文
  • python 自定义序列

    2011-09-11 07:28:39
    def checkIndex(key):  if key  if not isinstance(key, (int , long)): raise TypeError class NumberQueue:  def __init__(self, start=0, step=1):  self.start = start ... self.ste
    def checkIndex(key):
    
        if key < 0: raise IndexError
        if not isinstance(key, (int , long)): raise TypeError
    class NumberQueue:
        def __init__(self, start=0, step=1):
            self.start = start
            self.step = step
            self.change = {}
        def __getitem__(self, key):
            checkIndex(key)
            try: return self.change[key]
            except:
                return self.start + key * self.step
        def __setitem__(self, key, value):
            checkIndex(key)
            self.change[key] = value
            
    nq1 = NumberQueue(1,1)
    print nq1[4]
    nq1[4]=2
    print nq1[4]
    展开全文
  • 内置json模块对于Python内置类型序列化的描述 """Extensible JSON <http://json.org> encoder for Python data structures. Supports the following objects and types by default: +-------------------+...
  • python 自定义排序

    万次阅读 2019-01-05 11:27:26
    我们都知道python中有两种排序的方法, 原地排序的x.sort(),和不改变原列表有返回值的sorted(x) 自定义排序函数 先不关心其实原地排序还是有返回值的排序,研究其内部的排序原理,其内部是根据什么排序的呢,...
  • 本文实例讲述了python使用cPickle模块序列化的方法,分享给大家供大家参考。 具体方法如下: import cPickle data1 = ['abc',12,23] #几个测试数据 data2 = {1:'aaa',"b":'dad'} data3 = (1,2,4) output_file = ...
  • 自定义序列的相关魔法方法允许我们自己创建的类拥有序列的特性,让其使用起来就像 python 的内置序列(dict,tuple,list,string等)。 如果要实现这个功能,就要遵循 python 的相关的协议。所谓的协议就是一些约定...
  • python中如果我改了自己之前的类代码,那以前的序列化对象还能反序列化回来吗? 着急的可以跳过代码,直接看底下的结论. class DemoClass: #初始版本 def __init__(self,v1,v2,v3): self.v1=v1 self.v2=v2 ...
  • Python实现自定义序列》一节中,已经学会了如何自定义一个序列类,但该序列类对象并不支持迭代,因此还不能称之为迭代器。如果要自定义实现一个迭代器,则类中必须实现如下 2 个方法: next(self):返回容器的下一...
  • 自定义对象转json:自己探索出来的,直接看下面简单的例子吧。#自定义对象转换成json import json #自定义对象 class C: key1=list key2=str key3=int key4=tuple def __init__(self,key1,key2,key3,key4): ...
  • GeneratorExit 生成器(generator)发生异常来通知退出 ImportError 导入模块/对象失败 IndentationError 缩进错误 IndexError 序列中没有没有此索引(index) IOError 输入/输出操作失败 KeyboardInterrupt 用户中断...
  • filter()函数可以对序列做过滤处理,就是说可以使用一个自定的函数过滤一个序列,把序列的每一项传到自定义的过滤函数里处理,并返回结果做过滤。最终一次性返回过滤后的结果。 filter()函数有两个参数: 第一个,自...
  • python自定义排序函数

    万次阅读 2016-01-02 16:47:08
    python自定义排序函数,有两种方式 第一种自定义函数: # 自定义排序函数 def func(x,y): if x return -1 if x==y: return 0 else: return 1 a = [3,6,2,8,4] print u'正序排列:',sorted(a,func) print u'
  • 背景:Python 自定义函数是 PyFlink Table API 中最重要的功能之一,其允许用户在 PyFlink Table API 中使用 Python 语言开发的自定义函数,极大...
  • Python自定义函数需要注意的问题

    千次阅读 2019-08-21 14:32:13
    Python自定义函数需要注意的问题: 1.缩进。一个语句块要用相同的缩进,两个缩进相同的逻辑行可以看做可以并列的关系,不可能是所属关系。 return需要跟for对齐,否则 2.遍历。range(n) 代表的是从0开始,遍历到...
  • 切片是 Python 中最迷人最强大最 Amazing 的语言特性(几乎没有之一),在《Python进阶:切片的误区与高级用法》中,我介绍了切片的基础用法、高级用法以及一些使用误区。这些内容都是基于原生的序列类型(如字符串...
  • 完成gap值的自定义输入以及两条需比对序列的输入 b.完成得分矩阵的计算及输出 c.输出序列比对结果 d.使用matplotlib对得分矩阵路径的绘制 一、实现步骤 1.用户输入步骤 a.输入自定义的gap值 b.输入需要比对的碱基...
  • 每种编程语言都有各自的数据类型,其中面向对象的编程语言还允许开发者自定义数据类型(如:自定义类),Python也是一样。很多时候我们会有这样的需求: 把内存中的各种数据类型的数据通过网络传送给其它机器或...
  • 自定义序列 除了构造方法__init__,还可以使用如下4个特殊方法定义自己的序列类,就像以前说过的列表、字典等序列一样,只不过拥有自己特殊的行为。所有的特殊方法在名称前后都需要双下划线__。 __len__(self):返回...
  • 而DRF(Django REST Framework)就可以帮忙我解决这个问题,即序列化和反序列化 1.安装DRF 使用pip安装 pip install djangorestframework 配置应用 INSTALLED_APPS = [ ... 'rest_framework', ] 2.定义...
  • 函数 1.定义 函数是组织好的,可重复使用的,用来实现单一...自定义函数 1.3语法: def functionname(parameters): "函数_文档字符串" function_suite return [expression] 1.4函数的返回值 ...
  • 前言 在写项目级别的工程时候,需要将常用的函数封装成一个工具文件中,作为一名数据仔,通常只是写写...作为一个数据分析仔,和时间序列数据打交道是在平常不过了,下面有一个获取日期对应是星期几的函数为列子,...
  • 主要介绍了django 解决自定义序列化返回处理数据为null的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 详解Python 序列化Serialize 和 反序列化Deserialize 序列化 (serialization) 序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化, 它将流转换为对象。这两个过程结合起来,可以轻松地...
  • 最近刚接触到python,就想到了如何反序列化json串。...然后我在此基础上将python数据转换为了自定义类对象。 下面是测试代码及运行结果: import Json.JsonTool class Score: math = 0 chinese = 0 ...
  • python序列类型-python-序列类型

    千次阅读 2020-11-01 13:24:09
    1. 元组元组是个有序的序列,其中包含0个或多个对象引用。元组支持与字符串一样的分片与步距的语法,这使得从元组中提取数据项比较容易。元组也是固定的,不能替换或删除其中包含的任意数据项。如果需要修改有序序列...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,803
精华内容 25,521
关键字:

python自定义序列

python 订阅