python综合学习五之Pandas

Miracle 发布于2019-07-30 17:38 / 565人阅读

摘要：后者选择到标签之间的数据，并且包括这两个标签。根据位置设置和我们可以利用索引或者标签确定需要修改值的位置。通过上边的学习，我们学会了如何对中在自己想要的地方赋值或者增加数据。

这一节，主要深入学习Pandas的用法。

一、筛选

先建立一个 6X4 的矩阵数据。

dates = pd.date_range("20180830", periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=["A","B","C","D"])
print(df)

打印：

             A   B   C   D
2018-08-30   0   1   2   3
2018-08-31   4   5   6   7
2018-09-01   8   9  10  11
2018-09-02  12  13  14  15
2018-09-03  16  17  18  19
2018-09-04  20  21  22  23

简单的筛选

如果我们想选取 DataFrame 中的数据，下面描述了两种途径, 他们都能达到同一个目的：

print(df["A"])
print(df.A)

"""
2018-08-30     0
2018-08-31     4
2018-09-01     8
2018-09-02    12
2018-09-03    16
2018-09-04    20
Freq: D, Name: A, dtype: int64
"""

让选择跨越多行或多列:

print(df[0:3])
 
"""
            A  B   C   D
2018-08-30  0  1   2   3
2018-08-31  4  5   6   7
2018-09-01  8  9  10  11
"""

print(df["20180830":"20180901"])

"""
            A  B   C   D
2018-08-30  0  1   2   3
2018-08-31  4  5   6   7
2018-09-01  8  9  10  11
"""

如果df[3:3]将会是一个空对象。后者选择20180830到20180901标签之间的数据，并且包括这两个标签。

根据标签loc

同样我们可以使用标签来选择数据 loc, 本例子主要通过标签名字选择某一行数据，或者通过选择某行或者所有行（:代表所有行）然后选其中某一列或几列数据。:

print(df.loc["20130102"])
"""
A    4
B    5
C    6
D    7
Name: 2013-01-02 00:00:00, dtype: int64
"""

print(df.loc[:,["A","B"]]) 
"""
             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
"""

print(df.loc["20130102",["A","B"]])
"""
A    4
B    5
Name: 2013-01-02 00:00:00, dtype: int64
"""

根据序列iloc

另外我们可以采用位置进行选择 iloc, 在这里我们可以通过位置选择在不同情况下所需要的数据例如选某一个，连续选或者跨行选等操作。

print(df.iloc[3,1])
# 13

print(df.iloc[3:5,1:3])
"""
             B   C
2013-01-04  13  14
2013-01-05  17  18
"""

print(df.iloc[[1,3,5],1:3])
"""
             B   C
2013-01-02   5   6
2013-01-04  13  14
2013-01-06  21  22

"""

在这里我们可以通过位置选择在不同情况下所需要的数据, 例如选某一个，连续选或者跨行选等操作。

根据混合的这两种 ix

当然我们可以采用混合选择 ix, 其中选择’A’和’C’的两列，并选择前三行的数据。

print(df.ix[:3,["A","C"]])
"""
            A   C
2013-01-01  0   2
2013-01-02  4   6
2013-01-03  8  10
"""

二、设置值

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

首先建立了一个 6X4 的矩阵数据。

# -*- coding:utf-8 -*-

"""
@author: Corwien
@file: pd_value.py
@time: 18/8/31 00:59
"""

import pandas as pd
import numpy as np

dates = pd.date_range("20180101", periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=["A","B","C","D"])

print(df)

"""
             A   B   C   D
2018-01-01   0   1   2   3
2018-01-02   4   5   6   7
2018-01-03   8   9  10  11
2018-01-04  12  13  14  15
2018-01-05  16  17  18  19
2018-01-06  20  21  22  23
"""

根据位置设置loc和iloc

我们可以利用索引或者标签确定需要修改值的位置。

df.iloc[2,3] = 1111
df.loc["20180103", "B"] = 2222

print(df)

打印：

             A     B   C     D
2018-01-01   0     1   2     3
2018-01-02   4     5   6     7
2018-01-03   8  2222  10  1111
2018-01-04  12    13  14    15
2018-01-05  16    17  18    19
2018-01-06  20    21  22    23

根据条件设置

如果现在的判断条件是这样, 我们想要更改B中的数, 而更改的位置是取决于 A 的. 对于A大于4的位置. 更改B在相应位置上的数为0.

df.B[df.A>4] = 0
print(df)

原数据：

             A     B   C     D
2018-01-01   0     1   2     3
2018-01-02   4     5   6     7
2018-01-03   8  2222  10  1111
2018-01-04  12    13  14    15
2018-01-05  16    17  18    19
2018-01-06  20    21  22    23

df.B[df.A>4] = 0更改后的数据：

    A  B   C     D
