python 数据框的常用操作数据的读取、数据框的操作

一时失言乱红尘 2022-03-17 08:44 2499阅读 0赞

一、数据的读取  
1、数据目录的读取  
os函数

import os
    #获取当前的目录
    os.getcwd()
    #转换到指定的目录，记住进入文件夹是一个\,进入硬盘文件是\\
    os.chdir("C:\\Users\\Administrator.LAPTOP-1HM8PV0L\Desktop\论文\论文数据")

pandas.read_table(filepath_or_buffer,sep='\t',engine="python",header='infer')
    #filepath_or_buffer:文件名
    #sep 分割符
    #engine：读取引擎
    #header：infer，python自动识别
    
    注：excel保存时不要选utf-8格式的csv文件，不支持，选择csv格式，具体原因未知。

二、数据框的操作  
1、数据框去除重复

data1 = data1.drop_duplicates()
    pd.dataframe.drop_duplicates(self,subset=None,keep='first',inplace=False)

参数含义：subse：接受特定的字符串或者sequence。表示进行去重的列。默认为None，表示全部列。  
keep:接受特定的字符串，表示重复时保留的第几个数据  
first:保留第一个  
last：保留最后一个  
false：只要有重复都不保留 ,默认为 first  
inplace:接受的boolean.表示是否在原表上进行操作，默认为False。

2、数据框拼接  
（1）concat  
如result1和result2为我将要合并的数据框，数据框的合并共有两种方式，concat、append、merge皆可

result3=pd.concat([result1,result2],ignore_index=True) 
     result3=result1.append(result2,ignore_index=True)

pd.concat(objs, axis=0, join=‘outer’, join\_axes=None, ignore\_index=False, keys=None, levels=None, names=None,verify\_integrity=False, copy=True)

axis：要粘在哪个轴上。默认0，粘贴行。  
join：默认outer，合集；inner，交集。  
ignore\_index：布尔型，默认False。如果为Ture的话，会重新分配index从0…n-1。  
keys：一个序列，默认None。建立等级索引，作为最外层的level。  
levels：序列sequences构成的list，默认None。  
ignore\_index=True 表示是否合并后重置索引

（2）merge

pd.merge(left, right, how=‘inner’, on=None, left\_on=None, right\_on=None,  
left\_index=False, right\_index=False, sort=True,  
suffixes=(’\_x’, ‘\_y’), copy=True, indicator=False)  
参数说明：  
①left: 一个dataframe对象  
②right: 另一个dataframe对象  
③how: 可以是’left’, ‘right’, ‘outer’, ‘inner’. 默认为inner。这里相当于mysql中的左连接，右连接，外连接等等。  
④on: 列名，两个dataframe都有的列。如果不传参数，  
而且left\_index和right\_index也等于False，  
则默认把两者交叉/共有的列作为链接键（join keys）。  
可以是一个列名，也可以是包含多个列名的list。  
例1：

参数说明，on是链接的键的使用，传入一个时，代表以一个键进行匹配链接，传入列表时代表用列表中的键进行匹配链接
    left = pd.DataFrame({
        'key1': ['K0', 'K0', 'K1', 'K2'],
                          'key2': ['K0', 'K1', 'K0', 'K1'],
                             'A': ['A0', 'A1', 'A2', 'A3'],
                             'B': ['B0', 'B1', 'B2', 'B3']})
    
    right = pd.DataFrame({
        'key1': ['K0', 'K1', 'K1', 'K2'],
                          'key2': ['K0', 'K0', 'K0', 'K0'],
                             'C': ['C0', 'C1', 'C2', 'C3'],
                             'D': ['D0', 'D1', 'D2', 'D3']})
    
    result = pd.merge(left, right, on=['key1', 'key2'])
    # 同时传入两个Key，此时会进行以['key1','key2']列表的形式进行对应，left的keys列表是：[['K0', 'K0'],['K0', 'K1'],['K1', 'K0'],['K2', 'K1']],
    left的keys列表是：[['K0', 'K0'],['K1', 'K0'],['K1', 'K0'],['K2', 'K0']]，因此会有1个['K0', 'K0']、2个['K1', 'K0']对应。
    
    result
    Out[6]: 
        A   B key1 key2   C   D
    0  A0  B0   K0   K0  C0  D0
    1  A2  B2   K1   K0  C1  D1
    2  A2  B2   K1   K0  C2  D2
    ---------------------

④left\_on: 左边dataframe的列会用做keys。可以是列名，  
或者与dataframe长度相同的矩阵array。  
⑤right\_on: 右边同上。  
例2：

