python数据结构Pandas

港控/mmm° 2022-05-29 09:20 208阅读 0赞

**目录**

1. 要使用pandas，首先需要了解他主要两个数据结构：Series和DataFrame。

1.1 Series

1.2 DataFrame

2. pandas选择数据

3. pandas设置值

4. pandas处理丢失数据

5. pandas导入导出

6. pandas合并 concat

7. pandas合并merge

8. pandas plot 画图

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

python学习顺序：https://morvanzhou.github.io/learning-steps/

Numpy 和 pandas 有什么不同：

如果用 python 的列表和字典来作比较, 那么可以说 Numpy 是列表形式的，没有数值标签，而 Pandas 就是字典形式。Pandas是基于Numpy构建的，让Numpy为中心的应用变得更加简单。

## 1. 要使用pandas，首先需要了解他主要两个数据结构：Series和DataFrame。 ##

series：`Series`的字符串表现形式为：索引在左边，值在右边。由于我们没有为数据指定索引。于是会自动创建一个0到N-1（N为长度）的整数型索引。

DataFrame：`DataFrame`是一个表格型的数据结构，它包含有一组有序的列，每列可以是不同的值类型（数值，字符串，布尔值等）。`DataFrame`既有行索引也有列索引， 它可以被看做由`Series`组成的大字典。

### 1.1 Series ###

import pandas as pd
    import numpy as np
    
    s = pd.Series([1,3,6,np.nan,44,1])
    
    print(s)   #用了Series，0-5是自动生成的索引，右边是上面写入的值
    
    '''
    0     1.0
    1     3.0
    2     6.0
    3     NaN
    4    44.0
    5     1.0
    dtype: float64
    '''

### 1.2 DataFrame ###

import pandas as pd
    import numpy as np
    
    dates = pd.date_range('20160101',periods=6)  #第一个参数表示日期开始的时间，第二个参数表示日期总数量
    #行索引：row/index  列索引：columns   默认是0-N作为索引
    df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['a','b','c','d'])   #生成6*4数据，日期作为行索引，a-d作为列索引
    
    print(df)
    """
                       a         b         c         d
    2016-01-01  0.518328  0.635466 -0.373825 -0.177465
    2016-01-02  0.900477  0.733955  0.103209  0.494300
    2016-01-03  0.036176 -0.099010 -0.979401  2.032592
    2016-01-04 -0.137773 -0.178855  0.788385  0.133377
    2016-01-05 -0.072844 -0.356459 -0.444869  1.196717
    2016-01-06 -1.471765 -0.917903 -0.543412 -0.326014
    """

我们可以根据每一个不同的索引来挑选数据。比如挑选 `b` 的元素，就是print(df\['b'\])

DataFrame的一些简单运用

import pandas as pd
    import numpy as np
    
    #创建一组没有给定行标签和列标签的数据 df1:  这样,他就会采取默认的从0开始 index
    df1 = pd.DataFrame(np.arange(12).reshape((3,4)))
    print(df1)
    
    #还有一种生成 df 的方法, 如下 df2:  这种方法能对每一列的数据进行特殊对待
    df2 = pd.DataFrame({'A' : 1.,
                        'B' : pd.Timestamp('20130102'),
                        'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
                        'D' : np.array([3] * 4,dtype='int32'),
                        'E' : pd.Categorical(["test","train","test","train"]),
                        'F' : 'foo'})
                        
    print(df2)
    '''
         A          B    C  D      E    F
    0  1.0 2013-01-02  1.0  3   test  foo
    1  1.0 2013-01-02  1.0  3  train  foo
    2  1.0 2013-01-02  1.0  3   test  foo
    3  1.0 2013-01-02  1.0  3  train  foo
    '''
    #数据类型
    print(df2.dtypes)
    
    #如果想看对列的序号:
    print(df2.index)
    # Int64Index([0, 1, 2, 3], dtype='int64')
    
    #同样, 每种数据的名称也能看到:
    print(df2.columns)
    # Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')
    
    #如果只想看所有df2的值:
    print(df2.values)
    
    #想知道数据的总结, 可以用 describe():   只运算数字形式的
    print(df2.describe())
    
    #如果想翻转数据, transpose:
    print(df2.T)
    
    #如果想对数据的 index 进行排序并输出:    axis=1表示按行索引，ascending=False表示倒序
    print(df2.sort_index(axis=1, ascending=False))
    print(df2.sort_index(axis=0, ascending=False))
    
    #如果是对数据值排序输出:
    print(df2.sort_values(by='B'))

