1. Toy模板网首页
  2. > Toy博客

python序列化反序列化和异常处理笔记

9月前 作者：sun13047140038 分类：Toy博客 阅读(34) 违法举报

这篇具有很好参考价值的文章主要介绍了python序列化反序列化和异常处理笔记。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

迭代器

迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

1. 可迭代对象

我们已经知道可以对list、tuple、str等类型的数据使用for...in...的循环语法从其中依次拿到数据进行使用，我们把这样的过程称为遍历，也叫迭代。

但是，是否所有的数据类型都可以放到for...in...的语句中，然后让for...in...每次从中取出一条数据供我们使用，即供我们迭代吗？

>>> for i in 100:...     print(i)
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>># int整型不是iterable，即int整型不是可以迭代的

我们把可以通过for...in...这类语句迭代读取一条数据供我们使用的对象称之为可迭代对象(Iterable)。

2. 如何判断一个对象是否可以迭代

可以使用 isinstance() 判断一个对象是否是 Iterable 对象：

In [50]: from collections import Iterable
 

In [51]: isinstance([], Iterable)
 

Out[51]: True
 

 

In [52]: isinstance({}, Iterable)
 

Out[52]: True
 

 

In [53]: isinstance('abc', Iterable)
 

Out[53]: True
 

 

In [54]: isinstance(mylist, Iterable)
 

Out[54]: False
 

 

In [55]: isinstance(100, Iterable)
 

Out[55]: False
 

3. 可迭代对象的本质
 

我们分析对可迭代对象进行迭代使用的过程，发现每迭代一次（即在for...in...中每循环一次）都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有数据后结束。那么，在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，以便每次迭代都可以返回下一条数据。我们把这个能帮助我们进行数据迭代的“人”称为迭代器(Iterator)。
 

可迭代对象的本质就是可以向我们提供一个这样的中间“人”即迭代器帮助我们对其进行迭代遍历使用。
 

可迭代对象通过__iter__方法向我们提供一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据.
 

那么也就是说，一个具备了__iter__方法的对象，就是一个可迭代对象。
 

from collections.abc import Iterableclass Demo(object):
 

    def __init__(self, n):
 

        self.n = n
 

        self.current = 0
 

    def __iter__(self):
 

        pass
 

 

demo = Demo(10)
 

print(isinstance(demo, Iterable))  # True
 

for d in demo:   # 重写了 __iter__ 方法以后，demo就是一个一个可迭代对象了，可以放在for...in的后面
 

    print(d)
 

# 此时再使用for...in循环遍历，会提示 TypeError: iter() returned non-iterator of type 'NoneType'# 这是因为，一个可迭代对象如果想要被for...in循环，它必须要有一个迭代器
 

4. 迭代器Iterator
 

通过上面的分析，我们已经知道，迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的__next__方法（Python3中是对象的__next__方法，Python2中是对象的next()方法）。所以，我们要想构造一个迭代器，就要实现它的next方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现__iter__方法，而__iter__方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的__iter__方法返回自身即可。
 

一个实现了iter方法和next方法的对象，就是迭代器。
 

class MyIterator(object):
 

    def __init__(self, n):
 

        self.n = n
 

        self.current = 0
 

 

    # 自定义迭代器需要重写__iter__和__next__方法
 

    def __iter__(self):
 

        return self
 

 

    def __next__(self):
 

        if self.current < self.n:
 

            value = self.current
 

            self.current += 1
 

            return value
 

        else:
 

            raise StopIteration
 

 

my_it = MyIterator(10)
 

for i in my_it:    # 迭代器重写了__iter__方法，它本身也是一个可迭代对象
 

    print(i)
 

5. 如何判断一个对象是否是迭代器
 

调用一个对象的__iter__方法，或者调用iter()内置函数，可以获取到一个可迭代对象的迭代器。
 

names = ['hello', 'good', 'yes']
 

print(names.__iter__())  # 调用对象的__iter__()方法
 

print(iter(names))  # 调用iter()内置函数
 

可以使用 isinstance() 判断一个对象是否是 Iterator 对象：
 

from collections.abc import Iterator
 

names = ['hello', 'good', 'yes']
 

print(isinstance(iter(names), Iterator))
 

6. for...in...循环的本质
 

for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。
 

