numpy

#形状相同的广播：
np.arange(3)
#array([0, 1, 2])

a = np.ones((3,3))
print(a.ndim)
print(a.shape)
print(a)
# 2
# (3, 3)
# [[1. 1. 1.]
#  [1. 1. 1.]
#  [1. 1. 1.]]

print(a+a)
# [[2. 2. 2.]
#  [2. 2. 2.]
#  [2. 2. 2.]]

#相同维度，但其中某一个或多个维度长度为 1 的广播:
b = np.arange(3).reshape(1,3)
print(b.ndim)
print(b.shape)
print(b)
# 2
# (1, 3)
# [[0 1 2]]

print(a+b)
# [[1. 2. 3.]
#  [1. 2. 3.]
#  [1. 2. 3.]]

c = np.arange(3).reshape(3,1)
print(c.ndim)
print(c.shape)
print(c)
# 2
# (3, 1)
# [[0]
#  [1]
#  [2]]

print(a+c)
# [[1. 1. 1.]
#  [2. 2. 2.]
#  [3. 3. 3.]]

#较少的维度，默认在其前面追加长度为 1 的维度：
d = np.arange(3)
print(d.ndim)
print(d.shape)
print(d)
# 1
# (3,)
# [0 1 2]

print(a + d)
# [[1. 2. 3.]
#  [1. 2. 3.]
#  [1. 2. 3.]]

#如果是标量的话，会广播整个数组上：
 print(a * 3)
# [[3. 3. 3.]
#  [3. 3. 3.]
#  [3. 3. 3.]]

print(c * 3)
# [[0]
#  [3]
#  [6]]

print(d * 3)
#[0 3 6]

a = np.arange(9, dtype = np.float_).reshape(3,3)
b = np.array([10,11,12])
a
b
# array([[0., 1., 2.],
#        [3., 4., 5.],
#        [6., 7., 8.]])
# 
# array([10, 11, 12])

#执行数组的加法
print(np.add(a, b))
print(a+b)
# [[10. 12. 14.]
#  [13. 15. 17.]
#  [16. 18. 20.]]
# [[10. 12. 14.]
#  [13. 15. 17.]
#  [16. 18. 20.]]
#其余运算类似

a = np.arange(0,5,0.3)
a
# array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1, 2.4, 2.7, 3. , 3.3, 3.6,
#        3.9, 4.2, 4.5, 4.8])

print(np.reciprocal(a))
# [       inf 3.33333333 1.66666667 1.11111111 0.83333333 0.66666667
#  0.55555556 0.47619048 0.41666667 0.37037037 0.33333333 0.3030303
#  0.27777778 0.25641026 0.23809524 0.22222222 0.20833333]
# D:anacondalibsite-packagesipykernel_launcher.py:1: RuntimeWarning: 
#divide by zero encountered in reciprocal
#   """Entry point for launching an IPython kernel.

b = np.arange(1,5,1,dtype='int64')
print(b)
#[1 2 3 4]

#执行指数函数
np.exp(b)
np.exp2(b)
np.expm1(b) #返回np.exp(b)-1
# array([ 2.71828183,  7.3890561 , 20.08553692, 54.59815003])
# Out[155]:
# array([ 2.,  4.,  8., 16.])
# Out[155]:
# array([ 1.71828183,  6.3890561 , 19.08553692, 53.59815003])

#执行幂函数
np.power(3,b) #3的b次方
np.power(b,3) #b的3次方
# array([ 3,  9, 27, 81], dtype=int64)
# 
# array([ 1,  8, 27, 64], dtype=int64)

#numpy.mod() 此函数返回输入数组中相应元素的除法余数。函数 numpy.remainder() #也产生相同的结果。

a = np.array([10,20,30])
b = np.array([3,5,7])
print(a)
print(b)
# [10 20 30]
# [3 5 7]

print(np.mod(a,b))
print(np.remainder(a,b))
# [1 0 2]
# [1 0 2]

a = np.array([-5.6j, 0.2j, 11. , 1+1j])
print(a)
#[-0.-5.6j  0.+0.2j 11.+0.j   1.+1.j ]

print(np.real(a)) #实部
print(np.imag(a)) #虚部
# [-0.  0. 11.  1.]
# [-5.6  0.2  0.   1. ]

