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

不念不忘少年蓝@ 2024-03-23 22:40 182阅读 0赞

迭代器

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

1. 可迭代对象

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

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

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

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

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

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

  1. In [50]: from collections import Iterable
  3. In [51]: isinstance([], Iterable)
  5. Out[51]: True
  7. In [52]: isinstance({}, Iterable)
  9. Out[52]: True
  11. In [53]: isinstance('abc', Iterable)
  13. Out[53]: True
  15. In [54]: isinstance(mylist, Iterable)
  17. Out[54]: False
  19. In [55]: isinstance(100, Iterable)
  21. Out[55]: False

3. 可迭代对象的本质

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

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

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

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

  1. from collections.abc import Iterableclass Demo(object):
  3.     def __init__(self, n):
  5.         self.n = n
  7.         self.current = 0
  9.     def __iter__(self):
  11.         pass
  13. demo = Demo(10)
  15. print(isinstance(demo, Iterable))  # True
  17. for d in demo:   # 重写了 __iter__ 方法以后，demo就是一个一个可迭代对象了，可以放在for...in的后面
  19.     print(d)
  21. # 此时再使用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方法的对象，就是迭代器。

  1. class MyIterator(object):
  3.     def __init__(self, n):
  5.         self.n = n
  7.         self.current = 0
  9.     # 自定义迭代器需要重写__iter__和__next__方法
  11.     def __iter__(self):
  13.         return self
  15.     def __next__(self):
  17.         if self.current < self.n:
  19.             value = self.current
  21.             self.current += 1
  23.             return value
  25.         else:
  27.             raise StopIteration
  29. my_it = MyIterator(10)
  31. for i in my_it:    # 迭代器重写了__iter__方法，它本身也是一个可迭代对象
  33.     print(i)

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

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

  1. names = ['hello', 'good', 'yes']
  3. print(names.__iter__())  # 调用对象的__iter__()方法
  5. print(iter(names))  # 调用iter()内置函数

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

  1. from collections.abc import Iterator
  3. names = ['hello', 'good', 'yes']
  5. 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个数。那么这个斐波那契数列我们就可以用迭代器来实现，每次迭代都通过数学计算来生成下一个数。

  1. class FibIterator(object):
  3.     """斐波那契数列迭代器"""
  5.     def __init__(self, n):
  7.         """
  9.         :param n: int, 指明生成数列的前n个数
  11.         """
  13.         self.n = n
  15.         # current用来保存当前生成到数列中的第几个数了
  17.         self.current = 0
  19.         # num1用来保存前前一个数，初始值为数列中的第一个数0
  21.         self.num1 = 0
  23.         # num2用来保存前一个数，初始值为数列中的第二个数1
  25.         self.num2 = 1
  27.     def __next__(self):
  29.         """被next()函数调用来获取下一个数"""
  31.         if self.current < self.n:
  33.             num = self.num1
  35.             self.num1, self.num2 = self.num2, self.num1+self.num2
  37.             self.current += 1
  39.             return num
  41.         else:
  43.             raise StopIteration
  45.     def __iter__(self):
  47.         """迭代器的__iter__返回自身即可"""
  49.         return self
  51. if __name__ == '__main__':
  53.     fib = FibIterator(10)
  55.     for num in fib:
  57.         print(num, end=" ")

生成器

1. 生成器

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

2. 创建生成器方法1

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

  1. In [15]: L = [ x*2 for x in range(5)]
  3. In [16]: L
  5. Out[16]: [0, 2, 4, 6, 8]
  7. In [17]: G = ( x*2 for x in range(5))
  9. In [18]: G
  11. Out[18]: <generator object <genexpr> at 0x7f626c132db0>
  13. In [19]:

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

  1. In [19]: next(G)
  3. Out[19]: 0
  5. In [20]: next(G)
  7. Out[20]: 2
  9. In [21]: next(G)
  11. Out[21]: 4
  13. In [22]: next(G)
  15. Out[22]: 6
  17. In [23]: next(G)
  19. Out[23]: 8
  21. In [24]: next(G)
  23. ---------------------------------------------------------------------------
  25. StopIteration                             Traceback (most recent call last)
  27. <ipython-input-24-380e167d6934> in <module>()
  29. ----> 1 next(G)
  31. StopIteration:
  33. In [25]:
  35. In [26]: G = ( x*2 for x in range(5))
  37. In [27]: for x in G:
  39.    ....:     print(x)
  41.    ....:    
  43. 0
  45. 2
  47. 4
  49. 6
  51. 8
  53. In [28]:

