熟悉和使用NumPy模块

import numpy as np

一、完成下列数组操作与运算。

（1）创建2行4列的数组arr_a，数组中的元素为0至7，要求用arange()函数创建。

arr_a=np.arange(8)
arr_a.resize(2,4)
print(arr_a)
[[0 1 2 3]
 [4 5 6 7]]

（2）利用生成随机数函数创建有4个元素的一维数组arr_b。

arr_b=np.random.random(size=4)
print(arr_b)
[0.01274435 0.0964726  0.0888712  0.89423512]

（3）将arr_a和arr_b转换成矩阵，计算矩阵的矢量积和数量积。

mat_a=np.mat(arr_a)
mat_b=np.mat(arr_b)

print(mat_a)
print(mat_b)

# 无法计算矢量积，矩阵形状不符合要求
[[0 1 2 3]
 [4 5 6 7]]
[[0.01274435 0.0964726  0.0888712  0.89423512]]

（4）向arr_a数组添加元素[9,10]后，再赋值给arr_a数组。

t=[9,10]
arr_a=np.append(arr_a,t)
print(arr_a)
[ 0  1  2  3  4  5  6  7  9 10]

（5）在arr_a数组第3个元素之前插入[11,12]元素后，再赋值给arr_a数组。

arr_a=np.insert(arr_a,2,[11,12])
print(arr_a)
[ 0  1 11 12  2  3  4  5  6  7  9 10]

（6）从arr_a数组中删除下标为奇数的元素。

n=len(arr_a)
index=[]
for i in range(n):
    if i%2 == 1:
        index.append(i)
arr_a=np.delete(arr_a,index)
print(arr_a)
[0 6]

（7）将arr_a数组转换成列表。

list_a=list(arr_a)
print(list_a)
[0, 6]

（8）请创建下列python数组，并计算：

a.创建一个2*2的数组，计算对角线上元素之和;
a=np.arange(4).reshape(2,2)
n1 = a[0,1]
n2 = a[1,0]
sum = n1 + n2
print(sum)
3
b.创建一个长度为9的一维数组，数组元素为0~8，并将他们重新变成3*3的二维数组；
b=np.arange(9)
b=b.reshape(3,3)
print(b)
[[0 1 2]
 [3 4 5]
 [6 7 8]]
c.创建两个3*3 的数组，分别将它们合并为3 * 6、6 * 3的数组后，拆分为3个数组。
t1=np.arange(9).reshape(3,3)
t2=np.arange(9).reshape(3,3)
print(t1)
print(t2)

s1=np.concatenate((t1,t2),axis=1)
s2=np.concatenate((t1,t2),axis=0)
print(s1)
print(s2)

s3=np.split(s1,3)
s4=np.split(s2,3,axis=1)
print(s3)
print(s4)
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[0 1 2 0 1 2]
 [3 4 5 3 4 5]
 [6 7 8 6 7 8]]
[[0 1 2]
 [3 4 5]
 [6 7 8]
 [0 1 2]
 [3 4 5]
 [6 7 8]]
[array([[0, 1, 2, 0, 1, 2]]), array([[3, 4, 5, 3, 4, 5]]), array([[6, 7, 8, 6, 7, 8]])]
[array([[0],
       [3],
       [6],
       [0],
       [3],
       [6]]), array([[1],
       [4],
       [7],
       [1],
       [4],
       [7]]), array([[2],
       [5],
       [8],
       [2],
       [5],
       [8]])]

二、序列和数组

（1）现有序列a为[6,2,5,0,1,3,4,7,8,9],要求将a序列转换成2行5列数组，然后再分割成两个数组；

a=[6,2,5,0,1,3,4,7,8,9]
a=np.array(a).reshape(2,5)

print(a)

a1,a2=np.split(a,2)
print(a1,a2)
[[6 2 5 0 1]
 [3 4 7 8 9]]
[[6 2 5 0 1]] [[3 4 7 8 9]]

（2）现有序列a为[6,2,5,0,1,3,4,7,8,9]，序列b为[‘2’,’3’,’1’,5,7],将a序列转换成2行5列数组，b序列转换成1行5列数组，并将这两个数组相加。

a=[6,2,5,0,1,3,4,7,8,9]
b=[2,3,1,5,7]

