a = np.arange(15).reshape(3, 5)
a  #np.array

#ndarray的重要属性
print("ndarray类型为{}".format(type(a)))
print("ndarray的维度ndim为{}".format(a.ndim))
print("ndarray的shape为{}".format(a.shape))
print("ndarray总的元素数size为{}".format(a.size))
#a.shape元素乘积
print("ndarray元素类型dtype为{}".format(a.dtype))
#这句是我加的
print("ndarray元素类型dtype.name为{}".format(a.dtype.name))
#官方代码不知道为什么多出了这个name
print("ndarray每个元素占据的字节数itemsize为{}".format(a.itemsize))
print("ndarray元素的buffer data为{}".format(a.data))

#具体做法就是传入一个list或tuple作为参数
a = np.array([1,2,3,4])
#一种典型的错误情况：a = np.array(1,2,3,4)
#如果传入由多个list或tuple构成的list或tuple作为参数，遵守这个规律：
#array transforms sequences of sequences into two-dimensional arrays,
#sequences of sequences of sequences into three-dimensional arrays,
#and so on.
b = np.array([(1.5,2,3), (4,5,6)])
#自定义元素类型
c = np.array( [ [1,2], [3,4] ], dtype=complex )

d=np.zeros((3, 4))
e=np.ones( (2,3,4), dtype=np.int16 )  #也可以自定义元素类型
f=np.empty( (2,3) )  #根据内存状态随机初始化数组
#arrange类似于Python内置的range
g=np.arange( 10, 30, 5 )
h=np.arange( 0, 2, 0.3 )  #接受小数参数
#arrange函数由于浮点数精度的原因，可能无法知道数组最后有多少个数
#为解决这一问题可以使用linspace函数：
i=np.linspace( 0, 2, 9 )  # 9 numbers from 0 to 2

a = np.array( [20,30,40,50] )
b = np.arange( 4 )
print("a-b是{}".format(a-b))
print("a**2是{}".format(a**2))
print("10*np.sin(a)是{}".format(10*np.sin(a)))
print("a<35是{}".format(a<35))
print("a*b是{}".format(a*b))
#矩阵乘法
A = np.array( [[1,1], [0,1]] )
B = np.array( [[2,0], [3,4]] )
print("A*B是{}".format(A*B))
print("A@B是{}".format(A@B))  #矩阵乘法
print("A.dot(B)是{}".format(A.dot(B)))  #矩阵乘法
#+=，*=等运算符进行原地运算（需要加同类型的，如果不能强制转换就会报错）

#很多一元运算都是ndarray类的方法
print("a是{}".format(a))
print("a.sum()是{}".format(a.sum()))
print("a.min()是{}".format(a.min()))
print("a.max()是{}".format(a.max()))
print()
b = np.arange(12).reshape(3,4)
print("b是{}".format(b))
print("b.sum(axis=0)是{}".format(b.sum(axis=0)))
#这个axis我一直没太搞懂怎么计算的
#0是垂直，1是水平，这种比较直观的。再高维度我就搞不懂了
#为了便于理解，我自己的理解是消融维：
#如果在这个维度上做加总之类的计算，最后的结果就没有这个维度了
print("b.min(axis=1)是{}".format(b.min(axis=1)))
print("b.cumsum(axis=1)是{}".format(b.cumsum(axis=1)))  #cumulative sum

B = np.arange(3)
print("B是{}".format(B))
print("np.exp(B)是{}".format(np.exp(B)))
print("np.sqrt(B)是{}".format(np.sqrt(B)))
C = np.array([2., -1., 4.])
print("np.add(B, C)是{}".format(np.add(B, C)))

#一维数组的情况
a = np.arange(10)**3
print("a是{}".format(a))
print("a[2]是{}".format(a[2]))
#带:的切片：start_index（取得到）:end_index（取不到）:stride
#省略start_index默认为0，省略end_index默认为最后一个索引，省略stride默认为1
print("a[2:5]是{}".format(a[2:5]))
a[:6:2] = 1000  #等于a[0:6:2] = 1000
print("a[:6:2] = 1000之后的a是{}".format(a))
print("a[ : :-1]是{}".format(a[ : :-1]))  #ndarray反转
for i in a:
    pass  #总之ndarray是可以迭代的，是每个元素的迭代器
print()
#多维数组的情况
#在切片时没写的维度视作全部（:（一个维度）或...（任意多所需维度））
def f(x,y):
    return 10*x+y
b = np.fromfunction(f,(5,4),dtype=int)
print("b是{}".format(b))
print("b[2,3]是{}".format(b[2,3]))
print("b[2][3]是{}".format(b[2][3]))  #这个是我自己写的
print("b[0:5, 1]是{}".format(b[0:5, 1]))
print("b[ : ,1]是{}".format(b[ : ,1]))
print("b[1:3, : ]是{}".format(b[1:3, : ]))
print("b[-1]是{}".format(b[-1]))
print()
c = np.array( [[[  0,  1,  2],
                 [ 10, 12, 13]],
                [[100,101,102],
                 [110,112,113]]])
