DataWhale_Pandas_预备知识

0.序

pandas对数据分析来说，可以说是可以起到至关重要的作用；熟练运用pandas既可以大大提升我们的工作效率，还能轻而易举的和其他工作产生联动性。这一专题是跟随datawhale学习pandas的打卡学习专题，也希望能对读者有帮助；
这一章节，做个预热，学习一些python及numpy模块的知识；

一.Python基础

先导入第三方模块

import numpy as np
import timeit

1.列表推导式与条件赋值

L = []
'''当我们想要生成一个递增数字序列，可以先定义一个函数'''


def my_func(x):
    return 2 * x


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

print(L)
'''
[0, 2, 4, 6, 8]
'''

我们可以利用列表推导式简化代码

print([my_func(i) for i in range(5)])
'''
[0, 2, 4, 6, 8]
'''

同时列表表达式支持多层嵌套

print([m + '_' + n for m in ['a', 'b'] for n in ['c', 'd']])
'''
['a_c', 'a_d', 'b_c', 'b_d']
'''

除了列表推导式，还有一个使用的语法糖是条件赋值

'''
value = a if condition else b'

即如果满足condition条件则返回a，否则返回b
'''
value = 'cat' if 2 > 1 else 'dog'
print(value)
'''cat'''

截断列表中超过5的元素,即大于5的数用5表示

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

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

2.匿名函数与map方法

举个例子

my_func_1 = lambda x: 2 * x

my_func_1(3)
'''6'''

multi_para_func = lambda a, b: a + b

multi_para_func(1, 2)
'''3'''

我们不关心函数的名字，只关心函数之间的逻辑映射关系

print([(lambda x: 2 * x)(i) for i in range(5)])
'''[0, 2, 4, 6, 8]'''

上面的写法，python中提供了map函数完成，返回一个map对象，需要转化成list

'''
map(匿名函数, 变量)
'''
print(list(map(lambda x: 2 * x, range(5))))
'''[0, 2, 4, 6, 8]'''

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

print(list(map(lambda x, y: str(x) + '_' + y, range(5), list('abcde'))))
'''
['0_a', '1_b', '2_c', '3_d', '4_e']

其实lambda就是表达映射关系的函数，map有点遍历的味道
'''

3.zip对象和enumerate方法

zip函数将多个可迭代对象打包成一个元组（可迭代），返回的是一个zip对象

