【pandas入门】第一章-预备知识

开源学习内容为joyful pandas

本节课地址：https://datawhalechina.github.io/joyful-pandas/build/html/%E7%9B%AE%E5%BD%95/ch1.html

---

---

1.python基础

1.1 列表推导式与条件赋值

生成数字序列

L=[]
def my_func(x):
    return 2*x 

for i in range(5):
    L.append(my_func(i))
    
L

[0, 2, 4, 6, 8]

以上过程可以简化为[* for i in *]，其中第一个*为映射函数，其输入为后面i所指代的内容，第二个*为迭代对象，所以上面的过程可以写为

[my_func(i) for i in range(5)]

[0, 2, 4, 6, 8]

列表表达式还支持多层嵌套，如下面例子中第一个for为外层循环，第二个for为内层循环

[m+'_'+n for m in['a','b'] for n in ['c','d']]

['a_c', 'a_d', 'b_c', 'b_d']

• 带有if的条件赋值，if语句成立value的值为cat否则为dog

value='cat' if 2>1 else 'dog'
print(value)

#等价于
a,b='cat','dog'
condition=2>1 #此时为True
if condition:
    value=a
else:
    value=b
print(value)

cat
cat

• 截断列表中超过5的元素（值大于5用5代替，小于5保留原来的数值）

L=[1,2,3,4,5,6,7] 
[i if i<=5 else 5  for i in L]

[1, 2, 3, 4, 5, 5, 5]

1.2 匿名函数与map方法

有一些函数的定义具有清晰简单的映射关系，例如上面的 my_func 函数，这时候可以用匿名函数的方法简洁地表示：

my_func=lambda x:2*x 
print(my_func(3))

multi_para_func=lambda a,b:a+b
print(multi_para_func(1,2))

6
3

[(lambda x:2*x)(i) for i in range(5)]

[0, 2, 4, 6, 8]

对于上述的这种列表推导式的匿名函数映射， Python 中提供了 map 函数来完成，它返回的是一个 map 对象，需要通过 list 转为列表：

list(map(lambda x:2*x,range(5)))

[0, 2, 4, 6, 8]

对于多个输入值的函数映射，可以通过追加迭代对象实现：

list(map(lambda x, y: str(x)+'_'+y, range(5), list('abcde')))

[‘0_a’, ‘1_b’, ‘2_c’, ‘3_d’, ‘4_e’]

1.3 zip对象与enumerate方法

zip函数能够把多个可迭代对象打包成一个元组构成的可迭代对象，它返回了一个 zip 对象，通过 tuple, list 可以得到相应的打包结果：

L1, L2, L3 = list('abc'), list('def'), list('hij')
list(zip(L1, L2, L3))
tuple(zip(L1,L2,L3))

((‘a’, ‘d’, ‘h’), (‘b’, ‘e’, ‘i’), (‘c’, ‘f’, ‘j’))

往往循环中会使用zip函数

for i,j,k in zip(L1,L2,L3):
    print(i,j,k)

a d h
b e i
c f j

enumerate 是一种特殊的打包，它可以在迭代时绑定迭代元素的遍历序号：

L=list('abcd')
for index,value in enumerate(L):
    print(index,value)

0 a
1 b
2 c
3 d

用 zip 对象也能够简单地实现这个功能

for index,value in zip(range(len(L)),L):
    print(index,value)

0 a
1 b
2 c
3 d

当需要对两个列表建立字典映射的时候，可以使用zip对象

dict(zip(L1,L2))

{‘a’: ‘d’, ‘b’: ‘e’, ‘c’: ‘f’}

解压函数zipped 既然有了压缩函数，那么 Python 也提供了 * 操作符和 zip 联合使用来进行解压操作：

zipped=list(zip(L1,L2,L3))
zipped

list(zip(*zipped))

[(‘a’, ‘b’, ‘c’), (‘d’, ‘e’, ‘f’), (‘h’, ‘i’, ‘j’)]

