Pandas库

1、掌握DataFrame数据结构的创建和基本性质。
2、掌握Pandas库的数值运算和统计分析方法。
3、掌握DataFrame缺失值处理、数据集合并等操作。
4、掌握DataFrame累计与分组操作。
5、用eval和query实现更高效的计算。

numpy的表现已经很好了，但是当我们需要处理更灵活的数据任务的时候(如为数据添加标签、 处理缺失值、分组等)，numpy 的限制就非常明显了，基于numpy而创建的pandas 库提供了一种高效的带行标签和列标签的数据结构DataFrame，完美的解决了上述问题。`

对象创建

Pandas Series对象

Series是带标签数据的一维数组

Series对象的创建

通用结构：pd.Series(data, index=index,dtype=dtype)
-data：数据，可以是列表、字典或Numpy数组

• index：索引，为可选参数
• dtype：数据类型，为可选参数

1、用列表创建

• index缺省时，默认为整数序列

import pandas as pd

data = pd.Series([1.5, 3, 4.5, 6])
print(data)
"""
0    1.5
1    3.0
2    4.5
3    6.0
dtype: float64
"""
# 添加index，数据类型若缺省，则会自动根据传入的数据判断
x = pd.Series([1.5, 3, 4.5, 6], index=["a", "b", "c", "d"])
print(x)
"""
a    1.5
b    3.0
c    4.5
d    6.0
dtype: float64
"""

注意：①数据支持多种数据类型 ②数据类型可被强制改变

2、用一维numpy数组创建

import numpy as np
import pandas as pd

x = np.arange(5)
pd.Series(x)

3、用字典创建

• 默认以键为index，值为data：pd.Series(dict)

import pandas as pd

poplation_dict = {"BeiJing": 1234,
                  "ShangHai": 2424,
                  "ShenZhen": 1303,
                  "HangZhou": 981}
pop1 = pd.Series(poplation_dict)
print(pop1)
"""
BeiJing     1234
ShangHai    2424
ShenZhen    1303
dtype: int64
"""
pop2 = pd.Series(poplation_dict, index=["BeiJing", "HangZhou", "c", "d"])
print(pop2)
"""
BeiJing     1234.0
HangZhou     981.0
c              NaN
d              NaN
dtype: float64
"""

字典创建时，如果指定index，则会到字典的键中筛选，找不到的，值则为NaN

4、data为标量

import pandas as pd

p = pd.Series(5, index=[100, 200, 300])
print(p)
"""
100    5
200    5
300    5
dtype: int64
"""

Pandas DataFrame对象

DataFrame是带标签数据的多维数组

DataFrame对象的创建

通用结构：pd.DataFrame(data, index=index, columns=columns)

• data：数据，可以为列表、字典或Numpy数组
• index：索引，为可选参数
• columns：列标签，为可选参数

1、通过Series对象创建

import pandas as pd

poplation_dict = {"BeiJing": 1234,
                  "ShangHai": 2424,
                  "ShenZhen": 1303,
                  "HangZhou": 981}
pop = pd.Series(poplation_dict)
p = pd.DataFrame(pop)
print(p)
"""
             0
BeiJing   1234
ShangHai  2424
ShenZhen  1303
HangZhou   981
"""
p = pd.DataFrame(pop, columns=["population"])
print(p)
"""
          population
BeiJing         1234
ShangHai        2424
ShenZhen        1303
HangZhou         981
"""

2、通过Series对象字典创建

注意：数量不够的会自动补齐

import pandas as pd

poplation_dict = {"BeiJing": 1234,
                  "ShangHai": 2424,
                  "ShenZhen": 1303,
                  "HangZhou": 981}
GDP_dict = {"BeiJing": 1334,
            "ShangHai": 3424,
            "ShenZhen": 5303,
            "HangZhou": 9681}
pop = pd.Series(poplation_dict)
gdp = pd.Series(GDP_dict)
p = pd.DataFrame({"population": pop,
                  "GDP": gdp,
                "country": "china"})
print(p)
"""
                population   GDP country
BeiJing         1234  1334   China
ShangHai        2424  3424   China
ShenZhen        1303  5303   China
HangZhou         981  9681   China
"""

3、通过字典列表对象创建

• 字典索引作为index，字典键作为columns
• 不存在的键，会默认为NaN

import pandas as pd

data = [{"a": i, "b": 2*i} for i in range(3)]
p = pd.DataFrame(data)

d1 = [{"a": 1, "b": 1}, {"b": 3, "c": 4}]
p1 = pd.DataFrame(d1)
print(p)
print(p1)
"""
a  b
0  0  0
1  1  2
2  2  4
     a  b    c
0  1.0  1  NaN
1  NaN  3  4.0
"""

4、通过Numpy二维数组创建

import numpy as np
import pandas as pd

p = pd.DataFrame(np.random.randint(10, size=(3, 2)), columns=["foo", "bat"], index=["a", "b", "c"])
print(p)
"""
foo  bat
a    1    3
b    0    3
c    4    6
"""

DataFrame性质

1、属性

• df.values ：返回numpy数组表示的数据
• df.index：返回行索引
• df.columns：返回行索引
• df.shape：形状
• pd.size：大小
• pd.dtypes：返回每列数据类型

2、索引

(1) 获取列

• 字典式：data["列名"]
• 对象属性式：data.列名

(2) 获取行

• 绝对索引：df.loc["index名"]
• 相对索引：df.loc[index名所对应的索引]

(3) 获取标量：df.loc["index名", "列名"]

(4) Series对象的索引：Series对象名["index名"]

3、切片

import numpy as np
import pandas as pd

dates = pd.date_range(start="2019-01-01", periods=6)
print(dates)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=["A", "B", "C", "D"])
print(df)
"""
DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04',
               '2019-01-05', '2019-01-06'],
              dtype='datetime64[ns]', freq='D')
              
                   A         B         C         D
2019-01-01  0.650976  0.195642  0.373875  0.577994
2019-01-02  1.668273 -0.437919  0.107213  2.076671
2019-01-03 -0.969602  0.264837 -0.622912 -1.233762
2019-01-04  0.893448 -0.361137 -2.014520  0.418288
2019-01-05 -1.844135 -0.933371  0.412862 -1.228276
2019-01-06 -0.406997 -0.447221  2.063793 -0.914721
"""

(1) 行切片

print(df["2019-01-01": "2019-01-03"])
print(df.loc["2019-01-01": "2019-01-03"])
print(df.loc[0: 3])    # 相对索引，取0,1,2
"""
                   A         B         C         D
2019-01-01  0.708338 -0.534477  0.409186 -1.046577
2019-01-02 -0.425397  0.050827 -1.136897 -0.120209
2019-01-03  0.191192  0.862435  0.928217  1.448118
                   A         B         C         D
2019-01-01  0.708338 -0.534477  0.409186 -1.046577
2019-01-02 -0.425397  0.050827 -1.136897 -0.120209
2019-01-03  0.191192  0.862435  0.928217  1.448118
"""

(2) 列切片

print(df.loc[:, "A": "C"])
print(df.iloc[:, 0: 3])
"""
                   A         B         C
2019-01-01 -2.569867  0.021640  0.727239
2019-01-02  0.758475  0.209617  0.941152
2019-01-03  0.002097 -0.765052 -0.901855
2019-01-04 -0.209430  0.825318 -0.334309
2019-01-05  0.522325 -2.312552 -0.384917
2019-01-06  1.301911 -0.833983  0.874232
                   A         B         C
2019-01-01 -2.569867  0.021640  0.727239
2019-01-02  0.758475  0.209617  0.941152
2019-01-03  0.002097 -0.765052 -0.901855
2019-01-04 -0.209430  0.825318 -0.334309
"""

(3) 多种多样的取值

• 行、列同时切片：df.loc["2019-01-02": "2019-01-03", "C": "D"]
• 行切片、列分散取值：df.loc["2019-01-04": "2019-01-06", ["A", "C"]]
• 行分散取值、列切片：行分散只能用相对的位置索引进行切片——df.iloc[[1, 5], 0: 3]
• 行、列均分散取值：也只能用相对位置

4、布尔索引——掩码操作

• isin()：查询每一行对应列的值是否符合——df["E"].isin(["two", "four"])

5、赋值

import pandas as pd
import numpy as np

dates = pd.date_range(start="2019-01-01", periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=["A", "B", "C", "D"])
s1 = pd.Series([1, 2, 3, 4, 5, 6], index=pd.date_range("20190101", periods=6))
df["E"] = s1
print(df)   # 增加新列
"""
 A         B         C         D  E
2019-01-01 -0.658733  0.811131 -0.407930  0.176017  1
2019-01-02  1.221720 -1.436906  1.385231 -2.073760  2
2019-01-03  0.337256  0.878561  0.871931  0.816829  3
2019-01-04  0.656371  0.801415 -0.387575 -1.179588  4
2019-01-05 -0.936013  0.892519 -0.073850  0.983318  5
2019-01-06 -1.084148  0.178440 -1.661800  1.042642  6
"""
df.loc["2019-01-01", "A"] = 0   # 等价于df.iloc[0, 1] = 1,修改赋值
# df["D"] = np.array[5]*len(df)   # 可简化为df["D"] = 5
print(df)
"""
A         B         C         D  E
2019-01-01  0.000000 -0.781050  2.360735 -1.409223  1
2019-01-02  0.390676 -1.364522 -0.678399 -0.653149  2
2019-01-03  0.254998  0.402109  0.982087 -1.918915  3
2019-01-04 -1.498213  0.777009 -1.382488 -0.586266  4
2019-01-05  0.167791 -0.642785 -2.081390 -0.532108  5
2019-01-06  0.463543 -1.630412 -1.603518  1.018081  6
"""
"""修改index和columns"""
df.index = [i for i in range(len(df))]
df.columns = [i for i in range(df.shape[1])]
print(df)
"""
  0         1         2         3  4
0  0.000000 -1.111451  1.206426 -1.584109  1
1 -0.971625 -0.399996  0.311155 -0.713528  2
2 -1.085063  0.020041 -0.300341  0.804175  3
3 -0.426142  0.061551 -0.620271 -0.003336  4
4 -1.501278 -0.134365 -0.384964 -0.502363  5
5  0.648978  0.896500 -1.167059  0.589095  6
"""

数值运算及统计分析

数据的查看

import pandas as pd
import numpy as np

dates = pd.date_range(start="2019-01-01", periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=["A", "B", "C", "D"])
"""查看前面的行"""
df.head()   # 默认5行
df.head(2)
"""查看后面的行"""
df.tail()   # 默认5行
df.tail(3)
"""查看总体信息"""
df.info()

Numpy通用函数同样适用于Pandas

• (1) 向量化运算
• (2) 矩阵化运算
• (3) 广播运算：①按行广播 ②按列广播

3、新的用法

(1) 索引对齐

• pandas会自动对齐两个的索引，没有的值用np.nan表示
• 缺省值也可用fill_value来填充：a.add(B, fill_value=0)——直接用运算符，不能填充Nan处

(2) 统计相关

• 数据种类统计

一般来说，纯粹的计算在Numpy里执行的更快：Numpy更侧重在于计算，Pandas侧重于数据处理

import pandas as pd
import numpy as np
from collections import Counter

y = np.random.randint(3, size=20)
print(y)
"""
[0 1 0 1 2 1 2 0 2 1 2 1 0 2 1 0 0 1 1 1]
"""
print(np.unique(y))
"""
[0 1 2]
"""
print(Counter(y))
"""
Counter({1: 9, 0: 6, 2: 5})
"""
y1 = pd.DataFrame(y, columns=["A"])
print(y1)
"""
    A
0   0
1   0
2   2
3   1
4   0
5   0
6   1
7   1
8   0
9   2
10  0
11  2
12  0
13  0
14  2
15  2
16  0
17  1
18  2
19  0
"""
print(np.unique(y1))    # [0 1 2]
print(y1["A"].value_counts())   
"""
2    10
0     7
1     3
Name: A, dtype: int64
"""

• 产生新的结果，并进行排序：① city_info.sort_values(by="per_GDP") ① city_info.sort_values(by="per_GDP", ascending=False)
• 行排序：data.sort_index()
• 列排序：data.sort_index(axis=1, ascending=False)
• 非空个数 ：df.count()
• 求和：df.sum() df.sum(axis=1)
• 最小值、最大值：df.min() df.max(axis=1) df.idxmax()#坐标
• 均值：df.mean() df.var()
• 中位数：df.median()
• 标准差：df.std()
• 众数：data.mode()
• 75%分位数：df.quantile(0.75)
• 一网打尽：df.describe()
• 相关性系数和协方差：① df.corr() ②df.corrwith(df["A"]) # 某一列的相关信息
• 自定义输出：apply(method)——使用method方法默认对每一列进行相应的操作

df.apply(lambda x: x.max()-x.min())

缺失值处理

• 1、发现缺失值：有None、字符串等，数据类型全部变为object，它比int和float更消耗资源注意：np.nan是一种特殊的浮点数
• 2、删除缺失值：①删除整行：data.dropna() ②删除整列：data.dropna(axis="columns", how="all | any")
• 3、填充缺失值：①用均值进行替换：data.fillna(value=5) ②用均值进行替换：data.fillna(value=data.mean())

合并数据

import pandas as pd

"""构造一个生产DataFrame函数"""
def make_df(cols, ind):
    data = {c: [str(c)+str(i) for i in ind] for c in cols}
    return pd.DataFrame(data, ind)

df_1 = make_df("AB", [1, 2])
df_2 = make_df("AB", [3, 4])
print(df_1)
print(df_2)
"""
 A   B
1  A1  B1
2  A2  B2
    A   B
3  A3  B3
4  A4  B4
"""
"""垂直合并"""
pd_v = pd.concat([df_1, df_2])
print(pd_v)
"""
A   B
1  A1  B1
2  A2  B2
3  A3  B3
4  A4  B4
"""
"""水平合并"""
df_3 = make_df("CD", [1, 2])
pd_h = pd.concat([df_1, df_3], axis=1)
print(pd_h)
"""
    A   B   C   D
1  A1  B1  C1  D1
2  A2  B2  C2  D2
"""
"""行重叠"""
df_5 = make_df("AB", [1, 2])
df_6 = make_df("AB", [1, 2])
print(pd.concat([df_5, df_6], ignore_index=True))
"""
A   B
0  A1  B1
1  A2  B2
2  A1  B1
3  A2  B2
"""
"""对齐合并merge()"""
df_9 = make_df("AB", [1, 2])
df_10 = make_df("BC", [1, 2])
print(pd.merge(df_9, df_10))
"""
  A   B   C
0  A1  B1  C1
1  A2  B2  C2
"""

分组和数据透视表

(1) 分组

• 延迟计算：df.groupby("key") df.groupby("key").sum()

for i in df.groupby("key"):
    print(str(i))

• 按列取值： df.groupby("key")["data2"].sum()
• 按组迭代

for data, group in df.groupby("key"):
    print("{0:5} shape={1}".format(data, group.shape))

• 过滤：df.groupby("key").filter(filter_func)
• 转换：df.groupby("key").transform(lambda x: x-x.mean())
• apply()：
• 用字典将索引映射到分组
  [[]]：dataframe类型
  []：Series类型

数据透视表：数据集.pivot_table("需要查询列的名", index="index名", columns="class")

其他

• (1) 向量化字符串操作
• (2) 处理时间序列
• (3) 多级索引：用于多维数据高性能的Pandas：eval()

减少了复合代数式在计算中间过程的内存分配高性能的Pandas：query()
当处理小数组时，普通方法反而更快