## 2. pandas选择数据 ##

import pandas as pd
    import numpy as np
    
    #建立了一个 6X4 的矩阵数据
    dates = pd.date_range('20130101', periods=6)
    df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=['A','B','C','D'])
    print(df)
    '''
                 A   B   C   D
    2013-01-01   0   1   2   3
    2013-01-02   4   5   6   7
    2013-01-03   8   9  10  11
    2013-01-04  12  13  14  15
    2013-01-05  16  17  18  19
    2013-01-06  20  21  22  23
    '''
    #1. 简单筛选
    #如果想选取DataFrame中的数据，下面描述了两种途径, 他们都能达到同一个目的：
    #print(df['A'])
    #print(df.A)     
    '''
    2013-01-01     0
    2013-01-02     4
    2013-01-03     8
    2013-01-04    12
    2013-01-05    16
    2013-01-06    20
    Freq: D, Name: A, dtype: int32
    '''
    
    #选择跨越多行或多列
    print(df[0:3])   #第0-2行
    print(df['20130102':'20130104'])   #索引方式
    
    #2.根据loc标签
    #本例子主要通过标签名字选择某一行数据， 或者通过选择某行或者所有行
    #（:代表所有行）然后选其中某一列或几列数据。:
    print(df.loc['20130102']) 
    print(df.loc[:,['A','B']])   #保存所有行，对列筛选
    print(df.loc['20130104',['A','B']])  
    '''
    A    4
    B    5
    C    6
    D    7
    Name: 2013-01-02 00:00:00, dtype: int32
                 A   B
    2013-01-01   0   1
    2013-01-02   4   5
    2013-01-03   8   9
    2013-01-04  12  13
    2013-01-05  16  17
    2013-01-06  20  21
    A    12
    B    13
    Name: 2013-01-04 00:00:00, dtype: int32
    '''
    #3.根据序列iloc
    #另外我们可以采用位置进行选择 iloc, 在这里我们可以通过位置选择在不同情况下所
    #需要的数据例如选某一个，连续选或者跨行选等操作。
    #print(df.iloc[3])   #第3行   
    print(df.iloc[3,1])  #第3行，第1列
    print(df.iloc[3:5,1:3])  #3、4行，1、2列
    print(df.iloc[[1,3,5],1:3])  #逐个筛选，第1、3、5行
    '''
    A    12
    B    13
    C    14
    D    15
    Name: 2013-01-04 00:00:00, dtype: int32
    13
                 B   C
    2013-01-04  13  14
    2013-01-05  17  18
                 B   C
    2013-01-02   5   6
    2013-01-04  13  14
    2013-01-06  21  22
    
    '''
    #4.混合筛选ix  结合标签和序列
    print(df.ix[:3,['A','C']])  #其中选择’A’和’C’的两列，并选择前三行的数据
    #通过判断进行筛选
    print(df[df.A>8])  #保留df中A列大于8的那些数
    '''
                A   C
    2013-01-01  0   2
    2013-01-02  4   6
    2013-01-03  8  10
                 A   B   C   D
    2013-01-04  12  13  14  15
    2013-01-05  16  17  18  19
    2013-01-06  20  21  22  23
    '''

## 3. pandas设置值 ##

我们可以根据自己的需求, 用 pandas 进行更改数据里面的值, 或者加上一些空的,或者有数值的列.