2. Numpy基础

2.1 np数组的构造

2.1.1 普通数组通过array来构造

import numpy as np
np.array([1,2,3])

array([1, 2, 3])

2.1.2 特殊数组

- 等差序列

np.linspace(1,5,11) #起始，终止（包含），样本个数

array([1. , 1.4, 1.8, 2.2, 2.6, 3. , 3.4, 3.8, 4.2, 4.6, 5. ])

np.arange(1,5,2) #起始，终止（不包含），步长

array([1, 3])

- 全零矩阵，单位矩阵

#全零矩阵
np.zeros((2,3)) #传入元组表示各维度大小

array([[0., 0., 0.],
[0., 0., 0.]])

#单位矩阵
np.eye(3) #3*3的单位矩阵

array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

#偏移对角线1个单位的伪单位矩阵
np.eye(3,k=1)

array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])

#全a矩阵
np.full((2,3),10) #元组传入大小，10表示填充数值

array([[10, 10, 10],
[10, 10, 10]])

#每行填充相同列表
np.full((2,3),[1,2,3])

array([[1, 2, 3],
[1, 2, 3]])

- 随机矩阵 np.random
最常用的随机生成函数为 rand, randn, randint, choice ，它们分别表示0-1均匀分布的随机数组、标准正态的随机数组、随机整数组和随机列表抽样

#rand实现0-1之间分布的随机数组
#生成服从0-1分布的三个随机数
print(np.random.rand(3))

#生成服从0-1分布的二维数据
print(np.random.rand(3,3))

[0.50085773 0.32351751 0.67382476]
[[0.70627754 0.99860322 0.90817232]
[0.86349008 0.96001813 0.28585109]
[0.22782408 0.96014216 0.01442711]]

#生成服从区间a到b的均匀分布
#方法一：
a,b=5,15
print((b-a)*np.random.rand(3)+a )

#方法二，利用uniform实现
print(np.random.uniform(5,15,3))

[12.61893799 12.36863668 14.12371546]

#使用randn生成服从N（0，I）的标准正态分布
print(np.random.randn(3))
print(np.random.randn(2,2))

[-1.51342547 -1.64046826 0.50925419]
[[-1.22505264 -1.87610612]
[ 0.60312408 1.61483153]]

#生成服从方差为 σ2 均值为 μ 的一元正态分布
#方法一：
sigma,mu=2.5,3
print(mu+np.random.randn(3)*sigma)

#方法二，利用normal函数
print(np.random.normal(3,2.5,3))

[1.81491167 4.80991467 3.11061582] [6.45319501 3.13115423
4.36242053]

#使用randint指定生成随机数的最小值最大值（不包含）和维度大小
low,high,size=5,15,(2,2) #生成5到14的随机整数
np.random.randint(low,high,size)

array([[ 7, 9],
[ 7, 14]])

#使用choice从给定的列表中，以一定概率和方式抽取结果，
#当不指定概率时为均匀采样，默认抽取方式为有放回抽样
my_list = ['a', 'b', 'c', 'd']
print(np.random.choice(my_list, 2, replace=False, p=[0.1, 0.7, 0.1 ,0.1]) )#指定概率进行抽取，因为b的概率大，所以被抽到的次数多
print(np.random.choice(my_list, (3,3)))

[‘b’ ‘c’]
[[‘c’ ‘c’ ‘a’]
[‘c’ ‘c’ ‘b’]
[‘b’ ‘d’ ‘b’]]

#当返回的元素个数与原列表相同时，不放回抽样等价于使用 permutation 函数，即打散原列表，重新排列
np.random.permutation(my_list)

  array(['b', 'a', 'd', 'c'], dtype='<U1')

seed为随机种子，通过设置随机种子可以固定输出结果

#seed为随机种子，通过设置随机种子可以固定输出结果
np.random.seed(0)  #输出结果一致
print(np.random.rand())
np.random.seed(0)
print(np.random.rand())

