一、python基础

下面的python基础涉及python的基本数据结构等知识，本来想着在这里补充上的，试了一下发现并没有网上一些教程写的好，本着不重复造轮子的想法（其实就是懒）也就不加了，如果需要的话可参考廖雪峰的python教程

1、列表推导式和条件赋值

列表推导式：按照一定的语法帮助简化操作，可以较容易的获取一个列表，语法为[A for i in B]，其中A为函数名（需要注意的是别忘了要带参数比如：A(i)），B是一个迭代的对象。具体例子如下所示：

def my_func(x):
    return x * x
[myfunc(i) for i in range(5)]

## 结果如下
[0, 1, 4, 9, 16]

## 列表表达式还可以进行多层嵌套
[x + y for x in range(2) for y in (3, 4)]
## 结果如下
[3, 4, 4, 5]
## 个人理解：多层嵌套下相当于多重for循环，这个结果也验证了这个想法

条件赋值：类似Java的三目运算符的作用，语法为a if condition else b，翻译一下就是如果condition为true，则等于a，否则等于b，具体例子如下：

value = 1 if 1 > 0 else 0

## value结果如下
1

条件赋值也可结合列表使用，例子如下：

[i if i < 2 else 2 for i in range(5)]

## 结果如下
[0, 1, 2, 2, 2]

2、匿名函数与map方法

匿名函数：顾名思义，匿名函数不需要函数名，在python中匿名函数可以借助lambda关键字实现，语法为lambda 参数 ： 运算逻辑，相当于封装了一组一次性的操作逻辑给使用者进行调用，例子如下：

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

## 结果如下
[0, 2, 4, 6, 8]

上述例子的用法很好理解，其实相当于列表推导式的语法，只不过这里的函数换成了lambda x : x * 2，匿名函数其实也可以给他“命名”以供多次调用，但是个人认为如果是这样的话应该还是封装成一个函数较好，这样易于读代码和维护代码。

map方法：该方法提供了一种函数映射关系，例如我们上面的例子需要指定i为参数，使用map则只需要将函数和参数指定就可以产生映射关系，例子如下：

map(lambda x : x * 2, range(5))
## 这样返回的是一个map对象，可用list函数转成list对象
list(map(lambda x : x * 2, 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']

3、zip对象与enumerate方法

---

zip对象：zip函数可以把多个可迭代的对象打包成一个元组，类型为zip类型，用tuple和list可以得到相应的结果，例子如下：

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

## 运行结果
[('a', 'd', 'h'), ('b', 'e', 'i'), ('c', 'f', 'j')]

多个迭代对象往往会使用到zip函数，例子如下：

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

## 运行结果
a d h
b e i
c f j

zip也可搭配dict使用，构成一个字典对象，例子如下所示：

dict(zip(L1,L2))

## 运行结果
{
    'a': 'd', 'b': 'e', 'c': 'f'}

当然，python还提供了一个解压缩的方法，在zip对象前面加上*，例子如下：

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

## 运行结果
[('a', 'b', 'c'), ('d', 'e', 'f'), ('h', 'i', 'j')]

enumerate方法：enumerate可以再迭代时绑定元素的遍历序号，例子如下所示：

for index, value in enumerate(L1):
    print(index, value)

## 运行结果
0 a
1 b
2 c

二、Numpy基础

这部分主要是了解一些Numpy库里api的用法，这里根据课件的分类做成一个工具，方便日后查找，有新的api用法也将进行补充：

1.np数组的构造

最基本的用法是通过array构造，例子如下：

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

## 结果
array([1, 2, 3])

构造一个等差序列： np.linspace(起始，终止（包含），样本个数), np.arange（起始，终止（不包含），步长），注意的是包含和不包含表示这是一个左闭右开区间还是一个闭区间，例子如下：

np.linspace(0,5,5)
## 结果
array([0.  , 1.25, 2.5 , 3.75, 5.  ])

np.arange(1,5,1)
## 结果
np.arange(1,5,1)

构造一个特殊矩阵：

• np.zeros(矩阵维度)：构造一个全0填充的矩阵
• np.eye(单位矩阵的维度)：构造一个单位矩阵，注意参数是一个数，单位矩阵是M*M的
• np.full(矩阵维度，填充数值)：构造一个指定维度的矩阵，使用指定数值进行填充，也可传入列表填充每列的值

np.eye(3)
## 结果
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

np.zeros((3,3))
## 结果
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

np.full((3,3),1)
## 结果
array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]])