import pandas as pd
    import numpy as np
    
    #建立了一个 6X4 的矩阵数据
    dates = pd.date_range('20130101', periods=6)
    df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=['A','B','C','D'])
    print(df)
    
    df.iloc[2,2]=111   #根据位置设置 loc 和 iloc
    print(df)
    '''
                 A   B    C   D
    2013-01-01   0   1    2   3
    2013-01-02   4   5    6   7
    2013-01-03   8   9  111  11
    2013-01-04  12  13   14  15
    2013-01-05  16  17   18  19
    2013-01-06  20  21   22  23
    '''
    
    #可以利用索引或者标签确定需要修改值的位置
    df.loc['20130101','B'] = 2222
    print(df)
    '''
                 A     B   C   D
    2013-01-01   0  2222   2   3
    2013-01-02   4     5   6   7
    2013-01-03   8     9  10  11
    2013-01-04  12    13  14  15
    2013-01-05  16    17  18  19
    2013-01-06  20    21  22  23
    '''
    #根据条件设置
    df.B[df.A>4] = 0  #我们想要更改B中的数, 而更改的位置是取决于 A 的.
           #对于A大于4的位置. 更改B在相应位置上的数为0.
    print(df)
    '''
                 A  B   C   D
    2013-01-01   0  1   2   3
    2013-01-02   4  5   6   7
    2013-01-03   8  0  10  11
    2013-01-04  12  0  14  15
    2013-01-05  16  0  18  19
    2013-01-06  20  0  22  23
    '''
    
    #如果对整列做批处理, 加上一列 ‘F’, 并将 F 列全改为 NaN, 如下
    df['F'] = np.nan
    print(df)
    '''
                 A   B   C   D   F
    2013-01-01   0   1   2   3 NaN
    2013-01-02   4   5   6   7 NaN
    2013-01-03   8   9  10  11 NaN
    2013-01-04  12  13  14  15 NaN
    2013-01-05  16  17  18  19 NaN
    2013-01-06  20  21  22  23 NaN
    '''
    
    #添加数据  也可以加上 Series 序列（但是长度必须对齐）
    df['E'] = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130101',periods=6))
    print(df)
    '''
                 A   B   C   D  E
    2013-01-01   0   1   2   3  1
    2013-01-02   4   5   6   7  2
    2013-01-03   8   9  10  11  3
    2013-01-04  12  13  14  15  4
    2013-01-05  16  17  18  19  5
    2013-01-06  20  21  22  23  6
    '''

## 4. pandas处理丢失数据 ##

pd.dropna()

pd.fillna()

pd.isnull()

import pandas as pd
    import numpy as np
    
    #建立了一个 6X4 的矩阵数据
    dates = pd.date_range('20130101', periods=6)
    df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=['A','B','C','D'])
    print(df)
    df.iloc[0,1] = np.nan
    df.iloc[1,2] = np.nan
    print(df)
    '''
                 A     B     C   D
    2013-01-01   0   NaN   2.0   3
    2013-01-02   4   5.0   NaN   7
    2013-01-03   8   9.0  10.0  11
    2013-01-04  12  13.0  14.0  15
    2013-01-05  16  17.0  18.0  19
    2013-01-06  20  21.0  22.0  23
    '''
    #如果想直接去掉有 NaN 的行或列, 可以使用 dropna
    #pd.dropna() 
    df.dropna(
        axis=0,     # 0: 对行进行操作; 1: 对列进行操作
        how='any'   # 'any': 只要存在 NaN 就 drop 掉; 'all': 必须全部是 NaN 才 drop 
        )
    print(df.dropna(0,'any'))
    '''
                 A     B     C   D
    2013-01-03   8   9.0  10.0  11
    2013-01-04  12  13.0  14.0  15
    2013-01-05  16  17.0  18.0  19
    2013-01-06  20  21.0  22.0  23
    '''
    #如果是将 NaN 的值用其他值代替, 比如代替成 0:
    #pd.fillna()
    print(df.fillna(value=0))
    '''
                 A     B     C   D
    2013-01-01   0   0.0   2.0   3
    2013-01-02   4   5.0   0.0   7
    2013-01-03   8   9.0  10.0  11
    2013-01-04  12  13.0  14.0  15
    2013-01-05  16  17.0  18.0  19
    2013-01-06  20  21.0  22.0  23
    '''
    
    #判断是否有缺失数据 NaN, 为 True 表示缺失数据:
    #pd.isnull()
    print(df.isnull())
    '''
                    A      B      C      D
    2013-01-01  False   True  False  False
    2013-01-02  False  False   True  False
    2013-01-03  False  False  False  False
    2013-01-04  False  False  False  False
    2013-01-05  False  False  False  False
    2013-01-06  False  False  False  False
    '''
    
    #检测在数据中是否存在 NaN, 如果存在就返回 True:
    print(np.any(df.isnull()) == True)
    '''
    True
    '''

## 5. pandas导入导出 ##