2.2 np数组的合并与变形

- 转置：T

np.zeros((2,3)).T #从两行三列变成了三行两列

array([[0., 0.],
[0., 0.],
[0., 0.]])

- 合并操作： r_, c_

#对于二维数组而言， r_ 和 c_ 分别表示上下合并和左右合并
#上下合并
print('两行三列的两个全零矩阵上下合并：\n',np.r_[np.zeros((2,3)),np.zeros((2,3))])

#左右合并
print('两行三列的两个全零矩阵左右合并：\n',np.c_[np.zeros((2,3)),np.zeros((2,3))])

#一维数组和二维数组进行合并时，应当把其视作列向量，在长度匹配的情况下只能够使用左右合并的 c_ 操作：
try:
    np.r_[np.array([0,0]),np.zeros((2,1))]
except Exception as e:
    Err_Msg = e
Err_Msg


print('[0,0]和[0,0]进行上下合并：\n',np.r_[np.array([0,0]),np.zeros(2)])

print('[0,0]和两行三列的全0矩阵进行左右合并：\n',np.c_[np.array([0,0]),np.zeros((2,3))])

两行三列的两个全零矩阵上下合并：
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
两行三列的两个全零矩阵左右合并：
[[0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0.]]
[0,0]和[0,0]进行上下合并：
[0. 0. 0. 0.]
[0,0]和两行三列的全0矩阵进行左右合并：
[[0. 0. 0. 0.]
[0. 0. 0. 0.]]

- 维度变换： reshape

reshape 能够帮助用户把原数组按照新的维度重新排列。在使用时有两种模式，分别为 C 模式和 F 模式，分别以逐行和逐列的顺序进行填充读取。

target = np.arange(8).reshape(2,4)
target

array([[0, 1, 2, 3],
[4, 5, 6, 7]])

target.reshape((4,2), order='C') # 按照行读取和填充

array([[0, 1],
[2, 3],
[4, 5],
[6, 7]])

target.reshape((4,2), order='F') # 按照列读取和填充

array([[0, 2],
[4, 6],
[1, 3],
[5, 7]])

#特别地，由于被调用数组的大小是确定的， reshape 允许有一个维度存在空缺，此时只需填充-1即可
#此处已知道是4行，因为数据是八个，所以默认为两列
target.reshape((4,-1))

array([[0, 1],
[2, 3],
[4, 5],
[6, 7]])

#将 n*1 大小的数组转为1维数组
target = np.ones((3,1))
print('befor:\n',target)
target=target.reshape(-1)
print('after:\n',target) 

befor:
[[1.]
[1.]
[1.]]
after:
[1. 1. 1.]

2.3 np数字的切片与索引

数组的切片模式支持使用 slice 类型的 start🔚step 切片，还可以直接传入列表指定某个维度的索引进行切片

target = np.arange(9).reshape(3,3)
print('befor:\n',target)
print('after:\n',target[:-1, [0,2]]) #返回前两行，第一列和第三列的数据

befor:
[[0 1 2]
[3 4 5]
[6 7 8]]
after:
[[0 2]
[3 5]]

还可以利用 np.ix_ 在对应的维度上使用布尔索引，但此时不能使用 slice 切片

target[np.ix_([True, False, True], [True, False, True])]

array([[0, 2],
[6, 8]])

target[np.ix_([1,2], [True, False, True])]

array([[3, 5],
[6, 8]])

当数组维度为1维时，可以直接进行布尔索引，而无需 np.ix_

new = target.reshape(-1)
print('befor:\n',new)
print('after:\n',new[new%2==0]) #取偶数位的值

befor:
[0 1 2 3 4 5 6 7 8]
after:
[0 2 4 6 8]

2.4 常用函数

2.4.1 where

where 是一种条件函数，可以指定满足条件与不满足条件位置对应的填充值

a = np.array([-1,1,-1,0])
np.where(a>0, a, 5)

