Numpy100题通关

# 1.导入numpy
import numpy as np

# 2.打印numpy的版本信息等
print (np.__version__)
np.show_config()

1.16.3
blas_mkl_info:
NOT AVAILABLE
blis_info:
NOT AVAILABLE
openblas_info:
library_dirs = [‘C:\projects\numpy-wheels\numpy\build\openblas’]
libraries = [‘openblas’]
language = f77
define_macros = [(‘HAVE_CBLAS’, None)]
blas_opt_info:
library_dirs = [‘C:\projects\numpy-wheels\numpy\build\openblas’]
libraries = [‘openblas’]
language = f77
define_macros = [(‘HAVE_CBLAS’, None)]
lapack_mkl_info:
NOT AVAILABLE
openblas_lapack_info:
library_dirs = [‘C:\projects\numpy-wheels\numpy\build\openblas’]
libraries = [‘openblas’]
language = f77
define_macros = [(‘HAVE_CBLAS’, None)]
lapack_opt_info:
library_dirs = [‘C:\projects\numpy-wheels\numpy\build\openblas’]
libraries = [‘openblas’]
language = f77
define_macros = [(‘HAVE_CBLAS’, None)]

# 3.创建长度为10的零向量
Z = np.zeros(10)
print (Z)

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

# 4.获取数组所占内存大小（单位字节）
z = np.zeros((10,10))
print (z.size*z.itemsize)

800

# 5.怎么用命令行获取numpy add函数的文档说明
np.info(np.add)

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 sum of x1 and x2, element-wise.
This is a scalar if both x1 and x2 are scalars.

Notes

Equivalent to x1 + x2 in terms of array broadcasting.

Examples

np.add(1.0, 4.0)
5.0

x1 = np.arange(9.0).reshape((3, 3))
x2 = np.arange(3.0)
np.add(x1, x2)
array([[ 0., 2., 4.],
[ 3., 5., 7.],
[ 6., 8., 10.]])

# 6.创建一个长度为10的零向量，并把第五个赋值为1
z = np.zeros(10)
z[4] = 1
print (z)

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

# 7.创建一个值域为10到49的向量
z = np.arange(10,50)
print (z)

[10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49]

# 8.将一个向量进行反转（第一个元素变为最后一个元素）
z = np.arange(50)
z = z[::-1]
print (z)

[49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0]

# 9.创建一个3*3的矩阵，值域为0到8
z = np.arange(9).reshape(3,3)
print (z)

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

# 10.从数组[1,2,0,0,4,0]中找出非0元素的位置索引
z = np.nonzero([1,2,0,0,4,0])
print (z)

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

# 11.创建一个3*3的单位矩阵
z = np.eye(3)
print(z)

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

# 12.创建一个3*3*3的随机矩阵
z = np.random.random((3,3,3))
print (z)

[[[0.24390751 0.64580504 0.93959563]
[0.02881185 0.63204811 0.0731091 ]
[0.12333822 0.91637788 0.79135152]]
[[0.77075796 0.8609182 0.86275513]
[0.27512905 0.02827328 0.83723562]
[0.79759248 0.0017044 0.7337215 ]]
[[0.28415645 0.99869641 0.28808072]
[0.11111085 0.51930926 0.45643525]
[0.89315541 0.00613539 0.87915373]]]

# 13.创建一个10*10的随机数组，并找出该数组中的最大值与最小值
z = np.random.random((10,10))
num_min,num_max = z.min(),z.max()
print (num_min)
print (num_max)

0.010110823388984946
0.9695469198261658

# 14.创建一个长度为30的随机向量，并求它的平均值
z = np.random.random((10))
num_mean = z.mean()
print (num_mean)

0.5013696339996377

# 15.创建一个2维数组，该数组边界值为1，内部值为0
z = np.ones((10,10))
z[1:-1,1:-1] =0
print (z)

[[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.]]

# 16.如何用0来填充一个数组的边界
z = np.ones((10,10))
# np.pad()参考链接：https://www.jianshu.com/p/426a1622dd9f
z = np.pad(z,pad_width=1,mode='constant',constant_values=0)
print (z)

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

# 17.下面表达式运行的结果是什么
# NaN:not a number inf:infinity
表达式                  结果
0*np.nan                nan
np.nan == np.nan        False
np.inf > np.nan         False
np.nan-np.nan           nan
0.3 == 3*0.1            False

