Numpy数组与矩阵运算

目录

前言：

创建数组对象

数组属性：ndarray(数组）是存储单一数据类型的多维数组。

数组创建：

创建数组并查看数组属性：

重新设置数组的shape属性

使用arange函数创建数组

使用linespace函数创建数组

使用logspace函数创建等比数列

使用zeros函数创建数组

使用eye函数创建数组

使用diag函数创建数组

使用ones函数创建数组

数组数据类型

数组数据类型转换

创建数据类型

查看数据类型，可以直接查看或者使用nmpy.dtype函数查看

在使用array函数创建数组时，数组的数据类型默认是浮点型。自定义数组数据，则可以预先指定数据类型

生成随机数

无约束条件下生成随机数

生成服从均匀分布的随机数

生成服从正态分布的随机数

生成给定上下范围的随机数，如创建一个最小值不低于2、最大值不高于10的2行5列数组

random模块常用随机数生成函数

通过索引访问数组

一维数组的索引

多维数组的索引

多维数组的索引（使用整数和布尔值索引访问数据）

变换数组的形态

改变数组形状

使用ravel函数展平数组

使用flatten函数展平数组

组合数组

 切割数组

创建Numpy矩阵

 矩阵的运算

矩阵的属性

ufunc函数

一维数组的广播机制

​编辑

 二维数组的广播机制

 问题：

 代码演示：

---

前言：

扩展库numpy是Python支持科学计算的一个很重要的库，常用语数据分析和科学计算领域，如sklearn、pandas、scipy等，numpy提供了强大的数组运算能力以及复杂的广播机制。本篇内容将介绍数组与矩阵及其相关运算。

基于Numpy的数据分析计算生态系统有：

NumPy  SciPy  Pandas  Matplotlib  Sckit-image  statsmodels  scikit-learn 

Cython  PyTables  Numba  SymPy  NumExpr  OpenCV  astropy  PySAL 

BioPython GDAL......

功能介绍：

• Numpy是Python进行科学计算和数据分析所必需的基本程序库：

1. 创建强大的N维数组对象
2. 进行各种复杂的数值运算
3. 能够集成C/C++和Fortran代码
4. 实现线性代数、傅里叶变换和随机数运算

• Numpy提供两种基本对象：

1. ndarray(N-dimensinal array object)
2. ufunc(Universal function object)

• ndarray:Numpy的心脏

1. 多维数组，具有矢量运算能力，且快速、节省空间
2. 可对整组数据进行快速运算的标准数学函数、线性代数、随机数生成等功能

创建数组对象

• 数组属性：ndarray(数组）是存储单一数据类型的多维数组。

属性	说明
ndim	返回int。表示数组的维数
shape	返回tuple。表示数组的尺寸，对于n行n列的矩阵，形状为（n，m）
size	返回int。表示数组的元素总数，等于数组形状的乘机
dtype	返回data-type。描述数组中元素的类型
itemsize	返回int。表示数组的每个元素的大小（以字节为单位）

• 数组创建：

numpy.array(object, dtype=None, copy=True, order='K',subok=False, ndmin=0）

参数名称	说明
object	接收array。表示想要创建的数组。无默认
dtype	接收data-array。表示数组所需的数据类型。如果未给定，则选择保存对象所需的最小类型。默认为None。
ndmin	接收int。指定生成数组应该具有的最小维数。默认为None。

• 创建数组并查看数组属性：

import numpy as np

#例8.1:创建数组查看属性
import numpy as np  #导入NumPy库

arr1 = np.array([1, 2, 3, 4])  #创建一维数组
print('创建的数组为：', arr1)

arr2 = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])    #创建二维数组
print('创建的数组为：\n', arr2)

#查看数组结构
print('数组维度为：', arr2.shape)

# 查看数组类型
print('数组类型为：', arr2.dtype)

#查看数组元素个数
print('数组元素个数为：', arr2.size)

#查看数组每个元素大小
print('数组每个元素大小为：', arr2.itemsize)

• 重新设置数组的shape属性

arr2.shape = 4,3 #重新设置 shape
print('重新设置 shape 后的 arr2 为：',arr2)

创建的数组为：

[[ 1 2 3 4]

 [ 4 5 6 7]

 [ 7 8 9 10]]

数组维度为：（3,4）

重新设置shape维度后的arr2为：

[[ 1 2 3]

 [ 4 4 5]

 [ 6 7 7]

 [ 8 9 10]]

• 使用arange函数创建数组

print(‘使用arange函数创建的数组为：\n’,np.arange(0,1,0.1))

• 使用linespace函数创建数组

print(‘使用linespace函数创建的数组为：\n’,np.linespace(0,1,12))

• 使用logspace函数创建等比数列

print(‘使用logspace函数创建的数组为：\n’,np.logspace(0,5,40))

• 使用zeros函数创建数组

print(‘使用zeros函数创建的数组为：\n’,np.zeros((2,3)))

• 使用eye函数创建数组

print(‘使用eye函数创建的数组为：\n’，np.eye(5))

• 使用diag函数创建数组

print(‘使用diag函数创建的数组为：\n’,np.diag([1,2,3,4]))

• 使用ones函数创建数组

print(‘使用ones函数创建的数组为：\n’,np.ones((5,3)))

• 数组数据类型

Numpy基本数据类型与其取值范围

类型	描述
bool	用一位存储的布尔类型（值为TRUE或FALSE）
inti	由所在的平台决定其精度的整数（一般为int32或int64）
int8	整数，范围为-128到127
int16	整数，范围为-32768到32767
int32	整数，范围为-2^31到2^32-1
......	......

• 数组数据类型转换

#例8.2:数组数据类型转换
import numpy as np  #导入NumPy库

print('转换结果为：', np.float64(42)) #整型转换为浮点型

print('转换结果为：', np.int8(42.0)) #浮点型转换为整型

print('转换结果为：', np.bool(42)) #整型转换为布尔型

print('转换结果为：', np.bool(0)) #整型转换为布尔型

print('转换结果为：', np.float(True)) #布尔型转换为浮点型

print('转换结果为：', np.float(False)) #布尔型转换为浮点型

• 创建数据类型

do = np.dtype([("name", np.str_, 40), ("numitems", np.int64), ("price",np.float64)]) print('数据类型为：',df)

• 查看数据类型，可以直接查看或者使用nmpy.dtype函数查看

print('数据类型为：', df["name"]) print('数据类型为：', np.dtype(df["name"]))

• 在使用array函数创建数组时，数组的数据类型默认是浮点型。自定义数组数据，则可以预先指定数据类型

itemz = np.array([("tomatoes", 42, 4.14), ("cabbages", 13, 1.72)], dtype=df) print('自定义数据为：',itemz)

• 生成随机数

• 无约束条件下生成随机数

print('生成的随即数组为：',np.random.random(100))

• 生成服从均匀分布的随机数

print('生成的随机数组为：\n',np.random.rand(10,5))

• 生成服从正态分布的随机数

print('生成的随即数组为：\n',np.random.randn(10,5))

• 生成给定上下范围的随机数，如创建一个最小值不低于2、最大值不高于10的2行5列数组

print('生成的随即数组为：',np.random.randint(2,10,size = [2,5]))

• random模块常用随机数生成函数

函数	说明
seed	确定随机数生成器的种子
permutation	返回一个序列的随机排列或返回一个随机排列的范围
shuffle	对一个序列进行随机排序
binomial	产生二项分布的随机数
normal	产生正态（高斯）分布的随机数
beta	产生beta分布的随机数
chisquare	产生卡方分布的随机数
gamma	产生gamma分布的函数
uniform	产生在[0,1]中均匀分布的函数

• 通过索引访问数组

• 一维数组的索引

#例8.4:一维数组索引
import numpy as np  #导入NumPy库

arr = np.arange(10)
print(arr)
print('索引结果为：', arr[5]) #用整数作为下标可以获取数组中的某个元素

print('索引结果为：', arr[3:5]) #用范围作为下标获取数组的一个切片，包括arr[3]不包括arr[5]

print('索引结果为：', arr[:5]) #省略开始下标，表示从arr[0]开始

print('索引结果为：', arr[-1]) #下标可以使用负数，-1表示从数组后往前数的第一个元素

arr[2:4] = 100, 101

print('索引结果为：', arr) #下标还可以用来修改元素的值

#范围中的第三个参数表示步长，2表示隔一个元素取一个元素
print('索引结果为：', arr[1:-1:2])

print('索引结果为：', arr[5:1:-2]) #步长为负数时，开始下标必须大于结束下标

• 多维数组的索引

#例8.5:二维数组索引
import numpy as np  #导入NumPy库

arr = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print('创建的二维数组为：', arr)

print('索引结果为：', arr[0, 3:5]) #索引第0行中第3和4列的元素

#索引第2和3行中第3～5列的元素
print('索引结果为：', arr[1:, 2:])

print('索引结果为：', arr[:, 2]) #索引第2列的元素

• 多维数组的索引（使用整数和布尔值索引访问数据）

#例8.6:二维数组索引2
import numpy as np  #导入NumPy库

arr = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
#从两个序列的对应位置取出两个整数来组成下标：arr[0,1], arr[1,2], arr[2,3]
print('索引结果为：', arr[[(0,1,2), (1,2,3)]])

print('索引结果为：', arr[1:, (0,2,3)]) #索引第2、3行中第0、2、3列的元素

mask = np.array([1,0,1], dtype=np.bool)
print(mask)
#mask是一个布尔数组，它索引第1、3行中第2列的元素
print('索引结果为：', arr[mask, 2])

• 变换数组的形态

• 改变数组形状

#例8.7:变换数组形态
import numpy as np  #导入NumPy库

arr = np.arange(12) #创建一维数组
print('创建的一维数组为：', arr)

print('新的一维数组为：', arr.reshape(3,4)) #设置数组的形状

print('数组维度为：', arr.reshape(3,4).ndim) #查看数组维度
print(arr)

#ravel函数数组展平工作
arr = np.arange(12).reshape(3, 4)
print('创建的二维数组为：\n', arr)

print('数组展平后为：', arr.ravel())

#flatten函数数组展平工作
print('数组展平为：', arr.flatten()) #横向展平

print('数组展平为：', arr.flatten('F')) #纵向展平

• 使用ravel函数展平数组

• 使用flatten函数展平数组

• 组合数组

#例8.8:实现数组组合
import numpy as np
# hstack函数横向组合
arr1 = np.arange(12).reshape(3,4)
print('创建的数组1为：\n',arr1)

arr2 = arr1*3
print('创建的数组2为：\n',arr2)
print('横向组合为：\n',np.hstack((arr1,arr2)))  #hstack函数横向组合

#使用vstack函数实现数组纵向组合
print('纵向组合为：\n',np.vstack((arr1,arr2)))  #vstack函数纵向组合

# 使用concatenate函数实现数组组合
print('横向组合为：\n',np.concatenate((arr1,arr2),axis = 1))  #concatenate函数横向组合
print('纵向组合为：\n',np.concatenate((arr1,arr2),axis = 0))  #concatenate函数纵向组合

# 使用hsplit函数实现数组横向分割
arr = np.arange(16).reshape(4,4)
print('创建的二维数组为：\n',arr)
print('横向分割为：\n',np.hsplit(arr, 2))  #hsplit函数横向分割

# vsplit函数实现数组纵向分割
print('纵向分割为：\n',np.vsplit(arr, 2))  #vsplit函数纵向分割

# split函数分割数组
print('横向分割为：\n',np.split(arr, 2, axis=1))  #split函数横向分割
print('纵向分割为：\n',np.split(arr, 2, axis=0))  #split函数纵向分割

•  切割数组

• 创建Numpy矩阵

#例8.9：创建NumPy矩阵
import numpy as np  #导入NumPy库

matr1 = np.mat("1 2 3;4 5 6;7 8 9") #使用分号隔开数据
print('创建的矩阵为：\n', matr1)

matr2 = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print('创建的矩阵为：', matr2)

arr1 = np.eye(3)
print('创建的数组1为：\n', arr1)

arr2 = 3*arr1
print('创建的数组2为：\n', arr2)

print('创建的矩阵为：\n', np.bmat("arr1 arr2; arr1 arr2"))

print('创建的矩阵为：\n', np.bmat("arr1 arr2"))

print('创建的矩阵为：\n', np.bmat("arr1; arr2"))

•  矩阵的运算

#例8.10：矩阵运算
import numpy as np  #导入NumPy库

matr1 = np.mat("1 2 3;4 5 6;7 8 9")  #创建矩阵
print('创建的矩阵为：', matr1)

matr2 = matr1*3  #矩阵与数相乘
print('创建的矩阵为：', matr2)
print('矩阵相加结果为：', matr1+matr2)  #矩阵相加

print('矩阵相减结果为：', matr1-matr2)  #矩阵相减
print('矩阵相乘结果为：', matr1*matr2)  #矩阵相乘
print('矩阵对应元素相乘结果为：', np.multiply(matr1, matr2))

• 矩阵的属性

属性	说明
T	返回自身的转置
H	返回自身的共轭转置
I	返回自身的逆矩阵
A	返回自身数据的2维数组的一个视图

• ufunc函数

 

#例8.11：ufunc函数运算
import numpy as np  #导入NumPy库

#四则运算
x = np.array([1,2,3])
y = np.array([4,5,6])
print('数组相加结果为：', x + y)  #数组相加
print('数组相减结果为：', x - y)  #数组相减
print('数组相乘结果为：', x * y)  #数组相乘
print('数组相除结果为：', x / y)  #数组相除
print('数组幂运算结果为：', x ** y)  #数组幂运算

#比较运算
x = np.array([1,3,5])
y = np.array([2,3,4])
print('数组比较结果为：', x < y)
print('数组比较结果为：', x > y)
print('数组比较结果为：', x == y)
print('数组比较结果为：', x >= y)
print('数组比较结果为：', x <= y)
print('数组比较结果为：', x != y)

#逻辑运算
print('数组逻辑运算结果为：', np.all(x == y))  #np.all()表示逻辑and
print('数组逻辑运算结果为：', np.any(x == y))  #np.any()表示逻辑or

 

• 一维数组的广播机制

#例8.12：一维数组的广播机制
import numpy as np  #导入NumPy库

arr1 = np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('创建的数组1为：',arr1)
print('数组1的shape为：',arr1.shape)
arr2 = np.array([1,2,3])

print('创建的数组2为：',arr2)
print('数组2的shape为：',arr2.shape)
print('数组相加结果为：',arr1 + arr2)

•  二维数组的广播机制

#例8.13：二维数组的广播机制
import numpy as np  #导入NumPy库

arr1 = np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('创建的数组1为：',arr1)
print('数组1的shape为：',arr1.shape)

arr2 = np.array([1,2,3,4]).reshape((4,1))
print('创建的数组2为：',arr2)
print('数组2的shape为：',arr2.shape)

print('数组相加结果为：',arr1 + arr2)

•  问题：

• 输入：100个点的坐标
• 处理：计算两个点的距离
• 输出：距离矩阵

 代码演示：

import numpy as np #导入NumPy	
n = 100
dist = np.zeros([n, n])
point = np.random.rand(n,2)
for i in range(n):
    for j in range(n):
        dist[i, j] = np.sqrt(sum((point[i, :] - point[j, :])**2))
print(dist)

 以上便是我对numpy数组和矩阵运算的总结，感谢观看，码字不易，如果对你有帮助，点个赞就是给我最大的动力。