L1, L2, L3 = list('abc'), list('def'), list('hij')
print(zip(L1, L2, L3))
'''
如果不用list或tuple打包，那么返回的就是一个zip的对象

<zip object at 0x7fd56b553500>
'''
print(list(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对象

print(dict(zip(L1, L2)))
'''
{'a': 'd', 'b': 'e', 'c': 'f'}
'''

python也提供了*操作符和zip联合使用来进行解压操作

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

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

二.Numpy基础

1.构造numpy数组

1.1一般构造数组

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

1.2构造等差序列数组

# ### np.linspace(起始, 终止(包含),样本个数)
print(np.linspace(1, 5, 11))
'''
取1-5间的等差数列，结果数组长度为11

[1.  1.4 1.8 2.2 2.6 3.  3.4 3.8 4.2 4.6 5. ]
'''


# ### np.arange(起始, 终止(不包含), 步长)
print(np.arange(1, 5, 2))
'''
取1-5（不包括5）中的等差数列，步长为

[1 3]
'''

1.3特殊矩阵

### np.zeros() - 全零矩阵
print(np.zeros((2, 3)))
'''
创建一个两行三列的全零矩阵

[[0. 0. 0.]
 [0. 0. 0.]]
'''

# ### np.eye(num) - 单位矩阵
print(np.eye(3))
'''
创建一个3*3的单位矩阵

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
'''

# ### np.eye(num, k) - 伪单位矩阵
print(np.eye(3, k=1))
'''
创建一个伪单位矩阵，此矩阵向右偏移主对角线一个单位

[[0. 1. 0.]
 [0. 0. 1.]
 [0. 0. 0.]]
'''

print(np.eye(3, k=-1))
'''
[[0. 0. 0.]
 [1. 0. 0.]
 [0. 1. 0.]]

可以看出，k为正代表向右偏移，k为负则代表向左偏移


# ### np.full() - 填充矩阵
print(np.full((2, 3), 10))
'''
创建一个2行3列的矩阵，每个单元都是10

[[10 10 10]
 [10 10 10]]
'''

print(np.full((2, 3), [1, 2, 3]))
'''
创建一个2行3列的矩阵，每列的值通过传入列表填充

[[1 2 3]
 [1 2 3]]
'''

1.4随机矩阵

# ### np.random.rand() - 生成0-1均匀分布的随机数组
print(np.random.randn(3))
'''
生成0-1均匀分布的的3个随机数

[0.02605579 0.71166211 0.6767805 ]
'''

print(np.random.rand(3, 3))
'''
生成3*3的数组，数组的数服从0-1均匀分布

[[0.26625303 0.0105758  0.60136024]
 [0.56246983 0.20525019 0.53976412]
 [0.19432433 0.56442468 0.46587432]]
'''

# #### 若想生成服从区间a-b上均匀分布的数组
a, b = 5, 15
print((b - a) * np.random.rand(3) + a)
'''
[ 9.72424664 11.53581536  5.35203786]
'''

# ## 服从0-1标准正态分布的数组
print(np.random.randn(3))
'''
[ 0.04060852 -0.25813079  0.68928363]
'''

print(np.random.randn(2, 2))
'''
生成2*2的服从0-1的标准正态分布数组

[[ 0.6633934 -0.1198928]
 [-0.5722788 -1.3129398]]
'''

# #### 若想生成服从方差为𝜎2,均值为𝜇的一元正态分布
sigma, mu = 2.5, 3
print(mu + np.random.randn(3) * sigma)
'''
[0.31750625 1.25716176 4.51778326]
'''

# ## 指定生成随机整数的最小值、最大值和维度大小
low, high, size = 5, 15, (2, 2)
print(np.random.randint(low, high, size))
'''
生成一个2*2的整数数组，数组中元素的最小值为5，最大值为15

[[ 9 12]
 [10 13]]
'''

从给定的列表中，以一定的概率和方式抽取结果，当不指定概率时为均匀采样，默认抽取方式为有放回抽样

my_list = ['a', 'b', 'c', 'd']
print(np.random.choice(my_list, 2, replace=False, p=[0.1, 0.7, 0.1, 0.1]))
'''
参数：
    replace
        用来设置是否可以取相同元素，True表示可以取相同数字，False表示不可以取相同数字，默认是True
    p为概率数组，表示选中每个元素的概率

['b' 'c']
'''

print(np.random.choice(my_list, (3, 3)))
'''
从给定列表中，随机均匀有放回的抽取一个3*3的数组

[['d' 'a' 'b']
 ['b' 'd' 'd']
 ['d' 'd' 'a']]
'''

当返回的元素个数和原列表相同时，等价使用permutation函数，即打散原列表

print(np.random.permutation(my_list))
'''
['c' 'a' 'd' 'b']
'''

随机种子，确认随机种子后，能固定随机数的输出结果

np.random.seed(0)
print(np.random.rand())
'''
0.5488135039273248
'''

np.random.seed(0)
print(np.random.rand())
'''
0.5488135039273248
'''

2.numpy数组的变形与合并

2.1矩阵的转置

print(np.zeros((2, 3)).T)
'''
原本是生成一个二行三列的全零矩阵，转置后变换为一个二列三行的全零矩阵

[[0. 0.]
 [0. 0.]
 [0. 0.]]
'''

2.2矩阵的合并(以二维数组为例)

# ### 上下合并
print(np.r_[np.zeros((2, 3)), np.zeros((2, 3))])
'''
两个二行三列的全零矩阵，上下合并后，成为一个四行三列的全零矩阵

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
'''

# ### 左右合并
print(np.c_[np.zeros((2, 3)), np.zeros((2, 3))])
'''
两个二行三列的全零矩阵，左右合并后，成为一个二行六列的全零矩阵

[[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]]
'''


# ### 一维数组与二维数组合并：应把其视作列向量，在长度匹配的情况下只能使用左右合并操作
print(np.array([0, 0]))
'''
[0 0]
'''

print(np.zeros((2, 1)))
'''
[[0.]
 [0.]]
'''

try:
    np.r_[np.array([0, 0]), np.zeros((2, 1))]
except Exception as e:
    Err_Msg = e

print(Err_Msg)
'''
可以看出，在长度不匹配的情况下无法上下合并
'''

print(np.array([0, 0]))
'''
[0 0]
'''

print(np.zeros(2))
'''
[0. 0.]
'''


print(np.r_[np.array([0, 0]), np.zeros(2)])
'''
两个两行一列的数组按行合并为四行一列

[0. 0. 0. 0.]
'''

print(np.c_[np.array([0, 0]), np.zeros((2, 3))])
'''
一个两行一列的数组和一个两行三列的数组，按列合并为两行四列的数组

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]]
'''

# ### 维度变换
'''使用reshape把原数组按照新的维度重新排列'''
target = np.arange(8).reshape(2, 4)
print(np.arange(8))
print(target)
'''
将一维数组按二行四列的二维数组形式重排