# 18.创建一个5*5的矩阵，且设置值1，2，3，4对角线下一行
z = np.diag([1,2,3,4],k=-1)
print (z)

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

# 19.创建一个8*8的国际象棋棋盘矩阵（黑块为0，白块为1）
z = np.zeros((8,8),dtype=int)
z[1::2,::2] = 1
z[::2,1::2] = 1
print (z)

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

# 20.思考一下形状为（6，7，8）的数组的形状，且第100个元素的索引（x,y,z)分别表示什么
print (np.unravel_index(100,(6,7,8)))

(1, 5, 4)

# 21.用tile函数创建一个8*8的棋盘矩阵
# np.tile的用法，参考np.info(np.tile)
z = np.tile(np.array([[1,0],[0,1]]),(4,4))
print (z)

[[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]
[0 1 0 1 0 1 0 1]]

# 22.对5*5的随机矩阵进行归一化
z = np.random.randint(100,size=(5,5))
print (z)
zmin,zmax = z.min(),z.max()
z = (z-zmin)/(zmax-zmin)
print (z)

[[11 28 10 63 71]
[19 84 5 74 23]
[ 5 81 52 24 62]
[21 44 63 13 85]
[48 76 21 1 6]]
[[0.11904762 0.32142857 0.10714286 0.73809524 0.83333333]
[0.21428571 0.98809524 0.04761905 0.86904762 0.26190476]
[0.04761905 0.95238095 0.60714286 0.27380952 0.72619048]
[0.23809524 0.51190476 0.73809524 0.14285714 1. ]
[0.55952381 0.89285714 0.23809524 0. 0.05952381]]

# 23.创建一个dtype来表示颜色（RGBA）
color = np.dtype([('r',np.ubyte,1),
                 ('g',np.ubyte,1),
                 ('b',np.ubyte,1),
                 ('a',np.ubyte,1)])
c = np.array((255,255,255,1),dtype=color)
print (c)

(255, 255, 255, 1)

# 24.一个5*3的矩阵和一个3*2的矩阵相乘，结果是什么？
z1 = np.dot(np.ones((5,3)),np.ones((3,2))) # 第一种方法用np.dot()
z2 = np.ones((5,3))@np.ones((3,2)) # 第二种方法：用@
print (z1)
print (z2)

[[3. 3.]
[3. 3.]
[3. 3.]
[3. 3.]
[3. 3.]]
[[3. 3.]
[3. 3.]
[3. 3.]
[3. 3.]
[3. 3.]]

# 25.给定一个一维数组把它索引从3到8的元素求相反数
z = np.arange(11)
z[(3<=z)&(z<8)] *= -1
print (z)

[ 0 1 2 -3 -4 -5 -6 -7 8 9 10]

# 26.下面脚本的结果是什么
print (sum(range(5),-1))     # 0+1+2+3+4+5 -1 = 9
from numpy import *
print (sum(range(5),-1))    # 10 numpy.sum(a,axis=None)

9
10

# 27.关于整形的向量z下面哪些表达式正确
z**z                      True
2<<z>>2                   False
z<-z                      True
1j*z                      True
z/1/1                     True
z<z>z                     False

# 28.下面表达式的结果分别是什么？
np.array(0)/np.array(0)             # nan
np.array(0)//np.array(0)            # 0
np.array([np.nan]).astype(int).astype(float)      # array([-2.14748365e+09])

# 29.如何从零位开始舍入浮点数组
z = np.random.uniform(-10,+10,10)     # 生成10个数字，符合（-10，10）的平均分布
print (np.copysign(np.ceil(np.abs(z)),z))  # np.copysign(a,b) 将a,转为b一样的数据类型如（int，float）--》float
                                           # np.ceil计算大于等于该值的最小整数  

[-4.23189367 -8.6030526 -5.77068548 8.48826235 4.61998546 2.49277619
-1.64217651 4.54140347 -0.73228558 -2.82943278]
[-5. -9. -6. 9. 5. 3. -2. 5. -1. -3.]

# 30.如何找出两个数组公共的元素？
z1 = np.random.randint(0,10,10)
z2 = np.random.randint(0,10,10)
print (z1)
print (z2)
print (np.intersect1d(z1,z2))

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