7. 迭代器的应用场景
 

我们发现迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的，那么也就意味着可以不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，这样可以节省大量的存储（内存）空间。
 

举个例子，比如，数学中有个著名的斐波拉契数列(Fibonacci)，数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：
 

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
 

现在我们想要通过for...in...循环来遍历迭代斐波那契数列中的前n个数。那么这个斐波那契数列我们就可以用迭代器来实现，每次迭代都通过数学计算来生成下一个数。
 

class FibIterator(object):
 

    """斐波那契数列迭代器"""
 

    def __init__(self, n):
 

        """
 

        :param n: int, 指明生成数列的前n个数
 

        """
 

        self.n = n
 

        # current用来保存当前生成到数列中的第几个数了
 

        self.current = 0
 

        # num1用来保存前前一个数，初始值为数列中的第一个数0
 

        self.num1 = 0
 

        # num2用来保存前一个数，初始值为数列中的第二个数1
 

        self.num2 = 1
 

 

    def __next__(self):
 

        """被next()函数调用来获取下一个数"""
 

        if self.current < self.n:
 

            num = self.num1
 

            self.num1, self.num2 = self.num2, self.num1+self.num2
 

            self.current += 1
 

            return num
 

        else:
 

            raise StopIteration
 

 

    def __iter__(self):
 

        """迭代器的__iter__返回自身即可"""
 

        return self
 

 

if __name__ == '__main__':
 

    fib = FibIterator(10)
 

    for num in fib:
 

        print(num, end=" ")
 
 
 
 

生成器
 

1. 生成器
 

利用迭代器，我们可以在每次迭代获取数据（通过next()方法）时按照特定的规律进行生成。但是我们在实现一个迭代器时，关于当前迭代到的状态需要我们自己记录，进而才能根据当前状态生成下一个数据。为了达到记录当前状态，并配合next()函数进行迭代使用，我们可以采用更简便的语法，即生成器(generator)。生成器是一类特殊的迭代器。
 

2. 创建生成器方法1
 

要创建一个生成器，有很多种方法。第一种方法很简单，只要把一个列表生成式的 [ ] 改成 ( )
 

In [15]: L = [ x*2 for x in range(5)]
 

 

In [16]: L
 

Out[16]: [0, 2, 4, 6, 8]
 

 

In [17]: G = ( x*2 for x in range(5))
 

 

In [18]: G
 

Out[18]: <generator object <genexpr> at 0x7f626c132db0>
 

 

In [19]:
 

创建 L 和 G 的区别仅在于最外层的 [ ] 和 ( ) ， L 是一个列表，而 G 是一个生成器。我们可以直接打印出列表L的每一个元素，而对于生成器G，我们可以按照迭代器的使用方法来使用，即可以通过next()函数、for循环、list()等方法使用。
 

In [19]: next(G)
 

Out[19]: 0
 

 

In [20]: next(G)
 

Out[20]: 2
 

 

In [21]: next(G)
 

Out[21]: 4
 

 

In [22]: next(G)
 

Out[22]: 6
 

 

In [23]: next(G)
 

Out[23]: 8
 

 

In [24]: next(G)
 

---------------------------------------------------------------------------
 

StopIteration                             Traceback (most recent call last)
 

<ipython-input-24-380e167d6934> in <module>()
 

----> 1 next(G)
 

 

StopIteration:
 

 

In [25]:
 

In [26]: G = ( x*2 for x in range(5))
 

 

In [27]: for x in G:
 

   ....:     print(x)
 

   ....:     
 

0
 

2
 

4
 

6
 

8
 

 

In [28]:
 

3. 创建生成器方法2
 

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的 for 循环无法实现的时候，还可以用函数来实现。
 

我们仍然用上一节提到的斐波那契数列来举例，回想我们在上一节用迭代器的实现方式：
 