print(np.conj(a)) #求a的共轭复数
#[-0.+5.6j  0.-0.2j 11.-0.j   1.-1.j ]

print(np.angle(a,deg=True))  #角度
print(np.angle(a,deg=False)) #弧度
# [-90.  90.   0.  45.]
# [-1.57079633  1.57079633  0.          0.78539816]

#执行三角函数
a = np.array([0,30,45,60,90])
print(np.sin(a * np.pi/180))
#[0.         0.5        0.70710678 0.8660254  1.        ]

#numpy.around() 这个函数返回四舍五入到所需精度的值。decimals 表示要舍入的小数位##数。默认值为 0。如果 为负，整数将四舍五入到小数点左侧的位置

a = np.array([1.0,5.55, 123, 0.567, 25.532])
print(a)
print(np.around(a))
print(np.around(a, decimals = 1))
print(np.around(a, decimals = -1))
# [  1.      5.55  123.      0.567  25.532]
# [  1.   6. 123.   1.  26.]
# [  1.    5.6 123.    0.6  25.5]
# [  0.  10. 120.   0.  30.]

#同 Python 内置一样，在进行舍入操作时需要注意二进制小数的精度问题
np.around(2.5)
#2.0      为什么？？？？这个就有点意思了

#numpy.floor() 向下取整
#此函数返回不大于输入参数的最大整数。即标量 x 的下限是最大的整数 i ，使得 i <= x。注#意 在 Python 中，向下取整总是从 0 舍入。

a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print(np.floor(a))

#[-2.  1. -1.  0. 10.]

#numpy.ceil()向上取整
#本函数返回输入值的上限，即，标量 x 的上限是最小的整数 i ，使得 i> = x。
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print(np.ceil(a))
#[-1.  2. -0.  1. 10.]

#函数执行按元素的字符串连接：
a = np.array([["Hello"],["Hi"]])
print(a.dtype)
print(a)
# <U5
# [['Hello']
#  ['Hi']]

b = np.array([["abc"],["xyz"]])
print(b.dtype)
print(b)
# <U3
# [['abc']
#  ['xyz']]

print(np.char.add(a,b))
# [['Helloabc']
#  ['Hixyz']]

c = np.array(["abc", "def", "ghi"])
print(c.dtype)
print(c)
# <U3
# ['abc' 'def' 'ghi']

print(np.char.add(c, "嗯哼 ~?"))
#['abc嗯哼 ~?' 'def嗯哼 ~?' 'ghi嗯哼 ~?']

print(np.char.multiply('Hello ',3))
#Hello Hello Hello

print(np.char.multiply(a, 3))
# [['HelloHelloHello']
#  ['HiHiHi']]

np.char.center('hello', 20,fillchar = '*')
#array('*******hello********', dtype='<U20')

print(np.char.capitalize('hello world'))
#Hello world

e = np.array(['hello world', "how are you?"])
print(np.char.capitalize(e))
#['Hello world' 'How are you?']

print(np.char.title('hello how are you?'))
#Hello How Are You?

print(np.char.title(e))
#['Hello World' 'How Are You?']

#numpy.char.lower()
#函数返回一个数组，其元素转换为小写。它对每个元素调用 str.lower：

f = np.array(['HELLO','WORLD'])
print(np.char.lower(f))
#['hello' 'world']

#numpy.char.upper()
#函数返回一个数组，其元素转换为大写。它对每个元素调用 str.upper：

print(np.char.upper('world'))
#WORLD

print(np.char.upper(e))
#['HELLO WORLD' 'HOW ARE YOU?']

# numpy.char.split()
#此函数返回输入字符串中的单词列表。默认情况下，空格用作分隔符。否则，指定的分隔符字符用于分割字符串：

print(np.char.split(e))
#[list(['hello', 'world']) list(['how', 'are', 'you?'])]

print(np.char.split ('TutorialsPoint,Hyderabad,Telangana', sep = ','))
#['TutorialsPoint', 'Hyderabad', 'Telangana']

# numpy.char.splitlines()
# 函数返回数组中元素的单词列表，以换行符分割：
# '
'，'
'，'
' 都被当做换行符处理。