[[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]])
'''

# ### 将n*1的数组转成一维数组
target = np.ones((3, 1))
print(target)
'''
[[1.]
 [1.]
 [1.]]
'''

target.reshape(-1)
'''
array([1., 1., 1.])
'''

2.3数组的切片和索引

target = np.arange(9).reshape(3, 3)
print(target)
'''
[[0 1 2]
 [3 4 5]
 [6 7 8]]

创建一个0-8的3*3数组
'''

print(target[:-1, [0, 2]])
'''
去掉末位元素，每隔两个元素一切
'''

# ## 利用np.ix_在对应的维度上使用布尔索引，但此时不能使用slice切片
print(target)
'''
[[0 1 2]
 [3 4 5]
 [6 7 8]]
'''

print(target[np.ix_([True, False, True], [True, False, True])])
'''
此处np.ix_方法将后面两个布尔数组生成笛卡尔积的映射关系，即
(True, True), (True, False), (True, True)
(False, True), (False, False), (False, True)
(True, True), (True, False), (True, True)

其中，只有(True, True)判断为True，并返回；即原target数组的0， 2， 6， 8（四个角）
'''

print(target[np.ix_([1, 2], [True, False, True])])
'''
此处np.ix_方法将后面两个布尔数组生成笛卡尔积的映射关系，即
(1, True), (1, False), (1, True)
(2, True), (2, False), (2, False)

其中，(1, Ture)表示第二行（从0开始计数），是否选择，True即选择
'''

# ## 当数组维度是一维时，可以直接进行布尔索引，无需np.ix_
new = target.reshape(-1)
print(new)
'''
[0 1 2 3 4 5 6 7 8]
'''

print(new[new%2 == 0])
'''
取出偶数，即能被2整除

[0 2 4 6 8]
'''

2.4常用函数

'''为了简单起见，这里假设函数输入的数组均为一维'''

# ## where - 条件函数，可以指定满足条件与不满足条件位置对应的填充值
a = np.array([-1, 1, -1, 0])
print(np.where(a > 0, a, 5))
'''
对不满足a > 0这个条件的元素，用5填充

[5 1 5 5]
'''

# # 返回索引的函数
'''
索引从0开始
nonzero - 返回非零数的索引
argmax - 返回最大值的索引
argmin - 返回最小值的索引
'''
b = np.array([-2, -5, 0, 1, 3, -1])
print(np.nonzero(b))
'''(array([0, 1, 3, 4, 5]),)'''

print(b.argmax())
'''4'''

print(b.argmin())
'''1'''

# # 判断序列的非零元素情况
'''
any - 若当前序列至少存在一个True或非零元素，返回True，否则返回False
all - 若当前序列全为True或非零元素，返回True，否则返回False
'''
c = np.array([0, 1])
print(c)
'''
[0 1]
'''

print(c.any())
'''
存在一个0则为True

True
'''

print(c.all())
'''
因为不全为非零元素（有一个0），所以返回False

False
'''

# # cumprod - 累乘函数
d = np.array([1, 2, 3])
print(d)
'''
[1 2 3]
'''
print(d.cumprod())
'''
1 = 1
2 = 1 * 2
6 = 1 * 2 * 3

[1 2 6]
'''

# # cumsum - 累加函数
print(d.cumsum())
'''
1 = 1
3 = 1 + 2
6 = 1 + 2 + 3

[1 3 6]
'''

# # diff - 做差函数
print(np.diff(d))
'''
第一个元素没有前一个元素，所以是缺失值
1 = 2 - 1
1 = 3 - 2

[1 1]
'''

# # 统计函数
'''
对于含有缺失值的数组，返回的结果也有缺失值

max - 最大值
min - 最小值
mean - 平均值
median - 中位数
std - 标准差
var - 方差
sum - 求和
quantile - 分位数
'''
target = np.arange(5)
print(target)
'''
[0 1 2 3 4]
'''

print(target.max())
'''4'''

print(target.min())
'''0'''

print(target.mean())
'''2.0'''

print(np.quantile(target, 0.5))
'''
0.5分位数即中位数

2.0
'''

# # 计算协方差和相关系数
target1 = np.array([1, 3, 5, 9])
target2 = np.array([1, 5, 3, -9])
print(np.cov(target1, target2))
'''
协方差

[[ 11.66666667 -16.66666667]
 [-16.66666667  38.66666667]]
'''

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

[[ 1.         -0.78470603]
 [-0.78470603  1.        ]]
'''