a=np.array(a).reshape(2,5)
b=np.array(b).reshape(1,5)

print(a, b)

c=a+b 
print(c)
[[6 2 5 0 1]
 [3 4 7 8 9]] [[2 3 1 5 7]]
[[ 8  5  6  5  8]
 [ 5  7  8 13 16]]

（3）现有序列a为[6,2,5,0,1,3,4,7,8,9]，序列b为[‘2’,’a’,’3’,’1’,5,7,5.9],请编写程序求出a和b序列中去重元素的数组和去重元素的重复数量。

a=[6,2,5,0,1,3,4,7,8,9]
b=['2','a','3','1',5,7,5.9]

for i in b:
    a.append(i)

a=np.array(a)
u,cnt=np.unique(a,return_counts=True)
print("数组去重：",u)
print("重复数量:",cnt)
数组去重： ['0' '1' '2' '3' '4' '5' '5.9' '6' '7' '8' '9' 'a']
重复数量: [1 2 2 2 1 2 1 1 2 1 1 1]

（4）现有序列a为[1.1,3.3,7.7,9.9],序列b为[0.0,2.2,4.4,6.6,8.8],请编写程序实现输出序列c为[1.1,2.2,4.4,7.7,9.9]。

a=np.array([1.1,3.3,7.7,9.9])
b=np.array([0.0,2.2,4.4,6.6,8.8])

c=np.array([])
c = np.append(c,a[0])
c = np.append(c,b[1])
c = np.append(c,b[2])
c = np.append(c,a[2])
c = np.append(c,a[3])

print(c)
[1.1 2.2 4.4 7.7 9.9]

三、总结以下知识点内容

1、数组广播机制，并举例说明；

1.含义：

numpy两个数组的相加、相减以及相乘都是对应元素之间的操作。
当两个数组的形状并不相同的时候，我们可以通过扩展数组的方法来实现相加、相减、相乘等操作，这种机制叫做广播（broadcasting）。

a2 = np.array([[ 0, 0, 0],
              [10,10,10],
              [20,20,20],
              [30,30,30]])

b2 = np.array([[ 0, 1, 2],
              [ 0, 1, 2],
              [ 0, 1, 2],
              [ 0, 1, 2]])

numpy两个数组的相加、相减以及相乘都是对应元素之间的操作。

a2 + b2
array([[ 0,  1,  2],
       [10, 11, 12],
       [20, 21, 22],
       [30, 31, 32]])
b1 = np.array([0,1,2])
b1
array([0, 1, 2])
a2 + b1
array([[ 0,  1,  2],
       [10, 11, 12],
       [20, 21, 22],
       [30, 31, 32]])

结果一样，虽然两个数组的维数不一样，但是Numpy检测到b的维度与a的维度匹配，随意将b扩展为之前的形式，得到相同的形状。 对于更高的维度，这样的扩展依然有效。

将a变成一个列向量

a1 = np.array([0,10,20,30])
a1.shape = 4,1
a1
array([[ 0],
       [10],
       [20],
       [30]])
b1
array([0, 1, 2])
a1 + b1
array([[ 0,  1,  2],
       [10, 11, 12],
       [20, 21, 22],
       [30, 31, 32]])

2.广播原则与过程

如果两个数组的后缘维度（即从末尾开始算起的维度）的轴长度相符，或其中的一方的长度为1，则认为它们是广播兼容的。
广播会在缺失和(或)长度为1的维度上进行。
    对于Numpy来说，维度匹配当且仅当:
    ·维度相同
    ·后缘维度轴长度相符。
    ·有一个的维度是1
    ·匹配会从最后一维开始进行，直到某一个的维度全部匹配为止

广播的规则:

让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
输出数组的形状是输入数组形状的各个维度上的最大值。
如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
a=np.arange(1,5)
a
array([1, 2, 3, 4])
b= np.arange(4, 7).reshape((3,1))
b
array([[4],
       [5],
       [6]])
a + b
array([[ 5,  6,  7,  8],
       [ 6,  7,  8,  9],
       [ 7,  8,  9, 10]])
数组b变化过程
首先要和a做广播机制兼容判断,a的shape为(4,)b的shape为(3,1)，从最后向前逐一比对

1). b原始(3，1)
    [[4][5][6]]
    