np.full((3,3),[1,2,3])
## 结果
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

构造一个随机矩阵：

• np.random.rand(n)：生成服从0-1分布的n个随机数
• np.random.randn(m, n)：生成M行N列符合标准正态分布的矩阵
• np.random.randInt(low, high, size)：生成指定最小值low、最大值high（不包含）、维度size的随机整数矩阵
• np.choice(list, size, replace=(true/false), p=p_list)：从给定的list里按照p_list中的概率生成size维度的矩阵，默认抽取方式为有放回抽样和均匀采样

具体例子就不写了，记一些课件中的特殊用法吧：

## 对于服从区间 a 到 b 上的均匀分布可以如下生成：
a, b = 5, 15
(b - a) * np.random.rand(3) + a
## 结果
array([ 9.67438882, 12.49445466,  6.51381903])

## 对于服从方差为 σ2 均值为 μ 的一元正态分布可以如下生成：
sigma, mu = 2.5, 3
mu + np.random.randn(3) * sigma
## 结果如下
array([5.89540275, 2.56563403, 1.56208693])

2.np数组的变形与合并

转置：T，np对象.T就可以得到一个转置后的矩阵

合并：r_和c_，分别表示左右合并和上下合并，从例子中更容易理解

np.r_[np.array([[1,2,3],[4,5,6]]),np.array([[1,2,3],[4,5,6]])]
## 结果
array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 3],
       [4, 5, 6]])
## 这里有一点需要注意的是，一维向量合并后还是一维向量，比如[1,2,3]和[1,2,3]合并后是[1,2,3,1,2,3]

np.c_[np.array([1,2,3]),np.array([1,2,3])]
## 结果
array([[1, 1],
       [2, 2],
       [3, 3]])
## 当一维数组和二维数组进行合并时，应当把其视作列向量，只能使用c_操作，并且需要长度匹配

维度变换：reshape，通过该函数可以指定维度将矩阵进行重新排列，在使用时有两种模式，分别为 C 模式和 F 模式，分别以逐行和逐列的顺序进行填充读取。下面给出课件中的例子方便理解：

In [63]: target = np.arange(8).reshape(2,4)

In [64]: target
Out[64]: 
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

In [65]: target.reshape((4,2), order='C') # 按照行读取和填充
Out[65]: 
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7]])

In [66]: target.reshape((4,2), order='F') # 按照列读取和填充
Out[66]: 
array([[0, 2],
       [4, 6],
       [1, 3],
       [5, 7]])

reshape函数的一个有意思的点是可以指定维度为-1，代表空缺该维度，个人理解这是什么意思呢，还是通过举例子来说明吧

## 当要求变换reshape(-1,n)时候，意思是将矩阵列给固定下来，变换后的矩阵为n列，行则由数据多少决定
## 同理，当要求变换成reshape(m,-1)时，则固定矩阵的行为m，列则由数据多少决定

3.数组的索引与切片

数组的切片模式支持使用 slice 类型的 start:end:step 切片，还可以直接传入列表指定某个维度的索引进行切片，具体例子如下：

target = np.arange(16).reshape(4,4)
## 结果
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

target[:, [0,2]]
## 结果
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10],
       [12, 14]])

np.ix_(array1,array2) 在对应的维度上使用布尔索引或者列表索引，原理是根据两个数组生成的笛卡尔积去原数组中找到对应元素后进行排列

target[np.ix_([True, False, True, True], [True, False, True, False])]
## 结果
array([[ 0,  2],
       [ 8, 10],
       [12, 14]])
## 上述结果选取了(0,0)(0,2)等，依据是与运算

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

4.常用函数

同样地，这里也将写成工具集的形式，后续有其他好用的函数也会添加进来：

• where：np.where(a>0, a, 5) ，对应位置为True时填充a对应元素，否则填充5
• nonzero(a)：返回a中非零数的索引
• a.argmax()：返回a中最大值的索引
• a.min()：返回a中最小值的索引
• a.any()：当a中至少存在一个True或者非零元素时返回True，否则返回False
• a.all()：当a中元素全为True或者非零元素时返回True，否则返False
• a.cumprod()：累乘a中的元素函数，返回相同长度的数组
• a.cumsum()：累加a中的元素函数，返回相同长度的数组
• a.diff()：a中每个元素和前一个元素做差，返回的长度是原数组长度减一，因为第一个元素没有前一个元素做差