array([5, 1, 5, 5])

2.4.1 nonzero, argmax, argmin

这三个函数返回的都是索引， nonzero 返回非零数的索引， argmax, argmin 分别返回最大和最小数的索引

a = np.array([-2,-5,0,1,3,-1])
print('非0索引：',np.nonzero(a))
print('最大值索引：',a.argmax())
print('最小值索引：',a.argmin())

非0索引： (array([0, 1, 3, 4, 5], dtype=int64),)
最大值索引： 4
最小值索引： 1

2.4.3 any, all

any 指当序列至少 存在一个 True 或非零元素时返回 True ，否则返回 False

all 指当序列元素 全为 True 或非零元素时返回 True ，否则返回 False

a = np.array([0,1])
print('使用any：',a.any())
print('使用all：',a.all())

使用any： True
使用all： False

2.4.4 cumprod, cumsum, diff

cumprod, cumsum 分别表示累乘和累加函数，返回同长度的数组， diff 表示和前一个元素做差，由于第一个元素为缺失值，因此在默认参数情况下，返回长度是原数组减1

a = np.array([1,2,3])
print('使用cumprod累乘：',a.cumprod())
print('使用cumsum累加：',a.cumsum())
print('使用diff做差：',np.diff(a))

使用cumprod累乘： [1 2 6]
使用cumsum累加： [1 3 6]
使用diff做差： [1 1]

2.4.5 统计函数

常用的统计函数包括 max, min, mean, median, std, var, sum, quantile ，其中分位数计算是全局方法，因此不能通过 array.quantile 的方法调用：

target = np.arange(5)
print('target:',target)
print('最大值:',target.max())
print('0.5分位数',np.quantile(target, 0.5))

target: [0 1 2 3 4]
最大值: 4
0.5分位数 2.0

【注意】对于含有缺失值的数组，它们返回的结果也是缺失值，如果需要略过缺失值，必须使用 nan* 类型的函数，上述的几个统计函数都有对应的 nan* 函数

target = np.array([1, 2, np.nan])
print('target:',target)
print('去掉nan之前的最大值:',target.max())
print('去掉nan之后的最大值:',np.nanmax(target))
print('去掉nan之后的0.5分位数:',np.nanquantile(target, 0.5))

target: [ 1. 2. nan]
去掉nan之前的最大值: nan
去掉nan之后的最大值: 2.0
去掉nan之后的0.5分位数: 1.5

对于协方差和相关系数分别可以利用 cov, corrcoef 计算

target1 = np.array([1,3,5,9])
target2 = np.array([1,5,3,-9])

#协方差
print('协方差:',np.cov(target1, target2))

#相关系数
print('相关系数:',np.corrcoef(target1, target2))

协方差: [[ 11.66666667 -16.66666667]
[-16.66666667 38.66666667]]
相关系数: [[ 1. -0.78470603]
[-0.78470603 1. ]]

【注意】二维 Numpy 数组中统计函数的 axis 参数，它能够进行某一个维度下的统计特征计算，当 axis=0 时结果为列的统计指标，当 axis=1 时结果为行的统计指标：

target = np.arange(1,10).reshape(3,-1)
print('计算各个列之和:',target.sum(0))
print('计算各个行之和:',target.sum(1))

计算各个列之和: [12 15 18]
计算各个行之和: [ 6 15 24]

2.5 广播机制

广播机制用于处理两个不同维度数组之间的操作，这里只讨论不超过两维的数组广播机制。

2.5.1 标量和数组的操作

当一个标量和数组进行运算时，标量会自动把大小扩充为数组大小，之后进行逐元素操作

res = 3 * np.ones((2,2)) + 1
res

array([[4., 4.],
[4., 4.]])

res = 1 / res
res 

array([[0.25, 0.25],
[0.25, 0.25]])

2.5.2 二维数组之间的操作