# # 二维数组中的axis参数
'''
当axis=0时，结果为列的统计指标
当axis=1时，结果为行的统计指标
'''
target = np.arange(1, 10).reshape(3, -1)
print(target)
'''
[[1 2 3]
 [4 5 6]
 [7 8 9]]
'''

print(target.sum(axis=0))
'''
[12 15 18]
'''

print(target.sum(axis=1))
'''
[ 6 15 24]
'''

2.5广播机制

# ## 标量和数组的操作
'''当一个标量和数组进行运算时，标量会自动把大小扩充为数组大小，之后进行逐元素操作'''
res = 3 * np.ones((2, 2)) + 1
print(res)
'''
[[4. 4.]
 [4. 4.]]
'''

res = 1 / res
print(res)
'''
[[0.25 0.25]
 [0.25 0.25]]
'''

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

[[1. 1.]
 [1. 1.]
 [1. 1.]]
'''

print(np.array([[2, 3]]))
'''[[2 3]]'''

print(res * np.array([[2, 3]]))

'''
扩充第一维度为3

[[2. 3.]
 [2. 3.]
 [2. 3.]]
'''

print(np.array([[2], [3], [4]]))
'''
[[2]
 [3]
 [4]]
'''

print(res * np.array([[2], [3], [4]]))
'''
扩充第二维度为2

[[2. 2.]
 [3. 3.]
 [4. 4.]]
'''

print(res * np.array([[2]]))
'''
等价两次扩充

[[2. 2.]
 [2. 2.]
 [2. 2.]]
'''

# ## 一维数组与二维数组的操作
'''
当一维数组Ak与二维数组Bm,n操作时，等价于把一维数组视作A1,k的二维数组，使用广播法则
'''
print(np.ones(3))
'''[1. 1. 1.]'''

print(np.ones((2, 3)))
'''
[[1. 1. 1.]
 [1. 1. 1.]]
 '''

print(np.ones(3) + np.ones((2, 3)))
'''
[[2. 2. 2.]
 [2. 2. 2.]]
'''

print(np.ones((2, 1)))
'''
[[1.]
 [1.]]
'''

print(np.ones(3) + np.ones((2, 1)))
'''
[[2. 2. 2.]
 [2. 2. 2.]]
'''

print(np.ones(1) + np.ones((2, 3)))
'''
[[2. 2. 2.]
 [2. 2. 2.]]
'''

2.6向量与矩阵的计算

# ## 向量内积 - dot
f = np.array([1, 2, 3])
print(f)
'''
[1 2 3]
'''

g = np.array([1, 3, 5])
print(g)
'''
[1 3 5]
'''

f.dot(g)
'''22'''

# ## 向量范数和矩阵范数 - np.linalg.norm
'''在矩阵范数的计算中，最重要的是ord参数'''
martix_target = np.arange(4).reshape(-1, 2)
print(martix_target)
'''
reshape(-1, 2) - 表示生成2列，-1表示行数自动计算

[[0 1]
 [2 3]]
'''

print(np.linalg.norm(martix_target, 'fro'))
'''
3.7416573867739413
'''

print(np.linalg.norm(martix_target, np.inf))
'''5'''


# ## 矩阵乘法
a = np.arange(4).reshape(-1, 2)
print(a)
'''
[[0 1]
 [2 3]]
'''

b = np.arange(-4, 0).reshape(-1, 2)
print(b)
'''
[[-4 -3]
 [-2 -1]]
'''

print(a @ b)
'''
[[ -2  -1]
 [-14  -9]]
'''

三.练习

# # 利用列表推导式写矩阵乘法
'''
一般的矩阵乘法根据公式，可以由三重循环写出
'''
M1 = np.random.rand(2, 3)
print(M1)
'''
[[0.71518937 0.60276338 0.54488318]
 [0.4236548  0.64589411 0.43758721]]
'''

M2 = np.random.rand(3, 4)   # 满足矩阵乘法的条件了
print(M2)
'''
[[0.891773   0.96366276 0.38344152 0.79172504]
 [0.52889492 0.56804456 0.92559664 0.07103606]
 [0.0871293  0.0202184  0.83261985 0.77815675]]