下面记录一些统计函数：

• a.max()：最大值
• a.min()：最小值
• a.mean()：均值
• a.median()：中位数
• a.var()：方差
• a.sum()：求和
• a.max()：最大值
• np.quantile (a,0.5)：a的0.5分位数
• np.cov(array1, array2)：计算协方差
• a.max()：最大值

对于有缺失值的数组，使用上述统计函数返回的结果也为缺失值，如果需要略过缺失值，则需要使用nan*，比如a.nanmax()

5.广播机制

广播机制用于处理两个不同维度数组之间的操作

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

当二维数组a和b进行操作时，两个数组维度完全一致时，对应元素进行相关操作，维度不一致时报错。但是，当其中每个数组是m×1 或者 1×n时，把1这个维度扩充到另一个数组对应维度大小后进行计算，下面给出课件中的例子

In [112]: res = np.ones((3,2))

In [113]: res
Out[113]: 
array([[1., 1.],
       [1., 1.],
       [1., 1.]])

In [114]: res * np.array([[2,3]]) # 扩充第一维度为3
Out[114]: 
array([[2., 3.],
       [2., 3.],
       [2., 3.]])

In [115]: res * np.array([[2],[3],[4]]) # 扩充第二维度为2
Out[115]: 
array([[2., 2.],
       [3., 3.],
       [4., 4.]])

In [116]: res * np.array([[2]]) # 等价于两次扩充
Out[116]: 
array([[2., 2.],
       [2., 2.],
       [2., 2.]])

当一维数组和二维数组进行操作时，一维数组等价的看成是1行n列

6.向量与矩阵的计算

• a.dot(b)：a和b向量做内积运算
• a@b：矩阵a和矩阵b做乘法

向量范数和矩阵范数： np.linalg.nor(矩阵，ord)，ord可选值如下

ord	norm for matrices	norm for vectors
None	Frobenius norm	2-norm
‘fro’	Frobenius norm	–
‘nuc’	nuclear norm	–
inf	max(sum(abs(x), axis=1))	max(abs(x))
-inf	min(sum(abs(x), axis=1))	min(abs(x))
0	–	sum(x != 0)
1	max(sum(abs(x), axis=0))	as below
-1	min(sum(abs(x), axis=0))	as below
2	2-norm (largest sing. value)	as below
-2	smallest singular value	as below
other	–	sum(abs(x)ord)(1./ord)

三、课后习题

EX1：利用列表推导式写矩阵乘法

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

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

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

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

In [141]: 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 [142]: (np.abs(M1@M2 - res) < 1e-15).all() # 排除数值误差
Out[142]: True

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

解题如下：

import numpy as np

M1 = np.random.rand(2, 3)
M2 = np.random.rand(3, 4)
res = np.empty((M1.shape[0], M2.shape[1]))

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])]
# ans = [matrix_func(i, j, k) for i in range(M1.shape[0]) for j in range(M2.shape[1]) for k in range(M1.shape[1])]

print(np.abs((M1@M2 - res) < 1e-15).all())

这题最开始想用一个函数加上列表推导式完成，结果弄了半天发现好像并不行，看了答案和视频讲解后理解了一些大佬的做法和列表推导式的使用技巧，上述结果就是参考答案。说说自己的理解，首先观察矩阵乘法得到的是一个二维数组，既然是二维的，那框架应该是[ [ ] ]，最外层是i循环[ [ ] for i in range(M1.shape[0])]，内层还有两重循环，最内层k循环需要累加使用sum()函数，再加上j循环。其实关键是怎么分离循环，这点需要加强，切记。

Ex2：更新矩阵

设矩阵$ A_{m\times n}$ ，现在对 A 中的每一个元素进行更新生成矩阵 B ，更新方法是 $B_{ij}=A_{ij}\sum _{k=1}^n\frac{1}{A_{ik}}$ ，例如下面的矩阵为 A ，则$ B_{2,2}=5\times(\frac{1}{4}+\frac{1}{5}+\frac{1}{6})=\frac{37}{12}$ ，请利用 Numpy 高效实现。