import pandas as pd
    A={
        '年份':[1990,1991,1992],'受伤人数':[1000,2000,3000]}
    B={
        '日期':[1990,1991,1992],'死亡人数':[1000,2000,3000]}
    A=pd.DataFrame(A)
    B=pd.DataFrame(B)
    c=pd.merge(A,B,how='inner',left_on='年份',right_on='日期')
    print(c)

![在这里插入图片描述][20190801210945404.png]  
⑥left\_index: 如果为Ture，用左侧dataframe的index作为  
连接键。如果是多维索引，level数要跟右边相同才行。  
⑦right\_index: 右边同上。  
⑧sort: 对合并后的数据框排序，以连接键。  
⑨suffixes: 一个tuple，包字符串后缀，用来加在重叠的列名后面。  
默认是(’\_x’,’\_y’)。  
⑩copy: 默认Ture，复制数据。  
<11>indicator: 布尔型（True/FALSE），或是字符串。  
如果为True，合并之后会增加一列叫做’\_merge’。  
是分类数据，用left\_only, right\_only, both来标记  
来自左边，右边和两边的数据。  
原文：https://blog.csdn.net/u013421629/article/details/82851678

标准格式：

A、B为数据框
    c=pd.merge(A,B,how='inner',left_on=左表要连接的键,right_on=右边要连接的键)

3.数据框列的添加与删除与截取  
3.1列的添加

#1生成DataFrame数据
    	 df = DataFrame(np.random.randn(4, 5), columns=['A', 'B', 'C', 'D', 'E'])
    	 # DataFrame数据预览：
    	     A            B         C         D          E
    	 0 0.673092    0.230338  -0.171681  0.312303 -0.184813
    	 1 -0.504482   -0.344286 -0.050845 -0.811277 -0.298181
    	 2 0.542788    0.207708   0.651379  -0.656214 0.507595
    	 3 -0.249410   0.131549   -2.198480 -0.437407  1.628228
    	 #2计算各列数据总和并作为新列添加到末尾
    	 df['Col_sum'] = df.apply(lambda x: x.sum(), axis=1)
    	 #3计算各行数据总和并作为新行添加到末尾
    	 df.loc['Row_sum'] = df.apply(lambda x: x.sum())
    	 #最终的计算结果
    	               A            B          C           D          E         Col_sum
    	 0          0.673092   0.230338   -0.171681   0.312303   -0.184813   0.859238
    	 1         -0.504482   -0.344286  -0.050845   -0.811277  -0.298181   -2.009071
    	 2          0.542788    0.207708   0.651379    -0.656214  0.507595    1.253256
    	 3         -0.249410   0.131549   -2.198480   -0.437407  1.628228    -1.125520
    	 Row_sum    0.461987    0.225310   -1.769627   -1.592595  1.652828   -1.022097

3.2列的删除  
如我们要删除最后一列

df=df.drop(columns=["col_sum"])
    df
    Out[72]: 
                    A         B         C         D         E
    0       -0.527976  1.464786 -0.046443  0.699213  0.693570
    1        1.410014 -0.665359  1.266628  0.492753  0.074608
    2        0.180348 -0.999142  0.053691 -1.765229  0.709453
    3        1.517546 -1.319503 -1.424466 -0.133496  0.328733
    Row_sum  5.159863 -3.038438 -0.301181 -1.413519  3.612729

如果要删除行的话则不用传入columns参数

df=df.drop(["Row_sum"])
     df
     Out[75]: 
               A         B         C         D         E
     0     -0.527976  1.464786 -0.046443  0.699213  0.693570
     1     1.410014  -0.665359  1.266628  0.492753  0.074608
     2     0.180348  -0.999142  0.053691 -1.765229  0.709453
     3     1.517546  -1.319503 -1.424466 -0.133496  0.328733

我们在进行数据框删除时，其中有个参数为inplace参数，默认为False,如果inplace=True，则原数据框发生改变。  
3.3 删除多行多列  
当然我们在进行数据框操作时用的较多的不是单个行或者列的删除，而是多个行或者列的删除，所以如果我们要删除多行多列的话可以用如下代码

##多个列的删除
    ##删除数据框的1至3列
    df.drop(columns=df.columns[np.arange(3)],axis=1，inplace=True)
    Out[85]: 
                    D         E
    0        0.699213  0.693570
    1        0.492753  0.074608
    2       -1.765229  0.709453
    3       -0.133496  0.328733
    Row_sum -1.413519  3.612729
    ##多行的删除
    ##删除数据框的多个行
    df.drop(np.arange(3),inplace=True)  
    Out[92]: 
          D         E
    3  0.382525 -1.483225