# 31.如何忽略numpy的警告信息
# suicide mode on
defaults = np.seterr(all='ignore')
z = np.ones(1)/0

# back to sanity
_ = np.seterr(**defaults)

# 另一个等价的方式，使用上下文管理器（context manager）
with np.errstate(divide='ignore'):
    z = np.ones(1)/0

# 32.下面表达式是否为真
np.sqrt(-1) == np.emath.sqrt(-1)             False np.sqrt(-1) = nan ; np.emath.sqrt(-1) = 1j

# 33.如何获得所有与2016年7月的所有日期？
z = np.arange('2016-07','2016-08',dtype='datetime64[D]')
print (z)

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

# 34.如何获得昨天，今天和明天的日期？
yesterday = np.datetime64('today','D')-np.timedelta64(1,'D')
today = np.datetime64('today','D')
tomorrow = np.datetime64('today','D')+np.timedelta64(1,'D')
print (yesterday)
print (today)
print (tomorrow)

2021-08-09
2021-08-10
2021-08-11

# 35.如何计算((a+b)*(-a/2)),不使用中间变量
a = np.ones(3)*1
b = np.ones(3)*1
c = np.ones(3)*1
np.add(a,b,out=b)
np.divide(a,2,out=a)
np.negative(a,out=a)
np.multiply(a,b,out=a)

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

# 36.用5种不同的方法提取随机数组中的整数部分
z = np.random.uniform(0,10,10)
print (z)
print (z-z%1)
print (np.floor(z))
print (np.ceil(z)-1)
print (z.astype(int))
print (np.trunc(z))

[1.26196243 2.32490457 8.73424303 4.1935258 8.11571715 1.6695906
5.69275014 4.96872347 1.90804155 9.34199145]
[1. 2. 8. 4. 8. 1. 5. 4. 1. 9.]
[1. 2. 8. 4. 8. 1. 5. 4. 1. 9.]
[1. 2. 8. 4. 8. 1. 5. 4. 1. 9.]
[1 2 8 4 8 1 5 4 1 9]
[1. 2. 8. 4. 8. 1. 5. 4. 1. 9.]

# 37.创建一个5*5的矩阵且每一行的值范围为0到4
z = np.zeros((5,5))
z += np.arange(5)
print (z)

[[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.]]

# 38.如何利用一个生成10个整数的函数来构建数组
def generate():
    for x in range(10):
        yield x
z = np.fromiter(generate(),dtype=float)
print (z)

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

# 39.创建一个大小为10的向量，值域为0到1，不包括0和1
z = np.linspace(0,1,12,endpoint=True)[1:-1]
print (z)

[0.09090909 0.18181818 0.27272727 0.36363636 0.45454545 0.54545455 0.63636364 0.72727273 0.81818182 0.90909091]

# 40.创建一个大小为10的随机向量，并把它排序
z = np.random.random(10)
z.sort()
print (z)

[0.09435345 0.09466693 0.18369544 0.20325443 0.20944472 0.33672077 0.4716038 0.71778957 0.88556908 0.95287314]

# 41.对一个小数组进行求和，有没有比np.sum更快的
z = np.arange(10)
np.add.reduce(z)   # np.add.reduce是np.add模块中一个ufunc(universal function)函数，C语言实现

45

# 42.如何判断两个随机数组相等
a = np.random.randint(0,2,5)
b = np.random.randint(0,2,5)
equal = np.allclose(a,b)     # 假设array的形状相同和一个误差容限
print (equal)
equal2 = np.array_equal(a,b)    # 检测形状，元素值必须完全相等
print (equal2)

False
False

# 43.把数组变为只读
z = np.ones(5)
z.flags.writeable = False
z[1] =9

---

ValueError Traceback (most recent call last)
in ()
2 z = np.ones(5)
3 z.flags.writeable = False
----> 4 z[1] =9

ValueError: assignment destination is read-only

# 44.将一个10*2的笛卡尔坐标矩阵转为极坐标
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)

[1.11213732 0.90763413 0.71311885 0.29517064 0.58255878 0.47081257
0.2311726 0.94040656 0.06374446 0.84031496]
[0.47232445 1.13846058 0.70681102 0.68723358 0.36172867 0.41769481
0.67984896 0.27739964 0.48046445 0.09753571]

