Python零基础投喂(Pandas预备知识)

最新推荐文章于 2021-11-04 23:48:11 发布

心有猛虎嗷嗷待哺

最新推荐文章于 2021-11-04 23:48:11 发布

阅读量171

点赞数

分类专栏： Python零基础投喂

本文链接：https://blog.csdn.net/qq_41185007/article/details/111304056

版权

Python零基础投喂专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1.1 Python 基础

1.1.1 列表推导式与条件赋值

# 在生成一个数字序列的时候，在 Python 中可以如下写出：
L = []
def my_func(x):
    return 2+x

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

[2, 3, 4, 5, 6]

#事实上可以利用列表推导式进行写法上的简化：[* for i in *] 。其中，第一个 * 为映射函数，其输入为后面 i
#指代的内容，第二个 * 表示迭代的对象。
[my_func(i) for i in range(5)]

[2, 3, 4, 5, 6]

# 列表表达式还支持多层嵌套，如下面的例子中第一个 for 为外层循环，第二个为内层循环：
[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
value = 'cat' if 2>1 else 'dog'
value

'cat'

a,b='cat','dog'
condition = 2>1
if condition:
    value=a
else:
    value=b
value

'cat'

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.1.2 匿名函数与 map 方法

# 有一些函数的定义具有清晰简单的映射关系，例如上面的 my_func 函数，这时候可以用匿名函数的方法简
# 洁地表示：
# map() 会根据提供的函数对指定序列做映射。
# 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
my_func=lambda x:2+x
print(my_func(3))

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

# 但上面的用法其实违背了“匿名”的含义，事实上它往往在无需多处调用的场合进行使用，例如上面列表推
# 导式中的例子，用户不关心函数的名字，只关心这种映射的关系：
[(lambda x:2+x)(i) for i in range(5)]

[2, 3, 4, 5, 6]

# 对于上述的这种列表推导式的匿名函数映射，Python 中提供了 map 函数来完成，它返回的是一个 map 对象，需要通过 list 转为列表：
list(map(lambda x:2+x,range(5)))

[2, 3, 4, 5, 6]

# 对于多个输入值的函数映射，可以通过追加迭代对象实现：
list(map(lambda x,y:str(x)+'_'+y,range(5),list('abcde')))

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

1.1.3 zip 对象与 enumerate 方法

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

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

for index in range(len(l)):
    print(index)

for index in list(l):
    print(index)

a
b
c
d

#当需要对两个列表建立字典映射时，可以利用 zip 对象
dict(zip(l1,l2))

{'a': 'd', 'b': 'e', 'c': 'f'}

# 既然有了压缩函数，那么 Python 也提供了 * 操作符和 zip 联合使用来进行解压操作：
zipped = list(zip(l1,l2,l3))
zipped

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

list(zip(*zipped))

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

1.2 Numpy 基础

1.2.1 np 数组的构造

# 最一般的方法是通过 array 来构造：
import numpy as np
np.array([1,2,3])

array([1, 2, 3])

#下面讨论一些特殊数组的生成方式：
# 【a】等差序列：np.linspace, np.arange
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])

# 【b】特殊矩阵：zeros, eye, full
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.]])

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

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

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

#【c】随机矩阵：np.random
#最常用的随机生成函数为 rand, randn, randint, choice ，它们分别表示 0-1 均匀分布的随机数组、标准正态
#的随机数组、随机整数组和随机列表抽样：
np.random.rand(3) # 生成服从 0-1 均匀分布的三个随机数

array([0.05150622, 0.12623442, 0.05012188])

np.random.rand(3,3) # 注意这里传入的不是元组，每个维度大小分开输入

array([[0.49889527, 0.79718226, 0.9787408 ],
       [0.22907704, 0.63938829, 0.88717653],
       [0.98590688, 0.27542163, 0.84398524]])

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

array([ 8.94476537,  6.69380248, 10.53014755])

# randn 生成了 N(0, I) 的标准正态分布：
np.random.randn(3)

array([ 0.67401196, -0.61472109,  1.09121873])

np.random.randn(2,2)

array([[ 0.6208236 ,  0.64515623],
       [-0.59163504, -0.32420474]])

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

array([-0.56333074,  4.77478195,  7.04589299])

# randint 可以指定生成随机整数的最小值最大值和维度大小：
low,high,size=5,15,(2,2)
np.random.randint(low,high,size)

array([[ 7, 11],
       [ 5, 11]])

