python基础篇(十九)——Python中的一些易混淆点总结(下)

本是古典何须时尚 2022-08-31 11:19 125阅读 0赞

## 前言 ##

首先跟大家说声抱歉，由于刚入职，最近特别的忙，因此，上周实在没来得及更新，今天开始恢复更新，以后尽可能的继续保持在一周更新两篇文章。  
  [上篇文章][Link 1]我们给大家介绍了Python中的装饰器、在用到`return`和`global`易错的点，最后又介绍了对象的变动以及具体的应用场景。就今天我们继续为大家介绍Python中易错的点。

## 一、`__slots__`魔法 ##

在Python中，每个类都有实例属性。默认情况下Python用一个字典来保存一个对象的实例属性。这非常有用，因为它允许我们在运行时去设置任意的新属性。然而，对于有着已知属性的小类来说，它可能是个瓶颈。这个字典浪费了很多内存。Python不能在对象创建时直接分配一个固定量的内存来保存所有的属性。因此如果你创建许多对象（我指的是成千上万个），它会消耗掉很多内存。不过还是有一个方法来规避这个问题。这个方法需要使用\_\_slots\_\_来告诉Python不要使用字典，而且只给一个固定集合的属性分配空间。首先看一个使用与不使用`__slots__`的例子：

class MyClass(object):
        def __init__(self, name, identifier):
            self.name = name
            self.identifier = identifier
            self.set_up()

使用 `__slots__`:

class MyClass(object):
        __slots__ = ['name', 'identifier']
        def __init__(self, name, identifier):
            self.name = name
            self.identifier = identifier
            self.set_up()

第二段代码会为你的内存减轻负担。

## 二、虚拟环境(virtualenv) ##

Virtualenv 是一个工具，它能够帮我们创建一个独立(隔离)的Python环境。使用virtualenv！针对每个程序创建独立（隔离）的Python环境，而不是在全局安装所依赖的模块。使用virtualenv！针对每个程序创建独立（隔离）的Python环境，而不是在全局安装所依赖的模块。要安装它，只需要在命令行中输入以下命令：

pip install virtualenv

最重要的命令是：

virtualenv myproject
    source bin/activate

执行第一个命令在myproject文件夹创建一个隔离的virtualenv环境，第二个命令激活这个隔离的环境(virtualenv)。在创建virtualenv时，你必须做出决定：这个virtualenv是使用系统全局的模块呢？还是只使用这个virtualenv内的模块。 默认情况下，virtualenv不会使用系统全局模块。如果你想让你的virtualenv使用系统全局模块，请使用–system-site-packages参数创建你的virtualenv，例如：

virtualenv --system-site-packages mycoolproject

使用以下命令可以退出这个virtualenv:

deactivate

运行之后将恢复使用你系统全局的Python模块。

## 三、容器(Collections) ##

Python附带一个模块，它包含许多容器数据类型，名字叫作collections。我们将讨论它的作用和用法。我们将讨论的是：defaultdict、counter、deque、namedtuple、enum.Enum (包含在Python 3.4以上)。

### 1、defaultdict ###

我个人使用`defaultdict`较多，与`dict`类型不同，你不需要检查`key`是否存在，所以我们能这样做：

from collections import defaultdict
    colours = (
        ('Yasoob', 'Yellow'),
        ('Ali', 'Blue'),
        ('Arham', 'Green'),
        ('Ali', 'Black'),
        ('Yasoob', 'Red'),
        ('Ahmed', 'Silver'),
    )
    favourite_colours = defaultdict(list)
    for name, colour in colours:
        favourite_colours[name].append(colour)
    print(favourite_colours)

具体执行结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center][]  
  另一种重要的是例子就是：当你在一个字典中对一个键进行嵌套赋值时，如果这个键不存在，会触发keyError异常。 defaultdict允许我们用一个聪明的方式绕过这个问题。首先我分享一个使用dict触发KeyError的例子，然后提供一个使用defaultdict的解决方案。

some_dict = {
        }
    some_dict['colours']['favourite'] = "yellow"

会输出 **异常输出：KeyError: 'colours’**，具体解决方案如下：

import collections
    tree = lambda: collections.defaultdict(tree)
    some_dict = tree()
    some_dict['colours']['favourite'] = "yellow"
    import json
    print(json.dumps(some_dict))

具体执行结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 1][]

### 2、counter ###