`pandas`可以读取与存取的资料格式有很多种，像`csv`、`excel`、`json`、`html`与`pickle`等…， 详细请看官方说明   [http://pandas.pydata.org/pandas-docs/stable/io.html][http_pandas.pydata.org_pandas-docs_stable_io.html]

csv格式，最基本的excel格式

import pandas as pd
    import numpy as np
    
    data = pd.read_csv('student.csv')  #读取的文件   
    print(data)   #自动分配行索引
    data.to_pickle('student.pickle')  将资料存取成pickle

## 6. pandas合并 concat ##

`pandas`处理多组数据的时候往往会要用到数据的合并处理,使用 `concat`是一种基本的合并方式.而且`concat`中有很多参数可以调整,合并成你想要的数据形式.

axis（合并方向）     ignore\_index(重置index)

join合并：`join='outer'`为预设值，因此未设定任何参数时，函数默认`join='outer'`。此方式是依照`column`来做纵向合并，有相同的`column`上下合并在一起，其他独自的`column`个自成列，原本没有值的位置皆以`NaN`填充。

join\_axes(依照axes合并)

append（添加数据）：`append`只有纵向合并，没有横向合并

import pandas as pd
    import numpy as np
    
    #定义资料集
    df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
    df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
    df3 = pd.DataFrame(np.ones((3,4))*2, columns=['a','b','c','d'])
    
    #concat纵向合并
    res = pd.concat([df1, df2, df3], axis=0)
    
    #打印结果
    print(res)
    '''
         a    b    c    d
    0  0.0  0.0  0.0  0.0
    1  0.0  0.0  0.0  0.0
    2  0.0  0.0  0.0  0.0
    0  1.0  1.0  1.0  1.0
    1  1.0  1.0  1.0  1.0
    2  1.0  1.0  1.0  1.0
    0  2.0  2.0  2.0  2.0
    1  2.0  2.0  2.0  2.0
    2  2.0  2.0  2.0  2.0
    '''
    #index 重复
    
    #承上一个例子，并将index_ignore设定为True
    res = pd.concat([df1, df2, df3], axis=0, ignore_index=True)
    print(res)
    '''
         a    b    c    d
    0  0.0  0.0  0.0  0.0
    1  0.0  0.0  0.0  0.0
    2  0.0  0.0  0.0  0.0
    3  1.0  1.0  1.0  1.0
    4  1.0  1.0  1.0  1.0
    5  1.0  1.0  1.0  1.0
    6  2.0  2.0  2.0  2.0
    '''
    
    #join（合并方式）
    #定义资料集
    df4 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
    df5 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])
    
    #纵向"外"合并df1与df2
    res = pd.concat([df4, df5], axis=0, join='outer')
    print(res)
    '''
         a    b    c    d    e
    1  0.0  0.0  0.0  0.0  NaN
    2  0.0  0.0  0.0  0.0  NaN
    3  0.0  0.0  0.0  0.0  NaN
    2  NaN  1.0  1.0  1.0  1.0
    3  NaN  1.0  1.0  1.0  1.0
    '''
    #但只有相同的column合并在一起，其他的会被抛弃。
    res = pd.concat([df4, df5], axis=0, join='inner')
    print(res)
    '''
         b    c    d
    1  0.0  0.0  0.0
    2  0.0  0.0  0.0
    3  0.0  0.0  0.0
    2  1.0  1.0  1.0
    3  1.0  1.0  1.0
    4  1.0  1.0  1.0
    '''
    
    #重置index并打印结果
    res = pd.concat([df4, df5], axis=0, join='inner', ignore_index=True)
    print(res)
    '''
         b    c    d
    0  0.0  0.0  0.0
    1  0.0  0.0  0.0
    2  0.0  0.0  0.0
    3  1.0  1.0  1.0
    4  1.0  1.0  1.0
    5  1.0  1.0  1.0
    '''
    
    #join_axes (依照 axes 合并)
    res = pd.concat([df4, df5], axis=1, join_axes=[df1.index])
    #打印结果
    print(res)
    '''
        a    b    c    d    b    c    d    e
    0  NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
    1  0.0  0.0  0.0  0.0  NaN  NaN  NaN  NaN
    2  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0
    '''
    #append (添加数据)
    s1 = pd.Series([1,2,3,4], index=['a','b','c','d'])
    res = df1.append(df2, ignore_index=True)
    print(res)
    '''
         a    b    c    d
    0  0.0  0.0  0.0  0.0
    1  0.0  0.0  0.0  0.0
    2  0.0  0.0  0.0  0.0
    3  1.0  1.0  1.0  1.0
    4  1.0  1.0  1.0  1.0
    5  1.0  1.0  1.0  1.0
    '''
    
    #合并多个df，将df2与df3合并至df1的下面，以及重置index，并打印出结果
    res = df1.append([df2, df3], ignore_index=True)
    print(res)
    '''
         a    b    c    d
    0  0.0  0.0  0.0  0.0
    1  0.0  0.0  0.0  0.0
    2  0.0  0.0  0.0  0.0
    3  1.0  1.0  1.0  1.0
    4  1.0  1.0  1.0  1.0
    5  1.0  1.0  1.0  1.0
    6  2.0  2.0  2.0  2.0
    7  2.0  2.0  2.0  2.0
    8  2.0  2.0  2.0  2.0
    '''
    
    #合并series，将s1合并至df1，以及重置index，并打印出结果
    res = df1.append(s1, ignore_index=True)
    print(res)
    '''
         a    b    c    d
    0  0.0  0.0  0.0  0.0
    1  0.0  0.0  0.0  0.0
    2  0.0  0.0  0.0  0.0
    3  1.0  2.0  3.0  4.0
    '''