# 45.创建一个大小为10的随机向量并且将该向量中最大的值替换为0
z = np.random.random(10)
z[z.argmax()] = 0                # z.argmax()取得最大元素的索引
print (z)

[0. 0.59774454 0.61039471 0.38696947 0.98395726 0.6732856
0.38734879 0.8710888 0.19982718 0.0174059 ]

# 46.创建一个结构化数组，其中x和y坐标覆盖[0,1]*[1,0]
z = np.zeros((5,5),[('x',float),('y',float)])
# np.meshgrid :根据输入的坐标向量，生成对应的坐标矩阵
z['x'],z['y'] = np.meshgrid(np.linspace(0,1,5)),np.meshgrid(np.linspace(0,1,5))
print (z)

[[(0. , 0. ) (0.25, 0.25) (0.5 , 0.5 ) (0.75, 0.75) (1. , 1. )]
[(0. , 0. ) (0.25, 0.25) (0.5 , 0.5 ) (0.75, 0.75) (1. , 1. )]
[(0. , 0. ) (0.25, 0.25) (0.5 , 0.5 ) (0.75, 0.75) (1. , 1. )]
[(0. , 0. ) (0.25, 0.25) (0.5 , 0.5 ) (0.75, 0.75) (1. , 1. )]
[(0. , 0. ) (0.25, 0.25) (0.5 , 0.5 ) (0.75, 0.75) (1. , 1. )]]

# 47.给定两个数组X和Y，构造柯西（cauchy）矩阵Cij=1/(Xi-Yi)
x = np.arange(8)
y = x+0.5
c = 1.0/np.subtract.outer(x,y)   # x,y元素对应相减，返回值即为结果
print (c)
print (np.linalg.det(c))

[[-2. -0.66666667 -0.4 -0.28571429 -0.22222222 -0.18181818
-0.15384615 -0.13333333]
[ 2. -2. -0.66666667 -0.4 -0.28571429 -0.22222222
-0.18181818 -0.15384615]
[ 0.66666667 2. -2. -0.66666667 -0.4 -0.28571429
-0.22222222 -0.18181818]
[ 0.4 0.66666667 2. -2. -0.66666667 -0.4
-0.28571429 -0.22222222]
[ 0.28571429 0.4 0.66666667 2. -2. -0.66666667
-0.4 -0.28571429]
[ 0.22222222 0.28571429 0.4 0.66666667 2. -2.
-0.66666667 -0.4 ]
[ 0.18181818 0.22222222 0.28571429 0.4 0.66666667 2.
-2. -0.66666667]
[ 0.15384615 0.18181818 0.22222222 0.28571429 0.4 0.666666672. -2. ]]
3638.163637117973

# 48.打印每个numpy类型中的最小和最大可表示值
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)    # eps是一个很小的非负数

-128
127
-2147483648
2147483647
-9223372036854775808
9223372036854775807
-3.4028235e+38
3.4028235e+38
1.1920929e-07
-1.7976931348623157e+308
1.7976931348623157e+308
2.220446049250313e-16

# 49.如何打印数组中所有的值
import sys
np.set_printoptions(threshold=sys.maxsize)   # 当矩阵很大时，打印完成的矩阵
z = np.zeros((16,16))
print (z)

[[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. 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. 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.]]

# 50.如何在数组中找到与给定标量接近的值
z = np.arange(10)
v = np.random.uniform(0,100)
print (v)
index = (np.abs(z-v)).argmin()
print (z[index])

96.2174689881924
9

# 51.创建表示位置（x,y）的颜色r,g,b,a的结构化数组
z = np.zeros(10,[('position',[('x',float,1),('y',float,1)]),('color',[('r',float,1),('g',float,1),('b',float,1)])])
print (z)

[((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.))]

# 52.思考形状为（100，2）的随机向量，求出点与点之间的距离
z = np.random.random((100,2))
x,y = np.atleast_2d(z[:,0],z[:,1])    # np.atleast_2d:将输入视为至少具有二维的数组
d = np.sqrt((x-x.T)**2+(y-y.T)**2)
print (d)

import scipy.spatial

z = np.random.random((100,2))
d = scipy.spatial.distance.cdist(z,z)
print (d)