Counter是一个计数器，它可以帮助我们针对某项数据进行计数。比如它可以用来计算每个人喜欢多少种颜色：

from collections import Counter
    colours = (
        ('Yasoob', 'Yellow'),
        ('Ali', 'Blue'),
        ('Arham', 'Green'),
        ('Ali', 'Black'),
        ('Yasoob', 'Red'),
        ('Ahmed', 'Silver'),
    )
    favs = Counter(name for name, colour in colours)
    print(favs)

具体执行结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 2][]

### 3、deque ###

deque提供了一个双端队列，你可以从头/尾两端添加或删除元素。要想使用它，首先我们要从collections中导入deque模块：

from collections import deque
    # 现在，你可以创建一个deque对象。
    d = deque()
    # 它的用法就像python的list，并且提供了类似的方法，例如：
    d = deque()
    d.append('1')
    d.append('2')
    d.append('3')
    print(len(d))
    print(d[0])
    print(d[-1])
    # 你可以从两端取出(pop)数据：
    d = deque(range(5))
    print(len(d))
    d.popleft()
    d.pop()
    print(d)
    d = deque(maxlen=30)
    d = deque([1,2,3,4,5])
    d.extendleft([0])
    d.extend([6,7,8])
    print(d)

具体执行结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 3][]

### 4、namedtuple ###

一个元组是一个不可变的列表，你可以存储一个数据的序列，它和命名元组(namedtuples)非常像，但有几个关键的不同。主要相似点是都不像列表，你不能修改元组中的数据。为了获取元组中的数据，你需要使用整数作为索引：

man = ('Ali', 30)
    print(man[0])

具体执行结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 4][]  
  嗯，那namedtuples是什么呢？它把元组变成一个针对简单任务的容器。你不必使用整数索引来访问一个namedtuples的数据。你可以像字典(dict)一样访问namedtuples，但namedtuples是不可变的。

from collections import namedtuple
    Animal = namedtuple('Animal', 'name age type')
    perry = Animal(name="perry", age=31, type="cat")
    print(perry)
    print(perry.name)

具体执行结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 5][]  
  现在你可以看到，我们可以用名字来访问namedtuple中的数据。我们再继续分析它。一个命名元组(namedtuple)有两个必需的参数。它们是元组名称和字段名称。在上面的例子中，我们的元组名称是Animal，字段名称是’name’，‘age’和’type’。namedtuple让你的元组变得自文档了。你只要看一眼就很容易理解代码是做什么的。你也不必使用整数索引来访问一个命名元组，这让你的代码更易于维护。而且，namedtuple的每个实例没有对象字典，所以它们很轻量，与普通的元组比，并不需要更多的内存。这使得它们比字典更快。然而，要记住它是一个元组，属性值在namedtuple中是不可变的，所以下面的代码不能工作：

from collections import namedtuple
    Animal = namedtuple('Animal', 'name age type')
    perry = Animal(name="perry", age=31, type="cat")
    perry.age = 42

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 6][]

你应该使用命名元组来让代码自文档，它们向后兼容于普通的元组，这意味着你可以既使用整数索引，也可以使用名称来访问namedtuple：

from collections import namedtuple
    Animal = namedtuple('Animal', 'name age type')
    perry = Animal(name="perry", age=31, type="cat")
    print(perry[0])

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 7][]  
  最后，你可以将一个命名元组转换为字典，方法如下：

from collections import namedtuple
    Animal = namedtuple('Animal', 'name age type')
    perry = Animal(name="Perry", age=31, type="cat")
    print(perry._asdict())

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 8][]

### 5、enum.Enum ###

枚举(enumerate)是Python内置函数。它的用处很难在简单的一行中说明，但是大多数的新人，甚至一些高级程序员都没有意识到它。它允许我们遍历数据并自动计数，下面是一个例子：

my_list = ['apple', 'banana', 'grapes', 'pear']
    for c, value in enumerate(my_list, 1):
        print(c, value)

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 9][]  
  上面这个可选参数允许我们定制从哪个数字开始枚举。你还可以用来创建包含索引的元组列表， 例如：

my_list = ['apple', 'banana', 'grapes', 'pear']
    counter_list = list(enumerate(my_list, 1))
    print(counter_list)

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 10][]

## 四、对象自省 ##