#a 3D array (two stacked 2D arrays)
print("c是{}".format(c))
print("c[1,...]是{}".format(c[1,...]))
print("c[...,2]是{}".format(c[...,2]))
for element in b.flat:  #对所有元素的迭代器
    pass

a = np.array([[3., 7., 3., 4.],
       [1., 4., 2., 2.],
       [7., 2., 4., 9.]])
print("a是{}".format(a))
print("a.shape是{}".format(a.shape))
print()

#不改变a这一原始ndarray的方法：
print("a.ravel()是{}".format(a.ravel()))  #抻平到一维
print("a.reshape(6,2)是{}".format(a.reshape(6,2)))
print("a.T是{}".format(a.T))
#元素顺序是C-style（也可以通过参数设置为FORTRAN-style）
#C-style就是这个顺序

#改变a这一原始ndarray的方法：
a.resize((2,6))
print(a)

#如果维度写成-1会自动计算这个维度的具体值
print(a.reshape(3,-1))

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

a = np.array([[9., 7.],[5., 2.]])
b = np.array([[1., 9.],[5., 1.]])
print('np.vstack((a,b))是{}'.format(np.vstack((a,b))))
#和row_stack相同
print('np.hstack((a,b))是{}'.format(np.hstack((a,b))))
#和column_stack相似但不同（见下面解释）

from numpy import newaxis
#函数column_stack会将一维数组视作列堆叠成二维数组
#堆叠二维数组时和hstack结果一样
#二维数组：一样
print('np.column_stack((a,b))是{}'.format(np.column_stack((a,b))))
print()
print('a[:,newaxis]是{}'.format(a[:,newaxis]))
#将a转化为二维列向量
print('np.column_stack((a[:,newaxis],b[:,newaxis]))是{}'.format(np.column_stack((a[:,newaxis],b[:,newaxis]))))
print('np.hstack((a[:,newaxis],b[:,newaxis]))是{}'.format(np.hstack((a[:,newaxis],b[:,newaxis]))))
print()
#一维数组：不一样
a = np.array([4.,2.])
b = np.array([3.,8.])
print('np.column_stack((a,b))是{}'.format(np.column_stack((a,b))))
print('np.hstack((a,b))是{}'.format(np.hstack((a,b))))

#r_和c_可以沿某一维度堆叠数字为一个ndarray
np.r_[1:4,0,4]
#如果用ndarray作为参数，就跟vstack和hstack差不多，但是可以定义维度

#hsplit水平方向切割
a=np.array([[6., 7., 6., 9., 0., 5., 4., 0., 6., 8., 5., 2.],
            [8., 5., 5., 7., 1., 8., 6., 7., 1., 8., 1., 0.]])
print(np.hsplit(a,3))  #平均切成三份
print()
print(np.hsplit(a,(3,4)))  #在第三列、第四列后面切开
#vsplit垂直方向切割
#array_split可以沿任一方向切割

c=a.view()
print('c is a? {}'.format(c is a))
print('c.base is a? {}'.format(c.base is a))
#c is a view of the data owned by a
print('c.flags.owndata? {}'.format(c.flags.owndata))
#改变c的形状（reshape）不会改变a的形状，但是改变c的数据会改变a的数据
print()
#slicing相当于返回一个view
s = a[ : , 1:3]
s[:] = 10  #s[:] is a view of s.
print(a)
print()

d = a.copy()  #一个全新的ndarray，数据都是新建的
print('d is a? {}'.format(d is a))
print('d.base is a? {}'.format(d.base is a))
d[0,0] = 9999
print(a)

a = np.arange(12)**2
i = np.array([1, 1, 3, 8, 5])
print('a[i]是{}'.format(a[i]))
print()
j = np.array([[3, 4], [9, 7]])
print('a[j]是{}'.format(a[j]))

#一个图片的示例
palette = np.array([[0, 0, 0],         # black
                    [255, 0, 0],       # red
                    [0, 255, 0],       # green
                    [0, 0, 255],       # blue
                    [255, 255, 255]])  # white
image = np.array([[0, 1, 2, 0],        # each value corresponds to a color in the palette
                  [0, 3, 4, 0]])
palette[image]                         # the (2, 4, 3) color image

#用多维索引对多维数组进行索引：对每一维度切片的索引数组必须有相同的shape
a = np.arange(12).reshape(3,4)
print('a是{}\n'.format(a))
i = np.array([[0, 1],                     # indices for the first dim of a
              [1, 2]])
j = np.array([[2, 1],                     # indices for the second dim
              [3, 3]])
print('a[i, j]是{}\n'.format(a[i, j]))    # i and j must have equal shape
print('a[i, 2]是{}\n'.format(a[i, 2]))
print('a[:, j]是{}'.format(a[:, j]))      # i.e., a[ : , j]
#最后这个应该就是(2×2)矩阵，每个元素位置上放一个a[:,n]的向量。
#为什么是这个方向我有点没看懂，但是我能想象它的立体排布
#arr[i, j] is exactly the same as arr[(i, j)]
#不能这样把i和j叠起来做索引：s=np.array([i, j])
#但是可以用tuple(s)作为索引，效果等如[i,j]

