Python基础总结之常用内置方法总结

曾经终败给现在 2022-02-02 11:47 281阅读 0赞

### 文章目录 ###

*  前言
 *  1、str
 *   *  1.1、内置方法：
     *  1.2、常用的内置方法
     *  1.3、String模块的一些方法
 *  2、list
 *   *  2.1、内置方法
     *  2.2、常用内置方法
 *  3、tupple
 *   *  3.1、内置方法
     *  3.2、常用内置方法
 *  4、dict
 *   *  4.1、内置方法
     *  4.2、常用内置方法
 *  5、其他
 *   *  5.1、几个sort的使用
     *  5.2、enumerate（）：根据可迭代对象创建枚举对象
     *  5.3、filter
     *  5.4、map() 会根据提供的函数对指定序列做映射。
     *  5.5、reduce()
     *  5.6、dir()
     *  5.7、eval()
     *  5.8、file()
     *  5.9、isinstance()
     *  5.10、round()
     *  5.11、set()
     *  5.12、zip()
     *  5.13、Format()

# 前言 #

由于一些原因，好久没更博客了，接下来会陆续总结出一些包含各方面的基础知识的文章（如数据库、Python、数据挖掘等），算是作为以后的“考前”（面试）回顾的资料吧。首先就写下关于Python基础的一些总结吧。

# 1、str #

## 1.1、内置方法： ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70]  
\[‘capitalize’,‘casefold’,‘center’,‘**count**’,‘ncode’,‘endswith’,‘expandtabs’,‘**find**’,‘**format**’,‘format\_map’,‘**index**’,‘isalnum’,‘isalpha’,‘isdecimal’,‘**isdigit**’‘isidentifier’,‘**islower**’,‘isnumeric’,‘isprintable’,‘isspace’,‘istitle’,‘**isupper**’,‘**join**’,‘ljust’,‘**lower**’,‘lstrip’,‘**maketrans**’,‘partition’,‘**replace**’,‘rfind’,‘rindex’,‘rjust’,‘rpartition’,‘rsplit’,‘rstrip’,‘**split**’,‘splitlines’,‘startswith’,‘strip’,‘**swapcase**’,‘title’,‘**translate**’,‘**upper**’,‘zfill’\]

## 1.2、常用的内置方法 ##

> S.join(iterable)->str \#将iterable拼接成(转化为)字符串  
> ![在这里插入图片描述][20190511150714550.png]

“”.join(list)#将list转化为字符串

> S.replace(old,new\[,count\])->str \#替换字符串中元素，返回一个新字符串。  
> ![在这里插入图片描述][20190511153000184.png]

> S.split(sep,maxsplit)->list\#将字符串分割为list  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 1]

> S.strip(\[chars\])->str\#剔除字符串中的特定字符  
> ![在这里插入图片描述][20190511153037163.png]

> S.swapcase()->str\#转化字符串的大小写字母  
> ![在这里插入图片描述][20190511153141536.png]

> capitalize：Python capitalize()将字符串的第一个字母变成大写,其他字母变小写  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 2]  
> S.islower()/isupper() \#判断字符是否是全为大/小写  
> S.lower()/upper()\#将字符串转化为大写或小写  
> ![在这里插入图片描述][20190511150654569.png]

> maketrans()->:返回一张翻译表
> 
> \#定义翻译表，然后对相应的字符串一个字一个字的去映射。与replace的区别：replace不能对每个字符进行一一映射，而translate可以  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 3]  
> translate(table)->str\#传入table进行映射处理  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 4]

a="asdfsdafd123"
    g = str.maketrans("abc","123")
    print(a)
    asdfsdafd123
    print(a.translate(g))
    1sdfsd1fd123

> S.count(sub\[,start\[,end\]\])->int \#返回某个字符（串）出现的次数\`  
> ![在这里插入图片描述][20190511150001329.png]

> S.find(sub\[,star,end\]) -> int \#返回索引值  
> S.index()\#同find方法一样，区别：若没有该值的索引则抛出异常。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 5]

a="hello world"
    a.find("word")#找到返回初始的索引值
    a.find("wordl")#未找到返回-1

> S.format(\*args,\*\*kwargs)->str \#格式化输出字符串  
> ![在这里插入图片描述][20190511150358641.png]

"my name is {0} and age is {1}".format("xiaoli",25)
    "my name is {a}, i love {b}".format(a='pyer',b='apple')

> S.isdigit()->bool \#判断字符是否是数字  
> ![在这里插入图片描述][20190511150544349.png]

> str.strip(\[chars\])  
> 参数  
> chars – 移除字符串头尾指定的字符序列。  
> 返回值  
> **返回移除字符串头尾指定的字符生成的新字符串。**

