python numpy的基本操作

站长资讯平台：文章目录
0、NumPy 与 ndarry
1、数组属性查看：类型、尺寸、形状、维度
2、numpy元素中数据存储方式，数据类型，类型转换
2.1 查看元素数据存储类型
2.2 元素数据存储类型转换
3、List类型与numpy. ndarray类型的互相转换
4、创建 ndarray 数组
4.1 方法一：列表转换
4.2 zero，ones，empty函数创建特殊数组
4.3 arrange linspace 创建线性数组
5、矩阵的索引与打印
6、矩阵的运算
6.1 基础运算
6.2 点乘
6.3 其他矩阵特征运算
6.3 排序、转置、数值裁剪
7、其他操作
7.1 横纵向的拼接
7.2 矩阵添加或拼接新元素(append或concatenate)
7.3 新增维度
7.4 增减数组维度
7.5 矩阵的切片
7.6 reshape，ravel，flatten，transpose，shape，resize更改数组形状
8、常用操作
8.1 元素平方和
8.2 numpy转换成tensorflow的tensor
LAST、未来得及添加的内容
0、NumPy 与 ndarry
NumPy 是 Python 科学计算的基础包，它专为进行严格的数字处理而产生。

它提供：

快速高效的多维数组对象 ndarray；
直接对数组执行数学运算及对数组执行元素级计算的函数；
线性代数运算、随机数生成;
将 C、C++、Fortran 代码集成到 Python 的工具等。
它专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence Livermore，NASA 用其处理一些本来使用 C++，Fortran 或Matlab 等所做的任务。

ndarray 是一个多维的数组对象，具有矢量算术运算能力和复杂的广播能力，并具有执行速度快和节省空间的特点。

ndarray 的一个特点是同构：即其中所有元素的类型必须相同。

1、数组属性查看：类型、尺寸、形状、维度
import numpy as np
a1 = np.array([1,2,3,4],dtype=np.complex128)
print(a1)
print("数据类型",type(a1)) #打印数组数据类型
print("数组元素数据类型：",a1.dtype) #打印数组元素数据类型
print("数组元素总数：",a1.size) #打印数组尺寸，即数组元素总数
print("数组形状：",a1.shape) #打印数组形状
print("数组的维度数目：",a1.ndim) #打印数组的维度数目
1
2
3
4
5
6
7
8

2、numpy元素中数据存储方式，数据类型，类型转换
2.1 查看元素数据存储类型
dtype=。。。 可作为参数输入到之后的类型转换新array建立函数中，作为array初始化的参数选择。

import numpy as np
#指定数据 dtype
a = np.array([2,23,4],dtype=np.int)
print(a.dtype)
# int 64
a = np.array([2,23,4],dtype=np.int32)
print(a.dtype)
# int32
a = np.array([2,23,4],dtype=np.float)
print(a.dtype)
# float64
a = np.array([2,23,4],dtype=np.float32)
print(a.dtype)
# float32
a = np.array([1,2,3,4],dtype=np.complex128)
print(a.dtype)
# complex128

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

2.2 元素数据存储类型转换
import numpy as np
# 通过 ndarray 的 astype() 方法进行强制类型转换
# astype 会创建一份新的数组，即便是指定为同类型也依然如此
# 浮点数转换为整数时小数部分会被舍弃：
a = np.array([2.5,3.1,4.9],dtype=np.float32)
b = a.astype(np.int64)
print(b.dtype)
print(b)
# 如果某字符串类型的数组里的元素全是数字，也可以通过此方法直接转换成数值类型
a = np.array(["2.5","3.1","4.9"],dtype=np.float32)
b = a.astype(np.float64)
print(b.dtype)
print(b)
1
2
3
4
5
6
7
8
9
10
11
12
13

3、List类型与numpy. ndarray类型的互相转换
array函数接受一切序列类型的对象

