数据分析(4)--Pandas+DataFrame

DataFrame类型

DataFrame是一个多维数据类型。因为通常使用二维数据，因此，我们可以将DataFrame理解成类似excel的表格型数据，由多列组成，每个列的类型可以不同。
因为DataFrame是多维数据类型，因此，DataFrame既有行索引，也有列索引。

创建方式

我们可以使用如下的方式创建（初始化）DataFrame类型的对象（常用）：

• 二维数组结构（列表,ndarray数组，DataFrame等）类型。
• 字典类型，key为列名，value为一维数组结构（列表，ndarray数组,Series等）。

说明：

• 如果没有显式指定行与列索引，则会自动生成以0开始的整数值索引。我们可以在创建DataFrame对象时，通过index与columns参数指定。
• 可以通过head，tail访问前 / 后N行记录（数据）。

df = pd.DataFrame({0:[1, 2, 3], 1:5})
# 创建DataFrame类型。
# 使用二维数组结构来创建。
# df = pd.DataFrame([[10, 20, 39], [43, 51, 62]])
# df2 = pd.DataFrame([[5, 3, 10], [11, 35, 86]])
# print(df)
# print(df)

# a = np.array([1, 2, 3, 4, 5])
# print(a)
# a

# display函数。
# display与print比较相似，都是在控制台上输出结构。不同的是，display在某些对象上，显示的会比print
# 更加友好。使用display与我们直接求值输出效果相同，但是，直接求值输出仅会显示最后一个求值的结果。
# 注意：display不是python的内建函数。是否IPython中扩展的函数。
# df
# df2
# display(df)
# display(df2)
# 一次输出多个值。
# display(df, df2)

# 通过字典创建DataFrame类型的对象。字典中每个键值对为DataFrame对象的一列。
# key就是我们的列标签（列名或列索引），value为该列对应的值。
# df = pd.DataFrame({0: [10, 42], 1: [20, 51], 2:[39, 62]})
# df = pd.DataFrame({"A": [10, 42], "B": [20, 51], "C":[39, 62]})
# display(df)

# 如果没有显式指定DataFrame的索引（行，列），则会创建从0开始，1为增量的索引序列。
# 我们也可以通过index与columns属性来自定义索引。index表示行索引，columns表示列索引。
# df = pd.DataFrame([[10, 20, 39], [43, 51, 62]], index=["a", "b"], columns=["c", "d", "e"])
df = pd.DataFrame(np.random.random(size=(100, 5)))
# 我们也可以使用head与tail方法来查看DataFrame对象的前（后）n条记录。默认为5。
# df.head()
# df.tail(3)

相关属性

• index
• columns
• values
• shape
• ndim
• dtypes

说明：

• 可以通过index访问行索引，columns访问列索引，values访问数据，其中index与columns也可以进行设置（修改）。
• 可以为DataFrame的index与columns属性指定name属性值。
• DataFrame的数据不能超过二维。

# index 表示行索引，columns表示列索引。
df = pd.DataFrame(np.random.random(size=(4, 5)))
# 我们也可以在创建DataFrame对象之后，再去修改index与columns属性。
df.index = ["a", "b", "c", "d"]
df.columns = [10, 11, 12, 13, 14]
display(df)
# index与columns返回DataFrame的索引对象。
# type(df.index), type(df.columns)

# values 返回DataFrame的数据（二维数组类型）
# display(df.values)

# shape 返回数据的形状。
# display(df.shape)
# 返回数据的维度。
# display(df.ndim)
# 返回数据的类型。(每列的数据类型。)
# display(df.dtypes)

# 我们可以为index与columns指定name属性。
# df.index.name = "行索引名称"
# df.columns.name = "列索引名称"
# display(df)

# DataFrame的数据维度不能超过二维
# a = np.random.random((3, 3, 3))
# df = pd.DataFrame(a)

DataFrame相关操作

假设df为DataFrame类型的对象。

列操作

• 获取列【哪个更好些？】
  df[列索引]
  df.列索引