2). b变为(3,4)记作b'
    [[4 4 4 4],
     [5 5 5 5],
     [6 6 6 6]]
a的变化过程
1). a原始的shape(4,)
    [1 2 3 4]

2).前增维扩展变为(1,4)
    [[1 2 3 4]]

3).a倒数第二维轴长度继续变化成(3,4)
    [[1 2 3 4],
    [1 2 3 4],
    [1 2 3 4]]

2、列举numpy中随机数生成函数，添加删除数组元素的方法，数组合并与拆分，并举例说明；

numpy生成随机数

numpy中的random模块有多个函数用于生成不同类型的随机数，常见的有 uniform、rand、random、randint、random_interges

1、np.random.uniform的用法

作用：可以生成[low,high)中的随机数，可以是单个值，也可以是一维数组，也可以是多维数组

参数介绍：
low :float型，或者是数组类型的，默认为0

high:float型，或者是数组类型的，默认为1

size:int型，或元组，默认为空

np.random.uniform(1,5)
1.5067038599512839
np.random.uniform(1,5,4)  #生成一维数组
array([3.26876578, 2.6173546 , 3.38197901, 4.43208722])
np.random.uniform(1,5,(4,3)) #生成4x3的数组
array([[2.14201087, 2.59368517, 2.0196709 ],
       [2.91742343, 1.57022696, 2.63268222],
       [1.3684914 , 1.08793311, 1.48989766],
       [1.15124011, 3.51055034, 3.05698215]])

2、np.random.random_sample的用法和np.random.random作用一样

作用：返回[0,1)之间的浮点型随机数，通过size控制返回的形状
np.random.random_sample()
0.9476326431000757
type(np.random.random_sample())
float
np.random.random_sample((5,))
array([0.71194515, 0.80188765, 0.07996332, 0.6785923 , 0.48852146])

3、np.random.rand的用法

作用：返回[0,1)内的浮点数，输入的d0,d1…dn代表维度信息，没有输入时，则返回[0,1)内的一个随机值
np.random.rand()
0.9034964582775922
np.random.rand(3,3)
array([[0.51852303, 0.46162379, 0.36873982],
       [0.08255352, 0.82471965, 0.33477507],
       [0.32898842, 0.83280394, 0.17472697]])
np.random.rand(3,3,3)
array([[[0.57440555, 0.01045639, 0.578993  ],
        [0.38436008, 0.80956744, 0.42658199],
        [0.68789661, 0.53774762, 0.66243822]],

       [[0.78910076, 0.18440442, 0.57968317],
        [0.6409141 , 0.8462007 , 0.3178247 ],
        [0.33243866, 0.532967  , 0.15395335]],

       [[0.96032267, 0.37530695, 0.36120743],
        [0.80850029, 0.63474429, 0.41648437],
        [0.59607309, 0.77091618, 0.82464103]]])

4、np.random.randint的用法

randint(low, high=None, size=None, dtype=’l’)
作用：生成整型随机数，可以是单个随机数，也可以是多维的随机数构成的数组
参数介绍
low：int 型，随机数的下限
high：int 型，默认为空，随机数的上限，当此值为空时，函数生成[0,low)区间内的随机数
size：int、或ints、或元组，指明生成的随机数的类型
dtype:可选’int’ ,’int32’，默认为’l’
np.random.randint(4,size=4)
array([1, 1, 3, 2])
np.random.randint(4,10,size=6)
array([9, 5, 8, 7, 7, 8])
np.random.randint(4,10,size=(2,2),dtype='int32')
array([[9, 5],
       [7, 4]])

添加元素

一维数组创建：
import numpy as np
x=np.array([0,1,2,3,4,5,6,7,8,9])
x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
添加元素：使用np.append(x,[10,11])，作用为在末尾添加[10,11]
np.append(x,[10,11])
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
插入元素：使用np.insert(x,3,[10,11])，作用为在第3位置添加[10,11]
np.insert(x,3,[10,11])
array([ 0,  1,  2, 10, 11,  3,  4,  5,  6,  7,  8,  9])
删除元素：使用np.delete(x,[1,2,3])，作用为删除第1,2,3位置的元素
np.delete(x,[1,2,3])
array([0, 4, 5, 6, 7, 8, 9])

数组的合并

Python中numpy数组的合并有很多方法

np.append() 内存占用大