import numpy as np
list1 = [1,2,3,4,5]
#List转numpy.array:
temp = np.array(list1)
print(temp)
print("数据类型",type(temp)) #打印数组数据类型
print("数组元素数据类型：",temp.dtype) #打印数组元素数据类型
print("数组元素总数：",temp.size) #打印数组尺寸，即数组元素总数
print("数组形状：",temp.shape) #打印数组形状
#numpy.array转List:
arr = temp.tolist()
print(arr)
print("数据类型",type(arr)) #打印数组数据类型
1
2
3
4
5
6
7
8
9
10
11
12
13

4、创建 ndarray 数组
4.1 方法一：列表转换
import numpy as np
#创建数组
array = np.array([[1,2,3],[2,3,4]]) #列表转化为矩阵
print(array)
print('number of dim:',array.ndim) # 维度
# number of dim: 2
print('shape :',array.shape) # 行数和列数
# shape : (2, 3)
print('size:',array.size) # 元素个数
# size: 6
1
2
3
4
5
6
7
8
9
10

4.2 zero，ones，empty函数创建特殊数组
zeros() 函数和 ones() 函数这两个函数分别可以创建指定长度或形状的全0或全1的 ndarray 数组

empty() 函数这个函数可以创建一个没有任何具体值的 ndarray 数组，需要注意一点的是，这个函数返回的值不一定是 0，可能是其他未初始化的垃圾值。