print(np.char.splitlines('hello
how are you?'))
#['hello', 'how are you?']

a = np.array(['123', '456', 'abc', 'zxc', '789', 'ooo'])
b = a.reshape(3,2)
print(b)
# [['123' '456']
#  ['abc' 'zxc']
#  ['789' 'ooo']]

print(np.char.splitlines(b))
# [[list(['123']) list(['456'])]
#  [list(['abc']) list(['zxc'])]
#  [list(['789']) list(['ooo'])]]

#numpy.char.strip()
#函数返回数组的副本，其中元素移除了开头或结尾处的特定字符：

print(np.char.strip('ashok arora','a'))  #去除首位的a
print(np.char.strip(['arora','admin','java'],'a'))
#shok aror
#['ror' 'dmin' 'jav']

#numpy.char.join()
#这个函数返回一个字符串，其中单个字符由特定的分隔符连接：

print(np.char.join(':','dmy'))
print(np.char.join([':','-'],['dmy','ymd']))
#d:m:y
#['d:m:y' 'y-m-d']

#numpy.char.replace()
#这个函数返回字符串副本，其中所有字符序列的出现位置都被另一个给定的字符序列取代：

print(np.char.replace('she is a bad girl', 'is', 'was'))
#she was a bad girl

a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print(a)
# [[3 7 5]
#  [8 4 3]
#  [2 4 9]]

print(np.amin(a))    #返回数组中的最小值
print(np.amin(a,axis=0)) #返回每一列中的最小值
print(np.amin(a,axis=1)) #返回没一行中的最小值
# 2
# [2 4 3]
# [3 3 2]

a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print(a)
# [[3 7 5]
#  [8 4 3]
#  [2 4 9]]

print(np.amax(a))  #返回数组中的最大值
print(np.amax(a, 0)) #返回每一列当中的最大值
print(np.amax(a, 1)) #返回每一行当中的最大值
# 9
# [8 7 9]
# [7 8 9]

a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print(a)
# [[3 7 5]
#  [8 4 3]
#  [2 4 9]]

print(np.ptp(a))  #返回整个数组中的最大值-最小值
print(np.ptp(a, 0)) #返回每一列中的最大值-最小值
print(np.ptp(a, 1)) #返回每一行中的最大值-最小值
# 7 
# [6 3 6]
# [4 5 7]

a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print(a)
# [[30 40 70]
#  [80 20 10]
#  [50 90 60]]

print(np.percentile(a,50))
print(np.percentile(a,50, axis = 0))
print(np.percentile(a,50, axis = 1))
# 50.0
# [50. 40. 60.]
# [40. 20. 60.]

然后查了下它的实现原理：

  首先将你的输入数组进行从小到大排序，然后计算:

(n−1)∗p=i+j (n-1)*p = i + j(n−1)∗p=i+j

  其中n为数组元素的个数，将计算结果的整数部分用i表示，小数部分用j来表示。则最终的percentile值为：

res=(1−j)∗array[i]+j∗array[i+1] res = (1-j) * array[i] + j * array[i+1]res=(1−j)∗array[i]+j∗array[i+1]

#numpy.median()
#中值定义为将数据样本的上半部分与下半部分分开的值。

a = np.array([[30,65,70],[80,95,10],[50,90,60]])
print(a)
# [[30 65 70]
#  [80 95 10]
#  [50 90 60]]

print(np.median(a))
print(np.median(a, axis = 0))  #返回每一列的中值
print(np.median(a, axis = 1))
# 65.0
# [50. 90. 60.]
# [65. 80. 60.]

#numpy.mean()
#算术平均值是沿轴的元素的总和除以元素的数量。函数返回数组中元素的算术平均值。如果提#供了轴，则沿其计算。

a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# [[1 2 3]
#  [3 4 5]
#  [4 5 6]]

print(np.mean(a))
print(np.mean(a, axis = 0))
print(np.mean(a, axis = 1))
# 3.6666666666666665
# [2.66666667 3.66666667 4.66666667]
# [2. 4. 5.]

# numpy.average()
# 加权平均值是由每个分量乘以反映其重要性的因子得到的平均值。函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。该函数可以接受一个轴参数。如果没有指定轴，则数组会被展开。
# 考虑数组 [1,2,3,4] 和相应的权重 [4,3,2,1] ，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。
# 加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)

a = np.array([1,2,3,4])
print(a)
# [1 2 3 4]

#不指定权重时相当于 mean 函数
print(np.average(a)) #默认权重是[1, 1, 1, 1]
#2.5

wts = np.array([4,3,2,1])
print(np.average(a,weights = wts))
#2.0

#如果 returned 参数设为 true，则会返回权重的和
print(np.average([1,2,3,4],weights=[4,3,2,1], returned=True))  20/10
#(2.0, 10.0)      #以元祖形式返回（加权平均， 权重之和）

#numpy.std()
#标准差是与均值的偏差的平方的平均值的平方根。标准差公式如下： std = sqrt(mean((x - #x.mean())**2))

print(np.std([1,2,3,4]))
#1.118033988749895

print(np.var([1,2,3,4]))
#1.25

#numpy.sort()函数返回输入数组的排序副本。 默认对行进行升序

a = np.array([[3,7],[9,1]])
print(a)
# [[3 7]
#  [9 1]]

print(np.sort(a)) #默认对每行进行升序
# [[3 7]
#  [1 9]]

print(np.sort(a, axis = 0)) #axis = 0表示对列进行排序
# [[3 1]
#  [9 7]]

#numpy.argsort()
#函数对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。这个索引 #数组用于构造排序后的数组。 返回数组升序后的原来数组的索引

x = np.array([3, 1, 2])
print(x)
#[3 1 2]

y = np.argsort(x)
print(y)
#[1 2 0]

print(x[y])
#[1, 2, 3]

#numpy.lexsort()
#函数使用键序列执行间接排序。键可以看作是电子表格中的一列。该函数返回一个索引数组，#使用它可以获得排序数据。注意，最后一个键恰好是 sort 的主键。

a = [1,5,1,4,3,4,4] # First column
b = [9,4,0,4,0,2,1] # Second column
ind = np.lexsort((b,a)) # Sort by a, then by b
print(ind)
#[2 0 4 6 5 3 1]
#关于该函数的实现过程，第一步先对后面的a进行从小到大的排序[1 1 3 4 4 4 5]，得到索引[0 2 4 3 5 6 1]
#但是前面两个[1 1]，是一样的，这这时按照对应的索引[0 2]取出中的[9 0],对此进行排序[0 9]意味着要把
#[0 2]变成[2 0],后面的[4 4 4]一样的




[(a[i],b[i]) for i in ind] #列表推导式
#[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]

a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print(a)
# [[30 40 70]
#  [80 20 10]
#  [50 90 60]]

print(np.argmax(a)) #应该是返回在所有元素的第几个位置
#7

print(a.flatten()) #将数组转化为一行
a.flatten()[7]
#90

np.argmax(a, axis = 0) #按列来求
np.argmax(a, axis = 1) #按行来求

# array([1, 2, 0], dtype=int64)
# 
# array([2, 0, 1], dtype=int64)

a = np.array([[30,40,0],[0,20,10],[50,0,60]])
print(a)
# [[30 40  0]
#  [ 0 20 10]
#  [50  0 60]

print(np.nonzero(a)) #两个是分别按照axis=0,axis=1返回的索引 第一个数组是行，第二
                     #个数组是列！

#(array([0, 0, 1, 1, 2, 2], dtype=int64), array([0, 1, 1, 2, 0, 2], dtype=int64))

a[np.nonzero(a)] # 挑选出非零元素  相当经典
#array([30, 40, 20, 10, 50, 60])

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

print(np.where(x > 3))
#(array([1, 1, 2, 2, 2], dtype=int64), array([1, 2, 0, 1, 2], dtype=int64))

x[np.where(x>3)]
#array([4., 5., 6., 7., 8.])

a = np.array([1,2,3,4,5])
b = np.array([5,4,3,2,1])
print(np.where(a > b, a, b)) #返回a, b中的较大值
#[5 4 3 4 5]

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

condition = np.mod(x,2) == 0
print(condition)
# [[ True False  True]
#  [False  True False]
#  [ True False  True]]

np.extract(condition, x)
#array([0., 2., 4., 6., 8.])

arr = np.arange(15).reshape((3, 5))
print(arr
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]]

arr.T
# array([[ 0,  5, 10],
#        [ 1,  6, 11],
#        [ 2,  7, 12],
#        [ 3,  8, 13],
#        [ 4,  9, 14]])

#需要注意的是，转置只能发生在二维及以上的维度的数组上生效，一维的数组只有一个维度是 #不可以转置的。 一维的怎么办？np.reshape(1,-1)变成二维，再转置

a = np.arange(7)
print(a.shape)
print(a.ndim)
print(a)
# (7,)
# 1
# [0 1 2 3 4 5 6]

a.T
#array([0, 1, 2, 3, 4, 5, 6])

#字符串去重
names = np.array(['Atom', 'Lucy', 'Kid', 'Atom', 'Kid', 'Atom'])
print(names)
print(np.unique(names))
# ['Atom' 'Lucy' 'Kid' 'Atom' 'Kid' 'Atom']
# ['Atom' 'Kid' 'Lucy']

#整数去重
ints = np.array([1,2,3,4,2,4,3,5])
print(ints)
print(np.unique(ints))
# [1 2 3 4 2 4 3 5]
# [1 2 3 4 5]

#布尔值去重
bools = np.array([False, True, True, False])
print(bools)
print(np.unique(bools))
# [False  True  True False]
# [False  True]

#布尔值的any()和all()函数
bools = np.array([False, True, True, False])
bools.any() #有一个True就返回True
bools.all() #所有都为True才返回True
# True
# 
# False

val_1 = np.array([4,5,6,2,5,7,4,0])
val_2 = np.array([1,2,3,4,7,8,4,3])
# 验证 val_1 中的元素是否在给出的序列中
np.in1d(val_1, [0, 5, 7])
#array([False,  True, False, False,  True,  True, False,  True])

val_1 = np.array([4,5,6,2,5,7,4,0])
val_2 = np.array([1,2,3,4,7,8,4,3])
#求交集
np.intersect1d(val_1, val_2)

#array([2, 4, 7])

val_1 = np.array([4,5,6,2,5,7,4,0])
val_2 = np.array([1,2,3,4,7,8,4,3])
#求并集
np.union1d(val_1,val_2)

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

# 求差集 假设有集合A和B，所有属于A且不属于B的元素的集合被称为A与B的差集 =A - AB
np.setdiff1d(val_1, val_2)
np.setdiff1d(val_2, val_1)

# array([0, 5, 6])

# array([1, 3, 8])

import numpy.matlib

# matlib.empty()
# 函数返回一个新的矩阵，且不初始化元素。里面的初始化数据无意义

m = np.matlib.empty((2,2))
type(m)
m
# #numpy.matrixlib.defmatrix.matrix
# Out[42]:
# matrix([[4.24399158e-314, 8.48798317e-314],
#         [1.06099790e-313, 1.48539705e-313]])

np.matlib.zeros((2,2))

# matrix([[0., 0.],
#         [0., 0.]]

np.matlib.ones((5,5))

# # #matrix([[1., 1., 1., 1., 1.],
#            [1., 1., 1., 1., 1.],
#            [1., 1., 1., 1., 1.],
#            [1., 1., 1., 1., 1.],
#            [1., 1., 1., 1., 1.]])

np.matlib.eye(n = 3, M = 3, k = 0, dtype = float)
#n: 返回矩阵的行数
# M: 返回矩阵的列数，默认为 n
# k: 对角线的索引
# dtype: 数据类型

# matrix([[1., 0., 0.],
#         [0., 1., 0.],
#         [0., 0., 1.]])

np.matlib.eye(n = 3, M = 3, k = 1, dtype = float)
# matrix([[0., 1., 0.],
#         [0., 0., 1.],
#         [0., 0., 0.]])

np.matlib.eye(n = 3, M = 4, k = 1, dtype = float)
# matrix([[0., 1., 0., 0.],
#         [0., 0., 1., 0.],
#         [0., 0., 0., 1.]])

np.matlib.identity(5, dtype = float)
# matrix([[1., 0., 0., 0., 0.],
#         [0., 1., 0., 0., 0.],
#         [0., 0., 1., 0., 0.],
#         [0., 0., 0., 1., 0.],
#         [0., 0., 0., 0., 1.]])

np.matlib.rand(3,3)

# matrix([[0.15307052, 0.69552953, 0.31876643],
#         [0.6919703 , 0.55438325, 0.38895057],
#         [0.92513249, 0.84167   , 0.35739757]])

#numpy.dot()
#此函数返回两个数组的点积。对于二维向量，其等效于矩阵乘法。对于一维数组，它是向量的 #内积。对于 N 维数组，它是 a 的最后一个轴上的和与 b 的倒数第二个轴的乘积。

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(a)
print(b)

#  [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.dot(a,b)

# array([[37, 40],
#        [85, 92]])

#在较新版本中支持了以 @ 符号来表示矩阵的乘法
print(a @ b)

# array([[37, 40],
#        [85, 92]])

#numpy.vdot()
#此函数返回两个向量的点积。如果第一个参数是复数，那么它的共轭复数会用于计算。如果参#数是多维数组，它会被展开。相同位置的元素相乘再求和

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(a)
print(b)

# [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.vdot(a,b)  # 点积就是对应位置相乘再求和

#130

a = np.array([1,2,3,4])
b = np.array([11,12,13,14]).reshape(4,1)
print(a)
print(b)

#[1 2 3 4]
# [[11]
#  [12]
#  [13]
#  [14]]

np.vdot(a,b)

#130

print(np.inner(np.array([1,2,3]),
               np.array([0,1,0])) ) #等价于1*0+2*1+3*0

#2

a = np.array([[1,2], [3,4]])
b = np.array([[11, 12], [13, 14]])
print(a)
print(b)

# [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.inner(a, b)
# array([[35, 41],
#        [81, 95]])

#上面的例子中，内积计算如下：
#1∗11+2∗121∗11+2∗12 ,  1∗13+2∗141∗13+2∗14 
#3∗11+4∗123∗11+4∗12 ,  3∗13+4∗143∗13+4∗14 

#numpy.matmul()
#函数返回两个数组的矩阵乘积。虽然它返回二维数组的正常乘积，但如果任一参数的维数大于 #2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。另一方面，如果任一参数#是一 维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。

# 对于二维数组，它就是矩阵乘法
a = [[1,0],[0,1]]
b = [[4,1],[2,2]]
print(a)
print(b)
print(np.matmul(a,b))

# [[1, 0], [0, 1]]
# [[4, 1], [2, 2]]
# [[4 1]
#  [2 2]]

# 二维和一维运算
a = [[1,0],[0,1]]
b = [1,2]
print(np.matmul(a,b))
print(np.matmul(b,a))

# [1 2]
# [1 2]

 # 维度大于二的数组
a = np.arange(8).reshape(2,2,2)
b = np.arange(4).reshape(2,2)
print(np.matmul(a,b))

# [[[ 2  3]
#   [ 6 11]]
# 
#  [[10 19]
#   [14 27]]]

#numpy.linalg.det()
#函数计算输入矩阵的行列式。行列式在线性代数中是非常有用的值。

a = np.array([[1,2], [3,4]])
print(a)
np.linalg.det(a)

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

# -2.0000000000000004

b = np.array([[6,1,1], [4, -2, 5], [2,8,7]])
print(b)
np.linalg.det(b)

# [[ 6  1  1]
#  [ 4 -2  5]
#  [ 2  8  7]]
# 
# -306.0

A = np.array([[1,1,1],[0,2,5],[2,5,-1]])
B = np.array([6,-4,27])
print(A)
print(B)

# [[ 1  1  1]
#  [ 0  2  5]
#  [ 2  5 -1]]
# [ 6 -4 27]

X = np.linalg.solve(A, B)
print(X)

#[ 5.  3. -2.]

np.allclose(np.dot(A,X),B) #判断两者是否相等
#True

x = np.array([[1,2],[3,4]])
y = np.linalg.inv(x)
print(x)
print(y)

# [[1 2]
#  [3 4]]
# [[-2.   1. ]
#  [ 1.5 -0.5]]

print(x.dot(y))   #A*A^{-1}    等于单位阵

# [[1.00000000e+00 1.11022302e-16]
#  [0.00000000e+00 1.00000000e+00]]

a = np.array([1,2,3,4,5])
np.save('outfile222',a)

b = np.load('outfile222.npy')
print(b)

#[1 2 3 4 5]

a = np.array([1,2,3,4,5])
np.savetxt('out.txt',a)
b = np.loadtxt('out.txt')
print(b)

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