<jupyter_start><jupyter_text>1. import numpy<jupyter_code>import numpy as np<jupyter_output><empty_output><jupyter_text>2. 查看numpy版本以及配置<jupyter_code>print(np.__version__)
#np.show_config()<jupyter_output>1.15.1<jupyter_text>3. 创建长度为10的空向量<jupyter_code>np.zeros(10)<jupyter_output><empty_output><jupyter_text>4. 查看数组内存<jupyter_code>a = np.zeros((10,10))
print("bytes:%d" %(a.size*a.itemsize))
print("itemsize:%d" %a.itemsize)
print("size:%d" %a.size)
print(a)<jupyter_output>bytes:800
itemsize:8
size:100
[[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. 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. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]<jupyter_text>5. 得到numpy文档中对add函数的解释<jupyter_code>np.info(np.add)<jupyter_output>add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Add arguments element-wise.

Parameters
----------
x1, x2 : array_like
    The arrays to be added.  If ``x1.shape != x2.shape``, they must be
    broadcastable to a common shape (which may be the shape of one or
    the other).
out : ndarray, None, or tuple of ndarray and None, optional
    A location into which the result is stored. If provided, it must have
    a shape that the inputs broadcast to. If not provided or `None`,
    a freshly-allocated array is returned. A tuple (possible only as a
    keyword argument) must have length equal to the number of outputs.
where : array_like, optional
    Values of True indicate to calculate the ufunc at that position, values
    of False indicate to leave the value in the output alone.
**kwargs
    For other keyword-only arguments, see the
    :ref:`ufunc docs <ufuncs.kwargs>`.

Returns
-------
add : ndarray or scalar
    The[...]<jupyter_text>6. 创建一个除了第五个元素其他元素为空的向量<jupyter_code>z = np.zeros(10)
z[4] = 1
print (z)<jupyter_output>[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]<jupyter_text>7. 创建一个从49到89的向量<jupyter_code>np.arange(49,89)<jupyter_output><empty_output><jupyter_text>8. 翻转一个向量<jupyter_code>a = np.arange(50)
a[::-1]<jupyter_output><empty_output><jupyter_text>9. 创建一个值从0到8的3x3的矩阵<jupyter_code>np.arange(9).reshape((3,3))<jupyter_output><empty_output><jupyter_text>10. 找到数组中非0元素的索引<jupyter_code>np.nonzero([0,1,2,0,6])<jupyter_output><empty_output><jupyter_text>11. 创建一个3x3的单位矩阵<jupyter_code>np.eye(3)<jupyter_output><empty_output><jupyter_text>12. 创建一个3x3x3的随机数组<jupyter_code>np.random.random((3,3,3))<jupyter_output><empty_output><jupyter_text>13. 创建10x10的随机数数组并且找到最大值与最小值<jupyter_code>a = np.random.random((10,10))
a_min, a_max = a.min(),a.max()
print(a_min, a_max)
# print(a)<jupyter_output>0.0074002093211628095 0.9955838144915077<jupyter_text>14. 创建一个长度为30随机数组并找出他的平均值<jupyter_code>a = np.random.random(30)
Mean = a.mean()
print(Mean)<jupyter_output>0.4454909419797957<jupyter_text>15. 创建一个二维数组，其中边界值为1，其余值为0<jupyter_code>a = np.ones((10, 10))
a[1:-1,1:-1] = 0
print(a)<jupyter_output>[[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]<jupyter_text>16. 对于一个存在在数组，添加一个用0填充的边界<jupyter_code>a = np.ones((5, 5))
a = np.pad(a, pad_width=1, mode='constant', constant_values=0)
print(a)<jupyter_output>[[0. 0. 0. 0. 0. 0. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 0. 0. 0. 0. 0. 0.]]<jupyter_text>17. 以下表达式运行结果是什么？```python0 * np.nannp.nan == np.nannp.inf > np.nannp.nan - np.nan0.3 == 3 * 0.1```<jupyter_code>print(0 * np.nan)
print(np.nan == np.nan)
print(np.inf > np.nan)
print(np.nan - np.nan)
print(0.3 == 3 * 0.1)<jupyter_output>nan
False
False
nan
False<jupyter_text>18. 创建一个5x5的矩阵，并设置值1,2,3,4落在其对角线下方位置<jupyter_code>a = np.diag(1+np.arange(4), k=-1)
print(a)<jupyter_output>[[0 0 0 0 0]
 [1 0 0 0 0]
 [0 2 0 0 0]
 [0 0 3 0 0]
 [0 0 0 4 0]]<jupyter_text>> 这里我们来讲一下，np.diag这个函数，这个函数有些许的意思。> - 当你传入的参数是一个一维数组时，你得到的是一个以该一维数组为对角线的二维数组> - 当你传入的参数是一个二维数组时，你得到的是一个以对角线的一维数组> - 参数k，是用来标示对角线的位置，如果是-1，就是对角线下面一阶，如果是1，则是对角线上面一阶，以此类推。**我们来看一个例子**<jupyter_code># examples
a = np.arange(4).reshape((2,2))
b = np.arange(2)
print(a)
print(np.diag(a))
print(b)
print(np.diag(b))<jupyter_output>[[0 1]
 [2 3]]
[0 3]
[0 1]
[[0 0]
 [0 1]]<jupyter_text>19. 创建一个8x8 的矩阵，并且设置成棋盘样式<jupyter_code>a = np.zeros((8, 8), dtype=int)
a[1::2, ::2] = 1
a[::2, 1::2] = 1
print(a)<jupyter_output>[[0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]
 [0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]
 [0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]
 [0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]]<jupyter_text>> 在这里，我们讲一下python中双冒号的用法。> - 在最基础的list中，双冒号代表的意思是（从哪里开始：到哪里结束：每几部取一个元素）> - 在numpy的多维数组中，双冒号的作用是：（第几层::,第几行::，第几列::）> - 如果是负数的话，则是反向取值，应用的话就是字符串的翻转。**然后我们看一下例子**<jupyter_code># examples
a = np.arange(24).reshape((3,2,4)) #生成一个3x2x4的多维数组
print(a)
print(a[::,::2,::2]) #遍历每一层，每两行，每两列，取值
print(a[::2,::2,::2]) #每两层，每两行，每两列，取值
print(a[1::2,::2,::2]) #从第一层开始每两层，每两行，每两列，取值
str = "欢迎大家给我点star，嘻嘻嘻"
print(str[::-1])<jupyter_output>[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]

 [[16 17 18 19]
  [20 21 22 23]]]
[[[ 0  2]]

 [[ 8 10]]

 [[16 18]]]
[[[ 0  2]]

 [[16 18]]]
[[[ 8 10]]]
嘻嘻嘻，rats点我给家大迎欢<jupyter_text>20. 考虑一个 (6,7,8) 形状的数组，求其第100个元素的索引(x,y,z)<jupyter_code>np.unravel_index(100, (6, 7, 8))<jupyter_output><empty_output><jupyter_text>> 这里我们讲一下unravel_index这个函数：> - 这个函数是用来求取数组中某个元素的位置> - indices:要求取索引的数据，如果是一个数字，则返回一个元组代表了他的索引，如果是一个数组，则返回一个多维数组，每个小数组都代表了每一维的索引。> - dims:表示要求取的索引对应数组的维度**我们来看个例子**<jupyter_code>np.unravel_index(indices=[99,100,101], dims=(6, 7, 8))<jupyter_output><empty_output><jupyter_text>21. 用tile函数去创建一个 8x8的棋盘样式矩阵<jupyter_code>np.tile(np.array([[0, 1],[1, 0]]), (4,4))<jupyter_output><empty_output><jupyter_text>> （没错，又是我，小声bb）这次我们来讲一下np.tile> - 首先，这个函数是用来按某种方式重复某个矩阵从而实现矩阵的扩展> - 第一个参数是：要扩展的矩阵> - 第二个参数是：如何扩建，如果传入的是元组（1,2），那么就是行重复一次，列重复2次。如果传入的是一个数，那么就是列扩展。**我们来看个小例子**<jupyter_code>print(np.tile(np.array([[0,1]]), (1,2))) #行1，列2
print(np.tile(np.array([[0,1]]), (2,1))) #行2，列1
print(np.tile(np.array([[0,1]]), 2)) #列2<jupyter_output>[[0 1 0 1]]
[[0 1]
 [0 1]]
[[0 1 0 1]]<jupyter_text>22. 对一个5x5的随机矩阵做归一化<jupyter_code>a = np.random.random((5, 5))
a_max, a_min = a.max(), a.min()
a = (a - a_min)/(a_max - a_min)
print(a)<jupyter_output>[[0.08050577 0.01626421 0.91783023 0.72754503 0.20567642]
 [0.         0.42464496 0.45076977 0.63110828 0.51177089]
 [0.70211073 0.39623806 0.59813343 0.40126377 0.57336218]
 [0.53802696 0.43192207 0.5361353  1.         0.92133969]
 [0.76700841 0.73684713 0.02737611 0.08180195 0.42705149]]<jupyter_text>23. 创建一个将颜色描述为(RGBA)四个无符号字节的自定义dtype<jupyter_code>color = np.dtype([
    ("r", np.ubyte, 1),
    ("g", np.ubyte, 1),
    ("b", np.ubyte, 1),
    ("a", np.ubyte, 1)
])

print(color)<jupyter_output>[('r', 'u1'), ('g', 'u1'), ('b', 'u1'), ('a', 'u1')]<jupyter_text>> 我们讲一下 np.dtype> - 这个函数是用来自定义我们的数据类型的  24. 一个5x3的矩阵与一个3x2的矩阵相乘，实矩阵乘积是什么<jupyter_code>np.dot(np.ones((5,3)), np.ones((3, 2)))
np.ones((5,3))@np.ones((3, 2))<jupyter_output><empty_output><jupyter_text>25. 给定一个一维数组，对其在3到8之间的所有元素取反<jupyter_code>a = np.arange(11)
a = a[8:2:-1]
print(a)<jupyter_output>[8 7 6 5 4 3]<jupyter_text>26. 下面脚本运行后的结果是什么```pythonprint(sum(range(5),-1))from numpy import *print(sum(range(5),-1))```<jupyter_code>print(sum(range(5), -1))
from numpy import *
print(sum(range(5), -1))<jupyter_output>10<jupyter_text>> 解释：> 为什么是这样呢？> - 首先，我们先了解一下python标准库的sum函数，sum函数的第二个参数表示，求和以后再加一个数> - 但是，显然NumPy对sum函数有不同的实现，他的第二个参数是axis也就是求和的行或列。**让我们看个小例子**<jupyter_code>a = np.arange(12).reshape((3, 4))
print(a)
print(sum(a, axis=-1))
print(sum(a, axis=1))
print(sum(a, axis=0))<jupyter_output>[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[ 6 22 38]
[ 6 22 38]
[12 15 18 21]<jupyter_text>27. 考虑一个整数向量Z,下列表达合法的是哪个```pythonZ**Z2 > 2Z <- Z1j*ZZ/1/1ZZ```<jupyter_code>z = np.arange(5)
print(z**z)
print(2<<z>>2) #bit shift
print(z<-z)
print(1j*z) #复数
print(z/1/1)
# print(z<z>z) wrong<jupyter_output><empty_output><jupyter_text>> 我们解释一下位运算这里的东西：> - 左移运算就是乘2的位数> - 右移运算就是除以2的位数---> 还有numpy中的j表示的是复数  28. 下列表达式的结果分别是什么?```pythonnp.array(0) / np.array(0)np.array(0) // np.array(0)np.array([np.nan]).astype(int).astype(float)``` np.array(0) / np.array(0)<jupyter_code>np.array(0) // np.array(0)
np.array([np.nan]).astype(int).astype(float)<jupyter_output><empty_output><jupyter_text>> **Nan：Not a number** **Inf：Infinity(无穷大）** 当然容易搞混的还有None，None是python中用于标识空缺数据，Nan是nunpy和pandas中用于标识空缺数据，None是一个python特殊的数据类型， **但是NaN却是用一个特殊的float**  29. 如何从零位对浮点数组做舍入<jupyter_code>a = np.random.uniform(-10, +10, 10)
print(a)
print (np.copysign(np.ceil(np.abs(a)), a))<jupyter_output>[ 0.08067678  7.15673718 -9.16048693 -2.43296362 -5.42992065 -3.33577661
  7.39685508  5.64371225  9.07167516 -0.61907251]
[  1.   8. -10.  -3.  -6.  -4.   8.   6.  10.  -1.]<jupyter_text>> 讲解：> - 首先,np.ceil是向上取整> - 然后，copysign(a, b)是将b的符号赋值给a的元素> 为什么要这么做呢？> 我们可以想一下：> 如果a是个负数，我们不取绝对值，直接取整，那么会将位数舍去，但是如果a是个正数，他又会向上取整。  30. 如何找到两个数组中的共同元素?<jupyter_code>a = np.random.randint(0, 10, 10)
b = np.random.randint(0, 10, 10)
print(a)
print(b)
print(np.intersect1d(a, b))<jupyter_output>[9 9 1 7 7 9 3 3 0 5]
[0 0 7 9 4 1 7 2 3 7]
[0 1 3 7 9]<jupyter_text>> np.intersect1d是用来求取交集的函数  31. 如何忽略所有的 numpy 警告(尽管不建议这么做)<jupyter_code>defaults = np.seterr(all="ignore")
np.zeros(1)/0<jupyter_output><empty_output><jupyter_text>32. 下面的表达式是正确的吗?```pythonnp.sqrt(-1) == np.emath.sqrt(-1)```<jupyter_code>print(np.sqrt(-1) == np.emath.sqrt(-1))
print(np.sqrt(-1))
print(np.emath.sqrt(-1))<jupyter_output>1j<jupyter_text>> 讲解一下：emath是什么？> - NumPy中的自动域函数> - 可以更友好地使用数学函数，而不去考虑他的定义域> - 比如说：当我们对-1使用最初时的sqrt函数，会得到返回值nan，但是如果使用emath中的函数，他会为我们返回一个复数。相同的比如说对数函数。  33. 如何得到昨天，今天，明天的日期?<jupyter_code>yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')
print(yesterday)
today = np.datetime64('today', 'D')
print(today)
tomorrow = np.datetime64('today', 'D') + np.timedelta64(1, 'D')
print(tomorrow)<jupyter_output>2019-04-17<jupyter_text>> 日期时间与时间增量> - numpy从1.7开始，将时间变量加入到核心数据组中，但是由于python标准时间库中已经将datetime包含了进去，所以他叫做datetime64> - datetime的第二个参数指定了datetime的单位。日期单位是年（'Y'），月（'M'），周（'W'）和天（'D'），而时间单位是小时（'h'），分钟（'m'） ），秒（'s'），毫秒（'ms'）和一些额外的SI前缀基于秒的单位。> - NumPy允许减去两个Datetime值，这个操作产生一个带有时间单位的数字。 由于NumPy的核心没有物理量系统，因此创建了timedelta64数据类型以补充datetime64。**下面看个小例子**<jupyter_code>np.datetime64('1999-10-03', 'M')
np.datetime64('1999-10', 'D')
my_birthday = np.datetime64("1999-10-03", "D")
your_birthday = np.datetime64("1998-08-24", "D")
my_birthday - your_birthday<jupyter_output><empty_output><jupyter_text>34. 如何得到所有与2016年7月对应的日期<jupyter_code>Z = np.arange('2016-07', '2016-08', dtype='datetime64[D]')
print(Z)<jupyter_output>['2016-07-01' '2016-07-02' '2016-07-03' '2016-07-04' '2016-07-05'
 '2016-07-06' '2016-07-07' '2016-07-08' '2016-07-09' '2016-07-10'
 '2016-07-11' '2016-07-12' '2016-07-13' '2016-07-14' '2016-07-15'
 '2016-07-16' '2016-07-17' '2016-07-18' '2016-07-19' '2016-07-20'
 '2016-07-21' '2016-07-22' '2016-07-23' '2016-07-24' '2016-07-25'
 '2016-07-26' '2016-07-27' '2016-07-28' '2016-07-29' '2016-07-30'
 '2016-07-31']<jupyter_text>35. 如何直接在位计算(A+B)\*(-A/2)(不建立副本)?<jupyter_code>A = np.ones(3)*1
B = np.ones(3)*2
C = np.ones(3)*3
print(B)
np.add(A,B,out=B)
print(B)
print(A)
np.divide(A,2,out=A)
print(A)
print(A)
np.negative(A,out=A)
print(A)
print(A)
np.multiply(A,B,out=A)
print(A)<jupyter_output>[-0.5 -0.5 -0.5]
[-1.5 -1.5 -1.5]<jupyter_text>36. 用五种不同的方法去提取一个随机数组的整数部分<jupyter_code>a = np.random.uniform(-10, 10, 10)
print(a)
print(a - a%1)
np.floor(a)
np.ceil(a) - 1
a.astype(int)
np.trunc(a)<jupyter_output><empty_output><jupyter_text>> 讲解一下：> - np.floor 向下取整> - np.trunc 截取元素，也就是取最接近的整数。参数为array like的元素  37. 创建一个5x5的矩阵，其中每行的数值范围从0到4<jupyter_code>a = np.arange(5).astype(float64)
a = np.tile(a, (4,1))
print(a)
print(type(a))
b = np.zeros((5,5))
b += np.arange(5)
print(b)
print(type(b))<jupyter_output>[[0. 1. 2. 3. 4.]
 [0. 1. 2. 3. 4.]
 [0. 1. 2. 3. 4.]
 [0. 1. 2. 3. 4.]
 [0. 1. 2. 3. 4.]]
<class 'numpy.ndarray'><jupyter_text>38. 通过考虑一个可生成10个整数的函数，来构建一个数组<jupyter_code>def generate():
    for x in range(10):
        yield x
Z = np.fromiter(generate(),dtype=float,count=-1)
print (Z)<jupyter_output>[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]<jupyter_text>39. 创建一个长度为10的随机向量，其值域范围从0到1，但是不包括0和1<jupyter_code>np.random.uniform(0,1, 10)
Z = np.linspace(0,1,11,endpoint=False)[1:]
print(Z)
# 这是当时我看的那个人写的答案，但是在我查了np.linspace的用法以后，我认为他的答案是错的，他不满足随机<jupyter_output>[0.09090909 0.18181818 0.27272727 0.36363636 0.45454545 0.54545455
 0.63636364 0.72727273 0.81818182 0.90909091]<jupyter_text>> 讲解一下：> - np.linspace()是用来产生一个向量。> - 参数：start：起始值；end：最大值；endpoint：是否包含最大值，也就是end；retstep：步长> - 也正是因为这个步长，所以我说他的方法是错误的。  40. 创建一个长度为10的随机向量，并将其排序<jupyter_code>a = np.random.random(10)
print(a)
a.sort()
print(a)<jupyter_output>[0.81255397 0.35312583 0.34937138 0.39164577 0.92684109 0.10276133
 0.48956229 0.42140027 0.58769151 0.09750321]
[0.09750321 0.10276133 0.34937138 0.35312583 0.39164577 0.42140027
 0.48956229 0.58769151 0.81255397 0.92684109]<jupyter_text>41.对于一个小数组，如何用比 np.sum更快的方式对其求和<jupyter_code>a = np.arange(10)
import time
begin = time.time()
np.add.reduce(a)
end = time.time()
print(end - begin)
begin = time.time()
np.sum(a)
end = time.time()
print(end - begin)<jupyter_output>9.655952453613281e-05<jupyter_text>> 讲解一下：> - 在小阵列的数据上，np.add.reduce是要比np.sum快的，但是，当数据规模一上升，差异就消失了。> - 为什么呢？简单的说就是因为np.sum实际上调用的就是reduce，所差的时间也在参数处理和函数调用上。  42. 对于两个随机数组A和B，检查它们是否相等<jupyter_code>A = np.random.randint(0,2,5)
B = np.random.randint(0,2,5)
equal = np.allclose(A,B)
print(equal)<jupyter_output>False<jupyter_text>> 讲解一下：> - numpy的allclose方法，比较两个array是不是每一元素都相等，默认在1e-05的误差范围内 np.array_equal(A, B)  43. 创建一个只读数组(read-only)<jupyter_code>a = np.arange(5)
print(a)
a.flags.writeable = False
a[0] = 1<jupyter_output>[0 1 2 3 4]<jupyter_text>44. 将笛卡尔坐标下的一个10x2的矩阵转换为极坐标形式<jupyter_code>Z = np.random.random((10,2))
X,Y = Z[:,0], Z[:,1]
R = np.sqrt(X**2+Y**2)
T = np.arctan2(Y,X)
print (R)
print (T)<jupyter_output><empty_output><jupyter_text>45. 创建一个长度为10的向量，并将向量中最大值替换为1<jupyter_code>a = np.random.randint(0, 5, 10)
print(a)
a[a.argmax()] = 1
print(a)<jupyter_output><empty_output><jupyter_text>46. 创建一个结构化数组，并实现 x 和 y 坐标覆盖 [0,1]x[0,1] 区域<jupyter_code>Z = np.zeros((5,5), [('x',float),('y',float)])
Z['x'], Z['y'] = np.meshgrid(np.linspace(0,1,5),
                             np.linspace(0,1,5))
print(Z)<jupyter_output><empty_output><jupyter_text>> 讲解一下：> - np.meshgrid()其实就是在高维空间画网格用的函数> - 好多文章都说画网格，其实刚开始我是没有理解的，不过没有关系，我们来看个小栗子就好了<jupyter_code>a = np.random.randint(0, 5, 4)
b = np.random.randint(0, 8, 4)
print(a)
print(b)
[x, y] = np.meshgrid(a, b) # x是横向的线， y是纵向的线
print(x)
print(y)<jupyter_output><empty_output><jupyter_text>47. 给定两个数组X和Y，构造Cauchy矩阵C (Cij =1/(xi - yj)<jupyter_code>X = np.arange(8)
Y = X + 0.5
C = 1.0 / np.subtract.outer(X, Y)
print(np.linalg.det(C))<jupyter_output><empty_output><jupyter_text>> - substract,multiply等函数叫做ufunc，也就是通用函数> - ufunc.outer是Apply the ufunc op to all pairs (a, b) with a in A and b in B.简单的说就是应用ufunc到每一对数据上> - np.linalg.det是用来求行列式的，但是后两个维度必须是方阵**看个例子**<jupyter_code>a = np.arange(5)
b = a + 1
print(a)
print(b)
np.subtract.outer(a, b)<jupyter_output><empty_output><jupyter_text>48. 打印每个numpy标量类型的最小值和最大值<jupyter_code>for dtype in [np.int8, np.int32, np.int64]:
    print(np.iinfo(dtype).min)
    print(np.iinfo(dtype).max)
for dtype in [np.float32, np.float64]:
    print(np.finfo(dtype).min)
    print(np.finfo(dtype).max)
    print(np.finfo(dtype).eps)<jupyter_output><empty_output><jupyter_text>> - np.iinfo() Machine limits for integer types.> - np.finfo() Machine limits for floating point types.> - np.finfo().eps 所能表示的最小正数  49. 如何打印一个数组中的所有数值<jupyter_code># np.set_printoptions(threshold=np.nan)
Z = np.zeros((50,50))
print (Z)
np.set_printoptions(threshold=np.nan)
print (Z)<jupyter_output><empty_output><jupyter_text>> - 我们会发现，如果我们ndarray的数据一旦比较多的时候，我们在print的时候就会被折叠> - 这时候，我们就要使用np.setprintoptions()了> - - precision:输出结果保留精度的位数- - threshold:array数量的个数在小于threshold的时候不会被折叠- - edgeitems:在array已经被折叠后，开头和结尾都会显示edgeitems个数- - formatter:这个很有意思，像python3里面str.format(),就是可以对你的输出进行自定义的格式化**如果不明白，可以看一下上面的例子**  50. 给定标量时，如何找到数组中最接近标量的值<jupyter_code>Z = np.arange(100)
v = np.random.uniform(0,100)
index = (np.abs(Z-v)).argmin()
print (Z[index])<jupyter_output><empty_output><jupyter_text>51. 创建一个表示位置(x,y)和颜色(r,g,b)的结构化数组<jupyter_code>Z = np.zeros(10, [ ('position', [ ('x', float, 1),
                                  ('y', float, 1)]),
                   ('color',    [ ('r', float, 1),
                                  ('g', float, 1),
                                  ('b', float, 1)])])
print (Z)<jupyter_output><empty_output><jupyter_text>52. 对一个表示坐标形状为(100,2)的随机向量，找到点与点的距离<jupyter_code>Z = np.random.random((10,2))
X,Y = np.atleast_2d(Z[:,0], Z[:,1])
D = np.sqrt( (X-X.T)**2 + (Y-Y.T)**2)
print (D)<jupyter_output><empty_output><jupyter_text>> np.atleast_2d()是用来改变维度的，就是直接将其视为某个维度**比如说：**<jupyter_code>np.atleast_2d([1])
np.atleast_3d([1])<jupyter_output><empty_output><jupyter_text>53. 如何将32位的浮点数(float)转换为对应的整数(integer)<jupyter_code>a = np.arange(5, dtype=int32)
print(a)
a = a.astype(np.float32, copy=False)
print(a)<jupyter_output><empty_output><jupyter_text>54. 如何读取以下文件```1, 2, 3, 4, 56,  ,  , 7, 8 ,  , 9,10,11```<jupyter_code>np.genfromtxt(fname="./data.txt", dtype=np.int32, delimiter=',')<jupyter_output><empty_output><jupyter_text>> np.genfromtxt()函数：> - 用来将文件转换为表格> - 参数解析：>  - autostrip:是否自动去除空格>  - delimiter:分割符>  - fname:文件路径只有这个是必选的>  - miss:缺失值>  - missvalues:缺失值替换为什么>  - dtype:数据类型这里只列出常用的参数，如果大家还想深入了解，那么请大家看[这里](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.genfromtxt.html)  55. 对于numpy数组，enumerate的等价操作是什么<jupyter_code>Z = np.arange(9).reshape(3,3)
print(Z)
print("----------")
for index, value in np.ndenumerate(Z):
    print (index, value)
print("----------")
for index in np.ndindex(Z.shape):
    print (index, Z[index])<jupyter_output><empty_output><jupyter_text>**是什么呢？显然就是索引和值，不过多维数组的索引是一个tuple**  56. 生成一个通用的二维Gaussian-like数组<jupyter_code>X, Y = np.meshgrid(np.linspace(-1,1,10), np.linspace(-1,1,10))
D = np.sqrt(X*X+Y*Y)
sigma, mu = 1.0, 0.0
G = np.exp(-( (D-mu)**2 / ( 2.0 * sigma**2 ) ) )
print (G)<jupyter_output><empty_output><jupyter_text>57. 对一个二维数组，如何在其内部随机放置p个元素?<jupyter_code>a = np.zeros((10, 10))
print(a)
np.put(a, np.random.choice(range(10*10), 8, replace=False), 1)
print(a)<jupyter_output><empty_output><jupyter_text>> np.random.choice() 可以从一个int数字或1维array里随机选取内容，并将选取结果放入n维array中返回。> - 参数：>  - a : 如果是一维数组，就表示从这个一维数组中随机采样；如果是int型，就表示从0到a-1这个序列中随机采样。 >  - size : 采样结果的数量，默认为1.可以是整数，表示要采样的数量；也可以为tuple，如(m, n, k)，则要采样的数量为m * n * k，size为(m, n, k)。 >  - replace : boolean型，采样的样本是否要更换？这个地方我不太理解，测了一下发现replace指定为True时，采样的元素会有重复；当replace指定为False时，采样不会重复。 >  - p : 一个一维数组，制定了a中每个元素采样的概率，若为默认的None，则a中每个元素被采样的概率相同。  58. 减去一个矩阵中的每一行的平均值<jupyter_code>X = np.random.rand(5, 10)
print(X)
Y = X - X.mean(axis=1, keepdims=True)
print(Y)<jupyter_output><empty_output><jupyter_text>59. 如何通过第n列对一个数组进行排序?<jupyter_code>Z = np.random.randint(0,10,(3,3))
print (Z)
print (Z[Z[:,1].argsort()])<jupyter_output><empty_output><jupyter_text>**从中可以看出argsort函数返回的是数组值从小到大的索引值**  **举个例子**<jupyter_code>#examples
n = np.random.randint(0,8,5) #1d
print(n)
print(n.argsort())
a = np.random.randint(0, 8, (3,3)) #2d
print(a)
print(a.argsort())<jupyter_output><empty_output><jupyter_text>60. 如何检查一个二维数组是否有空列<jupyter_code>Z = np.random.randint(0,3,(3,10))
# print ((~Z.any(axis=0)).any())
print(~Z.any(axis=0).any())<jupyter_output><empty_output><jupyter_text>> 知识补充：> - 在NumPy中，～表示对条件判断式的否定> - any()函数其实是一个OR的过程，就是说A1 OR A2 OR A3 ...> - all()就是and了**看不懂？没关系，我们来看个小例子。**<jupyter_code>a = np.random.randint(0, 8, (3, 3))
print(a.any(axis=0))
print(~a.any(axis=0))
print(~a.any(axis=0).any())<jupyter_output><empty_output><jupyter_text>61. 从数组中的给定值中找出最近的值<jupyter_code>Z = np.random.uniform(0,1,10)
z = 0.5
m = Z.flat[np.abs(Z - z).argmin()]
print (m)
n = Z[np.abs(Z - z).argmin()]
print(n)<jupyter_output><empty_output><jupyter_text>> 知识补充:  > - flat有什么用呢？返回一个迭代器，那么迭代器和我们的数组有什么不一样的呢？> - 节省内存  62. 如何用迭代器(iterator)计算两个分别具有形状(1,3)和(3,1)的数组<jupyter_code>A = np.arange(3).reshape(3,1)
B = np.arange(3).reshape(1,3)
it = np.nditer([A,B,None])
for x,y,z in it: 
    z[...] = x + y
print (it.operands[2])<jupyter_output><empty_output><jupyter_text>> 知识补充：> - np.nditer()是返回一个迭代器，可以对一维数组和多维数组迭代> - 默认情况下，nditer将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定op_flags=['readwrite']模式：> - 参数：>  - op_flag:是否可写>  - flag:['f_index'/'mulit_index']多维迭代或者一维迭代>  - order:迭代顺序，有两种  63. 创建一个具有name属性的数组类<jupyter_code>class NamedArray(np.ndarray):
    def __new__(cls, array, name="no name"):
        obj = np.asarray(array).view(cls)
        obj.name = name
        return obj
    def __array_finalize__(self, obj):
        if obj is None: return
        self.info = getattr(obj, 'name', "no name")

Z = NamedArray(np.arange(10), "range_10")
print (Z.name)
print(Z)<jupyter_output><empty_output><jupyter_text>64. 考虑一个给定的向量，如何对由第二个向量索引的每个元素加1(小心重复的索引)<jupyter_code>Z = np.ones(10)
I = np.random.randint(0,len(Z),20)
print(I)
Z += np.bincount(I, minlength=len(Z))
print(Z)
# 方法2
np.add.at(Z, I, 1)
print(Z)
# examples
a = np.random.randint(0, 5, 6)
print(a)
np.bincount(a)<jupyter_output><empty_output><jupyter_text>65. 根据索引列表(I)，如何将向量(X)的元素累加到数组(F)<jupyter_code>X = [1,2,3,4,5,6]
I = [1,3,9,3,4,1]
F = np.bincount(I,X)
print (F)<jupyter_output><empty_output><jupyter_text>66. 考虑一个(dtype=ubyte) 的 (w,h,3)图像，计算其唯一颜色的数量<jupyter_code>w,h = 16,16
I = np.random.randint(0,2,(h,w,3)).astype(np.ubyte)
#Note that we should compute 256*256 first. 
#Otherwise numpy will only promote F.dtype to 'uint16' and overfolw will occur
F = I[...,0]*(256*256) + I[...,1]*256 +I[...,2]
n = len(np.unique(F))
print (n)<jupyter_output><empty_output><jupyter_text>67. 考虑一个四维数组，如何一次性计算出最后两个轴(axis)的和？<jupyter_code>a = np.random.randint(0, 10, (3,4,3,4))
print(a)
sum = a.sum(axis=(-2,-1))
sum<jupyter_output><empty_output><jupyter_text>68. 考虑一个一维向量D，如何使用相同大小的向量S来计算D子集的均值？<jupyter_code>D = np.random.uniform(0,1,100)
S = np.random.randint(0,10,100)

D_sums = np.bincount(S, weights=D)
print(D_sums)
D_counts = np.bincount(S)
print(D_counts)
D_means = D_sums / D_counts
print (D_means)
a = np.array([1,2,2,3,3,4,4,4,5])
# np.set_printoptions(threshold=np.nan)
# np.bincount 用来对数组中的数进行计数，minlength 是返回数组的最小长度
# 打印出来，你就知道
#如果指定权重，则输入数组由它加权，即如果在位置i处找到值n，则[n] + = weight [i]而不是out [n] + = 1
# print(np.bincount(a))
# print(np.bincount(a, minlength=900))
b = np.arange(9)
print(b)
np.bincount(a, weights=b)<jupyter_output><empty_output><jupyter_text>69. 如何获得点积 dot prodcut的对角线?<jupyter_code>a = np.random.uniform(0,1,(5,5))
b = np.random.uniform(0,1,(5,5))

np.diag(np.dot(a, b))
# 这种方法据说更快
np.sum(a*b.T, axis=1)<jupyter_output><empty_output><jupyter_text>70. 考虑一个向量[1,2,3,4,5],如何建立一个新的向量，在这个新向量中每个值之间有3个连续的零<jupyter_code>a = np.array([1,2,3,4,5])
z = np.zeros(a.shape[0] + (a.shape[0] - 1)*3)
z[::4] = a
z<jupyter_output><empty_output><jupyter_text>71. 考虑一个维度(5,5,3)的数组，如何将其与一个(5,5)的数组相乘？<jupyter_code>A = np.ones((5,5,3))
B = 2*np.ones((5,5))
# print(B[:,:, None])
print (A * B[:,:,None])<jupyter_output><empty_output><jupyter_text>72. 如何对一个数组中任意两行做交换?<jupyter_code>A = np.arange(25).reshape(5,5)
print (A)
A[[0,1]] = A[[1,0]]
print (A)<jupyter_output><empty_output><jupyter_text>73. 考虑一个可以描述10个三角形的triplets，找到可以分割全部三角形的line segment<jupyter_code>faces = np.random.randint(0,100,(10,3))
F = np.roll(faces.repeat(2,axis=1),-1,axis=1)
F = F.reshape(len(F)*3,2)
F = np.sort(F,axis=1)
G = F.view( dtype=[('p0',F.dtype),('p1',F.dtype)] )
G = np.unique(G)
print (G)<jupyter_output><empty_output><jupyter_text>75. 如何通过滑动窗口计算一个数组的平均数<jupyter_code>def moving_average(a, n=3) :
    ret = np.cumsum(a, dtype=float)
    ret[n:] = ret[n:] - ret[:-n]
    return ret[n - 1:] / n
Z = np.arange(20)
print(moving_average(Z, n=3))<jupyter_output>[ 0.  1.  3.  6.  9. 12. 15. 18. 21. 24. 27. 30. 33. 36. 39. 42. 45. 48.
 51. 54.]
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17. 18.]<jupyter_text>> 知识补充：> - np.cumsum 滑动求和（我起的名字）> - 参数 ：>  - axis :按行求和，还是按列求和>  - dtype : 老生常谈>  - out : 同上**看个例子**<jupyter_code>a = np.arange(20)
print(a)
np.cumsum(a)<jupyter_output>[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]<jupyter_text>76.考虑一维数组Z，构建一个二维数组，其第一行为（Z [0]，Z [1]，Z [2]），每个后续行移1（最后一行应为（Z [-3]，Z [-2]，Z [-1])<jupyter_code>from numpy.lib import stride_tricks

def rolling(a, window):
    shape = (a.size - window + 1, window)
    strides = (a.itemsize, a.itemsize)
    return stride_tricks.as_strided(a, shape=shape, strides=strides)
Z = rolling(np.arange(10), 3)

print (Z)<jupyter_output>[[0 1 2]
 [1 2 3]
 [2 3 4]
 [3 4 5]
 [4 5 6]
 [5 6 7]
 [6 7 8]
 [7 8 9]]<jupyter_text>> stride_tricks是用来给矩阵分块的函数，具体的我们看个例子吧。```import numpy as np 数独是个 9x9 的二维数组 包含 9 个 3x3 的九宫格sudoku = np.array([       [2, 8, 7, 1, 6, 5, 9, 4, 3],    [9, 5, 4, 7, 3, 2, 1, 6, 8],    [6, 1, 3, 8, 4, 9, 7, 5, 2],    [8, 7, 9, 6, 5, 1, 2, 3, 4],    [4, 2, 1, 3, 9, 8, 6, 7, 5],    [3, 6, 5, 4, 2, 7, 8, 9, 1],    [1, 9, 8, 5, 7, 3, 4, 2, 6],    [5, 4, 2, 9, 1, 6, 3, 8, 7],    [7, 3, 6, 2, 8, 4, 5, 1, 9]]) 要将其变成 3x3x3x3 的四维数组 但不能直接 reshape，因为这样会把一行变成一个九宫格shape = (3, 3, 3, 3) 大行之间隔 27 个元素，大列之间隔 3 个元素 小行之间隔 9 个元素，小列之间隔 1 个元素strides = sudoku.itemsize * np.array([27, 3, 9, 1])squares = np.lib.stride_tricks.as_strided(sudoku, shape=shape, strides=strides) print(squares)```<jupyter_code>import numpy as np

# 数独是个 9x9 的二维数组
# 包含 9 个 3x3 的九宫格
sudoku = np.array([   
    [2, 8, 7, 1, 6, 5, 9, 4, 3],
    [9, 5, 4, 7, 3, 2, 1, 6, 8],
    [6, 1, 3, 8, 4, 9, 7, 5, 2],
    [8, 7, 9, 6, 5, 1, 2, 3, 4],
    [4, 2, 1, 3, 9, 8, 6, 7, 5],
    [3, 6, 5, 4, 2, 7, 8, 9, 1],
    [1, 9, 8, 5, 7, 3, 4, 2, 6],
    [5, 4, 2, 9, 1, 6, 3, 8, 7],
    [7, 3, 6, 2, 8, 4, 5, 1, 9]
])

# 要将其变成 3x3x3x3 的四维数组
# 但不能直接 reshape，因为这样会把一行变成一个九宫格
shape = (3, 3, 3, 3)

# 大行之间隔 27 个元素，大列之间隔 3 个元素
# 小行之间隔 9 个元素，小列之间隔 1 个元素
strides = sudoku.itemsize * np.array([27, 3, 9, 1])

squares = np.lib.stride_tricks.as_strided(sudoku, shape=shape, strides=strides) 
print(squares)<jupyter_output>[[[[2 8 7]
   [9 5 4]
   [6 1 3]]

  [[1 6 5]
   [7 3 2]
   [8 4 9]]

  [[9 4 3]
   [1 6 8]
   [7 5 2]]]


 [[[8 7 9]
   [4 2 1]
   [3 6 5]]

  [[6 5 1]
   [3 9 8]
   [4 2 7]]

  [[2 3 4]
   [6 7 5]
   [8 9 1]]]


 [[[1 9 8]
   [5 4 2]
   [7 3 6]]

  [[5 7 3]
   [9 1 6]
   [2 8 4]]

  [[4 2 6]
   [3 8 7]
   [5 1 9]]]]<jupyter_text>77. 如何对布尔值取反，或者原位(in-place)改变浮点数的符号(sign)<jupyter_code>Z = np.random.randint(0,2,100)
print(Z)
np.logical_not(Z, out=Z) #逻辑非，同理还会有逻辑与，逻辑或 logical_and logical_or
Z = np.random.uniform(-1.0,1.0,100)
print(Z)
np.negative(Z, out=Z)<jupyter_output>[-0.87638814 -0.44485029  0.75040057  0.64159917 -0.36912503  0.25417871
  0.90100716 -0.8226923   0.65146656  0.88955991 -0.74543886  0.57046328
 -0.79931355 -0.01595821 -0.64230106  0.32684531  0.47701174  0.19527115
 -0.00797375 -0.12267978 -0.20960754 -0.55486925 -0.92234711 -0.77985576
  0.0976761   0.98259651  0.8356385   0.38777041  0.15950792  0.21404288
  0.14772865  0.59803907  0.44162255  0.42467753 -0.13097248  0.16734773
  0.2570299   0.1431644  -0.52775316 -0.24814243  0.27944517  0.6825489
  0.932524    0.15356064  0.63279899 -0.97559693 -0.65709397  0.11834266
 -0.50450423 -0.50862836  0.82845173  0.25674094  0.06721974 -0.39651809
  0.71583944 -0.06306563  0.52951089 -0.09272905 -0.9412096  -0.56143855
 -0.58294638 -0.81617219  0.50014726  0.37449868  0.95849642  0.58695881
  0.46167994  0.17876374  0.94044051 -0.74627799  0.30425265 -0.90197186
 -0.21996316 -0.23971922  0.75614973  0.57086455  0.46957292 -0.02892293
 -0.24754286  0.09158267 -0.05690896 -0.84664467  0.[...]<jupyter_text>78. 考虑两组点集P0和P1去描述一组线(二维)和一个点p,如何计算点p到每一条线 i (P0[i],P1[i])的距离<jupyter_code>def distance(P0, P1, p):
    T = P1 - P0
    L = (T**2).sum(axis=1)
    U = -((P0[:,0]-p[...,0])*T[:,0] + (P0[:,1]-p[...,1])*T[:,1]) / L
    U = U.reshape(len(U),1)
    D = P0 + U*T - p
    return np.sqrt((D**2).sum(axis=1))

P0 = np.random.uniform(-10,10,(10,2))
P1 = np.random.uniform(-10,10,(10,2))
p  = np.random.uniform(-10,10,( 1,2))

print (distance(P0, P1, p))<jupyter_output>[4.03814975 8.29198498 1.7003489  1.94024808 7.07245717 1.24030996
 5.6981882  0.90599089 3.83462339 2.91692719]<jupyter_text>> 对于数组切片骚操作的解释：> - [:,:,None]增加维度> - [..., None]省略前面的冒号**看个例子，你就明白**<jupyter_code>a = np.random.uniform(1,3,(3,3))
print(a)
print(a[:,:,None])
print(a[...,None])
print(...,1)<jupyter_output>[[1.72110244 1.41926035 2.81894445]
 [2.90477256 1.28485572 1.56810657]
 [2.85284183 1.1295819  2.48448686]]
[[[1.72110244]
  [1.41926035]
  [2.81894445]]

 [[2.90477256]
  [1.28485572]
  [1.56810657]]

 [[2.85284183]
  [1.1295819 ]
  [2.48448686]]]
[[[1.72110244]
  [1.41926035]
  [2.81894445]]

 [[2.90477256]
  [1.28485572]
  [1.56810657]]

 [[2.85284183]
  [1.1295819 ]
  [2.48448686]]]
Ellipsis 1<jupyter_text>79.考虑两组点集P0和P1去描述一组线(二维)和一组点集P，如何计算每一个点 j(P[j]) 到每一条线 i (P0[i],P1[i])的距离<jupyter_code># based on distance function from previous question
P0 = np.random.uniform(-10, 10, (10,2))
P1 = np.random.uniform(-10,10,(10,2))
p = np.random.uniform(-10, 10, (10,2))
print (np.array([distance(P0,P1,p_i) for p_i in p]))<jupyter_output>[[ 2.16061101  3.89707373  9.85944793  3.50926851  0.75295654  6.59294124
   1.7617086   2.11500623  0.02417287  2.81848899]
 [ 9.5179201   2.33379033  7.43950755  4.98311814  8.14611213  8.91565434
   9.12890882  9.16419713  4.23647117  2.18376661]
 [ 0.79308637  1.90956538  5.10172706  2.18658692  0.74005576  0.88847569
   1.8218356   2.88961543  5.43322752  7.96495993]
 [ 4.55743422  8.72449127 10.96888797  1.18328341  5.43031015  3.55564003
   4.38583486  3.62946843  4.62488316  7.98877147]
 [ 2.33764044  9.32752781 16.92340572  9.88985826  2.74283125 12.58101556
   1.81253308  2.19637136  4.6761304   1.2031157 ]
 [ 1.12458704  4.92947244 10.39803298  3.47796422  0.39015212  6.43063424
   0.62009314  0.99790992  0.49643396  3.41452715]
 [11.23836874  2.76506772 15.24085259 12.78209669  5.55906025 16.42800544
   6.44435262  5.54827037 10.63432186  7.93673024]
 [ 1.71676924  3.56234897  9.09848754  2.61236046  0.77476286  5.69740842
   1.79499159  2.26036698  0.86669042  3.61704689]
[...]<jupyter_text>80. 考虑一个任意数组，编写一个提取具有固定形状的子部分并以给定元素为中心的函数（必要时用填充值填充)<jupyter_code>Z = np.random.randint(0,10,(10,10))
shape = (5,5)
fill  = 0
position = (1,1)

R = np.ones(shape, dtype=Z.dtype)*fill
P  = np.array(list(position)).astype(int)
Rs = np.array(list(R.shape)).astype(int)
Zs = np.array(list(Z.shape)).astype(int)

R_start = np.zeros((len(shape),)).astype(int)
R_stop  = np.array(list(shape)).astype(int)
Z_start = (P-Rs//2)
Z_stop  = (P+Rs//2)+Rs%2

R_start = (R_start - np.minimum(Z_start,0)).tolist()
Z_start = (np.maximum(Z_start,0)).tolist()
R_stop = np.maximum(R_start, (R_stop - np.maximum(Z_stop-Zs,0))).tolist()
Z_stop = (np.minimum(Z_stop,Zs)).tolist()

r = [slice(start,stop) for start,stop in zip(R_start,R_stop)]
z = [slice(start,stop) for start,stop in zip(Z_start,Z_stop)]
R[r] = Z[z]
print (Z)
print (R)<jupyter_output>[[3 8 6 3 1 5 5 8 1 1]
 [9 6 8 2 9 5 2 9 0 5]
 [9 6 7 0 0 8 6 1 0 8]
 [8 0 6 7 0 3 6 1 8 9]
 [9 6 6 7 9 6 1 6 7 3]
 [9 0 5 6 5 0 5 3 0 0]
 [8 7 3 2 3 2 8 5 0 7]
 [1 9 7 8 2 8 8 0 5 0]
 [6 7 8 9 4 8 8 0 1 8]
 [3 9 0 2 2 8 4 2 0 0]]
[[0 0 0 0 0]
 [0 3 8 6 3]
 [0 9 6 8 2]
 [0 9 6 7 0]
 [0 8 0 6 7]]<jupyter_text>81. 考虑一个数组Z = [1,2,3,4,5,6,7,8,9,10,11,12,13,14],如何生成一个数组R = [[1,2,3,4], [2,3,4,5], [3,4,5,6], ...,[11,12,13,14]]<jupyter_code>Z = np.arange(1,15,dtype=np.uint32)
R = stride_tricks.as_strided(Z,(11,4),(4,4))
print (Z)
print(Z.strides)<jupyter_output>[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14]
(4,)<jupyter_text>解释一下np.ndarray.strides，看了许多例子都没看懂，然后看了一下NumPy的官方文档，却瞬间明白了。> 翻译一下：该数组作为40个字节存储在存储器中，一个接一个地存储（称为连续的存储器块）。数组的步幅告诉我们在内存中跳过多少字节以沿着某个轴移动到下一个位置。例如，我们必须跳过4个字节（1个值）才能移动到下一列，但是需要20个字节（5个值）才能到达下一行的相同位置。因此，阵列x的步幅将是（20,4）。**这时候，我们再看一个例子**<jupyter_code>a = np.random.randint(0,3,5,dtype=np.uint16)
b = np.random.randint(0,3,5,dtype=np.uint32)
c = np.random.randint(0,3,5,dtype=np.uint64)

print("步长：",a.strides," itemsize:",a.itemsize)
print("步长：",b.strides," itemsize:",b.itemsize)
print("步长：",c.strides," itemsize:",c.itemsize)<jupyter_output>(2,)
步长： (2,)  itemsize: 2
步长： (4,)  itemsize: 4
步长： (8,)  itemsize: 8<jupyter_text>82. 计算一个矩阵的秩<jupyter_code>Z = np.random.uniform(0,1,(10,10))
U, S, V = np.linalg.svd(Z) # Singular Value Decomposition
rank = np.sum(S > 1e-10)
print(rank)<jupyter_output>10<jupyter_text>83. 如何找到一个数组中出现频率最高的值<jupyter_code>a = np.array([1,1,1,1,2,2,2,3,4])
print(a[np.bincount(a).argmax()])<jupyter_output>1<jupyter_text>84. 从一个10x10的矩阵中提取出连续的3x3区块<jupyter_code>a = np.random.random((10,10))
shape = (3,3,3,3)
strides = a.itemsize*np.array([7,3,3,3])
stride_tricks.as_strided(a,shape=shape,strides=strides)<jupyter_output><empty_output><jupyter_text>85. 创建一个满足 Z[i,j] == Z[j,i]的子类<jupyter_code>class Symetric(np.ndarray):
    def __setitem__(self, index, value):
        i,j = index
        super(Symetric, self).__setitem__((i,j), value)
        super(Symetric, self).__setitem__((j,i), value)

def symetric(Z):
    return np.asarray(Z + Z.T - np.diag(Z.diagonal())).view(Symetric)

S = symetric(np.random.randint(0,10,(5,5)))
S[2,3] = 42
print (S)<jupyter_output>[[ 0 12  1  7  3]
 [12  1  3  8 12]
 [ 1  3  8 42 10]
 [ 7  8 42  7 14]
 [ 3 12 10 14  7]]<jupyter_text>86. 考虑p个 nxn 矩阵和一组形状为(n,1)的向量，如何直接计算p个矩阵的乘积(n,1)<jupyter_code>p, n = 10, 20
M = np.ones((p,n,n))
V = np.ones((p,n,1))
S = np.tensordot(M, V, axes=[[0, 2], [0, 1]])
print (S)<jupyter_output>[[200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]
 [200.]]
{'fraction_non_alphanumeric': 0.19883782667689223, 'fraction_numerical': 0.15037460916760073, 'mean_word_length': 4.662769333556038, 'pattern_counts': {'":': 0, '<': 361, '<?xml version=': 0, '>': 470, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 18, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '100', 'dir': 'jupyter-structured-clean-dedup', 'id': '385874', 'license': 'MIT', 'n_tokens_mistral': 22082, 'n_tokens_neox': 19981, 'n_words': 2858, 'path': 'numpy100.ipynb', 'repo_name': 'skyf0cker/NumPy100', 'size': '33902'}