[[4.41509535e-01 2.18607785e-02 8.49139142e-01 1.85039334e-01
5.54057442e-01 3.54521566e-01 6.82352639e-01 8.75752751e-01
5.20921475e-02 9.60725442e-01 6.24241970e-02 8.29901291e-01
1.24824708e-02 4.33505273e-01 7.36958247e-01 4.40113288e-01
5.01828104e-01 3.49125743e-01 6.69433063e-01 2.78397204e-01
7.15660124e-02 4.86951733e-01 7.57586456e-01 4.83334063e-01
4.76692709e-01 3.18073821e-01 3.00125336e-01 3.01685325e-01
9.79193460e-01 4.54353773e-01 9.56300181e-01 4.93845917e-01
9.03983115e-01 5.83526345e-01 1.78252936e-01 7.34548206e-02
9.94112947e-02 4.83058307e-01 4.66800075e-01 4.90612105e-01
1.58339588e-01 1.74735969e …

# 53.如何将类型为float（32位）的数组类型转为integer（32位）
z = np.arange(10,dtype=np.float32)
z = z.astype(np.int32,copy=False)
print (z)

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

# 54.如何读取下面的文件
# 1,2,3,4,5
# 6, ,6,6,7
#  , , , ,9
# 先将上面文件保存到e.txt文件中，然后使用np.genfromtxt（）函数读取
z = np.genfromtxt('e.txt',delimiter=',')
print (z)

[[ 1. 2. 3. 4. 5.]
[ 6. nan 6. 6. 7.]
[nan nan nan nan 9.]]

# 55.numpy数组枚举(enumerate)的等价操作
z = np.arange(9).reshape(3,3)
for index,value in np.ndenumerate(z):
    print (index,value)
for index in np.ndindex(z.shape):
    print (index,z[index])

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

# 56.构造一个二维高斯矩阵
x,y = np.meshgrid(np.linspace(-1,1,10),np.linspace(-1,1,10))
d = np.sqrt(x**2+y**2)
sigma,mu = 1.0,0.0
g = np.exp(-(d-mu)**2/(2*sigma**2))
print (g)

[[0.36787944 0.44822088 0.51979489 0.57375342 0.60279818 0.60279818
0.57375342 0.51979489 0.44822088 0.36787944]
[0.44822088 0.54610814 0.63331324 0.69905581 0.73444367 0.73444367
0.69905581 0.63331324 0.54610814 0.44822088]
[0.51979489 0.63331324 0.73444367 0.81068432 0.85172308 0.85172308
0.81068432 0.73444367 0.63331324 0.51979489]
[0.57375342 0.69905581 0.81068432 0.89483932 0.9401382 0.9401382
0.89483932 0.81068432 0.69905581 0.57375342]
[0.60279818 0.73444367 0.85172308 0.9401382 0.98773022 0.98773022
0.9401382 0.85172308 0.73444367 0.60279818]
[0.60279818 0.73444367 0.85172308 0.9401382 0.98773022 0.98773022
0.9401382 0.85172308 0.73444367 0.60279818]
[0.57375342 0.69905581 0.81068432 0.89483932 0.9401382 0.9401382
0.89483932 0.81068432 0.69905581 0.57375342]
[0.51979489 0.63331324 0.73444367 0.81068432 0.85172308 0.85172308
0.81068432 0.73444367 0.63331324 0.51979489]
[0.44822088 0.54610814 0.63331324 0.69905581 0.73444367 0.73444367
0.69905581 0.63331324 0.54610814 0.44822088]
[0.36787944 0.44822088 0.51979489 0.57375342 0.60279818 0.60279818
0.57375342 0.51979489 0.44822088 0.36787944]]

# 57.如何在二维数组随机位置放置p个元素
n = 10
p = 3
z = np.zeros((n,n))
np.put(z,np.random.choice(range(n*n),p,replace=False),1)
print (z)

[[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. 1. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 1. 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. 1. 0. 0.]]

# 58.减去矩阵每一行的平均值
x = np.random.rand(5,10)
print (x)
# 新
y1 = x-x.mean(axis=1,keepdims=True)   # keepdims:保持原有维度 axis=1：按行求均值 axis=0:按列
# 旧
y2 = x-x.mean(axis=1).reshape(-1,1)
print (y1)
print (y2)

# 59.如何对数组通过第n列进行排序
z = np.random.randint(0,10,(3,3))
print (z)
print (z[:,1])
print (z[:,1].argsort()) # np.argsort()排序返回索引
print (z[z[:,1].argsort()])

[[8 0 6]
[8 7 1]
[4 2 6]]
[0 7 2]
[0 2 1]
[[8 0 6]
[4 2 6]
[8 7 1]]

# 60.如何判断一个给定的威威数组存在空列
z = np.random.randint(0,3,(3,10))
print (z)
print ((~z.any(axis=0)).any())

[[0 1 2 0 2 0 0 1 1 0]
[0 0 0 1 1 0 2 1 2 0]
[2 0 0 0 1 1 1 2 2 2]]
False

# 61.从数组中找出与给定值最接近的值
z = np.random.uniform(0,1,10)
t = 0.5
m = z.flat[np.abs(z-t).argmin()]  # z.flat() 将高维的z矩阵，降维为一维的list，可用来迭代
print (m)

0.48334771496927587

# 62.思考形状为（1，3）和（3，1）的两个数组形状，如何使用迭代器计算它们的和
z1 = np.random.randint(0,3,3).reshape(1,3)
z2 = np.random.randint(0,3,3).reshape(3,1)
it = np.nditer([z1,z2,None])
for x,y,z in it:
    z[...] = x+y
print (it.operands[2])

[[1 3 3]
[2 4 4]
[1 3 3]]

# 63. 创建一个具有name属性的数组类
class NameArray(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 = NameArray(np.arange(10),'range_10')
print (z.name)

range_10

# 64.给定一个向量，如何让在第二个向量索引的每个元素加1（注意重估索引）
z = np.ones(10)
i = np.random.randint(0,len(z),20)
z += np.bincount(i,minlength=len(z))
print (z)

np.add.at(z,i,1)
print (z)

[5. 1. 4. 3. 2. 4. 3. 2. 2. 4.]
[9. 1. 7. 5. 3. 7. 5. 3. 3. 7.]

# 65.如何根据所以列表i将向量x的元素累加到数组f
x = [1,2,3,4,5,6]
i = [1,3,9,3,4,1]
f = np.bincount(i,weights=x) # np.bincount()是计算x中的元素出现的次数，有weights要按权重计算，如i中1的权重是1+6=7
print (f)

[0. 7. 0. 6. 5. 0. 0. 0. 0. 3.]

# 66 思考（dtype=utype）的（w,h,3）图像，计算唯一颜色的值
w,h = 16,16
i = np.random.randint(0,2,(h,w,3)).astype(np.ubyte) # ubyte：无符号取值0~255   byte：有符号取值-127~127
f = i[...,0]*256*256 + i[...,1]*256 + i[...,2]     # [...,0] == [:,:,0]
n = len(np.unique(f))
print (np.unique(i))              # np.unique() 去重后，将剩余的数组排序

[0 1]

# 67.思考如何求一个四维数组最后两个轴的数据和
a = np.random.randint(0,10,(3,4,3,4))
sum = a.sum(axis=(-2,-1))
print (sum)

sum = a.reshape(a.shape[::-2]+(-1,)).sum(axis=-1)
print (sum)

[[39 40 38 51]
[48 67 67 54]
[44 67 40 52]]
[[21 42 28 26]
[42 38 34 52]
[57 35 42 31]
[50 39 36 34]]

# 68.考虑一维向量D，如何使用相同大小的向量s来计算D的子集的均值，其描述子集索引
d = np.random.uniform(0,1,100)
s = np.random.randint(0,10,100)
d_sums =np.bincount(s,weights=d)
d_counts = np.bincount(s)
d_means = d_sums/d_counts
print (d_means)

import pandas as pd
print (pd.Series(d).groupby(s).mean())

[0.54002298 0.65238318 0.47896022 0.44455516 0.56398833 0.74567636
0.60799306 0.53824426 0.52417325 0.43821521]
0 0.540023
1 0.652383
2 0.478960
3 0.444555
4 0.563988
5 0.745676
6 0.607993
7 0.538244
8 0.524173
9 0.438215
dtype: float64

# 69.如何获得点积的对角线
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)
# 更快的
np.einsum('ji,ji->i',a,b)

array([1.42225903, 0.81291533, 1.10111194, 0.71011214, 0.29794416])

# 70.考虑向量[1,2,3,4,5],如何建立一个新的向量，在每个值之间交错有3个连续的零
z = np.array([1,2,3,4,5])
nz =3
z0 = np.zeros(len(z)+(len(z)-1)*(nz))
print (z0)
z0[::nz+1] = z
print (z0)

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[1. 0. 0. 0. 2. 0. 0. 0. 3. 0. 0. 0. 4. 0. 0. 0. 5.]

# 71.考虑一个维度（5,5,3）的数组，如何将其与一个（5，5）的数组相乘
z1 = np.ones((5,5,3))
z2 = 2*np.ones((5,5))
print (z1*z2[:,:,None])

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

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

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

[[2. 2. 2.]
[2. 2. 2.]
[2. 2. 2.] …

# 72.如何对一个数组中任意两行做交换
a = np.arange(25).reshape(5,5)
print (a)
print (a[0])  # 取行
print (a[:,0]) # 取列
a[[0,1]] = a[[1,0]]
print (a)

[[ 5 6 7 8 9]
[ 0 1 2 3 4]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]]

# 73.思考描述10个三角形（共享顶点）的一组10个三元组，找到组成所有三角形的唯一线段集
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 = g.view(dtype=[('p0',f.dtype),('p1',f.dtype)])
g = np.unique(g)
print (g)

[(-1617542929, 1071427494) (-1276333073, 1072567708)
(-1276333072, 1072567708) (-1017963999, 1072382288)
(-1017963998, 1072382288) ( -989635017, 1071741367)
( -989635016, 1071741367) ( -459498402, 1071686184)
( -459498401, 1071686184) ( 66463672, 1072136336)
( 66463673, 1072136336) ( 66463674, 1072136336)
( 270307586, 1072472710) ( 574693891, 1071799344)
( 582710294, 1071924250) ( 582710295, 1071924250)
( 582710296, 1071924250) ( 908914486, 1071090518)
( 1082442898, 1072296224) ( 1082442899, 1072296224)
( 1082442900, 1072296224) ( 1283202972, 1072062122)
( 1283202973, 1072062122) ( 1283202974, 1072062122)
( 1711282230, 1072667516) ( 1712121385, 1071860255)]

# 74.给定一个二进制的数组C，如何生成一个数组A满足np.bincount(A)==C
c = np.bincount([1,1,2,3,4,4,6])
a = np.repeat(np.arange(len(c)),c)
print (a)

[1 1 2 3 4 4 6]
[0 2 1 1 2 0 1]

# 75. 如何通过一个滑动窗口计算一个数组的平均数
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))