# choice 可以从给定的列表中，以一定概率和方式抽取结果，当不指定概率时为均匀采样，默认抽取方式为有放回抽样：
my_list=['a','b','c','d']
np.random.choice(my_list,2,replace=False,p=[0.1,0.7,0.1,0.1])

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

np.random.choice(my_list,(3,3))

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

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

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

# 最后，需要提到的是随机种子，它能够固定随机数的输出结果：
np.random.seed(0)

np.random.rand()

0.5488135039273248

np.random.seed(0)
np.random.rand()

0.5488135039273248

1.2.2 np 数组的变形与合并

#【a】转置：T
np.zeros((2,3)).T

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

np.zeros((2,3))

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

#【b】合并操作：r_, c_
# 对于二维数组而言，r_ 和 c_ 分别表示上下合并和左右合并：
np.r_[np.zeros((2,3)),np.zeros((2,3))]

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

np.c_[np.zeros((2,3)),np.zeros((2,3))]

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

# 一维数组和二维数组进行合并时，应当把其视作列向量，在长度匹配的情况下只能够使用左右合并的 c_ 操作：
np.zeros(2)

array([0., 0.])

np.array([0,0])

array([0, 0])

np.r_[np.array([0,0]),np.zeros(2)]

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

print(np.array([0,0]))
print(np.zeros((2,3)))
np.c_[np.array([0,0]),np.zeros((2,3))]

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





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

#【c】维度变换：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 即可：
target.reshape((4,-1))

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

# 下面将 n*1 大小的数组转为 1 维数组的操作是经常使用的：
target=np.ones((3,1))
target

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

target.reshape(-1)

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

# 1.2.3 np 数组的切片与索引
# 数组的切片模式支持使用 slice 类型的 start:end:step 切片，还可以直接传入列表指定某个维度的索引进行切片：
target=np.arange(9).reshape(3,3)
target

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

target[:-1,[0,2]] ## :-1,除了最后一个取全部  -1,取最后一个 ::-1取从后向前相反的元素

array([[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)
new

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

new[new%2==0]

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

1.2.4 常用函数

#为了简单起见，这里假设下述函数输入的数组都是一维的。
#【a】where
# where 是一种条件函数，可以指定满足条件与不满足条件位置对应的填充值：
a=np.array([[-1,1,-1,0]])
a

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

np.where(a>0,a,5)

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

#【b】nonzero, argmax, argmin
# 这三个函数返回的都是索引，nonzero 返回非零数的索引，argmax, argmin 分别返回最大和最小数的索引：
a = np.array([-2,-5,0,1,3,-1])
np.nonzero(a)

(array([0, 1, 3, 4, 5], dtype=int64),)

np.argmax(a)

a.argmax()

#【c】any, all
# any 指当序列至少 存在一个 True 或非零元素时返回 True ，否则返回 False
# all 指当序列元素 全为 True 或非零元素时返回 True ，否则返回 False
a=np.array([0,1])
print(a.any())
print(a.all())

True
False

#【d】cumprod, cumsum, diff
# cumprod, cumsum 分别表示累乘和累加函数，返回同长度的数组，diff 表示和前一个元素做差，由于第一个
# 元素为缺失值，因此在默认参数情况下，返回长度是原数组减 1
a=np.array([1,2,4])
a.cumprod()

array([1, 2, 8], dtype=int32)

a.cumsum()

array([1, 3, 7], dtype=int32)

np.diff(a)

array([1, 2])

# 【e】统计函数
# 常用的统计函数包括 max, min, mean, median, std, var, sum, quantile ，其中分位数计算是全局方法，因此不能通过 array.quantile 的方法调用：
target=np.arange(5)
target

target.max()

np.quantile(target,0.5) #0.5分位数

2.0

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

target=np.array([1,2,np.nan])
target

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

target.max()

nan

np.nanmax(target)

2.0

np.nanquantile(target,0.5)

1.5

# 对于协方差和相关系数分别可以利用 cov, corrcoef 如下计算：
target1=np.array([1,3,5,9])
target2=np.array([1,5,3,-9])
np.cov(target1,target2)

array([[ 11.66666667, -16.66666667],
       [-16.66666667,  38.66666667]])

np.corrcoef(target1,target2)

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

# 最后，需要说明二维 Numpy 数组中统计函数的 axis 参数，它能够进行某一个维度下的统计特征计算，当
# axis=0 时结果为列的统计指标，当 axis=1 时结果为行的统计指标：
target=np.arange(1,10).reshape(3,-1)
target

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

target.sum(0)  #列

array([12, 15, 18])

target.sum(1)  #行

array([ 6, 15, 24])

# 1.2.5 广播机制
# 广播机制用于处理两个不同维度数组之间的操作，这里只讨论不超过两维的数组广播机制。
#【a】标量和数组的操作
#当一个标量和数组进行运算时，标量会自动把大小扩充为数组大小，之后进行逐元素操作：
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]])