自省(introspection)，在计算机编程领域里，是指在运行时来判断一个对象的类型的能力。它是Python的强项之一。Python中所有一切都是一个对象，而且我们可以仔细勘察那些对象。Python还包含了许多内置函数和模块来帮助我们。

### 1、dir ###

在这个小节里我们会学习到dir以及它在自省方面如何给我们提供便利。它是用于自省的最重要的函数之一。它返回一个列表，列出了一个对象所拥有的属性和方法。这里是一个例子：

my_list = [1, 2, 3]
    print(dir(my_list))

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 11][]  
  上面的自省给了我们一个列表对象的所有方法的名字。当你没法回忆起一个方法的名字，这会非常有帮助。如果我们运行dir()而不传入参数，那么它会返回当前作用域的所有名字。

### 2、type和id ###

type函数返回一个对象的类型。举个例子：

print(type(''))
    print(type([]))
    print(type({
        }))
    print(type(dict))
    print(type(3))

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 12][]  
  id()函数返回任意不同种类对象的唯一ID，举个例子：

name = "Yasoob"
    print(id(name))

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 13][]

### 3、inspect模块 ###

inspect模块也提供了许多有用的函数，来获取活跃对象的信息。比方说，你可以查看一个对象的成员，只需运行：

import inspect
    print(inspect.getmembers(str))

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 14][]

## 五、各种推导式(comprehensions) ##

推导式（又称解析式）是Python的一种独有特性，如果我被迫离开了它，我会非常想念。推导式是可以从一个数据序列构建另一个新的数据序列的结构体。 共有三种推导，在Python2和3中都有支持：列表(list)推导式、字典(dict)推导式、集合(set)推导式。我们将一一进行讨论。一旦你知道了使用列表推导式的诀窍，你就能轻易使用任意一种推导式了。

### 1、列表推导式（list comprehensions） ###

列表推导式（又称列表解析式）提供了一种简明扼要的方法来创建列表。它的结构是在一个中括号里包含一个表达式，然后是一个for语句，然后是0个或多个for或者if语句。那个表达式可以是任意的，意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表，在这个以if和for语句为上下文的表达式运行完成之后产生。

variable = [out_exp for out_exp in input_list if out_exp == 2]

这里是另外一个简明例子:

multiples = [i for i in range(30) if i % 3 is 0] 
    print(multiples)

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 15][]  
  这将对快速生成列表非常有用。有些人甚至更喜欢使用它而不是filter函数。列表推导式在有些情况下超赞，特别是当你需要使用for循环来生成一个新列表。举个例子，你通常会这样做：

squared = []
    
    for x in range(10):
    	squared.append(x**2)

你可以使用列表推导式来简化它，就像这样：

squared = [x**2 for x in range(10)]

### 2、字典推导式（dict comprehensions） ###

字典推导和列表推导的使用方法是类似的。这里有个我最近发现的例子：

mcase = {
        'a': 10, 'b': 34, 'A': 7, 'Z': 3}
    mcase_frequency = {
        
        k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)
        for k in mcase.keys()
        }
    mcase_frequency == {
        'a': 17, 'z': 3, 'b': 34}

在上面的例子中我们把同一个字母但不同大小写的值合并起来了。就我个人来说没有大量使用字典推导式。你还可以快速对换一个字典的键和值：

{
        v: k for k, v in some_dict.items()}

### 3、集合推导式（set comprehensions） ###

它们跟列表推导式也是类似的。 唯一的区别在于它们使用大括号\{\}。 举个例子：

squared = {
        x**2 for x in [1, 1, 2]} 
    print(squared)

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 16][]

## 六、异常 ##

异常处理是一种艺术，一旦你掌握，会授予你无穷的力量。我将要向你展示我们能处理异常的一些方式。最基本的术语里我们知道了try/except从句。可能触发异常产生的代码会放到try语句块里，而处理异常的代码会在except语句块里实现。这是一个简单的例子：

try:
        file = open('test.txt', 'rb')
    except IOError as e:
        print('An IOError occurred. {}'.format(e.args[-1]))

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 17][]  
  上面的例子里，我们仅仅在处理一个IOError的异常。大部分初学者还不知道的是，我们可以处理多个异常。

### 1、处理多个异常 ###

我们可以使用三种方法来处理多个异常。第一种方法需要把所有可能发生的异常放到一个元组里。像这样：