KaTeX parse error: No such environment: split at position 7: \begin{̲s̲p̲l̲i̲t̲}̲A=\left[ \begin…

解题如下：

A = np.arange(1,10).reshape(3,3)
C = np.sum(1/A, axis = 1).reshape(-1,1)
B = A*C

参考答案是A*(1/A).sum(1).reshape(-1,1)

看答案之后才知道原来可以直接对np对象使用sum()函数

Ex3：卡方统计量

设矩阵 $A_{m\times n}$ ，记 $B_{ij}=\frac{({\sum }_{i=1}^m{A}_{ij})\times ({\sum }_{j=1}^n{A}_{ij})}{{\sum }_{i=1}^m{\sum }_{j=1}^n{A}_{ij}}$，定义卡方值如下：

${\chi }^2={\sum }_{i=1}^m{\sum }_{j=1}^n\frac{(A_{ij}-B_{ij}{)}^2}{B_{ij}}$

请利用 Numpy 对给定的矩阵 A 计算${\chi }^2$。

解题如下：

A = np.random.rand(3,2)
A_m = np.sum(A, axis = 0)
A_n = np.sum(A, axis = 1).reshape(-1, 1)
B = (A_m * A_n) / np.sum(A)
X = np.sum((A - B)*(A-B)/B)

Ex4：改进矩阵计算的性能

设$ Z$ 为 $m\times n $的矩阵， $B$ 和$ U$ 分别是 $m\times p$ 和$ p\times n$ 的矩阵， $B_i $为B的第i行，$ U_j$ 为 $U $的第 $j $列，下面定义 $\displaystyle R=\sum_{i=1}^m\sum_{j=1}n|B_i-U_j|2^2Z{ij} $，其中$ |\mathbf{a}|_2^2 $表示向量$ \mathbf{a} $的分量平方和$ \sum_i a_i^2$ 。

现有某人根据如下给定的样例数据计算 R 的值，请充分利用 Numpy 中的函数，基于此问题改进这段代码的性能。

解题如下：

np.random.seed(0)
m, n, p = 100, 80, 50
B = np.random.randint(0, 2, (m, p))
U = np.random.randint(0, 2, (p, n))
Z = np.random.randint(0, 2, (m, n))

# 错误解答：(((B.sum(1).reshape(-1, 1) - U.sum(0))**2)*Z).sum()

# 参考答案
(((B**2).sum(1).reshape(-1,1) + (U**2).sum(0) - 2*B@U)*Z).sum()

这题有些天真了，看了答案后发现主要问题在于没有把B - U这个转换做好

还有需要注意的一点是直接用np对象做sum的话，不管指定沿着哪个维度累加，最后都会变成一行N列的向量

Ex5：连续整数的最大长度

输入一个整数的 Numpy 数组，返回其中递增连续整数子数组的最大长度。例如，输入 [1,2,5,6,7]，[5,6,7]为具有最大长度的递增连续整数子数组，因此输出3；输入[3,2,1,2,3,4,6]，[1,2,3,4]为具有最大长度的递增连续整数子数组，因此输出4。请充分利用 Numpy 的内置函数完成。（提示：考虑使用 nonzero, diff 函数）

解答如下：

# 参考答案
np.diff(np.nonzero(np.r_[1,np.diff(a)!=1,1])).max()

这题用np的内置函数完成确实没想到，在leetcode上好像刷过这个题（不用numpy的话用两个指针探测最大长度应该是可行的），总结一下大佬给的参考答案的思路吧

首先利用diff函数得到相减后的数组，并且利用布尔索引将数组转换为相邻数值间差不为1的值设置为1，相邻数值间差为1的设置为0，为nonzero函数做准备，这里需要注意的是，前后要补1，因为最开始这个数没有数字减，最后一个数没有数减它，把[1,2,3,4]作为例子代入也能明白为什么要补1

接着用nonzero函数得到不为0的索引值数组，比如[2,5]那么就代表了索引2和5中间的数字是连续的

最后再利用diff函数做一次差值就能得到原始数组中各个整数连续段所包含的整数个数

写在最后

人太懒，好久没写过博客了，第一次参加datawhale的组队学习活动，因为之前主要还是做java，对python了解一些但也不是特别熟悉，学习起来还是有些吃力，特别是最后的习题也花了蛮久的时间，还是半看答案半做才做完。虽然困难重重，花了大概一整天的时间，但也算是完成了第一次作业，可喜可贺，希望能继续坚持下去，也希望能把坚持写博客的习惯养成，不要三天打鱼两天晒网。