'''【b】二维数组之间的操作
当两个数组维度完全一致时，使用对应元素的操作，否则会报错，除非其中的某个数组的维度是 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]])

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

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

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

res * np.array([[2]])

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

#【c】一维数组与二维数组的操作
#当一维数组 Ak 与二维数组 Bm,n 操作时，等价于把一维数组视作 A1,k 的二维数组，使用的广播法则与【b】
#中一致，当 k! = n 且 k, n 都不是 1 时报错。
np.ones(3)

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

np.ones((2,3))

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

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

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

np.ones((2,1))

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

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

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

np.ones(1)

array([1.])

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

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

1.2.6 向量与矩阵的计算

#【a】向量内积：dot
a = np.array([1,2,3])
b = np.array([1,3,5])
a.dot(b)

#【b】向量范数和矩阵范数：np.linalg.norm
martix_target = np.arange(4).reshape(-1,2)
martix_target

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

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

3.7416573867739413

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

5.0

np.linalg.norm(martix_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

#【c】矩阵乘法：@
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.3 练习

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

M1 = np.random.rand(2,3)
M2 = np.random.rand(3,4)

print(M1)
print(M2)

[[0.60484552 0.73926358 0.03918779]
 [0.28280696 0.12019656 0.2961402 ]]
[[0.11872772 0.31798318 0.41426299 0.0641475 ]
 [0.69247212 0.56660145 0.26538949 0.52324805]
 [0.09394051 0.5759465  0.9292962  0.31856895]]

M1.shape[0] #shape[0]：表示矩阵的行数

M2.shape[1] #shape[1]：表示矩阵的列数

res = np.empty((M1.shape[0],M2.shape[1]))  #2*4的矩阵
res

array([[0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
        0.00000000e+000],
       [0.00000000e+000, 7.25288368e-321, 1.24610926e-306,
        1.42410974e-306]])

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
res

array([[0.58741267, 0.63376859, 0.48317497, 0.43810157],
       [0.14462935, 0.32859231, 0.42425732, 0.17537505]])

M1@M2

array([[0.58741267, 0.63376859, 0.48317497, 0.43810157],
       [0.14462935, 0.32859231, 0.42425732, 0.17537505]])

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

True

1.3.2 Ex2：更新矩阵

#先构建A矩阵
A=np.arange(1,10).reshape(3,-1)
A

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

#计算倒数
1/A

array([[1.        , 0.5       , 0.33333333],
       [0.25      , 0.2       , 0.16666667],
       [0.14285714, 0.125     , 0.11111111]])

(1/A).sum(1)

array([1.83333333, 0.61666667, 0.37896825])

(1/A).sum(1).reshape(-1,1)

array([[1.83333333],
       [0.61666667],
       [0.37896825]])

A*((1/A).sum(1).reshape(-1,1))

array([[1.83333333, 3.66666667, 5.5       ],
       [2.46666667, 3.08333333, 3.7       ],
       [2.65277778, 3.03174603, 3.41071429]])

1.3.3 Ex3：卡方统计量

# 定义A矩阵：
np.random.seed(0)
A = np.random.randint(10, 20, (8, 5))

array([[15, 10, 13, 13, 17],
       [19, 13, 15, 12, 14],
       [17, 16, 18, 18, 11],
       [16, 17, 17, 18, 11],
       [15, 19, 18, 19, 14],
       [13, 10, 13, 15, 10],
       [12, 13, 18, 11, 13],
       [13, 13, 17, 10, 11]])

A.sum(0)

array([120, 111, 129, 116, 101])

A.sum(1)

array([68, 73, 80, 79, 85, 61, 67, 64])

A.sum(0)*(A.sum(1).reshape(-1,1))

array([[ 8160,  7548,  8772,  7888,  6868],
       [ 8760,  8103,  9417,  8468,  7373],
       [ 9600,  8880, 10320,  9280,  8080],
       [ 9480,  8769, 10191,  9164,  7979],
       [10200,  9435, 10965,  9860,  8585],
       [ 7320,  6771,  7869,  7076,  6161],
       [ 8040,  7437,  8643,  7772,  6767],
       [ 7680,  7104,  8256,  7424,  6464]])

B=A.sum(0)*(A.sum(1).reshape(-1,1))/A.sum()
B

array([[14.14211438, 13.08145581, 15.20277296, 13.67071057, 11.90294627],
       [15.18197574, 14.04332756, 16.32062392, 14.67590988, 12.77816291],
       [16.63778163, 15.38994801, 17.88561525, 16.08318891, 14.0034662 ],
       [16.42980936, 15.19757366, 17.66204506, 15.88214905, 13.82842288],
       [17.67764298, 16.35181976, 19.0034662 , 17.08838821, 14.87868284],
       [12.68630849, 11.73483536, 13.63778163, 12.26343154, 10.67764298],
       [13.93414211, 12.88908146, 14.97920277, 13.46967071, 11.72790295],
       [13.3102253 , 12.31195841, 14.3084922 , 12.86655113, 11.20277296]])

((A-B)**2/B).sum()

11.842696601945802

1.3.4 Ex4：改进矩阵计算的性能

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

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

U = np.random.randint(0, 2, (p, n))
U

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

Z = np.random.randint(0, 2, (m, n))
Z

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

B**2

array([[0, 1, 1, ..., 1, 0, 1],
       [0, 1, 1, ..., 1, 1, 0],
       [1, 0, 0, ..., 1, 1, 1],
       ...,
       [1, 0, 0, ..., 1, 1, 0],
       [0, 0, 0, ..., 1, 1, 0],
       [0, 1, 1, ..., 1, 1, 1]], dtype=int32)

B1=(B**2).sum(1).reshape(-1,1).T
B1

array([[30, 26, 26, 19, 23, 28, 32, 28, 27, 23, 21, 27, 25, 28, 26, 22,
        27, 27, 24, 15, 21, 25, 24, 26, 22, 29, 27, 31, 30, 25, 27, 25,
        27, 24, 25, 24, 21, 28, 25, 29, 24, 22, 24, 25, 25, 25, 33, 27,
        25, 25, 29, 21, 28, 31, 24, 26, 26, 24, 32, 28, 22, 27, 31, 27,
        24, 20, 23, 25, 25, 29, 20, 22, 24, 29, 27, 23, 30, 20, 25, 24,
        26, 26, 26, 15, 29, 30, 31, 30, 28, 30, 24, 16, 25, 20, 26, 28,
        20, 23, 28, 23]], dtype=int32)

U1=(U**2).sum(0)
U1

array([27, 26, 25, 32, 26, 21, 24, 27, 27, 29, 26, 25, 23, 29, 27, 22, 24,
       29, 30, 29, 25, 24, 21, 25, 24, 25, 27, 28, 26, 25, 24, 27, 28, 27,
       26, 24, 22, 27, 28, 28, 23, 21, 26, 23, 32, 26, 22, 24, 21, 28, 19,
       25, 22, 22, 28, 27, 24, 28, 25, 16, 25, 27, 25, 26, 24, 22, 26, 21,
       22, 27, 23, 26, 25, 27, 25, 20, 27, 29, 25, 26], dtype=int32)

BU1=2*B@U
BU1

array([[32, 34, 24, ..., 30, 32, 34],
       [24, 26, 30, ..., 28, 30, 28],
       [26, 30, 30, ..., 32, 24, 32],
       ...,
       [26, 24, 30, ..., 22, 22, 24],
       [30, 28, 32, ..., 30, 30, 30],
       [24, 22, 26, ..., 16, 26, 24]])

B1.T*U1-BU1

array([[778, 746, 726, ..., 840, 718, 746],
       [678, 650, 620, ..., 726, 620, 648],
       [676, 646, 620, ..., 722, 626, 644],
       ...,
       [595, 574, 545, ..., 645, 553, 574],
       [726, 700, 668, ..., 782, 670, 698],
       [597, 576, 549, ..., 651, 549, 574]])

((B1.T*U1-BU1)*Z).sum()

1.3.5 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 函数）'''

x=np.array([1,2,5,6,7])
x

array([1, 2, 5, 6, 7])

np.diff(x)!=1   #F为0，T为1

array([False,  True, False, False])

np.r_[1,np.diff(x)!=1,1]

array([1, 0, 1, 0, 0, 1], dtype=int32)

np.nonzero(np.r_[1,np.diff(x)!=1,1])

(array([0, 2, 5], dtype=int64),)

np.diff(np.nonzero(np.r_[1,np.diff(x)!=1,1]))

array([[2, 3]], dtype=int64)

np.diff(np.nonzero(np.r_[1,np.diff(x)!=1,1])).max()

心有猛虎嗷嗷待哺

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录