try:
        file = open('test.txt', 'rb')
    except (IOError, EOFError) as e:
        print("An error occurred. {}".format(e.args[-1]))

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 18][]  
  另外一种方式是对每个单独的异常在单独的except语句块中处理。我们想要多少个except语句块都可以。这里是个例子：

try:
        file = open('test.txt', 'rb')
    except EOFError as e:
        print("An EOF error occurred.")
        raise e
    except IOError as e:
        print("An error occurred.")
        raise e

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 19][]  
  上面这个方式中，如果异常没有被第一个except语句块处理，那么它也许被下一个语句块处理，或者根本不会被处理。

### 2、finally从句 ###

我们把我们的主程序代码包裹进了try从句。然后我们把一些代码包裹进一个except从句，它会在try从句中的代码触发异常时执行。在下面的例子中，我们还会使用第三个从句，那就是finally从句。包裹到finally从句中的代码不管异常是否触发都将会被执行。这可以被用来在脚本执行之后做清理工作。这里是个简单的例子：

try:
        file = open('test.txt', 'rb')
    except IOError as e:
        print('An IOError occurred. {}'.format(e.args[-1]))
    finally:
        print("This would be printed whether or not an exception occur")

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 20][]

### 3、try/else从句 ###

我们常常想在没有触发异常的时候执行一些代码。这可以很轻松地通过一个else从句来达到。有人也许问了：如果你只是想让一些代码在没有触发异常的情况下执行，为啥你不直接把代码放在try里面呢？回答是，那样的话这段代码中的任意异常都还是会被try捕获，而你并不一定想要那样。大多数人并不使用else从句，而且坦率地讲我自己也没有大范围使用。这里是个例子：

try:
        print('I am sure no exception is going to occur!')
    except Exception:
        print('exception')
    else:
            print('This would only run if no exception occurs. And an erro would NOT be caught.')
    finally:
        print('This would be printed in every case.')

具体实现结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 21][]  
  else从句只会在没有异常的情况下执行，而且它会在finally语句之前执行。

## 总结 ##

[上篇文章][Link 1]我们给大家介绍了Python中的装饰器、在用到`return`和`global`易错的点，最后又介绍了对象的变动以及具体的应用场景。本文给大家介绍了`__slots__`、虚拟化环境、容器、对象自省、各种推导式以及Python中常见的异常。Python是一门注重实际操作的语言，它是众多编程语言中最简单，也是最好入门的。当你把这门语言学会了，再去学习java、go以及C语言就比较简单了。当然，Python也是一门热门语言，对于人工智能的实现有着很大的帮助，因此，值得大家花时间去学习。生命不息，奋斗不止，我们每天努力，好好学习，不断提高自己的能力，相信自己一定会学有所获。加油！！！  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 22][]

[Link 1]: https://blog.csdn.net/Oliverfly1/article/details/118650388
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/37ee1a228a2844ba8026b42a08c999cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/848886c188af431fbb9214f9db9ae9c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/0ecc8426adf0431c8cb2ac604f9737ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220829/a16685c4b6c0473bbcdb25b772ccbcdd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220829/5bac6d55787b428da8e908996dbf3e31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20220829/c154ffab80af48babf0b8fe57e3619fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20220829/18bb2caa32f7472188aa4a1a3279a673.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20220829/4bce4d3dcaa145c6928a936adae81cd9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20220829/d12e390bd7564ebaadb06e789e0296ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20220829/0e13ec4c5043490c89c2ea6be6be656f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20220829/29471eb50cf14576a0e122a61eac289d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20220829/c4b5cdc57bc2497d9b7e0388c07230dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20220829/18777248140e412994927ce2f29d2e30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20220829/dda1d457a2fb404899c3b84fd81c3499.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20220829/0625126d53c54db0b4125de0eb63dc64.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20220829/2b754cb97f7849559a40d0cbcef9de29.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20220829/f0cb0e4590eb4123badec597a9ec9dde.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20220829/8abe72f9472d4e55b5e5b20b09b6e6cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20220829/6c48d4358d7b4d578bd97512bce9078d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20220829/84b6011628e64dbebb735c04ff5133ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20220829/f982a92a41c0448e8b906df81f931bfb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 21]: /images/20220829/a28ac529addc4746865a63d2fc357faf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09saXZlcmZseTE_size_16_color_FFFFFF_t_70_pic_center 22]: /images/20220829/314c39b9cd60450d9685610a00cdac91.png