3.4插入行数据  
行数据的插入有两种方法一种是像上面所用的.loc()函数，另一种就是我们通过pd.concat()将两个数据框拼接，我们仍然用上面的例子做演示

#1生成DataFrame数据
        df = DataFrame(np.random.randn(4, 5), columns=['A', 'B', 'C', 'D', 'E'])
        # DataFrame数据预览：
             A            B         C         D          E
        0 0.673092    0.230338  -0.171681  0.312303 -0.184813
        1 -0.504482   -0.344286 -0.050845 -0.811277 -0.298181
        2 0.542788    0.207708   0.651379  -0.656214 0.507595
        3 -0.249410   0.131549   -2.198480 -0.437407  1.628228
        我们重新插入一行，注意我们插入的行列数需要与原来的数据框列数相等。
    
        #方法1
        df.loc[4]=list(np.arange(5))
        df
        Out[126]: 
                  A         B         C         D         E
        0 -0.118109  0.025787 -0.303449  0.489557 -1.081694
        1  0.904017  0.726163 -0.416009 -0.166353 -1.797127
        2  0.077853 -0.038286  0.306290  0.566673  2.889657
        3 -0.024119 -0.463047 -1.197924  0.003828  0.065078
        4  0.000000  1.000000  2.000000  3.000000  4.000000
        (注意，添加列是dataframe[ ],不用加loc)
    
        #方法2
        ##生成新的数据框
        a=pd.DataFrame(np.array(np.arange(5)),index=df.columns).T
        ##拼接
        df=pd.concat([a,df],ignore_index=True)
        df
        Out[181]: 
                  A         B         C         D         E
        0  0.000000  1.000000  2.000000  3.000000  4.000000
        1 -0.118109  0.025787 -0.303449  0.489557 -1.081694
        2  0.904017  0.726163 -0.416009 -0.166353 -1.797127
        3  0.077853 -0.038286  0.306290  0.566673  2.889657
        4 -0.024119 -0.463047 -1.197924  0.003828  0.065078
        5  0.000000  1.000000  2.000000  3.000000  4.000000

3.5、选取固定的行和列  
(1)、选取固定的列

*  按列名选择  
    数据框\[\[列名1，列名2…\]\]
 *  按数字索引选择  
    ①生成选择列的数字列表，如要选择1-5，则生成\[1,2,3,4,5\]  
    ②利用数据框.column选择对应的列名  
    choose\_variable=all\_variable.columns\[\[5,6,7,11\]\]并将其命名为新变量名  
    再利用生成的列名列表去选取固定的列  
    如

choose_variable=all_variable.columns[[5,6,7,11]]
    a=all_variable[choose_variable]

(2)、选取固定的行和列  
数据框中有iloc这个属性可以选取数据框中固定的行和列，比如:

#选取数据框的第一行第一列
    数据框.iloc[1,1]
    #选取数据框的前1-5行，所有列
    数据框.iloc[[0,1,2,3,4],:]
    #选取数据框的前1-5列，所有行
    数据框.iloc[:,[0,1,2,3,4]]

（3）根据列的字段选取固定的行  
例：在数据框中选取指定车牌号的车辆  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70]  
可以使用isin函数

ffyy3=ffyy2[ffyy2.hphm.isin(['粤CYJ276','粤CSW658','粤C6G268'])]

其中号牌号码为列名，后面的选取指定列中的固定字段  
（4）使用.loc选取固定的行和列  
这里用使用同一个数据框作为例子  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 1]  
.loc主要是基于标签(label)的，包括行标签(index)和列标签(columns)，即行名称和列名称，可以使用df.loc\[index\_name,col\_name\]，选择指定位置的数据，其它的用法有：  
1、 使用单个标签。如果.loc\[\]中只有单个标签，那么选择的是某一行。 df.loc\[3\]选择的是index名为‘3’的一行，注意这里的’3’是index的名称，而不是序号  
![在这里插入图片描述][20190819150815835.png]  
2、使用标签的list：同样是只选择行  
![在这里插入图片描述][20190819150911461.png]  
3、 标签的切片对象：与通常的python切片不同，在最终选择的数据中包含切片的start和stop  
![在这里插入图片描述][20190819151020304.png]  
4. 布尔型的数组：通常用于筛选符合某些条件的行  
![在这里插入图片描述][20190819151043417.png]  
![在这里插入图片描述][20190819151055807.png]  
5、可调用的函数  
![在这里插入图片描述][20190819151123788.png]  
3.6、对数据框框某些列进行数据变换  
（1）对数变换  
对数据框的某些列进行对数变换，可以采用numpy包中的log函数进行  
4、显示数据框的列名