## 1.3、String模块的一些方法 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 6]

# 2、list #

## 2.1、内置方法 ##

![在这里插入图片描述][20190511153604422.png]

## 2.2、常用内置方法 ##

\[‘append’,‘clear’,‘copy’,‘count’,‘extend’,‘index’,‘insert’,‘pop’,‘remove’,‘reverse’,‘sort’\]

> L.append()->None \#添加元素到list末尾  
> ![在这里插入图片描述][20190511153805814.png]

> L.insert(index,object)\#在对应的index添加元素![在这里插入图片描述][2019051115383833.png]

> L.clear()->None \#清空list所有元素![在这里插入图片描述][20190511153938104.png]

> L.pop(\[index\])-|>item\#剔除index的元素并返回  
> ![在这里插入图片描述][20190511154004608.png]

> L.remove(value)->None\#剔除list中的包含的第一项的value。![在这里插入图片描述][20190511154025588.png]![在这里插入图片描述][20190511154043923.png]

> L.extend(iterable)->None \#添加迭代器来扩展list![在这里插入图片描述][20190511153907538.png]

> L.reverse()\#反转list

> L.count(value)->int \#查找list中某value出现的次数  
> ![在这里插入图片描述][20190511154131983.png]

> L.sort(key)->None \#只需要传入对应的key即可,原理就是拿key中的每个元素执行sort方法  
> ![在这里插入图片描述][20190511154149988.png]

a.sort(key=lambda x :x[],reverse=True)

> L.copy()->list \#生成一个新的list，存储地址不同

# 3、tupple #

## 3.1、内置方法 ##

![在这里插入图片描述][20190511154338809.png]

## 3.2、常用内置方法 ##

> count()  
> index()

# 4、dict #

## 4.1、内置方法 ##

![在这里插入图片描述][201905111544207.png]

## 4.2、常用内置方法 ##

\[‘clear’, ‘copy’, ‘fromkeys’  
, ‘get’,  ‘items’, ‘keys’, ‘pop’, ‘popitem’, ‘setdefault’, ‘update’, ‘values’\]

> fromkeys(iterable,value=None)\#通过传入iterable生成新的dict。  
> ![在这里插入图片描述][20190511154733157.png]  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 7]

> D.get(k\[,d\])->D\[k\]\#传入k得到对应的value  
> ![在这里插入图片描述][20190511154818932.png]

> D.items()->set \#返回dict的子项item  
> ![在这里插入图片描述][2019051115484812.png]

> D.update()\#传入dict进行更新  
> ![在这里插入图片描述][20190511154913738.png]![在这里插入图片描述][20190511154928737.png]

# 5、其他 #

## 5.1、几个sort的使用 ##

> sorted \#传入对应的迭代器和key即可比较  
> ![在这里插入图片描述][20190511155044103.png]

> 字典如何去排序\#sorted(dict.items(),key=lambdax:x\[1\])\#dict.item()返回值为tuple,所以才能利用sored排序！  
> ![在这里插入图片描述][2019051115532780.png]

> a.sort(key=lambda x :x\[\],reverse=True)\#key最好用\#声明按字典中key或者value进行排序  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 8]

> 多级排序咋个办\#使用sort方法中operator  
> ![在这里插入图片描述][2019051115524720.png]

sorted() 函数对所有可迭代的对象进行排序操作。

**sort 与 sorted 区别：**  
1、sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。  
2、list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法  
sorted 语法：

sorted(iterable\[, cmp\[, key\[, reverse\]\]\])  
参数说明：

iterable – 可迭代对象。  
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。  
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。  
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。  
返回值  
返回重新排序的列表。