• 增加（修改）列：df[列索引] = 列数据
• 删除列
  del df[列索引]
  df.pop(列索引)
  df.drop(列索引或数组)

行操作

• 获取行
  df.loc 根据标签进行索引。
  df.iloc 根据位置进行索引。
  df.ix 混合索引。先根据标签索引，如果没有找到，则根据位置进行索引（前提是标签不是数值类型）。【已不建议使用】
• 增加行：append【多次使用append增加行会比连接计算量更大，可考虑使用pd.concat来代替。】
• 删除行
  df.drop(行索引或数组)

行列混合操作：

• 先获取行，再获取列。
• 先获取列，在获取行。

说明：

• drop方法既可以删除行，也可以删除列，通过axis指定轴方向。【可以原地修改，也可以返回修改之后的结果。】
• 通过df[索引]访问是对列进行操作。
• 通过df[切片]访问是对行进行操作。【先按标签，然后按索引访问。如果标签是数值类型，则仅会按标签进行匹配。】
• 通过布尔索引是对行进行操作。
• 通过数组索引是对列进行操作。

在对行或列进行操作时，如果针对多行（列）进行操作？如果是不连续的呢？

df = pd.DataFrame(np.random.random((5, 4)), columns=["a", 0, "c", "d"])
# display(df)
# 获取列。通过df[标签]永远是获取列。
# 获取列，我们可以使用df["列名"]，也可以使用df.列名。建议使用第一种方式。因为第一种方式局限性少，
# 当列名不是合法的标示符时，也能够使用。
# display(df[0])
# 错误。
# display(df.0)

# 增加 / 修改列
# 增加与修改列的语法是相同的，如果列名（列索引）在DataFrame中存在，则修改该列，
# 如果不存在，则增加一列。
# df["e"] = [10, 20, 30, 40, 50]
# 也可以使用标量。
# df["e"] = 30
# df["a"] = [30, 40, 50, 60, 70]
# display(df)

# 删除
# del df["a"]
# df.pop("a")
# display(df.drop("a", axis=1))
# df = df.drop("a", axis=1)
# df.drop("a", axis=1, inplace=True)
# display(df)
# display(df)

# 对DataFrame行进行的操作
df = pd.DataFrame(np.random.random((5, 3)), index=["a", "b", "c", "d", "e"])
display(df)
# 获取行
# 根据标签获取一行。
# display(df.loc["b"])
# 根据位置获取一行。
# display(df.iloc[1])
# 不建议使用ix来获取行。因为会带来不必要的混淆。
# df = df.append(pd.Series([300, 200, 100], name="新增"))
# display(df)

# df2 = pd.DataFrame(np.random.random((3, 3)), index=["a", "b", "c"])
# 如果要增加一行（少量的行），可以使用append。如果是增加多行，建议使用concat。
# r = pd.concat([df, df2], axis=1)
# display(r)

# 删除行
# df.drop("a", axis=0, inplace=True)
# 删除多行（列）
# df.drop(["a", "c"])
# df.drop([0, 2], axis=1)

# 行列混合操作
# 先获取行，再获取列。
# df.loc["a"].loc[1]
# 先获取列，再获取行。
# df[2].loc["a"]

# 混淆之处
# df[索引] 获取列
# df[切片] 获取行
# 因此，如果需要对行进行切片，建议df.loc[切片]或df.iloc[切片]

# 既然df[切片]是获取行，那如果要获取多个列呢？
# df[ [] ]  通过数组进行索引提取元素，是对列进行操作。
# df[[0, 1]]
# df.iloc[:, :-1]

# 通过布尔类型数组提取元素，是对行进行的操作。
# 如果布尔类型的数组是一维结构，则值为True，提取对应位置的该行，否则丢弃该行。
# b = [True, True, False, False, False]
# df[b]
# 如果布尔类型的数组是二维结构，如果值为True，则保留对应位置的元素，否则，将对应位置的元素置为NaN。（空值）
df[df > 0.5]