数据框名.columns

5、数据的统计分析  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 2]  
1、对数据框某个列的字段进行统计  
例：对数据按hphm、kkbh、auth\_acount(电话)进行分类，并显示  
ffyy\_people1=ffyy\_people.groupby(by=\[‘hphm’,‘kkbh’,‘auth\_account’\])  
ffyy\_people1.size().sort\_values()  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 3]  
同样也可以将其转换为数据框的形式进行操作  
a=ffyy\_people1.size().sort\_values()  
此时a为一个series  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 4]  
如果要将series变为一个数据框可以采用如下操作：

list1=list(a.index)
    arr1=[]
    arr2=[]
    arr3=[]
    value=list(a.values)
    for i in list1:
        hphm=i[0]
        kkbh=i[1]
        tel=i[2]
        arr1.append(hphm)
        arr2.append(kkbh)
        arr3.append(tel)
    a1=pd.DataFrame({
        'hphm':arr1,'kkbh':arr2,'auth_acount':arr3,'cishu':value})

2、对数据框进行排序  
用sort\_value(\[字段名1，字段名2…字段名n\])  
例：  
ffyy\_people=ffyy\_people.sort\_values(\[‘hphm’,‘kkbh’\],ascending=True)  
对ffyy\_people数据框进行排序，按照号牌号码、卡口编号进行升序排序。

# 4.数据框的读入与写出 #

## 4.1 文件读取 ##

python中读取文件主要有readcsv和read\_table两种类型。两个函数的主要参数如下表所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 5][]  
4.2 文件写出  
python的文件写出一般用to\_csv( )函数

> dataframe.to\_csv(path,sep=",",np\_rep=’’,columns=None,header=True,index=True,、index\_label=None,mode=‘w’,encoding=None)
> 
> 参数名称如下所示：  
> path：代表文件路径。 sep:文件分割类型，默认为“，” na\_rep:接受字符串，代表缺失值，默认为None  
> columns:代表写出的列名，默认为“None” header:代表是否将列名写出，默认为True  
> index:是否将索引写出，默认为True  
> index\_label:接受数列。表示是否自己编写索引名，默认为None(以原先数据框的索引为主) mode:数据的写入模式，默认为w  
> encoding：存储文件的编码格式。默认为none

一般来说我们在写出文件时是不需要索引的，所以写出文件的一般格式可以表示为：  
\#注gbk格式比utf-8更兼容  
data.to\_csv(“文件名.csv”,index=False（index=True）,sep=",",header=True,encoding=“gbk”)  
\#如果写出的中文格式文件中有中文乱码，可以采用utf\_8\_sig来进行输出  
data.to\_csv(“文件名.csv”,index=False（index=True）,sep=",",header=True,encoding=“utf\_8\_sig”)

## 5.数据框划分 ##

我们有时在对数据进行处理时常常会用到一些方法将数据划分为测试集和训练集，python中的sklearn.model\_selection包中的train\_test\_split函数能够很好的划分数据  
train\_test\_split(arrays,…)

参数及其用法

1.  arrays:接受一个或者多个数据集，为将要划分的数据集
2.  test\_size:接受float、int类型，表示测试集划分的数据大小test\_size:接受float、int类型，表示测试集划分的数据大小
3.  train\_size:接受float、int类型，训练数据的大小，表示训练集的大小  
    （注：测试集与训练集只能传入一个参数）（注：测试集与训练集只能传入一个参数，且如果传入的为测试集参数则分出的第一个数据集为测试集大小，否则则为训练集大小：例如：train\_pork,test\_pork=train\_test\_split(pork,train\_size=0.7,random\_state=42)  
    则前一个为测试集 ）
4.  random\_state:随机数的种子
5.  shuffle:代表是否进行有放回抽样，默认为False。如果该参数取值为True,则straitfy参数不能为空
6.  straitfy：接受array或者None，默认为None，当不为None时必须通过传入标签进行分层抽取

## 5、将其他数据格式转换为数据框 ##

Python中将列表转换成为数据框有两种情况：第一种是两个不同列表转换成一个数据框，第二种是一个包含不同子列表的列表转换成为数据框。  
①第一种：两个不同列表转换成为数据框