class FibIterator(object):
 

    """斐波那契数列迭代器"""
 

    def __init__(self, n):
 

        """
 

        :param n: int, 指明生成数列的前n个数
 

        """
 

        self.n = n
 

        # current用来保存当前生成到数列中的第几个数了
 

        self.current = 0
 

        # num1用来保存前前一个数，初始值为数列中的第一个数0
 

        self.num1 = 0
 

        # num2用来保存前一个数，初始值为数列中的第二个数1
 

        self.num2 = 1
 

 

    def __next__(self):
 

        """被next()函数调用来获取下一个数"""
 

        if self.current < self.n:
 

            num = self.num1
 

            self.num1, self.num2 = self.num2, self.num1+self.num2
 

            self.current += 1
 

            return num
 

        else:
 

            raise StopIteration
 

 

    def __iter__(self):
 

        """迭代器的__iter__返回自身即可"""
 

        return self
 

注意，在用迭代器实现的方式中，我们要借助几个变量(n、current、num1、num2)来保存迭代的状态。现在我们用生成器来实现一下。
 

In [30]: def fib(n):
 

   ....:     current = 0
 

   ....:     num1, num2 = 0, 1
 

   ....:     while current < n:
 

   ....:         yield num1
 

   ....:         num1, num2 = num2, num1+num2
 

   ....:         current += 1
 

   ....:     return 'done'
 

   ....:
 

 

In [31]: F = fib(5)
 

 

In [32]: next(F)
 

Out[32]: 1
 

 

In [33]: next(F)
 

Out[33]: 1
 

 

In [34]: next(F)
 

Out[34]: 2
 

 

In [35]: next(F)
 

Out[35]: 3
 

 

In [36]: next(F)
 

Out[36]: 5
 

 

In [37]: next(F)
 

---------------------------------------------------------------------------
 

StopIteration                             Traceback (most recent call last)
 

<ipython-input-37-8c2b02b4361a> in <module>()
 

----> 1 next(F)
 

 

StopIteration: done
 

在使用生成器实现的方式中，我们将原本在迭代器__next__方法中实现的基本逻辑放到一个函数中来实现，但是将每次迭代返回数值的return换成了yield，此时新定义的函数便不再是函数，而是一个生成器了。简单来说：只要在def中有yield关键字的 就称为 生成器
 

此时按照调用函数的方式( 案例中为F = fib(5) )使用生成器就不再是执行函数体了，而是会返回一个生成器对象（ 案例中为F ），然后就可以按照使用迭代器的方式来使用生成器了。
 

In [38]: for n in fib(5):
 

   ....:     print(n)
 

   ....:     11235
 

 

In [39]:
 

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
 

In [39]: g = fib(5)
 

 

In [40]: while True:
 

   ....:     try:
 

   ....:         x = next(g)
 

   ....:         print("value:%d"%x)      
 

   ....:     except StopIteration as e:
 

   ....:         print("生成器返回值:%s"%e.value)
 

   ....:         break
 

   ....:     
 

value:1
 

value:1
 

value:2
 

value:3
 

value:5
 

生成器返回值:done
 

 

In [41]:
 

总结
 

    

  • 使用了yield关键字的函数不再是函数，而是生成器。（使用了yield的函数就是生成器）
    • 

  • 
yield关键字有两点作用： 
  
      

    • 保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起
      • 

    • 将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return的作用
      • 

    

    • 

  • 可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）
    • 

  • 
Python3中的生成器可以使用return返回最终运行的返回值，而Python2中的生成器不允许使用return返回一个返回值（即可以使用return从生成器中退出，但return后不能有任何表达式）。

    • 



4. 使用send唤醒
 

我们除了可以使用next()函数来唤醒生成器继续执行外，还可以使用send()函数来唤醒执行。使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据。
 

例子：执行到yield时，gen函数作用暂时保存，返回i的值; temp接收下次c.send("python")，send发送过来的值，c.next()等价c.send(None)
 

In [10]: def gen():
 

   ....:     i = 0
 

   ....:     while i<5:
 

   ....:         temp = yield i
 

   ....:         print(temp)
 

   ....:         i+=1
 

   ....:
 

使用send
 

In [43]: f = gen()
 

 

In [44]: next(f)
 

Out[44]: 0
 

 

In [45]: f.send('haha')
 

haha
 

Out[45]: 1
 

 

In [46]: next(f)None
 

Out[46]: 2
 

 

In [47]: f.send('haha')
 

haha
 

Out[47]: 3
 

 

In [48]:
 

使用next函数
 

In [11]: f = gen()
 

 

In [12]: next(f)
 

Out[12]: 0
 

 

In [13]: next(f)
 

None
 