np.concatenate() 没有内存问题

np. stack() 沿着新的轴加入一系列数组

np.hstack() 堆栈数组垂直顺序（行）

np.vstack() 堆栈数组垂直顺序（列）

np.dstack() 堆栈数组按顺序深入（沿第3维）

np.vsplit() 将数组分解成垂直的多个子数组的列表

方法一——append

np.append(arr,values,axis=None)

对于参数规定：

要么一个数组和一个数值

要么两个数组

不能三个及以上数组直接append拼接。

示例：

append() 函数可以合并一维数组：

append() 也可以合并多维数组：

import numpy as np
a =np.arange(4).reshape(2, 2)
b = np.arange(4).reshape(2, 2)
# 按行合并
c = np.append(a, b, axis=0)
print('按行合并后的结果')
print(c)
print('合并后数据维度', c.shape)
# 按列合并
d = np.append(a, b, axis=1)
print('按列合并后的结果')
print(d)
print('合并后数据维度', d.shape)
按行合并后的结果
[[0 1]
 [2 3]
 [0 1]
 [2 3]]
合并后数据维度 (4, 2)
按列合并后的结果
[[0 1 0 1]
 [2 3 2 3]]
合并后数据维度 (2, 4)

方法二——concatenate

concatenate连接连接多个数组

concatenate()比append()效率更高，适合大规模的数据拼接，能够一次完成多个数组的拼接。

numpy.concatenate ( (a1,a2,…), axis=O)

注意，这些数组要用(包括到一个元组中去

其中a1,a2,…是数组类型的参数，传入的数组必须具有相同的形状。

axis指定拼接的方向，默认axis =0 (逐行拼接)(纵向的拼接沿着axis= 1方向)。

除了给定的轴外，这些数组其他轴的长度必须是一样的。

示例：

沿指定轴连接数组或矩阵：

import numpy as np
a =np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
c = np.concatenate((a, b), axis=0)
print(c)
d = np.concatenate((a, b.T), axis=1)
print(d)
[[1 2]
 [3 4]
 [5 6]]
[[1 2 5]
 [3 4 6]]

拆分数组

split(ary, indices_or_sections, axis=0)
返回结果：

沿特定的轴将数组分割为子数组

参数：
  • ary：想要拆分的数组
  • indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）。
  • axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。
a = np.arange(9)

print ('第一个数组：')
print (a)
print ('\n')
 
print ('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print (b)
print ('\n')
 
print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print (b)
第一个数组：
[0 1 2 3 4 5 6 7 8]


将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]


将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
a = np.arange(16).reshape(4, 4)
print('第一个数组：')
print(a)
print('\n')
print('默认分割（0轴）：')
b = np.split(a,2)
print(b)
print('\n')

print('沿水平方向分割：')
c = np.split(a,2,1)
print(c)
print('\n')
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]


默认分割（0轴）：
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]


沿水平方向分割：
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]

3、Numpy代数运算，并举例说明；

代数运算(求行列式、逆矩阵、特征值)

3.1、矩阵乘法
a = np.array([[1,2,3,4],[5,6,7,8]]) 
a
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])
a.shape #查看维数
(2, 4)
b = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]]) 
b
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
b.shape #查看维数
(4, 3)
c = np.dot(a, b) #二维数组矩阵之间的dot函数运算得到的乘积是矩阵乘积
c
array([[ 70,  80,  90],
       [158, 184, 210]])
c.shape #查看维数
(2, 3)
3.2、代数运算 numpy.linalg

numpy 中还包含一些代数运算的方法，尤其是涉及到矩阵的计算方法，求解特征值、特征向量、逆矩阵等，非常方便。

m = np.array([[1,2,3], [2,2,3], [2,3,4]]) 
m
array([[1, 2, 3],
       [2, 2, 3],
       [2, 3, 4]])
3.2.1、求行列式
np.linalg.det(m) #线性代数函数库linalg，包含了线性代数所需的所有功能。.det()函数计算输入矩阵的行列式
1.0
a = np.array( [[1,0,1], [2,1,1], [1,3,2]] )
a
array([[1, 0, 1],
       [2, 1, 1],
       [1, 3, 2]])
3.2.2、求逆矩阵