当两个数组维度完全一致时，使用对应元素的操作，否则会报错，除非其中的某个数组的维度是 m×1 或者 1×n ，那么会扩充其具有 1 的维度为另一个数组对应维度的大小。例如， 1×2 数组和 3×2 数组做逐元素运算时会把第一个数组扩充为 3×2 ，扩充时的对应数值进行赋值。但是，需要注意的是，如果第一个数组的维度是 1×3 ，那么由于在第二维上的大小不匹配且不为 1 ，此时报错。

res = np.ones((3,2))
res

array([[1., 1.],
[1., 1.],
[1., 1.]])

res * np.array([[2,3]]) # 第二个数组扩充第一维度为3

array([[2., 3.],
[2., 3.],
[2., 3.]])

res * np.array([[2],[3],[4]]) # 第二个数组扩充第二维度为2

array([[2., 2.],
[3., 3.],
[4., 4.]])

res * np.array([[2]]) # 等价于两次扩充，第二个数组两个维度分别扩充为3和2

array([[2., 2.],
[2., 2.],
[2., 2.]])

2.5.3 一维数组与二维数组的操作

当一维数组 Ak 与二维数组 Bm,n 操作时，等价于把一维数组视作 A1,k 的二维数组，使用的广播法则与二维数组之间的操作一致，当 k!=n 且 k,n 都不是 1 时报错。

np.ones(3) + np.ones((2,3))

array([[2., 2., 2.],
[2., 2., 2.]])

np.ones(3) + np.ones((2,1))

array([[2., 2., 2.],
[2., 2., 2.]])

np.ones(1) + np.ones((2,3))

array([[2., 2., 2.],
[2., 2., 2.]])

2.5.4 向量与矩阵计算

- 向量内积 a⋅b=∑aibi

a = np.array([1,2,3])
b = np.array([1,3,5])
a.dot(b)

22

- 向量范数和矩阵范数： np.linalg.norm
在矩阵范数的计算中，最重要的是 ord 参数，可选值如下：

matrix_target =  np.arange(4).reshape(-1,2)
matrix_target

array([[0, 1],
[2, 3]])

np.linalg.norm(matrix_target, 'fro')

3.7416573867739413

np.linalg.norm(matrix_target, np.inf)

5.0

np.linalg.norm(matrix_target, 2)

3.702459173643833

vector_target =  np.arange(4)
vector_target

array([0, 1, 2, 3])

np.linalg.norm(vector_target, np.inf)

3.0

np.linalg.norm(vector_target, 2)

3.7416573867739413

np.linalg.norm(vector_target, 3)

3.3019272488946263

- 矩阵乘法

a = np.arange(4).reshape(-1,2)
a 

array([[0, 1],
[2, 3]])

b = np.arange(-4,0).reshape(-1,2)
b

array([[-4, -3],
[-2, -1]])

a@b

array([[ -2, -1],
[-14, -9]])

练习

【1】利用列表推导式写矩阵乘法

一般的矩阵乘法根据公式，可以由三重循环写出：

In [140]: M1 = np.random.rand(2,3)

In [141]: M2 = np.random.rand(3,4)

In [142]: res = np.empty((M1.shape[0],M2.shape[1]))

In [143]: for i in range(M1.shape[0]):
…: for j in range(M2.shape[1]):
…: item = 0
…: for k in range(M1.shape[1]):
…: item += M1[i][k] * M2[k][j]
…: res[i][j] = item
…:

In [144]: ((M1@M2 - res) < 1e-15).all() # 排除数值误差

Out[144]: True

请将其改写为列表推导式的形式。

M1 = np.random.rand(2,3)
M2 = np.random.rand(3,4)
res = [[sum([M1[i][k] * M2[k][j] for k in range(M1.shape[1])]) for j in range(M2.shape[1])] for i in range(M1.shape[0])]
((M1@M2 - res) < 1e-15).all()

True

【2】更新矩阵

• 卡方统计量

【3】改进矩阵计算的性能

【4】连续整数的最大长度