Out[13]: 1
 

 

In [14]: next(f)
 

None
 

Out[14]: 2
 

 

In [15]: next(f)
 

None
 

Out[15]: 3
 

 

In [16]: next(f)
 

None
 

Out[16]: 4
 

 

In [17]: next(f)
 

None
 

---------------------------------------------------------------------------
 

StopIteration                             Traceback (most recent call last)
 

<ipython-input-17-468f0afdf1b9> in <module>()
 

----> 1 next(f)
 

 

StopIteration:
 

使用__next__()方法（不常使用）
 

In [18]: f = gen()
 

 

In [19]: f.__next__()
 

Out[19]: 0
 

 

In [20]: f.__next__()
 

None
 

Out[20]: 1
 

 

In [21]: f.__next__()
 

None
 

Out[21]: 2
 

 

In [22]: f.__next__()
 

None
 

Out[22]: 3
 

 

In [23]: f.__next__()
 

None
 

Out[23]: 4
 

 

In [24]: f.__next__()
 

None
 

---------------------------------------------------------------------------
 

StopIteration                             Traceback (most recent call last)
 

<ipython-input-24-39ec527346a9> in <module>()
 

----> 1 f.__next__()
 

 

StopIteration:
 
 
 

property属性
 

property属性是一种用起来像是实例属性一样的特殊属性，可以对应于某个方法。
 

class Foo:
 

    def func(self):
 

        pass
 

 

    # 定义property属性    @property
 

    def prop(self):
 

        pass
 

# ############### 调用 ###############
 

foo_obj = Foo()
 

foo_obj.func()  # 调用实例方法
 

foo_obj.prop  # 调用property属性
 

property属性的定义和调用要注意一下几点：
 



定义时，在实例方法的基础上添加 @property 装饰器；并且仅有一个self参数
 

    

  • 

  • 



调用时，无需括号
 



  方法：foo_obj.func()
 

  property属性：foo_obj.prop
 



简单的实例
 

对于京东商城中显示电脑主机的列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据 这个分页的功能包括：
 

    

  • 根据用户请求的当前页和总数据条数计算出 m 和 n
    • 

  • 根据m 和 n 去数据库中请求数据
    • 



# ############### 定义 ###############class Pager:
 

    def __init__(self, current_page):
 

        # 用户当前请求的页码（第一页、第二页...）
 

        self.current_page = current_page
 

        # 每页默认显示10条数据
 

        self.per_items = 10 
 

    @property
 

    def start(self):
 

        val = (self.current_page - 1) * self.per_items
 

        return val
 

    @property
 

    def end(self):
 

        val = self.current_page * self.per_items
 

        return val
 

# ############### 调用 ###############
 

p = Pager(1)
 

p.start  # 就是起始值，即：m
 

p.end  # 就是结束值，即：n
 

从上述可见
 

  • 
Python的property属性的功能是：property属性内部进行一系列的逻辑计算，最终将计算结果返回。



property属性的两种方式
 

    

  • 装饰器 即：在方法上应用装饰器
    • 

  • 类属性 即：在类中定义值为property对象的类属性
    • 



装饰器方式
 

在类的实例方法上应用@property装饰器
 

Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 如果类继object，那么该类是新式类 ）
 



经典类的实现：
 



class Goods:    @property
 

    def price(self):
 

        return "laowang"
 

 

obj = Goods()
 

result = obj.price  # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
 

print(result)
 

    

  • 

  • 



新式类的实现：
 



class Goods:
 

    """
 

    只有在python3中才有@xxx.setter  @xxx.deleter
 

    """
 

    def __init__(self):
 

        # 原价
 

        self.original_price = 100
 

        # 折扣
 

        self.discount = 0.8
 

    @property
 

    def price(self):
 

        new_price = self.original_price * self.discount
 

        return new_price
 

    @price.setter
 

    def price(self, value):
 

        self.original_price = value
 

    @price.deleter
 

    def price(self):
 

        del self.original_price
 

obj = Goods()
 

obj.price          # 获取商品价格
 

obj.price = 200    # 修改商品原价del obj.price      # 删除商品原价
 



总结：
 

    

  • 经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
    • 

  • 新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
    • 



类属性方式
 



当使用类属性的方式创建property属性时，经典类和新式类无区别。
 