注：
逆矩阵：设A是数域上的一个n nn阶矩阵，若在相同数域上存在另一个n nn阶矩阵B，使得 A B = B A = E AB=BA=EAB=BA=E ，
则我们称B是A的逆矩阵，而A则被称为可逆矩阵。注：E为单位矩阵。

A = np.array([[1,2], [1,4]])
A
array([[1, 2],
       [1, 4]])
B = np.linalg.inv(A) #.inv()函数计算矩阵的乘法逆矩阵
B
array([[ 2. , -1. ],
       [-0.5,  0.5]])

对于两个数组(一维)，计算的是这两个数组对应下标元素的乘积和(内积)
对于二维数组，计算的是两个数组的矩阵乘积
对于多维数组，结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二维上的所有元素的乘积和

参数：
np.dot(a,b,out=None)
a,b：数组
out：可选，用于存储计算结果

np.dot(A, B)
array([[1., 0.],
       [0., 1.]])
np.dot(B, A)
array([[1., 0.],
       [0., 1.]])
3.2.3、特征值与特征向量
(1).linalg.eig()函数

w,v = numpy.linalg.eig(a)

功能：计算方形矩阵a的特征值和右特征向量

参数：
a : 待求特征值和特征向量的方阵。

返回：
w: 多个特征值组成的一个矢量。备注：多个特征值并没有按特定的次序排列。特征值中可能包含复数。
v: 多个特征向量组成的一个矩阵。每一个特征向量都被归一化了。第i列的特征向量v[:,i]对应第i个特征值w[i]。

np.linalg.eig(m)
(array([ 7.66898014+0.j        , -0.33449007+0.13605817j,
        -0.33449007-0.13605817j]),
 array([[-0.47474371+0.j        , -0.35654645+0.23768904j,
         -0.35654645-0.23768904j],
        [-0.53664812+0.j        ,  0.80607696+0.j        ,
          0.80607696-0.j        ],
        [-0.6975867 +0.j        , -0.38956192-0.12190158j,
         -0.38956192+0.12190158j]]))
(2).linalg.eigvals()函数

linalg.eigvals(a)

功能：计算一般矩阵的特征值。

参数：
a： (…, M, M) 数组
将计算其特征值的复数或实值矩阵。

返回：
w： (…, M,) ndarray
特征值，每个都根据其多重性重复。它们不一定是有序的，对于实矩阵也不一定是实数。

np.linalg.eigvals(m)
array([ 7.66898014+0.j        , -0.33449007+0.13605817j,
       -0.33449007-0.13605817j])

4、列举NumPy矩阵创建方法、及操作方法（矩阵常用的操作有矩阵转置、索引取值、求矩阵的行列数、排序和将列表转换成矩阵等），并举例说明；

4.1.矩阵的创建方法

可以使用mat、格式字符串、matrix以及bmat函数来创建矩阵。
4.1.1.使用mat方法讲数组转换成矩阵
使用mat函数创建矩阵时，若输入matrix或ndarray对象，则不会为它们创建副本。因此，调用mat函数和调用matrix(data, copy=False)等价。
import numpy as np
a = np.array([[1,2,3],
              [4,5,6],
              [7,8,9]])
print(type(a))

A = np.mat(a)
print(A)
print(type(A))
<class 'numpy.ndarray'>
[[1 2 3]
 [4 5 6]
 [7 8 9]]
<class 'numpy.matrix'>
4.1.2.使用格式字符串创建矩阵
使用分号隔开数据，规定矩阵结构,空格分隔列，分号分隔行
note:矩阵的换行必须是用分号(;)隔开，内部数据必须为字符串形式(‘ ’)，矩阵的元素之间必须以空格隔开。
B = np.mat('1 2 3; 4 5 6; 7 8 9')
print(B)
print(type(B))
[[1 2 3]
 [4 5 6]
 [7 8 9]]
<class 'numpy.matrix'>
4.1.3.利用分块创造新的矩阵
一般情况下使用bmat函数合成矩阵，逗号或空格分隔列，分号分隔行
a = np.array([[1,2],
              [3,4]])
b = np.array([[10,20],
              [30,40]])
np.bmat('a,b; b,a')
matrix([[ 1,  2, 10, 20],
        [ 3,  4, 30, 40],
        [10, 20,  1,  2],
        [30, 40,  3,  4]])
