文章目录
- 1、掌握 NumPy 数组对象 ndarray
- 1.1、 数组属性：ndarray（数组）是存储单一数据类型的多维数组。
- 1.2、数组创建
- 1.2.1、重新设置数组的 shape 属性
- 1.2.2、使用 arange 函数创建数组
- 1.2.3、使用 linspace 函数创建数组——等差
- 1.2.4、使用 logspace 函数创建数列——等比
- 1.2.5、使用zeros函数创建数组——全“0”
- 1.2.6、使用ones函数创建数组——全“1”
- 1.2.7、使用eye函数创建数组——对角线为“1”
- 1.2.8、使用diag函数创建数组——对角线为指定内容
- 1.3、数组数据类型
- 2、生成随机数
- 3、通过索引访问数组
- 4、变换数组的形态
1、掌握 NumPy 数组对象 ndarray
1.1、 数组属性：ndarray（数组）是存储单一数据类型的多维数组。
| 属性 | 说明 |
|---|---|
| ndim | 返回 int。表示数组的维数 |
| shape | 返回 tuple。表示数组的尺寸，对于 n 行 m 列的矩阵，形状为(n,m) |
| size | 返回 int。表示数组的元素总数，等于数组形状的乘积 |
| dtype | 返回 data-type。描述数组中元素的类型 |
| itemsize | 返回 int。表示数组的每个元素的大小（以字节为单位） |
1.2、数组创建
numpy.array(object, dtype=None, copy=True, order=‘K’,subok=False, ndmin=0)
| 参数名称 | 说明 |
|---|---|
| object | 接收array。表示想要创建的数组。无默认。 |
| dtype | 接收data-type。表示数组所需的数据类型。如果未给定，则选择保存对象所需的最小类型。默认为None。 |
| ndmin | 接收int。指定生成数组应该具有的最小维数。默认为None。 |
(1) 创建一个一维数组
import numpy as np
np.array([1,2,3])#这是一个一维数组
结果：
array([1, 2, 3])
import numpy as np
a = np.array([1,2,3])#这是一个一维数组
a.size#结果为3
a.shape#结果为(3,)
(2) 创建一个二维数组
import numpy as np
np.array([[1,2,3],[1,2,4]])#这是一个二维数组
array([[1, 2, 3],
[1, 2, 4]])
- 查看相关信息
import numpy as np
a = np.array([[1,2,3],[1,2,4]])#这是一个二维数组
a.size #结果为6
a.ndim #维度结果为2
a.shape #2行3列(2,3)
a.dtype
dtype('int32')
(3) 强制转化类型
a = np.array([[1,2,3],[1,2,4]],dtype=np.float32)#这是一个二维数组
a.dtype
结果：
dtype('float32')
1.2.1、重新设置数组的 shape 属性
- 把上面2行3列的数据改为3行2列
a.reshape(3,2)
结果：
array([[1., 2.],
[3., 1.],
[2., 4.]], dtype=float32)
1.2.2、使用 arange 函数创建数组
list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
1.2.3、使用 linspace 函数创建数组——等差
np.linspace( start, stop,num=50, endpoint=True, retstep=False, dtype=None, axis=0)
- num默认为50
np.linspace(0,10)#0~1，默认50个
结果：
array([ 0. , 0.20408163, 0.40816327, 0.6122449 , 0.81632653,
1.02040816, 1.2244898 , 1.42857143, 1.63265306, 1.83673469,
2.04081633, 2.24489796, 2.44897959, 2.65306122, 2.85714286,
3.06122449, 3.26530612, 3.46938776, 3.67346939, 3.87755102,
4.08163265, 4.28571429, 4.48979592, 4.69387755, 4.89795918,
5.10204082, 5.30612245, 5.51020408, 5.71428571, 5.91836735,
6.12244898, 6.32653061, 6.53061224, 6.73469388, 6.93877551,
7.14285714, 7.34693878, 7.55102041, 7.75510204, 7.95918367,
8.16326531, 8.36734694, 8.57142857, 8.7755102 , 8.97959184,
9.18367347, 9.3877551 , 9.59183673, 9.79591837, 10. ])
- 限定个数
np.linspace(0,10,10)#限定10个
array([ 0. , 1.11111111, 2.22222222, 3.33333333, 4.44444444,
5.55555556, 6.66666667, 7.77777778, 8.88888889, 10. ])
- 限定结束值：
np.linspace(0,10,10,endpoint=False)#从0到9，不包括10在内
等价于
np.linspace(0,9,10)#限定10个
array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
1.2.4、使用 logspace 函数创建数列——等比
np.logspace( start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0 )
- 默认公比为10
np.logspace(0,10,10,endpoint=False)#base为公比10
array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,
1.e+08, 1.e+09])
- 相当于上一等差数列的10次幂
10**np.linspace(0,10,10,endpoint=False)
array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,
1.e+08, 1.e+09])
- 设置公比为2
np.logspace(0,10,10,endpoint=False,base=2)#公比为2
array([ 1., 2., 4., 8., 16., 32., 64., 128., 256., 512.])
1.2.5、使用zeros函数创建数组——全“0”
- 1行2列
np.zeros((2))
array([0., 0.])
- 2行3列
np.zeros((2,3))#2行3列
array([[0., 0., 0.],
[0., 0., 0.]])
1.2.6、使用ones函数创建数组——全“1”
- 1 行 3 列
np.ones((3))
array([1., 1., 1.])
- 3行5列
np.ones((3,5))
array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
1.2.7、使用eye函数创建数组——对角线为“1”
- 1 行 3列
np.eye((3))
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
1.2.8、使用diag函数创建数组——对角线为指定内容
- 对角线为1，2，3，4
np.diag((1,2,3,4))
array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])
1.3、数组数据类型
- NumPy基本数据类型与其取值范围（只展示一部分）
| 类型 | 描述 |
|---|---|
| bool | 用一位存储的布尔类型（值为TRUE或FALSE） |
| inti | 由所在平台决定其精度的整数（一般为int32或int64） |
| int8 | 整数，范围为−128至127 |
| int16 | 整数，范围为−32768至32767 |
| int32 | 整数，范围为-2^31 至 2^32 -1 |
- 创建数组
np.array([1,2,3])
array([1, 2, 3])
- 查看类型
np.array([1,2,3]).dtype
dtype('int32')
1.3.1、数据类型转换
- 在使用array函数创建数组时，数组的数据类型默认是浮点型。自定义数组数据，则可以预先指定数据类型
(1) 把32位转换为8位
- 指定数据类型
np.array([1,2,3],dtype=np.int8)
array([1, 2, 3], dtype=int8)
- 查看数据类型
a = np.array([1,2,3],dtype=np.int8)
a.dtype
dtype('int8')
(2) 把8位转换为32位
b = np.int32(a)
b.dtype
dtype('int32')
2、生成随机数
2.1、无约束条件下生成随机数
- np.random.random(size=5),size只有一个值，可以忽略不写，范围是0~1之间，不包括1，浮点型数值
np.random.random(5)
array([0.36310196, 0.14207322, 0.0737932 , 0.98477148, 0.80380514])
- 随机生成范围在0~1之间的二维数组
np.random.random(size=(2,3))
array([[0.94727277, 0.65118965, 0.17318994],
[0.06562574, 0.18040911, 0.34669738]])
2.2、生成服从均匀分布的随机数
np.random.rand(2,3)
array([[0.38608332, 0.12179838, 0.18462742],
[0.53765068, 0.12882099, 0.52347163]])
- 2个维度的2行3列数组
np.random.rand(2,2,3)#第一个2表示维度，(2,3)表示2行3列
array([[[0.57951376, 0.31890818, 0.69303659],
[0.59486505, 0.79720304, 0.13110962]],
[[0.33119501, 0.70135721, 0.8722298 ],
[0.71925445, 0.67850433, 0.16578164]]])
2.3、生成服从正态分布的随机数
np.random.randn(2,2,3)#第一个2表示维度，(2,3)表示2行3列正态分布
array([[[-0.88786051, 0.75810713, 0.69680607],
[ 1.07179959, -0.6339035 , 0.43253647]],
[[ 2.25968166, 0.17084194, -0.90667182],
[ 0.99405285, -0.92300171, 0.48305359]]])
2.4、生成给定上下范围的随机数
- 如创建一个最小值不低于2、最大值不高于10的2行5列数组
np.random.randint(0,10,size=(2,3))#0~10,不包括10
array([[4, 6, 9],
[4, 0, 9]])
3、通过索引访问数组
3.1、一维数组的索引
arr = np.arange(10)
arr
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
(1) 用整数作为下标可以获取数组中的某个元素
arr[5]
5
(2) 用范围作为下标获取数组的一个切片，包括arr[3]不包括arr[5]
arr[3:5]
array([3, 4])
(3) 省略开始下标，表示从arr[0]开始
arr[:5]
array([0, 1, 2, 3, 4])
(4) 下标可以使用负数，-1表示从数组后往前数的第一个元素
arr[-1]
9
(5) 下标还可以用来修改元素的值
arr[2:4] = 100,101
arr
array([ 0, 1, 100, 101, 4, 5, 6, 7, 8, 9])
(6) 范围中的第三个参数表示步长，2表示隔一个元素取一个元素
arr[1:-1:2]
array([ 1, 101, 5, 7])
(7) 步长为负数时，开始下标必须大于结束下标,如5>2，往左取值
arr[5:1:-2]
array([ 5, 101])
3.2、二维数组的索引
arr = np.array([[1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11]])
arr
array([[ 1, 2, 3, 4, 5],
[ 4, 5, 6, 7, 8],
[ 7, 8, 9, 10, 11]])
(1) 索引第0行中第3和4列的元素
arr[0,3:5]
array([4, 5])
(2) 索引第2和3行中第3～5列的元素
arr[1:,2:]
array([[ 6, 7, 8],
[ 9, 10, 11]])
(3) 索引第3列的元素
arr[:,2]
array([3, 6, 9])
(4) 从两个序列的对应位置取出两个整数来组成下标：arr[0,1], arr[1,2]
arr[0,1]
2
(5) 索引第2、3行中第0、2、3列的元素
arr[1:,(0,2,3)]
array([[ 4, 6, 7],
[ 7, 9, 10]])
(6) 布尔值索引访问数据
- mask是一个布尔数组，它索引第1、3行中第2列的元素
mask = np.array([1,0,1],dtype = np.bool)
mask
array([ True, False, True])
arr[mask,2]
array([3, 9])
4、变换数组的形态
arr = np.arange(12)
arr
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
4.1、改变数组形状
(1) 设置数组的形状
arr.reshape(3,4)
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
(2) 查看数组维度
arr.reshape(3,4).ndim
2
4.2、使用ravel函数展平数组
(1) 创建一个二维数组
arr = np.arange(12).reshape(3,4)
arr
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
(2) 横向展平
arr.ravel()
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
4.3、使用flatten函数展平数组
(1) 创建一个二维数组
a = np.array([[0,2,9],[7,9,5]])
a
array([[0, 2, 9],
[7, 9, 5]])
(2) 横向展平
a.flatten()
array([0, 2, 9, 7, 9, 5])
(3) array([0, 2, 9, 7, 9, 5])
a.flatten('F')
array([0, 7, 2, 9, 9, 5])
4.4、组合数组
a = np.arange(10).reshape(2,5)
b = np.linspace(0,1,endpoint=False,num=10).reshape(2,5)
(1) 使用vstack函数实现数组纵向组合：np.vstack((arr1,arr2))
np.vstack((a,b))#纵向合并，上下堆叠
array([[0. , 1. , 2. , 3. , 4. ],
[5. , 6. , 7. , 8. , 9. ],
[0. , 0.1, 0.2, 0.3, 0.4],
[0.5, 0.6, 0.7, 0.8, 0.9]])
(2) 使用hstack函数实现数组横向组合：np.hstack((arr1,arr2))
np.hstack((a,b))#横向合并，左右拼接
array([[0. , 1. , 2. , 3. , 4. , 0. , 0.1, 0.2, 0.3, 0.4],
[5. , 6. , 7. , 8. , 9. , 0.5, 0.6, 0.7, 0.8, 0.9]])
(3) 使用concatenate函数实现数组纵向组合
np.concatenate((a,b),axis=0)#相当于vstack(),默认axis=0
array([[0. , 1. , 2. , 3. , 4. ],
[5. , 6. , 7. , 8. , 9. ],
[0. , 0.1, 0.2, 0.3, 0.4],
[0.5, 0.6, 0.7, 0.8, 0.9]])
(4) 使用concatenate函数实现数组横向组合
np.concatenate((a,b),axis=1)#相当于hstack()
array([[0. , 1. , 2. , 3. , 4. , 0. , 0.1, 0.2, 0.3, 0.4],
[5. , 6. , 7. , 8. , 9. , 0.5, 0.6, 0.7, 0.8, 0.9]])
4.5、切割数组
arr = np.arange(12).reshape(3,4)
arr
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
(1) 使用hsplit函数和split函数实现数组横向分割：
np.hsplit(arr, 4)
[array([[0],
[4],
[8]]), array([[1],
[5],
[9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
等价于：
np.split(arr,4,axis=1)
[array([[0],
[4],
[8]]), array([[1],
[5],
[9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
(2) 使用vsplit函数和split函数实现数组纵向分割：
np.vsplit(arr,3)
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
等价于：
np.split(arr,3,axis=0)
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