from pandas.core.frame import DataFrame
    a=[1,2,3,4]#列表a
    b=[5,6,7,8]#列表b
    data=DataFrame({
        "a":a,"b":b})#将列表a，b转换成字典
    )#将字典转换成为数据框
    print(data)
    
    #结果
       a  b
    0  1  5
    1  2  6
    2  3  7
    3  4  8

②第二种：将包含不同子列表的列表转换为数据框

a=[[1,2,3,4],[5,6,7,8]]#包含两个不同的子列表[1,2,3,4]和[5,6,7,8]
    data=pd.DataFrame(a)#这时候是以行为标准写入的
    print(data)
    ##结果
       0  1  2  3
    0  1  2  3  4
    1  5  6  7  8

③数据框的转置及列名的修改  
①如果我们想以列为标准，转置一下就可以了

data=data.T#转置之后得到想要的结果
       0  1
    0  1  5
    1  2  6
    2  3  7
    3  4  8

②修改列名  
方法1：逐个修改

data.rename(columns={
        0:'a',1:'b'},inplace=True)#注意这里0和1都不是字符串
    print(data)
    ##结果
      a  b
    0  1  5
    1  2  6
    2  3  7
    3  4  8

例2：将数据框中的北京、天津修改为北京市、天津市。

R_D_Data
        北    京            天     津  
    8.440692799999999	2.715041
    8.68530142368	    2.7937220346
    14.24201056	        4.5810982
    25.740540799999998	8.279725999999998
    38.425054720000006	12.359838400000001
    44.82038496	        14.4169662
    46.73918816	        15.034170199999998
    59.96872384	        19.2895948
    61.903857280000004	19.912051599999998
    79.82629568	        25.6769996
    80.39785408	        25.8608476
    80.4978768	        25.893020999999997
    105.1871584	      	33.834598
    134.0304448			43.112356
    R_D_Data.rename(columns={
        '北    京':'北京市','天    津':'天津市'},inplace=True)
    #注意我们在进行列名修改时，一定要注意字符串是否打对了比如这里原本的列名为"北   京",如果你打为"北京"
    #则不会修改，即进行rename时如果找不到列名，python不会报错也不会修改，我们可以用data.columns来获取列#名列表来修改
        北京市            天津市  
    8.440692799999999	2.715041
    8.68530142368	    2.7937220346
    14.24201056	        4.5810982
    25.740540799999998	8.279725999999998
    38.425054720000006	12.359838400000001
    44.82038496	        14.4169662
    46.73918816	        15.034170199999998
    59.96872384	        19.2895948
    61.903857280000004	19.912051599999998
    79.82629568	        25.6769996
    80.39785408	        25.8608476
    80.4978768	        25.893020999999997
    105.1871584	      	33.834598
    134.0304448			43.112356

方法2：批量修改

data.rename(columns=["a","b"],inplace=True)#注意这里0和1都不是字符串

修改后的效果和上面一样

## 6、数据框的常用函数 ##

①apply（fun）  
Series.apply(fun)，对series中的每一个元素都使用func函数.注：apply运用的对象为Series即数据框中的元素，list使用map函数  
如：

#apply
    a=[1,2,3,4]
    a=pd.Series(a)
    a.apply(lambda a:a**2)
    #map
    a=[1,2,3,4]
    d1=map(lambda a:a**2,a)
    print(list(d1))

结果1：  
0 1  
1 4  
2 9  
3 16  
结果2：  
\[1, 4, 9, 16\]

[20190801210945404.png]: /images/20220317/9bc019b9cab543b48e10740d98c3f7f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70]: /images/20220317/c765b57e89e4434e83283b76d910e5e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 1]: /images/20220317/cc5e028cd81f405e9e5121b9481e80b6.png
[20190819150815835.png]: /images/20220317/ad10b540353d4de2919d92f1af85a3ee.png
[20190819150911461.png]: /images/20220317/6b5ec04c0faf48e4b0ced4a6d184384a.png
[20190819151020304.png]: /images/20220317/27b83ea62d57482aaaa6b679de713c1e.png
[20190819151043417.png]: /images/20220317/488bb729be444f8fbffc07c77de3867c.png
[20190819151055807.png]: /images/20220317/601e9ad683d4446cb0a3f51b510feb63.png
[20190819151123788.png]: /images/20220317/e6ce5566608f4bd79514e6ccb169f3cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 2]: /images/20220317/1a2bf27100d94d2983b6a1b01f401985.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 3]: /images/20220317/a8c41964aa8c465d937c5d9082651788.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 4]: /images/20220317/222a7647a2e24fb8a4d6ceb008504f1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 5]: /images/20220317/d92bcbae88b64f6c9e133de546399b44.png