# 当我们选择（截取）DataFrame的时候。如果我们单纯选择一行（列），返回的是Series类型。
df = pd.DataFrame(np.random.random((5, 3)), columns=["a", "b", "c"], index=["r1", "r2", "r3", "r4", "r5"])
# type(df["a"])
# type(df.iloc[0])
# 当我们使用切片选择多行多列的时候，返回DataFrame类型。
# type(df.iloc[0:2, 0:2])
# 多行一列，或一行多列，返回Series类型。
# type(df.iloc[1, 0:2])
# type(df.iloc[0:2, 0])
# 如果使用切片，即使截取出的结果是单行（单列），返回的类型，依然是DataFrame类型。
# type(df.iloc[1:2, 0:2])

DataFrame结构

DataFrame的一行或一列，都是Series类型的对象。对于行来说，Series对象的name属性值就是行索引名称，其内部元素的值，就是对应的列索引名称。对于列来说，Series对象的name属性值就是列索引名称，其内部元素的值，就是对应的行索引名称。

DataFrame运算

DataFrame的一行或一列都是Series类型的对象。因此，DataFrame可以近似看做是多行或多列Series构成的，Series对象支持的很多操作，对于DataFrame对象也同样适用，我们可以参考之前Series对象的操作。

• 转置
• DataFrame进行运算时，会根据行索引与列索引进行对齐。当索引无法匹配时，产生空值（NaN）。如果不想产生空值，可以使用DataFrame提供的运算函数来代替运算符计算，通过fill_value参数来指定填充值。
• DataFrame与Series混合运算。【默认Series索引匹配DataFrame的列索引，然后进行行广播。可以通过DataFrame对象的运算方法的axis参数，指定匹配方式（匹配行索引还是列索引）。】

df = pd.DataFrame(np.arange(16).reshape(4, 4))
df2 = pd.DataFrame(np.arange(16, 32).reshape(4, 4), columns=[1, 2, 3, 4])
# display(df, df2)
# 转置
# display(df.T)
# 会根据行索引与列索引对齐，无法匹配，则产生NaN。
# display(df + df2)
# 可以使用DataFrame提供的运算方法，代替运算符。这样可以填充空值。
# df.add(df2, fill_value=0)
s = pd.Series([100, 200, 300, 400])
# DataFrame与Series进行混合运算，Series会匹配DataFrame的列索引。
# df + s
# 如果希望Series能够匹配DataFrame的行索引，我们可以通过函数计算，同时将axis的值设置为0或index。
df.add(s, axis=0)

排序

索引排序

Series与DataFrame对象可以使用sort_index方法对索引进行排序。DataFrame对象在排序时，还可以通过axis参数来指定轴（行索引还是列索引）。也可以通过ascending参数指定升序还是降序。

值排序

Series与DataFrame对象可以使用sort_values方法对值进行排序。

# 对索引进行排序
df = pd.DataFrame(np.arange(9).reshape(3, 3), index=["c", "a", "b"], columns=["y", "k", "x"])
# 默认对行索引，升序排列
# df.sort_index()
# 可以通过axis参数来指定对行（列）排序。
# df.sort_index(axis=1)
# 我们可以指定ascending来控制是升序排列还是降序排列，默认是升序排列。
# df.sort_index(ascending=False)

# 对值进行排序。
# df.sort_values("c", axis=1)
# df.sort_values("y", ascending=False)

# 对索引或对值进行排序时，可以指定inplace=True，进行就地修改。

索引对象

Series(DataFrame)的index或者DataFrame的columns就是一个索引对象。

• 索引对象可以向数组那样进行索引访问。
• 索引对象是不可修改的。

统计相关方法

• mean / sum / count
• max / min
• cumsum / cumprod
• argmax / argmin
• idxmax / idxmin
• var / std
• corr / cov

df = pd.DataFrame([[8, 3, 4], [1, 2, 10]])
display(df)
df.idxmax(axis=1)

其他

• unique
• value_counts

# s = pd.Series([1, 5, 4, 1, 5])
# 去掉重复的值。（无排序的功能）
# s.unique()

df = pd.DataFrame(np.random.randint(1, 10, size=(100, 3)))
df[2].value_counts(sort=True, ascending=True)