class Foo:
 

    def get_bar(self):
 

        return 'laowang'
 

    BAR = property(get_bar)
 

 

obj = Foo()
 

reuslt = obj.BAR  # 自动调用get_bar方法，并获取方法的返回值
 

print(reuslt)
 



property方法中有个四个参数文章来源地址https://www.toymoban.com/news/detail-648510.html
 

  •  
  
      

    • 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
      • 

    • 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
      • 

    • 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
      • 

    • 第四个参数是字符串，调用 对象.属性.doc ，此参数是该属性的描述信息
      • 

    



class Foo(object):
 

    def get_bar(self):
 

        print("getter...")
 

        return 'laowang'
 

 

    def set_bar(self, value): 
 

        """必须两个参数"""
 

        print("setter...")
 

        return 'set value' + value
 

 

    def del_bar(self):
 

        print("deleter...")
 

        return 'laowang'
 

 

    BAR = property(get_bar, set_bar, del_bar, "description...")
 

 

obj = Foo()
 

 

obj.BAR  # 自动调用第一个参数中定义的方法：get_bar
 

obj.BAR = "alex"  # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
 

desc = Foo.BAR.__doc__  # 自动获取第四个参数中设置的值：description...
 

print(desc)del obj.BAR  # 自动调用第三个参数中定义的方法：del_bar方法
 

总结：
 

    

  • 定义property属性共有两种方式，分别是【装饰器】和【类属性】，而【装饰器】方式针对经典类和新式类又有所不同。
    • 

  • 通过使用property属性，能够简化调用者在获取数据的流程。
    • 


                    
到了这里，关于python序列化反序列化和异常处理笔记的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

                

                

                                                

                   

                       
                            
                            
                            
                            
                    
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

                

                                

                    
分享到：

                    领支付宝红包
                    赞助服务器费用
                

                            

            

		        