## 7. pandas合并merge ##

`pandas`中的`merge`和`concat`类似,但主要是用于两组有key column的数据,统一索引的数据. 通常也被用在Database的处理当中.

import pandas as pd
    import numpy as np
    
    #依据一组key合并
    #定义资料集并打印出
    left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                                 'A': ['A0', 'A1', 'A2', 'A3'],
                                 'B': ['B0', 'B1', 'B2', 'B3']})
    right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                                  'C': ['C0', 'C1', 'C2', 'C3'],
                                  'D': ['D0', 'D1', 'D2', 'D3']})
    
    print(left)
    print(right)
    
    res = pd.merge(left, right, on='key')
    print(res)
    '''
        A   B key
    0  A0  B0  K0
    1  A1  B1  K1
    2  A2  B2  K2
    3  A3  B3  K3
        C   D key
    0  C0  D0  K0
    1  C1  D1  K1
    2  C2  D2  K2
    3  C3  D3  K3
        A   B key   C   D
    0  A0  B0  K0  C0  D0
    1  A1  B1  K1  C1  D1
    2  A2  B2  K2  C2  D2
    3  A3  B3  K3  C3  D3
    '''
    
    left2 = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                          'key2': ['K0', 'K1', 'K0', 'K1'],
                          'A': ['A0', 'A1', 'A2', 'A3'],
                          'B': ['B0', 'B1', 'B2', 'B3']})
    right2 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                           'key2': ['K0', 'K0', 'K0', 'K0'],
                           'C': ['C0', 'C1', 'C2', 'C3'],
                           'D': ['D0', 'D1', 'D2', 'D3']})
    
    print(left2)
    print(right2)
    '''
        A   B key1 key2
    0  A0  B0   K0   K0
    1  A1  B1   K0   K1
    2  A2  B2   K1   K0
    3  A3  B3   K2   K1
        C   D key1 key2
    0  C0  D0   K0   K0
    1  C1  D1   K1   K0
    2  C2  D2   K1   K0
    3  C3  D3   K2   K0
    '''
    #依据两组key合并
    #合并时有4种方法how = ['left', 'right', 'outer', 'inner']，预设值how='inner'。
    res = pd.merge(left2, right2, on=['key1', 'key2'], how='inner')
    print(res)
    '''
        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
    '''
    
    res = pd.merge(left2, right2, on=['key1', 'key2'], how='outer')
    print(res)
    '''
         A    B key1 key2    C    D
    0   A0   B0   K0   K0   C0   D0
    1   A1   B1   K0   K1  NaN  NaN
    2   A2   B2   K1   K0   C1   D1
    3   A2   B2   K1   K0   C2   D2
    4   A3   B3   K2   K1  NaN  NaN
    5  NaN  NaN   K2   K0   C3   D3
    '''
    
    res = pd.merge(left2, right2, on=['key1', 'key2'], how='left')
    print(res)
    '''
        A   B key1 key2    C    D
    0  A0  B0   K0   K0   C0   D0
    1  A1  B1   K0   K1  NaN  NaN
    2  A2  B2   K1   K0   C1   D1
    3  A2  B2   K1   K0   C2   D2
    4  A3  B3   K2   K1  NaN  NaN
    '''
    res = pd.merge(left2, right2, on=['key1', 'key2'], how='right')
    print(res)
    '''
         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
    3  NaN  NaN   K2   K0  C3  D3
    '''
    
    #Indicator： indicator=True会将合并的记录放在新的一列。
    df1 = pd.DataFrame({'col1':[0,1], 'col_left':['a','b']})
    df2 = pd.DataFrame({'col1':[1,2,2],'col_right':[2,2,2]})
    
    print(df1)
    print(df2)
    '''
       col1 col_left
    0     0        a
    1     1        b
       col1  col_right
    0     1          2
    1     2          2
    2     2          2
    '''
    
    # 依据col1进行合并，并启用indicator=True，最后打印出
    res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)
    print(res)
    '''
       col1 col_left  col_right      _merge
    0     0        a        NaN   left_only
    1     1        b        2.0        both
    2     2      NaN        2.0  right_only
    3     2      NaN        2.0  right_only
    '''
    
    # 自定indicator column的名称，并打印出
    res = pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
    print(res)
    '''
       col1 col_left  col_right indicator_column
    0     0        a        NaN        left_only
    1     1        b        2.0             both
    2     2      NaN        2.0       right_only
    3     2      NaN        2.0       right_only
    '''
    
    #依据index合并
    left1 = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                         'B': ['B0', 'B1', 'B2']},
                         index=['K0', 'K1', 'K2'])
    right1 = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                          'D': ['D0', 'D2', 'D3']},
                         index=['K0', 'K2', 'K3'])
    
    print(left1)
    print(right1)
    '''
         A   B
    K0  A0  B0
    K1  A1  B1
    K2  A2  B2
         C   D
    K0  C0  D0
    K2  C2  D2
    K3  C3  D3
    '''
    #依据左右资料集的index进行合并，how='outer',并打印出  
    res = pd.merge(left1, right1, left_index=True, right_index=True, how='outer')
    print(res)
    '''
          A    B    C    D
    K0   A0   B0   C0   D0
    K1   A1   B1  NaN  NaN
    K2   A2   B2   C2   D2
    K3  NaN  NaN   C3   D3
    '''
    res = pd.merge(left1, right1, left_index=True, right_index=True, how='inner')
    print(res)
    '''
         A   B   C   D
    K0  A0  B0  C0  D0
    K2  A2  B2  C2  D2
    '''
    #解决overlapping的问题
    #定义资料集
    boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
    girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})
    print(boys)
    print(girls)
    
    #使用suffixes解决overlapping的问题
    res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')
    print(res)
    '''
       age   k
    0    1  K0
    1    2  K1
    2    3  K2
       age   k
    0    4  K0
    1    5  K0
    2    6  K3
       age_boy   k  age_girl
    0        1  K0         4
    1        1  K0         5
    '''