[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18.]

# 76.思考一维数组z，构建一个二维数组，其第一行是(z[0],z[1],z[2]),然后每一行移动一位，最后一行为（z[-3],z[-2],z[-1]）
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)

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

# 77.如何对布尔值取反，或改变浮点数的符号（sign）
z = np.random.randint(0,2,100)
np.logical_not(z,out=z)
z = np.random.uniform(-1.0,1.0,100)
np.negative(z,out=z)

array([ 0.40193582, -0.58308127, 0.82948653, 0.92415364, 0.22430644,
0.5294474 , 0.08016235, -0.14289955, 0.69310344, -0.15490275,
0.26143725, -0.49193714, 0.21641678, -0.8209942 , 0.45683027,
0.04500856, -0.55813758, -0.28637101, 0.37643521, 0.2035459 ,
-0.18874938, 0.57884654, 0.16544985, -0.51832053, -0.4589683 ,
0.17818091, -0.21200743, 0.91443081, -0.60634949, -0.34874673,
-0.0097264 , 0.33002454, -0.41445273, -0.65395247, -0.51081667,
0.4879729 , -0.27852001, -0.85882383, 0.68619327, -0.9643229 ,
0.5859684 , 0.70990011, -0.51323274, -0.08272127, -0.59916656,
-0.06146568, 0.73373326, -0.06754513, 0.19078156, 0.19144694,
-0.84621932, -0.90579552, 0.76961515, 0.60009871, 0.66885975,
-0.53757515, -0.43060693, 0.08160696, 0.89275245, 0.07433191,
0.98784269, -0.83898574, -0.34567601, 0.91493694, -0.37968306,
0.44369691, -0.37228063, 0.08052574, -0.22954629, -0.2064579 ,
-0.17877743, -0.78952568, -0.75414189, 0.73771155, 0.40161806,
0.87508136, -0.46960304, 0.84697331, -0.96042992, -0.06757031,
0.16145276, -0.98480081, 0.14169162, 0.46817432, 0.2162708 ,
0.16179021, -0.4484453 , -0.76567416, -0.28307074, 0.79778518,
0.64701724, -0.92326914, -0.08793902, 0.34625157, -0.60441526,
0.64946072, 0.21505624, 0.4522085 , 0.60381597, 0.26250817])