相关文章

			    
    
			        			        
  • 
			                                    
    
                            
                                【Linux后端服务器开发】协议定制（序列化与反序列化）
                            
                        
    
                                                
    
                            
    
                                【Linux后端服务器开发】协议定制（序列化与反序列化）
                            
    
                            
    
                                
    目录 一、应用层协议概述 二、序列化与反序列化 Protocal.h头文件 Server.h头文件 Client.h头文件 server.cpp源文件 client.cpp源文件 什么是应用层 ？我们通过编写程序解决一个个实际问题、满足我们日常需求的网络程序，都是应用层程序。 协议是一种“约定”，socket的api接口，在读
    
                            
    
                            
    
                                2024年02月16日
                                
    
                                    浏览(40)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                Protobuf协议初级详解（python使用）从安装到序列化-反序列化
                            
                        
    
                                                
    
                            
    
                                Protobuf协议初级详解（python使用）从安装到序列化-反序列化
                            
    
                            
    
                                
    Protobuf是一种轻便高效的结构化数据存储格式，可以用于结构化数据序列化，很适合做数据存储或 RPC 数据交换格式。它可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。 可以简单理解为，是一种跨语言、跨平台的数据传输格式。与j
    
                            
    
                            
    
                                2024年02月04日
                                
    
                                    浏览(42)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                读数据压缩入门笔记10_通用压缩和序列化
                            
                        
    
                                                
    
                            
    
                                读数据压缩入门笔记10_通用压缩和序列化
                            
    
                            
    
                                
    1.2.3.1. 如果今天多云，那么明后两天会下雨的概率是多少？ 1.2.5.1. 要使马尔可夫链算法变得实用，就必须要解决内存消耗问题与计算性能问题，即使用最佳链来编码 1.4.3.1. 在PPMZ算法中，对于符号如何去响应匹配，人们尝试了多种类型的上下文 1.4.6.1. 缺点是在进行数据压
    
                            
    
                            
    
                                2024年02月16日
                                
    
                                    浏览(39)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                JS中JSON序列化JSON.stringify的坑点和处理
                            
                        
    
                                                
    
                            
    
                                JS中JSON序列化JSON.stringify的坑点和处理
                            
    
                            
    
                                
    JSON.stringify的问题 在js中提到对象转JSON字符串，基本都会想到JSON.stringify这个方法，以及对应的解析方法JSON.parse方法，这个的转换也被不少人用于深拷贝的操作中。 但是随着这一对方法的使用，我们会发现它们存在的弊端，比如会丢失函数和undefined类型的内容，如下： 这里
    
                            
    
                            
    
                                2024年02月06日
                                
    
                                    浏览(89)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
    
                                后端项目开发：工具类封装（序列化、反射）
                            
    
                            
    
                                
    根据《阿里巴巴开发规范》，包名使用单数，类名可以使用复数。 所以generic-common创建util包和utils工具类 很多时候我们需要将接收到的json数据转换为对象，或者将对象转为json存储。这时候我们需要编写用于json转换的工具类。 新建util目录，再创建JacksonUtils类
    
                            
    
                            
    
                                2024年02月11日
                                
    
                                    浏览(37)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                Web开发模式、API接口、restful规范、序列化和反序列化、drf安装和快速使用、路由转换器(复习)
                            
                        
    
                                                
    
                            
    
                                Web开发模式、API接口、restful规范、序列化和反序列化、drf安装和快速使用、路由转换器(复习)
                            
    
                            
    
                                
    一 Web开发模式 1. 前后端混合开发模式 2.前后端分离开发模式 二 API接口 三 restful规范 四 序列化和反序列化 五 drf安装和快速使用
    
                            
    
                            
    
                                2024年02月10日
                                
    
                                    浏览(43)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
    
                                python序列化和结构化数据详解
                            
    
                            
    
                                
    序列化和结构化数据是计算机程序中非常重要的概念，它们的原理和应用在许多应用程序中都是必不可少的。Python作为一种高级编程语言，在序列化和结构化数据方面提供了很多优秀的解决方案。在本文中，我们将详细介绍Python中序列化和结构化数据的相关概念和应用。 1.
    
                            
    
                            
    
                                2024年02月08日
                                
    
                                    浏览(61)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
    
                                Python中关于对象序列化实现和原理
                            
    
                            
    
                                
    pickle模块可以实现任意的Python对象转换为一系列字节(即序列化对象)的算法。这些字节流可以被传输或存储，接着也可以重构为—个和原先对象具有相同特征的新对象。 注意： pickle的文档清晰的表明它不提供安全保证。实际上，反序列化后可以执行任意代码，所以慎用 pick
    
                            
    
                            
    
                                2024年02月03日
                                
    
                                    浏览(42)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                Hadoop3.0大数据处理学习3（MapReduce原理分析、日志归集、序列化机制、Yarn资源调度器）
                            
                        
    
                                                
    
                            
    
                                Hadoop3.0大数据处理学习3（MapReduce原理分析、日志归集、序列化机制、Yarn资源调度器）
                            
    
                            
    
                                
    前言：如果想知道一堆牌中有多少张红桃，直接的方式是一张张的检查，并数出有多少张红桃。 而MapReduce的方法是，给所有的节点分配这堆牌，让每个节点计算自己手中有几张是红桃，然后将这个数汇总，得到结果。 官方介绍：MapReduce是一种分布式计算模型，由Google提出，
    
                            
    
                            
    
                                2024年02月08日
                                
    
                                    浏览(54)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                深入理解 python 虚拟机：破解核心魔法——反序列化 pyc 文件
                            
                        
    
                                                
    
                            
    
                                深入理解 python 虚拟机：破解核心魔法——反序列化 pyc 文件
                            
    
                            
    
                                
    在前面的文章当中我们详细的对于 pyc 文件的结构进行了分析，pyc 文件主要有下面的四个部分组成：魔术、 Bite Filed 、修改日期和 Code Object 组成。在前面的文章当中我们已经对前面三个部分进行了字节角度的分析，直接从 pyc 文件当中读取对应的数据并且打印出来了。而在本
    
                            
    
                            
    
                                2024年02月05日
                                
    
                                    浏览(39)
                                 
    
                            
    
                        
    
                    
    • 			    

			

        

                
    

    



    
觉得文章有用就打赏一下文章作者



    
支付宝扫一扫打赏

    
博客赞助





    
微信扫一扫打赏

    
请作者喝杯咖啡吧~博客赞助











    
支付宝扫一扫领取红包，优惠每天领

	

	    
二维码1

	    
领取红包

	

	

	    
二维码2

	    
领红包