## 8. pandas plot 画图 ##

matplotlib安装：安装好pip和numpy（numpy是matplotlib的一个基本组件）后，在cmd中输入pip install matplotlib 即可。

这次我们讲如何将数据可视化. 首先`import`我们需要用到的模块，除了 pandas，我们也需要使用 numpy 生成一些数据，这节里使用的 matplotlib 仅仅是用来 show 图片的, 即 `plt.show()`。

import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    
    #这是一个线性的数据，我们随机生成1000个数据，Series 默认的 index 就是从0开始的整数
    # 随机生成1000个数据
    data = pd.Series(np.random.randn(1000),index=np.arange(1000))
     
    # 为了方便观看效果, 我们累加这个数据
    #data.cumsum()
    
    # pandas 数据可以直接观看其可视化形式
    data.plot()
    
    plt.show()
    
    #熟悉 matplotlib 的朋友知道如果需要plot一个数据，我们可以使用 plt.plot(x=, y=)，
    #把x,y的数据作为参数存进去，但是data本来就是一个数据，所以我们可以直接plot

![70][]

Dataframe可视化

![70 1][]

除了`plot`，我经常会用到还有`scatter`，这个会显示散点图，首先给大家说一下在 pandas 中有多种方法

bar、hist、box、kde、area、scatter、hexbin

import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    
    data = pd.DataFrame(
        np.random.randn(1000,4),
        index=np.arange(1000),
        columns=list("ABCD")
        )
    data.cumsum()
    #scatter只有x，y两个属性，我们我们就可以分别给x, y指定数据
    ax = data.plot.scatter(x='A',y='B',color='DarkBlue',label='Class1')
    
    #可以再画一个在同一个ax上面，选择不一样的数据列，不同的 color 和 label
    # 将之下这个 data 画在上一个 ax 上面
    data.plot.scatter(x='A',y='C',color='LightGreen',label='Class2',ax=ax)
    plt.show()

![70 2][]

[http_pandas.pydata.org_pandas-docs_stable_io.html]: http://http//pandas.pydata.org/pandas-docs/stable/io.html
[70]: /images/20220529/b4942e4efdab42ffb82de7b31431a0df.png
[70 1]: /images/20220529/feaa35252fb6408a89fc6b8e71ed2e2c.png
[70 2]: /images/20220529/24ffc7dbafa94bed950f6821590461d3.png