78~80.

# 78.如何计算p到每一条线i（p0[i],p1[i]）的距离
# 79.思考两组点集p0和p1去描述一组线（二维）
# 80.思考一个任意的数组，编写一个函数，该函数提取一个具有固定形状的子部分，并以一个给定元素为中心（在该部分填充）

# 81.考虑一个数组z=[1,2,3....,12,13,14],如何生成一个数组[[1,2,3,4],[2,3,4,5]...[11,12,13,14]]
z = np.arange(15,dtype=np.int32)
r = stride_tricks.as_strided(z,(11,4),(4,4))
print (r)

[[ 0 1 2 3]
[ 1 2 3 4]
[ 2 3 4 5]
[ 3 4 5 6]
[ 4 5 6 7]
[ 5 6 7 8]
[ 6 7 8 9]
[ 7 8 9 10]
[ 8 9 10 11]
[ 9 10 11 12]
[10 11 12 13]]

# 82.计算矩阵的秩
z = np.random.uniform(0,1,(10,10))
u,s,v = np.linalg.svd(z)
rank = np.sum(s>1e-10)
print (rank)

10

# 83.如何找出数组中出现频率最高的值
z = np.random.randint(0,10,50)
print (np.bincount(z).argmax())

6

84-85.

# 84.从一个10*10的矩阵中提取出连续的3*3区块
# 85.创建一个满足z[i,j]==z[j,i]的二维数组子类