4.1.4 mat()函数创建常见的矩阵
# 3*3 全0矩阵
print(np.mat(np.zeros((3,3))))
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
# 2*4 全1矩阵
print(np.mat(np.ones((2,4))))
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]]
# 3*3的2-10之间的随机整数矩阵
print(np.mat(np.random.randint(2,10,size = (3,3))))
[[8 4 3]
 [7 2 3]
 [9 6 8]]

4.2矩阵的操作方法

4.2.1 矩阵转置
  1. 使用双重循环
# python 双重循环

arr = [[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]]

arr2 = []
# 数组的第二维维度
for i in range(len(arr[0])):
    temp = []
    # 数组的第一维维度
    for j in range(len(arr)):
        temp.append(arr[j][i])
    arr2.append(temp)
print(arr2)
[[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]
  1. 使用列表表达式
# python 列表表达式
# 使用嵌套的列表表达式
arr = [[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]]
# i 为第二个维度，j 为第一个维度
arr2 = [[arr[j][i] for j in range(len(arr))] for i in range(len(arr[0]))]
print(arr2)
[[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]
  1. 使用zip函数
# python zip函数
arr = [[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]]
# zip(* )在这里是解压的作用
# 将arr 看做是一个打包后的数组
arr2 = zip(* arr)
print(list(arr2))
[(1, 4, 7, 10), (2, 5, 8, 11), (3, 6, 9, 12)]

4. 使用numpy模块

# 使用numpy转置
import numpy as np

arr = [[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]]
arr = np.array(arr)
# 这里可以三种方法达到转置的目的
# 第一种方法
print(arr.T)
# 第二种方法
print(arr.transpose())
# 第三种方法
print(arr.swapaxes(0, 1))
[[ 1  4  7 10]
 [ 2  5  8 11]
 [ 3  6  9 12]]
[[ 1  4  7 10]
 [ 2  5  8 11]
 [ 3  6  9 12]]
[[ 1  4  7 10]
 [ 2  5  8 11]
 [ 3  6  9 12]]
4.2.2索引取值

a.item (* args)

将数组中的元素复制到标准Python标量并返回它。

参数(变量号和类型)

none:在这种情况下，该方法只对数组有效

只有一个元素(’ a。size == 1 ')，是哪个元素

复制到标准Python标量对象并返回。

int_type:这个参数被解释为一个平面索引

数组，指定复制和返回哪个元素。

int_types的元组:与单个int_type参数相同的函数，

参数被解释为一个nd索引数组中。

返回值：

z:标准Python标量对象

数组中指定元素的一个副本

Python标量

当’ a '的数据类型是longdouble或clongdouble时，item()返回一个标量数组对象，因为没有可用的Python标量，不会丢失信息。Void数组为item()返回一个缓冲区对象，除非定义了字段，否则将返回一个tuple。

’ item '与[args]非常相似，不同的是，它不是一个数组标量，返回一个标准的Python标量。这对于加速是很有用的访问数组的元素并对元素执行运算，使用Python的优化数学数组。

np.random.seed(123)
x = np.random.randint(9, size=(3, 3))
print(x)

print(x.item(3))

print(x.item(7))

print(x.item((0,1)))

print(x.item((2, 2)))
[[2 2 6]
 [1 3 6]
 [1 0 1]]
1
0
2
1
4.2.3 求矩阵的行列数

1、利用shape函数输出矩阵的行和列

x.shape函数可以输出一个元组（m,n），其中元组的第一个数m表示矩阵的行数，元组的第二个数n为矩阵的列数

import numpy as np
x = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]])
# 输出数组的行和列数
print(x.shape) 
# 只输出行数
print(x.shape[0])
# 只输出列数
print (x.shape[1])
(4, 3)
4
3

2、对于矩阵的行数，也可以使len(x)函数输出的矩阵长度，也就是所谓的行数。

import numpy as np
x = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]])
# 输出数组的行数
print(len(x))
4

3、使用x.ndim函数可以输出矩阵维数，即列数

import numpy as np
x = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]])
# 输出数组的行数
print(x.ndim)
2
4.2.4 矩阵的排序
使用numpy.sort函数可以对数组进行排序，并返回排序好的数组。
使用方法：
numpy.sort(a, axis=-1, kind=None, order=None)