time = np.linspace(20, 145, 5)                 # time scale
data = np.sin(np.arange(20)).reshape(5,4)      # 4 time-dependent series
print(time)
print(data)

# index of the maxima for each series
ind = data.argmax(axis=0)
print(ind)

time_max = time[ind]
print(time_max)

data_max = data[ind, range(data.shape[1])]
# => data[ind[0],0], data[ind[1],1]...
print(data_max)

print(np.all(data_max == data.max(axis=0)))

a = np.arange(5)
print(a)
a[[1,3,4]] = 0
print(a)
#用列表索引赋值时，如果列表索引有重复，只会留下最后的赋值
#因为会运行多次赋值工作
a = np.arange(5)
a[[0,0,2]]=[1,2,3]
print(a)
#但是如果用+=：
a = np.arange(5)
a[[0,0,2]]+=1
print(a)
#对这种现象的解释是：
#Even though 0 occurs twice in the list of indices,
#the 0th element is only incremented once.
#This is because Python requires “a+=1” to be equivalent to “a = a + 1”.
#我没看懂，但是反正是有这种现象

a = np.arange(12).reshape(3,4)
print(a)
b = a > 4
print(b)
print(a[b])
a[b] = 0
print(a)  #可以直接用以赋值

#画曼德布洛特集合
#（函数没看懂，但是反正就是布尔索引和被切片数组shape相同这种情况）
import numpy as np
import matplotlib.pyplot as plt
def mandelbrot( h,w, maxit=20 ):
    """Returns an image of the Mandelbrot fractal of size (h,w)."""
    y,x = np.ogrid[ -1.4:1.4:h*1j, -2:0.8:w*1j ]
    c = x+y*1j
    z = c
    divtime = maxit + np.zeros(z.shape, dtype=int)
    for i in range(maxit):
        z = z**2 + c
        diverge = z*np.conj(z) > 2**2            # who is diverging
        div_now = diverge & (divtime==maxit)  # who is diverging now
        divtime[div_now] = i                  # note when
        z[diverge] = 2                        # avoid diverging too much
    return divtime
plt.imshow(mandelbrot(400,400))

a = np.arange(12).reshape(3,4)
print(a)
print()
b1 = np.array([False,True,True])             # first dim selection
b2 = np.array([True,False,True,False])       # second dim selection
print(a[b1])
print()
print(a[b1,:])
print()
print(a[:,b2])
print()
print(a[b1,b2])  #……？这个结果为什么是这样

#举例来说，可以对abc三个向量每个三元组计算a+b*c
a = np.array([2,3,4,5])
b = np.array([8,5,4])
c = np.array([5,4,6,8,3])
ax,bx,cx = np.ix_(a,b,c)
print(ax)
print()
print(bx)
print()
print(cx)
print()
print(ax.shape)
print()
print(bx.shape)
print()
print(cx.shape)
print()
result = ax+bx*cx
print(result)
print()
print(result[3,2,4])
print(a[3]+b[2]*c[4])
#虽然我还是没看懂具体如何实现的，但是我看懂它在干啥了，我会用了

def ufunc_reduce(ufct, *vectors):
   vs = np.ix_(*vectors)
   r = ufct.identity
   for v in vs:
       r = ufct(r,v)
   return r
ufunc_reduce(np.add,a,b,c)
#这个ufunc.reduce还没有搞懂是什么东西
#用这个版本的reduce相比ufunc.reduce的好处在于：
#利用了广播机制，不用创造尺寸为output * the number of vectors的参数数组
#（什么玩意，没看懂）

#例子也没看懂，我就抄一遍完了
a = np.array([[1.0, 2.0], [3.0, 4.0]])
print(a)
print()
print(a.transpose())
print()
print(np.linalg.inv(a))
print()
u = np.eye(2)  #I
print(u)
print()
j = np.array([[0.0, -1.0], [1.0, 0.0]])
print(j @ j)
print()
print(np.trace(u))
print()
y = np.array([[5.], [7.]])
print(np.linalg.solve(a, y))
print()
print(np.linalg.eig(j))
#返回值第一个元素是特征值，第二个元素是对应的特征向量（normalized）

import numpy as np
rg = np.random.default_rng(1)
import matplotlib.pyplot as plt
# Build a vector of 10000 normal deviates with variance 0.5^2 and mean 2
mu, sigma = 2, 0.5
v = rg.normal(mu,sigma,10000)
# Plot a normalized histogram with 50 bins
plt.hist(v, bins=50, density=1)       # matplotlib version (plot)直方图
# Compute the histogram with numpy and then plot it
(n, bins) = np.histogram(v, bins=50, density=True)  # NumPy version (no plot)
plt.plot(.5*(bins[1:]+bins[:-1]), n)  #折线图（这个计算平均值的方法好绝）
#matplotlib的hist方法直接就画了（蓝框）
#numpy的histogram方法返回两个向量：输入参数的直方图，bin_edges（那个长方形的宽长度）

from numpy import pi
print(pi)

#random
rg = np.random.default_rng(1)