Numpy和amp;pandas基本使用方法(机器学习入门)

_Brooke_

2024-06-19 帮助1人

目录

一、Numpy

1.初识ndarray对象(同类型数据的集合)

2.创建一个ndarray对象

3.数据类型：

4.用dtype生成数据类型对象

5.创建数组/矩阵

①numpy.empty()

②numpy.zeros

③ numpy.ones

④numpy.arange

⑤ numpy.asarray

⑥ numpy.frombuffer

⑦利用numpy.random模块生成数组

6.切片和索引

①NumPy 切片

法一：使用slice函数进行切片编辑

法二：直接使用下标索引

    补充：视图和副本

② Numpy索引

法一：使用索引数组进行索引访问

法二：布尔索引

法三：花式索引

7.Numpy数组运算和操作

①修改数组形状

（a）numpy.reshape

（b） numpy.ndarray.flatten

②矩阵的转置：

numpy.transpose

③修改数组维度

（a）numpy.expand_dims

（b）numpy.squeeze

④连接数组

（a）numpy.concatenate

（b）numpy.stack

⑧分隔数组

numpy.split

⑨数组元素的添加与删除

（a）numpy.resize

（b）numpy.append

（c）numpy.insert

（d）numpy.delete

（e） numpy.unique

8.Numpy基本计算&数组统计计算

①基本计算

②数组统计计算

9.广播机制介绍：

①广播的原则：

②例子

10.深浅拷贝问题

①无拷贝：（相当于引用！）

②视图or浅拷贝

   ③副本or深拷贝

二、pandas

1.数据结构：

①Series

（a）创建

（b）切片和索引

（c）Series与Dict编辑

（d）基本运算 * / 等同numpy

（e）自动对齐编辑

（f）缺失值检测

   (G)name属性 &index、values属性

② DataFrame

（A）创建编辑

（B）基本属性与整体情况查询

(C)索引

(i)常规使用ndarray式的索引方法

(ii) 使用 .loc ->根据index和column名进行操作，.loc[...]

(iii)使用 .iloc

(iv)布尔值索引

（D）层次化索引

（i） Series 层次化索引

(ii) DataFrame 层次化索引

(E)数据的合并

（i）merge共同列

（ii）Join：更为方便的实现行索引上的合并

(F)分割与组合

2.读写数据

①read_csv 编辑

②read_table编辑

③ to_csv编辑

3.缺失值数据处理

4. 数据特征分析

①排序

                        sort_index方法

sort_values 方法

  ②.基本统计数据

③.累计统计数据

④.相关性分析

一、Numpy

1.初识ndarray对象(同类型数据的集合)

学新通

2.创建一个ndarray对象

学新通

3.数据类型：

4.用dtype生成数据类型对象

学新通

对于组合数据类型：

学新通

例：将构成一个学生整体的数据类型对象学新通

学新通

5.创建数组/矩阵

①numpy.empty()

学新通

②numpy.zeros

学新通

③ numpy.ones

学新通

numpy.ones_like() 学新通

④numpy.arange

学新通

#注意：对于浮点参数（参数为浮点），结果的长度为（stop - start）/ step）由于浮点溢出，此规则可能导致最后一个元素大于stop。因此要特别注意

⑤ numpy.asarray

import numpy as np
[in]: a = [1, 2, 3, 4]
[in]: new_arr = np.asarray(a)
[in]: print(new_arr)
[out]: [1 2 3 4]
[in]: new_arr = np.asarray(a , dtype=np.float32)
[in]: print(new_arr)
[out]: [1. 2. 3. 4.]

⑥ numpy.frombuffer

numpy.frombuffer 用于实现动态数组，将数据以流的形式读入转化成ndarray对象