'''

res = np.empty((M1.shape[0], M2.shape[1]))
print(res)
'''
Ai,j * Bj,k = Ci,k
所以这里创建一个占位矩阵，矩阵的形状符合M1*M2得到的矩阵(2行4列

[[-3.5 -1.5  0.5  4.5]
 [ 1.   5.   3.  -9. ]]
'''

for i in range(M1.shape[0]):
    for j in range(M2.shape[1]):
        item = 0
        # 这里k既是M1的列，又是M2的行
        for k in range(M1.shape[1]):
            # item是M1矩阵i行k列和M2矩阵k行j列乘积的累加值（矩阵相乘的计算公式）
            item += M1[i][k] * M2[k][j]
        # i行k列和k行j列矩阵相乘得到i行j列的新矩阵
        res[i][j] = item

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


# ## 将其改写为列表推导式的形式
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()
'''
关键点在于列表推导式应该先从最内层的循环开始写，一步步推上去，难度不大
'''

# # 更新矩阵
A = np.arange(1, 10).reshape(-1, 3)
print(A)

res = np.empty((A.shape[0], A.shape[1]))

for i in range(A.shape[0]):
    for j in range(A.shape[1]):
        item_a = 0
        for k in range(A.shape[1]):
            item_a += 1/(A[i][k])
            item = A[i][j] * item_a
        res[i][j] = item

print(res)
'''
[[1.83333333 3.66666667 5.5       ]
 [2.46666667 3.08333333 3.7       ]
 [2.65277778 3.03174603 3.41071429]]
'''

# ## 更好的方法
C = A * (1/A).sum(1).reshape(-1, 1)
print(C)
'''
[[1.83333333 3.66666667 5.5       ]
 [2.46666667 3.08333333 3.7       ]
 [2.65277778 3.03174603 3.41071429]]
'''
# ### 如果看不懂，那就一步步拆解
print(A)
'''
[[1 2 3]
 [4 5 6]
 [7 8 9]]
'''

# ### 求矩阵中每个元素的倒数
print(1/A)
'''
[[1.         0.5        0.33333333]
 [0.25       0.2        0.16666667]
 [0.14285714 0.125      0.11111111]]
'''

print((1/A).sum(1))     # 按列求和
'''
[1.83333333 0.61666667 0.37896825]
'''

# 因为按列求和是1*3的矩阵，无法和A相乘，所以这里得变化矩阵的形状，改成3*1

print((1/A).sum(1).reshape(-1, 1))
'''
[[1.83333333]
 [0.61666667]
 [0.37896825]]
'''


print(A * (1/A).sum(1).reshape(-1, 1))
'''
最后在和A相乘

[[1.83333333 3.66666667 5.5       ]
 [2.46666667 3.08333333 3.7       ]
 [2.65277778 3.03174603 3.41071429]]
'''

# # 卡方统计量
A = np.arange(1, 10).reshape(-1, 3)
B = A.sum(0) * A.sum(1).reshape(-1, 1) / A.sum()
result = ((A - B)**2 / B).sum()
print(result)
'''0.46875'''

# # 改进矩阵运算的性能
# ## 原方法
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))


def solution(B=B, U=U, Z=Z):
    l_res = []
    for i in range(m):
        for j in range(n):
            # 分量平方和
            norm_value = ((B[i] - U[:, j]) ** 2).sum()
            l_res.append(norm_value * Z[i][j])
    return sum(l_res)


solution(B, U, Z)
'''10056'''

# ## 改进方法：主要是向量（B-U）的分量平方和的计算
(((B ** 2).sum(1).reshape(-1, 1) + (U ** 2).sum(0) - 2 * B@U) * Z).sum()
'''10056'''


# ## 对比两个方法的性能
solution(B, U, Z).timeit()
timeit.timeit(solution(B, U, Z))

print(timeit.timeit(solution, number=1))
'''0.065'''

# # 连续整数的最大长度
f = lambda x: np.diff(np.nonzero(np.r_[1, np.diff(x) != 1, 1])).max()
f([1, 2, 5, 6, 7])
f([3, 2, 1, 2, 3, 4, 6])

# ## 我们分解来看
A = [1, 2, 5, 6, 7]

np.diff(A)  # 我们上面学到的做差函数
'''array([1, 3, 1, 1])'''

np.diff(A) != 1     # 看看这个差是不是等于1，如果不等于1说明不连续了
'''array([False,  True, False, False])'''

np.r_[1, np.diff(A) != 1, 1]    # 起始用两个1拼接一下
'''array([1, 0, 1, 0, 0, 1])'''

np.nonzero(np.r_[1, np.diff(A) != 1, 1])    # 找出非零项的序号,这几位是满足连续的
'''(array([0, 2, 5]),)'''

np.diff(np.nonzero(np.r_[1, np.diff(A) != 1, 1])).max()     # 看一下最大连续长度
'''
3
'''

四.总结

说实话，这期的练习还是有点难的，没有想到任务的一开始难度就那么大，难怪说这期的pandas质量很高。慢慢学，慢慢看，从painful到joyful，希望大家能从中学习到想要的知识～