>>>a = [5,7,6,3,4,1,2]
    >>> b = sorted(a)       # 保留原列表
    >>> a 
    [5, 7, 6, 3, 4, 1, 2]
    >>> b
    [1, 2, 3, 4, 5, 6, 7]
     
    >>> L=[('b',2),('a',1),('c',3),('d',4)]
    >>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
    [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
    >>> sorted(L, key=lambda x:x[1])               # 利用key
    [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
     
     
    >>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
    >>> sorted(students, key=lambda s: s[2])            # 按年龄排序
    [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
     
    >>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
    [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
    >>>

## 5.2、enumerate（）：根据可迭代对象创建枚举对象 ##

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

语法  
以下是 enumerate() 方法的语法:

**enumerate(sequence, \[start=0\])**  
参数  
sequence – 一个序列、迭代器或其他支持迭代对象。  
start – 下标起始位置。  
返回值  
返回 enumerate(枚举) 对象。

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    >>> list(enumerate(seasons))
    [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    >>> list(enumerate(seasons, start=1))       # 下标从 1 开始
    [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
    >>>seq = ['one', 'two', 'three']
    >>> for i, element in enumerate(seq):
    ...     print i, element
    ... 
    0 one
    1 two
    2 three

## 5.3、filter ##

**filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。**  
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。  
语法  
以下是 filter() 方法的语法:

filter(function, iterable)  
参数  
function – 判断函数。  
iterable – 可迭代对象。  
返回值  
返回列表。

实例
    以下展示了使用 filter 函数的实例：
    过滤出列表中的所有奇数：
    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    def is_odd(n):
        return n % 2 == 1
     
    newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    print(newlist)
    输出结果 ：
    
    [1, 3, 5, 7, 9]

## 5.4、map() 会根据提供的函数对指定序列做映射。 ##

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

map() 函数语法：  
map(function, iterable, …)  
参数  
function – 函数  
iterable – 一个或多个序列  
返回值  
Python 2.x 返回列表。  
Python 3.x 返回迭代器

>>>def square(x) :            # 计算平方数
    ...     return x ** 2
    ... 
    >>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
    [1, 4, 9, 16, 25]
    >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
    [1, 4, 9, 16, 25]
     
    # 提供了两个列表，对相同位置的列表数据进行相加
    >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
    [3, 7, 11, 15, 19]

## 5.5、reduce() ##

**函数会对参数序列中元素进行累积。**  
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

语法  
reduce() 函数语法：

reduce(function, iterable\[, initializer\])  
参数  
function – 函数，有两个参数  
iterable – 可迭代对象  
initializer – 可选，初始参数  
返回值  
返回函数计算结果。

实例
    以下实例展示了 reduce() 的使用方法：
    >>>def add(x, y) :            # 两数相加
    ...     return x + y
    ... 
    >>> reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
    15
    >>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
    15

## 5.6、dir() ##

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法\_\_dir\_\_()，该方法将被调用。如果参数不包含\_\_dir\_\_()，该方法将最大限度地收集参数信息。  
dir 语法：

dir(\[object\])  
参数说明：

object – 对象、变量、类型。  
返回值  
返回模块的属性列表。

>>>dir()   #  获得当前模块的属性列表
    ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
    >>> dir([ ])    # 查看列表的方法
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

## 5.7、eval() ##

**用来执行一个字符串表达式，并返回表达式的值。**  
语法  
以下是 eval() 方法的语法:

eval(expression\[, globals\[, locals\]\])  
参数  
expression – 表达式。  
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。  
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。  
返回值  
返回表达式计算结果。

>>>x = 7
    >>> eval( '3 * x' )
    21
    >>> eval('pow(2,2)')
    4
    >>> eval('2 + 2')
    4
    >>> n=81
    >>> eval("n + 4")
    85

## 5.8、file() ##

**用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。**

语法  
以下是 file() 方法的语法:

file(name\[, mode\[, buffering\]\])  
参数  
name – 文件名  
mode – 打开模式  
**buffering – 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小。**  
返回值  
文件对象。

实例
    测试文件 test.txt，内容如下：
    
    RUNOOB1
    RUNOOB2
    >>>f = file('test.txt')
    >>> f.read()
    'RUNOOB1\nRUNOOB2\n'

## 5.9、isinstance() ##

来判断一个对象是否是一个已知的类型，类似 type()。

**isinstance() 与 type() 区别：**

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

**如果要判断两个类型是否相同推荐使用 isinstance()。**

语法  
以下是 isinstance() 方法的语法:

isinstance(object, classinfo)  
参数  
object – 实例对象。  
classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。  
返回值  
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。

实例
    >>>a = 2
    >>> isinstance (a,int)
    True
    >>> isinstance (a,str)
    False
    >>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
    True

## 5.10、round() ##

方法返回浮点数x的四舍五入值。

语法  
以下是 round() 方法的语法:

round( x \[, n\] )  
参数  
x – 数值表达式。  
n – 数值表达式。  
返回值  
返回浮点数x的四舍五入值。

round(80.23456, 2) :  80.23
    round(100.000056, 3) :  100.0
    round(-100.000056, 3) :  -100.0

## 5.11、set() ##

函数创建一个**无序不重复元素集**，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

语法  
set 语法：

class set(\[iterable\])  
参数说明：

iterable – 可迭代对象对象；  
返回值  
返回新的集合对象。

>>>x = set('runoob')
    >>> y = set('google')
    >>> x, y
    (set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除

## 5.12、zip() ##

函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

**如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同**，利用 \* 号操作符，可以将元组解压为列表。

zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

如果需要了解 Pyhton3 的应用，可以参考 Python3 zip()。

语法  
zip 语法：

zip(\[iterable, …\])  
参数说明：

iterabl – 一个或多个迭代器;  
返回值  
返回元组列表。

实例
    >>>a = [1,2,3]
    >>> b = [4,5,6]
    >>> c = [4,5,6,7,8]
    >>> zipped = zip(a,b)     # 打包为元组的列表
    [(1, 4), (2, 5), (3, 6)]
    >>> zip(a,c)              # 元素个数与最短的列表一致
    [(1, 4), (2, 5), (3, 6)]
    >>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
    [(1, 2, 3), (4, 5, 6)]

## 5.13、Format() ##

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
    'hello world'
     
    >>> "{0} {1}".format("hello", "world")  # 设置指定位置
    'hello world'
     
    >>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
    'world hello world'

**数字格式化**  
下表展示了 str.format() 格式化数字的多种方法：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 9]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70]: /images/20220202/80fbecd1ca194dd98c2bda840668cc57.png
[20190511150714550.png]: /images/20220202/33d385008e96417b8dabd0ea2106cd87.png
[20190511153000184.png]: /images/20220202/46d8df9fdacb4d4b802f030b1041f100.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 1]: /images/20220202/f225ded72d204438a68b89ce426ef563.png
[20190511153037163.png]: /images/20220202/ee109954b393480a8e42228af848aa3b.png
[20190511153141536.png]: /images/20220202/a0f675c4f4c644f99eca9af3096f4dc6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 2]: /images/20220202/af1b188d0e6941e78a26378ae30328fe.png
[20190511150654569.png]: /images/20220202/477e30e5c1cd40a6a2a6c8e9f085229d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 3]: /images/20220202/ed15a41005624f14a24b19c4d66dfee7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 4]: /images/20220202/990ea16f33ca43ae90c914c0cb24c539.png
[20190511150001329.png]: /images/20220202/17b85486fb8e442cae295cf3a67014f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 5]: /images/20220202/5617c6c5c9ae456b8cfed50c16f2421f.png
[20190511150358641.png]: /images/20220202/77bfadc00a71489ba395cfcbb6b055da.png
[20190511150544349.png]: /images/20220202/dbd8c35611ee419cb01725325038037d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 6]: /images/20220202/32260c4ac3c545ca947f376423acada1.png
[20190511153604422.png]: /images/20220202/3da121487ee14236a4668592134174ff.png
[20190511153805814.png]: /images/20220202/16bd3aabaeab41aab51dff95781001fc.png
[2019051115383833.png]: /images/20220202/12a40dcd25fb44588bdcf33dbef9e469.png
[20190511153938104.png]: /images/20220202/2472a3ba602a42d1bf1c88ac22e89a8a.png
[20190511154004608.png]: /images/20220202/ba22a516bba1498eb72d8ffdf6370703.png
[20190511154025588.png]: https://img-blog.csdnimg.cn/20190511154025588.png
[20190511154043923.png]: /images/20220202/ae23b37786334136b2aa02c45ac0e033.png
[20190511153907538.png]: /images/20220202/6700ce0a616549359c2f33f295cd2ac6.png
[20190511154131983.png]: /images/20220202/70af9fc25950414ba447e480dc52d188.png
[20190511154149988.png]: /images/20220202/b5fa6105eddd468c82cf27304c3cc580.png
[20190511154338809.png]: /images/20220202/2174d38ad9fe45019ab9336840185ac9.png
[201905111544207.png]: /images/20220202/efc29558b6804ddd94680964df051eac.png
[20190511154733157.png]: /images/20220202/32d8847f37a84727b4a9235e509cd640.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 7]: /images/20220202/9a52038123804be5b5a05c7b9817030c.png
[20190511154818932.png]: /images/20220202/3ebe6b332836485ab9f60cf54e0542e1.png
[2019051115484812.png]: /images/20220202/858d67d5aeaf48c5acf8b0d4ccdd8ed3.png
[20190511154913738.png]: https://img-blog.csdnimg.cn/20190511154913738.png
[20190511154928737.png]: /images/20220202/01ae32978c64438481488556a9c701db.png
[20190511155044103.png]: /images/20220202/1a386b3bb925442da58f43d4c9286a4b.png
[2019051115532780.png]: /images/20220202/f6b64f11dbee4e5c981d758a3b85f47f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 8]: /images/20220202/bbb4623693254a25941d3258ccc2fa80.png
[2019051115524720.png]: /images/20220202/c86dd95dc92f4609800e4be38712d8e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 9]: /images/20220202/1b55998fe76f4817a6ebc71919253b26.png