python数据结构Pandas

目录

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

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

                             

Dataframe可视化

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()
data.plot()
plt.show()

                      

除了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()