2018-01-01   0  1   2     3
2018-01-02   4  5   6     7
2018-01-03   8  0  10  1111
2018-01-04  12  0  14    15
2018-01-05  16  0  18    19
2018-01-06  20  0  22    23

按行或列设置

如果对整列做批处理, 加上一列 ‘F’, 并将 F 列全改为 NaN, 如下:

df["F"] = np.nan
"""
          A  B   C     D   F
2018-01-01   0  1   2     3 NaN
2018-01-02   4  5   6     7 NaN
2018-01-03   8  0  10  1111 NaN
2018-01-04  12  0  14    15 NaN
2018-01-05  16  0  18    19 NaN
2018-01-06  20  0  22    23 NaN
"""

添加数据

用上面的方法也可以加上 Series 序列（但是长度必须对齐）。

        A  B   C     D   F  E
2018-01-01   0  1   2     3 NaN  1
2018-01-02   4  5   6     7 NaN  2
2018-01-03   8  0  10  1111 NaN  3
2018-01-04  12  0  14    15 NaN  4
2018-01-05  16  0  18    19 NaN  5
2018-01-06  20  0  22    23 NaN  6

通过上边的学习，我们学会了如何对 DataFrame 中在自己想要的地方赋值或者增加数据。

三、处理丢失数据

创建含 NaN 的矩阵

有时候我们导入或处理数据, 会产生一些空的或者是 NaN 数据,如何删除或者是填补这些 NaN 数据就是我们今天所要提到的内容.

建立了一个6X4的矩阵数据并且把两个位置置为空.

dates = pd.date_range("20130101", periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=["A","B","C","D"])
df.iloc[0,1] = np.nan
df.iloc[1,2] = np.nan
"""
             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
"""

pd.dropna()

如果想直接去掉有 NaN 的行或列, 可以使用 dropna

df.dropna(
    axis=0,     # 0: 对行进行操作; 1: 对列进行操作
    how="any"   # "any": 只要存在 NaN 就 drop 掉; "all": 必须全部是 NaN 才 drop 
    ) 
"""
             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
"""

pd.fillna()