import numpy as np
[in]: s = b'Hello World' #buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b
[in]: a = np.frombuffer(s, dtype = 'S1')
[in]: print (a)
[out]: [b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']

⑦利用`numpy.random`模块生成数组

总体来说，numpy.random模块分为四个部分，对应四种功能：

简单随机数：产生简单的随机数据，可以是任何维度

排列：将所给对象随机排列

分布：产生指定分布的数据，如高斯分布等

生成器：种随机数种子，根据同一种子产生的随机数是相同的

学新通

6.切片和索引

①NumPy 切片

法一：使用slice函数进行切片

相当于就是将slice的第一个参数当做切片的start，第二个参数当做切片的end，第三个参数当做切片的步长

法二：直接使用下标索引

对于一维数组(直接当做list看)

[in]: x = np.arange(10)
[in]: y = x[2:8:3]
[in]: print(y)

[out]: [2 5]

推广至二维：(中间利用逗号,进行分隔，第一部分参数是表示第一个维度，第二部分参数表示第二个维度)，根据axis总结的相关知识，第一个维度管理的是沿着其变化方向如（0,0）->（1,0）可知，第一个维度管理的是每一层，所以此处对每一层是不会进行切割处理的。同理，我们看第二个维度，（0,0）->（0,1）沿着列方向向下变化，管理每一个列，于是切割到只剩下index=2的一列

axis维度的相关讲解

学新通

补充：视图和副本

python的 list 的切片返回是原数据的副本，即开辟了一个新的内存地址储存数据，因此修改切片出来的结果，原数据并不会发生改变。

而numpy 以效率为主，所以 numpy 的切片返回的是原数据的视图，即不会创建新的内存地址，而是对原数据内存地址的引用。所以对numpy 切片结果进行修改会发现，原数据也一起发生了改变。

注意：numpy 中所有的运算操作符都不会为数组创建副本

[in]: x = np.arange(1,10).reshape(3,-1) #创建一个3 * 3大小的二维数组
#解释一下，上行代码的-1的作用：前面生成9个元素，axis=1位置-1自动9/3=3
[in]: print(x)
[out]: [[1 2 3]
[4 5 6]
[7 8 9]]
[in]: y = x[:2,:2]
[in]: print(y)
[out]: [[1 2]
[4 5]]
[in]: y[1,1] = 999
[in]: print(y)
[out]: [[ 1 2]
[ 4 999]]
[in]: print(x)
[out]: [[ 1 2 3]
[ 4 999 6]
[ 7 8 9]]

② Numpy索引

法一：使用索引数组进行索引访问

注意：对于索引数组的所有情况，返回的是原始数据的副本，而不是切片获取的视图。

# x = [10 9 8 7 6 5 4 3 2]
[in]: y = x[np.array([3,3,-3,8])]
[in]: print(y)
[out]: [7 7 4 2]

推广至多维：(np.array中的元素构成单一索引值，一个一个地映射到x中，并进行相应的替换。)

# x = [10 9 8 7 6 5 4 3 2]
[in]: y = x[np.array([[1,1],[2,3]])]
[in]: print(y)
[out]: array([[9, 9],
[8, 7]])

验证索引用的是副本，而不是视图！！！学新通

很显然92没有被改变 学新通

法二：布尔索引

学新通

推广至二维：

学新通

法三：花式索引

学新通

广播机制的应用：

Numpy 的广播机制先将[2]变成[2, 2]，然后再拼接成相应的下标 arr[0, 2] 和 arr[1, 2] 。

学新通

其他例子：

学新通

In a nutshell：

学新通

7.Numpy数组运算和操作

①修改数组形状

（a）numpy.reshape

学新通

（b） numpy.ndarray.flatten

学新通

②矩阵的转置：

学新通

（a） numpy.transpose

学新通

③修改数组维度

（a）numpy.expand_dims

（b）numpy.squeeze

④连接数组

（a）numpy.concatenate

（b）numpy.stack

学新通

import numpy
arr_1 = numpy.arange(1, 7).reshape((2, 3))
arr_2 = numpy.arange(7, 13).reshape((2, 3))
arr_3 = numpy.arange(13, 19).reshape((2, 3))
arr_4 = numpy.arange(19, 25).reshape((2, 3))
print(numpy.stack([arr_1, arr_2, arr_3, arr_4], axis=0))
print(numpy.stack([arr_1, arr_2, arr_3, arr_4], axis=0).shape)
print(numpy.stack([arr_1, arr_2, arr_3, arr_4], axis=1))
print(numpy.stack([arr_1, arr_2, arr_3, arr_4], axis=1).shape)
print(numpy.stack([arr_1, arr_2, arr_3, arr_4], axis=2))
print(numpy.stack([arr_1, arr_2, arr_3, arr_4], axis=2).shape)

输出：

需要注意的是：axis 等于几就说明在哪个维度上进行堆叠。

当 axis=0 的时候，意味着整体，也就是一个2行3列的数组。所以对于0维堆叠，相当于简单的物理罗列，比如这四个数组代表的是4张图像的数据，进行0维堆叠也就是把它们按顺序排放了起来，形成了一个(4,2,3)的3维数组。

当 axis=1 的时候，意味着第一个维度，也就是数组的每一行。所以对于1维堆叠，4个2行3列的数组，各自拿出自己的第一行数据进行堆叠形成3维数组的第一“行”，各自拿出自己的第二行数据进行堆叠形成3维数组的第二“行”，从而形成了一个(2,4,3)的3维数组。

当 axis=2 的时候，意味着第二个维度，注意：千万不要理解成2维堆叠是对每一列拿出来进行堆叠！这个堆叠是对于整个维度来讲的，我们把一维空间理解为一条线，而二维空间则是一个平面。从第二个维度堆叠可以看作平面与平面的堆叠。

⑧分隔数组

numpy.split

import numpy as np
arr = np.arange(9)
print(arr)
arr_1 = np.split(arr, 3)
arr_2 = np.split(arr, [4, 7])
print(arr_1)
print(arr_2)
'''output：
[0 1 2 3 4 5 6 7 8]
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

⑨数组元素的添加与删除

（a）numpy.resize

（b）numpy.append

（c）numpy.insert

（d）numpy.delete

学新通

（e） numpy.unique

学新通

8.Numpy基本计算&数组统计计算

①基本计算

对应位置，依次进行相关的操作！！！

②数组统计计算

学新通

9.广播机制介绍：

①广播的原则：

如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符，或其中的一方的长度为1，则认为它们是广播兼容的。广播会在缺失和（或）长度为1的维度上进行。

通俗的解释一下就是广播机制可以在两种情况下作用，一种是两个数组的维数不相等，但是它们的后缘维度的轴长相符（其实就是从后数的连续若干个维度数都相同），另外一种是有一方的长度为1（其实就是如果从后数有维度不同，但是维度大小为1时，广播机制同样可以发挥作用）。

②例子

（a）后锥维度的轴长相符

学新通

（b）后缘维度不全相同，有一方长度为1 学新通

（c）反例 学新通

10.深浅拷贝问题

NumPy 的 copy 操作分为三种：无拷贝、浅拷贝、深拷贝。每种拷贝方式的机制和内存操作有所区别，可以联系到我们之前学过的视图和副本的内容，如果使用不当可以浪费大量内存，因此要理解操作中的各种行为，根据实际情况选择最合理的方法。

①无拷贝：（相当于引用！）

②视图or浅拷贝

学新通

可以看到 a 和 b 并不同属一块内存，是两个不同的对象。然而对 b 的修改会改变 a ，证明其实浅拷贝操作还是共用的一个底层数据。

虽然改b的值会同步更新到a，但是改动b的形状是不会反映到a的！！！

③副本or深拷贝

二、pandas

1.数据结构：

①Series

（a）创建

#1.从列表创建
s1 = pd.Series([1, 2, 3, 4, 5])
#2.从 ndarray 创建
s2 = pd.Series(np.arange(5), index=['a','b','c','d','e'])
#3.从字典创建
temp_dict = {"name": "zhangsan", "age": 27, "tel": 10086}
s3 = pd.Series(temp_dict)
#4.从标量值构造
s4 = pd.Series(1., index=list("abcde"))

输出：

（b）切片和索引

学新通

（c）Series与Dict

学新通

**（d）基本运算 * / 等同numpy**

（e）自动对齐

对于上面两个不能完全对齐的 Series,结果的 index 是两者的并集,同时不能对齐的部分当作缺失值处理.

（f）缺失值检测

学新通

# 创建一个带缺失值Series
s = pd.Series([1, 2, None, 4, None])
# 检测缺失值
print(s.isna())
'''Output:
0 False
1 False
2 True
3 False
4 True
dtype: bool'''
# 填充缺失值，填充值为0.
print(s.fillna(0.))
'''Output:
0 1.0
1 2.0
2 0.0
3 4.0
4 0.0
dtype: float64'''

(G)name属性 &index、values属性

（i）可以在定义时指定 name 属性:

s = pd.Series(np.arange(5), name="something")

print(s.name)

'''[out]:

something'''

(ii)通过 Series.index 查看索引, 通过 values 查看值

s = pd.Series(np.arange(5), index=list("abcde"))

print(s.index)

'''[out]:

Index(['a', 'b', 'c', 'd', 'e'], dtype='object')'''

print(s.values)

'''[out]:

[0 1 2 3 4]'''

② DataFrame

DataFrame 是 pandas 中的二维数据结构,可以看成一个 Excel 中的工作表,或者一个 SQL 表,或者一个存储Series 对象的字典,它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。

DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）,其中的 index用于指定行的 label,columns 用于指定列的 label ,如果参数不传入,那么会按照传入的内容进行设定。

（a）创建

两大类创建方式(①从列表(单个嵌套)②从字典（数组or列表）)

#1.1使用单个列表创建
data = [1, 2, 3, 4, 5]
df = pd.DataFrame(data)
print(df)
'''[out]:
0
0 1
1 2
2 3
3 4
4 5'''
#1.2使用嵌套列表创建并指定列索引
data = [['xiaoming', 10], ['xiaohong', 11], ['xiaozhang', 12]]
df = pd.DataFrame(data, columns=['Name', 'Age'])
print(df)
'''[out]:
Name Age
0 xiaoming 10
1 xiaohong 11
2 xiaozhang 12'''
#2.1从字典使用数组创建->注意:两个数据的长度必须一样
data = {'Name': ['xiaoming', 'zhangsan', 'lisi'], 'Age':[10, 11, 21]}
df = pd.DataFrame(data)
print(df)
'''[out]:
Name Age
0 xiaoming 10
1 zhangsan 11
2 lisi 21'''
#2.2从字典列表创建
#字典列表可作为输入数据传递以用来创建 DataFrame ,
#字典键默认为列名,缺失的部分会自动填充 NaN 值
data = [{'a': 1, 'b': 2}, {'a': 5, 'b': 6, 'c': 7}]
df = pd.DataFrame(data, index=["first", "second"]) # 指定行索引
print(df)
'''[out]:
a b c
first 1 2 NaN
second 5 6 7.0'''

注：2.1的示例显然字典的键默认充当了column值！！！value 可以是各种能够转化为 Series 的对象，与 Series 要求所有的类型都一致不同，DataFrame 值要求每一列数据的格式相同->各列数据类型用下面的df.dtypes来进行查询。

（b）基本属性与整体情况查询

DataFrame 的基础属性

df.shape # 形状，行数列数

df.dtypes # 列数据类型

df.ndim # 数据维度

df.index # 行索引

df.columns # 列索引

df.values # 对象值，二维ndarray数组

DataFrame 的整体情况查询

df.head() # 显示头部几行

df.tail() # 显示尾部几行

df.info() # 相关信息概览：行数，列数，列索引，列非空值个数，列类型，内存占用

df.describe() # 快速综合统计结果：计数，均值，标准差，最大值，四分位数，最小值

describe（）：示例

print(df.describe())
'''[out]:
A B C D
count 6.000000 6.000000 6.000000 6.000000
mean 0.170426 0.204062 -0.433312 -0.112912
std 1.831264 0.861747 1.082089 0.861061
min -1.252650 -1.068945 -1.715116 -1.294911
25% -0.791367 -0.101212 -1.225638 -0.466866
50% -0.469743 0.061138 -0.342377 -0.222187
75% 0.156002 0.712040 -0.048075 0.193103
max 3.748685 1.397363 1.270031 1.278703'''

(C)索引

DataFrame 支持 ndarray 的索引语法，但是推荐使用 .loc, .iloc .ix 方法进行索引。

(i)常规使用ndarray式的索引方法

# 创建一个6行3列的正太分布结构
df = pd.DataFrame(np.random.randn(6,4), index=list("abcdef"),
columns=list('ABCD'))
# 创建一个3行4列的结构
df2 = pd.DataFrame(np.arange(12).reshape(3, 4), index=list("abc"), columns=list("WXYZ"))
#1.1列：读取单列
print(df["A"])
#等效于 print(df.A)
'''Output:
a -2.021650
b 0.259206
c 0.868003
d 0.803916
e -0.271057
f -1.251718
Name: A, dtype: float64'''
#1.2列：读取多列
print(df[["A", "C"]])
''' Output:
A C
a -2.021650 0.659043
b 0.259206 -0.542967
c 0.868003 0.599239
d 0.803916 -0.207791
e -0.271057 -0.588037
f -1.251718 -2.018937'''
#2.1行：使用切片
print(df[0:3])
'''output:
A B C D
a -2.021650 -0.819054 0.659043 0.526803
b 0.259206 -3.061188 -0.542967 -0.118463
c 0.868003 0.460860 0.599239 1.919060'''
#2.2行：索引读取
print(df["a":"c"])
''' A B C D
a -2.021650 -0.819054 0.659043 0.526803
b 0.259206 -3.061188 -0.542967 -0.118463
c 0.868003 0.460860 0.599239 1.919060'''
#3.读取多行多列也是可以的
print(df["a":"c"][["A", "D"]])
''' A D
a -2.021650 0.526803
b 0.259206 -0.118463
c 0.868003 1.919060'''

(ii) 使用 `.loc ->根据index和column名进行操作，.loc[...]`

# 创建一个3行4列的结构
df2 = pd.DataFrame(np.arange(12).reshape(3, 4), index=list("abc"), columns=list("WXYZ"))
#1单切：.loc 可以使用 label 进行索引
#查询单行
print(df2.loc["a"])
'''W 0
X 1
Y 2
Z 3
Name: a, dtype: int32'''
#查询多行
print(df2.loc[["a", "c"]])
'''W X Y Z
a 0 1 2 3
c 8 9 10 11'''
#2.连续切片：“,”左边为行索引，右边为列索引
#写法1, 离散的多行多列
print(df2.loc[["a", "b"], ["W", "Y"]])
'''W Y
a 0 2
b 4 6'''
#写法2，连续的多行离散的多列
print(df2.loc[df2.index[0:2], ["W", "Y"]])
'''W Y
a 0 2
b 4 6'''
#写法3，连续的多行多列
print(df2.loc["a": "c", "W": "Y"])
'''W X Y
a 0 1 2
b 4 5 6
c 8 9 10'''

注意：loc是闭区间！！！！！

(iii)使用 `.iloc`

根据位置（就是直接用数字(默认从0开始)切片or索引）读取

，也可以进行切片 ->>>补充：.ix可以综合iloc和.loc使用

# 创建一个3行4列的结构
df2 = pd.DataFrame(np.arange(12).reshape(3, 4), index=list("abc"), columns=list("WXYZ"))
# 获取前两行->左闭右开（注意区分）
print(df2.iloc[0:2])
''' W X Y Z
a 0 1 2 3
b 4 5 6 7'''
# 获取前2行前3列
print(df2.iloc[0:2, 0:3])
''' W X Y
a 0 1 2
b 4 5 6'''
# 获取所有行，前2列
print(df2.iloc[:, 0:2])
'''W X
a 0 1
b 4 5
c 8 9'''
# 获取前2行，所有列
print(df2.iloc[0:2, :])
'''W X Y Z
a 0 1 2 3
b 4 5 6 7'''

(iv)布尔值索引

# 创建一个6行3列的正太分布结构
df = pd.DataFrame(np.random.randn(6,4), index=list("abcdef"),
columns=list('ABCD'))
print(df > 0)
'''A B C D
a False False True True
b True False False False
c True True True True
d True False False True
e False False False True
f False True False False'''
#获取所有 A 列大于0的行：
print(df['A'] > 0)
'''
a False
b True
c True
d True
e False
f False
Name: A, dtype: bool'''
print(df[df['A'] > 0])
''' A B C D
b 0.259206 -3.061188 -0.542967 -0.118463
c 0.868003 0.460860 0.599239 1.919060
d 0.803916 -1.835040 -0.207791 0.445216'''
#也能传入多个条件，不同的条件之间需要用括号括起来
print(df2[(df2 > 1) & (df2 < 10)])
'''W X Y Z
a NaN NaN 2.0 3.0
b 4.0 5.0 6.0 7.0
c 8.0 9.0 NaN NaN'''

（D）层次化索引

在一个轴上拥有多个索引级别，另一种说法是它能以低纬度形式来处理高纬度数据。

（i） Series 层次化索引

data = [16, 17, 21, 18, 19, 22]
s = pd.Series(data,
index=[["first", "first", "second", "second", "third", "third"],
["male", "female", "male", "female", "male", "female"]])
print(s)
'''output:
first male 16
female 17
second male 21
female 18
third male 19
female 22
dtype: int64'''
# 显示层次化索引
print(s.index)
'''MultiIndex([( 'first', 'male'),
( 'first', 'female'),
('second', 'male'),
('second', 'female'),
( 'third', 'male'),
( 'third', 'female')],
)'''

Series层次索引应用实例：

#1.获取一下一班的男女生人数：
# 传入第一个索引
print(s["first"])
'''[out]:
male 16
female 17
dtype: int64'''
#2.获取一二班的男女生人数->层次索引的切片操作
print(s["first": "second"])
'''[out]:
first male 16
female 17
second male 21
female 18
dtype: int64'''
# 也可以多项选择
print(s[["first", "third"]])
'''[out]:
first male 16
female 17
third male 19
female 22
dtype: int64 '''
#3.获取一班的男生人数
#方式一：内外层结合选择
print(s["first", "male"])
#方式二：先选择外层索引，再选择内层索引
print(s["first"]["male"])
'''16'''
#4.获取各班的女生人数
#方式一：内外层结合选择
print(s[:, "female"])
#方式二：先选择外层索引，再选择内层索引
print(s["first": "third"][:, "female"])
'''[out]:
first 17
second 18
third 22
dtype: int64'''

(ii) DataFrame 层次化索引

对于 DataFrame 来说，行和列都能进行层次化索引，也就是四个索引决定一个值，将一个二维数据变成了一个四维数据。

我们来统计一下三个班级中数学、语文、英语三门学科男生和女生考试成绩的等级划分：

data = np.random.randint(10, 20, size=(6, 9)) # [10， 20)之间的随机整数

index = [["first", "first", "second", "second", "third", "third"],

["male", "female", "male", "female", "male", "female"]]

columns = [["Ch", "Ch", "Ch", "Ma", "Ma", "Ma", "En", "En", "En"],

["A", "B", "C", "A", "B", "C", "A", "B", "C"]]

df = pd.DataFrame(data, index=index, columns=columns)

print(df)

'''[out]:

Ch Ma En

A B C A B C A B C

first male 18 14 12 14 18 11 18 15 11

female 13 13 15 13 16 19 12 17 19

second male 11 16 17 19 19 10 15 11 13

female 11 11 17 16 11 17 19 12 11

third male 18 18 12 16 12 19 13 19 18

female 18 14 18 19 15 18 13 18 13'''

# 显示层次化索引

print(df.index)

'''[out]:

MultiIndex([( 'first', 'male'),

( 'first', 'female'),

('second', 'male'),

('second', 'female'),

( 'third', 'male'),

( 'third', 'female')],

)'''

print(df.columns)

'''[out]:

MultiIndex([('Ch', 'A'),

('Ch', 'B'),

('Ch', 'C'),

('Ma', 'A'),

('Ma', 'B'),

('Ma', 'C'),

('En', 'A'),

('En', 'B'),

('En', 'C')],

)'''

DataFrame层次化索引应用举例

#各班的学生数学成绩各等级人数：
print(df["Ma"])
'''[out]:
A B C
first male 14 18 11
female 13 16 19
second male 19 19 10
female 16 11 17
third male 16 12 19
female 19 15 18'''
#获取一班的所有项:
print(df.loc["first"])
'''
Ch Ma En
A B C A B C A B C
male 18 14 12 14 18 11 18 15 11
female 13 13 15 13 16 19 12 17 19'''
#获取一班男女生英语成绩各等级的人数
print(df.loc["first", "En"])
''' A B C
male 18 15 11
female 12 17 19'''
#获取各班语文成绩为 A 的人数：
print(df["Ch"]["A"])
'''
first male 18
female 13
second male 11
female 11
third male 18
female 18
Name: A, dtype: int32'''
#获取一班男女生的语文和英语成绩各等级人数:
print(df.loc["first", ["Ch", "En"]])
''' Ch En
A B C A B C
male 18 14 12 18 15 11
female 13 13 15 12 17 19'''
#获取一班男女生的语文成绩 A 等级人数:
print(df.loc["first", "Ch"]["A"])
'''[out]:
male 18
female 13
Name: A, dtype: int32'''
#获取一班男生的各科成绩等级人数:
print(df.loc["first", :].loc["male"])
'''
Ch A 18
B 14
C 12
Ma A 14
B 18
C 11
En A 18
B 15
C 11
Name: male, dtype: int32'''

注意：

import numpy as np
import pandas as pd
index=[['first','first','second','second','third','third']
,['male','female','male','female','male','female']]
column=[['Ch','Ch','Ch','Ma','Ma','Ma','En','En','En',],
['A','B','C','A','B','C','A','B','C']]
data=pd.DataFrame(np.random.randint(10,20,size=(6,9)),index=index,columns=column)
print(data.loc['second',:])
print(data.loc['second',:].loc['male'])
print('*'*50)
print(data.loc['second','Ma'])
print(data.loc['second','Ma']['A'])
#注意上面的两种写法->只有当指定外层的两个单个索引时，才能直接进行[]索引，否则需要继续loc

输出：

''' Ch Ma En

A B C A B C A B C

male 12 12 11 18 19 16 18 12 16

female 18 15 19 14 12 19 14 10 12

Ch A 12

B 12

C 11

Ma A 18

B 19

C 16

En A 18

B 12

C 16

Name: male, dtype: int32

**************************************************

A B C

male 18 19 16

female 14 12 19

male 18

female 14

Name: A, dtype: int32

'''

(E)数据的合并

Pandas 包的 merge、join 方法可以完成数据的合并，merge 方法主要基于两个 DataFrame 的共同列进行合并，join 方法主要基于两个 DataFrame 的索引进行合并。

（i）merge共同列

pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

学新通

df1 = pd.DataFrame({'key':['s','s','w','x','x','n','f','c'], 'data1':range(8)})
df2 = pd.DataFrame({'key':['w','w','s','s','x','f'], 'data2':range(6)})
'''df1:
key data1
0 s 0
1 s 1
2 w 2
3 x 3
4 x 4
5 n 5
6 f 6
7 c 7
df2:
key data2
0 w 0
1 w 1
2 s 2
3 s 3
4 x 4
5 f 5'''
#1.默认情况下的合并(默认使用的是 inner 内连接方式，结果做的交集->发现有行消失了
print(pd.merge(df1, df2))
'''
key data1 data2
0 s 0 2
1 s 0 3
2 s 1 2
3 s 1 3
4 w 2 0
5 w 2 1
6 x 3 4
7 x 4 4
8 f 6 5'''
#2.外连接
#outer 外连接方式，我们可以理解为基于共同列的并集进行连接，参数 on 设置链接的共有列名。
print(pd.merge(df1, df2, how="outer", on="key"))
''' key data1 data2
0 s 0 2.0
1 s 0 3.0
2 s 1 2.0
3 s 1 3.0
4 w 2 0.0
5 w 2 1.0
6 x 3 4.0
7 x 4 4.0
8 n 5 NaN
9 f 6 5.0
10 c 7 NaN'''
#若两个 DataFrame 间出了 on 设置的连接列外并无相同列，则该列的值置为 NaN
#3.左连接
#left 左连接，我们可以理解为基于左边位置的 DataFrame 的列进行连接
print(pd.merge(df1, df2, how="left"))
''' key data1 data2
0 s 0 2.0
1 s 0 3.0
2 s 1 2.0
3 s 1 3.0
4 w 2 0.0
5 w 2 1.0
6 x 3 4.0
7 x 4 4.0
8 n 5 NaN
9 f 6 5.0
10 c 7 NaN'''

4.基于多列的连接
df1 = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],
'key2': ['one', 'two', 'one'],'val': [1, 2, 3]})
'''key1 key2 val
0 foo one 1
1 foo two 2
2 bar one 3'''
df2 = pd.DataFrame({'key1': ['foo', 'foo','bar','bar'],
'key2': ['one', 'one', 'one','two'],'val': [4,5,6,7]})
'''key1 key2 val
0 foo one 4
1 foo one 5
2 bar one 6
3 bar two 7'''
#4.1多列的右连接：
print(pd.merge(df1, df2, on=["key1", "key2"], how="right"))
'''key1 key2 val_x val_y
0 foo one 1.0 4
1 foo one 1.0 5
2 bar one 3.0 6
3 bar two NaN 7'''
#多列连接只需要传入列名组成的列表就可以了
#注意：left列表中foo two由于右列表无，所以，交之后被删去。右列表有的左没有，那也得加上去。
4.2当合并的数据有相同的列时，结构会默认在后面添加 _x, _y 来区分，
我们也可以通过 suffixes 参数来手动指定：
print(pd.merge(df1, df2, on=["key1", "key2"], suffixes=["_left", "_right"]))
''' key1 key2 val_left val_right
0 foo one 1 4
1 foo one 1 5
2 bar one 3 6'''

（ii）Join：更为方便的实现行索引上的合并

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

学新通

df1 = pd.DataFrame(np.arange(8).reshape(2, 4),
index=["one", "two"], columns=list("ABCD"))
''' A B C D
one 0 1 2 3
two 4 5 6 7'''
df2 = pd.DataFrame(np.arange(12).reshape(3, 4),
index=["one", "two", "three"], columns=list("CDEF"))
''' W X Y Z
one 0 1 2 3
two 4 5 6 7
three 8 9 10 11'''
#1.默认情况下的join
# 未指定合并的列，默认选取两者重复的列
print(df1.join(df2))
''' A B C D W X Y Z
one 0 1 2 3 0 1 2 3
two 4 5 6 7 4 5 6 7'''
#2.df2.join(df1)
df2.join(df1)
''' W X Y Z A B C D
one 0 1 2 3 0.0 1.0 2.0 3.0
two 4 5 6 7 4.0 5.0 6.0 7.0
three 8 9 10 11 NaN NaN NaN NaN'''
#可见会以前者的索引为基准来进行合并，并且不足的地方会自动填充 NaN 值，超出的地方会自动删除

(F)分割与组合

学新通

DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=<no_default>, observed=False, dropna=True)

参数说明:

by：接收list，string，mapping，generator，用于确定分组的依据，无默认。

axis：接收int，表示操作的轴向，默认为0，对列进行操作。

level：接收int或者索引名，代表标签所在级别。

as_index：表示聚合后的聚合标签是否以DataFrame索引形式输出，默认为True。

sort：表示是否对分组依据分组标签进行排序。

group_keys：表示是否显示分组标签的名称。

squeeze：表示是否在允许的情况下对返回数据进行降维。

更加详细的 API 描述可以查阅官方文档 pandas.DataFrame.groupby

我们先来创建一个 DataFrame，包含课程，等级，和男女生人数信息：

# 用字典创建DataFrame
[in]: data = {"lessons": ['Ch', 'En', 'Ch', 'En', 'Ch', 'Ma', 'En', 'Ma'],
"grade": ['A', 'A', 'B', 'B', 'C', 'A', 'C', 'B'],
"male": np.random.randint(10, 20, 8), # [10, 20)的8个随机整数
"female": np.random.randint(10, 20, 8)}
[in]: df = pd.DataFrame(data)
[in]: print(df)
[out]:
lessons grade male female
0 Ch A 14 17
1 En A 10 11
2 Ch B 11 11
3 En B 15 12
4 Ch C 14 13
5 Ma A 15 19
6 En C 19 15
7 Ma B 17 12

对课程 lessons 分组，我们会得到什么呢

[in]: print(df.groupby(by="lessons"))
[out]:
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x00000209C7C76460>

我们看到它实际上还没有进行任何计算，而是返回了一个 DataFrameGroupBy 对象，用 groupby 方法分组后的结果并不能直接查看，而是被存在内存中，输出的时内存地址。

如果要得到我们想要的结果，我们应该怎么做呢？ DataFrameGroupBy 对象有很多经过优化的方法：

count：计算分组中非NA值的数量

sum：计算非NA值的和

mean：计算非NA值的平均值

median：计算非NA值的算术中位数

std、var：无偏（分母为n-1）标准差和方差

min、max：非NA值的最小值和最大值

我们来尝试计算一下各等级的男生人数：

[in]: group1 = df.groupby(by="grade")
[in]: print(group1.sum())
[out]:
male female
grade
A 39 47
B 43 35
C 33 28

size() 返回每个分组的元素个数

[in]: group2 = df.groupby(by="lessons")
[in]: print(group2.count())
[in]: print('-' * 50)
[in]: print(group2.size())
[out]:
grade male female
lessons
Ch 3 3 3
En 3 3 3
Ma 2 2 2
--------------------------------------------------
lessons
Ch 3
En 3
Ma 2
dtype: int64

一次传入多个分组依据，统计各学科各等级的男女生人数

# 安装学科和成绩进行分组
[in]: group3 = df.groupby(by=[df["lessons"], df["grade"]])
[in]: print(group3.sum())
[out]:
male female
lessons grade
Ch A 14 17
B 11 11
C 14 13
En A 10 11
B 15 12
C 19 15
Ma A 15 19
B 17 12

我们在分组统计之后如果只想查看男生的情况，当然也是可以的

[in]: print(df.groupby(by=[df["lessons"], df["grade"]]).sum()["male"])
[out]:
lessons grade
Ch A 14
B 11
C 14
En A 10
B 15
C 19
Ma A 15
B 17
Name: male, dtype: int32

这样的写法 df["male"].groupby(by=[df["lessons"], df["grade"]]).sum() 当然也是可以的。

2.读写数据

①`read_csv`

data = pd.read_csv("train.csv")

②`read_table`

③ `to_csv`

3.缺失值数据处理

[in]: df = pd.DataFrame(np.random.randn(4, 5), index=["one", "two", "three", "four"], columns=list("ABCDE"))
[in]: df.iloc[0, 2] = np.nan
[in]: df.iloc[[1, 3], 4] = np.nan #锁定五列，将二四行置NaN
[in]: print(df)
[out]:
A B C D E
one 0.123806 0.493575 NaN 0.476856 0.547563
two 0.750184 -0.326554 0.448464 0.449652 NaN
three 1.075840 0.228632 0.769619 -1.091077 0.440128
four -1.545927 0.243639 1.158786 1.381231 NaN

学新通

注：df.mean()是获取每列的均质构成5*1的ndaray 学新通

4. 数据特征分析

①排序

sort_index方法

.sort_index() 方法在指定轴上根据索引进行排序，默认为零轴，升序。

.sort_index(axis=0,ascending=True)

axis: 指定要排序的轴。
ascending : 指递增排序。

[in]: df1 = pd.DataFrame(np.arange(20).reshape(4,5), index = list("cabd"))
[in]: print(df1)
[in]: print('-' * 50)
[out]:
0 1 2 3 4
c 0 1 2 3 4
a 5 6 7 8 9
b 10 11 12 13 14
d 15 16 17 18 19
--------------------------------------------------
# 规定按照降序排序
[in]: print(df1.sort_index(ascending=False))
[out]:
0 1 2 3 4
d 15 16 17 18 19
c 0 1 2 3 4
b 10 11 12 13 14
a 5 6 7 8 9

sort_values 方法

.sort_values() 方法在指定轴上根据数值进行排序，默认为零轴，升序

Series.sort_values(axis=0, ascending=True)
DataFrame.sort_values(by, axis=0, ascending=True)

by: axis 轴上的某个索引或索引列表。
ascending : 指递增排序。

[in]: df2 = pd.DataFrame(np.arange(20).reshape(4,5), index = list("abcd"))
[in]: print(df2)
[out]:
0 1 2 3 4
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
# 默认在0轴上，指定对索引为2的那一列按照降序排序
[in]: print(b.sort_values(2, ascending=False))
[out]:
0 1 2 3 4
d 15 16 17 18 19
c 10 11 12 13 14
b 5 6 7 8 9
a 0 1 2 3 4
# 指定在1轴上，对索引为‘c’的那一行进行降序排序
[in]: print(b.sort_values('a',axis=1, ascending=False))
[out]:
4 3 2 1 0
a 4 3 2 1 0
b 9 8 7 6 5
c 14 13 12 11 10
d 19 18 17 16 15

②.基本统计数据

适用于 Series 和 DataFrame 类型：

方法	说明
.sum()	计算数据的总和，按0轴计算，下同
.count()	非Nan值的数量
.mean() .median()	计算数据的算数平均值、算数中位数
.var() .std()	计算数据的方差、标准差
.min() .max()	计算数据的最小值、最大值

适用于 Series 类型的方法：

方法	说明
.argmin() .argmax()	计算数据最大值、最小值所在位置的索引（返回自动索引）
.idxmin() .idxmax()	计算数据最大值、最小值所在位置的索引（返回自定义索引）

适用于 Series 和 DataFrame 类型：

方法	说明
.describe()	针对0轴（各列）的统计汇总

统计 df1 在行方向的均值和列方向的均值

# 在0轴上的均值
[in]: print(df1.mean(axis=0))
[out]:
0 7.5
1 8.5
2 9.5
3 10.5
4 11.5
dtype: float64
# 在1轴上的均值
[in]: print(df1.mean(axis=1))
[out]:
c 2.0
a 7.0
b 12.0
d 17.0
dtype: float64

③.累计统计数据

适用于 Series 和 DataFrame 类型：

方法	说明
.cumsum()	依次给出前1、2、…、n个数的和
.cumprod()	依次给出前1、2、…、n个数的积
.cummax()	依次给出前1、2、…、n个数的最大值
.cummin()	依次给出前1、2、…、n个数的最小值

[in]: a = pd.DataFrame(np.arange(20).reshape(4,5), index = list("abcd"))
[in]: print(a)
[in]: print("-" * 50)
[out]:
0 1 2 3 4
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
--------------------------------------------------
[in]: print(a.cumsum())
[in]: print("-" * 50)
[out]:
0 1 2 3 4
a 0 1 2 3 4
b 5 7 9 11 13
c 15 18 21 24 27
d 30 34 38 42 46
--------------------------------------------------
[in]: print(a.cumprod())
[in]: print("-" * 50)
[out]:
0 1 2 3 4
a 0 1 2 3 4
b 0 6 14 24 36
c 0 66 168 312 504
d 0 1056 2856 5616 9576
--------------------------------------------------
[in]: print(a.cummax())
[in]: print("-" * 50)
[out]:
0 1 2 3 4
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
--------------------------------------------------
[in]: print(a.cummin())
[out]:
0 1 2 3 4
a 0 1 2 3 4
b 0 1 2 3 4
c 0 1 2 3 4
d 0 1 2 3 4

适用于 Series 和 DataFrame 类型，滚动计算（窗口计算）：

方法	说明
.rolling(w).sum()	依次计算相邻w个元素的和
.rolling(w).mean()	依次计算相邻w个元素的算数平均值
.rolling(w).var()	依次计算相邻w个元素的方差
.rolling(w).std()	依次计算相邻w个元素的标准差
.rolling(w).min() .max()	依次计算相邻w个元素的最小值和最大值

[in]: b = pd.DataFrame(np.arange(20).reshape(4,5), index = list("abcd"))
[in]: print(b)
[in]: print("-" * 50)
[out]:
0 1 2 3 4
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
--------------------------------------------------
# 每一行元素都和他的上一行元素相加。第一行的上一行为NaN，相加还为NaN
[in]: print(b.rolling(2).sum())
[in]: print("-" * 50)
[out]:
0 1 2 3 4
a NaN NaN NaN NaN NaN
b 5.0 7.0 9.0 11.0 13.0
c 15.0 17.0 19.0 21.0 23.0
d 25.0 27.0 29.0 31.0 33.0
--------------------------------------------------
[in]: print(b.rolling(3).sum())
[in]: print("-" * 50)
[out]:
0 1 2 3 4
a NaN NaN NaN NaN NaN
b NaN NaN NaN NaN NaN
c 15.0 18.0 21.0 24.0 27.0
d 30.0 33.0 36.0 39.0 42.0

④.相关性分析

什么是相关性呢，现有两个事物，表示为X和Y：

X增大，Y增大，两个变量正相关

X增大，Y减小，两个变量负相关

X增大，Y无视，两个变量不变

在统计学上的度量标准为：协方差

学新通

协方差>0, X和Y正相关
协方差<0, X和Y负相关
协方差=0, X和Y独立

方法	说明
.cov()	计算协方差矩阵
.corr()	计算相关系数矩阵，Pearson、Spearman、Kendall等系数