参数：
a : 要排序的数组；
axis ：按什么轴进行排序，默认按最后一个轴进行排序；
kind ：排序方法，默认是快速排序；
order :  当数组定义了字段属性时，可以按照某个属性进行排序；
import numpy as np

# 创建一个一维数组

x1 = np.array([1,8,2,4])

x1
array([1, 8, 2, 4])

排序

np.sort(x1)
array([1, 2, 4, 8])
import numpy as np

# 创建一个二维数组

x2 = np.array([[1,8,2,4],[4,5,1,3]])

x2
array([[1, 8, 2, 4],
       [4, 5, 1, 3]])

默认按最后一个轴排序

np.sort(x2)
array([[1, 2, 4, 8],
       [1, 3, 4, 5]])

轴设为0，即按列排序

np.sort(x2,axis=0)
array([[1, 5, 1, 3],
       [4, 8, 2, 4]])

按照字段属性进行排序

import numpy as np

# 这是一个名字、身高、年龄的数组

# 先给各字段配置属性类型

dtype = [('Name', 'S10'), ('Height', float), ('Age', int)]

# 各字段值

values = [('Li', 1.8, 41), ('Wang', 1.9, 38),('Duan', 1.7, 38)]

# 创建数组

a = np.array(values, dtype=dtype)
a
array([(b'Li', 1.8, 41), (b'Wang', 1.9, 38), (b'Duan', 1.7, 38)],
      dtype=[('Name', 'S10'), ('Height', '<f8'), ('Age', '<i4')])

按照属性Height进行排序,此时参数为字符串

np.sort(a, order='Height')
array([(b'Duan', 1.7, 38), (b'Li', 1.8, 41), (b'Wang', 1.9, 38)],
      dtype=[('Name', 'S10'), ('Height', '<f8'), ('Age', '<i4')])

先按照属性Age排序,如果Age相等，再按照Height排序

np.sort(a, order=['Age', 'Height'])
array([(b'Duan', 1.7, 38), (b'Wang', 1.9, 38), (b'Li', 1.8, 41)],
      dtype=[('Name', 'S10'), ('Height', '<f8'), ('Age', '<i4')])

numpy.argsort函数

numpy.argsort函数用于将数组排序后，返回数组元素从小到大依次排序的所有元素索引。

使用方法(和sort类似)：

numpy.argsort(a, axis=-1, kind=None, order=None)

参数：

a : 要排序的数组；

axis ：按什么轴进行排序，默认按最后一个轴进行排序；

kind ：排序方法，默认是快速排序；

order : 当数组定义了字段属性时，可以按照某个属性进行排序；

import numpy as np

# 创建一维数组

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

获取排序后的索引

np.argsort(x)
array([1, 2, 0], dtype=int64)
import numpy as np

# 创建二维数组

x2 = np.array([[0, 3], [2, 2]])
x2
array([[0, 3],
       [2, 2]])

默认按照最后一个轴进行排序

np.argsort(x2)
array([[0, 1],
       [0, 1]], dtype=int64)

按字段属性进行排序，并获取索引。

# 先给各字段配置属性类型

dtype = [('name', str), ('age', int)]

# 值

values = [('Anna', 28), ('Bob', 27),('Brown',21)]

# 创建数组

x = np.array(values, dtype=dtype)

x
array([('', 28), ('', 27), ('', 21)],
      dtype=[('name', '<U'), ('age', '<i4')])

先按照属性name排序,如果name相等，再按照age排序

np.argsort(x,order=['name','age'])
array([2, 1, 0], dtype=int64)
4.2.5 将列表转换成矩阵
np.argsort(x,order=['name','age'])

#### 4.2.5 将列表转换成矩阵
import numpy as np
#创建列表
mylist = [[1, 2, 3], [4, 5, 6]] # 列表

print(type(mylist))

print(mylist, end='\n\n')
<class 'list'>
[[1, 2, 3], [4, 5, 6]]

列表转矩阵

mymatrix = np.mat(mylist) 
print(type(mymatrix))

print(mymatrix, end='\n\n')
<class 'numpy.matrix'>
[[1 2 3]
 [4 5 6]]

矩阵转列表

Array = mymatrix.tolist() 

print(type(Array))

print(Array)
<class 'list'>
[[1, 2, 3], [4, 5, 6]]