如果是将 NaN 的值用其他值代替, 比如代替成 0:

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
"""

pd.isnull()

判断是否有缺失数据 NaN, 为 True 表示缺失数据:

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:

np.any(df.isnull()) == True  
# True

四、导入导出 说明

pandas可以读取与存取的资料格式有很多种，像csv、excel、json、html与pickle等…，详细请看官方说明文件

读取csv

import pandas as pd #加载模块

#读取csv
data = pd.read_csv("student.csv")

#打印出data
print(data)

打印结果：

/Users/kaiyiwang/anaconda2/bin/python /Users/kaiyiwang/Code/python/baseLearn/pandas/pd_csv.py
    Student ID  name   age  gender
0         1100  Kelly   22  Female
1         1101    Clo   21  Female
2         1102  Tilly   22  Female
3         1103   Tony   24    Male
4         1104  David   20    Male
5         1105  Catty   22  Female
6         1106      M    3  Female
7         1107      N   43    Male
8         1108      A   13    Male
9         1109      S   12    Male
10        1110  David   33    Male
11        1111     Dw    3  Female
12        1112      Q   23    Male
13        1113      W   21  Female

将资料存取成pickle

data.to_pickle("student.pickle")

五、合并concat

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

axis(合并方向)

axis=0是预设值，因此未设定任何参数时，函数默认axis=0。

# -*- coding:utf-8 -*-

"""
@author: Corwien
@file: pd_concat.py
@time: 18/9/1 10:28
"""
   
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"])

# print df1

#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是0, 1, 2, 0, 1, 2, 0, 1, 2，若要将index重置，请看例子二。

ignore_index (重置 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
# 7  2.0  2.0  2.0  2.0
# 8  2.0  2.0  2.0  2.0

结果的index变0, 1, 2, 3, 4, 5, 6, 7, 8。

join (合并方式)

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

#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=["a","b","c","d"], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=["b","c","d","e"], index=[2,3,4])

print(df1)
print("======
")

print(df2)
print("======
")

#纵向"外"合并df1与df2
res = pd.concat([df1, df2], axis=0, join="outer")

print(res)

结果打印：

    a    b    c    d
1  0.0  0.0  0.0  0.0
2  0.0  0.0  0.0  0.0
3  0.0  0.0  0.0  0.0
======

     b    c    d    e
2  1.0  1.0  1.0  1.0
3  1.0  1.0  1.0  1.0
4  1.0  1.0  1.0  1.0
======

     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
4  NaN  1.0  1.0  1.0  1.0

原理同上个例子的说明，但只有相同的column合并在一起，其他的会被抛弃。

#承上一个例子

#纵向"内"合并df1与df2
res = pd.concat([df1, df2], 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([df1, df2], 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合并)

#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=["a","b","c","d"], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=["b","c","d","e"], index=[2,3,4])

#依照`df1.index`进行横向合并
res = pd.concat([df1, df2], axis=1, join_axes=[df1.index])

#打印结果
print(res)
#     a    b    c    d    b    c    d    e
# 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
# 3  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0

#移除join_axes，并打印结果
res = pd.concat([df1, df2], axis=1)
print(res)
#     a    b    c    d    b    c    d    e
# 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
# 3  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0
# 4  NaN  NaN  NaN  NaN  1.0  1.0  1.0  1.0

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))*1, columns=["a","b","c","d"])
s1 = pd.Series([1,2,3,4], index=["a","b","c","d"])

#将df2合并到df1的下面，以及重置index，并打印出结果
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  1.0  1.0  1.0  1.0
# 7  1.0  1.0  1.0  1.0
# 8  1.0  1.0  1.0  1.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

六、合并merge

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

依据一组key合并

import pandas as pd

#定义资料集并打印出
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)
#    A   B key
# 0  A0  B0  K0
# 1  A1  B1  K1
# 2  A2  B2  K2
# 3  A3  B3  K3

print(right)
#    C   D key
# 0  C0  D0  K0
# 1  C1  D1  K1
# 2  C2  D2  K2
# 3  C3  D3  K3

#依据key column合并，并打印出
res = pd.merge(left, right, on="key")

print(res)
     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

依据两组key合并

合并时有4种方法how = ["left", "right", "outer", "inner"]，预设值how="inner"。

import pandas as pd

#定义资料集并打印出
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"]})

print(left)
#    A   B key1 key2
# 0  A0  B0   K0   K0
# 1  A1  B1   K0   K1
# 2  A2  B2   K1   K0
# 3  A3  B3   K2   K1

print(right)
#    C   D key1 key2
# 0  C0  D0   K0   K0
# 1  C1  D1   K1   K0
# 2  C2  D2   K1   K0
# 3  C3  D3   K2   K0

#依据key1与key2 columns进行合并，并打印出四种结果["left", "right", "outer", "inner"]
res = pd.merge(left, right, 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(left, right, 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(left, right, 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(left, right, 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会将合并的记录放在新的一列。

import pandas as pd

#定义资料集并打印出
df1 = pd.DataFrame({"col1":[0,1], "col_left":["a","b"]})
df2 = pd.DataFrame({"col1":[1,2,2],"col_right":[2,2,2]})

print(df1)
#   col1 col_left
# 0     0        a
# 1     1        b

print(df2)
#   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.0        a        NaN   left_only
# 1   1.0        b        2.0        both
# 2   2.0      NaN        2.0  right_only
# 3   2.0      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.0        a        NaN        left_only
# 1   1.0        b        2.0             both
# 2   2.0      NaN        2.0       right_only
# 3   2.0      NaN        2.0       right_only

依据index合并

import pandas as pd

#定义资料集并打印出
left = pd.DataFrame({"A": ["A0", "A1", "A2"],
                     "B": ["B0", "B1", "B2"]},
                     index=["K0", "K1", "K2"])
right = pd.DataFrame({"C": ["C0", "C2", "C3"],
                      "D": ["D0", "D2", "D3"]},
                     index=["K0", "K2", "K3"])

print(left)
#     A   B
# K0  A0  B0
# K1  A1  B1
# K2  A2  B2

print(right)
#     C   D
# K0  C0  D0
# K2  C2  D2
# K3  C3  D3

#依据左右资料集的index进行合并，how="outer",并打印出
res = pd.merge(left, right, 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

#依据左右资料集的index进行合并，how="inner",并打印出
res = pd.merge(left, right, 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的问题

import pandas as pd

#定义资料集
boys = pd.DataFrame({"k": ["K0", "K1", "K2"], "age": [1, 2, 3]})
girls = pd.DataFrame({"k": ["K0", "K0", "K3"], "age": [4, 5, 6]})

#使用suffixes解决overlapping的问题
res = pd.merge(boys, girls, on="k", suffixes=["_boy", "_girl"], how="inner")
print(res)
#    age_boy   k  age_girl
# 0        1  K0         4
# 1        1  K0         5

七、plot出图

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

创建一个Series

这是一个线性的数据，我们随机生成1000个数据，Series 默认的 index 就是从0开始的整数，但是这里我显式赋值以便让大家看的更清楚

# -*- coding:utf-8 -*-

"""
@author: Corwien
@file: pd_plot.py
@time: 18/9/1 10:59
"""
   
import pandas as pd #加载模块
import numpy as np
import matplotlib.pyplot as plt

# 随机生成1000个数据
data = pd.Series(np.random.randn(1000), index=np.arange(1000))

# print(data)
# 为了方便观看效果, 我们累加这个数据
data.cumsum()

# print "
=======
"
# print(data)

# pandas 数据可以直接观看其可视化形式
data.plot()

plt.show()

数据打印：

0      1.055920
1      2.151946
2      0.376157
3     -1.279114
4      0.584658
5      1.178072
6      0.873750
7     -1.039058
8     -0.892274
9     -0.532982
10     0.040962

         ...   

990    0.663714
991    0.013612
992   -1.993561
993    0.238042
994    0.696388
995    1.275367
996   -1.660392
997   -0.795660
998    1.062841
999    0.200333
Length: 1000, dtype: float64

Dataframe 可视化

我们生成一个1000*4 的DataFrame，并对他们累加

data = pd.DataFrame(
    np.random.randn(1000,4),
    index=np.arange(1000),
    columns=list("ABCD")
    )
data.cumsum()
data.plot()
plt.show()

结果打印：

            A         B         C         D
0   -0.240516  1.689101  2.195897 -1.011582
1   -1.067106  1.908657 -0.534270  0.016602
2   -0.239367  0.033567 -0.782701  0.746416
3   -0.104149 -0.756916 -0.984102  0.126436
4   -3.228259 -0.380957 -0.129879  0.738176
5    0.454551 -0.213664  0.200234  0.920599
6   -0.931042  0.731300 -1.424736  0.185456
7    1.823043  0.333958 -0.375364  0.371867
8   -1.407975  0.209401 -1.387218 -0.236411
9   -0.286918 -0.599334 -1.266337 -0.707990
10  -0.205903 -0.942891  1.650707  0.467071

..        ...       ...       ...       ...

994 -1.143698  1.159974 -0.433339 -0.705888
995  0.507159 -0.295003  0.534483 -0.925546
996  1.470531 -0.484951  0.087811 -1.393423
997 -0.225130  0.717332 -0.117851 -0.849506
998 -1.078925 -0.688264 -0.133773 -0.803970
999 -0.589185  0.649868  1.436989 -0.553600

[1000 rows x 4 columns]

这个就是我们刚刚生成的4个column`的数据，因为有4组数据，所以4组数据会分别plot出来。plot 可以指定很多参数，具体的用法大家可以自己查一下这里

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

bar

hist

box

ode

area

scatter

hexbin

但是我们今天不会一一介绍，主要说一下 plot 和 scatter. 因为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()

下面就是我plot出来的图片

这就是我们今天讲的两种呈现方式，一种是线性的方式，一种是散点图。

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/42320.html

Python机器学习入门资料整理

摘要：在基本语法入门之后，就要准备选一个研究方向了。是自己比较感兴趣的方向，可是，导师这边的数据处理肯定不能由我做主了。真的挺愁人的还有几个月就要进行春季实习招聘了，加油总结一下机器学习方面的资料吧。在python基本语法入门之后，就要准备选一个研究方向了。Web是自己比较感兴趣的方向，可是，导师这边的数据处理肯定不能由我做主了。paper、peper、paper……真的挺愁人的还有几个...

Rango 2019-07-31 11:41 评论0 收藏0
python综合学习三之Numpy和Pandas

摘要：本章学习两个科学运算当中最为重要的两个模块，一个是一个是。这种工具可用来存储和处理大型矩阵，比自身的嵌套列表结构要高效的多该结构也可以用来表示矩阵。专为进行严格的数字处理而产生。可以通过函数对相应值进行打印检验。本章学习两个科学运算当中最为重要的两个模块，一个是 numpy,一个是 pandas。任何关于数据分析的模块都少不了它们两个。一、numpy & pandas特点 NumP...

tinylcy 2019-07-30 17:37 评论0 收藏0
python综合学习四之Numpy和Pandas(下)

摘要：一基础运算二通过上一节的学习，我们可以了解到一部分矩阵中元素的计算和查找操作。相应的，在矩阵的个元素中，最小值即，对应索引，最大值为，对应索引为。确认是否与相同。要使用，首先需要了解他主要两个数据结构和。这一节继续学习Numpy和Pandas。一、numpy基础运算二通过上一节的学习，我们可以了解到一部分矩阵中元素的计算和查找操作。然而在日常使用中，对应元素的索引也是非常重要的。...

yeyan1996 2019-07-30 17:36 评论0 收藏0
零基础如何学爬虫技术

摘要：楚江数据是专业的互联网数据技术服务，现整理出零基础如何学爬虫技术以供学习，。本文来源知乎作者路人甲链接楚江数据提供网站数据采集和爬虫软件定制开发服务，服务范围涵盖社交网络电子商务分类信息学术研究等。楚江数据是专业的互联网数据技术服务，现整理出零基础如何学爬虫技术以供学习，http://www.chujiangdata.com。第一：Python爬虫学习系列教程（来源于某博主：htt...

KunMinX 2019-07-25 11:29 评论0 收藏0