import numpy as np
#创建全零数组
a = np.zeros((3,4)) # 数据全为0，3行4列
print('a:',a)
b = np.zeros(a.shape) # 数据全为0，3行4列
print('b:',b)
#创建全一数组, 同时也能指定这些特定数据的 dtype:
a = np.ones((3,4),dtype = np.int) # 数据为1，3行4列
print('a:',a)
b = np.ones(a.shape) # 数据全为0，3行4列
print('b:',b)
#创建全空数组, 其实每个值都是接近于零的数:
a = np.empty((3,4)) # 数据为empty，3行4列
print('a:',a)
b = np.empty(a.shape) # 数据全为0，3行4列
print('b:',b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.3 arrange linspace 创建线性数组
import numpy as np
#用 arange 创建连续数组:
a = np.arange(10,20,2) # 10-19 的数据，2步长
print(a)
#使用 reshape 改变数据的形状
a = np.arange(12).reshape((3,4)) # 3行4列，0到11
print(a)
#用 linspace 创建线段型数据:
a = np.linspace(1,10,20) # 开始端1，结束端10，且分割成20个数据，生成线段
print(a)
#同样也能进行 reshape 工作:
a = np.linspace(1,10,20).reshape((5,4)) # 更改shape
print(a)
1
2
3
4
5
6
7
8
9
10
11
12
13

5、矩阵的索引与打印
import numpy as np

#一维索引
A = np.arange(3,15)
print('A = ',A)
print('A[3] = ',A[3]) # 6

#二维
A = np.arange(3,15).reshape((3,4))
print('A = ',A)
print('A[2] = ',A[2])
print('A[2][]2 = ',A[2][2])
print('A[2,2] = ',A[2,2])
print('A[1, 1:3] = ',A[1, 1:3])

print('row = ')
for row in A:
print(row)
print('column = ')
for column in A.T:
print(column)

#flatten是一个展开性质的函数，将多维的矩阵进行展开成1行的数列。而flat是一个迭代器，本身是一个object属性。
print('A.flatten = ',A.flatten())
print('A.flat ===== 所有元素逐个打印')
for item in A.flat:
print(item)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

6、矩阵的运算
6.1 基础运算
import numpy as np
array1 = np.array([[1,2,3],[2,3,4]]) #列表转化为矩阵
array2 = np.array([[2,3,4],[3,4,5]]) #列表转化为矩阵
# 减法
array3 = array2 - array1
print(array3)
# 加法
array3 = array2 + array1
print(array3)
# 对应元素相乘
array3 = array2 * array1
print(array3)
# 对应元素乘系数
array4 = array1 * 2
print(array4)
# 对应元素次方
array4 = array1 ** 2
print(array4)
# 对应元素正弦
array4 = np.sin(array1)
print(array4)
# 比较符号
array5 = array1>2
print(array5)
# 判断矩阵是否全部为正确
print(array5.all())
# 判断矩阵是否存在正确
print(array5.any())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

6.2 点乘
import numpy as np
arr1=np.array([[1,1],[0,1]])
arr2=np.arange(4).reshape((2,2))# 形变
print(arr1)
print(arr2)
# 点乘运算
arr3 = np.dot(arr1,arr2)
print(arr3)
1
2
3
4
5
6
7
8
6.3 其他矩阵特征运算
import numpy as np
A = np.arange(2,14).reshape((3,4))
print("A =",A)
print("sum =",np.sum(A,axis=1))
print("min =",np.min(A,axis=0))
print("max =",np.max(A,axis=1))
print("全矩阵mean =",np.average(A))
print("不同维度mean =",np.average(A,axis=0))
print("全矩阵mean =",np.mean(A))
print("不同维度mean =",np.mean(A,axis=1))
print("中位数 = ",np.median(A)) # 7.5中位数
# argmin() 和 argmax() 两个函数分别对应着求矩阵中最小元素和最大元素的索引。
# 相应的，在矩阵的12个元素中，最小值即2，对应索引0，最大值为13，对应索引为11。
print("最小值索引",np.argmin(A)) # 0
print("最大值索引",np.argmax(A)) # 11
print("累加矩阵 = ",np.cumsum(A)) #累加函数 （返回的是以为数组） 生成的矩阵每一个元素均是从原矩阵首项累加到对应项的元素之和
print("累差矩阵 = ",np.diff(A)) #累差运算函数
x,y = np.nonzero(A) #将所有非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵
print("非零行坐标 = ",x)
print("非零列坐标 = ",y)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

6.3 排序、转置、数值裁剪
import numpy as np
A = np.arange(14,2, -1).reshape((3,4))
print("A = ",A)
print("A默认维度排序 = ",np.sort(A))
print("A其他维度排序 = ",np.sort(A,axis = 0))
print("A转置 = ",np.transpose(A)) #转置
print("A转置 = ",A.T)#转置
print("矩阵数值裁剪 = ",np.clip(A,5,9)) #后面的最小值最大值则用于让函数判断矩阵中元素是否有比最小值小的或者比最大值大的元素，并将这些指定的元素转换为最小值或者最大值。
1
2
3
4
5
6
7
8

7、其他操作
7.1 横纵向的拼接
import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
# vertical stack上下合并
C = np.vstack((A,B))
print(C.shape)
print(C)
# horizontal stack左右合并
D = np.hstack((A,B))
print(D.shape)
print(D)
1
2
3
4
5
6
7
8
9
10
11

A = np.array([[1,1,1],[1,1,1]])
B = np.array([[2,2,2],[2,2,2]])
C = np.concatenate((A,B,B,A),axis=0)
print("(A,B,B,A),axis=0 = ")
print(C)
D = np.concatenate((A,B,B,A),axis=1)
print("(A,B,B,A),axis=1 = ")
print(D)
1
2
3
4
5
6
7
8

7.2 矩阵添加或拼接新元素(append或concatenate)
import numpy as np
A = np.array([1,1,1])
B = np.concatenate((A,[100])) # 先将p_变成list形式进行拼接，注意输入为一个tuple
C = np.append(B,200) #直接向p_arr里添加p_
#注意一定不要忘记用赋值覆盖原p_arr不然不会变
print(B.shape)
print(B)
print(C.shape)
print(C)
1
2
3
4
5
6
7
8
9

7.3 新增维度
import numpy as np

#这样改变维度的作用往往是将一维的数据转变成一个矩阵，与代码后面的权重矩阵进行相乘， 否则单单的数据是不能呢这样相乘的哦。
A = np.array([1,1,1])
print(type(np.newaxis))
print(np.newaxis==None)#np.newaxis 在使用和功能上等价于 None
print("A:",A)
print("A.shape:",A.shape)
print("A[np.newaxis,:]:",A[np.newaxis,:])
print("A[np.newaxis,:].shape:",A[np.newaxis,:].shape)
print("A[:,np.newaxis]:",A[:,np.newaxis])
print("A[:,np.newaxis].shape:",A[:,np.newaxis].shape)
print("A[np.newaxis,:,np.newaxis].shape:",A[np.newaxis,:,np.newaxis].shape)
# (3,1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

7.4 增减数组维度
import numpy as np
# 假设a的shape为[1000,128,128]
a = np.random.rand(1000,128,128)
print(a.shape)
# expand_dims为增加内容为空的维度
b=np.expand_dims(a,axis=0)
print(b.shape)
b=np.expand_dims(a,axis=1)
print(b.shape)
b=np.expand_dims(a,axis=2)
print(b.shape)
b=np.expand_dims(a,axis=3)
print(b.shape)
# squeeze为删除内容为空的维度
c=np.squeeze(b)
print(c.shape)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7.5 矩阵的切片
import numpy as np
A = np.arange(12).reshape((3, 4))
print("A = ")
print(A)
B1,B2 = np.split(A, 2, axis=1)# 返回的是一个列表 里面两个元素分别为切片后的array矩阵
print(np.split(A, 2, axis=1))
print("B1 = ",B1)
print("B2 = ",B2)
C1,C2,C3 = np.split(A, 3, axis=0)
print(np.split(A, 3, axis=0))
print("C1 = ",C1)
print("C2 = ",C2)
print("C3 = ",C3)
1
2
3
4
5
6
7
8
9
10
11
12
13

import numpy as np
A = np.arange(12).reshape((3, 4))
D1,D2,D3 = np.array_split(A, 3, axis=1)
print(np.array_split(A, 3, axis=1))
print(D1)
print(D2)
print(D3)
E1,E2,E3 = np.vsplit(A, 3) # 纵向切割
print(np.vsplit(A, 3))
print(E1)
print(E2)
print(E3)
F1,F2 = np.hsplit(A, 2) # 水平切割
print(np.hsplit(A, 2))
print(F1)
print(F2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7.6 reshape，ravel，flatten，transpose，shape，resize更改数组形状
import numpy as np

a = np.arange(24)
print('a = ',a)
b = a.reshape(2,3,4)
print('reshape = ',b)
# ravel函数 可以将多维数组展平（也就是变回一维）
c = b.ravel()
print('ravel = ',c)
# flatten函数 也是将多维数组展平，与ravel函数的功能相同，不过flatten函数会请求分配内存来保存结果，而ravel函数只是返回数组的一个视图(view)
c = b.flatten()
print('flatten = ',c)
# 这种做法将直接改变所操作的数组
b.shape = (6,4)
print('重新设置形状',b)
# transpose函数 将矩阵进行转置
d = b.transpose()
print("转置 = ",d)
# resize函数 和reshape函数的功能一样，但resize会直接修改所操作的数组
# 并且这一步不可以通过赋值来实现，如下所示
b.resize((2,12))
print('resize重新设置形状',b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8、常用操作
8.1 元素平方和
np.sum(arrayname**2)
1
8.2 numpy转换成tensorflow的tensor
import numpy as np
import tensorflow as tf
numpy_test = np.ones(5)
print(numpy_test)
print(numpy_test.shape)
tensor_test = tf.convert_to_tensor(numpy_test)
print(tensor_test)
print(tensor_test.shape)
1
2
3
4
5
6
7
8

LAST、未来得及添加的内容
numpy random 生成随机矩阵

np.random.choice的用法

numpy：np.random.choice的用法

np.random.choice用法中文和样例详解

numpy.linspace使用详解

Numpy 中clip函数的使用

np.max 与 np.maximum

Numpy中stack()，hstack()，vstack()函数详解

numpy中loadtxt 的用法

【Python数据分析】Numpy的详细教程

numpy&pandas莫烦
————————————————
版权声明：本文为CSDN博主「呆呆象呆呆」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41554005/article/details/103257481