3. 创建生成器方法2

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

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

  1. class FibIterator(object):
  3.     """斐波那契数列迭代器"""
  5.     def __init__(self, n):
  7.         """
  9.         :param n: int, 指明生成数列的前n个数
  11.         """
  13.         self.n = n
  15.         # current用来保存当前生成到数列中的第几个数了
  17.         self.current = 0
  19.         # num1用来保存前前一个数，初始值为数列中的第一个数0
  21.         self.num1 = 0
  23.         # num2用来保存前一个数，初始值为数列中的第二个数1
  25.         self.num2 = 1
  27.     def __next__(self):
  29.         """被next()函数调用来获取下一个数"""
  31.         if self.current < self.n:
  33.             num = self.num1
  35.             self.num1, self.num2 = self.num2, self.num1+self.num2
  37.             self.current += 1
  39.             return num
  41.         else:
  43.             raise StopIteration
  45.     def __iter__(self):
  47.         """迭代器的__iter__返回自身即可"""
  49.         return self

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

  1. In [30]: def fib(n):
  3.    ....:     current = 0
  5.    ....:     num1, num2 = 0, 1
  7.    ....:     while current < n:
  9.    ....:         yield num1
  11.    ....:         num1, num2 = num2, num1+num2
  13.    ....:         current += 1
  15.    ....:     return 'done'
  17.    ....:
  19. In [31]: F = fib(5)
  21. In [32]: next(F)
  23. Out[32]: 1
  25. In [33]: next(F)
  27. Out[33]: 1
  29. In [34]: next(F)
  31. Out[34]: 2
  33. In [35]: next(F)
  35. Out[35]: 3
  37. In [36]: next(F)
  39. Out[36]: 5
  41. In [37]: next(F)
  43. ---------------------------------------------------------------------------
  45. StopIteration                             Traceback (most recent call last)
  47. <ipython-input-37-8c2b02b4361a> in <module>()
  49. ----> 1 next(F)
  51. StopIteration: done

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

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

  1. In [38]: for n in fib(5):
  3.    ....:     print(n)
  5.    ....:     11235
  7. In [39]:

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

  1. In [39]: g = fib(5)
  3. In [40]: while True:
  5.    ....:     try:
  7.    ....:         x = next(g)
  9.    ....:         print("value:%d"%x)     
  11.    ....:     except StopIteration as e:
  13.    ....:         print("生成器返回值:%s"%e.value)
  15.    ....:         break
  17.    ....:    
  19. value:1
  21. value:1
  23. value:2
  25. value:3
  27. value:5
  29. 生成器返回值:done
  31. 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)

  1. In [10]: def gen():
  3.    ....:     i = 0
  5.    ....:     while i<5:
  7.    ....:         temp = yield i
  9.    ....:         print(temp)
  11.    ....:         i+=1
  13.    ....:
使用send
  1. In [43]: f = gen()
  3. In [44]: next(f)
  5. Out[44]: 0
  7. In [45]: f.send('haha')
  9. haha
  11. Out[45]: 1
  13. In [46]: next(f)None
  15. Out[46]: 2
  17. In [47]: f.send('haha')
  19. haha
  21. Out[47]: 3
  23. In [48]:
使用next函数
  1. In [11]: f = gen()
  3. In [12]: next(f)
  5. Out[12]: 0
  7. In [13]: next(f)
  9. None
  11. Out[13]: 1
  13. In [14]: next(f)
  15. None
  17. Out[14]: 2
  19. In [15]: next(f)
  21. None
  23. Out[15]: 3
  25. In [16]: next(f)
  27. None
  29. Out[16]: 4
  31. In [17]: next(f)
  33. None
  35. ---------------------------------------------------------------------------
  37. StopIteration                             Traceback (most recent call last)
  39. <ipython-input-17-468f0afdf1b9> in <module>()
  41. ----> 1 next(f)
  43. StopIteration:
使用__next__()方法（不常使用）
  1. In [18]: f = gen()
  3. In [19]: f.__next__()
  5. Out[19]: 0
  7. In [20]: f.__next__()
  9. None
  11. Out[20]: 1
  13. In [21]: f.__next__()
  15. None
  17. Out[21]: 2
  19. In [22]: f.__next__()
  21. None
  23. Out[22]: 3
  25. In [23]: f.__next__()
  27. None
  29. Out[23]: 4
  31. In [24]: f.__next__()
  33. None
  35. ---------------------------------------------------------------------------
  37. StopIteration                             Traceback (most recent call last)
  39. <ipython-input-24-39ec527346a9> in <module>()
  41. ----> 1 f.__next__()
  43. StopIteration:

property属性

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

  1. class Foo:
  3.     def func(self):
  5.         pass
  7.     # 定义property属性    @property
  9.     def prop(self):
  11.         pass
  13. # ############### 调用 ###############
  15. foo_obj = Foo()
  17. foo_obj.func()  # 调用实例方法
  19. foo_obj.prop  # 调用property属性
property属性的定义和调用要注意一下几点：

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

调用时，无需括号

  • 方法：foo_obj.func()

    property属性：foo_obj.prop

简单的实例

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

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

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

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

    1. def __init__(self, current_page):
    3.     # 用户当前请求的页码（第一页、第二页...）
    5.     self.current_page = current_page
    7.     # 每页默认显示10条数据
    9.     self.per_items = 10
    11. @property
    13. def start(self):
    15.     val = (self.current_page - 1) * self.per_items
    17.     return val
    19. @property
    21. def end(self):
    23.     val = self.current_page * self.per_items
    25.     return val

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

    p = Pager(1)

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

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

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

property属性的两种方式

  • 装饰器 即：在方法上应用装饰器
  • 类属性 即：在类中定义值为property对象的类属性

装饰器方式

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

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

经典类的实现：

  • class Goods: @property

    1. def price(self):
    3.     return "laowang"

    obj = Goods()

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

    print(result)

新式类的实现：

  • class Goods:

    1. """
    3. 只有在python3中才有@xxx.setter  @xxx.deleter
    5. """
    7. def __init__(self):
    9.     # 原价
    11.     self.original_price = 100
    13.     # 折扣
    15.     self.discount = 0.8
    17. @property
    19. def price(self):
    21.     new_price = self.original_price * self.discount
    23.     return new_price
    25. @price.setter
    27. def price(self, value):
    29.     self.original_price = value
    31. @price.deleter
    33. def price(self):
    35.     del self.original_price

    obj = Goods()

    obj.price # 获取商品价格

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

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

类属性方式

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

  • class Foo:

    1. def get_bar(self):
    3.     return 'laowang'
    5. BAR = property(get_bar)

    obj = Foo()

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

    print(reuslt)

property方法中有个四个参数

    • 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
    • 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
    • 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
    • 第四个参数是字符串，调用 对象.属性.doc ，此参数是该属性的描述信息

    class Foo(object):

    def get_bar(self):

    1.    print("getter...")
    3.    return 'laowang'

    def set_bar(self, value):

    1.    """必须两个参数"""
    3.    print("setter...")
    5.    return 'set value' + value

    def del_bar(self):

    1.    print("deleter...")
    3.    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属性，能够简化调用者在获取数据的流程。

发表评论

表情：
评论列表 （有 0 条评论，182人围观）

还没有评论，来说两句吧...

相关阅读

    相关 序列化和反序列化

      互联网的产生带来了机器间通讯的需求，而互联通讯的双方需要采用约定的协议，序列化和反序列化属于通讯协议的一部分。通讯协议往往采用分层模型，不同模型每层的功能定义以及颗粒度不同

    古城微笑少年丶古城微笑少年丶/ 0 赞/ 433 阅读

    相关 序列化和反序列化

    序列化和反序列化 　　摘要 　　序列化和反序列化几乎是工程师们每天都要面对的事情，但是要精确掌握这两个概念并不容易：一方面，它们往往作为框架的一部分出现而湮没

    淡淡的烟草味﹌淡淡的烟草味﹌/ 0 赞/ 501 阅读

    相关 序列化和反序列化

    个人学习理解 (只是自己默写序列化和反序列的代码以及几个问题) 1.序列化 和 反序列化 1.1 什么是序列化 和 反序列化 或者 你如何理解序列化和

    墨蓝墨蓝/ 0 赞/ 535 阅读

    相关 序列化和反序列化

    序列化：指把堆内存中的 Java 对象数据，通过某种方式把对象存储到磁盘文件中或者传递给其他网络节点（在网络上传输）。这个过程称为序列化。通俗来说就是将数据结构或对象转换成二进

    ￡神魔★判官ぃ￡神魔★判官ぃ/ 0 赞/ 903 阅读