❀编码理解❀numpy中那些必须要理解的基本（加代码）

2022 4 18 5:38

忽略的小细节可能会改变对整体的认知。

                                                                 --insanena

Pycharm下

import numpy as np #引入numpy基本库简写为np。

要了解的定义：

标量（scalar）：一般指一个数，-100,0.05，8，等(只有大小，没有方向的量)

序列（sequence）：是python中最基本的数据结构，序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置，并且序列中的数据会按照添加的顺序来分配索引。序列包含可变序列列表（list）和字典(dict),也包括不可变序列字符串（str）和元组（tuple）。

（向量（Vector）与列表（List）是两种典型的序列（Sequence）。）

列表（list）：基于链表实现，是对链表结构的抽象与扩展。列表是用来存储有序的，对象的对象.语法：列表[起始：结束：步长]。eg:x=[1,2,3，4,5,6]print(a[0:5:2])#打印从第一个元素开始，到第五个元素截止，步长为2的列表。结果就是[1,3,5]

向量（vector）：基于数组实现，因此也被称作数组列表（ArrayList）[1,2]    [3,3,3]等

数组（array）：np.array()输出的就是数组。数组是计算机中存储信息的一个概念，数组中的元素可以是数字，也可以是数值。对于乘法、乘方和除法等运算，矩阵运算与数组运算的运算符及含义都不同，数组运算按对应元素运算定义，使用点运算符，对应元素进行运算。

矩阵（matrix）：[[1,2],[3,4]]2*2的矩阵 等（比向量多一个中括号）。矩阵是计算科学当中的一个概念，矩阵中的元素只能是数值。矩阵运算按线性变换定义，使用通常符号。

张量（tensor）：[[[1,2],[3,4]],[[1,2],[3,4]]]（比向量多2个中括号，比矩阵多1个中括号）

torch.tensor()输出的就是张量.其中，0维的张量就是标量，1维的张量就是向量，2维的张量就是矩阵，大于等于3维的张量统一叫做张量。

1.np.array()

语法：arr = np.array(data, dtype=dtype, copy=copy)#在numpy中创建矩阵

#数组的联系及变化

import numpy as np
#1：np.array()与np.asarray()的区别
a=[[1,2,3],[4,5,6],[7,8,9]]#把a赋值给三个向量
b=np.array(a)#b等于数组a
c=np.asarray(a)#c等于
a[2]=1#定义a的第三个元素等于1
print(a)
print(b)
print(c)

'''
输出结果为：
[[1, 2, 3], [4, 5, 6], 1]

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

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

#2输入为数组时
a=np.random.random((3,3))#输入一个3*3的随机数组
print(a.dtype)
b=np.array(a,dtype='float32')
c=np.asarray(a,dtype='float32')
a[2]=2#每个定义的第三个数都为2
print(a)
print(b)
print(c)

'''
输出结果为：
float64
[[0.197422   0.79698091 0.47039659]
 [0.04872883 0.77691557 0.42768748]
 [2.         2.         2.        ]]
[[0.197422   0.79698091 0.47039659]
 [0.04872883 0.77691557 0.42768748]
 [0.4383789  0.25756943 0.21566227]] #np.array输出不是2
[[0.197422   0.79698091 0.47039659]
 [0.04872883 0.77691557 0.42768748]
 [2.         2.         2.        ]] #np.asarray输出是2，当float32时，输出不会改变
'''
#3：输入array类型转为list类型
a=np.random.random((3,3))
print(a.dtype)
b=a.tolist()
a[1]=2
print(a)
print(b)
'''
输出结果为：
float64
[[0.16345856 0.97967348 0.36779687]
 [2.         2.         2.        ]
 [0.79421058 0.53767031 0.16113611]]
[[0.16345855721891467, 0.9796734821736771, 0.36779687339507416], [0.21354288752427475, 0.17388485497498962, 0.45500183183428156], [0.7942105804174061, 0.5376703139612654, 0.16113610637379305]]
当一个3*3的矩阵变为一个列表时，定义的元素会发生改变
而且原本的元素还变长了
'''

2.np.mat()mat与matrix相同

#关于numpy.mat()的代码练习
import numpy as np
from mpmath import matrix
from numpy import mat
#1：理解np.mat（）的语法
m=np.mat([[1,2,3]])#俩个方括号表示只接受矩阵格式
x=np.matrix([[1,2,],[3,4]])
print('m:',m)#m是1*3的矩阵
print('x:',x)#x是2*2的矩阵
print('x的第一行为：',m[0])#取m的第一行
#print('x的第一行为：',m[0][1])#出错，无法读取第一行第2个值
'''
运行结果为：
m: [[1 2 3]]
x: [[1 2]
 [3 4]]
x的第一行为： [[1 2 3]]
'''
#2：将Python的列表转换成NumPy的矩阵
list=[1,2,3]#定义一个序列
print('list转为矩阵：',mat(list))#打印序列转为矩阵的值
'''
运行结果为：
list转为矩阵： [[1 2 3]]
'''
#3：将Numpy dnarray转换成Numpy矩阵
n = np.array([1,2,3])
print('n是：',n)
print('np.mat(n)是:',np.mat(n))#矩阵格式，多了中括号
'''
运行结果为：
n是： [1 2 3]
np.mat(n)是: [[1 2 3]]
'''
#4：排序和索引取值
m=np.mat([[2,5,1],[4,6,2]])  #创建2行3列矩阵
print('m是：',m)
m.sort()          #对每一行进行排序
print('m是：',m)
print('m的size：',m.shape)
print('m的行数为：',m.shape[0])
print('m的列数为：',m.shape[1])
print('第一行的所有元素为：',m[1,:])#取得第一行的所有元素
print(m[1,0:1])#打印第一行第1个元素，注意左闭右开
print(m[1,0:3])#打印第一行前三个元素
print(m[1,0:2])#打印第一行前俩个元素
'''
运行结果为：
m是： [[2 5 1]
 [4 6 2]]
m是： [[1 2 5]
 [2 4 6]]
m的size： (2, 3)
m的行数为： 2
m的列数为： 3
第一行的所有元素为： [[2 4 6]]
[[2]]
[[2 4 6]]
[[2 4]]
'''

3.flatten()展平

import numpy as np

#1用在数组
from numpy import array, mat, shape


a=[[1,3],[2,4],[3,5]]
a=array(a)
print(a.flatten())

'''
输出结果为：
[1 3 2 4 3 5]#把原本的拉平成一个1*n的序列
'''
#2用在列表
#a = [[1, 3], [2, 4], [3, 5]]
#a.flatten()#直接用会出错

a = [[1,3],[2,4],[3,5],["abc","def"]]
a1 = [y for x in a for y in x]
print(a1)
#换种方式
a = [[1,3],[2,4],[3,5],["abc","def"]]
flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]
print(flatten(a))

'''
输出结果为：
[1, 3, 2, 4, 3, 5, 'abc', 'def']
[1, 3, 2, 4, 3, 5, 'abc', 'def']
'''
#3用在矩阵
a = [[1,3],[2,4],[3,5]]#定义a是一个2*3的数组
a = mat(a)#个人理解：在numpy上建立数组而不是平铺的数组
y = a.flatten()#y等于把数组展开的值，俩个中括号（数组）
print('a展平后的y是：',y)

y = a.flatten().A
print(y.dtype)
print(shape(y))#打印y的大小
print(shape(y[0]))
y = a.flatten().A[0]
print('打印y：',y)
'''
输出结果为：
a展平后的y是： [[1 3 2 4 3 5]]
int32
(1, 6)
(6,)
打印y： [1 3 2 4 3 5]
'''