# 86.考虑p个nxn矩阵和一组形状为（n，1）的向量，如何直接计算p个矩阵的乘积（n,1）
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)

# 87.对于一个16*16的数组，如何得到一个区域的和（区域大小为4*4）
z = np.ones((16,16))
k = 4
s = np.add.reduceat(np.add.reduceat(z,np.arange(0,z.shape[0],k),axis=0),np.arange(0,z.shape[1],k),axis=1)
print(s)

[[16. 16. 16. 16.]
[16. 16. 16. 16.]
[16. 16. 16. 16.]
[16. 16. 16. 16.]]

# 88.如何利用numpy数组实现game of life

# 89.如何找到一个数组的第n个最大值
z = np.arange(10000)
np.random.shuffle(z)
n = 5
print (z[np.argpartition(-z,n)[:n]])

[9997 9999 9998 9996 9995]

90~96.

# 90.给定任意个数向量，创建笛卡尔积（每一个元素的每一种组合）
# 91.如何从一个常规数组中创建记录数组
# 92.思考一个大向量z，用三种不同的方法计算它的立方
# 93.考虑两个形状分别为（8，3）和（2，2）的数组a和b。如何在数组a中找到满足包含b中元素的行？
# 94.思考一个10*3的矩阵，如何分解出有不全相同的行
# 95.将一个整数向量转为二进制矩阵
# 96.给定一个二维数组，如何提取出唯一的行

# 97.考虑两个向量a和b，写出用einsum等式对应的inner，outer，sum，mul函数
a = np.random.uniform(0,1,10)
b = np.random.uniform(0,1,10)

np.einsum('i->',a)    # np.sum(a)
np.einsum('i,i->i',a,b)  # a*b
np.einsum('i,i',a,b)    # np.inner(a,b)
np.einsum('i,j->ij',a,b)  # np.outer(a,b)

98~100.

# 98.考虑一个由两个向量描述的路径（x,y),如何用等距样例对其进行采样
# 99.给定一个整数n和一个二维数组x，从x中选择可以被解释为从多n度的多项分布式的行，即这些行只包含整数对n的和
# 100.对于一个一维数组x，计算它boostrapped之后的95%置信度区间的平均值

---

参考链接：https://blog.csdn.net/qq_39362996/article/details/90204737